minify-js

Extremely fast JavaScript minifier, written in Rust.

Goals

• Fully written in Rust for maximum compatibility with Rust programs and derivatives (FFI, WASM, embedded, etc.).
• Maximises performance on a single CPU core for simple efficient scaling and easy compatible integration.
• Minification of individual inputs/files only; no bundling or transforming.
• Prefer minimal complexity and faster performance over maximum configurability and minimal extra compression.

Performance

Comparison with esbuild, run on common libraries.

Features

• Fast parsing powered by SIMD instructions and lookup tables.
• Supports JSX.
• Minification of identifiers.
• Omits semicolons, spaces, parentheses, and braces where possible.

Usage

CLI

Precompiled binaries are available for Linux, macOS, and Windows.

Linux x64 | macOS x64 | Windows x64

Use the --help argument for more details.

bash minify-js --output /path/to/output.min.js /path/to/src.js

Rust

Add the dependency:

toml [dependencies] minify-js = "0.2.11"

Call the method:

```rust use minify_js::minify;

let mut code: &[u8] = b"let x = 1;"; let mut out = Vec::new(); minify(code.tovec(), &mut out).unwrap(); asserteq!(out.as_slice(), b"let x=1"); ```

Node.js

Install the dependency:

bash npm i @minify-js/node

Call the method:

```typescript import {minify} from "@minify-js/node";

const src = Buffer.from("let x = 1;", "utf-8"); const min = minify(src); ```

In progress

• Combine and reorder declarations.
• Evaluation and folding of constant expressions.
• Parse and erase TypeScript syntax.
• Removal of unreachable, unused, and redundant code.
• Inlining single-use declarations.
• Replacing if statements with conditional and logical expressions.
• Returning an explicit error on illegal code e.g. multiple declarations/exports with identical names.
• Much more inline, high level, and usage documentation.
• Support import and export string names e.g. import { "a-b" as "c-d" } from "x".
• Simplify pattern parsing and minification.
• Micro-optimisations:
  • Unwrap string literal computed members, then identifier or number string members.
  • Replace x === null || x === undefined with x == null, where x is side-effect free.
  • Replace typeof x === "undefined" with x === undefined.
  • Using shorthand properties.
  • Replace void x with x, undefined.
  • Replace return undefined with return.
  • Replace const with let.
  • Hoist let and const.
  • Unwrapping blocks.
  • Unwrapping paretheses, altering expressions as necessary.
  • if (...) return a; else if (...) return b; else return c => return (...) ? a : (...) ? b : c.

Textual compression

• Aliasing of reused well-knowns.
• Aliasing repeated identical literal values.
• Aliasing frequently accessed properties and called methods.
• Using Object.assign.
• Replace typeof and instanceof with functions.