@vxrn/compiler 1.25.16 → 1.26.0

package/dist/cjs/transformBabel.test.cjs

@@ -97,4 +97,264 @@ var import_transformBabel = require("./transformBabel.cjs");
       plugins: [negativeControl]
     })).rejects.toThrow("NATIVE_TRANSFORM_NEGATIVE_CONTROL");
   });
+});
+(0, import_vitest.describe)("transformOxcReactCompiler", () => {
+  const componentCode = `
+    import { useState } from 'react'
+
+    export function Counter() {
+      const [count, setCount] = useState(0)
+      return <button onClick={() => setCount(count + 1)}>{count}</button>
+    }
+  `;
+  (0, import_vitest.it)("compiles and memoizes React components with Rust React Compiler", async () => {
+    const result = await (0, import_transformBabel.transformOxcReactCompiler)("/project/Counter.tsx", componentCode, "19", false);
+    (0, import_vitest.expect)(result.code).toContain("_c(");
+    (0, import_vitest.expect)(result.code).toContain("react/compiler-runtime");
+    (0, import_vitest.expect)(result.map).toBeUndefined();
+  });
+  (0, import_vitest.it)("generates source maps when requested", async () => {
+    const result = await (0, import_transformBabel.transformOxcReactCompiler)("/project/Counter.tsx", componentCode, "19", true);
+    (0, import_vitest.expect)(result.code).toContain("_c(");
+    (0, import_vitest.expect)(result.map).toBeDefined();
+    (0, import_vitest.expect)(result.map?.mappings).toBeDefined();
+  });
+  (0, import_vitest.it)("supports target 18", async () => {
+    const result = await (0, import_transformBabel.transformOxcReactCompiler)("/project/Counter.tsx", componentCode, "18", false);
+    (0, import_vitest.expect)(result.code).toContain("_c(");
+  });
+});
+(0, import_vitest.describe)("compiler plugin multi-stage source map composition", () => {
+  (0, import_vitest.it)("composes earlier compiler maps when Babel also runs", async () => {
+    const {
+      createVXRNCompilerPlugin
+    } = await import("./index");
+    const {
+      TraceMap,
+      originalPositionFor
+    } = await import("@jridgewell/trace-mapping");
+    const origSourceMap = process.env.VXRN_ENABLE_SOURCE_MAP;
+    const origBabelGen = process.env.VXRN_USE_BABEL_FOR_GENERATORS;
+    process.env.VXRN_ENABLE_SOURCE_MAP = "1";
+    process.env.VXRN_USE_BABEL_FOR_GENERATORS = "1";
+    (0, import_configure.configureVXRNCompilerPlugin)({
+      enableCompiler: true
+    });
+    const tempFile = import_node_path.default.join(import_node_os.default.tmpdir(), `Counter-${Date.now()}.tsx`);
+    import_node_fs.default.writeFileSync(tempFile, `import { useState } from 'react'
+
+export function Counter() {
+  const [count, setCount] = useState(0)
+  return <button onClick={() => setCount(count + 1)}>{count}</button>
+}
+
+export async function* generatorProbe() {
+  throw new Error("MARKER")
+}
+`);
+    try {
+      const plugins = await createVXRNCompilerPlugin();
+      const plugin = plugins.find(p => p.name === "one:compiler");
+      await plugin.configResolved({
+        root: import_node_os.default.tmpdir(),
+        build: {}
+      });
+      const hook = plugin.transform.handler || plugin.transform;
+      const code = import_node_fs.default.readFileSync(tempFile, "utf8");
+      const context = {
+        environment: {
+          name: "client"
+        }
+      };
+      const result = await hook.call(context, code, tempFile);
+      (0, import_vitest.expect)(result).toBeDefined();
+      (0, import_vitest.expect)(result.map).toBeDefined();
+      const tracer = new TraceMap(result.map);
+      const lines = result.code.split("\n");
+      const markerLineIndex = lines.findIndex(l => l.includes("MARKER"));
+      (0, import_vitest.expect)(markerLineIndex).toBeGreaterThan(0);
+      const markerCol = lines[markerLineIndex].indexOf("throw");
+      const pos = originalPositionFor(tracer, {
+        line: markerLineIndex + 1,
+        column: markerCol
+      });
+      (0, import_vitest.expect)(pos.source).toBe(tempFile);
+      (0, import_vitest.expect)(pos.line).toBe(9);
+    } finally {
+      if (origSourceMap !== void 0) {
+        process.env.VXRN_ENABLE_SOURCE_MAP = origSourceMap;
+      } else {
+        delete process.env.VXRN_ENABLE_SOURCE_MAP;
+      }
+      if (origBabelGen !== void 0) {
+        process.env.VXRN_USE_BABEL_FOR_GENERATORS = origBabelGen;
+      } else {
+        delete process.env.VXRN_USE_BABEL_FOR_GENERATORS;
+      }
+      (0, import_configure.configureVXRNCompilerPlugin)({
+        enableCompiler: false
+      });
+      import_node_fs.default.rmSync(tempFile, {
+        force: true
+      });
+    }
+  });
+});
+(0, import_vitest.describe)("shared compiler worklets backend selection", () => {
+  (0, import_vitest.it)("retains Babel for worklets by default when enableNativeWorklets is false", async () => {
+    const {
+      vi
+    } = await import("vitest");
+    const {
+      createVXRNCompilerPlugin
+    } = await import("./index");
+    const workletsModule = await import("./transformWorklets");
+    const workletSpy = vi.spyOn(workletsModule, "transformWorklets");
+    (0, import_configure.configureVXRNCompilerPlugin)({
+      enableReanimated: true,
+      enableNativeWorklets: false
+    });
+    const tempFile = import_node_path.default.join(process.cwd(), `test-default-worklet-${Date.now()}.tsx`);
+    const inputCode = `export function fn() { 'worklet'; return 1 }`;
+    import_node_fs.default.writeFileSync(tempFile, inputCode);
+    try {
+      const plugins = await createVXRNCompilerPlugin();
+      const plugin = plugins.find(p => p.name === "one:compiler");
+      await plugin.configResolved({
+        root: process.cwd(),
+        build: {}
+      });
+      const hook = plugin.transform.handler || plugin.transform;
+      const context = {
+        environment: {
+          name: "ios"
+        }
+      };
+      const result = await hook.call(context, inputCode, tempFile);
+      (0, import_vitest.expect)(result).toBeDefined();
+      (0, import_vitest.expect)(workletSpy).not.toHaveBeenCalled();
+    } finally {
+      workletSpy.mockRestore();
+      (0, import_configure.configureVXRNCompilerPlugin)({
+        enableReanimated: false,
+        enableNativeWorklets: false
+      });
+      import_node_fs.default.rmSync(tempFile, {
+        force: true
+      });
+    }
+  });
+  (0, import_vitest.it)("uses native SWC for worklets when enableNativeWorklets is true", async () => {
+    const compiler = await import("./index");
+    const {
+      vi
+    } = await import("vitest");
+    const workletsModule = await import("./transformWorklets");
+    const workletSpy = vi.spyOn(workletsModule, "transformWorklets");
+    (0, import_configure.configureVXRNCompilerPlugin)({
+      enableReanimated: true,
+      enableNativeWorklets: true
+    });
+    const tempFile = import_node_path.default.join(process.cwd(), `test-native-worklet-${Date.now()}.tsx`);
+    const inputCode = `export function fn() { 'worklet'; return 1 }`;
+    import_node_fs.default.writeFileSync(tempFile, inputCode);
+    try {
+      const plugins = await compiler.createVXRNCompilerPlugin();
+      const plugin = plugins.find(p => p.name === "one:compiler");
+      await plugin.configResolved({
+        root: process.cwd(),
+        build: {}
+      });
+      const hook = plugin.transform.handler || plugin.transform;
+      const context = {
+        environment: {
+          name: "ios"
+        }
+      };
+      const result = await hook.call(context, inputCode, tempFile);
+      (0, import_vitest.expect)(result).toBeDefined();
+      (0, import_vitest.expect)(workletSpy).toHaveBeenCalled();
+    } finally {
+      workletSpy.mockRestore();
+      (0, import_configure.configureVXRNCompilerPlugin)({
+        enableReanimated: false,
+        enableNativeWorklets: false
+      });
+      import_node_fs.default.rmSync(tempFile, {
+        force: true
+      });
+    }
+  });
+  (0, import_vitest.it)("invalidates cache when toggling worklets backend on the same unchanged file", async () => {
+    const compiler = await import("./index");
+    const {
+      vi
+    } = await import("vitest");
+    const workletsModule = await import("./transformWorklets");
+    const workletSpy = vi.spyOn(workletsModule, "transformWorklets");
+    const tempFile = import_node_path.default.join(process.cwd(), `test-cache-toggle-${Date.now()}.tsx`);
+    const inputCode = `export function fn() { 'worklet'; return 1 }`;
+    import_node_fs.default.writeFileSync(tempFile, inputCode);
+    try {
+      (0, import_configure.configureVXRNCompilerPlugin)({
+        enableReanimated: true,
+        enableNativeWorklets: false
+      });
+      const plugins1 = await compiler.createVXRNCompilerPlugin();
+      const plugin1 = plugins1.find(p => p.name === "one:compiler");
+      await plugin1.configResolved({
+        root: process.cwd(),
+        build: {}
+      });
+      const hook1 = plugin1.transform.handler || plugin1.transform;
+      const context = {
+        environment: {
+          name: "ios"
+        }
+      };
+      const res1 = await hook1.call(context, inputCode, tempFile);
+      (0, import_vitest.expect)(res1).toBeDefined();
+      (0, import_vitest.expect)(workletSpy).toHaveBeenCalledTimes(0);
+      (0, import_configure.configureVXRNCompilerPlugin)({
+        enableReanimated: true,
+        enableNativeWorklets: true
+      });
+      const plugins2 = await compiler.createVXRNCompilerPlugin();
+      const plugin2 = plugins2.find(p => p.name === "one:compiler");
+      await plugin2.configResolved({
+        root: process.cwd(),
+        build: {}
+      });
+      const hook2 = plugin2.transform.handler || plugin2.transform;
+      const res2 = await hook2.call(context, inputCode, tempFile);
+      (0, import_vitest.expect)(res2).toBeDefined();
+      (0, import_vitest.expect)(workletSpy).toHaveBeenCalledTimes(1);
+      const res3 = await hook2.call(context, inputCode, tempFile);
+      (0, import_vitest.expect)(res3).toBeDefined();
+      (0, import_vitest.expect)(workletSpy).toHaveBeenCalledTimes(1);
+      (0, import_configure.configureVXRNCompilerPlugin)({
+        enableReanimated: true,
+        enableNativeWorklets: false
+      });
+      const plugins3 = await compiler.createVXRNCompilerPlugin();
+      const plugin3 = plugins3.find(p => p.name === "one:compiler");
+      await plugin3.configResolved({
+        root: process.cwd(),
+        build: {}
+      });
+      const hook3 = plugin3.transform.handler || plugin3.transform;
+      const res4 = await hook3.call(context, inputCode, tempFile);
+      (0, import_vitest.expect)(res4).toBeDefined();
+      (0, import_vitest.expect)(workletSpy).toHaveBeenCalledTimes(1);
+    } finally {
+      workletSpy.mockRestore();
+      (0, import_configure.configureVXRNCompilerPlugin)({
+        enableReanimated: false,
+        enableNativeWorklets: false
+      });
+      import_node_fs.default.rmSync(tempFile, {
+        force: true
+      });
+    }
+  });
 });

package/dist/cjs/transformHermesAsync.cjs

@@ -0,0 +1,61 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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
+  });
+};
+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;
+};
+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
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var transformHermesAsync_exports = {};
+__export(transformHermesAsync_exports, {
+  transformHermesAsync: () => transformHermesAsync
+});
+module.exports = __toCommonJS(transformHermesAsync_exports);
+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
+  };
+}

package/dist/cjs/transformHermesLoops.cjs

@@ -0,0 +1,319 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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
+  });
+};
+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;
+};
+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
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var transformHermesLoops_exports = {};
+__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";
+}
+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;
+  }
+}
+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);
+    }
+  }
+}
+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;
+}
+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;
+}
+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));
+}
+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;
+}
+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, `{
+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
+    })
+  };
+}
+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();
+}
+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;
+}