@frontmcp/uipack 0.12.2 → 1.0.0-beta.2

package/resolver/index.js

@@ -0,0 +1,708 @@
+"use strict";
+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);
+
+// libs/uipack/src/resolver/index.ts
+var resolver_exports = {};
+__export(resolver_exports, {
+  DEFAULT_CDN_REGISTRY: () => DEFAULT_CDN_REGISTRY,
+  createEsmShResolver: () => createEsmShResolver,
+  createImportMap: () => createImportMap,
+  createImportMapFromResolved: () => createImportMapFromResolved,
+  createResolverWithOverrides: () => createResolverWithOverrides,
+  extractExternalPackages: () => extractExternalPackages,
+  generateCDNScriptTags: () => generateCDNScriptTags,
+  generateDependencyHTML: () => generateDependencyHTML,
+  generateImportMapScriptTag: () => generateImportMapScriptTag,
+  generateImportMapScriptTagMinified: () => generateImportMapScriptTagMinified,
+  getPackageCDNUrl: () => getPackageCDNUrl,
+  getPackageName: () => getPackageName,
+  getPackagePeerDependencies: () => getPackagePeerDependencies,
+  getRegisteredPackages: () => getRegisteredPackages,
+  isPackageRegistered: () => isPackageRegistered,
+  lookupPackage: () => lookupPackage,
+  mergeImportMaps: () => mergeImportMaps,
+  mergeRegistries: () => mergeRegistries,
+  parseImports: () => parseImports,
+  rewriteImports: () => rewriteImports,
+  validateImportMap: () => validateImportMap
+});
+module.exports = __toCommonJS(resolver_exports);
+
+// libs/uipack/src/resolver/cdn-registry.ts
+var DEFAULT_CDN_REGISTRY = {
+  react: {
+    packageName: "react",
+    defaultVersion: "19.2.4",
+    providers: {
+      cloudflare: {
+        url: "https://cdnjs.cloudflare.com/ajax/libs/react/19.2.4/umd/react.production.min.js",
+        global: "React",
+        crossorigin: "anonymous"
+      },
+      jsdelivr: {
+        url: "https://cdn.jsdelivr.net/npm/react@19.2.4/umd/react.production.min.js",
+        global: "React",
+        crossorigin: "anonymous"
+      },
+      unpkg: {
+        url: "https://unpkg.com/react@19.2.4/umd/react.production.min.js",
+        global: "React",
+        crossorigin: "anonymous"
+      },
+      "esm.sh": {
+        url: "https://esm.sh/react@19.2.4",
+        esm: true,
+        crossorigin: "anonymous"
+      }
+    },
+    preferredProviders: ["esm.sh", "cloudflare", "jsdelivr", "unpkg"],
+    metadata: {
+      description: "A JavaScript library for building user interfaces",
+      homepage: "https://react.dev",
+      license: "MIT"
+    }
+  },
+  "react-dom": {
+    packageName: "react-dom",
+    defaultVersion: "19.2.4",
+    providers: {
+      cloudflare: {
+        url: "https://cdnjs.cloudflare.com/ajax/libs/react-dom/19.2.4/umd/react-dom.production.min.js",
+        global: "ReactDOM",
+        crossorigin: "anonymous",
+        peerDependencies: ["react"]
+      },
+      jsdelivr: {
+        url: "https://cdn.jsdelivr.net/npm/react-dom@19.2.4/umd/react-dom.production.min.js",
+        global: "ReactDOM",
+        crossorigin: "anonymous",
+        peerDependencies: ["react"]
+      },
+      unpkg: {
+        url: "https://unpkg.com/react-dom@19.2.4/umd/react-dom.production.min.js",
+        global: "ReactDOM",
+        crossorigin: "anonymous",
+        peerDependencies: ["react"]
+      },
+      "esm.sh": {
+        url: "https://esm.sh/react-dom@19.2.4",
+        esm: true,
+        crossorigin: "anonymous",
+        peerDependencies: ["react"]
+      }
+    },
+    preferredProviders: ["esm.sh", "cloudflare", "jsdelivr", "unpkg"],
+    metadata: {
+      description: "React package for working with the DOM",
+      homepage: "https://react.dev",
+      license: "MIT"
+    }
+  },
+  "chart.js": {
+    packageName: "chart.js",
+    defaultVersion: "4.5.1",
+    providers: {
+      cloudflare: {
+        url: "https://cdnjs.cloudflare.com/ajax/libs/Chart.js/4.5.1/chart.umd.min.js",
+        global: "Chart",
+        crossorigin: "anonymous"
+      },
+      jsdelivr: {
+        url: "https://cdn.jsdelivr.net/npm/chart.js@4.5.1/dist/chart.umd.min.js",
+        global: "Chart",
+        crossorigin: "anonymous"
+      },
+      unpkg: {
+        url: "https://unpkg.com/chart.js@4.5.1/dist/chart.umd.min.js",
+        global: "Chart",
+        crossorigin: "anonymous"
+      }
+    },
+    preferredProviders: ["esm.sh", "cloudflare", "jsdelivr", "unpkg"],
+    metadata: {
+      description: "Simple yet flexible JavaScript charting library",
+      homepage: "https://www.chartjs.org",
+      license: "MIT"
+    }
+  },
+  d3: {
+    packageName: "d3",
+    defaultVersion: "7.9.0",
+    providers: {
+      cloudflare: {
+        url: "https://cdnjs.cloudflare.com/ajax/libs/d3/7.9.0/d3.min.js",
+        integrity: "sha512-vc58qvvBdrDR4etbxMdlTt4GBQk1qjvyORR2nrsPsFPyrs+/u5c3+1Ct6upOgdZoIl7eq6k3a1UPDSNAQi/32A==",
+        global: "d3",
+        crossorigin: "anonymous"
+      },
+      jsdelivr: {
+        url: "https://cdn.jsdelivr.net/npm/d3@7.9.0/dist/d3.min.js",
+        global: "d3",
+        crossorigin: "anonymous"
+      },
+      unpkg: {
+        url: "https://unpkg.com/d3@7.9.0/dist/d3.min.js",
+        global: "d3",
+        crossorigin: "anonymous"
+      }
+    },
+    preferredProviders: ["esm.sh", "cloudflare", "jsdelivr", "unpkg"],
+    metadata: {
+      description: "Data-Driven Documents",
+      homepage: "https://d3js.org",
+      license: "ISC"
+    }
+  },
+  lodash: {
+    packageName: "lodash",
+    defaultVersion: "4.17.21",
+    providers: {
+      cloudflare: {
+        url: "https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.21/lodash.min.js",
+        integrity: "sha512-WFN04846sdKMIP5LKNphMaWzU7YpMyCU245etK3g/2ARYbPK9Ub18eG+ljU96qKRCWh+quCY7yefSmlkQw1ANQ==",
+        global: "_",
+        crossorigin: "anonymous"
+      },
+      jsdelivr: {
+        url: "https://cdn.jsdelivr.net/npm/lodash@4.17.21/lodash.min.js",
+        global: "_",
+        crossorigin: "anonymous"
+      },
+      unpkg: {
+        url: "https://unpkg.com/lodash@4.17.21/lodash.min.js",
+        global: "_",
+        crossorigin: "anonymous"
+      }
+    },
+    preferredProviders: ["esm.sh", "cloudflare", "jsdelivr", "unpkg"],
+    metadata: {
+      description: "A modern JavaScript utility library",
+      homepage: "https://lodash.com",
+      license: "MIT"
+    }
+  }
+};
+function lookupPackage(packageName, registry = DEFAULT_CDN_REGISTRY) {
+  return registry[packageName];
+}
+function getPackageCDNUrl(packageName, providerOrder = ["esm.sh", "cloudflare", "jsdelivr", "unpkg"], registry = DEFAULT_CDN_REGISTRY) {
+  const entry = lookupPackage(packageName, registry);
+  if (!entry) return void 0;
+  for (const provider of providerOrder) {
+    const config = entry.providers[provider];
+    if (config?.url) {
+      return config.url;
+    }
+  }
+  for (const provider of Object.keys(entry.providers)) {
+    const config = entry.providers[provider];
+    if (config?.url) {
+      return config.url;
+    }
+  }
+  return void 0;
+}
+function getRegisteredPackages(registry = DEFAULT_CDN_REGISTRY) {
+  return Object.keys(registry);
+}
+function isPackageRegistered(packageName, registry = DEFAULT_CDN_REGISTRY) {
+  return packageName in registry;
+}
+function mergeRegistries(customRegistry) {
+  return {
+    ...DEFAULT_CDN_REGISTRY,
+    ...customRegistry
+  };
+}
+function getPackagePeerDependencies(packageName, registry = DEFAULT_CDN_REGISTRY) {
+  const entry = lookupPackage(packageName, registry);
+  if (!entry) return [];
+  for (const provider of Object.keys(entry.providers)) {
+    const config = entry.providers[provider];
+    if (config?.peerDependencies) {
+      return config.peerDependencies;
+    }
+  }
+  return [];
+}
+
+// libs/uipack/src/resolver/import-parser.ts
+var IMPORT_PATTERNS = {
+  named: /import\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]/g,
+  default: /import\s+(\w+)\s+from\s*['"]([^'"]+)['"]/g,
+  namespace: /import\s*\*\s*as\s+(\w+)\s+from\s*['"]([^'"]+)['"]/g,
+  sideEffect: /import\s*['"]([^'"]+)['"]/g,
+  dynamic: /(?:await\s+)?import\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+  defaultAndNamed: /import\s+(\w+)\s*,\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]/g,
+  defaultAndNamespace: /import\s+(\w+)\s*,\s*\*\s*as\s+(\w+)\s+from\s*['"]([^'"]+)['"]/g,
+  reExport: /export\s*\{[^}]+\}\s*from\s*['"]([^'"]+)['"]/g,
+  reExportAll: /export\s*\*\s*from\s*['"]([^'"]+)['"]/g
+};
+function parseNamedImports(namedString) {
+  return namedString.split(",").map((s) => s.trim()).filter((s) => s.length > 0).map((s) => {
+    const asMatch = s.match(/^(\w+)\s+as\s+\w+$/);
+    return asMatch ? asMatch[1] : s;
+  });
+}
+function isRelativeImport(specifier) {
+  return specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/");
+}
+function isExternalImport(specifier) {
+  return !isRelativeImport(specifier) && !specifier.startsWith("#");
+}
+function getPackageName(specifier) {
+  if (specifier.startsWith("@")) {
+    const parts = specifier.split("/");
+    if (parts.length >= 2) {
+      return `${parts[0]}/${parts[1]}`;
+    }
+    return specifier;
+  }
+  const firstSlash = specifier.indexOf("/");
+  return firstSlash === -1 ? specifier : specifier.slice(0, firstSlash);
+}
+function getLineNumber(source, index) {
+  let line = 1;
+  for (let i = 0; i < index && i < source.length; i++) {
+    if (source[i] === "\n") {
+      line++;
+    }
+  }
+  return line;
+}
+function getColumnNumber(source, index) {
+  let column = 0;
+  for (let i = index - 1; i >= 0 && source[i] !== "\n"; i--) {
+    column++;
+  }
+  return column;
+}
+function parseImports(source) {
+  const imports = [];
+  const seenStatements = /* @__PURE__ */ new Set();
+  const addImport = (imp) => {
+    const key = `${imp.type}:${imp.specifier}:${imp.statement}`;
+    if (!seenStatements.has(key)) {
+      seenStatements.add(key);
+      imports.push(imp);
+    }
+  };
+  let match;
+  const defaultAndNamedRegex = new RegExp(IMPORT_PATTERNS.defaultAndNamed.source, "g");
+  while ((match = defaultAndNamedRegex.exec(source)) !== null) {
+    const [statement, defaultName, namedString, specifier] = match;
+    addImport({
+      statement,
+      specifier,
+      type: "default",
+      defaultImport: defaultName,
+      namedImports: parseNamedImports(namedString),
+      line: getLineNumber(source, match.index),
+      column: getColumnNumber(source, match.index)
+    });
+  }
+  const defaultAndNamespaceRegex = new RegExp(IMPORT_PATTERNS.defaultAndNamespace.source, "g");
+  while ((match = defaultAndNamespaceRegex.exec(source)) !== null) {
+    const [statement, defaultName, namespaceName, specifier] = match;
+    addImport({
+      statement,
+      specifier,
+      type: "default",
+      defaultImport: defaultName,
+      namespaceImport: namespaceName,
+      line: getLineNumber(source, match.index),
+      column: getColumnNumber(source, match.index)
+    });
+  }
+  const namedRegex = new RegExp(IMPORT_PATTERNS.named.source, "g");
+  while ((match = namedRegex.exec(source)) !== null) {
+    const [statement, namedString, specifier] = match;
+    addImport({
+      statement,
+      specifier,
+      type: "named",
+      namedImports: parseNamedImports(namedString),
+      line: getLineNumber(source, match.index),
+      column: getColumnNumber(source, match.index)
+    });
+  }
+  const defaultRegex = new RegExp(IMPORT_PATTERNS.default.source, "g");
+  while ((match = defaultRegex.exec(source)) !== null) {
+    const [statement, defaultName, specifier] = match;
+    const afterMatch = source.slice(match.index + match[0].length - specifier.length - 2);
+    if (afterMatch.startsWith(",")) continue;
+    addImport({
+      statement,
+      specifier,
+      type: "default",
+      defaultImport: defaultName,
+      line: getLineNumber(source, match.index),
+      column: getColumnNumber(source, match.index)
+    });
+  }
+  const namespaceRegex = new RegExp(IMPORT_PATTERNS.namespace.source, "g");
+  while ((match = namespaceRegex.exec(source)) !== null) {
+    const [statement, namespaceName, specifier] = match;
+    addImport({
+      statement,
+      specifier,
+      type: "namespace",
+      namespaceImport: namespaceName,
+      line: getLineNumber(source, match.index),
+      column: getColumnNumber(source, match.index)
+    });
+  }
+  const sideEffectRegex = new RegExp(IMPORT_PATTERNS.sideEffect.source, "g");
+  while ((match = sideEffectRegex.exec(source)) !== null) {
+    const [statement, specifier] = match;
+    const beforeMatch = source.slice(Math.max(0, match.index - 50), match.index);
+    if (beforeMatch.includes("from")) continue;
+    addImport({
+      statement,
+      specifier,
+      type: "side-effect",
+      line: getLineNumber(source, match.index),
+      column: getColumnNumber(source, match.index)
+    });
+  }
+  const dynamicRegex = new RegExp(IMPORT_PATTERNS.dynamic.source, "g");
+  while ((match = dynamicRegex.exec(source)) !== null) {
+    const [statement, specifier] = match;
+    addImport({
+      statement,
+      specifier,
+      type: "dynamic",
+      line: getLineNumber(source, match.index),
+      column: getColumnNumber(source, match.index)
+    });
+  }
+  const reExportRegex = new RegExp(IMPORT_PATTERNS.reExport.source, "g");
+  while ((match = reExportRegex.exec(source)) !== null) {
+    const [statement, specifier] = match;
+    addImport({
+      statement,
+      specifier,
+      type: "named",
+      line: getLineNumber(source, match.index),
+      column: getColumnNumber(source, match.index)
+    });
+  }
+  const reExportAllRegex = new RegExp(IMPORT_PATTERNS.reExportAll.source, "g");
+  while ((match = reExportAllRegex.exec(source)) !== null) {
+    const [statement, specifier] = match;
+    addImport({
+      statement,
+      specifier,
+      type: "namespace",
+      line: getLineNumber(source, match.index),
+      column: getColumnNumber(source, match.index)
+    });
+  }
+  const externalImports = imports.filter((imp) => isExternalImport(imp.specifier));
+  const relativeImports = imports.filter((imp) => isRelativeImport(imp.specifier));
+  const externalPackages = [...new Set(externalImports.map((imp) => getPackageName(imp.specifier)))];
+  return {
+    imports,
+    externalImports,
+    relativeImports,
+    externalPackages
+  };
+}
+function extractExternalPackages(source) {
+  return parseImports(source).externalPackages;
+}
+
+// libs/uipack/src/resolver/esm-sh.resolver.ts
+var DEFAULT_FALLBACK_CDN = "https://esm.sh";
+function createResolverWithOverrides(overrides, baseOptions) {
+  const base = createEsmShResolver(baseOptions);
+  return {
+    overrides,
+    resolve(specifier, context) {
+      if (overrides[specifier]) {
+        return { value: overrides[specifier], type: "url" };
+      }
+      for (const [prefix, url] of Object.entries(overrides)) {
+        if (specifier.startsWith(prefix + "/")) {
+          const subpath = specifier.slice(prefix.length);
+          return { value: url + subpath, type: "url" };
+        }
+      }
+      return base.resolve(specifier, context);
+    }
+  };
+}
+function createEsmShResolver(options = {}) {
+  const {
+    fallbackCdnBase = DEFAULT_FALLBACK_CDN,
+    registry = DEFAULT_CDN_REGISTRY,
+    providerOrder = ["esm.sh", "cloudflare", "jsdelivr", "unpkg"]
+  } = options;
+  return {
+    resolve(specifier, _context) {
+      if (specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/")) {
+        return null;
+      }
+      if (specifier.startsWith("node:") || specifier.startsWith("#")) {
+        return null;
+      }
+      const pkgName = getPackageName(specifier);
+      const entry = lookupPackage(pkgName, registry);
+      if (entry) {
+        for (const provider of providerOrder) {
+          const config = entry.providers[provider];
+          if (config?.url) {
+            const subpath = specifier.slice(pkgName.length);
+            if (subpath && config.url.includes("esm.sh/")) {
+              return {
+                value: config.url + subpath,
+                type: "url",
+                integrity: config.integrity
+              };
+            }
+            if (subpath) {
+              return {
+                value: `${fallbackCdnBase}/${specifier}`,
+                type: "url"
+              };
+            }
+            if (config.global && !config.esm) {
+              return {
+                value: config.url,
+                type: "url",
+                integrity: config.integrity
+              };
+            }
+            return {
+              value: config.url,
+              type: "url",
+              integrity: config.integrity
+            };
+          }
+        }
+      }
+      return {
+        value: `${fallbackCdnBase}/${specifier}`,
+        type: "url"
+      };
+    }
+  };
+}
+
+// libs/uipack/src/utils/index.ts
+function escapeHtmlAttr(str) {
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+}
+
+// libs/uipack/src/resolver/import-map.ts
+function createImportMapFromResolved(resolved) {
+  const imports = {};
+  const integrity = {};
+  for (const [specifier, res] of Object.entries(resolved)) {
+    if (res.type === "url") {
+      imports[specifier] = res.value;
+      if (res.integrity) {
+        integrity[res.value] = res.integrity;
+      }
+    }
+  }
+  return {
+    imports,
+    integrity: Object.keys(integrity).length > 0 ? integrity : void 0
+  };
+}
+function createImportMap(dependencies) {
+  const imports = {};
+  const integrity = {};
+  for (const dep of dependencies) {
+    imports[dep.packageName] = dep.cdnUrl;
+    if (dep.integrity) {
+      integrity[dep.cdnUrl] = dep.integrity;
+    }
+  }
+  return {
+    imports,
+    integrity: Object.keys(integrity).length > 0 ? integrity : void 0
+  };
+}
+function mergeImportMaps(...maps) {
+  const imports = {};
+  const integrity = {};
+  const scopes = {};
+  for (const map of maps) {
+    Object.assign(imports, map.imports);
+    if (map.integrity) {
+      Object.assign(integrity, map.integrity);
+    }
+    if (map.scopes) {
+      for (const [scope, mappings] of Object.entries(map.scopes)) {
+        scopes[scope] = { ...scopes[scope], ...mappings };
+      }
+    }
+  }
+  return {
+    imports,
+    integrity: Object.keys(integrity).length > 0 ? integrity : void 0,
+    scopes: Object.keys(scopes).length > 0 ? scopes : void 0
+  };
+}
+function generateImportMapScriptTag(map) {
+  const json = JSON.stringify(map, null, 2).replace(/<\//g, "<\\/");
+  return `<script type="importmap">
+${json}
+</script>`;
+}
+function generateImportMapScriptTagMinified(map) {
+  const json = JSON.stringify(map).replace(/<\//g, "<\\/");
+  return `<script type="importmap">${json}</script>`;
+}
+function generateCDNScriptTags(dependencies) {
+  return dependencies.filter((dep) => !dep.esm).map((dep) => {
+    const attrs = [`src="${escapeHtmlAttr(dep.cdnUrl)}"`];
+    if (dep.integrity) {
+      attrs.push(`integrity="${escapeHtmlAttr(dep.integrity)}"`);
+    }
+    attrs.push('crossorigin="anonymous"');
+    return `<script ${attrs.join(" ")}></script>`;
+  });
+}
+function generateDependencyHTML(dependencies, options = {}) {
+  const { minify = false } = options;
+  const parts = [];
+  const importMap = createImportMap(dependencies);
+  const importMapTag = minify ? generateImportMapScriptTagMinified(importMap) : generateImportMapScriptTag(importMap);
+  parts.push(importMapTag);
+  const umdTags = generateCDNScriptTags(dependencies);
+  parts.push(...umdTags);
+  return parts.join(minify ? "" : "\n");
+}
+function validateImportMap(map) {
+  const errors = [];
+  if (typeof map !== "object" || map === null) {
+    return { valid: false, errors: ["Import map must be an object"] };
+  }
+  const obj = map;
+  if (!obj["imports"]) {
+    errors.push('Import map must have an "imports" field');
+  } else if (typeof obj["imports"] !== "object" || obj["imports"] === null) {
+    errors.push('"imports" must be an object');
+  } else {
+    const imports = obj["imports"];
+    for (const [key, value] of Object.entries(imports)) {
+      if (typeof value !== "string") {
+        errors.push(`Import "${key}" must map to a string URL`);
+      } else if (!value.startsWith("https://")) {
+        errors.push(`Import "${key}" URL must use HTTPS: ${value}`);
+      }
+    }
+  }
+  if (obj["integrity"] !== void 0) {
+    if (typeof obj["integrity"] !== "object" || obj["integrity"] === null) {
+      errors.push('"integrity" must be an object');
+    } else {
+      const integrity = obj["integrity"];
+      for (const [url, hash] of Object.entries(integrity)) {
+        if (typeof hash !== "string") {
+          errors.push(`Integrity for "${url}" must be a string`);
+        } else if (!hash.match(/^sha(256|384|512)-/)) {
+          errors.push(`Invalid integrity hash format for "${url}": ${hash}`);
+        }
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+// libs/uipack/src/resolver/import-rewriter.ts
+function rewriteImports(source, options = {}) {
+  const { resolver = createEsmShResolver(), skipPackages = [], overrides = {} } = options;
+  const skipSet = new Set(skipPackages);
+  const rewrites = /* @__PURE__ */ new Map();
+  const fallbackPackages = [];
+  const parsed = parseImports(source);
+  const specifierMap = /* @__PURE__ */ new Map();
+  for (const imp of parsed.externalImports) {
+    const specifier = imp.specifier;
+    if (specifierMap.has(specifier)) continue;
+    if (specifier.startsWith("node:")) continue;
+    const pkgName = getPackageName(specifier);
+    if (skipSet.has(pkgName)) continue;
+    if (overrides[specifier]) {
+      specifierMap.set(specifier, overrides[specifier]);
+      continue;
+    }
+    if (overrides[pkgName]) {
+      const subpath = specifier.slice(pkgName.length);
+      specifierMap.set(specifier, overrides[pkgName] + subpath);
+      continue;
+    }
+    const resolved = resolver.resolve(specifier);
+    if (resolved && resolved.type === "url") {
+      specifierMap.set(specifier, resolved.value);
+    }
+  }
+  let code = source;
+  for (const [specifier, cdnUrl] of specifierMap) {
+    const escaped = escapeRegExp(specifier);
+    const singleQuotePattern = new RegExp(`((?:import|export)\\s+(?:[^'"]*\\s+)?from\\s+)'${escaped}'`, "g");
+    const doubleQuotePattern = new RegExp(`((?:import|export)\\s+(?:[^'"]*\\s+)?from\\s+)"${escaped}"`, "g");
+    const dynamicSinglePattern = new RegExp(`(import\\s*\\(\\s*)'${escaped}'`, "g");
+    const dynamicDoublePattern = new RegExp(`(import\\s*\\(\\s*)"${escaped}"`, "g");
+    const sideEffectSinglePattern = new RegExp(`(import\\s+)'${escaped}'`, "g");
+    const sideEffectDoublePattern = new RegExp(`(import\\s+)"${escaped}"`, "g");
+    const beforeLength = code.length;
+    code = code.replace(singleQuotePattern, `$1'${cdnUrl}'`).replace(doubleQuotePattern, `$1"${cdnUrl}"`).replace(dynamicSinglePattern, `$1'${cdnUrl}'`).replace(dynamicDoublePattern, `$1"${cdnUrl}"`).replace(sideEffectSinglePattern, `$1'${cdnUrl}'`).replace(sideEffectDoublePattern, `$1"${cdnUrl}"`);
+    if (code.length !== beforeLength || code !== source) {
+      rewrites.set(specifier, cdnUrl);
+    }
+  }
+  return {
+    code,
+    rewrittenCount: rewrites.size,
+    rewrites,
+    fallbackPackages
+  };
+}
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_CDN_REGISTRY,
+  createEsmShResolver,
+  createImportMap,
+  createImportMapFromResolved,
+  createResolverWithOverrides,
+  extractExternalPackages,
+  generateCDNScriptTags,
+  generateDependencyHTML,
+  generateImportMapScriptTag,
+  generateImportMapScriptTagMinified,
+  getPackageCDNUrl,
+  getPackageName,
+  getPackagePeerDependencies,
+  getRegisteredPackages,
+  isPackageRegistered,
+  lookupPackage,
+  mergeImportMaps,
+  mergeRegistries,
+  parseImports,
+  rewriteImports,
+  validateImportMap
+});