@vxrn/compiler 1.25.5 → 1.25.7

package/dist/cjs/cache.cjs

@@ -0,0 +1,132 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var cache_exports = {};
+__export(cache_exports, {
+  getCacheStats: () => getCacheStats,
+  getCachedTransform: () => getCachedTransform,
+  logCacheStats: () => logCacheStats,
+  setCachedTransform: () => setCachedTransform
+});
+module.exports = __toCommonJS(cache_exports);
+var import_node_crypto = require("node:crypto");
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var import_configure = require("./configure.cjs");
+const stats = {
+  hits: 0,
+  misses: 0,
+  writes: 0
+};
+function getCacheDir() {
+  const cacheDir = (0, import_node_path.join)(process.cwd(), "node_modules", ".vxrn", "compiler-cache");
+  if (!(0, import_node_fs.existsSync)(cacheDir)) {
+    (0, import_node_fs.mkdirSync)(cacheDir, {
+      recursive: true
+    });
+  }
+  return cacheDir;
+}
+function getConfigFingerprint() {
+  return (0, import_node_crypto.createHash)("sha1").update(JSON.stringify({
+    compiler: import_configure.configuration.enableCompiler,
+    reanimated: import_configure.configuration.enableReanimated,
+    nativewind: import_configure.configuration.enableNativewind,
+    nativeCSS: import_configure.configuration.enableNativeCSS,
+    // bump when the transform engine changes, so entries written by a
+    // previous engine aren't served for the same source
+    engine: "oxc-react-compiler"
+  })).digest("hex").slice(0, 8);
+}
+function getCacheKey(filePath, environment) {
+  const hash = (0, import_node_crypto.createHash)("sha1").update(`${environment}:${filePath}:${getConfigFingerprint()}`).digest("hex");
+  return hash;
+}
+function getContentHash(code) {
+  return (0, import_node_crypto.createHash)("sha1").update(code).digest("hex").slice(0, 16);
+}
+function getCachedTransform(filePath, code, environment) {
+  try {
+    const cleanPath = filePath.startsWith("\0") ? filePath.slice(1) : filePath;
+    const cacheDir = getCacheDir();
+    const cacheKey = getCacheKey(cleanPath, environment);
+    const cachePath = (0, import_node_path.join)(cacheDir, `${cacheKey}.json`);
+    if (!(0, import_node_fs.existsSync)(cachePath)) {
+      stats.misses++;
+      return null;
+    }
+    const cached = JSON.parse((0, import_node_fs.readFileSync)(cachePath, "utf-8"));
+    const currentMtime = (0, import_node_fs.statSync)(cleanPath).mtimeMs;
+    if (cached.mtime !== currentMtime) {
+      stats.misses++;
+      return null;
+    }
+    const currentHash = getContentHash(code);
+    if (cached.hash !== currentHash) {
+      stats.misses++;
+      return null;
+    }
+    stats.hits++;
+    return {
+      code: cached.code,
+      map: cached.map
+    };
+  } catch (err) {
+    stats.misses++;
+    return null;
+  }
+}
+function setCachedTransform(filePath, code, result, environment) {
+  try {
+    const cleanPath = filePath.startsWith("\0") ? filePath.slice(1) : filePath;
+    const cacheDir = getCacheDir();
+    const cacheKey = getCacheKey(cleanPath, environment);
+    const cachePath = (0, import_node_path.join)(cacheDir, `${cacheKey}.json`);
+    const mtime = (0, import_node_fs.statSync)(cleanPath).mtimeMs;
+    const hash = getContentHash(code);
+    const entry = {
+      mtime,
+      hash,
+      code: result.code,
+      map: result.map
+    };
+    (0, import_node_fs.writeFileSync)(cachePath, JSON.stringify(entry), "utf-8");
+    stats.writes++;
+  } catch (err) {
+    console.warn(`[cache] Failed to write cache for ${filePath}:`, err);
+  }
+}
+function getCacheStats() {
+  return {
+    ...stats
+  };
+}
+function logCacheStats() {
+  if (!process.env.DEBUG_COMPILER_PERF) {
+    return;
+  }
+  const total = stats.hits + stats.misses;
+  if (total === 0) return;
+  const hitRate = (stats.hits / total * 100).toFixed(1);
+  console.info(`
+\u{1F4BE} [Cache Stats] ${stats.hits} hits / ${stats.misses} misses (${hitRate}% hit rate), ${stats.writes} writes`);
+}

