@vxrn/vite-plugin-metro 1.25.16 → 1.26.0

package/dist/cjs/transformer/metroNativeWorker.cjs

@@ -0,0 +1,1590 @@
+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 metroNativeWorker_exports = {};
+__export(metroNativeWorker_exports, {
+  ScopeTracker: () => ScopeTracker,
+  applyEnvironmentGuard: () => applyEnvironmentGuard,
+  applyInlineEnvVars: () => applyInlineEnvVars,
+  applyModuleResolverAliases: () => applyModuleResolverAliases,
+  applyOneRouterMetro: () => applyOneRouterMetro,
+  assertNoUnportedBabelPlugins: () => assertNoUnportedBabelPlugins,
+  collectBlockBindings: () => collectBlockBindings,
+  collectHoistedBindings: () => collectHoistedBindings,
+  collectPatternNames: () => collectPatternNames,
+  convertSourceMapToMetroRawMappings: () => convertSourceMapToMetroRawMappings,
+  countLinesAndTerminateMap: () => countLinesAndTerminateMap,
+  default: () => metroNativeWorker_default,
+  extractDependencies: () => extractDependencies,
+  getCacheKey: () => getCacheKey,
+  getDependencyKey: () => getDependencyKey,
+  getImportMetaEnv: () => getImportMetaEnv,
+  getModuleResolverAliases: () => getModuleResolverAliases,
+  getOneRouterMetroOptions: () => getOneRouterMetroOptions,
+  getRemoveServerCodeRouterRoot: () => getRemoveServerCodeRouterRoot,
+  resolveAliasSpecifier: () => resolveAliasSpecifier,
+  rewriteDependencyCalls: () => rewriteDependencyCalls,
+  transform: () => transform,
+  wrapJson: () => wrapJson,
+  wrapModule: () => wrapModule
+});
+module.exports = __toCommonJS(metroNativeWorker_exports);
+var import_node_crypto = __toESM(require("node:crypto"), 1);
+var import_node_module = require("node:module");
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_oxc_parser = require("oxc-parser");
+var import_magic_string = __toESM(require("magic-string"), 1);
+var import_remapping = __toESM(require("@jridgewell/remapping"), 1);
+var import_trace_mapping = require("@jridgewell/trace-mapping");
+var import_compiler = require("@vxrn/compiler");
+var import_platformEnv = require("../env/platformEnv.cjs");
+function collectModuleLiteralBindings(program) {
+  const reassigned = /* @__PURE__ */new Set();
+  const declCount = /* @__PURE__ */new Map();
+  (function findReassignments(node) {
+    if (!node || typeof node !== "object") return;
+    if (Array.isArray(node)) {
+      for (const child of node) findReassignments(child);
+      return;
+    }
+    if (node.type === "AssignmentExpression" && node.left?.type === "Identifier") {
+      reassigned.add(node.left.name);
+    } else if (node.type === "UpdateExpression" && node.argument?.type === "Identifier") {
+      reassigned.add(node.argument.name);
+    }
+    for (const key in node) {
+      if (key === "type" || key === "start" || key === "end") continue;
+      findReassignments(node[key]);
+    }
+  })(program);
+  for (const stmt of program.body || []) {
+    if (stmt.type !== "VariableDeclaration") continue;
+    for (const decl of stmt.declarations || []) {
+      if (decl.id?.type === "Identifier") {
+        declCount.set(decl.id.name, (declCount.get(decl.id.name) || 0) + 1);
+      }
+    }
+  }
+  const bindings = /* @__PURE__ */new Map();
+  for (const stmt of program.body || []) {
+    if (stmt.type !== "VariableDeclaration") continue;
+    for (const decl of stmt.declarations || []) {
+      if (decl.id?.type === "Identifier" && decl.init?.type === "Literal" && !reassigned.has(decl.id.name) && declCount.get(decl.id.name) === 1) {
+        bindings.set(decl.id.name, decl.init);
+      }
+    }
+  }
+  return bindings;
+}
+const WORKER_CACHE_KEY_VERSION = "5";
+function langForFilename(filename) {
+  if (filename.endsWith(".tsx")) return "tsx";
+  if (filename.endsWith(".ts")) return "ts";
+  return "jsx";
+}
+function getOneRouterMetroOptions(options) {
+  const plugins = options.customTransformOptions?.vite?.babelConfig?.plugins;
+  if (!Array.isArray(plugins)) return void 0;
+  for (const plugin of plugins) {
+    if (Array.isArray(plugin) && typeof plugin[0] === "string" && plugin[0].includes("one-router-metro")) {
+      return plugin[1];
+    }
+  }
+  return void 0;
+}
+function getRemoveServerCodeRouterRoot(options) {
+  const plugins = options.customTransformOptions?.vite?.babelConfig?.plugins;
+  if (!Array.isArray(plugins)) return void 0;
+  for (const plugin of plugins) {
+    if (Array.isArray(plugin) && typeof plugin[0] === "string" && plugin[0].includes("remove-server-code")) {
+      return plugin[1]?.routerRoot ?? "app";
+    }
+  }
+  return void 0;
+}
+const importMetaEnvCache = /* @__PURE__ */new WeakMap();
+function getImportMetaEnv(options) {
+  const plugins = options.customTransformOptions?.vite?.babelConfig?.plugins;
+  const platform = options.platform ?? "";
+  let byPlatform = Array.isArray(plugins) ? importMetaEnvCache.get(plugins) : void 0;
+  const cached = byPlatform?.get(platform);
+  if (cached) return cached;
+  let env = {};
+  if (Array.isArray(plugins)) {
+    for (const plugin of plugins) {
+      if (Array.isArray(plugin) && typeof plugin[0] === "string" && plugin[0].includes("import-meta-env-plugin")) {
+        const found = plugin[1]?.env;
+        if (found && typeof found === "object") env = found;
+      }
+    }
+  }
+  const merged = {
+    ...env,
+    ...(0, import_platformEnv.getPlatformEnv)((0, import_platformEnv.metroPlatformToViteEnvironment)(options.platform))
+  };
+  if (Array.isArray(plugins)) {
+    if (!byPlatform) {
+      byPlatform = /* @__PURE__ */new Map();
+      importMetaEnvCache.set(plugins, byPlatform);
+    }
+    byPlatform.set(platform, merged);
+  }
+  return merged;
+}
+const PORTED_BABEL_PLUGINS = ["import-meta-env-plugin", "one-router-metro", "remove-server-code", "module-resolver", "environment-guard", "inline-one-server-url",
+// the worklets transform is a native oxc port, so both plugin names it can
+// arrive under are covered.
+"react-native-worklets/plugin", "react-native-reanimated/plugin", "babel-plugin-react-compiler"];
+const unportedPluginCache = /* @__PURE__ */new WeakMap();
+const loadedNativeTransforms = /* @__PURE__ */new Map();
+function getNativeTransforms(options, projectRoot) {
+  const ids = options.customTransformOptions?.vite?.nativeTransformModules;
+  if (!Array.isArray(ids) || !ids.length) return [];
+  const req = (0, import_node_module.createRequire)(import_node_path.default.join(projectRoot, "package.json"));
+  return ids.map(id => {
+    const cached = loadedNativeTransforms.get(id);
+    if (cached) return cached;
+    let mod;
+    try {
+      mod = req(id);
+    } catch (err) {
+      throw new Error(`[vxrn/metro] Could not load the native transform "${id}" from ${projectRoot}: ${err.message}`);
+    }
+    const fn = mod?.default ?? mod;
+    if (typeof fn !== "function") {
+      throw new Error(`[vxrn/metro] The native transform "${id}" must default-export a function (code, ctx) => string.`);
+    }
+    loadedNativeTransforms.set(id, fn);
+    return fn;
+  });
+}
+function isReactCompilerCandidate(filename) {
+  if (!/\.tsx?$/.test(filename)) return false;
+  if (filename.includes("node_modules")) return false;
+  if (filename.includes("+api.")) return false;
+  return true;
+}
+function hasBabelPlugin(options, id) {
+  const plugins = options.customTransformOptions?.vite?.babelConfig?.plugins;
+  if (!Array.isArray(plugins)) return false;
+  return plugins.some(plugin => (Array.isArray(plugin) ? plugin[0] : plugin) === id);
+}
+function assertNoUnportedBabelPlugins(options) {
+  const plugins = options.customTransformOptions?.vite?.babelConfig?.plugins;
+  if (!Array.isArray(plugins)) return;
+  let unported = unportedPluginCache.get(plugins);
+  if (!unported) {
+    unported = [];
+    for (const plugin of plugins) {
+      const id = Array.isArray(plugin) ? plugin[0] : plugin;
+      if (typeof id !== "string") {
+        unported.push("(a function or object plugin, which cannot be ported)");
+        continue;
+      }
+      if (!PORTED_BABEL_PLUGINS.some(ported => id.includes(ported))) {
+        unported.push(id);
+      }
+    }
+    unportedPluginCache.set(plugins, unported);
+  }
+  if (unported.length) {
+    throw new Error(`[vxrn/metro] the native transform path runs no babel, so these babel plugins would be silently ignored:
+` + unported.map(id => `  - ${id}`).join("\n") + `
+
+Port each one to a native transform and list it in bundlerOptions.nativeTransformModules, remove it from bundlerOptions.babelConfigOverrides, or set bundlerOptions.nativeTransforms: false (or ONE_METRO_NATIVE_TRANSFORMS=0) to go back to the babel transformer.`);
+  }
+}
+function getModuleResolverAliases(options) {
+  const plugins = options.customTransformOptions?.vite?.babelConfig?.plugins;
+  if (!Array.isArray(plugins)) return void 0;
+  for (const plugin of plugins) {
+    if (Array.isArray(plugin) && typeof plugin[0] === "string" && plugin[0].includes("module-resolver")) {
+      const alias = plugin[1]?.alias;
+      if (alias && typeof alias === "object") return alias;
+    }
+  }
+  return void 0;
+}
+function resolveAliasSpecifier(specifier, filename, projectRoot, aliases) {
+  for (const [rawKey, value] of Object.entries(aliases)) {
+    let target;
+    if (rawKey.endsWith("$")) {
+      if (specifier === rawKey.slice(0, -1)) target = value;
+    } else if (specifier === rawKey || specifier.startsWith(`${rawKey}/`)) {
+      target = value + specifier.slice(rawKey.length);
+    }
+    if (target === void 0) continue;
+    const abs = import_node_path.default.resolve(projectRoot, target);
+    let rel = import_node_path.default.relative(import_node_path.default.dirname(filename), abs).split(import_node_path.default.sep).join("/");
+    if (!rel.startsWith(".")) rel = `./${rel}`;
+    return rel;
+  }
+  return void 0;
+}
+function applyModuleResolverAliases(code, filename, projectRoot, aliases) {
+  const parsed = (0, import_oxc_parser.parseSync)(filename, code, {
+    lang: langForFilename(filename)
+  });
+  if (parsed?.errors?.length) {
+    throw new Error(`[vxrn/metro] Failed to parse ${filename} for alias resolution: ${parsed.errors[0].message}`);
+  }
+  if (!parsed?.program) return code;
+  const ms = new import_magic_string.default(code);
+  let changed = false;
+  function rewrite(sourceNode) {
+    if (sourceNode?.type !== "Literal" || typeof sourceNode.value !== "string") return;
+    const resolved = resolveAliasSpecifier(sourceNode.value, filename, projectRoot, aliases);
+    if (resolved === void 0) return;
+    ms.overwrite(sourceNode.start, sourceNode.end, JSON.stringify(resolved));
+    changed = true;
+  }
+  function walk(node) {
+    if (!node || typeof node !== "object") return;
+    if (node.type === "ImportDeclaration" || node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration" || node.type === "ImportExpression") {
+      rewrite(node.source);
+    } else if (node.type === "CallExpression" && node.callee?.type === "Identifier" && node.callee.name === "require") {
+      rewrite(node.arguments?.[0]);
+    }
+    for (const k of Object.keys(node)) {
+      if (k === "start" || k === "end" || k === "loc" || k === "range" || k === "parent" || k === "comments") continue;
+      const child = node[k];
+      if (Array.isArray(child)) {
+        for (const item of child) walk(item);
+      } else if (child && typeof child === "object") {
+        walk(child);
+      }
+    }
+  }
+  walk(parsed.program);
+  return changed ? ms.toString() : code;
+}
+function applyInlineEnvVars(code, filename, isProduction, env = {}) {
+  const parsed = (0, import_oxc_parser.parseSync)(filename, code, {
+    lang: langForFilename(filename)
+  });
+  if (parsed?.errors?.length) {
+    throw new Error(`[vxrn/metro] Failed to parse ${filename} for env inlining: ${parsed.errors[0].message}`);
+  }
+  if (!parsed?.program) return code;
+  const ms = new import_magic_string.default(code);
+  let needsEnvImport = false;
+  const edits = [];
+  const known = /* @__PURE__ */new Map();
+  function replace(node, value) {
+    const text = value === void 0 ? "undefined" : JSON.stringify(value);
+    edits.push({
+      start: node.start,
+      end: node.end,
+      text
+    });
+    known.set(node, value);
+  }
+  function keyOf(prop, computed) {
+    if (!computed && prop?.type === "Identifier") return prop.name;
+    if (prop?.type === "Literal" && typeof prop.value === "string") return prop.value;
+    return void 0;
+  }
+  function isImportMeta(node) {
+    return node?.type === "MetaProperty" && node.meta?.name === "import" && node.property?.name === "meta";
+  }
+  function walk(node, parent) {
+    if (!node || typeof node !== "object") return;
+    if (node.type === "MemberExpression" || node.type === "OptionalMemberExpression") {
+      const obj = node.object;
+      const isMember = obj?.type === "MemberExpression" || obj?.type === "OptionalMemberExpression";
+      const isProcessEnv = isMember && obj.object?.type === "Identifier" && obj.object.name === "process" && keyOf(obj.property, obj.computed) === "env";
+      const isAssignmentTarget = parent?.type === "AssignmentExpression" && parent.left === node;
+      const key = keyOf(node.property, node.computed);
+      if (isProcessEnv && !isAssignmentTarget && key === "ONE_SERVER_URL") {
+        replace(node, process.env.ONE_SERVER_URL || "");
+        return;
+      }
+      if (isProcessEnv && !isAssignmentTarget && key?.startsWith("EXPO_PUBLIC_")) {
+        if (isProduction) {
+          replace(node, process.env[key] ?? void 0);
+        } else {
+          edits.push({
+            start: node.start,
+            end: node.end,
+            text: `_$$_EXPO_ENV.${key}`
+          });
+          needsEnvImport = true;
+        }
+        return;
+      }
+      if (!isAssignmentTarget && isMember && isImportMeta(obj.object) && keyOf(obj.property, obj.computed) === "env" && key !== void 0) {
+        replace(node, env[key]);
+        return;
+      }
+      if (!isAssignmentTarget && isImportMeta(obj) && key === "env") {
+        edits.push({
+          start: node.start,
+          end: node.end,
+          text: JSON.stringify(env)
+        });
+        return;
+      }
+      if (isProcessEnv && !isAssignmentTarget && key !== void 0 && key in env) {
+        replace(node, env[key]);
+        return;
+      }
+    }
+    for (const k of Object.keys(node)) {
+      if (k === "start" || k === "end" || k === "loc" || k === "range" || k === "parent" || k === "comments") continue;
+      const child = node[k];
+      if (Array.isArray(child)) {
+        for (const item of child) walk(item, node);
+      } else if (child && typeof child === "object") {
+        walk(child, node);
+      }
+    }
+  }
+  walk(parsed.program, null);
+  function testValue(node) {
+    if (known.has(node)) return !!known.get(node);
+    if (node?.type === "UnaryExpression" && node.operator === "!") {
+      const inner = testValue(node.argument);
+      return inner === void 0 ? void 0 : !inner;
+    }
+    if (node?.type === "BinaryExpression" && (node.operator === "===" || node.operator === "!==")) {
+      const left = known.has(node.left) ? known.get(node.left) : void 0;
+      const right = node.right?.type === "Literal" ? node.right.value : void 0;
+      if (!known.has(node.left) || node.right?.type !== "Literal") return void 0;
+      return node.operator === "===" ? left === right : left !== right;
+    }
+    return void 0;
+  }
+  const dead = [];
+  (function foldWalk(node) {
+    if (!node || typeof node !== "object") return;
+    if (Array.isArray(node)) {
+      for (const child of node) foldWalk(child);
+      return;
+    }
+    if (node.type === "IfStatement" || node.type === "ConditionalExpression") {
+      const value = testValue(node.test);
+      if (value !== void 0) {
+        const kept = value ? node.consequent : node.alternate;
+        if (!kept) {
+          dead.push({
+            start: node.start,
+            end: node.end,
+            text: ";"
+          });
+          return;
+        }
+        dead.push({
+          start: node.start,
+          end: kept.start,
+          text: ""
+        });
+        if (kept.end < node.end) {
+          dead.push({
+            start: kept.end,
+            end: node.end,
+            text: ""
+          });
+        }
+        foldWalk(kept);
+        return;
+      }
+    }
+    for (const k of Object.keys(node)) {
+      if (k === "start" || k === "end" || k === "loc" || k === "range" || k === "parent" || k === "comments") continue;
+      foldWalk(node[k]);
+    }
+  })(parsed.program);
+  for (const range of dead) {
+    ms.overwrite(range.start, range.end, range.text);
+  }
+  for (const edit of edits) {
+    if (dead.some(d => edit.start >= d.start && edit.end <= d.end)) continue;
+    ms.overwrite(edit.start, edit.end, edit.text);
+  }
+  if (needsEnvImport) {
+    ms.prepend(`import { env as _$$_EXPO_ENV } from "expo/virtual/env";
+`);
+  }
+  return ms.hasChanged() ? ms.toString() : code;
+}
+const GUARD_SPECIFIERS = /* @__PURE__ */new Set(["server-only", "client-only", "web-only"]);
+function applyEnvironmentGuard(code, filename) {
+  const parsed = (0, import_oxc_parser.parseSync)(filename, code, {
+    lang: langForFilename(filename)
+  });
+  if (parsed?.errors?.length) {
+    throw new Error(`[vxrn/metro] Failed to parse ${filename} for environment guards: ${parsed.errors[0].message}`);
+  }
+  const body = parsed?.program?.body;
+  if (!body) return code;
+  const ms = new import_magic_string.default(code);
+  let changed = false;
+  for (const node of body) {
+    if (node.type !== "ImportDeclaration") continue;
+    const source = node.source?.value;
+    if (source === "native-only") {
+      ms.remove(node.start, node.end);
+      changed = true;
+    } else if (GUARD_SPECIFIERS.has(source)) {
+      ms.overwrite(node.start, node.end, `throw new Error(${JSON.stringify(`${source} cannot be imported in a native environment`)});`);
+      changed = true;
+    }
+  }
+  return changed ? ms.toString() : code;
+}
+function applyOneRouterMetro(code, filename, options) {
+  const isMetroEntry = filename.endsWith("metro-entry.js");
+  const isEntryCtx = filename.endsWith("metro-entry-ctx.js");
+  if (!isMetroEntry && !isEntryCtx) return code;
+  const parsed = (0, import_oxc_parser.parseSync)(filename, code, {
+    lang: langForFilename(filename)
+  });
+  if (parsed?.errors?.length) {
+    throw new Error(`[vxrn/metro] Failed to parse ${filename} for one-router-metro: ${parsed.errors[0].message}`);
+  }
+  if (!parsed?.program) return code;
+  const ms = new import_magic_string.default(code);
+  let lastImportEnd = -1;
+  function replacementFor(key) {
+    if (key.startsWith("ONE_ROUTER_APP_ROOT_RELATIVE_TO_ENTRY")) {
+      return JSON.stringify(options.ONE_ROUTER_APP_ROOT_RELATIVE_TO_ENTRY);
+    }
+    if (key.startsWith("ONE_ROUTER_ROOT_FOLDER_NAME")) {
+      return JSON.stringify(options.ONE_ROUTER_ROOT_FOLDER_NAME);
+    }
+    if (key.startsWith("ONE_ROUTER_REQUIRE_CONTEXT_REGEX")) {
+      return `/${options.ONE_ROUTER_REQUIRE_CONTEXT_REGEX_STRING}/`;
+    }
+    if (key === "ONE_ROUTER_LINKING_CONFIG") {
+      return isMetroEntry ? JSON.stringify(options.ONE_ROUTER_LINKING_CONFIG ?? null) : void 0;
+    }
+    if (key === "ONE_SETUP_FILE_NATIVE") {
+      return options.ONE_SETUP_FILE_NATIVE ? JSON.stringify(options.ONE_SETUP_FILE_NATIVE) : "undefined";
+    }
+    return void 0;
+  }
+  function walk(node, parent) {
+    if (!node || typeof node !== "object") return;
+    if (node.type === "ImportDeclaration" && parent === parsed.program) {
+      lastImportEnd = Math.max(lastImportEnd, node.end);
+    }
+    if (node.type === "MemberExpression" && node.object?.type === "MemberExpression" && !node.object.computed && node.object.object?.type === "Identifier" && node.object.object.name === "process" && node.object.property?.type === "Identifier" && node.object.property.name === "env") {
+      const key = node.computed ? node.property?.type === "Literal" && typeof node.property.value === "string" ? node.property.value : void 0 : node.property?.type === "Identifier" ? node.property.name : void 0;
+      const isAssignTarget = parent?.type === "AssignmentExpression" && parent.left === node;
+      if (key && !isAssignTarget) {
+        const replacement = replacementFor(key);
+        if (replacement !== void 0) {
+          ms.overwrite(node.start, node.end, replacement);
+        }
+      }
+    }
+    for (const k of Object.keys(node)) {
+      if (k === "start" || k === "end" || k === "loc" || k === "range" || k === "parent" || k === "comments") continue;
+      const child = node[k];
+      if (Array.isArray(child)) {
+        for (const item of child) walk(item, node);
+      } else if (child && typeof child === "object") {
+        walk(child, node);
+      }
+    }
+  }
+  walk(parsed.program, parsed.program);
+  if (isMetroEntry && options.ONE_SETUP_FILE_NATIVE) {
+    const stmt = `
+import ${JSON.stringify(options.ONE_SETUP_FILE_NATIVE)};`;
+    if (lastImportEnd >= 0) {
+      ms.appendRight(lastImportEnd, stmt);
+    } else {
+      ms.prepend(`${stmt}
+`);
+    }
+  }
+  return ms.toString();
+}
+function collectPatternNames(pattern, names) {
+  if (!pattern) return;
+  if (pattern.type === "Identifier") {
+    names.add(pattern.name);
+  } else if (pattern.type === "AssignmentPattern") {
+    collectPatternNames(pattern.left, names);
+  } else if (pattern.type === "ObjectPattern") {
+    for (const prop of pattern.properties || []) {
+      if (prop.type === "Property") collectPatternNames(prop.value, names);else if (prop.type === "RestElement") collectPatternNames(prop.argument, names);
+    }
+  } else if (pattern.type === "ArrayPattern") {
+    for (const elem of pattern.elements || []) {
+      if (elem) collectPatternNames(elem, names);
+    }
+  } else if (pattern.type === "RestElement") {
+    collectPatternNames(pattern.argument, names);
+  }
+}
+function collectHoistedBindings(node, names) {
+  function traverse(n) {
+    if (!n || typeof n !== "object") return;
+    if (n === node) {} else if (n.type === "FunctionDeclaration" || n.type === "FunctionExpression" || n.type === "ArrowFunctionExpression") {
+      if (n.type === "FunctionDeclaration" && n.id?.name) {
+        names.add(n.id.name);
+      }
+      return;
+    }
+    if (n.type === "VariableDeclaration" && n.kind === "var") {
+      for (const decl of n.declarations || []) {
+        collectPatternNames(decl.id, names);
+      }
+    }
+    for (const key of Object.keys(n)) {
+      if (key === "start" || key === "end" || key === "loc" || key === "range" || key === "parent" || key === "comments") continue;
+      const child = n[key];
+      if (Array.isArray(child)) {
+        for (const item of child) traverse(item);
+      } else if (child && typeof child === "object") {
+        traverse(child);
+      }
+    }
+  }
+  traverse(node);
+}
+function collectBlockBindings(statements, names) {
+  if (!Array.isArray(statements)) return;
+  for (const stmt of statements) {
+    if (!stmt) continue;
+    if (stmt.type === "VariableDeclaration" && stmt.kind !== "var") {
+      for (const decl of stmt.declarations || []) {
+        collectPatternNames(decl.id, names);
+      }
+    } else if (stmt.type === "ClassDeclaration" && stmt.id?.name) {
+      names.add(stmt.id.name);
+    } else if (stmt.type === "FunctionDeclaration" && stmt.id?.name) {
+      names.add(stmt.id.name);
+    }
+  }
+}
+class ScopeTracker {
+  stack = [/* @__PURE__ */new Set()];
+  enter(initialBindings) {
+    this.stack.push(new Set(initialBindings));
+  }
+  exit() {
+    if (this.stack.length > 1) {
+      this.stack.pop();
+    }
+  }
+  add(name) {
+    this.stack[this.stack.length - 1].add(name);
+  }
+  currentScope() {
+    return this.stack[this.stack.length - 1];
+  }
+  addPattern(pattern) {
+    collectPatternNames(pattern, this.currentScope());
+  }
+  isShadowed(name) {
+    for (let i = this.stack.length - 1; i >= 0; i--) {
+      if (this.stack[i].has(name)) return true;
+    }
+    return false;
+  }
+}
+function getCacheKey(config = {}, opts) {
+  const hash = import_node_crypto.default.createHash("sha256");
+  hash.update("metroNativeWorker");
+  hash.update(WORKER_CACHE_KEY_VERSION);
+  if (config.globalPrefix) {
+    hash.update(config.globalPrefix);
+  }
+  if (config.unstable_dependencyMapReservedName) {
+    hash.update(config.unstable_dependencyMapReservedName);
+  }
+  if (config.minifierPath) {
+    hash.update(config.minifierPath);
+  }
+  if (opts?.projectRoot) {
+    hash.update(opts.projectRoot);
+  }
+  return hash.digest("hex");
+}
+function convertSourceMapToMetroRawMappings(composedMap) {
+  if (!composedMap) return [];
+  const tracer = new import_trace_mapping.TraceMap(composedMap);
+  const rawMappings = [];
+  (0, import_trace_mapping.eachMapping)(tracer, m => {
+    if (m.originalLine == null) {
+      rawMappings.push([m.generatedLine, m.generatedColumn]);
+    } else if (m.name == null) {
+      rawMappings.push([m.generatedLine, m.generatedColumn, m.originalLine, m.originalColumn]);
+    } else {
+      rawMappings.push([m.generatedLine, m.generatedColumn, m.originalLine, m.originalColumn, m.name]);
+    }
+  });
+  rawMappings.sort((a, b) => {
+    if (a[0] !== b[0]) return a[0] - b[0];
+    return a[1] - b[1];
+  });
+  const deduped = [];
+  for (const mapping of rawMappings) {
+    const prev = deduped[deduped.length - 1];
+    if (prev && prev[0] === mapping[0] && prev[1] === mapping[1]) {
+      continue;
+    }
+    deduped.push(mapping);
+  }
+  return deduped;
+}
+function countLinesAndTerminateMap(code, map = []) {
+  const NEWLINE = /\r\n?|\n|\u2028|\u2029/g;
+  let lineCount = 1;
+  let lastLineStart = 0;
+  for (const match of code.matchAll(NEWLINE)) {
+    lineCount++;
+    lastLineStart = match.index + match[0].length;
+  }
+  const lastLineLength = code.length - lastLineStart;
+  const lastLineIndex1Based = lineCount;
+  const lastLineNextColumn0Based = lastLineLength;
+  const lastMapping = map[map.length - 1];
+  const terminatingMapping = [lastLineIndex1Based, lastLineNextColumn0Based];
+  if (!lastMapping || lastMapping[0] !== terminatingMapping[0] || lastMapping[1] !== terminatingMapping[1]) {
+    return {
+      lineCount,
+      map: map.concat([terminatingMapping])
+    };
+  }
+  return {
+    lineCount,
+    map: [...map]
+  };
+}
+function wrapJson(source, options) {
+  const globalPrefix = options?.globalPrefix || "";
+  const factory = ["function (global, require, _importDefaultUnused, _importAllUnused, module, exports, _dependencyMapUnused) {", `  module.exports = ${source};`, "}"].join("\n");
+  if (options?.moduleId !== void 0) {
+    const depIds = options.dependencyIds ? JSON.stringify(options.dependencyIds) : "[]";
+    return `${globalPrefix}__d(${factory}, ${JSON.stringify(options.moduleId)}, ${depIds});`;
+  }
+  return `${globalPrefix}__d(${factory});`;
+}
+function wrapModule(code, options) {
+  const globalPrefix = options?.globalPrefix || "";
+  const depMap = options?.dependencyMapName || "_dependencyMap";
+  const header = `function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, ${depMap}) {`;
+  const requireAlias = options?.requireAlias !== false ? "var require = _$$_REQUIRE;\n" : "";
+  const footer = `}`;
+  if (options?.moduleId !== void 0) {
+    const depIds = options.dependencyIds ? JSON.stringify(options.dependencyIds) : "[]";
+    return `${globalPrefix}__d(${header}
+${requireAlias}${code}
+${footer}, ${JSON.stringify(options.moduleId)}, ${depIds});`;
+  }
+  return `${globalPrefix}__d(${header}
+${requireAlias}${code}
+${footer});`;
+}
+function getDependencyKey(name, isESM, asyncType = null, contextParams) {
+  let key = `${name}\0${isESM ? "import" : "require"}`;
+  if (asyncType != null) {
+    key += `\0${asyncType}`;
+  }
+  if (contextParams) {
+    key += ["", "context", String(contextParams.recursive), String(contextParams.filter.pattern), String(contextParams.filter.flags), contextParams.mode].join("\0");
+  }
+  return key;
+}
+function rewriteDependencyCalls(code, dependencies, depMapName = "_dependencyMap", filename = "module.js", asyncRequirePath = "metro-runtime/src/modules/asyncRequire") {
+  const ms = new import_magic_string.default(code);
+  const emptyResult = {
+    code,
+    map: ms.generateMap({
+      source: filename,
+      hires: true,
+      includeContent: true
+    }),
+    toString() {
+      return code;
+    }
+  };
+  if (dependencies.length === 0) return emptyResult;
+  let parsed;
+  try {
+    parsed = (0, import_oxc_parser.parseSync)(filename, code, {
+      lang: langForFilename(filename)
+    });
+  } catch (err) {
+    throw new Error(`[vxrn/metro] Failed to parse ${filename} for dependency rewriting: ${err.message || err}`);
+  }
+  if (parsed?.errors?.length) {
+    throw new Error(`[vxrn/metro] Failed to parse ${filename} for dependency rewriting: ${parsed.errors[0].message}`);
+  }
+  if (!parsed?.program) return emptyResult;
+  const contextLiteralBindings = collectModuleLiteralBindings(parsed.program);
+  const scopeTracker = new ScopeTracker();
+  collectHoistedBindings(parsed.program, scopeTracker.currentScope());
+  collectBlockBindings(parsed.program.body, scopeTracker.currentScope());
+  for (const stmt of parsed.program.body || []) {
+    if (stmt.type === "ImportDeclaration") {
+      for (const spec of stmt.specifiers || []) {
+        if (spec.local?.name) {
+          scopeTracker.add(spec.local.name);
+        }
+      }
+    }
+  }
+  function walk(node) {
+    if (!node || typeof node !== "object") return;
+    let pushedScope = false;
+    if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+      scopeTracker.enter();
+      pushedScope = true;
+      for (const param of node.params || []) {
+        scopeTracker.addPattern(param);
+      }
+      if (node.type === "FunctionExpression" && node.id?.name) {
+        scopeTracker.add(node.id.name);
+      }
+      if (node.body) {
+        collectHoistedBindings(node.body, scopeTracker.currentScope());
+      }
+    } else if (node.type === "BlockStatement") {
+      scopeTracker.enter();
+      pushedScope = true;
+      collectBlockBindings(node.body, scopeTracker.currentScope());
+    } else if (node.type === "CatchClause") {
+      scopeTracker.enter();
+      pushedScope = true;
+      if (node.param) {
+        scopeTracker.addPattern(node.param);
+      }
+    } else if (node.type === "ForStatement" || node.type === "ForInStatement" || node.type === "ForOfStatement") {
+      const decl = node.type === "ForStatement" ? node.init : node.left;
+      if (decl?.type === "VariableDeclaration" && decl.kind !== "var") {
+        scopeTracker.enter();
+        pushedScope = true;
+        for (const d of decl.declarations || []) {
+          scopeTracker.addPattern(d.id);
+        }
+      }
+    }
+    if (node.type === "ImportExpression" && node.source?.type === "Literal" && typeof node.source.value === "string") {
+      const depName = node.source.value;
+      const depKey = getDependencyKey(depName, true, "async");
+      const dep = dependencies.find(d => d.data.key === depKey) || dependencies.find(d => d.name === depName && d.data.asyncType === "async");
+      const asyncKey = getDependencyKey(asyncRequirePath, false, null);
+      const asyncDep = dependencies.find(d => d.data.key === asyncKey) || dependencies.find(d => d.name === asyncRequirePath && d.data.asyncType == null);
+      if (dep && asyncDep) {
+        const depIndex = dep.data.index ?? dependencies.indexOf(dep);
+        const asyncIndex = asyncDep.data.index ?? dependencies.indexOf(asyncDep);
+        ms.overwrite(node.start, node.end, `require(${depMapName}[${asyncIndex}], ${JSON.stringify(asyncRequirePath)})(${depMapName}[${depIndex}], ${depMapName}.paths, ${JSON.stringify(depName)})`);
+      }
+    } else if (node.type === "CallExpression" && node.callee?.type === "Identifier" && node.callee.name === "require" && !scopeTracker.isShadowed("require") && node.arguments?.length >= 1) {
+      const arg = node.arguments[0];
+      if (arg.type === "Literal" && typeof arg.value === "string") {
+        const depKey = getDependencyKey(arg.value, false, null);
+        const dep = dependencies.find(d => d.data.key === depKey) || dependencies.find(d => d.name === arg.value && d.data.asyncType == null);
+        if (dep) {
+          const index = dep.data.index ?? dependencies.indexOf(dep);
+          ms.overwrite(arg.start, arg.end, `${depMapName}[${index}], ${JSON.stringify(arg.value)}`);
+        }
+      }
+    } else if (
+    // metro rewrites require.context(dir, ...) down to a plain require of the
+    // single context module it registered for that directory.
+    node.type === "CallExpression" && node.callee?.type === "MemberExpression" && !node.callee.computed && node.callee.object?.type === "Identifier" && node.callee.object.name === "require" && node.callee.property?.type === "Identifier" && node.callee.property.name === "context" && !scopeTracker.isShadowed("require") && node.arguments?.length >= 1) {
+      const arg = node.arguments[0]?.type === "Identifier" ? contextLiteralBindings.get(node.arguments[0].name) : node.arguments[0];
+      if (arg?.type === "Literal" && typeof arg.value === "string") {
+        const dep = dependencies.find(d => d.name === arg.value && d.data.contextParams != null);
+        if (dep) {
+          const index = dep.data.index ?? dependencies.indexOf(dep);
+          ms.overwrite(node.start, node.end, `require(${depMapName}[${index}], ${JSON.stringify(arg.value)})`);
+        }
+      }
+    }
+    for (const key of Object.keys(node)) {
+      if (key === "start" || key === "end" || key === "loc" || key === "range" || key === "parent" || key === "comments") continue;
+      const child = node[key];
+      if (Array.isArray(child)) {
+        for (const item of child) walk(item);
+      } else if (child && typeof child === "object") {
+        walk(child);
+      }
+    }
+    if (pushedScope) {
+      scopeTracker.exit();
+    }
+  }
+  walk(parsed.program);
+  const resultString = ms.toString();
+  const map = ms.generateMap({
+    source: filename,
+    hires: true,
+    includeContent: true
+  });
+  return {
+    code: resultString,
+    map,
+    toString() {
+      return resultString;
+    }
+  };
+}
+function extractDependencies(code, filename, options) {
+  const asyncRequirePath = options?.asyncRequireModulePath || "metro-runtime/src/modules/asyncRequire";
+  const allowOptionalDependencies = options?.allowOptionalDependencies;
+  const lineOffsets = [0];
+  for (let i = 0; i < code.length; i++) {
+    if (code[i] === "\n") {
+      lineOffsets.push(i + 1);
+    }
+  }
+  function offsetToLoc(pos) {
+    let low = 0;
+    let high = lineOffsets.length - 1;
+    while (low <= high) {
+      const mid = low + high >> 1;
+      if (lineOffsets[mid] <= pos) {
+        low = mid + 1;
+      } else {
+        high = mid - 1;
+      }
+    }
+    const line = high + 1;
+    const column = pos - lineOffsets[high];
+    return {
+      line,
+      column
+    };
+  }
+  let parseResult;
+  try {
+    parseResult = (0, import_oxc_parser.parseSync)(filename, code, {
+      lang: langForFilename(filename)
+    });
+  } catch (err) {
+    throw new Error(`[vxrn/metro] Failed to parse ${filename} for dependency extraction: ${err.message || err}`);
+  }
+  if (parseResult?.errors?.length) {
+    throw new Error(`[vxrn/metro] Failed to parse ${filename} for dependency extraction: ${parseResult.errors[0].message}`);
+  }
+  if (!parseResult?.program) {
+    return [];
+  }
+  const depMap = /* @__PURE__ */new Map();
+  function addDep(name, isESM, asyncType, start, end, contextParams, isOptional) {
+    const key = getDependencyKey(name, isESM, asyncType, contextParams);
+    let entry = depMap.get(key);
+    const loc = {
+      start: offsetToLoc(start),
+      end: offsetToLoc(end)
+    };
+    if (!entry) {
+      entry = {
+        name,
+        data: {
+          key,
+          asyncType,
+          locs: [loc],
+          isESMImportAtSource: isESM,
+          isESMImport: isESM,
+          index: depMap.size,
+          ...(contextParams ? {
+            contextParams
+          } : {}),
+          ...(isOptional ? {
+            isOptional: true
+          } : {})
+        }
+      };
+      depMap.set(key, entry);
+    } else {
+      entry.data.locs.push(loc);
+    }
+  }
+  const moduleConsts = collectModuleLiteralBindings(parseResult.program);
+  function resolveConst(node) {
+    if (node?.type === "Identifier") return moduleConsts.get(node.name);
+    return node;
+  }
+  const ancestors = [];
+  function isOptionalHere(name) {
+    if (!allowOptionalDependencies) return false;
+    if (Array.isArray(allowOptionalDependencies.exclude)) {
+      if (allowOptionalDependencies.exclude.includes(name)) return false;
+    }
+    let sCount = 0;
+    for (let i = ancestors.length - 1; i >= 0 && sCount < 3; i--) {
+      const n = ancestors[i];
+      const isStatement = /(?:Statement|Declaration)$/.test(n.type);
+      if (!isStatement) continue;
+      if (n.type === "BlockStatement") {
+        const parent = ancestors[i - 1];
+        return parent?.type === "TryStatement" && parent.block === n;
+      }
+      sCount += 1;
+    }
+    return false;
+  }
+  const scopeTracker = new ScopeTracker();
+  collectHoistedBindings(parseResult.program, scopeTracker.currentScope());
+  collectBlockBindings(parseResult.program.body, scopeTracker.currentScope());
+  for (const stmt of parseResult.program.body || []) {
+    if (stmt.type === "ImportDeclaration") {
+      for (const spec of stmt.specifiers || []) {
+        if (spec.local?.name) {
+          scopeTracker.add(spec.local.name);
+        }
+      }
+    }
+  }
+  function walk(node) {
+    if (!node || typeof node !== "object") return;
+    let pushedScope = false;
+    ancestors.push(node);
+    if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+      scopeTracker.enter();
+      pushedScope = true;
+      for (const param of node.params || []) {
+        scopeTracker.addPattern(param);
+      }
+      if (node.type === "FunctionExpression" && node.id?.name) {
+        scopeTracker.add(node.id.name);
+      }
+      if (node.body) {
+        collectHoistedBindings(node.body, scopeTracker.currentScope());
+      }
+    } else if (node.type === "BlockStatement") {
+      scopeTracker.enter();
+      pushedScope = true;
+      collectBlockBindings(node.body, scopeTracker.currentScope());
+    } else if (node.type === "CatchClause") {
+      scopeTracker.enter();
+      pushedScope = true;
+      if (node.param) {
+        scopeTracker.addPattern(node.param);
+      }
+    } else if (node.type === "ForStatement" || node.type === "ForInStatement" || node.type === "ForOfStatement") {
+      const decl = node.type === "ForStatement" ? node.init : node.left;
+      if (decl?.type === "VariableDeclaration" && decl.kind !== "var") {
+        scopeTracker.enter();
+        pushedScope = true;
+        for (const d of decl.declarations || []) {
+          scopeTracker.addPattern(d.id);
+        }
+      }
+    }
+    if (node.type === "ImportDeclaration" && node.source?.value) {
+      if (node.importKind !== "type") {
+        const hasValueSpecifier = !node.specifiers?.length || node.specifiers.some(s => s.importKind !== "type");
+        if (hasValueSpecifier) {
+          addDep(node.source.value, true, null, node.start, node.end);
+        }
+      }
+    } else if ((node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration") && node.source?.value) {
+      if (node.exportKind !== "type") {
+        addDep(node.source.value, true, null, node.start, node.end);
+      }
+    } else if (node.type === "ImportExpression") {
+      if (node.source?.type === "Literal" && typeof node.source.value === "string") {
+        addDep(node.source.value, true, "async", node.start, node.end);
+        addDep(asyncRequirePath, false, null, node.start, node.end);
+      } else {
+        throw new Error(`[vxrn/metro] Dynamic import with non-string literal is not supported by Metro in ${filename}`);
+      }
+    } else if (node.type === "CallExpression" && node.callee?.type === "Identifier" && node.callee.name === "require" && !scopeTracker.isShadowed("require")) {
+      if (node.arguments?.[0]?.type === "Literal" && typeof node.arguments[0].value === "string") {
+        addDep(node.arguments[0].value, false, null, node.start, node.end, void 0, node.arguments[0].value !== asyncRequirePath && isOptionalHere(node.arguments[0].value));
+      }
+    } else if (
+    // require.context(dir, recursive?, filter?, mode?) registers a whole
+    // directory as one dependency. one's router entry uses it for the route
+    // tree, so dropping it silently omits every route from the bundle.
+    node.type === "CallExpression" && node.callee?.type === "MemberExpression" && !node.callee.computed && node.callee.object?.type === "Identifier" && node.callee.object.name === "require" && node.callee.property?.type === "Identifier" && node.callee.property.name === "context" && !scopeTracker.isShadowed("require")) {
+      const args = node.arguments || [];
+      const dir = resolveConst(args[0]);
+      if (dir?.type !== "Literal" || typeof dir.value !== "string") {
+        throw new Error(`[vxrn/metro] First argument of require.context must be a string literal in ${filename}`);
+      }
+      if (args.length > 4) {
+        throw new Error(`[vxrn/metro] Too many arguments provided to require.context in ${filename}. Expected 4, got: ${args.length}`);
+      }
+      let recursive = true;
+      const recursiveArg = resolveConst(args[1]);
+      if (recursiveArg) {
+        if (recursiveArg.type !== "Literal" || typeof recursiveArg.value !== "boolean") {
+          throw new Error(`[vxrn/metro] Second argument of require.context must be an optional boolean literal in ${filename}`);
+        }
+        recursive = recursiveArg.value;
+      }
+      let filter = {
+        pattern: ".*",
+        flags: ""
+      };
+      const filterArg = resolveConst(args[2]);
+      if (filterArg) {
+        if (filterArg.type !== "Literal" || !filterArg.regex) {
+          throw new Error(`[vxrn/metro] Third argument of require.context must be an optional RegExp literal in ${filename}, instead found node of type: ${filterArg.type}`);
+        }
+        filter = {
+          pattern: filterArg.regex.pattern,
+          flags: filterArg.regex.flags || ""
+        };
+      }
+      let mode = "sync";
+      const modeArg = resolveConst(args[3]);
+      if (modeArg) {
+        const m = modeArg.type === "Literal" ? modeArg.value : void 0;
+        if (m !== "sync" && m !== "eager" && m !== "lazy" && m !== "lazy-once") {
+          throw new Error(`[vxrn/metro] require.context mode must be one of sync, eager, lazy, lazy-once in ${filename}`);
+        }
+        mode = m;
+      }
+      addDep(dir.value, false, null, node.start, node.end, {
+        recursive,
+        filter,
+        mode
+      });
+    }
+    for (const key of Object.keys(node)) {
+      if (key === "start" || key === "end" || key === "loc" || key === "range" || key === "parent" || key === "comments") continue;
+      const child = node[key];
+      if (Array.isArray(child)) {
+        for (const item of child) walk(item);
+      } else if (child && typeof child === "object") {
+        walk(child);
+      }
+    }
+    ancestors.pop();
+    if (pushedScope) {
+      scopeTracker.exit();
+    }
+  }
+  walk(parseResult.program);
+  return Array.from(depMap.values());
+}
+function checkReservedStrings(sourceCode, config, options) {
+  const reservedStrings = [];
+  if (options.customTransformOptions?.unstable_staticHermesOptimizedRequire === true) {
+    reservedStrings.push("_$$_METRO_MODULE_ID");
+  }
+  if (config.unstable_dependencyMapReservedName != null) {
+    reservedStrings.push(config.unstable_dependencyMapReservedName);
+  }
+  for (const reservedString of reservedStrings) {
+    const position = sourceCode.indexOf(reservedString);
+    if (position > -1) {
+      throw new SyntaxError("Source code contains the reserved string `" + reservedString + "` at character offset " + position);
+    }
+  }
+}
+let workletsConfigured = false;
+let oneNativeTransforms;
+function loadOneNativeTransforms(projectRoot) {
+  if (oneNativeTransforms !== void 0) return oneNativeTransforms;
+  try {
+    const req = (0, import_node_module.createRequire)(import_node_path.default.resolve(projectRoot, "package.json"));
+    oneNativeTransforms = req("one/native-transforms");
+  } catch {
+    oneNativeTransforms = null;
+  }
+  return oneNativeTransforms;
+}
+async function configureWorkletsForWorker(projectRoot) {
+  if (workletsConfigured) return;
+  workletsConfigured = true;
+  if (!projectRoot) return;
+  const req = (0, import_node_module.createRequire)(import_node_path.default.resolve(projectRoot, "package.json"));
+  let hasReanimated = false;
+  try {
+    req.resolve("react-native-reanimated/package.json");
+    hasReanimated = true;
+  } catch {
+    try {
+      req.resolve("react-native-worklets/package.json");
+      hasReanimated = true;
+    } catch {}
+  }
+  const {
+    configureVXRNCompilerPlugin
+  } = await import("@vxrn/compiler");
+  configureVXRNCompilerPlugin({
+    enableReanimated: hasReanimated
+  });
+}
+async function transform(config, projectRoot, filename, data, options) {
+  assertNoUnportedBabelPlugins(options);
+  let sourceCode = typeof data === "string" ? data : data.toString("utf8");
+  const environment = options.customTransformOptions?.environment;
+  const isClientEnvironment = environment !== "node" && environment !== "react-server";
+  if (isClientEnvironment && /[\\/]expo[\\/]virtual[\\/]env\.js$/.test(filename)) {
+    if (options.dev) {
+      const rel = import_node_path.default.relative(import_node_path.default.dirname(filename), projectRoot).split(import_node_path.default.sep).join("/");
+      sourceCode = `const dotEnvModules = require.context(${JSON.stringify(rel)},false,/^\\.\\/\\.env/);
+export const env = !dotEnvModules.keys().length ? process.env : { ...process.env, ...['.env', '.env.development', '.env.local', '.env.development.local'].reduce((acc, file) => {
+  return { ...acc, ...(dotEnvModules(file)?.default ?? {}) };
+}, {}) };`;
+    } else {
+      sourceCode = `export const env = new Proxy({}, {
+  get(target, key) {
+    throw new Error(\`Attempting to access internal environment variable "\${String(key)}" is not supported in production bundles.\`);
+  },
+});`;
+    }
+  } else if (/(^|[\\/])\.env(\.(local|(development|production)(\.local)?))?$/.test(filename)) {
+    const {
+      parseEnvFile
+    } = await import("@expo/metro-config/build/transform-worker/dot-env-development");
+    sourceCode = `export default ${JSON.stringify(parseEnvFile(sourceCode, isClientEnvironment))};`;
+  }
+  checkReservedStrings(sourceCode, config, options);
+  if (filename.endsWith(".json")) {
+    try {
+      JSON.parse(sourceCode);
+    } catch (err) {
+      throw new Error(`[vxrn/metro] JSON parse error in ${filename}: ${err.message || err}`);
+    }
+    let code2 = config.unstable_disableModuleWrapping === true ? `module.exports = ${sourceCode};` : wrapJson(sourceCode, {
+      globalPrefix: config.globalPrefix,
+      moduleId: options.moduleId,
+      dependencyIds: options.dependencyIds
+    });
+    if (options.minify && options.unstable_transformProfile !== "hermes-canary" && options.unstable_transformProfile !== "hermes-stable" && config.minifierPath) {
+      try {
+        const minifier = require(config.minifierPath);
+        const minified = await minifier({
+          code: code2,
+          config: config.minifierConfig,
+          filename
+        });
+        code2 = minified.code;
+      } catch (err) {
+        throw new Error(`[vxrn/metro] Minifier failed for ${filename}: ${err.message || err}`);
+      }
+    }
+    const {
+      lineCount: lineCount2,
+      map: map2
+    } = countLinesAndTerminateMap(code2, []);
+    const outputType = options.type === "asset" ? "js/module/asset" : options.type === "script" ? "js/script" : "js/module";
+    return {
+      dependencies: [],
+      output: [{
+        data: {
+          code: code2,
+          lineCount: lineCount2,
+          map: map2,
+          functionMap: null
+        },
+        type: outputType
+      }]
+    };
+  }
+  if (options.type === "asset") {
+    const assetRegistryPath = config.assetRegistryPath || "react-native/Libraries/Image/AssetRegistry";
+    let properDescriptor = null;
+    const absolutePath = import_node_path.default.resolve(projectRoot, filename);
+    if (import_node_fs.default.existsSync(absolutePath)) {
+      try {
+        let getAssetData;
+        try {
+          getAssetData = require("metro/private/Assets").getAssetData;
+        } catch {
+          getAssetData = require("metro/src/Assets").getAssetData;
+        }
+        if (typeof getAssetData === "function") {
+          const rawData = await getAssetData(absolutePath, filename, config.assetPlugins || [], options.platform || "", config.publicPath || "/assets");
+          const copied = {
+            ...rawData
+          };
+          delete copied.files;
+          delete copied.fileSystemLocation;
+          delete copied.path;
+          properDescriptor = copied;
+        }
+      } catch (err) {
+        throw new Error(`[vxrn/metro] Asset resolution failed for ${filename}: ${err.message || err}`);
+      }
+    }
+    if (!properDescriptor) {
+      const ext = import_node_path.default.extname(filename).slice(1);
+      const name = import_node_path.default.basename(filename, "." + ext);
+      properDescriptor = {
+        __packager_asset: true,
+        httpServerLocation: config.publicPath || "/assets",
+        width: void 0,
+        height: void 0,
+        scales: [1],
+        hash: import_node_crypto.default.createHash("md5").update(sourceCode).digest("hex"),
+        name,
+        type: ext
+      };
+    }
+    const assetDepMapName = config.unstable_dependencyMapReservedName || "_dependencyMap";
+    const assetCode = `module.exports = require(${assetDepMapName}[0], ${JSON.stringify(assetRegistryPath)}).registerAsset(${JSON.stringify(properDescriptor)});`;
+    let code2 = config.unstable_disableModuleWrapping === true ? assetCode : wrapModule(assetCode, {
+      globalPrefix: config.globalPrefix,
+      moduleId: options.moduleId,
+      dependencyIds: options.dependencyIds,
+      dependencyMapName: config.unstable_dependencyMapReservedName
+    });
+    const dependencies2 = [{
+      name: assetRegistryPath,
+      data: {
+        key: getDependencyKey(assetRegistryPath, false, null),
+        asyncType: null,
+        locs: [],
+        isESMImportAtSource: false,
+        isESMImport: false,
+        index: 0
+      }
+    }];
+    const {
+      lineCount: lineCount2,
+      map: map2
+    } = countLinesAndTerminateMap(code2, []);
+    return {
+      dependencies: dependencies2,
+      output: [{
+        data: {
+          code: code2,
+          lineCount: lineCount2,
+          map: map2,
+          functionMap: null
+        },
+        type: "js/module/asset"
+      }]
+    };
+  }
+  let code = sourceCode;
+  const intermediateMaps = [];
+  for (const nativeTransform of getNativeTransforms(options, projectRoot)) {
+    const out = nativeTransform(code, {
+      // absolute, unlike metro's own project-relative name. a transform that
+      // matches on paths (include/exclude lists, node_modules skips) or stamps
+      // a location into the output would otherwise get a different answer here
+      // than the babel plugin it replaced, which is handed an absolute path.
+      filename: import_node_path.default.isAbsolute(filename) ? filename : import_node_path.default.resolve(projectRoot, filename),
+      platform: options.platform,
+      dev: options.dev,
+      projectRoot
+    });
+    if (typeof out === "string") code = out;
+  }
+  const oneRouterOptions = getOneRouterMetroOptions(options);
+  if (oneRouterOptions) {
+    code = applyOneRouterMetro(code, filename, oneRouterOptions);
+  }
+  try {
+    const codegenRes = (0, import_compiler.transformReactNativeCodegen)(code, filename, projectRoot);
+    if (codegenRes?.code) {
+      code = codegenRes.code;
+      if (codegenRes.map) {
+        intermediateMaps.push(codegenRes.map);
+      }
+    }
+  } catch (err) {
+    throw new Error(`[vxrn/metro] React Native codegen failed for ${filename}: ${err.message || err}`);
+  }
+  if ((0, import_compiler.shouldStripFlow)(filename, code)) {
+    try {
+      const fft = await import("fast-flow-transform");
+      const flowTransform = fft.default || fft;
+      const flowResult = await flowTransform({
+        filename,
+        source: code,
+        sourcemap: true,
+        dialect: "flow",
+        format: "pretty"
+      });
+      if (flowResult?.code) {
+        code = flowResult.code;
+        if (flowResult.map) {
+          intermediateMaps.push(typeof flowResult.map === "string" ? JSON.parse(flowResult.map) : flowResult.map);
+        }
+      }
+    } catch (err) {
+      throw new Error(`[vxrn/metro] Flow transform failed for ${filename}: ${err.message || err}`);
+    }
+  }
+  const asyncRequirePath = config.asyncRequireModulePath || "metro-runtime/src/modules/asyncRequire";
+  const aliases = getModuleResolverAliases(options);
+  if (aliases && projectRoot) {
+    const aliasKeys = Object.keys(aliases);
+    if (aliasKeys.some(k => code.includes(k.endsWith("$") ? k.slice(0, -1) : k))) {
+      code = applyModuleResolverAliases(code, filename, projectRoot, aliases);
+    }
+  }
+  if (code.includes("process.env") || code.includes("import.meta")) {
+    code = applyInlineEnvVars(code, filename, !options.dev, getImportMetaEnv(options));
+  }
+  if (code.includes("-only")) {
+    code = applyEnvironmentGuard(code, filename);
+  }
+  const serverCodeRouterRoot = getRemoveServerCodeRouterRoot(options);
+  if (serverCodeRouterRoot && projectRoot && !filename.includes("node_modules")) {
+    const oneNativeTransforms2 = loadOneNativeTransforms(projectRoot);
+    if (oneNativeTransforms2) {
+      const shaken = await oneNativeTransforms2.transformTreeShakeClient(code, filename, projectRoot, serverCodeRouterRoot);
+      if (shaken?.code) {
+        code = shaken.code;
+      }
+    }
+  }
+  const dependencies = extractDependencies(code, filename, {
+    asyncRequireModulePath: asyncRequirePath,
+    allowOptionalDependencies: config.allowOptionalDependencies
+  });
+  await configureWorkletsForWorker(projectRoot);
+  let shouldRunWorklets = Boolean(options.customTransformOptions?.worklets);
+  if (!shouldRunWorklets) {
+    const {
+      shouldTransformWorklets
+    } = await import("@vxrn/compiler");
+    shouldRunWorklets = shouldTransformWorklets({
+      id: filename,
+      code
+    });
+  }
+  const shouldRunReactCompiler = Boolean(options.customTransformOptions?.reactCompiler) || hasBabelPlugin(options, "babel-plugin-react-compiler") && isReactCompilerCandidate(filename) || code.includes('"use memo"') || code.includes("'use memo'");
+  if (shouldRunReactCompiler) {
+    try {
+      const {
+        prepareWorkletsForReactCompiler,
+        transformOxcReactCompiler
+      } = await import("@vxrn/compiler");
+      if (shouldRunWorklets) {
+        const prepared = prepareWorkletsForReactCompiler(filename, code, true);
+        if (prepared) {
+          code = prepared.code;
+          if (prepared.map) intermediateMaps.push(prepared.map);
+        }
+      }
+      const compilerRes = await transformOxcReactCompiler(filename, code, "19", true);
+      if (compilerRes?.code) {
+        code = compilerRes.code;
+        if (compilerRes.map) {
+          intermediateMaps.push(typeof compilerRes.map === "string" ? JSON.parse(compilerRes.map) : compilerRes.map);
+        }
+      }
+    } catch (err) {
+      throw new Error(`[vxrn/metro] React Compiler failed for ${filename}: ${err.message || err}`);
+    }
+  }
+  if (shouldRunWorklets) {
+    try {
+      const {
+        transformWorklets
+      } = await import("@vxrn/compiler");
+      const workletRes = await transformWorklets(filename, code, true, {
+        projectRoot
+      });
+      if (workletRes?.code) {
+        code = workletRes.code;
+        if (workletRes.map) {
+          intermediateMaps.push(typeof workletRes.map === "string" ? JSON.parse(workletRes.map) : workletRes.map);
+        }
+      }
+    } catch (err) {
+      throw new Error(`[vxrn/metro] Worklets transform failed for ${filename}: ${err.message || err}`);
+    }
+  }
+  const lang = langForFilename(filename);
+  const {
+    transformSync: oxcTransform
+  } = await import("oxc-transform");
+  let oxcRes;
+  try {
+    oxcRes = oxcTransform(filename, code, {
+      lang,
+      target: "es2020",
+      assumptions: {
+        setPublicClassFields: true
+      },
+      jsx: {
+        runtime: "automatic",
+        development: Boolean(options.dev)
+      },
+      sourcemap: true
+    });
+  } catch (err) {
+    throw new Error(`[vxrn/metro] Oxc transform failed for ${filename}: ${err.message || err}`);
+  }
+  if (oxcRes.errors?.length) {
+    throw new Error(`[vxrn/metro] Oxc transform failed for ${filename}: ${oxcRes.errors[0].message || oxcRes.errors[0]}`);
+  }
+  code = oxcRes.code || code;
+  if (oxcRes.map) {
+    intermediateMaps.push(typeof oxcRes.map === "string" ? JSON.parse(oxcRes.map) : oxcRes.map);
+  }
+  try {
+    const esbuildRes = await (0, import_compiler.transformHermesAsync)(code, filename, true, options.type === "script" ? void 0 : "cjs");
+    if (esbuildRes) {
+      code = esbuildRes.code;
+      if (esbuildRes.map) {
+        intermediateMaps.push(esbuildRes.map);
+      }
+    }
+  } catch (err) {
+    throw new Error(`[vxrn/metro] native async/CJS lowering failed for ${filename}: ${err.message || err}`);
+  }
+  try {
+    const loopsRes = (0, import_compiler.transformHermesLoops)(code, filename);
+    if (loopsRes) {
+      code = loopsRes.code;
+      for (const map2 of loopsRes.maps) {
+        intermediateMaps.push(map2);
+      }
+    }
+  } catch (err) {
+    throw new Error(`[vxrn/metro] Hermes loop-binding transform failed for ${filename}: ${err.message || err}`);
+  }
+  const finalDeps = extractDependencies(code, filename, {
+    asyncRequireModulePath: asyncRequirePath,
+    allowOptionalDependencies: config.allowOptionalDependencies
+  });
+  const finalNames = new Set(finalDeps.map(d => d.name));
+  const reconciled = dependencies.filter(d => finalNames.has(d.name));
+  for (const injected of finalDeps) {
+    if (reconciled.some(d => d.name === injected.name)) continue;
+    reconciled.push(injected);
+  }
+  dependencies.length = 0;
+  for (const dep of reconciled) {
+    dependencies.push({
+      ...dep,
+      data: {
+        ...dep.data,
+        index: dependencies.length
+      }
+    });
+  }
+  const depMapName = config.unstable_dependencyMapReservedName || "_dependencyMap";
+  if (options.type === "script") {
+    const msScript = new import_magic_string.default(code);
+    msScript.prepend(`(function (global) {
+`);
+    msScript.append(`
+})(typeof globalThis !== 'undefined' ? globalThis : typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : this);`);
+    code = msScript.toString();
+    intermediateMaps.push(msScript.generateMap({
+      source: filename,
+      hires: true,
+      includeContent: true
+    }));
+  } else if (config.unstable_disableModuleWrapping === true) {
+    const rewriteRes = rewriteDependencyCalls(code, dependencies, depMapName, filename, asyncRequirePath);
+    code = rewriteRes.code;
+    if (rewriteRes.map) {
+      intermediateMaps.push(rewriteRes.map);
+    }
+  } else {
+    const rewriteRes = rewriteDependencyCalls(code, dependencies, depMapName, filename, asyncRequirePath);
+    if (rewriteRes.map) {
+      intermediateMaps.push(rewriteRes.map);
+    }
+    const msWrap = new import_magic_string.default(rewriteRes.code);
+    const globalPrefix = config.globalPrefix || "";
+    const header = `function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, ${depMapName}) {
+var require = _$$_REQUIRE;
+`;
+    const footer = `
+}`;
+    msWrap.prepend(`${globalPrefix}__d(${header}`);
+    if (options.moduleId !== void 0) {
+      const depIds = options.dependencyIds ? JSON.stringify(options.dependencyIds) : "[]";
+      msWrap.append(`${footer}, ${JSON.stringify(options.moduleId)}, ${depIds});`);
+    } else {
+      msWrap.append(`${footer});`);
+    }
+    code = msWrap.toString();
+    intermediateMaps.push(msWrap.generateMap({
+      source: filename,
+      hires: true,
+      includeContent: true
+    }));
+  }
+  if (options.minify && options.unstable_transformProfile !== "hermes-canary" && options.unstable_transformProfile !== "hermes-stable" && config.minifierPath) {
+    try {
+      const minifier = require(config.minifierPath);
+      const minified = await minifier({
+        code,
+        config: config.minifierConfig,
+        filename,
+        map: new import_magic_string.default(code).generateMap({
+          source: filename,
+          hires: true,
+          includeContent: true
+        })
+      });
+      code = minified.code;
+      if (minified.map) {
+        intermediateMaps.push(typeof minified.map === "string" ? JSON.parse(minified.map) : minified.map);
+      } else {
+        intermediateMaps.length = 0;
+      }
+    } catch (err) {
+      throw new Error(`[vxrn/metro] Minifier failed for ${filename}: ${err.message || err}`);
+    }
+  }
+  let rawMappings = [];
+  if (intermediateMaps.length > 0) {
+    const cleanMaps = intermediateMaps.map(m => typeof m === "string" ? JSON.parse(m) : m).filter(Boolean);
+    if (cleanMaps.length > 0) {
+      const composed = cleanMaps.length === 1 ? cleanMaps[0] : (0, import_remapping.default)(cleanMaps.slice().reverse(), () => null);
+      rawMappings = convertSourceMapToMetroRawMappings(composed);
+    }
+  }
+  const {
+    lineCount,
+    map
+  } = countLinesAndTerminateMap(code, rawMappings);
+  return {
+    dependencies,
+    output: [{
+      data: {
+        code,
+        lineCount,
+        map,
+        functionMap: null
+      },
+      type: options.type === "script" ? "js/script" : "js/module"
+    }]
+  };
+}
+var metroNativeWorker_default = {
+  transform,
+  getCacheKey,
+  wrapModule,
+  wrapJson,
+  extractDependencies,
+  rewriteDependencyCalls,
+  convertSourceMapToMetroRawMappings
+};