or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

code-generation.mdindex.mdminification.mdparsing.mdtransformation.md
tile.json

tessl/npm-swc--wasm

WebAssembly module for SWC compiler providing JavaScript/TypeScript parsing, transformation, and minification in browsers and Node.js

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/@swc/wasm@1.13.x

To install, run

npx @tessl/cli install tessl/npm-swc--wasm@1.13.0

index.mddocs/

SWC WebAssembly

SWC WebAssembly provides a complete JavaScript/TypeScript compilation toolchain in WebAssembly format, enabling fast parsing, transformation, minification, and code generation in both browser and Node.js environments where native bindings are unavailable.

Package Information

  • Package Name: @swc/wasm
  • Package Type: npm
  • Language: TypeScript (compiled from Rust)
  • Installation: npm install @swc/wasm

Core Imports

import * as swc from "@swc/wasm";

For CommonJS:

const swc = require("@swc/wasm");

Basic Usage

import * as swc from "@swc/wasm";

// Transform TypeScript code
const result = await swc.transform(`
  class Example {
    private value: number = 42;
    
    getValue(): number {
      return this.value;
    }
  }
`, {
  jsc: {
    target: "es2015",
    parser: {
      syntax: "typescript"
    }
  }
});

console.log(result.code);
// Output: ES2015 JavaScript code

// Parse code into AST
const ast = await swc.parse(`const x = 1;`, {
  syntax: "ecmascript",
  target: "es2020"
});

// Minify JavaScript
const minified = await swc.minify(`
  function example() {
    const message = "Hello World";
    console.log(message);
  }
`, {
  module: false
});

console.log(minified.code);
// Output: minified code

Architecture

SWC WebAssembly is built around several key components:

  • Parser Engine: Converts JavaScript/TypeScript source code into Abstract Syntax Trees (AST)
  • Transform Pipeline: Applies configurable transformations (TypeScript compilation, module conversion, etc.)
  • Code Generator: Converts AST back to JavaScript with optional source maps
  • Minifier: Optimizes JavaScript code for production deployment
  • WebAssembly Interface: Provides both synchronous and asynchronous APIs via wasm-bindgen

Capabilities

Code Parsing

Parse JavaScript and TypeScript code into Abstract Syntax Trees with comprehensive syntax support and error reporting.

function parse(src: string, options?: ParseOptions): Promise<Module>;
function parse(src: string, options: ParseOptions & { isModule: false | "commonjs" }): Promise<Script>;
function parseSync(src: string, options?: ParseOptions): Module;
function parseSync(src: string, options: ParseOptions & { isModule: false | "commonjs" }): Script;

interface ParseOptions extends ParserConfig {
  comments?: boolean;
  script?: boolean;
  target?: JscTarget;
}

Code Parsing

Code Transformation

Transform JavaScript and TypeScript code with configurable compilation targets, module systems, and optimization settings.

function transform(
  code: string | Program,
  options?: Options,
  experimental_plugin_bytes_resolver?: any
): Promise<Output>;

function transformSync(
  code: string | Program,
  opts?: Options,
  experimental_plugin_bytes_resolver?: any
): Output;

interface Output {
  code: string;
  map?: string;
  diagnostics: string[];
}

Code Transformation

Code Generation

Convert Abstract Syntax Trees back to JavaScript source code with optional source map generation.

function print(m: Program, options?: Options): Promise<Output>;
function printSync(m: Program, options?: Options): Output;

Code Generation

Code Minification

Optimize JavaScript code for production with configurable compression and mangling options.

function minify(src: string, opts?: JsMinifyOptions): Promise<Output>;
function minifySync(code: string, opts?: JsMinifyOptions): Output;

Code Minification

Core Types

type Program = Module | Script;

interface Module extends Node, HasSpan {
  type: "Module";
  body: ModuleItem[];
  interpreter: string;
}

interface Script extends Node, HasSpan {
  type: "Script";
  body: Statement[];
  interpreter: string;
}

interface Options extends Config {
  script?: boolean;
  cwd?: string;
  caller?: CallerOptions;
  filename?: string;
  root?: string;
  rootMode?: "root" | "upward" | "upward-optional";
  envName?: string;
  configFile?: string | boolean;
  swcrc?: boolean;
  swcrcRoots?: boolean | MatchPattern | MatchPattern[];
  inputSourceMap?: boolean | string;
  sourceFileName?: string;
  sourceRoot?: string;
  plugin?: Plugin;
  isModule?: boolean | "unknown" | "commonjs";
  outputPath?: string;
}

interface Config {
  test?: string | string[];
  exclude?: string | string[];
  env?: EnvConfig;
  jsc?: JscConfig;
  module?: ModuleConfig;
  minify?: boolean;
  sourceMaps?: boolean | "inline";
  inlineSourcesContent?: boolean;
}

type JscTarget = "es3" | "es5" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022";

type ParserConfig = TsParserConfig | EsParserConfig;

interface TsParserConfig {
  syntax: "typescript";
  tsx?: boolean;
  decorators?: boolean;
  dynamicImport?: boolean;
}

interface EsParserConfig {
  syntax: "ecmascript";
  jsx?: boolean;
  functionBind?: boolean;
  decorators?: boolean;
  decoratorsBeforeExport?: boolean;
  exportDefaultFrom?: boolean;
  importAssertions?: boolean;
}

interface MatchPattern {
  // Pattern matching interface for file selection
}

interface Span {
  start: number;
  end: number;
  ctxt: number;
}