@vxrn/compiler 2.0.0-beta.33.1 → 2.0.0-beta.45.1

package/dist/cjs/transformHermesLoops.cjs

@@ -5,315 +5,313 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
-  for (var name in all) __defProp(target, name, {
-    get: all[name],
-    enumerable: true
-  });
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
 };
 var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    });
-  }
-  return to;
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: () => from[key],
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-// If the importer is in node compatibility mode or this is not an ESM
-// file that has been converted to a CommonJS file using a Babel-
-// compatible transform (i.e. "__esModule" has not been set), then set
-// "default" to the CommonJS "module.exports" for node compatibility.
-isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-  value: mod,
-  enumerable: true
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
 }) : target, mod));
-var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
-  value: true
-}), mod);
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var transformHermesLoops_exports = {};
-__export(transformHermesLoops_exports, {
-  transformHermesLoops: () => transformHermesLoops
-});
+__export(transformHermesLoops_exports, { transformHermesLoops: () => transformHermesLoops });
 module.exports = __toCommonJS(transformHermesLoops_exports);
 var import_magic_string = __toESM(require("magic-string"), 1);
 var import_oxc_parser = require("oxc-parser");
 const LOOP_RE = /\b(?:for|while)\s*(?:await\s+)?\(/;
 const LEXICAL_RE = /\b(?:let|const|class)\b/;
 function langFor(filename) {
-  const ext = filename.split("?")[0].split(".").pop() || "js";
-  if (ext === "ts" || ext === "cts" || ext === "mts") return "ts";
-  if (ext === "tsx") return "tsx";
-  return "jsx";
+	const ext = filename.split("?")[0].split(".").pop() || "js";
+	if (ext === "ts" || ext === "cts" || ext === "mts") return "ts";
+	if (ext === "tsx") return "tsx";
+	return "jsx";
 }
 function collectPatternNames(node, out) {
-  if (!node || typeof node !== "object") return;
-  switch (node.type) {
-    case "Identifier":
-      out.push(node.name);
-      return;
-    case "ObjectPattern":
-      for (const p of node.properties || []) {
-        collectPatternNames(p.value ?? p.argument, out);
-      }
-      return;
-    case "ArrayPattern":
-      for (const el of node.elements || []) collectPatternNames(el, out);
-      return;
-    case "AssignmentPattern":
-      collectPatternNames(node.left, out);
-      return;
-    case "RestElement":
-      collectPatternNames(node.argument, out);
-      return;
-  }
+	if (!node || typeof node !== "object") return;
+	switch (node.type) {
+		case "Identifier":
+			out.push(node.name);
+			return;
+		case "ObjectPattern":
+			for (const p of node.properties || []) {
+				collectPatternNames(p.value ?? p.argument, out);
+			}
+			return;
+		case "ArrayPattern":
+			for (const el of node.elements || []) collectPatternNames(el, out);
+			return;
+		case "AssignmentPattern":
+			collectPatternNames(node.left, out);
+			return;
+		case "RestElement":
+			collectPatternNames(node.argument, out);
+			return;
+	}
 }
-const FUNCTION_TYPES = /* @__PURE__ */new Set(["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"]);
+const FUNCTION_TYPES = /* @__PURE__ */ new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression"
+]);
 function eachChild(node, fn) {
-  for (const key in node) {
-    if (key === "type" || key === "start" || key === "end" || key === "parent") continue;
-    const value = node[key];
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        if (item && typeof item.type === "string") fn(item);
-      }
-    } else if (value && typeof value === "object" && typeof value.type === "string") {
-      fn(value);
-    }
-  }
+	for (const key in node) {
+		if (key === "type" || key === "start" || key === "end" || key === "parent") continue;
+		const value = node[key];
+		if (Array.isArray(value)) {
+			for (const item of value) {
+				if (item && typeof item.type === "string") fn(item);
+			}
+		} else if (value && typeof value === "object" && typeof value.type === "string") {
+			fn(value);
+		}
+	}
 }
 function capturesInClosure(body, names) {
-  let found = false;
-  function scanInsideFunction(node, shadowed) {
-    if (found || !node || typeof node !== "object") return;
-    if (node.type === "Identifier" && names.has(node.name) && !shadowed.has(node.name)) {
-      found = true;
-      return;
-    }
-    if (FUNCTION_TYPES.has(node.type)) {
-      const inner = new Set(shadowed);
-      const params = [];
-      for (const p of node.params || []) collectPatternNames(p, params);
-      for (const p of params) inner.add(p);
-      if (node.id?.name) inner.add(node.id.name);
-      eachChild(node, c => scanInsideFunction(c, inner));
-      return;
-    }
-    if (node.type === "MemberExpression" && !node.computed) {
-      scanInsideFunction(node.object, shadowed);
-      return;
-    }
-    if (node.type === "Property" && !node.computed && node.key === node.value) {
-      scanInsideFunction(node.value, shadowed);
-      return;
-    }
-    eachChild(node, c => scanInsideFunction(c, shadowed));
-  }
-  function walk(node) {
-    if (found || !node || typeof node !== "object") return;
-    if (FUNCTION_TYPES.has(node.type)) {
-      const shadowed = /* @__PURE__ */new Set();
-      const params = [];
-      for (const p of node.params || []) collectPatternNames(p, params);
-      for (const p of params) shadowed.add(p);
-      eachChild(node, c => scanInsideFunction(c, shadowed));
-      return;
-    }
-    eachChild(node, walk);
-  }
-  walk(body);
-  return found;
+	let found = false;
+	function scanInsideFunction(node, shadowed) {
+		if (found || !node || typeof node !== "object") return;
+		if (node.type === "Identifier" && names.has(node.name) && !shadowed.has(node.name)) {
+			found = true;
+			return;
+		}
+		if (FUNCTION_TYPES.has(node.type)) {
+			const inner = new Set(shadowed);
+			const params = [];
+			for (const p of node.params || []) collectPatternNames(p, params);
+			for (const p of params) inner.add(p);
+			if (node.id?.name) inner.add(node.id.name);
+			eachChild(node, (c) => scanInsideFunction(c, inner));
+			return;
+		}
+		if (node.type === "MemberExpression" && !node.computed) {
+			scanInsideFunction(node.object, shadowed);
+			return;
+		}
+		if (node.type === "Property" && !node.computed && node.key === node.value) {
+			scanInsideFunction(node.value, shadowed);
+			return;
+		}
+		eachChild(node, (c) => scanInsideFunction(c, shadowed));
+	}
+	function walk(node) {
+		if (found || !node || typeof node !== "object") return;
+		if (FUNCTION_TYPES.has(node.type)) {
+			const shadowed = /* @__PURE__ */ new Set();
+			const params = [];
+			for (const p of node.params || []) collectPatternNames(p, params);
+			for (const p of params) shadowed.add(p);
+			eachChild(node, (c) => scanInsideFunction(c, shadowed));
+			return;
+		}
+		eachChild(node, walk);
+	}
+	walk(body);
+	return found;
 }
 function analyzeBody(body, names) {
-  const facts = {
-    hasBreak: false,
-    hasContinue: false,
-    hasReturn: false,
-    hasAwait: false,
-    hasYield: false,
-    assignsBinding: false,
-    hasLabeledJump: false
-  };
-  function walk(node, inNestedBreakable, inNestedLoop, inFunction) {
-    if (!node || typeof node !== "object") return;
-    if (FUNCTION_TYPES.has(node.type)) {
-      eachChild(node, c => walk(c, inNestedBreakable, inNestedLoop, true));
-      return;
-    }
-    switch (node.type) {
-      case "BreakStatement":
-        if (node.label) facts.hasLabeledJump = true;else if (!inNestedBreakable) facts.hasBreak = true;
-        break;
-      case "ContinueStatement":
-        if (node.label) facts.hasLabeledJump = true;else if (!inNestedLoop) facts.hasContinue = true;
-        break;
-      case "ReturnStatement":
-        if (!inFunction) facts.hasReturn = true;
-        break;
-      case "AwaitExpression":
-        if (!inFunction) facts.hasAwait = true;
-        break;
-      case "YieldExpression":
-        if (!inFunction) facts.hasYield = true;
-        break;
-      case "AssignmentExpression":
-        if (node.left?.type === "Identifier" && names.has(node.left.name)) {
-          facts.assignsBinding = true;
-        }
-        break;
-      case "UpdateExpression":
-        if (node.argument?.type === "Identifier" && names.has(node.argument.name)) {
-          facts.assignsBinding = true;
-        }
-        break;
-    }
-    const isLoop = node.type === "ForStatement" || node.type === "ForOfStatement" || node.type === "ForInStatement" || node.type === "WhileStatement" || node.type === "DoWhileStatement";
-    const isBreakable = isLoop || node.type === "SwitchStatement";
-    eachChild(node, c => walk(c, inNestedBreakable || isBreakable, inNestedLoop || isLoop, inFunction));
-  }
-  walk(body, false, false, false);
-  return facts;
+	const facts = {
+		hasBreak: false,
+		hasContinue: false,
+		hasReturn: false,
+		hasAwait: false,
+		hasYield: false,
+		assignsBinding: false,
+		hasLabeledJump: false
+	};
+	function walk(node, inNestedBreakable, inNestedLoop, inFunction) {
+		if (!node || typeof node !== "object") return;
+		if (FUNCTION_TYPES.has(node.type)) {
+			eachChild(node, (c) => walk(c, inNestedBreakable, inNestedLoop, true));
+			return;
+		}
+		switch (node.type) {
+			case "BreakStatement":
+				if (node.label) facts.hasLabeledJump = true;
+				else if (!inNestedBreakable) facts.hasBreak = true;
+				break;
+			case "ContinueStatement":
+				if (node.label) facts.hasLabeledJump = true;
+				else if (!inNestedLoop) facts.hasContinue = true;
+				break;
+			case "ReturnStatement":
+				if (!inFunction) facts.hasReturn = true;
+				break;
+			case "AwaitExpression":
+				if (!inFunction) facts.hasAwait = true;
+				break;
+			case "YieldExpression":
+				if (!inFunction) facts.hasYield = true;
+				break;
+			case "AssignmentExpression":
+				if (node.left?.type === "Identifier" && names.has(node.left.name)) {
+					facts.assignsBinding = true;
+				}
+				break;
+			case "UpdateExpression":
+				if (node.argument?.type === "Identifier" && names.has(node.argument.name)) {
+					facts.assignsBinding = true;
+				}
+				break;
+		}
+		const isLoop = node.type === "ForStatement" || node.type === "ForOfStatement" || node.type === "ForInStatement" || node.type === "WhileStatement" || node.type === "DoWhileStatement";
+		const isBreakable = isLoop || node.type === "SwitchStatement";
+		eachChild(node, (c) => walk(c, inNestedBreakable || isBreakable, inNestedLoop || isLoop, inFunction));
+	}
+	walk(body, false, false, false);
+	return facts;
 }
 function collectBodyLexicalNames(node, out) {
-  if (!node || typeof node !== "object" || typeof node.type !== "string") return;
-  if (FUNCTION_TYPES.has(node.type) || node.type === "ClassBody") return;
-  if (node.type === "VariableDeclaration") {
-    if (node.kind === "let" || node.kind === "const") {
-      for (const d of node.declarations || []) collectPatternNames(d.id, out);
-    }
-    return;
-  }
-  if (node.type === "ClassDeclaration") {
-    if (node.id?.name) out.push(node.id.name);
-    return;
-  }
-  eachChild(node, c => collectBodyLexicalNames(c, out));
+	if (!node || typeof node !== "object" || typeof node.type !== "string") return;
+	if (FUNCTION_TYPES.has(node.type) || node.type === "ClassBody") return;
+	if (node.type === "VariableDeclaration") {
+		if (node.kind === "let" || node.kind === "const") {
+			for (const d of node.declarations || []) collectPatternNames(d.id, out);
+		}
+		return;
+	}
+	if (node.type === "ClassDeclaration") {
+		if (node.id?.name) out.push(node.id.name);
+		return;
+	}
+	eachChild(node, (c) => collectBodyLexicalNames(c, out));
 }
