JavaScript Minifier

1. What This Tool Actually Does

This minifier runs six passes over your JavaScript source, in order. It first removes any line that is entirely a // comment, then removes trailing // comments that follow code — but only when the // is directly preceded by a semicolon, brace, comma, parenthesis, or whitespace, which avoids mistaking a :// inside a URL string for a comment. Next it strips every /* block */ comment. It then collapses every newline plus its following indentation into a single space, and collapses any remaining runs of multiple spaces into one. It removes spaces immediately touching operator and punctuation characters (= + - * / % & | ^ ! < > , ; : { } ( ) [ ]) where doing so is always safe. Finally, as a safety net, it scans for reserved keywords like return, typeof, or function that ended up sitting directly against the next character, and re-inserts a single space so a keyword never accidentally fuses with an identifier.

2. How to Use the JS Minifier

1. Paste your JavaScript into the Input JavaScript panel, or click Load Sample JS to see it run on a working performance-tracking snippet.
2. Watch the Minified Output panel update live as you type, entirely in your browser.
3. Check the green stats pill for exact input/output byte counts and the percentage saved for your file.
4. Click Copy and paste the result wherever it's needed — an inline <script> tag, a WordPress wp_add_inline_script() call, or a small standalone utility file.
5. Always spot-check the output against the original, especially for code with unusual comment placement or string content — read the limitations below before shipping to production.

3. Why This Is "Safe" Minification, Not Full Compilation

JavaScript engines tokenize source code into keywords, identifiers, operators, and literals — whitespace between tokens is almost always insignificant to the parser, and comments are discarded before execution ever begins. That's why removing them doesn't change what the code does. But JavaScript has real edge cases where whitespace does matter: inside string and template literals, inside regular expression literals, and around Automatic Semicolon Insertion (ASI), where a line break can silently terminate a statement even without an explicit semicolon.

Because this tool works on raw text with regular expressions rather than parsing a real Abstract Syntax Tree (AST), it takes a conservative approach: it never deletes newlines outright (it replaces them with a single space, preserving ASI-relevant statement breaks), and it never touches whitespace inside quotes since it doesn't track whether it's currently "inside a string" the way a real parser would. Tools like Terser or esbuild build a full AST and can therefore go further — renaming local variables, dropping unreachable branches, and inlining constants — none of which this tool attempts.

4. A Real Example

Take this small function with a full-line comment:

function add(a, b) {
  // sum two numbers
  return a + b;
}

Running it through the minifier produces:

function add(a,b){return a+b;}

The comment line is gone entirely, the space inside (a, b) after the comma is removed, and every space around { } + ; collapses — while the space between return and a is preserved, since it's a plain identifier-to-identifier boundary the tool never touches. Load this exact example with the Load Sample JS button to see a longer version with a full IIFE and JSDoc block.

5. Practical Use Cases

• Inline WordPress scripts: Trimming a small tracking or analytics snippet before pasting it into an inline <script> block or a theme's functions.php via wp_add_inline_script(), where every byte is added to every page load.
• Standalone utility scripts: A small, hand-written helper script that isn't part of a bundler pipeline can still be compacted before deployment.
• Quick weight audits: Paste an existing script to see how much of its footprint is comments and formatting versus actual logic.
• Reducing HTML payload: Inline scripts embedded directly in HTML (rather than external files) count toward the initial document's transfer size — minifying them shrinks that specific payload.

6. Common Mistakes & Limitations

• Not AST-based: This tool never renames variables, removes dead code, or inlines expressions. For production bundle optimization, pair it with a real build step using Terser or esbuild.
• Regex comment detection has edge cases: A standalone line containing only a protocol-relative URL, or a comment-like sequence inside a template literal, could theoretically be mishandled since the tool doesn't track string/template boundaries. Review unusual code manually.
• ASI-dependent code is inherently risky: Code that deliberately omits semicolons and relies on line breaks to separate statements is fragile under any minifier, including this one. Prefer explicit semicolons in source code you plan to minify.
• Not a replacement for tree-shaking: Unused functions, imports, or variables are left in place exactly as written — this tool only removes formatting, not logic.