@mercurjs/dashboard-sdk 2.0.0-canary.8 → 2.0.0-canary.80

package/dist/index.cjs

@@ -30,15 +30,39 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  dashboardPlugin: () => dashboardPlugin,
-  defineConfig: () => defineConfig
+  mercurDashboardPlugin: () => mercurDashboardPlugin
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/plugin.ts
 var import_path5 = __toESM(require("path"), 1);
+var import_fs4 = __toESM(require("fs"), 1);
+
+// src/babel.ts
+var import_parser = require("@babel/parser");
+var import_traverse = __toESM(require("@babel/traverse"), 1);
+var import_types = require("@babel/types");
+var traverse;
+if (typeof import_traverse.default === "function") {
+  traverse = import_traverse.default;
+} else {
+  traverse = import_traverse.default.default;
+}
 
 // src/utils.ts
+function normalizePath(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+function getParserOptions(file) {
+  const options = {
+    sourceType: "module",
+    plugins: ["jsx"]
+  };
+  if (file.endsWith(".ts") || file.endsWith(".tsx")) {
+    options.plugins.push("typescript");
+  }
+  return options;
+}
 function resolveExports(moduleExports) {
   if ("default" in moduleExports && moduleExports.default && "default" in moduleExports.default) {
     return resolveExports(moduleExports.default);
@@ -67,13 +91,31 @@ var safeRegister = async () => {
   }
   return res;
 };
-function normalizePath(filePath) {
-  return filePath.replace(/\\/g, "/");
+function hasDefaultExport(ast) {
+  let found = false;
+  traverse(ast, {
+    ExportDefaultDeclaration() {
+      found = true;
+    },
+    AssignmentExpression(path6) {
+      if (path6.node.left.type === "MemberExpression" && path6.node.left.object.type === "Identifier" && path6.node.left.object.name === "exports" && path6.node.left.property.type === "Identifier" && path6.node.left.property.name === "default") {
+        found = true;
+      }
+    },
+    ExportNamedDeclaration(path6) {
+      const specifiers = path6.node.specifiers;
+      if (specifiers?.some(
+        (s) => s.type === "ExportSpecifier" && s.exported.type === "Identifier" && s.exported.name === "default"
+      )) {
+        found = true;
+      }
+    }
+  });
+  return found;
 }
 
 // src/constants.ts
 var VALID_FILE_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js"];
-var CONFIG_NAME = "mercur.config.ts";
 var CONFIG_VIRTUAL_MODULE = "virtual:mercur/config";
 var ROUTES_VIRTUAL_MODULE = "virtual:mercur/routes";
 var COMPONENTS_VIRTUAL_MODULE = "virtual:mercur/components";
@@ -128,31 +170,51 @@ function crawlPages(dir, pattern = "page") {
   }
   return files;
 }
-function hasDefaultExport(filePath) {
-  try {
-    const content = import_fs.default.readFileSync(filePath, "utf-8");
-    return /export\s+default\s+/.test(content) || /export\s*\{\s*[^}]*\s+as\s+default\s*[,}]/.test(content);
-  } catch {
-    return false;
-  }
-}
-function hasConfigPublic(filePath) {
-  try {
-    const content = import_fs.default.readFileSync(filePath, "utf-8");
-    return /export\s+const\s+config\s*=\s*\{[^}]*public\s*:\s*true/.test(content);
-  } catch {
-    return false;
-  }
-}
-function getNamedExports(filePath) {
-  try {
-    const content = import_fs.default.readFileSync(filePath, "utf-8");
-    const hasHandle = /export\s+(const|function|async\s+function)\s+handle\b/.test(content) || /export\s*\{[^}]*\bhandle\b[^}]*\}/.test(content);
-    const hasLoader = /export\s+(const|function|async\s+function)\s+loader\b/.test(content) || /export\s*\{[^}]*\bloader\b[^}]*\}/.test(content);
-    return { hasHandle, hasLoader };
-  } catch {
-    return { hasHandle: false, hasLoader: false };
-  }
+function hasConfigPublic(ast) {
+  let found = false;
+  traverse(ast, {
+    ExportNamedDeclaration(path6) {
+      const declaration = path6.node.declaration;
+      if (!(0, import_types.isVariableDeclaration)(declaration)) return;
+      for (const decl of declaration.declarations) {
+        if ((0, import_types.isVariableDeclarator)(decl) && (0, import_types.isIdentifier)(decl.id, { name: "config" }) && decl.init?.type === "ObjectExpression") {
+          const publicProp = decl.init.properties.find(
+            (prop) => (0, import_types.isObjectProperty)(prop) && (0, import_types.isIdentifier)(prop.key, { name: "public" }) && (0, import_types.isBooleanLiteral)(prop.value, { value: true })
+          );
+          if (publicProp) {
+            found = true;
+          }
+        }
+      }
+    }
+  });
+  return found;
+}
+function getNamedExports(ast) {
+  let hasHandle = false;
+  let hasLoader = false;
+  traverse(ast, {
+    ExportNamedDeclaration(path6) {
+      const declaration = path6.node.declaration;
+      if (declaration?.type === "VariableDeclaration") {
+        declaration.declarations.forEach((decl) => {
+          if (decl.id.type === "Identifier" && decl.id.name === "handle") {
+            hasHandle = true;
+          }
+          if (decl.id.type === "Identifier" && decl.id.name === "loader") {
+            hasLoader = true;
+          }
+        });
+      }
+      if (declaration?.type === "FunctionDeclaration" && declaration.id?.name === "loader") {
+        hasLoader = true;
+      }
+      if (declaration?.type === "FunctionDeclaration" && declaration.id?.name === "handle") {
+        hasHandle = true;
+      }
+    }
+  });
+  return { hasHandle, hasLoader };
 }
 function generateRouteComponentName(index) {
   return `RouteComponent${index}`;
@@ -218,18 +280,24 @@ ${indent}}`;
   return result;
 }
 function parseFile(file, pagesDir, index) {
-  if (!hasDefaultExport(file)) {
+  try {
+    const code = import_fs.default.readFileSync(file, "utf-8");
+    const ast = (0, import_parser.parse)(code, getParserOptions(file));
+    if (!hasDefaultExport(ast)) {
+      return null;
+    }
+    const { hasHandle, hasLoader } = getNamedExports(ast);
+    const isPublic = hasConfigPublic(ast);
+    const routePath = getRoute(file, pagesDir);
+    const imports = generateImports(file, index, hasHandle, hasLoader);
+    const route = generateRouteObject(routePath, index, hasHandle, hasLoader, isPublic);
+    return {
+      imports,
+      route
+    };
+  } catch {
     return null;
   }
-  const { hasHandle, hasLoader } = getNamedExports(file);
-  const isPublic = hasConfigPublic(file);
-  const routePath = getRoute(file, pagesDir);
-  const imports = generateImports(file, index, hasHandle, hasLoader);
-  const route = generateRouteObject(routePath, index, hasHandle, hasLoader, isPublic);
-  return {
-    imports,
-    route
-  };
 }
 function buildRouteTree(results) {
   const routeMap = /* @__PURE__ */ new Map();
@@ -243,7 +311,7 @@ function buildRouteTree(results) {
       const parentPath = routePath.split("/@")[0];
       const parent = routeMap.get(parentPath);
       if (parent) {
-        parent.route.children = parent.route.children || [];
+        parent.route.children = parent.route.children ?? [];
         parent.route.children.push({
           ...result.route,
           path: result.route.path.replace("/@", "/")
@@ -258,31 +326,37 @@ function buildRouteTree(results) {
   }
   return Array.from(routeMap.values());
 }
-function generateRoutes({ srcDir }) {
+function generateRoutes({ srcDir, pluginExtensions }) {
   const pagesDir = import_path.default.join(srcDir, "pages");
-  const files = crawlPages(pagesDir);
-  if (files.length === 0) {
-    return `export const customRoutes = []`;
-  }
   let index = 0;
   const results = [];
-  for (const file of files) {
+  for (const file of crawlPages(pagesDir)) {
     const result = parseFile(file, pagesDir, index);
     if (result) {
       results.push(result);
       index++;
     }
   }
-  if (results.length === 0) {
+  const pluginDeclarations = pluginExtensions.map(
+    (ext, i) => `const __plugin${i} = (await import("${normalizePath(ext)}")).default`
+  );
+  const pluginSpreads = pluginExtensions.map(
+    (_, i) => `    ...(__plugin${i}.routeModule?.routes ?? [])`
+  );
+  const routeTree = buildRouteTree(results);
+  const appImports = routeTree.flatMap((r) => r.imports);
+  const appRoutes = routeTree.map((r) => formatRoute(r.route));
+  const allImports = [...appImports];
+  const allRoutes = [...appRoutes, ...pluginSpreads];
+  if (allImports.length === 0 && pluginDeclarations.length === 0 && allRoutes.length === 0) {
     return `export const customRoutes = []`;
   }
-  const routeTree = buildRouteTree(results);
-  const imports = routeTree.flatMap((result) => result.imports);
-  const routes = routeTree.map((result) => formatRoute(result.route));
-  return `${imports.join("\n")}
+  return `${allImports.join("\n")}
+
+${pluginDeclarations.join("\n")}
 
 export const customRoutes = [
-${routes.join(",\n")}
+${allRoutes.join(",\n")}
 ]`;
 }
 