package/dist/cjs/configure.cjs

@@ -0,0 +1,37 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var configure_exports = {};
+__export(configure_exports, {
+  configuration: () => configuration,
+  configureVXRNCompilerPlugin: () => configureVXRNCompilerPlugin
+});
+module.exports = __toCommonJS(configure_exports);
+const configuration = {
+  enableNativewind: false,
+  enableReanimated: false,
+  enableCompiler: false,
+  enableNativeCSS: false
+};
+function configureVXRNCompilerPlugin(_) {
+  Object.assign(configuration, _);
+}

package/dist/cjs/constants.cjs

@@ -0,0 +1,77 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var constants_exports = {};
+__export(constants_exports, {
+  asyncGeneratorRegex: () => asyncGeneratorRegex,
+  debug: () => debug,
+  parsers: () => parsers,
+  runtimePublicPath: () => runtimePublicPath,
+  validParsers: () => validParsers
+});
+module.exports = __toCommonJS(constants_exports);
+var import_utils = require("@vxrn/utils");
+const {
+  debug
+} = (0, import_utils.createDebugger)("vxrn:compiler-plugin");
+const runtimePublicPath = "/@react-refresh";
+const asyncGeneratorRegex = /(async \*|async function\*|for await)/;
+const parsers = {
+  ".tsx": {
+    syntax: "typescript",
+    tsx: true,
+    decorators: true
+  },
+  ".ts": {
+    syntax: "typescript",
+    tsx: false,
+    decorators: true
+  },
+  ".jsx": {
+    syntax: "ecmascript",
+    jsx: true,
+    importAttributes: true,
+    explicitResourceManagement: true
+  },
+  ".js": {
+    syntax: "ecmascript",
+    importAttributes: true,
+    explicitResourceManagement: true
+  },
+  ".mjs": {
+    syntax: "ecmascript",
+    importAttributes: true,
+    explicitResourceManagement: true
+  },
+  ".cjs": {
+    syntax: "ecmascript",
+    importAttributes: true,
+    explicitResourceManagement: true
+  },
+  ".mdx": {
+    syntax: "ecmascript",
+    jsx: true,
+    importAttributes: true,
+    explicitResourceManagement: true
+  }
+};
+const validParsers = /* @__PURE__ */new Set([...Object.keys(parsers), ".css"]);

package/dist/cjs/index.cjs

