tessl/npm-swc--wasm

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

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

SWC WebAssembly

Name: tessl/npm-swc--wasm
Author: tessl

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;
}