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

package/dist/esm/transformHermesAsync.mjs

@@ -1,25 +1,24 @@
 async function transformHermesAsync(code, filename, sourceMaps = false, format) {
-  if (!format && !code.includes("async")) return;
-  const {
-    transformSync
-  } = await import("esbuild");
-  const cleanId = filename.split("?")[0];
-  const result = transformSync(code, {
-    loader: /\.[cm]?ts$/.test(cleanId) ? "ts" : cleanId.endsWith(".tsx") ? "tsx" : "jsx",
-    jsx: "preserve",
-    format,
-    supported: {
-      "async-await": false,
-      "async-generator": false,
-      "for-await": false
-    },
-    sourcefile: filename,
-    sourcemap: sourceMaps ? "external" : false
-  });
-  return {
-    code: result.code,
-    map: result.map ? JSON.parse(result.map) : void 0
-  };
+	if (!format && !code.includes("async")) return;
+	const { transformSync } = await import("esbuild");
+	const cleanId = filename.split("?")[0];
+	const result = transformSync(code, {
+		loader: /\.[cm]?ts$/.test(cleanId) ? "ts" : cleanId.endsWith(".tsx") ? "tsx" : "jsx",
+		jsx: "preserve",
+		format,
+		supported: {
+			"async-await": false,
+			"async-generator": false,
+			"for-await": false
+		},
+		sourcefile: filename,
+		sourcemap: sourceMaps ? "external" : false
+	});
+	return {
+		code: result.code,
+		map: result.map ? JSON.parse(result.map) : void 0
+	};
 }
+
 export { transformHermesAsync };
 //# sourceMappingURL=transformHermesAsync.mjs.map

package/dist/esm/transformHermesAsync.mjs.map

@@ -1 +1 @@
-{"version":3,"names":["transformHermesAsync","code","filename","sourceMaps","format","includes","transformSync","cleanId","split","result","loader","test","endsWith","jsx","supported","sourcefile","sourcemap","map","JSON","parse"],"sources":["../../src/transformHermesAsync.ts"],"sourcesContent":[null],"mappings":"AAGA,eAAsBA,qBACpBC,IAAA,EACAC,QAAA,EACAC,UAAA,GAAa,OACbC,MAAA,EACkD;EAClD,IAAI,CAACA,MAAA,IAAU,CAACH,IAAA,CAAKI,QAAA,CAAS,OAAO,GAAG;EAExC,MAAM;IAAEC;EAAc,IAAI,MAAM,OAAO,SAAS;EAChD,MAAMC,OAAA,GAAUL,QAAA,CAASM,KAAA,CAAM,GAAG,EAAE,CAAC;EACrC,MAAMC,MAAA,GAASH,aAAA,CAAcL,IAAA,EAAM;IACjCS,MAAA,EAAQ,aAAaC,IAAA,CAAKJ,OAAO,IAAI,OAAOA,OAAA,CAAQK,QAAA,CAAS,MAAM,IAAI,QAAQ;IAC/EC,GAAA,EAAK;IACLT,MAAA;IACAU,SAAA,EAAW;MACT,eAAe;MACf,mBAAmB;MACnB,aAAa;IACf;IACAC,UAAA,EAAYb,QAAA;IACZc,SAAA,EAAWb,UAAA,GAAa,aAAa;EACvC,CAAC;EACD,OAAO;IACLF,IAAA,EAAMQ,MAAA,CAAOR,IAAA;IACbgB,GAAA,EAAKR,MAAA,CAAOQ,GAAA,GAAMC,IAAA,CAAKC,KAAA,CAAMV,MAAA,CAAOQ,GAAG,IAAI;EAC7C;AACF","ignoreList":[]}
+{"version":3,"file":"transformHermesAsync.js","names":[],"sources":["esm/transformHermesAsync.js"],"sourcesContent":["async function transformHermesAsync(code, filename, sourceMaps = false, format) {\n  if (!format && !code.includes(\"async\")) return;\n  const { transformSync } = await import(\"esbuild\");\n  const cleanId = filename.split(\"?\")[0];\n  const result = transformSync(code, {\n    loader: /\\.[cm]?ts$/.test(cleanId) ? \"ts\" : cleanId.endsWith(\".tsx\") ? \"tsx\" : \"jsx\",\n    jsx: \"preserve\",\n    format,\n    supported: {\n      \"async-await\": false,\n      \"async-generator\": false,\n      \"for-await\": false\n    },\n    sourcefile: filename,\n    sourcemap: sourceMaps ? \"external\" : false\n  });\n  return {\n    code: result.code,\n    map: result.map ? JSON.parse(result.map) : void 0\n  };\n}\nexport {\n  transformHermesAsync\n};\n//# sourceMappingURL=transformHermesAsync.js.map\n"],"mappings":";AAAA,eAAe,qBAAqB,MAAM,UAAU,aAAa,OAAO,QAAQ;CAC9E,IAAI,CAAC,UAAU,CAAC,KAAK,SAAS,OAAO,GAAG;CACxC,MAAM,EAAE,kBAAkB,MAAM,OAAO;CACvC,MAAM,UAAU,SAAS,MAAM,GAAG,CAAC,CAAC;CACpC,MAAM,SAAS,cAAc,MAAM;EACjC,QAAQ,aAAa,KAAK,OAAO,IAAI,OAAO,QAAQ,SAAS,MAAM,IAAI,QAAQ;EAC/E,KAAK;EACL;EACA,WAAW;GACT,eAAe;GACf,mBAAmB;GACnB,aAAa;EACf;EACA,YAAY;EACZ,WAAW,aAAa,aAAa;CACvC,CAAC;CACD,OAAO;EACL,MAAM,OAAO;EACb,KAAK,OAAO,MAAM,KAAK,MAAM,OAAO,GAAG,IAAI,KAAK;CAClD;AACF"}

