gofront 0.0.9 → 1.0.0

package/src/minifier.js

@@ -75,6 +75,166 @@ const SPACE_AFTER_KW = new Set([
 // ── Tokenizer ────────────────────────────────────────────────
 // Splits JS source into tokens preserving strings, template literals, and regexes.
 
+const THREE_CHAR_OPS = new Set(["===", "!==", "...", ">>>", "**="]);
+const TWO_CHAR_OPS = new Set([
+	"==",
+	"!=",
+	"<=",
+	">=",
+	"&&",
+	"||",
+	"++",
+	"--",
+	"+=",
+	"-=",
+	"*=",
+	"/=",
+	"=>",
+	"**",
+	"??",
+	"?.",
+	">>",
+	"<<",
+]);
+// Tokens/values after which a `/` starts a regex rather than a division
+const REGEX_CONTEXT_VALUES = new Set([
+	"(",
+	"[",
+	",",
+	";",
+	"!",
+	"=",
+	"==",
+	"===",
+	"!=",
+	"!==",
+	":",
+	"return",
+	"case",
+	"typeof",
+	"{",
+	"&&",
+	"||",
+]);
+
+function _isRegexContext(tokens) {
+	const prev = lastNonWhitespaceToken(tokens);
+	if (!prev) return true;
+	return prev.type === "op" || REGEX_CONTEXT_VALUES.has(prev.value);
+}
+
+function _scanRegexLiteral(code, i, len) {
+	let j = i + 1;
+	let escaped = false;
+	let inCharClass = false;
+	while (j < len) {
+		const rc = code[j];
+		if (escaped) {
+			escaped = false;
+		} else if (rc === "\\") {
+			escaped = true;
+		} else if (rc === "[") {
+			inCharClass = true;
+		} else if (rc === "]") {
+			inCharClass = false;
+		} else if (rc === "/" && !inCharClass) {
+			j++;
+			break;
+		}
+		j++;
+	}
+	// consume flags
+	while (j < len && /[gimsuy]/.test(code[j])) j++;
+	return j;
+}
+
+function _scanStringLiteral(code, i, len, quote) {
+	let j = i + 1;
+	while (j < len) {
+		if (code[j] === "\\" && j + 1 < len) {
+			j += 2;
+		} else if (code[j] === quote) {
+			j++;
+			break;
+		} else {
+			j++;
+		}
+	}
+	return j;
+}
+
+function _scanTemplateLiteral(code, i, len) {
+	let j = i + 1;
+	let depth = 1;
+	let braceDepth = 0;
+	while (j < len && depth > 0) {
+		if (code[j] === "\\" && j + 1 < len) {
+			j += 2;
+			continue;
+		}
+		if (braceDepth === 0 && code[j] === "`") {
+			depth--;
+			j++;
+			continue;
+		}
+		if (code[j] === "$" && code[j + 1] === "{" && braceDepth === 0) {
+			braceDepth = 1;
+			j += 2;
+			continue;
+		}
+		if (braceDepth > 0) {
+			if (code[j] === "{") braceDepth++;
+			else if (code[j] === "}") braceDepth--;
+		}
+		j++;
+	}
+	return j;
+}
+
+function _scanDecimalNumber(code, j, len) {
+	while (j < len && /[0-9]/.test(code[j])) j++;
+	if (j < len && code[j] === ".") {
+		j++;
+		while (j < len && /[0-9]/.test(code[j])) j++;
+	}
+	if (j < len && (code[j] === "e" || code[j] === "E")) {
+		j++;
+		if (j < len && (code[j] === "+" || code[j] === "-")) j++;
+		while (j < len && /[0-9]/.test(code[j])) j++;
+	}
+	return j;
+}
+
+function _scanNumber(code, i, len) {
+	const ch = code[i];
+	let j = i + 1;
+	if (ch === "0" && j < len && (code[j] === "x" || code[j] === "X")) {
+		j++;
+		while (j < len && /[0-9a-fA-F]/.test(code[j])) j++;
+	} else {
+		j = _scanDecimalNumber(code, j, len);
+	}
+	return j;
+}
+
+function _scanWhitespace(code, i, len) {
+	let j = i + 1;
+	while (j < len && /\s/.test(code[j])) j++;
+	return j;
+}
+
+function _scanIdent(code, i, len) {
+	let j = i + 1;
+	while (j < len && /[a-zA-Z0-9_$]/.test(code[j])) j++;
+	return j;
+}
+
+function _isNumberStart(ch, code, i, len) {
+	return (
+		/[0-9]/.test(ch) || (ch === "." && i + 1 < len && /[0-9]/.test(code[i + 1]))
+	);
+}
+
 function tokenize(code) {
 	const tokens = [];
 	let i = 0;
@@ -83,7 +243,6 @@ function tokenize(code) {
 	while (i < len) {
 		const ch = code[i];
 
-		// Line comment
 		if (ch === "/" && code[i + 1] === "/") {
 			let end = code.indexOf("\n", i);
 			if (end === -1) end = len;
@@ -91,8 +250,6 @@ function tokenize(code) {
 			i = end;
 			continue;
 		}
-
-		// Block comment
 		if (ch === "/" && code[i + 1] === "*") {
 			const end = code.indexOf("*/", i + 2);
 			const closeAt = end === -1 ? len : end + 2;
@@ -100,123 +257,32 @@ function tokenize(code) {
 			i = closeAt;
 			continue;
 		}
-
-		// Regex literal — only after certain tokens
-		if (ch === "/") {
-			const prev = lastNonWhitespaceToken(tokens);
-			const prevVal = prev?.value;
-			const isRegexContext =
-				!prev ||
-				prev.type === "op" ||
-				prevVal === "(" ||
-				prevVal === "[" ||
-				prevVal === "," ||
-				prevVal === ";" ||
-				prevVal === "!" ||
-				prevVal === "=" ||
-				prevVal === "==" ||
-				prevVal === "===" ||
-				prevVal === "!=" ||
-				prevVal === "!==" ||
-				prevVal === ":" ||
-				prevVal === "return" ||
-				prevVal === "case" ||
-				prevVal === "typeof" ||
-				prevVal === "{" ||
-				prevVal === "&&" ||
-				prevVal === "||";
-			if (isRegexContext) {
-				let j = i + 1;
-				let escaped = false;
-				let inCharClass = false;
-				while (j < len) {
-					const rc = code[j];
-					if (escaped) {
-						escaped = false;
-					} else if (rc === "\\") {
-						escaped = true;
-					} else if (rc === "[") {
-						inCharClass = true;
-					} else if (rc === "]") {
-						inCharClass = false;
-					} else if (rc === "/" && !inCharClass) {
-						j++;
-						break;
-					}
-					j++;
-				}
-				// consume flags
-				while (j < len && /[gimsuy]/.test(code[j])) j++;
-				tokens.push({ type: "regex", value: code.slice(i, j) });
-				i = j;
-				continue;
-			}
+		if (ch === "/" && _isRegexContext(tokens)) {
+			const j = _scanRegexLiteral(code, i, len);
+			tokens.push({ type: "regex", value: code.slice(i, j) });
+			i = j;
+			continue;
 		}
-
-		// String literals (double or single quote)
 		if (ch === '"' || ch === "'") {
-			let j = i + 1;
-			while (j < len) {
-				if (code[j] === "\\" && j + 1 < len) {
-					j += 2;
-				} else if (code[j] === ch) {
-					j++;
-					break;
-				} else {
-					j++;
-				}
-			}
+			const j = _scanStringLiteral(code, i, len, ch);
 			tokens.push({ type: "string", value: code.slice(i, j) });
 			i = j;
 			continue;
 		}
-
-		// Template literal
 		if (ch === "`") {
-			let j = i + 1;
-			let depth = 1;
-			let braceDepth = 0;
-			while (j < len && depth > 0) {
-				if (code[j] === "\\" && j + 1 < len) {
-					j += 2;
-					continue;
-				}
-				if (braceDepth === 0 && code[j] === "`") {
-					depth--;
-					j++;
-					continue;
-				}
-				if (code[j] === "$" && code[j + 1] === "{" && braceDepth === 0) {
-					braceDepth = 1;
-					j += 2;
-					continue;
-				}
-				if (braceDepth > 0) {
-					if (code[j] === "{") braceDepth++;
-					else if (code[j] === "}") {
-						braceDepth--;
-					}
-				}
-				j++;
-			}
+			const j = _scanTemplateLiteral(code, i, len);
 			tokens.push({ type: "template", value: code.slice(i, j) });
 			i = j;
 			continue;
 		}
-
-		// Whitespace
 		if (/\s/.test(ch)) {
-			let j = i + 1;
-			while (j < len && /\s/.test(code[j])) j++;
+			const j = _scanWhitespace(code, i, len);
 			tokens.push({ type: "ws", value: code.slice(i, j) });
 			i = j;
 			continue;
 		}
-
-		// Identifier or keyword
 		if (/[a-zA-Z_$]/.test(ch)) {
-			let j = i + 1;
-			while (j < len && /[a-zA-Z0-9_$]/.test(code[j])) j++;
+			const j = _scanIdent(code, i, len);
 			const word = code.slice(i, j);
 			tokens.push({
 				type: JS_KEYWORDS.has(word) ? "kw" : "ident",
@@ -225,74 +291,24 @@ function tokenize(code) {
 			i = j;
 			continue;
 		}
-
-		// Number
-		if (
-			/[0-9]/.test(ch) ||
-			(ch === "." && i + 1 < len && /[0-9]/.test(code[i + 1]))
-		) {
-			let j = i + 1;
-			// hex
-			if (ch === "0" && j < len && (code[j] === "x" || code[j] === "X")) {
-				j++;
-				while (j < len && /[0-9a-fA-F]/.test(code[j])) j++;
-			} else {
-				while (j < len && /[0-9]/.test(code[j])) j++;
-				if (j < len && code[j] === ".") {
-					j++;
-					while (j < len && /[0-9]/.test(code[j])) j++;
-				}
-				if (j < len && (code[j] === "e" || code[j] === "E")) {
-					j++;
-					if (j < len && (code[j] === "+" || code[j] === "-")) j++;
-					while (j < len && /[0-9]/.test(code[j])) j++;
-				}
-			}
+		if (_isNumberStart(ch, code, i, len)) {
+			const j = _scanNumber(code, i, len);
 			tokens.push({ type: "num", value: code.slice(i, j) });
 			i = j;
 			continue;
 		}
-
-		// Multi-char operators
-		const two = code.slice(i, i + 2);
 		const three = code.slice(i, i + 3);
-		if (
-			three === "===" ||
-			three === "!==" ||
-			three === "..." ||
-			three === ">>>" ||
-			three === "**="
-		) {
+		if (THREE_CHAR_OPS.has(three)) {
 			tokens.push({ type: "op", value: three });
 			i += 3;
 			continue;
 		}
-		if (
-			two === "==" ||
-			two === "!=" ||
-			two === "<=" ||
-			two === ">=" ||
-			two === "&&" ||
-			two === "||" ||
-			two === "++" ||
-			two === "--" ||
-			two === "+=" ||
-			two === "-=" ||
-			two === "*=" ||
-			two === "/=" ||
-			two === "=>" ||
-			two === "**" ||
-			two === "??" ||
-			two === "?." ||
-			two === ">>" ||
-			two === "<<"
-		) {
+		const two = code.slice(i, i + 2);
+		if (TWO_CHAR_OPS.has(two)) {
 			tokens.push({ type: "op", value: two });
 			i += 2;
 			continue;
 		}
-
-		// Single-char operator/punctuation
 		tokens.push({ type: "op", value: ch });
 		i += 1;
 	}
@@ -314,51 +330,51 @@ function isIdentLike(type) {
 	return type === "ident" || type === "kw" || type === "num";
 }
 
+// Token types that always need a space after a keyword
+const SPACE_AFTER_KW_RIGHT_TYPES = new Set([
+	"ident",
+	"kw",
+	"num",
+	"string",
+	"template",
+	"regex",
+]);
+// Operator values that do NOT need a space after a keyword
+const NO_SPACE_AFTER_KW_OPS = new Set(["(", "[", "!", "-", "+"]);
+// Adjacent op pairs that would accidentally merge into a different operator
+const _INCREMENT_MERGE_PAIRS = new Set([
+	"+|+",
+	"-|-",
+	"+|++",
+	"-|--",
+	"++|+",
+	"--|−-",
+]);
+
+function _wouldMergeUnaryOps(left, right) {
+	return (
+		(left.value === "+" && right.value === "+") ||
+		(left.value === "-" && right.value === "-") ||
+		(left.value === "+" && right.value === "++") ||
+		(left.value === "-" && right.value === "--") ||
+		(left.value === "++" && right.value === "+") ||
+		(left.value === "--" && right.value === "-")
+	);
+}
+
 function needsSpaceBetween(left, right) {
 	// Keywords that need space after when followed by ident/num/string/keyword
 	if (left.type === "kw" && SPACE_AFTER_KW.has(left.value)) {
-		if (
-			right.type === "ident" ||
-			right.type === "kw" ||
-			right.type === "num" ||
-			right.type === "string" ||
-			right.type === "template" ||
-			right.type === "regex"
-		) {
-			return true;
-		}
-		// e.g., `return(` or `return!` — no space needed
-		if (
-			right.type === "op" &&
-			(right.value === "(" ||
-				right.value === "[" ||
-				right.value === "!" ||
-				right.value === "-" ||
-				right.value === "+")
-		) {
-			// "return(" is fine, "delete(" is fine, "new(" is fine
-			// But "function(" needs no space, "class{" needs no space... actually they do need space before name
+		if (SPACE_AFTER_KW_RIGHT_TYPES.has(right.type)) return true;
+		if (right.type === "op" && NO_SPACE_AFTER_KW_OPS.has(right.value))
 			return false;
-		}
 	}
 
 	// Two adjacent ident-like tokens need a space
 	if (isIdentLike(left.type) && isIdentLike(right.type)) return true;
 
-	// ident followed by string/template/regex needs space in some cases
-	// but generally not for GoFront output
-
 	// Prevent ++ or -- from merging with adjacent + or -
-	if (
-		(left.value === "+" && right.value === "+") ||
-		(left.value === "-" && right.value === "-") ||
-		(left.value === "+" && right.value === "++") ||
-		(left.value === "-" && right.value === "--") ||
-		(left.value === "++" && right.value === "+") ||
-		(left.value === "--" && right.value === "-")
-	) {
-		return true;
-	}
+	if (_wouldMergeUnaryOps(left, right)) return true;
 
 	return false;
 }
@@ -424,15 +440,30 @@ function findPrevNonWs(tokens, index) {
 
 // ── Stage 3: Identifier mangling ─────────────────────────────
 
-function mangle(code) {
-	const tokens = tokenize(code);
+function _collectProtectedIdent(tok, tokens, i, protectedNames) {
+	if (tok.value === "class" || tok.value === "extends" || tok.value === ".") {
+		const next = nextNonWs(tokens, i);
+		if (next && next.tok.type === "ident") protectedNames.add(next.tok.value);
+	}
+}
 
-	// Collect local variable declarations and their scopes
-	const nameGen = shortNameGeneratorFn();
-	const renameMap = new Map();
+function _collectVarLocalDecls(tokens, i, declaredLocals) {
+	const next = nextNonWs(tokens, i);
+	if (next && next.tok.type === "ident") declaredLocals.add(next.tok.value);
+	if (next && (next.tok.value === "[" || next.tok.value === "{"))
+		collectDestructured(tokens, next.idx, declaredLocals);
+}
 
-	// Find all identifiers that are local declarations (let, const, var, function params)
-	// and not class/method names or properties
+function _collectParamDecls(tokens, i, declaredLocals) {
+	const prev = findPrevNonWsToken(tokens, i);
+	if (
+		prev &&
+		(prev.value === "function" || prev.type === "ident" || prev.value === ")")
+	)
+		collectParams(tokens, i, declaredLocals);
+}
+
+function _collectLocalDecls(tokens) {
 	const declaredLocals = new Set();
 	const protectedNames = new Set();
 
@@ -440,132 +471,88 @@ function mangle(code) {
 		const tok = tokens[i];
 		if (tok.type !== "kw" && tok.type !== "op") continue;
 
-		// class Name or extends Name — protect
-		if (tok.value === "class" || tok.value === "extends") {
-			const next = nextNonWs(tokens, i);
-			if (next && next.tok.type === "ident") {
-				protectedNames.add(next.tok.value);
-			}
-		}
-
-		// Property access: .name — protect
-		if (tok.value === ".") {
-			const next = nextNonWs(tokens, i);
-			if (next && next.tok.type === "ident") {
-				protectedNames.add(next.tok.value);
-			}
-		}
-
-		// Method definitions: name( in class body — protect
-		// We approximate: ident followed by ( at class level
+		_collectProtectedIdent(tok, tokens, i, protectedNames);
 
-		// let/const/var name — local
-		if (tok.value === "let" || tok.value === "const" || tok.value === "var") {
-			const next = nextNonWs(tokens, i);
-			if (next && next.tok.type === "ident") {
-				declaredLocals.add(next.tok.value);
-			}
-			// Destructuring: let [a, b] or let {a, b}
-			if (next && (next.tok.value === "[" || next.tok.value === "{")) {
-				collectDestructured(tokens, next.idx, declaredLocals);
-			}
-		}
+		if (tok.value === "let" || tok.value === "const" || tok.value === "var")
+			_collectVarLocalDecls(tokens, i, declaredLocals);
 
-		// Function params
-		if (tok.value === "(") {
-			const prev = findPrevNonWsToken(tokens, i);
-			if (
-				prev &&
-				(prev.value === "function" ||
-					prev.type === "ident" ||
-					prev.value === ")")
-			) {
-				collectParams(tokens, i, declaredLocals);
-			}
-		}
-
-		// Arrow function params handled by ( above
+		if (tok.value === "(") _collectParamDecls(tokens, i, declaredLocals);
 	}
 
-	// Remove protected names from locals
-	for (const name of protectedNames) {
-		declaredLocals.delete(name);
-	}
+	for (const name of protectedNames) declaredLocals.delete(name);
+	return { declaredLocals };
+}
 
-	// Also protect known globals and short names
-	const globals = new Set([
-		"console",
-		"document",
-		"window",
-		"Math",
-		"JSON",
-		"String",
-		"Number",
-		"Boolean",
-		"Array",
-		"Object",
-		"Error",
-		"Date",
-		"RegExp",
-		"Map",
-		"Set",
-		"Promise",
-		"Symbol",
-		"parseInt",
-		"parseFloat",
-		"isNaN",
-		"isFinite",
-		"undefined",
-		"null",
-		"NaN",
-		"Infinity",
-		"TextEncoder",
-		"TextDecoder",
-		"setTimeout",
-		"setInterval",
-		"clearTimeout",
-		"clearInterval",
-		"prototype",
-		"constructor",
-		"this",
-		"super",
-		"arguments",
-	]);
-	for (const name of globals) declaredLocals.delete(name);
-
-	// Don't mangle __ prefixed helpers or single-char names
-	for (const name of declaredLocals) {
-		if (name.startsWith("__") || name.length <= 1) {
-			declaredLocals.delete(name);
-		}
-	}
+const MANGLE_GLOBALS = new Set([
+	"console",
+	"document",
+	"window",
+	"Math",
+	"JSON",
+	"String",
+	"Number",
+	"Boolean",
+	"Array",
+	"Object",
+	"Error",
+	"Date",
+	"RegExp",
+	"Map",
+	"Set",
+	"Promise",
+	"Symbol",
+	"parseInt",
+	"parseFloat",
+	"isNaN",
+	"isFinite",
+	"undefined",
+	"null",
+	"NaN",
+	"Infinity",
+	"TextEncoder",
+	"TextDecoder",
+	"setTimeout",
+	"setInterval",
+	"clearTimeout",
+	"clearInterval",
+	"prototype",
+	"constructor",
+	"this",
+	"super",
+	"arguments",
+]);
 
-	// Assign short names
+function _filterRenameCandidates(declaredLocals) {
+	for (const name of MANGLE_GLOBALS) declaredLocals.delete(name);
 	for (const name of declaredLocals) {
-		const short = nameGen();
-		renameMap.set(name, short);
+		if (name.startsWith("__") || name.length <= 1) declaredLocals.delete(name);
 	}
+}
 
-	// Apply renaming
+function _applyRenaming(tokens, renameMap) {
 	let out = "";
 	for (let i = 0; i < tokens.length; i++) {
 		const tok = tokens[i];
 		if (tok.type === "ident" && renameMap.has(tok.value)) {
-			// Don't rename if preceded by dot (property access)
 			const prev = findPrevNonWsToken(tokens, i);
-			if (prev && prev.value === ".") {
-				out += tok.value;
-			} else {
-				out += renameMap.get(tok.value);
-			}
+			out += prev && prev.value === "." ? tok.value : renameMap.get(tok.value);
 		} else {
 			out += tok.value;
 		}
 	}
-
 	return out;
 }
 
+function mangle(code) {
+	const tokens = tokenize(code);
+	const nameGen = shortNameGeneratorFn();
+	const renameMap = new Map();
+	const { declaredLocals } = _collectLocalDecls(tokens);
+	_filterRenameCandidates(declaredLocals);
+	for (const name of declaredLocals) renameMap.set(name, nameGen());
+	return _applyRenaming(tokens, renameMap);
+}
+
 function nextNonWs(tokens, index) {
 	for (let i = index + 1; i < tokens.length; i++) {
 		if (tokens[i].type !== "ws" && tokens[i].type !== "comment") {
@@ -597,25 +584,25 @@ function collectDestructured(tokens, startIdx, locals) {
 	}
 }
 
+function _isParamStart(tokens, i) {
+	const prev = findPrevNonWsToken(tokens, i);
+	return (
+		!prev ||
+		prev.value === "(" ||
+		prev.value === "," ||
+		prev.value === "[" ||
+		prev.value === "{"
+	);
+}
+
 function collectParams(tokens, openIdx, locals) {
 	let depth = 1;
 	for (let i = openIdx + 1; i < tokens.length && depth > 0; i++) {
 		const t = tokens[i];
 		if (t.value === "(") depth++;
 		else if (t.value === ")") depth--;
-		else if (depth === 1 && t.type === "ident") {
-			// Check if not a default value expression
-			const prev = findPrevNonWsToken(tokens, i);
-			if (
-				!prev ||
-				prev.value === "(" ||
-				prev.value === "," ||
-				prev.value === "[" ||
-				prev.value === "{"
-			) {
-				locals.add(t.value);
-			}
-		}
+		else if (depth === 1 && t.type === "ident" && _isParamStart(tokens, i))
+			locals.add(t.value);
 	}
 }