@@ -0,0 +1,429 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var index_exports = {};
+__export(index_exports, {
+  createVXRNCompilerPlugin: () => createVXRNCompilerPlugin
+});
+module.exports = __toCommonJS(index_exports);
+var import_node_fs = require("node:fs");
+var import_promises = require("node:fs/promises");
+var import_node_path = require("node:path");
+var import_node_url = require("node:url");
+var import_utils = require("@vxrn/utils");
+var import_css_to_rn = require("react-native-css-interop/css-to-rn/index.js");
+var import_configure = require("./configure.cjs");
+var import_constants = require("./constants.cjs");
+var import_transformBabel = require("./transformBabel.cjs");
+var import_cache = require("./cache.cjs");
+__reExport(index_exports, require("./configure.cjs"), module.exports);
+__reExport(index_exports, require("./transformBabel.cjs"), module.exports);
+__reExport(index_exports, require("./transformSWC.cjs"), module.exports);
+const import_meta = {};
+const perfStats = {
+  babel: {
+    totalCalls: 0,
+    totalTransforms: 0,
+    totalTime: 0,
+    byEnvironment: {}
+  },
+  optimizeDeps: {
+    byEnvironment: {}
+  }
+};
+function logPerfSummary() {
+  if (!process.env.DEBUG_COMPILER_PERF) {
+    return;
+  }
+  console.info("\n\u{1F4CA} [Compiler Performance Summary]");
+  console.info(`Babel: ${perfStats.babel.totalTransforms} transforms / ${perfStats.babel.totalCalls} calls (${(perfStats.babel.totalTransforms / Math.max(perfStats.babel.totalCalls, 1) * 100).toFixed(1)}% transform rate)`);
+  console.info(`Babel total time: ${perfStats.babel.totalTime}ms`);
+  for (const [env, stats] of Object.entries(perfStats.babel.byEnvironment)) {
+    if (stats.transforms > 0) {
+      console.info(`  ${env}: ${stats.transforms} transforms, ${stats.time}ms (${(stats.time / stats.transforms).toFixed(1)}ms avg)`);
+    }
+  }
+  for (const [env, stats] of Object.entries(perfStats.optimizeDeps.byEnvironment)) {
+    const elapsed = Date.now() - stats.startTime;
+    console.info(`optimizeDeps ${env}: checked ${stats.filesChecked} files, transformed ${stats.filesTransformed} (${elapsed}ms)`);
+  }
+}
+const compilerLog = {
+  compiled: 0,
+  cached: 0,
+  time: 0,
+  // typed loose because the dom lib types setTimeout as number, but node gives
+  // us a Timeout we need to unref so the debounce never holds the process open
+  timer: null
+};
+function logCompiled(cached, ms) {
+  if (cached) {
+    compilerLog.cached++;
+  } else {
+    compilerLog.compiled++;
+    compilerLog.time += ms;
+  }
+  if (compilerLog.timer) clearTimeout(compilerLog.timer);
+  compilerLog.timer = setTimeout(() => {
+    const total = compilerLog.compiled + compilerLog.cached;
+    const detail = compilerLog.compiled ? `${compilerLog.compiled} compiled in ${compilerLog.time}ms${compilerLog.cached ? `, ${compilerLog.cached} cached` : ""}` : `all cached`;
+    console.info(` \u{1FA84} [compiler] ${total} file${total === 1 ? "" : "s"} (${detail})`);
+    compilerLog.compiled = 0;
+    compilerLog.cached = 0;
+    compilerLog.time = 0;
+    compilerLog.timer = null;
+  }, 500);
+  compilerLog.timer.unref?.();
+}
+async function performBabelTransform({
+  id,
+  code,
+  projectRoot,
+  environment,
+  production,
+  reactForRNVersion,
+  optionsIn
+}) {
+  perfStats.babel.totalCalls++;
+  if (!perfStats.babel.byEnvironment[environment]) {
+    perfStats.babel.byEnvironment[environment] = {
+      calls: 0,
+      transforms: 0,
+      time: 0
+    };
+  }
+  perfStats.babel.byEnvironment[environment].calls++;
+  const transformProps = {
+    id,
+    code,
+    projectRoot,
+    development: !production,
+    environment,
+    reactForRNVersion
+  };
+  const userTransform = optionsIn?.transform?.(transformProps);
+  if (userTransform === false) {
+    return null;
+  }
+  if (userTransform !== "swc") {
+    const babelOptions = (0, import_transformBabel.getBabelOptions)({
+      ...transformProps,
+      userSetting: userTransform
+    });
+    if (babelOptions) {
+      const hasCompilerPlugin = babelOptions.plugins?.some(x => Array.isArray(x) && x[0] === "babel-plugin-react-compiler");
+      const cached = (0, import_cache.getCachedTransform)(id, code, environment);
+      if (cached) {
+        perfStats.babel.byEnvironment[environment].transforms++;
+        if (hasCompilerPlugin && (cached.code.includes("react/compiler-runtime") || cached.code.includes("react-compiler-runtime"))) {
+          (0, import_constants.debug)?.(` \u{1FA84} [compiler] ${(0, import_node_path.relative)(process.cwd(), id)} (cached)`);
+          logCompiled(true, 0);
+        }
+        (0, import_constants.debug)?.(`[babel/cached] ${id}`);
+        return cached;
+      }
+      const compilerOnly = hasCompilerPlugin && babelOptions.plugins?.length === 1;
+      const compilerTarget = compilerOnly ? babelOptions.plugins[0][1]?.target ?? "19" : "19";
+      const startTime = Date.now();
+      const babelOut = compilerOnly ? await (0, import_transformBabel.transformOxcReactCompiler)(id, code, compilerTarget) : await (0, import_transformBabel.transformBabel)(id, code, babelOptions);
+      const babelTime = Date.now() - startTime;
+      if (babelOut?.code) {
+        perfStats.babel.totalTransforms++;
+        perfStats.babel.totalTime += babelTime;
+        perfStats.babel.byEnvironment[environment].transforms++;
+        perfStats.babel.byEnvironment[environment].time += babelTime;
+        if (hasCompilerPlugin && (babelOut.code.includes("react/compiler-runtime") || babelOut.code.includes("react-compiler-runtime"))) {
+          (0, import_constants.debug)?.(` \u{1FA84} [compiler] ${(0, import_node_path.relative)(process.cwd(), id)} (${babelTime}ms)`);
+          logCompiled(false, babelTime);
+        }
+        (0, import_constants.debug)?.(`[babel] ${id}`);
+        const outCode = `${babelOut.code}
+// vxrn-did-babel`;
+        const result = {
+          code: outCode,
+          map: babelOut.map
+        };
+        (0, import_cache.setCachedTransform)(id, code, result, environment);
+        return result;
+      }
+    }
+  }
+  return null;
+}
+async function createVXRNCompilerPlugin(optionsIn) {
+  const reactVersion = await (async () => {
+    const path = (0, import_utils.resolvePath)("react/package.json");
+    const json = JSON.parse(await (0, import_promises.readFile)(path, "utf-8"));
+    return json.version;
+  })();
+  const envNames = {
+    ios: true,
+    android: true,
+    client: true,
+    ssr: true
+  };
+  function getEnvName(name) {
+    if (!envNames[name]) throw new Error(`Invalid env: ${name}`);
+    return name;
+  }
+  const reactForRNVersion = reactVersion.split(".")[0];
+  const cssTransformCache = /* @__PURE__ */new Map();
+  const rolldownPath = (0, import_utils.resolvePath)("rolldown");
+  const rolldownNodeMods = rolldownPath.slice(0, rolldownPath.indexOf(import_node_path.sep + "node_modules"));
+  let config;
+  return [{
+    name: "one:compiler-resolve-refresh-runtime",
+    apply: "serve",
+    enforce: "pre",
+    // Run before Vite default resolve to avoid syscalls
+    resolveId: id => id === import_constants.runtimePublicPath || id === `${import_constants.runtimePublicPath}.map` ? id : void 0,
+    load: id => {
+      const basePath = (0, import_node_path.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
+      if (id === import_constants.runtimePublicPath) {
+        return (0, import_node_fs.readFileSync)((0, import_node_path.join)(basePath, "refresh-runtime.mjs"), "utf-8").replace(/\/\/# sourceMappingURL=.*/, "");
+      }
+      if (id === `${import_constants.runtimePublicPath}.map`) {
+        return JSON.stringify({
+          version: 3,
+          sources: [],
+          mappings: ""
+        });
+      }
+      return void 0;
+    }
+  }, {
+    name: `one:compiler-css-to-js`,
+    // only .css files can match, so let rust reject everything else
+    transform: {
+      filter: {
+        id: /\.css$/
+      },
+      handler(codeIn, id) {
+        const environment = getEnvName(this.environment.name);
+        if (import_configure.configuration.enableNativeCSS && (environment === "ios" || environment === "android")) {
+          {
+            const data = JSON.stringify((0, import_css_to_rn.cssToReactNativeRuntime)(codeIn, {
+              inlineRem: 16
+            }));
+            const code = `require("nativewind/dist/index.js").__require().StyleSheet.registerCompiled(${data})`;
+            const newId = `${id}.js`;
+            const cssId = newId.replace(rolldownNodeMods + import_node_path.sep, "");
+            cssTransformCache.set(cssId, code);
+            return {
+              code,
+              id: newId,
+              map: null
+            };
+          }
+        }
+      }
+    },
+    generateBundle(_, bundle) {
+      const environment = getEnvName(this.environment.name);
+      if (import_configure.configuration.enableNativeCSS && (environment === "ios" || environment === "android")) {
+        const rootJSName = Object.keys(bundle).find(i => {
+          const chunk = bundle[i];
+          return chunk.type == "chunk" && chunk.fileName.match(/.[cm]?js(?:\?.+)?$/) != null;
+        });
+        if (!rootJSName) {
+          throw new Error(`Can't find root js, internal one error`);
+        }
+        const rootJS = bundle[rootJSName];
+        const cssAssets = Object.keys(bundle).filter(i => bundle[i].fileName.endsWith(".css.js"));
+        for (const name of cssAssets) {
+          delete bundle[name];
+          const jsCSS = cssTransformCache.get(name);
+          rootJS.code = `
+${jsCSS}
+${rootJS.code}
+`;
+        }
+      }
+    }
+  }, {
+    name: "one:compiler",
+    enforce: "pre",
+    config: () => {
+      const nodeModulesFilter = /node_modules[/\\].*\.(tsx?|jsx?|mjs|cjs)$/;
+      const createEnvironmentConfig = environment => {
+        if (!perfStats.optimizeDeps.byEnvironment[environment]) {
+          perfStats.optimizeDeps.byEnvironment[environment] = {
+            filesChecked: 0,
+            filesTransformed: 0,
+            startTime: Date.now()
+          };
+        }
+        return {
+          optimizeDeps: {
+            rolldownOptions: {
+              plugins: [{
+                name: `transform-before-optimize-deps-${environment}`,
+                async transform(code, id) {
+                  if (!nodeModulesFilter.test(id)) {
+                    return null;
+                  }
+                  perfStats.optimizeDeps.byEnvironment[environment].filesChecked++;
+                  const production = process.env.NODE_ENV === "production" || process.env.NODE_ENV === "test";
+                  (0, import_constants.debug)?.(`[rolldown optimizeDeps] ${id}`);
+                  const result = await performBabelTransform({
+                    id,
+                    code,
+                    projectRoot: config.root,
+                    environment,
+                    production,
+                    reactForRNVersion,
+                    optionsIn
+                  });
+                  if (!result) {
+                    return null;
+                  }
+                  perfStats.optimizeDeps.byEnvironment[environment].filesTransformed++;
+                  return {
+                    code: result.code,
+                    map: result.map
+                  };
+                },
+                buildEnd() {
+                  if (process.env.DEBUG_COMPILER_PERF) {
+                    const stats = perfStats.optimizeDeps.byEnvironment[environment];
+                    const elapsed = Date.now() - stats.startTime;
+                    console.info(`[optimizeDeps ${environment}] Done: ${stats.filesChecked} files checked, ${stats.filesTransformed} transformed (${elapsed}ms)`);
+                  }
+                  const allDone = Object.keys(perfStats.optimizeDeps.byEnvironment).length >= 2;
+                  if (allDone) {
+                    (0, import_cache.logCacheStats)();
+                    logPerfSummary();
+                  }
+                }
+              }]
+            }
+          },
+          define: {
+            "process.env.NATIVEWIND_OS": JSON.stringify(environment === "ios" || environment === "android" ? "native" : "web")
+          }
+        };
+      };
+      return {
+        environments: {
+          ios: createEnvironmentConfig("ios"),
+          android: createEnvironmentConfig("android"),
+          client: createEnvironmentConfig("client"),
+          ssr: createEnvironmentConfig("ssr")
+        }
+      };
+    },
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    async transform(codeIn, _id) {
+      let code = codeIn;
+      const environment = getEnvName(this.environment.name);
+      const isNative = environment === "ios" || environment === "android";
+      const production = config.command === "build" || process.env.NODE_ENV === "production" || JSON.parse(this.environment.config?.define?.["process.env.NODE_ENV"] || '""') === "production";
+      const isEntry = _id.includes("one-entry-native");
+      if (isEntry) {
+        if (isNative && !production) {
+          code = `import '@vxrn/vite-native-client'
+${code}`;
+        }
+        if (isNative && import_configure.configuration.enableNativewind) {
+          code = `import * as x from 'nativewind'
+${code}`;
+        }
+        return code;
+      }
+      const id = _id.split("?")[0];
+      const extension = (0, import_node_path.extname)(id);
+      if (extension === ".css" || !import_constants.validParsers.has(extension)) {
+        return;
+      }
+      if (id.includes(`virtual:`)) {
+        return;
+      }
+      if (codeIn.endsWith(`// vxrn-did-babel`)) {
+        (0, import_constants.debug)?.(`[skip babel] ${id}`);
+        return;
+      }
+      return performBabelTransform({
+        id,
+        code: codeIn,
+        projectRoot: config.root,
+        environment,
+        production,
+        reactForRNVersion,
+        optionsIn
+      });
+    }
+  },
+  // wraps client-side TSX/JSX with React Refresh preamble + import.meta.hot.accept
+  // runs after vite:oxc (no enforce:'pre') so it sees the already-transformed code
+  {
+    name: "one:react-refresh-web",
+    apply: "serve",
+    transform(code, _id) {
+      if (this.environment.name !== "client") return;
+      if (code.includes(import_constants.runtimePublicPath)) return;
+      const id = _id.split("?")[0];
+      if (id.includes("node_modules")) return;
+      if (id.includes("virtual:")) return;
+      if (id === import_constants.runtimePublicPath) return;
+      const ext = (0, import_node_path.extname)(id);
+      if (ext !== ".tsx" && ext !== ".jsx") return;
+      const hasRefreshCalls = /\$RefreshReg\$\(/.test(code);
+      let out = `import * as RefreshRuntime from "${import_constants.runtimePublicPath}";
+
+`;
+      if (hasRefreshCalls) {
+        out += `if (!window.$RefreshReg$) throw new Error("React refresh preamble was not loaded. Something is wrong.");
+const prevRefreshReg = window.$RefreshReg$;
+const prevRefreshSig = window.$RefreshSig$;
+window.$RefreshReg$ = RefreshRuntime.getRefreshReg("${id}");
+window.$RefreshSig$ = RefreshRuntime.createSignatureFunctionForTransform;
+
+`;
+      }
+      out += code;
+      if (hasRefreshCalls) {
+        out += `
+
+window.$RefreshReg$ = prevRefreshReg;
+window.$RefreshSig$ = prevRefreshSig;
+`;
+      }
+      out += `
+RefreshRuntime.__hmr_import(import.meta.url).then((currentExports) => {
+  RefreshRuntime.registerExportsForReactRefresh("${id}", currentExports);
+  import.meta.hot.accept((nextExports) => {
+    if (!nextExports) return;
+    const invalidateMessage = RefreshRuntime.validateRefreshBoundaryAndEnqueueUpdate("${id}", currentExports, nextExports);
+    if (invalidateMessage) import.meta.hot.invalidate(invalidateMessage);
+  });
+});
+`;
+      return {
+        code: out,
+        map: null
+      };
+    }
+  }];
+}