@@ -319,29 +393,90 @@ function getRoute2(file, pagesDir) {
     ""
   ) || "/";
 }
-function hasConfigExport(filePath) {
-  try {
-    const content = import_fs2.default.readFileSync(filePath, "utf-8");
-    return /export\s+(const|let|var)\s+config\b/.test(content) || /export\s*\{[^}]*\bconfig\b[^}]*\}/.test(content);
-  } catch {
-    return false;
+function getConfigObjectProperties(path6) {
+  if ((0, import_types.isVariableDeclarator)(path6.node)) {
+    const decl = (0, import_types.isIdentifier)(path6.node.id, { name: "config" }) ? path6.node : null;
+    if (!decl) return null;
+    if ((0, import_types.isCallExpression)(decl.init) && decl.init.arguments.length > 0 && (0, import_types.isObjectExpression)(decl.init.arguments[0])) {
+      return decl.init.arguments[0].properties;
+    }
+    if ((0, import_types.isObjectExpression)(decl.init)) {
+      return decl.init.properties;
+    }
+    return null;
+  }
+  const declaration = path6.node.declaration;
+  if ((0, import_types.isVariableDeclaration)(declaration)) {
+    const configDecl = declaration.declarations.find(
+      (d) => (0, import_types.isVariableDeclarator)(d) && (0, import_types.isIdentifier)(d.id, { name: "config" })
+    );
+    if (configDecl && (0, import_types.isCallExpression)(configDecl.init) && configDecl.init.arguments.length > 0 && (0, import_types.isObjectExpression)(configDecl.init.arguments[0])) {
+      return configDecl.init.arguments[0].properties;
+    }
+    const directDecl = declaration.declarations.find(
+      (d) => (0, import_types.isVariableDeclarator)(d) && (0, import_types.isIdentifier)(d.id, { name: "config" })
+    );
+    if (directDecl && (0, import_types.isObjectExpression)(directDecl.init)) {
+      return directDecl.init.properties;
+    }
   }
+  return null;
 }
-function getConfigProperties(filePath) {
+function processConfigProperties(properties) {
+  const hasProperty = (name) => properties.some(
+    (prop) => (0, import_types.isObjectProperty)(prop) && (0, import_types.isIdentifier)(prop.key, { name })
+  );
+  const hasLabel = hasProperty("label");
+  if (!hasLabel) {
+    return null;
+  }
+  const hasIcon = hasProperty("icon");
+  const nested = properties.find(
+    (prop) => (0, import_types.isObjectProperty)(prop) && (0, import_types.isIdentifier)(prop.key, { name: "nested" })
+  );
+  let nestedValue;
+  if (nested && (0, import_types.isObjectProperty)(nested) && (0, import_types.isStringLiteral)(nested.value)) {
+    nestedValue = nested.value.value;
+  }
+  const translationNs = properties.find(
+    (prop) => (0, import_types.isObjectProperty)(prop) && (0, import_types.isIdentifier)(prop.key, { name: "translationNs" })
+  );
+  let translationNsValue;
+  if (translationNs && (0, import_types.isObjectProperty)(translationNs) && (0, import_types.isStringLiteral)(translationNs.value)) {
+    translationNsValue = translationNs.value.value;
+  }
+  const rank = properties.find(
+    (prop) => (0, import_types.isObjectProperty)(prop) && (0, import_types.isIdentifier)(prop.key, { name: "rank" })
+  );
+  let rankValue;
+  if (rank && (0, import_types.isObjectProperty)(rank) && (0, import_types.isNumericLiteral)(rank.value)) {
+    rankValue = rank.value.value;
+  }
+  return { label: hasLabel, icon: hasIcon, rank: rankValue, nested: nestedValue, translationNs: translationNsValue };
+}
+function getRouteConfig(file) {
   try {
-    const content = import_fs2.default.readFileSync(filePath, "utf-8");
-    const hasLabel = /\blabel\s*[:=]/.test(content);
-    if (!hasLabel) {
-      return null;
-    }
-    const hasIcon = /\bicon\s*[:=]/.test(content);
-    const rankMatch = content.match(/\brank\s*:\s*(\d+)/);
-    const rank = rankMatch ? parseInt(rankMatch[1], 10) : void 0;
-    const nestedMatch = content.match(/\bnested\s*:\s*["']([^"']+)["']/);
-    const nested = nestedMatch ? nestedMatch[1] : void 0;
-    const translationNsMatch = content.match(/\btranslationNs\s*:\s*["']([^"']+)["']/);
-    const translationNs = translationNsMatch ? translationNsMatch[1] : void 0;
-    return { label: hasLabel, icon: hasIcon, rank, nested, translationNs };
+    const code = import_fs2.default.readFileSync(file, "utf-8");
+    const ast = (0, import_parser.parse)(code, getParserOptions(file));
+    let config = null;
+    let configFound = false;
+    traverse(ast, {
+      VariableDeclarator(path6) {
+        if (configFound) return;
+        const properties = getConfigObjectProperties(path6);
+        if (!properties) return;
+        config = processConfigProperties(properties);
+        if (config) configFound = true;
+      },
+      ExportNamedDeclaration(path6) {
+        if (configFound) return;
+        const properties = getConfigObjectProperties(path6);
+        if (!properties) return;
+        config = processConfigProperties(properties);
+        if (config) configFound = true;
+      }
+    });
+    return config;
   } catch {
     return null;
   }
@@ -378,10 +513,7 @@ ${parts.join(",\n")}
     }`;
 }
 function parseFile2(file, pagesDir, index) {
-  if (!hasConfigExport(file)) {
-    return null;
-  }
-  const config = getConfigProperties(file);
+  const config = getRouteConfig(file);
   if (!config) {
     return null;
   }
@@ -390,31 +522,37 @@ function parseFile2(file, pagesDir, index) {
     menuItem: generateMenuItem(config, file, pagesDir, index)
   };
 }
-function generateMenuItems({ srcDir }) {
+function generateMenuItems({ srcDir, pluginExtensions }) {
   const pagesDir = import_path2.default.join(srcDir, "pages");
-  const files = crawlPages2(pagesDir);
-  if (files.length === 0) {
-    return `export default { menuItems: [] }`;
-  }
   let index = 0;
   const results = [];
-  for (const file of files) {
+  for (const file of crawlPages2(pagesDir)) {
     const result = parseFile2(file, pagesDir, index);
     if (result) {
       results.push(result);
       index++;
     }
   }
-  if (results.length === 0) {
+  const pluginDeclarations = pluginExtensions.map(
+    (ext, i) => `const __plugin${i} = (await import("${normalizePath(ext)}")).default`
+  );
+  const pluginSpreads = pluginExtensions.map(
+    (_, i) => `        ...(__plugin${i}.menuItemModule?.menuItems ?? [])`
+  );
+  const appImports = results.map((r) => r.import);
+  const appMenuItems = results.map((r) => formatMenuItem(r.menuItem));
+  const allImports = [...appImports];
+  const allMenuItems = [...appMenuItems, ...pluginSpreads];
+  if (allImports.length === 0 && pluginDeclarations.length === 0 && allMenuItems.length === 0) {
     return `export default { menuItems: [] }`;
   }
-  const imports = results.map((r) => r.import);
-  const menuItems = results.map((r) => formatMenuItem(r.menuItem));
-  return `${imports.join("\n")}
+  return `${allImports.join("\n")}
+
+${pluginDeclarations.join("\n")}
 
 export default {
     menuItems: [
-${menuItems.join(",\n")}
+${allMenuItems.join(",\n")}
     ]
 }`;
 }
@@ -506,47 +644,111 @@ function loadI18nModule(mercurConfig) {
 }
 
 // src/plugin.ts
-function buildConfig(config, root) {
-  const srcDir = import_path5.default.join(root, "src");
-  return {
-    ...config,
-    backendUrl: config.backendUrl ?? "http://localhost:9000",
-    root,
-    srcDir,
-    configPath: import_path5.default.resolve(root, CONFIG_NAME)
-  };
+function isPageFile(file) {
+  const basename = import_path5.default.basename(file, import_path5.default.extname(file));
+  return basename === "page";
+}
+var UI_MODULE_KEYS = [
+  "admin_ui",
+  "vendor_ui"
+];
+function findNodeModulesRoot(configDir) {
+  let dir = configDir;
+  while (dir !== import_path5.default.dirname(dir)) {
+    const candidate = import_path5.default.join(dir, "node_modules");
+    if (import_fs4.default.existsSync(candidate) && import_fs4.default.statSync(candidate).isDirectory()) {
+      return candidate;
+    }
+    dir = import_path5.default.dirname(dir);
+  }
+  return import_path5.default.join(configDir, "node_modules");
 }
-async function loadMercurConfig(root) {
-  const configPath = import_path5.default.resolve(root, CONFIG_NAME);
+function resolvePluginRoot(resolve, configDir, nodeModulesRoot) {
   try {
-    const mod = await getFileExports(configPath);
-    const content = mod.default ?? mod;
-    return buildConfig(content, root);
-  } catch (error) {
-    console.error(error);
-    throw new Error(
-      `[@mercurjs/dashboard-sdk] Could not find or load ${CONFIG_NAME} in ${root}`
-    );
+    if (resolve.startsWith(".")) {
+      const resolved = import_path5.default.resolve(configDir, resolve);
+      if (import_fs4.default.existsSync(resolved)) {
+        return import_fs4.default.realpathSync(resolved);
+      }
+      return null;
+    }
+    const packagePath = import_path5.default.join(nodeModulesRoot, resolve);
+    if (!import_fs4.default.existsSync(packagePath)) {
+      return null;
+    }
+    return import_fs4.default.realpathSync(packagePath);
+  } catch {
+    return null;
   }
 }
-function isPageFile(file) {
-  const basename = import_path5.default.basename(file, import_path5.default.extname(file));
-  return basename === "page";
+function resolvePluginExtensions(plugins, configDir) {
+  const nodeModulesRoot = findNodeModulesRoot(configDir);
+  const extensions = [];
+  const appTypes = ["admin", "vendor"];
+  for (const plugin of plugins) {
+    const resolve = typeof plugin === "string" ? plugin : plugin?.resolve;
+    if (!resolve || typeof resolve !== "string") continue;
+    const pluginRoot = resolvePluginRoot(resolve, configDir, nodeModulesRoot);
+    if (!pluginRoot) continue;
+    for (const appType of appTypes) {
+      const extFile = import_path5.default.join(pluginRoot, ".medusa/server/src", appType, "index.mjs");
+      if (import_fs4.default.existsSync(extFile)) {
+        extensions.push(extFile);
+      }
+    }
+  }
+  return extensions;
+}
+async function loadMedusaConfig(medusaConfigPath, root) {
+  try {
+    const mod = await getFileExports(medusaConfigPath);
+    const medusaConfig = mod.default ?? mod;
+    const modules = medusaConfig?.modules ?? {};
+    const configDir = import_path5.default.dirname(medusaConfigPath);
+    let base;
+    for (const key of UI_MODULE_KEYS) {
+      const value = modules[key];
+      if (!value || typeof value !== "object" || !value.options?.appDir) continue;
+      const appDir = import_path5.default.resolve(configDir, value.options.appDir);
+      if (appDir === root) {
+        base = value.options.path;
+        break;
+      }
+    }
+    const plugins = medusaConfig?.plugins?.filter((plugin) => plugin.resolve !== "@medusajs/draft-order") ?? [];
+    const pluginExtensions = resolvePluginExtensions(plugins, configDir);
+    return { base, pluginExtensions };
+  } catch {
+    return { pluginExtensions: [] };
+  }
 }
-function dashboardPlugin() {
+function mercurDashboardPlugin(pluginConfig) {
   let root;
   let config;
   return {
     name: "@mercurjs/dashboard-sdk",
     async config(viteConfig) {
       root = viteConfig.root || process.cwd();
-      config = await loadMercurConfig(root);
+      const medusaConfigPath = import_path5.default.resolve(root, pluginConfig.medusaConfigPath);
+      const { base, pluginExtensions } = await loadMedusaConfig(medusaConfigPath, root);
+      const srcDir = import_path5.default.join(root, "src");
+      const backendUrl = pluginConfig.backendUrl ?? "http://localhost:9000";
+      config = {
+        ...pluginConfig,
+        backendUrl,
+        base,
+        root,
+        srcDir,
+        pluginExtensions
+      };
       return {
+        base: config.base,
         define: {
-          "__BACKEND_URL__": JSON.stringify(config.backendUrl)
+          "__BACKEND_URL__": JSON.stringify(config.backendUrl),
+          "__BASE__": JSON.stringify(config.base || "/")
         },
         optimizeDeps: {
-          exclude: ["@mercurjs/vendor", "virtual:mercur/config"]
+          exclude: ["virtual:mercur/config", "virtual:mercur/routes", "virtual:mercur/components", "virtual:mercur/menu-items", "virtual:mercur/i18n"]
         }
       };
     },
@@ -575,11 +777,6 @@ function dashboardPlugin() {
       server.watcher.on("unlink", handlePageChange);
     },
     handleHotUpdate({ file, server }) {
-      const configPath = import_path5.default.resolve(root, CONFIG_NAME);
-      if (file === configPath) {
-        server.restart();
-        return;
-      }
       if (isPageFile(file)) {
         const mod = server.moduleGraph.getModuleById(RESOLVED_ROUTES_MODULE);
         if (mod) {
@@ -589,13 +786,7 @@ function dashboardPlugin() {
     }
   };
 }
-
-// src/define-config.ts
-function defineConfig(config) {
-  return config;
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  dashboardPlugin,
-  defineConfig
+  mercurDashboardPlugin
 });

package/dist/index.d.cts

@@ -1,9 +1,9 @@
 import * as Vite from 'vite';
 import { ComponentType } from 'react';
 
-declare function dashboardPlugin(): Vite.Plugin;
-
 interface MercurConfig {
+    medusaConfigPath: string;
+    backendUrl?: string;
     name?: string;
     logo?: string;
     components?: {
@@ -14,13 +14,14 @@ interface MercurConfig {
     i18n?: {
         defaultLanguage: string;
     };
-    backendUrl?: string;
+    enableSellerRegistration?: boolean;
 }
 interface BuiltMercurConfig extends MercurConfig {
     backendUrl: string;
+    base?: string;
     root: string;
     srcDir: string;
-    configPath: string;
+    pluginExtensions: string[];
 }
 type RouteConfig = {
     label: string;
@@ -31,6 +32,6 @@ type RouteConfig = {
     public?: boolean;
 };
 
-declare function defineConfig(config: MercurConfig): MercurConfig;
+declare function mercurDashboardPlugin(pluginConfig: MercurConfig): Vite.Plugin;
 
-export { type BuiltMercurConfig, type MercurConfig, type RouteConfig, dashboardPlugin, defineConfig };
+export { type BuiltMercurConfig, type MercurConfig, type RouteConfig, mercurDashboardPlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mercurjs/dashboard-sdk",
-  "version": "2.0.0-canary.8",
+  "version": "2.0.0-canary.80",
   "repository": {
     "type": "git",
     "url": "https://github.com/mercurjs/mercur",
@@ -25,6 +25,9 @@
     "lint": "eslint . --ext ts,tsx --report-unused-disable-directives --max-warnings 0"
   },
   "dependencies": {
+    "@babel/parser": "7.25.6",
+    "@babel/traverse": "7.25.6",
+    "@babel/types": "7.25.6",
     "esbuild-register": "^3.6.0"
   },
   "devDependencies": {