package/dist/esm/transformHermesClasses.mjs

@@ -0,0 +1,25 @@
+async function transformHermesClasses(code, filename, sourceMaps = false) {
+	if (!/\b(?:class(?:\s|\{)|(?:let|const)\s)/.test(code)) return;
+	const [{ transformAsync }, { default: transformClasses }, { default: transformBlockScoping }] = await Promise.all([
+		import("@babel/core"),
+		import("@babel/plugin-transform-classes"),
+		import("@babel/plugin-transform-block-scoping")
+	]);
+	const result = await transformAsync(code, {
+		filename,
+		babelrc: false,
+		configFile: false,
+		sourceMaps,
+		inputSourceMap: false,
+		parserOpts: { plugins: ["jsx"] },
+		plugins: [transformClasses, transformBlockScoping]
+	});
+	if (!result?.code) return;
+	return {
+		code: result.code,
+		map: result.map
+	};
+}
+
+export { transformHermesClasses };
+//# sourceMappingURL=transformHermesClasses.mjs.map

package/dist/esm/transformHermesClasses.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformHermesClasses.js","names":[],"sources":["esm/transformHermesClasses.js"],"sourcesContent":["async function transformHermesClasses(code, filename, sourceMaps = false) {\n  if (!/\\b(?:class(?:\\s|\\{)|(?:let|const)\\s)/.test(code)) return;\n  const [\n    { transformAsync },\n    { default: transformClasses },\n    { default: transformBlockScoping }\n  ] = await Promise.all([\n    import(\"@babel/core\"),\n    import(\"@babel/plugin-transform-classes\"),\n    import(\"@babel/plugin-transform-block-scoping\")\n  ]);\n  const result = await transformAsync(code, {\n    filename,\n    babelrc: false,\n    configFile: false,\n    sourceMaps,\n    // the caller composes stage maps itself; a file's own sourceMappingURL\n    // composed here would give the stage map several sources\n    // @ts-expect-error @types/babel__core omits false, which babel accepts\n    inputSourceMap: false,\n    parserOpts: { plugins: [\"jsx\"] },\n    // Legacy Hermes hoists lexical names, including in class-free functions.\n    // Lower block scope so minification cannot shadow parameters or constructors.\n    plugins: [transformClasses, transformBlockScoping]\n  });\n  if (!result?.code) return;\n  return { code: result.code, map: result.map };\n}\nexport {\n  transformHermesClasses\n};\n//# sourceMappingURL=transformHermesClasses.js.map\n"],"mappings":";AAAA,eAAe,uBAAuB,MAAM,UAAU,aAAa,OAAO;CACxE,IAAI,CAAC,uCAAuC,KAAK,IAAI,GAAG;CACxD,MAAM,CACJ,EAAE,kBACF,EAAE,SAAS,oBACX,EAAE,SAAS,2BACT,MAAM,QAAQ,IAAI;EACpB,OAAO;EACP,OAAO;EACP,OAAO;CACT,CAAC;CACD,MAAM,SAAS,MAAM,eAAe,MAAM;EACxC;EACA,SAAS;EACT,YAAY;EACZ;EAIA,gBAAgB;EAChB,YAAY,EAAE,SAAS,CAAC,KAAK,EAAE;EAG/B,SAAS,CAAC,kBAAkB,qBAAqB;CACnD,CAAC;CACD,IAAI,CAAC,QAAQ,MAAM;CACnB,OAAO;EAAE,MAAM,OAAO;EAAM,KAAK,OAAO;CAAI;AAC9C"}

package/dist/esm/transformHermesLoops.mjs

@@ -1,283 +1,292 @@
 import MagicString from "magic-string";
 import { parseSync } from "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 = 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 MagicString(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 = 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 MagicString(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 MagicString(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 MagicString(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;
 }
+
 export { transformHermesLoops };
 //# sourceMappingURL=transformHermesLoops.mjs.map