deno | A modern runtime for JavaScript and TypeScript

In your code, just pushing the promises inside the array won't start a concurrency work, but the way you will resolve them that can be made in a concurrency way. In this for loop, each item of the results array will execute synchronously one after another without any concurrency execution and the performance will be very low.

The javascript provides a way to achieve this "concurrency" execution, using the all static method of the Promise native class:

As far as I know, there is no timeout by default in async-await. There is the await-timeout package, for example, that is adding a timeout behavior. Example:

No, TypeScript is not a "standalone" language in that sense. It is and always will be a superset of JavaScript. This is why the TypeScript Compiler is often referred to as a transpiler: it doesn't compile to a lower-level language. After tsc has run its checks it transforms existing source to JavaScript by simply stripping out all the TypeScript constructs.

From the intro of the official TypeScript Handbook:

The goal of TypeScript is to be a static typechecker for JavaScript programs - in other words, a tool that runs before your code runs (static) and ensures that the types of the program are correct (typechecked).

So in order to execute TypeScript, you will always need a JavaScript engine. You could adapt an existing JavaScript engine (or build your own) to understand TypeScript as well, but still it would always first have to be an engine conforming to the ECMAScript specification.

Deno is no different. It has a built-in TypeScript Compiler, which is a copy of the official one. From the TypeScript chapter of the Deno manual.

At a high level, Deno converts TypeScript (as well as TSX and JSX) into JavaScript. It does this via a combination of the TypeScript compiler, which we build into Deno, and a Rust library called swc. When the code has been type checked and transformed, it is stored in a cache, ready for the next run without the need to convert it from its source to JavaScript again.

After transpilation, Deno runs the output JavaScript on Google's V8 Engine, the same engine used in NodeJS and Chrome.

There is not currently a way to ignore files, but if you'd like to only include certain files, you can organize them separately in a subdirectory of your repository, and use that option when publishing your module:

The subdirectory that you choose in this step will become the root of the module's file hierarchy.

Three different this behaviours for three different JS engines

That's a misleading way of putting it. You have three different JS environments, but they're all using the same engine.

I am befuddled by Node giving me this = {}.

That's not what it's giving you: this = [object global].

What you're not seeing in Node is var count showing up as this.count. One way you'd get that behavior (I don't know whether that's what Node is doing) is by wrapping the entire code in an IIFE. If you do:

You can use https://deno.land/x/std/node. It provide some Node's built-in modules. For external modules, you can take a look at https://esm.sh (The syntax is https://esm.sh/.

And if you want to use it like NodeJS environment, you can do the following:

The problem is not that they are relative specifiers, but that they are not fully qualified. From section 6.6 in the manual:

Can I use TypeScript not written for Deno?

Maybe. That is the best answer, we are afraid. For lots of reasons, Deno has chosen to have fully qualified module specifiers. In part this is because it treats TypeScript as a first class language. Also, Deno uses explicit module resolution, with no magic. This is effectively the same way browsers themselves work, though they don't obviously support TypeScript directly. If the TypeScript modules use imports that don't have these design decisions in mind, they may not work under Deno.

Also, in recent versions of Deno (starting with 1.5), we have started to use a Rust library to do transformations of TypeScript to JavaScript in certain scenarios. Because of this, there are certain situations in TypeScript where type information is required, and therefore those are not supported under Deno. If you are using tsc as stand-alone, the setting to use is "isolatedModules" and setting it to true to help ensure that your code can be properly handled by Deno.

One of the ways to deal with the extension and the lack of Node.js non-standard resolution logic is to use import maps which would allow you to specify "packages" of bare specifiers which then Deno could resolve and load.

Use cwd to specify a different path relative to your working directory (or use an absolute path).

Answer credit to @AlexeyBelkov - Answered here: https://youtrack.jetbrains.com/issue/KTIJ-893

The syntax highlighting feature worked after:

1. Delete ~/.gradle/caches
2. Delete ~/Library/Application\ Support/Library/JetBrains/IntelliJIdea2020.3
3. Delete /.gradle
4. Delete /.idea
5. Start IDEA and reimport the project.