Using the compiler

Similar to TypeScript's tsc compiling to JavaScript, AssemblyScript's asc compiles to WebAssembly:

Syntax:   asc [entryFile ...] [options]

Examples: asc hello.ts
          asc hello.ts -b hello.wasm -t hello.wat
          asc hello1.ts hello2.ts -b -O > hello.wasm

Options:
 --version, -v          Prints just the compiler's version and exits.
 --help, -h             Prints this message and exits.
 --optimize, -O         Optimizes the module. Also accepts the optimize level:

                         -O     Uses defaults. Equivalent to -O2s
                         -O0    Equivalent to --optimizeLevel 0
                         -O1    Equivalent to --optimizeLevel 1
                         -O2    Equivalent to --optimizeLevel 2
                         -O3    Equivalent to --optimizeLevel 3
                         -Oz    Equivalent to -O but with --shrinkLevel 2
                         -O3s   Equivalent to -O3 with --shrinkLevel 1 etc.

 --optimizeLevel        How much to focus on optimizing code. [0-3]
 --shrinkLevel          How much to focus on shrinking code size. [0-2, s=1, z=2]
 --validate, -c         Validates the module using Binaryen. Exits if invalid.
 --baseDir              Specifies the base directory of input and output files.
 --outFile, -o          Specifies the output file. File extension indicates format.
 --binaryFile, -b       Specifies the binary output file (.wasm).
 --textFile, -t         Specifies the text output file (.wat).
 --asmjsFile, -a        Specifies the asm.js output file (.js).
 --idlFile, -i          Specifies the WebIDL output file (.webidl).
 --tsdFile, -d          Specifies the TypeScript definition output file (.d.ts).
 --sourceMap            Enables source map generation. Optionally takes the URL
                        used to reference the source map from the binary file.
 --noTreeShaking        Disables compiler-level tree-shaking, compiling everything.
 --noDebug              Disables maintaining of debug information in binaries.
 --noAssert             Replaces assertions with just their value without trapping.
 --noEmit               Performs compilation as usual but does not emit code.
 --noMemory             Does not set up a memory. Useful for low-level WebAssembly.
 --importMemory         Imports the memory instance provided by the embedder.
 --memoryBase           Sets the start offset of compiler-generated static memory.
 --importTable          Imports the function table instance provided by the embedder.
 --noLib                Does not include the shipped standard library.
 --lib                  Adds one or multiple paths to custom library components and
                        uses exports of all top-level files at this path as globals.
 --use, -u              Aliases a global object under another name, e.g., to switch
                        the default 'Math' implementation used: --use Math=JSMath
 --trapMode             Sets the trap mode to use.

                         allow  Allow trapping operations. This is the default.
                         clamp  Replace trapping operations with clamping semantics.
                         js     Replace trapping operations with JS semantics.

 --runPasses            Specifies additional Binaryen passes to run after other
                        optimizations, if any. See: Binaryen/src/passes/pass.cpp
 --feature              Enables additional (experimental) WebAssembly features.

                         sign-extension  Enables sign-extension operations
                         mutable-global  Enables mutable global imports and exports

 --transform           Specifies the path to a custom transform to 'require'.

 --measure              Prints measuring information on I/O and compile times.

The compiler API can also be used programmatically. It accepts the same options as the CLI but also lets you override stdout and stderr and/or provide a callback:

const asc = require("assemblyscript/cli/asc");
asc.main([
  "myModule.ts",
  "--binaryFile", "myModule.wasm",
  "--optimize",
  "--sourceMap",
  "--measure"
], {
  stdout: process.stdout,
  stderr: process.stderr
}, function(err) {
  if (err)
    throw err;
  ...
});

Available command line options can also be obtained programmatically:

const options = require("assemblyscript/cli/asc.json");
...

You can also compile a source string directly, for example in a browser environment:

const { binary, text, stdout, stderr } = asc.compileString(`...`, { optimize: 2 });
...