@nasti-toolchain/nasti 1.5.0 → 1.5.2

package/dist/index.js

@@ -164,6 +164,14 @@ async function resolveConfig(inlineConfig = {}, command) {
     return p.apply === command;
   });
   resolved.plugins = filteredPlugins;
+  if (resolved.target === "electron") {
+    const autoExternal = detectNativeDeps(root);
+    if (autoExternal.length > 0) {
+      const current = new Set(resolved.electron.external ?? []);
+      for (const dep of autoExternal) current.add(dep);
+      resolved.electron.external = [...current];
+    }
+  }
   for (const plugin of resolved.plugins) {
     if (plugin.configResolved) {
       await plugin.configResolved(resolved);
@@ -171,6 +179,73 @@ async function resolveConfig(inlineConfig = {}, command) {
   }
   return resolved;
 }
+function detectNativeDeps(root) {
+  const result = /* @__PURE__ */ new Set();
+  const pkgJsonPath = path.resolve(root, "package.json");
+  if (!fs.existsSync(pkgJsonPath)) return [];
+  let pkg;
+  try {
+    pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+  } catch {
+    return [];
+  }
+  const deps = {
+    ...pkg.dependencies ?? {},
+    ...pkg.optionalDependencies ?? {}
+  };
+  const KNOWN_NATIVE = /* @__PURE__ */ new Set([
+    "node-pty",
+    "better-sqlite3",
+    "sharp",
+    "serialport",
+    "@vscode/tree-sitter-wasm",
+    "keytar",
+    "nodegit",
+    "sqlite3",
+    "fsevents"
+  ]);
+  for (const dep of Object.keys(deps)) {
+    if (KNOWN_NATIVE.has(dep)) {
+      result.add(dep);
+      continue;
+    }
+    const depDir = path.resolve(root, "node_modules", dep);
+    if (!fs.existsSync(depDir)) continue;
+    if (fs.existsSync(path.join(depDir, "binding.gyp"))) {
+      result.add(dep);
+      continue;
+    }
+    const subPkg = path.join(depDir, "package.json");
+    if (fs.existsSync(subPkg)) {
+      try {
+        const sub = JSON.parse(fs.readFileSync(subPkg, "utf-8"));
+        if (sub.gypfile === true || sub.binary?.module_name) {
+          result.add(dep);
+          continue;
+        }
+      } catch {
+      }
+    }
+    if (hasDotNodeFile(depDir)) {
+      result.add(dep);
+    }
+  }
+  return [...result];
+}
+function hasDotNodeFile(dir, depth = 0) {
+  if (depth > 3) return false;
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const e of entries) {
+      if (e.isFile() && e.name.endsWith(".node")) return true;
+      if (e.isDirectory() && (e.name === "build" || e.name === "prebuilds" || e.name === "Release")) {
+        if (hasDotNodeFile(path.join(dir, e.name), depth + 1)) return true;
+      }
+    }
+  } catch {
+  }
+  return false;
+}
 function deepMerge(target, source) {
   const result = { ...target };
   for (const key of Object.keys(source)) {
@@ -415,6 +490,15 @@ function htmlPlugin(config) {
     transformIndexHtml(html) {
       const tags = [];
       if (config.command === "serve") {
+        const isReactLike = config.framework === "react" || config.framework === "auto";
+        if (isReactLike) {
+          tags.push({
+            tag: "script",
+            attrs: { type: "module" },
+            children: REACT_REFRESH_HTML_PREAMBLE,
+            injectTo: "head-prepend"
+          });
+        }
         tags.push({
           tag: "script",
           attrs: { type: "module", src: "/@nasti/client" },
@@ -465,9 +549,17 @@ async function readHtmlFile(root) {
   if (!fs4.existsSync(htmlPath)) return null;
   return fs4.readFileSync(htmlPath, "utf-8");
 }
+var REACT_REFRESH_HTML_PREAMBLE;
 var init_html = __esm({
   "src/plugins/html.ts"() {
     "use strict";
+    REACT_REFRESH_HTML_PREAMBLE = `
+import RefreshRuntime from "/@react-refresh";
+RefreshRuntime.injectIntoGlobalHook(window);
+window.$RefreshReg$ = () => {};
+window.$RefreshSig$ = () => (type) => type;
+window.__vite_plugin_react_preamble_installed__ = true;
+`.trim();
   }
 });
 
@@ -701,7 +793,7 @@ import pc from "picocolors";
 async function build(inlineConfig = {}) {
   const config = await resolveConfig(inlineConfig, "build");
   const startTime = performance.now();
-  console.log(pc.cyan("\n\u{1F528} nasti build") + pc.dim(` v${"1.5.0"}`));
+  console.log(pc.cyan("\n\u{1F528} nasti build") + pc.dim(` v${"1.5.2"}`));
   console.log(pc.dim(`  root: ${config.root}`));
   console.log(pc.dim(`  mode: ${config.mode}`));
   const outDir = path7.resolve(config.root, config.build.outDir);
@@ -1005,11 +1097,93 @@ var init_ws = __esm({
 // src/server/middleware.ts
 var middleware_exports = {};
 __export(middleware_exports, {
+  REACT_REFRESH_GLOBAL_PREAMBLE: () => REACT_REFRESH_GLOBAL_PREAMBLE,
   transformMiddleware: () => transformMiddleware,
   transformRequest: () => transformRequest
 });
 import path9 from "path";
 import fs8 from "fs";
+import { createRequire as createRequire2 } from "module";
+import { fileURLToPath } from "url";
+function getReactRefreshRuntimeEsm() {
+  if (__refreshRuntimeCache) return __refreshRuntimeCache;
+  let cjsPath;
+  try {
+    const pkgPath = __require.resolve("react-refresh/package.json");
+    cjsPath = path9.join(path9.dirname(pkgPath), "cjs", "react-refresh-runtime.development.js");
+  } catch (err) {
+    cjsPath = path9.resolve(__dirname_esm, "../../node_modules/react-refresh/cjs/react-refresh-runtime.development.js");
+    if (!fs8.existsSync(cjsPath)) {
+      const origMsg = err instanceof Error ? err.message : String(err);
+      throw new Error(
+        `[nasti] Missing dependency "react-refresh". Install it with: npm install react-refresh
+Original resolve error: ${origMsg}`
+      );
+    }
+  }
+  const cjsSource = fs8.readFileSync(cjsPath, "utf-8");
+  __refreshRuntimeCache = `// Wrapped react-refresh runtime -> ESM
+const exports = {};
+const module = { exports };
+const process = { env: { NODE_ENV: 'development' } };
+${cjsSource}
+const __rt = module.exports;
+export const injectIntoGlobalHook = __rt.injectIntoGlobalHook;
+export const register = __rt.register;
+export const createSignatureFunctionForTransform = __rt.createSignatureFunctionForTransform;
+export const performReactRefresh = __rt.performReactRefresh;
+export const isLikelyComponentType = __rt.isLikelyComponentType;
+export const hasUnrecoverableErrors = __rt.hasUnrecoverableErrors;
+export const setSignature = __rt.setSignature;
+export const getFamilyByID = __rt.getFamilyByID;
+export const getFamilyByType = __rt.getFamilyByType;
+export const findAffectedHostInstances = __rt.findAffectedHostInstances;
+export const collectCustomHooksForSignature = __rt.collectCustomHooksForSignature;
+export default __rt;
+`;
+  return __refreshRuntimeCache;
+}
+function buildReactRefreshWrapper(moduleUrl, transformedCode) {
+  const urlLit = JSON.stringify(moduleUrl);
+  const userCode = transformedCode.replace(/\bimport\.meta\.hot\b/g, "__nasti_hot__");
+  return `import * as RefreshRuntime from "/@react-refresh";
+import { createHotContext as __nasti_createHotContext__ } from "/@nasti/client";
+const __nasti_hot__ = __nasti_createHotContext__(${urlLit});
+
+if (!window.__vite_plugin_react_preamble_installed__) {
+  throw new Error("[nasti] React Fast Refresh preamble missing. Make sure nasti:html is wired with framework: 'react'.");
+}
+
+const prevRefreshReg = window.$RefreshReg$;
+const prevRefreshSig = window.$RefreshSig$;
+window.$RefreshReg$ = (type, id) => {
+  RefreshRuntime.register(type, ${urlLit} + " " + id);
+};
+window.$RefreshSig$ = RefreshRuntime.createSignatureFunctionForTransform;
+
+${userCode}
+
+window.$RefreshReg$ = prevRefreshReg;
+window.$RefreshSig$ = prevRefreshSig;
+
+if (__nasti_hot__) {
+  __nasti_hot__.accept(() => {
+    clearTimeout(window.__nasti_refresh_timer__);
+    window.__nasti_refresh_timer__ = setTimeout(() => {
+      RefreshRuntime.performReactRefresh();
+    }, 30);
+  });
+}
+`;
+}
+function injectImportMetaHot(code, moduleUrl) {
+  if (!/\bimport\.meta\.hot\b/.test(code)) return code;
+  const urlLit = JSON.stringify(moduleUrl);
+  const header = `import { createHotContext as __nasti_createHotContext__ } from "/@nasti/client";
+const __nasti_hot__ = __nasti_createHotContext__(${urlLit});
+`;
+  return header + code.replace(/\bimport\.meta\.hot\b/g, "__nasti_hot__");
+}
 function transformMiddleware(ctx) {
   ctx.envDefine = buildEnvDefine(
     loadEnv(ctx.config.mode, ctx.config.root, ctx.config.envPrefix),
@@ -1083,7 +1257,7 @@ async function transformRequest(url, ctx) {
     return cached.transformResult;
   }
   if (cleanReqUrl === "/@react-refresh") {
-    return { code: REACT_REFRESH_RUNTIME };
+    return { code: getReactRefreshRuntimeEsm() };
   }
   const filePath = resolveUrlToFile(url, config.root);
   if (!filePath || !fs8.existsSync(filePath)) return null;
@@ -1100,6 +1274,8 @@ async function transformRequest(url, ctx) {
   if (pluginResult) {
     code = typeof pluginResult === "string" ? pluginResult : pluginResult.code;
   }
+  const stableUrl = cleanReqUrl;
+  let wrappedWithRefresh = false;
   if (shouldTransform(filePath)) {
     const isJsx = /\.[jt]sx$/.test(filePath);
     const useRefresh = isJsx && config.framework !== "vue";
@@ -1111,9 +1287,14 @@ async function transformRequest(url, ctx) {
     });
     code = result.code;
     if (useRefresh) {
-      code = REACT_REFRESH_PREAMBLE + code + REACT_REFRESH_FOOTER;
+      code = buildReactRefreshWrapper(stableUrl, code);
+      wrappedWithRefresh = true;
+      mod.isSelfAccepting = true;
     }
   }
+  if (!wrappedWithRefresh) {
+    code = injectImportMetaHot(code, stableUrl);
+  }
   const envDefine = ctx.envDefine ?? buildEnvDefine(
     loadEnv(config.mode, config.root, config.envPrefix),
     config.mode
@@ -1181,8 +1362,8 @@ function rewriteExternalRequires(code) {
 }
 async function injectCjsNamedExports(code, entryFile) {
   try {
-    const { createRequire: createRequire4 } = await import("module");
-    const req = createRequire4(entryFile);
+    const { createRequire: createRequire5 } = await import("module");
+    const req = createRequire5(entryFile);
     const cjsExports = req(entryFile);
     if (!cjsExports || typeof cjsExports !== "object" && typeof cjsExports !== "function" || Array.isArray(cjsExports)) return code;
     const namedKeys = Object.keys(cjsExports).filter(
@@ -1345,12 +1526,15 @@ function getHmrClientCode() {
 // Nasti HMR Client
 const socket = new WebSocket(\`ws://\${location.host}\`, 'nasti-hmr');
 const hotModulesMap = new Map();
+const disposeMap = new Map();
+const pruneMap = new Map();
 
 socket.addEventListener('message', ({ data }) => {
   const payload = JSON.parse(data);
   switch (payload.type) {
     case 'connected':
       console.log('[nasti] connected.');
+      clearErrorOverlay();
       break;
     case 'update':
       payload.updates.forEach((update) => {
@@ -1360,11 +1544,18 @@ socket.addEventListener('message', ({ data }) => {
           updateCss(update.path);
         }
       });
+      clearErrorOverlay();
       break;
     case 'full-reload':
       console.log('[nasti] full reload');
       location.reload();
       break;
+    case 'prune':
+      payload.paths.forEach((p) => {
+        const cb = pruneMap.get(p);
+        if (cb) cb();
+      });
+      break;
     case 'error':
       console.error('[nasti] error:', payload.err.message);
       showErrorOverlay(payload.err);
@@ -1372,14 +1563,23 @@ socket.addEventListener('message', ({ data }) => {
   }
 });
 
+// \u81EA\u52A8\u91CD\u8FDE\uFF08\u65AD\u7EBF\u65F6\u6307\u6570\u9000\u907F\uFF09
+let reconnectTimer = 0;
+socket.addEventListener('close', () => {
+  clearTimeout(reconnectTimer);
+  reconnectTimer = setTimeout(() => location.reload(), 1000);
+});
+
 async function fetchUpdate(update) {
   const mod = hotModulesMap.get(update.path);
+  // \u5148\u8DD1 dispose\uFF08\u7ED9\u6A21\u5757\u673A\u4F1A\u6E05\u7406\u526F\u4F5C\u7528\uFF09
+  const dispose = disposeMap.get(update.path);
+  if (dispose) dispose();
+
+  const newMod = await import(update.acceptedPath + '?t=' + update.timestamp);
   if (mod) {
-    const newMod = await import(update.acceptedPath + '?t=' + update.timestamp);
-    mod.callbacks.forEach((cb) => cb(newMod));
-  } else {
-    // \u6CA1\u6709\u6CE8\u518C hot \u56DE\u8C03\uFF0C\u5C1D\u8BD5\u91CD\u65B0 import
-    await import(update.path + '?t=' + update.timestamp);
+    // \u590D\u5236\u56DE\u8C03\u6570\u7EC4\u907F\u514D\u56DE\u8C03\u5185\u90E8\u53C8\u4FEE\u6539 hotModulesMap \u9020\u6210\u8FED\u4EE3\u5F02\u5E38
+    [...mod.callbacks].forEach((cb) => cb(newMod));
   }
 }
 
@@ -1392,7 +1592,13 @@ function updateCss(path) {
   }
 }
 
+function clearErrorOverlay() {
+  const el = document.getElementById('nasti-error-overlay');
+  if (el) el.remove();
+}
+
 function showErrorOverlay(err) {
+  clearErrorOverlay();
   const overlay = document.createElement('div');
   overlay.id = 'nasti-error-overlay';
   overlay.style.cssText = 'position:fixed;inset:0;z-index:99999;background:rgba(0,0,0,0.85);color:#fff;font-family:monospace;padding:2rem;overflow:auto;';
@@ -1411,59 +1617,55 @@ function showErrorOverlay(err) {
   document.body.appendChild(overlay);
 }
 
-// import.meta.hot API
-const createHotContext = (ownerPath) => ({
-  accept(deps, callback) {
-    if (typeof deps === 'function' || !deps) {
-      // self-accepting
-      const callbacks = hotModulesMap.get(ownerPath)?.callbacks || [];
-      callbacks.push(deps || (() => {}));
-      hotModulesMap.set(ownerPath, { callbacks });
-    }
-  },
-  prune(callback) {
-    // \u6A21\u5757\u88AB\u79FB\u9664\u65F6\u6267\u884C
-  },
-  dispose(callback) {
-    // \u6A21\u5757\u66F4\u65B0\u524D\u6267\u884C\u6E05\u7406
-  },
-  invalidate() {
-    location.reload();
-  },
-  data: {},
-});
-
-// \u66B4\u9732\u7ED9\u6A21\u5757\u4F7F\u7528
-if (!window.__nasti_hot_map) window.__nasti_hot_map = new Map();
-window.__NASTI_HMR__ = { createHotContext };
+/**
+ * \u751F\u6210 import.meta.hot \u7684 hot context\u3002
+ * \u5173\u952E\u7EA6\u675F\uFF1A\u540C\u4E00 ownerPath \u7684 accept \u56DE\u8C03\u5FC5\u987B\u66FF\u6362\uFF08\u4E0D\u662F append\uFF09\u3002
+ * \u6BCF\u6B21\u6A21\u5757\u91CD\u65B0 import \u90FD\u4F1A\u8C03\u7528 createHotContext\uFF0C\u65E7\u56DE\u8C03\u4F1A\u88AB fetchUpdate \u8C03\u7528\u540E\u7ACB\u5373\u88AB\u65B0 import
+ * \u91CC\u7684 accept \u66FF\u6362\u3002\u4E0D\u66FF\u6362\u7684\u8BDD\u6BCF\u7F16\u8F91\u4E00\u6B21\u5C31\u591A\u4E00\u4E2A\u56DE\u8C03\uFF0C\u8D8A\u8DD1\u8D8A\u6162\u3002
+ */
+export function createHotContext(ownerPath) {
+  return {
+    accept(deps, callback) {
+      // \u81EA\u63A5\u53D7: hot.accept() \u6216 hot.accept(callback)
+      if (typeof deps === 'function' || deps === undefined) {
+        hotModulesMap.set(ownerPath, { callbacks: [deps || (() => {})] });
+        return;
+      }
+      // \u4F9D\u8D56\u63A5\u53D7: hot.accept(deps, callback)\uFF0C\u591A\u6B21\u8C03\u7528\u8FFD\u52A0
+      const existing = hotModulesMap.get(ownerPath)?.callbacks ?? [];
+      hotModulesMap.set(ownerPath, { callbacks: [...existing, callback] });
+    },
+    prune(callback) {
+      pruneMap.set(ownerPath, callback);
+    },
+    dispose(callback) {
+      disposeMap.set(ownerPath, callback);
+    },
+    invalidate() {
+      location.reload();
+    },
+    data: {},
+  };
+}
 `;
 }
-var REACT_REFRESH_RUNTIME, REACT_REFRESH_PREAMBLE, REACT_REFRESH_FOOTER, esmBundleCache, VALID_IDENT, RESOLVE_EXTENSIONS, ESM_CONDITIONS;
+var __dirname_esm, __require, __refreshRuntimeCache, REACT_REFRESH_GLOBAL_PREAMBLE, esmBundleCache, VALID_IDENT, RESOLVE_EXTENSIONS, ESM_CONDITIONS;
 var init_middleware = __esm({
   "src/server/middleware.ts"() {
     "use strict";
     init_transformer();
     init_html();
     init_env();
-    REACT_REFRESH_RUNTIME = `
-export function createSignatureFunctionForTransform() {
-  return function(type, key, forceReset, getCustomHooks) { return type; };
-}
-export function register(type, id) {}
-export default { createSignatureFunctionForTransform, register };
-`;
-    REACT_REFRESH_PREAMBLE = `
-import RefreshRuntime from '/@react-refresh';
-if (!window.$RefreshReg$) {
-  window.$RefreshReg$ = (type, id) => RefreshRuntime.register(type, import.meta.url + ' ' + id);
-  window.$RefreshSig$ = RefreshRuntime.createSignatureFunctionForTransform;
-}
-`;
-    REACT_REFRESH_FOOTER = `
-if (import.meta.hot) {
-  import.meta.hot.accept();
-}
-`;
+    __dirname_esm = path9.dirname(fileURLToPath(import.meta.url));
+    __require = createRequire2(import.meta.url);
+    __refreshRuntimeCache = null;
+    REACT_REFRESH_GLOBAL_PREAMBLE = `
+import RefreshRuntime from "/@react-refresh";
+RefreshRuntime.injectIntoGlobalHook(window);
+window.$RefreshReg$ = () => {};
+window.$RefreshSig$ = () => (type) => type;
+window.__vite_plugin_react_preamble_installed__ = true;
+`.trim();
     esmBundleCache = /* @__PURE__ */ new Map();
     VALID_IDENT = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
     RESOLVE_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js", ".mjs", ".json", ".vue"];
@@ -1595,7 +1797,7 @@ async function createServer(inlineConfig = {}) {
           const localUrl = `http://localhost:${actualPort}`;
           const networkUrl = host === "0.0.0.0" ? `http://${getNetworkAddress()}:${actualPort}` : null;
           console.log();
-          console.log(pc3.cyan("  nasti dev server") + pc3.dim(` v${"1.5.0"}`));
+          console.log(pc3.cyan("  nasti dev server") + pc3.dim(` v${"1.5.2"}`));
           console.log();
           console.log(`  ${pc3.green(">")} Local:   ${pc3.cyan(localUrl)}`);
           if (networkUrl) {
@@ -1719,7 +1921,7 @@ async function buildElectron(inlineConfig = {}) {
   const config = await resolveConfig({ ...inlineConfig, target: "electron" }, "build");
   const startTime = performance.now();
   assertElectronVersion(config);
-  console.log(pc2.cyan("\n\u26A1 nasti build (electron)") + pc2.dim(` v${"1.5.0"}`));
+  console.log(pc2.cyan("\n\u26A1 nasti build (electron)") + pc2.dim(` v${"1.5.2"}`));
   console.log(pc2.dim(`  root: ${config.root}`));
   console.log(pc2.dim(`  mode: ${config.mode}`));
   console.log(pc2.dim(`  target: electron (\u2265 ${config.electron.minVersion})`));
@@ -1854,7 +2056,7 @@ init_server();
 init_config();
 import path12 from "path";
 import fs10 from "fs";
-import { createRequire as createRequire2 } from "module";
+import { createRequire as createRequire3 } from "module";
 import { spawn } from "child_process";
 import chokidar from "chokidar";
 import pc4 from "picocolors";
@@ -1866,7 +2068,7 @@ async function startElectronDev(inlineConfig = {}) {
   const { noSpawn, ...rest } = inlineConfig;
   const config = await resolveConfig({ ...rest, target: "electron" }, "serve");
   warnElectronVersion(config);
-  console.log(pc4.cyan("\n\u26A1 nasti electron dev") + pc4.dim(` v${"1.5.0"}`));
+  console.log(pc4.cyan("\n\u26A1 nasti electron dev") + pc4.dim(` v${"1.5.2"}`));
   const { createServer: createServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
   const server = await createServer2({ ...rest, target: "electron" });
   await server.listen();
@@ -1930,11 +2132,16 @@ async function startElectronDev(inlineConfig = {}) {
     const watchTargets = [mainEntry, ...preloadEntries].filter(fs10.existsSync);
     const watcher = chokidar.watch(watchTargets, { ignoreInitial: true });
     let restarting = null;
-    watcher.on("all", async () => {
-      if (restarting) return;
+    let pending = false;
+    const restart = async () => {
+      if (restarting) {
+        pending = true;
+        return;
+      }
       restarting = (async () => {
-        console.log(pc4.cyan("\n  \u267B \u4E3B/preload \u53D8\u66F4\uFF0C\u91CD\u542F Electron..."));
-        try {
+        do {
+          pending = false;
+          console.log(pc4.cyan("\n  \u267B \u4E3B/preload \u53D8\u66F4\uFF0C\u91CD\u542F Electron..."));
           if (child && !child.killed) {
             ;
             child.__nastiKilled = true;
@@ -1948,12 +2155,24 @@ async function startElectronDev(inlineConfig = {}) {
               dying.kill();
             });
           }
-          await compileAll();
-          spawnElectron();
-        } finally {
-          restarting = null;
-        }
+          try {
+            await compileAll();
+            spawnElectron();
+          } catch (e) {
+            console.warn(pc4.yellow(`  \u26A0 \u91CD\u542F\u7F16\u8BD1\u5931\u8D25\uFF0C\u4FDD\u7559\u4E0A\u4E00\u6B21\u8FDB\u7A0B: ${e.message}`));
+          }
+        } while (pending);
+        restarting = null;
       })();
+      return restarting;
+    };
+    let debounceTimer = null;
+    watcher.on("all", () => {
+      if (debounceTimer) clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(() => {
+        debounceTimer = null;
+        void restart();
+      }, 80);
     });
   }
 }
@@ -2001,7 +2220,7 @@ function resolveElectronBinary(config) {
     return config.electron.electronPath;
   }
   try {
-    const require2 = createRequire2(path12.resolve(config.root, "package.json"));
+    const require2 = createRequire3(path12.resolve(config.root, "package.json"));
     const pathFile = require2.resolve("electron");
     const electronModule = require2(pathFile);
     if (typeof electronModule === "string" && fs10.existsSync(electronModule)) {
@@ -2034,7 +2253,7 @@ function warnElectronVersion(config) {
 import path13 from "path";
 import fs11 from "fs";
 import crypto2 from "crypto";
-import { createRequire as createRequire3 } from "module";
+import { createRequire as createRequire4 } from "module";
 var DEFAULT_WORKERS = {
   editorWorkerService: "monaco-editor/esm/vs/editor/editor.worker",
   css: "monaco-editor/esm/vs/language/css/css.worker",
@@ -2053,7 +2272,7 @@ function normalizePublicPath(p) {
 }
 function readMonacoVersion(root) {
   try {
-    const require2 = createRequire3(path13.resolve(root, "package.json"));
+    const require2 = createRequire4(path13.resolve(root, "package.json"));
     const pkgJsonPath = require2.resolve("monaco-editor/package.json", { paths: [root] });
     const pkg = JSON.parse(fs11.readFileSync(pkgJsonPath, "utf-8"));
     return typeof pkg.version === "string" ? pkg.version : "unknown";
@@ -2081,7 +2300,7 @@ function monacoEditorPlugin(options = {}) {
     if (existing) return existing;
     const task = (async () => {
       const { rolldown: rolldown4 } = await import("rolldown");
-      const require2 = createRequire3(path13.resolve(resolvedConfig.root, "package.json"));
+      const require2 = createRequire4(path13.resolve(resolvedConfig.root, "package.json"));
       let entry;
       try {
         entry = require2.resolve(worker.entry, { paths: [resolvedConfig.root] });