-const LOOP_TYPES = /* @__PURE__ */new Set(["ForStatement", "ForOfStatement", "ForInStatement", "WhileStatement", "DoWhileStatement"]);
+const LOOP_TYPES = /* @__PURE__ */ new Set([
+	"ForStatement",
+	"ForOfStatement",
+	"ForInStatement",
+	"WhileStatement",
+	"DoWhileStatement"
+]);
 function headDeclaration(node) {
-  if (node.type === "ForStatement") return node.init;
-  if (node.type === "ForOfStatement" || node.type === "ForInStatement") return node.left;
-  return null;
+	if (node.type === "ForStatement") return node.init;
+	if (node.type === "ForOfStatement" || node.type === "ForInStatement") return node.left;
+	return null;
 }
 function transformOnce(code, filename) {
-  const parsed = (0, import_oxc_parser.parseSync)(filename, code, {
-    lang: langFor(filename)
-  });
-  if (!parsed?.program || parsed.errors?.length) return null;
-  const candidates = [];
-  function findLoops(node, insideCandidate) {
-    if (!node || typeof node !== "object") return;
-    let isCandidate = false;
-    if (LOOP_TYPES.has(node.type) && node.body) {
-      const names = [];
-      const decl = headDeclaration(node);
-      if (decl?.type === "VariableDeclaration" && (decl.kind === "let" || decl.kind === "const")) {
-        for (const d of decl.declarations || []) collectPatternNames(d.id, names);
-      }
-      const shared = [...names];
-      collectBodyLexicalNames(node.body, shared);
-      if (shared.length && capturesInClosure(node.body, new Set(shared))) {
-        isCandidate = true;
-        if (!insideCandidate) candidates.push({
-          node,
-          names
-        });
-      }
-    }
-    eachChild(node, c => findLoops(c, insideCandidate || isCandidate));
-  }
-  findLoops(parsed.program, false);
-  if (!candidates.length) return null;
-  const s = new import_magic_string.default(code);
-  let counter = 0;
-  let changed = false;
-  for (const {
-    node,
-    names
-  } of candidates) {
-    const nameSet = new Set(names);
-    const facts = analyzeBody(node.body, nameSet);
-    if (facts.hasYield || facts.assignsBinding || facts.hasLabeledJump) continue;
-    const fnName = `_hermesLoop${counter++}`;
-    const params = names.join(", ");
-    let bodyText = code.slice(node.body.start, node.body.end);
-    if (node.body.type !== "BlockStatement") {
-      bodyText = `{ ${bodyText} }`;
-    }
-    if (facts.hasBreak || facts.hasReturn || facts.hasContinue) {
-      bodyText = rewriteJumps(bodyText, node.body, code, nameSet);
-    }
-    const asyncKw = facts.hasAwait ? "async " : "";
-    const awaitKw = facts.hasAwait ? "await " : "";
-    let call = `${awaitKw}${fnName}(${params})`;
-    if (facts.hasBreak || facts.hasReturn) {
-      const checks = [];
-      if (facts.hasBreak) checks.push("if (_r === 1) break;");
-      if (facts.hasReturn) checks.push("if (_r) return _r.v;");
-      call = `{ var _r = ${call}; ${checks.join(" ")} }`;
-    } else {
-      call = `{ ${call}; }`;
-    }
-    s.overwrite(node.body.start, node.body.end, call);
-    s.appendLeft(node.start, `{
+	const parsed = (0, import_oxc_parser.parseSync)(filename, code, { lang: langFor(filename) });
+	if (!parsed?.program || parsed.errors?.length) return null;
+	const candidates = [];
+	function findLoops(node, insideCandidate) {
+		if (!node || typeof node !== "object") return;
+		let isCandidate = false;
+		if (LOOP_TYPES.has(node.type) && node.body) {
+			const names = [];
+			const decl = headDeclaration(node);
+			if (decl?.type === "VariableDeclaration" && (decl.kind === "let" || decl.kind === "const")) {
+				for (const d of decl.declarations || []) collectPatternNames(d.id, names);
+			}
+			const shared = [...names];
+			collectBodyLexicalNames(node.body, shared);
+			if (shared.length && capturesInClosure(node.body, new Set(shared))) {
+				isCandidate = true;
+				if (!insideCandidate) candidates.push({
+					node,
+					names
+				});
+			}
+		}
+		eachChild(node, (c) => findLoops(c, insideCandidate || isCandidate));
+	}
+	findLoops(parsed.program, false);
+	if (!candidates.length) return null;
+	const s = new import_magic_string.default(code);
+	let counter = 0;
+	let changed = false;
+	for (const { node, names } of candidates) {
+		const nameSet = new Set(names);
+		const facts = analyzeBody(node.body, nameSet);
+		if (facts.hasYield || facts.assignsBinding || facts.hasLabeledJump) continue;
+		const fnName = `_hermesLoop${counter++}`;
+		const params = names.join(", ");
+		let bodyText = code.slice(node.body.start, node.body.end);
+		if (node.body.type !== "BlockStatement") {
+			bodyText = `{ ${bodyText} }`;
+		}
+		if (facts.hasBreak || facts.hasReturn || facts.hasContinue) {
+			bodyText = rewriteJumps(bodyText, node.body, code, nameSet);
+		}
+		const asyncKw = facts.hasAwait ? "async " : "";
+		const awaitKw = facts.hasAwait ? "await " : "";
+		let call = `${awaitKw}${fnName}(${params})`;
+		if (facts.hasBreak || facts.hasReturn) {
+			const checks = [];
+			if (facts.hasBreak) checks.push("if (_r === 1) break;");
+			if (facts.hasReturn) checks.push("if (_r) return _r.v;");
+			call = `{ var _r = ${call}; ${checks.join(" ")} }`;
+		} else {
+			call = `{ ${call}; }`;
+		}
+		s.overwrite(node.body.start, node.body.end, call);
+		s.appendLeft(node.start, `{
 var ${fnName} = ${asyncKw}(${params}) => ${bodyText};
 `);
-    s.appendLeft(node.end, "\n}");
-    changed = true;
-  }
-  if (!changed) return null;
-  return {
-    code: s.toString(),
-    map: s.generateMap({
-      hires: true,
-      source: filename,
-      includeContent: false
-    })
-  };
+		s.appendLeft(node.end, "\n}");
+		changed = true;
+	}
+	if (!changed) return null;
+	return {
+		code: s.toString(),
+		map: s.generateMap({
+			hires: true,
+			source: filename,
+			includeContent: false
+		})
+	};
 }
 function rewriteJumps(bodyText, bodyNode, code, names) {
-  const offset = bodyNode.start;
-  const s = new import_magic_string.default(bodyText);
-  const pad = bodyNode.type === "BlockStatement" ? 0 : 2;
-  function walk(node, inNestedBreakable, inNestedLoop, inFunction) {
-    if (!node || typeof node !== "object") return;
-    if (FUNCTION_TYPES.has(node.type)) {
-      eachChild(node, c => walk(c, inNestedBreakable, inNestedLoop, true));
-      return;
-    }
-    if (node.type === "BreakStatement" && !node.label && !inNestedBreakable) {
-      s.overwrite(node.start - offset + pad, node.end - offset + pad, "return 1;");
-      return;
-    }
-    if (node.type === "ContinueStatement" && !node.label && !inNestedLoop) {
-      s.overwrite(node.start - offset + pad, node.end - offset + pad, "return;");
-      return;
-    }
-    if (node.type === "ReturnStatement" && !inFunction) {
-      const arg = node.argument;
-      const replacement = arg ? `return { v: ${code.slice(arg.start, arg.end)} };` : "return { v: undefined };";
-      s.overwrite(node.start - offset + pad, node.end - offset + pad, replacement);
-      return;
-    }
-    const isLoop = node.type === "ForStatement" || node.type === "ForOfStatement" || node.type === "ForInStatement" || node.type === "WhileStatement" || node.type === "DoWhileStatement";
-    const isBreakable = isLoop || node.type === "SwitchStatement";
-    eachChild(node, c => walk(c, inNestedBreakable || isBreakable, inNestedLoop || isLoop, inFunction));
-  }
-  walk(bodyNode, false, false, false);
-  return s.toString();
+	const offset = bodyNode.start;
+	const s = new import_magic_string.default(bodyText);
+	const pad = bodyNode.type === "BlockStatement" ? 0 : 2;
+	function walk(node, inNestedBreakable, inNestedLoop, inFunction) {
+		if (!node || typeof node !== "object") return;
+		if (FUNCTION_TYPES.has(node.type)) {
+			eachChild(node, (c) => walk(c, inNestedBreakable, inNestedLoop, true));
+			return;
+		}
+		if (node.type === "BreakStatement" && !node.label && !inNestedBreakable) {
+			s.overwrite(node.start - offset + pad, node.end - offset + pad, "return 1;");
+			return;
+		}
+		if (node.type === "ContinueStatement" && !node.label && !inNestedLoop) {
+			s.overwrite(node.start - offset + pad, node.end - offset + pad, "return;");
+			return;
+		}
+		if (node.type === "ReturnStatement" && !inFunction) {
+			const arg = node.argument;
+			const replacement = arg ? `return { v: ${code.slice(arg.start, arg.end)} };` : "return { v: undefined };";
+			s.overwrite(node.start - offset + pad, node.end - offset + pad, replacement);
+			return;
+		}
+		const isLoop = node.type === "ForStatement" || node.type === "ForOfStatement" || node.type === "ForInStatement" || node.type === "WhileStatement" || node.type === "DoWhileStatement";
+		const isBreakable = isLoop || node.type === "SwitchStatement";
+		eachChild(node, (c) => walk(c, inNestedBreakable || isBreakable, inNestedLoop || isLoop, inFunction));
+	}
+	walk(bodyNode, false, false, false);
+	return s.toString();
 }
 function transformHermesLoops(code, filename) {
-  if (!LOOP_RE.test(code) || !LEXICAL_RE.test(code)) return null;
-  let current = code;
-  const maps = [];
-  for (let i = 0; i < 10; i++) {
-    const next = transformOnce(current, filename);
-    if (!next) break;
-    current = next.code;
-    maps.push(next.map);
-  }
-  return maps.length ? {
-    code: current,
-    maps
-  } : null;
-}
+	if (!LOOP_RE.test(code) || !LEXICAL_RE.test(code)) return null;
+	let current = code;
+	const maps = [];
+	for (let i = 0; i < 10; i++) {
+		const next = transformOnce(current, filename);
+		if (!next) break;
+		current = next.code;
+		maps.push(next.map);
+	}
+	return maps.length ? {
+		code: current,
+		maps
+	} : null;
+}