@esm.sh/import-map 0.2.0 → 0.3.0

package/dist/add.mjs

@@ -1,374 +0,0 @@
-import { satisfies, valid } from "semver";
-async function addImport(importMap, specifier, noSRI) {
-  const imp = parseImportSpecifier(specifier);
-  const config = importMap.config ?? {};
-  const target = normalizeTarget(config.target);
-  const cdnOrigin = getCdnOrigin(config.cdn);
-  const meta = await fetchImportMeta(cdnOrigin, imp, target);
-  const mark = /* @__PURE__ */ new Set();
-  await addImportMeta(importMap, mark, meta, false, void 0, cdnOrigin, target, noSRI ?? false);
-}
-const KNOWN_TARGETS = /* @__PURE__ */ new Set([
-  "es2015",
-  "es2016",
-  "es2017",
-  "es2018",
-  "es2019",
-  "es2020",
-  "es2021",
-  "es2022",
-  "es2023",
-  "es2024",
-  "esnext"
-]);
-const ESM_SEGMENTS = /* @__PURE__ */ new Set([
-  "es2015",
-  "es2016",
-  "es2017",
-  "es2018",
-  "es2019",
-  "es2020",
-  "es2021",
-  "es2022",
-  "es2023",
-  "es2024",
-  "esnext",
-  "denonext",
-  "deno",
-  "node"
-]);
-const SPECIFIER_MARK_SEPARATOR = "\0";
-const META_CACHE = /* @__PURE__ */ new Map();
-function parseImportSpecifier(specifier) {
-  let source = specifier.trim();
-  const imp = {
-    name: "",
-    version: "",
-    subPath: "",
-    github: false,
-    jsr: false,
-    external: false,
-    dev: false
-  };
-  if (source.startsWith("gh:")) {
-    imp.github = true;
-    source = source.slice(3);
-  } else if (source.startsWith("jsr:")) {
-    imp.jsr = true;
-    source = source.slice(4);
-  }
-  let scopeName = "";
-  if ((source.startsWith("@") || imp.github) && source.includes("/")) {
-    [scopeName, source] = splitByFirst(source, "/");
-  }
-  let packageAndVersion = "";
-  [packageAndVersion, imp.subPath] = splitByFirst(source, "/");
-  [imp.name, imp.version] = splitByFirst(packageAndVersion, "@");
-  if (scopeName) {
-    imp.name = `${scopeName}/${imp.name}`;
-  }
-  if (!imp.name) {
-    throw new Error(`invalid package name or version: ${specifier}`);
-  }
-  return imp;
-}
-function normalizeTarget(target) {
-  if (target && KNOWN_TARGETS.has(target)) {
-    return target;
-  }
-  return "es2022";
-}
-function getCdnOrigin(cdn) {
-  if (cdn && (cdn.startsWith("https://") || cdn.startsWith("http://"))) {
-    return cdn.replace(/\/+$/, "");
-  }
-  return "https://esm.sh";
-}
-function specifierOf(imp) {
-  const prefix = imp.github ? "gh:" : imp.jsr ? "jsr:" : "";
-  return `${prefix}${imp.name}${imp.subPath ? `/${imp.subPath}` : ""}`;
-}
-function esmSpecifierOf(imp) {
-  const prefix = imp.github ? "gh/" : imp.jsr ? "jsr/" : "";
-  const external = hasExternalImports(imp) ? "*" : "";
-  return `${prefix}${external}${imp.name}@${imp.version}`;
-}
-function registryPrefix(imp) {
-  if (imp.github) {
-    return "gh/";
-  }
-  if (imp.jsr) {
-    return "jsr/";
-  }
-  return "";
-}
-function hasExternalImports(meta) {
-  if (meta.peerImports.length > 0) {
-    return true;
-  }
-  for (const dep of meta.imports) {
-    if (!dep.startsWith("/node/") && !dep.startsWith(`/${meta.name}@`)) {
-      return true;
-    }
-  }
-  return false;
-}
-function moduleUrlOf(cdnOrigin, target, imp) {
-  let url = `${cdnOrigin}/${esmSpecifierOf(imp)}/${target}/`;
-  if (imp.subPath) {
-    if (imp.dev || imp.subPath === "jsx-dev-runtime") {
-      url += `${imp.subPath}.development.mjs`;
-    } else {
-      url += `${imp.subPath}.mjs`;
-    }
-    return url;
-  }
-  const fileName = imp.name.includes("/") ? imp.name.split("/").at(-1) : imp.name;
-  return `${url}${fileName}.mjs`;
-}
-async function fetchImportMeta(cdnOrigin, imp, target) {
-  const star = imp.external ? "*" : "";
-  const version = imp.version ? `@${imp.version}` : "";
-  const subPath = imp.subPath ? `/${imp.subPath}` : "";
-  const targetQuery = target !== "es2022" ? `&target=${encodeURIComponent(target)}` : "";
-  const url = `${cdnOrigin}/${star}${registryPrefix(imp)}${imp.name}${version}${subPath}?meta${targetQuery}`;
-  const cached = META_CACHE.get(url);
-  if (cached) {
-    return cached;
-  }
-  const pending = (async () => {
-    const res = await fetch(url);
-    if (res.status === 404) {
-      throw new Error(`package not found: ${imp.name}${version}${subPath}`);
-    }
-    if (!res.ok) {
-      throw new Error(`unexpected http status ${res.status}: ${await res.text()}`);
-    }
-    const bodyText = await res.text();
-    let data;
-    try {
-      data = JSON.parse(bodyText);
-    } catch {
-      throw new Error(`invalid meta response from ${url}: ${bodyText.slice(0, 200)}`);
-    }
-    return {
-      name: data.name ?? imp.name,
-      version: data.version ?? imp.version,
-      subPath: imp.subPath,
-      github: imp.github,
-      jsr: imp.jsr,
-      external: imp.external,
-      dev: imp.dev,
-      module: data.module ?? "",
-      integrity: data.integrity ?? "",
-      exports: data.exports ?? [],
-      imports: data.imports ?? [],
-      peerImports: data.peerImports ?? []
-    };
-  })();
-  META_CACHE.set(url, pending);
-  try {
-    return await pending;
-  } catch (error) {
-    META_CACHE.delete(url);
-    throw error;
-  }
-}
-async function addImportMeta(importMap, mark, imp, indirect, targetImports, cdnOrigin, target, noSRI) {
-  const markedSpecifier = `${specifierOf(imp)}${SPECIFIER_MARK_SEPARATOR}${imp.version}`;
-  if (mark.has(markedSpecifier)) {
-    return;
-  }
-  mark.add(markedSpecifier);
-  const cdnScopeKey = `${cdnOrigin}/`;
-  const cdnScopeImports = importMap.scopes?.[cdnScopeKey];
-  const imports = indirect ? targetImports ?? ensureScope(importMap, cdnScopeKey) : importMap.imports;
-  const moduleUrl = moduleUrlOf(cdnOrigin, target, imp);
-  const currentSpecifier = specifierOf(imp);
-  imports[currentSpecifier] = moduleUrl;
-  await updateIntegrity(importMap, imp, moduleUrl, cdnOrigin, target, noSRI);
-  if (!indirect) {
-    if (cdnScopeImports) {
-      delete cdnScopeImports[currentSpecifier];
-    }
-    pruneEmptyScopes(importMap);
-  }
-  const allDeps = [
-    ...imp.peerImports.map((pathname) => ({ pathname, isPeer: true })),
-    ...imp.imports.map((pathname) => ({ pathname, isPeer: false }))
-  ];
-  await Promise.all(
-    allDeps.map(async ({ pathname, isPeer }) => {
-      if (pathname.startsWith("/node/")) {
-        return;
-      }
-      const depImport = parseEsmPath(pathname);
-      if (depImport.name === imp.name) {
-        depImport.version = imp.version;
-      }
-      const depSpecifier = specifierOf(depImport);
-      const existingUrl = importMap.imports[depSpecifier] ?? importMap.scopes?.[cdnScopeKey]?.[depSpecifier];
-      let scopedTargetImports = targetImports;
-      if (existingUrl?.startsWith(`${cdnOrigin}/`)) {
-        const existingImport = parseEsmPath(existingUrl);
-        const existingVersion = valid(existingImport.version);
-        if (existingVersion && depImport.version === existingImport.version) {
-          return;
-        }
-        if (existingVersion && depImport.version && !valid(depImport.version)) {
-          if (satisfies(existingVersion, depImport.version, { includePrerelease: true })) {
-            return;
-          }
-          if (isPeer) {
-            console.warn(
-              `incorrect peer dependency(unmeet ${depImport.version}): ${depImport.name}@${existingVersion}`
-            );
-            return;
-          }
-          const scope = `${cdnOrigin}/${esmSpecifierOf(imp)}/`;
-          scopedTargetImports = ensureScope(importMap, scope);
-        }
-      }
-      const depMeta = await fetchImportMeta(cdnOrigin, depImport, target);
-      await addImportMeta(importMap, mark, depMeta, !isPeer, scopedTargetImports, cdnOrigin, target, noSRI);
-    })
-  );
-  pruneEmptyScopes(importMap);
-}
-async function updateIntegrity(importMap, imp, moduleUrl, cdnOrigin, target, noSRI) {
-  if (noSRI) {
-    if (importMap.integrity) {
-      delete importMap.integrity[moduleUrl];
-      if (Object.keys(importMap.integrity).length === 0) {
-        delete importMap.integrity;
-      }
-    }
-    return;
-  }
-  if (!hasExternalImports(imp)) {
-    if (imp.integrity) {
-      importMap.integrity ??= {};
-      importMap.integrity[moduleUrl] = imp.integrity;
-    }
-    return;
-  }
-  const integrityMeta = await fetchImportMeta(
-    cdnOrigin,
-    {
-      name: imp.name,
-      version: imp.version,
-      subPath: imp.subPath,
-      github: imp.github,
-      jsr: imp.jsr,
-      external: true,
-      dev: imp.dev
-    },
-    target
-  );
-  if (integrityMeta.integrity) {
-    importMap.integrity ??= {};
-    importMap.integrity[moduleUrl] = integrityMeta.integrity;
-  }
-}
-function ensureScope(importMap, scopeKey) {
-  importMap.scopes ??= {};
-  importMap.scopes[scopeKey] ??= {};
-  return importMap.scopes[scopeKey];
-}
-function pruneEmptyScopes(importMap) {
-  if (!importMap.scopes) {
-    return;
-  }
-  for (const [scope, imports] of Object.entries(importMap.scopes)) {
-    if (Object.keys(imports).length === 0) {
-      delete importMap.scopes[scope];
-    }
-  }
-  if (Object.keys(importMap.scopes).length === 0) {
-    delete importMap.scopes;
-  }
-}
-function parseEsmPath(pathnameOrUrl) {
-  let pathname;
-  if (pathnameOrUrl.startsWith("https://") || pathnameOrUrl.startsWith("http://")) {
-    pathname = new URL(pathnameOrUrl).pathname;
-  } else if (pathnameOrUrl.startsWith("/")) {
-    pathname = splitByFirst(splitByFirst(pathnameOrUrl, "#")[0], "?")[0];
-  } else {
-    throw new Error(`invalid pathname or url: ${pathnameOrUrl}`);
-  }
-  const imp = {
-    name: "",
-    version: "",
-    subPath: "",
-    github: false,
-    jsr: false,
-    external: false,
-    dev: false
-  };
-  if (pathname.startsWith("/gh/")) {
-    imp.github = true;
-    pathname = pathname.slice(3);
-  } else if (pathname.startsWith("/jsr/")) {
-    imp.jsr = true;
-    pathname = pathname.slice(4);
-  }
-  const segs = pathname.split("/").filter(Boolean);
-  if (segs.length === 0) {
-    throw new Error(`invalid pathname: ${pathnameOrUrl}`);
-  }
-  if (segs[0].startsWith("@")) {
-    if (!segs[1]) {
-      throw new Error(`invalid pathname: ${pathnameOrUrl}`);
-    }
-    const [name, version] = splitByLast(segs[1], "@");
-    imp.name = `${segs[0]}/${name}`.replace(/^\*/, "");
-    imp.version = version;
-    segs.splice(0, 2);
-  } else {
-    const [name, version] = splitByLast(segs[0], "@");
-    imp.name = name.replace(/^\*/, "");
-    imp.version = version;
-    segs.splice(0, 1);
-  }
-  let hasTargetSegment = false;
-  if (segs[0] && ESM_SEGMENTS.has(segs[0])) {
-    hasTargetSegment = true;
-    segs.shift();
-  }
-  if (segs.length > 0) {
-    if (hasTargetSegment && pathname.endsWith(".mjs")) {
-      let subPath = segs.join("/");
-      if (subPath.endsWith(".mjs")) {
-        subPath = subPath.slice(0, -4);
-      }
-      if (subPath.endsWith(".development")) {
-        subPath = subPath.slice(0, -12);
-        imp.dev = true;
-      }
-      if (subPath.includes("/") || subPath !== imp.name && !imp.name.endsWith(`/${subPath}`)) {
-        imp.subPath = subPath;
-      }
-    } else {
-      imp.subPath = segs.join("/");
-    }
-  }
-  return imp;
-}
-function splitByFirst(value, separator) {
-  const idx = value.indexOf(separator);
-  if (idx < 0) {
-    return [value, ""];
-  }
-  return [value.slice(0, idx), value.slice(idx + separator.length)];
-}
-function splitByLast(value, separator) {
-  const idx = value.lastIndexOf(separator);
-  if (idx < 0) {
-    return [value, ""];
-  }
-  return [value.slice(0, idx), value.slice(idx + separator.length)];
-}
-export {
-  addImport
-};

package/dist/blank.mjs

@@ -1,17 +0,0 @@
-function createBlankImportMap(baseURL) {
-  return {
-    baseURL: new URL(baseURL ?? ".", "file:///"),
-    imports: {}
-  };
-}
-function isBlankImportMap(importMap) {
-  const { imports, scopes } = importMap;
-  if (Object.keys(imports).length > 0 || scopes && Object.keys(scopes).length > 0) {
-    return false;
-  }
-  return true;
-}
-export {
-  createBlankImportMap,
-  isBlankImportMap
-};

package/dist/parse.mjs

@@ -1,88 +0,0 @@
-import { createBlankImportMap } from "./blank.ts";
-function importMapFrom(v, baseURL) {
-  const im = createBlankImportMap(baseURL);
-  if (isObject(v)) {
-    const { config, imports, scopes, integrity } = v;
-    if (isObject(config)) {
-      validateStringMap(config);
-      im.config = config;
-    }
-    if (isObject(imports)) {
-      validateImports(imports);
-      im.imports = imports;
-    }
-    if (isObject(scopes)) {
-      validateScopes(scopes);
-      im.scopes = scopes;
-    }
-    if (isObject(integrity)) {
-      validateStringMap(integrity);
-      im.integrity = integrity;
-    }
-  }
-  return im;
-}
-function parseImportMapFromJson(json, baseURL) {
-  const im = createBlankImportMap(baseURL);
-  const v = JSON.parse(json);
-  if (isObject(v)) {
-    const { config, imports, scopes, integrity } = v;
-    if (isObject(config)) {
-      validateStringMap(config);
-      im.config = config;
-    }
-    if (isObject(imports)) {
-      validateImports(imports);
-      im.imports = imports;
-    }
-    if (isObject(scopes)) {
-      validateScopes(scopes);
-      im.scopes = scopes;
-    }
-    if (isObject(integrity)) {
-      validateStringMap(integrity);
-      im.integrity = integrity;
-    }
-  }
-  return im;
-}
-function parseImportMapFromHtml(html, baseURL) {
-  const tplEl = document.createElement("template");
-  tplEl.innerHTML = html;
-  const scriptEl = tplEl.content.querySelector("script[type='importmap']");
-  if (scriptEl) {
-    return parseImportMapFromJson(scriptEl.textContent, baseURL);
-  }
-  return createBlankImportMap(baseURL);
-}
-function validateImports(imports) {
-  for (const [k, v] of Object.entries(imports)) {
-    if (!v || typeof v !== "string") {
-      delete imports[k];
-    }
-  }
-}
-function validateScopes(imports) {
-  for (const [k, v] of Object.entries(imports)) {
-    if (isObject(v)) {
-      validateImports(v);
-    } else {
-      delete imports[k];
-    }
-  }
-}
-function validateStringMap(map) {
-  for (const [k, v] of Object.entries(map)) {
-    if (typeof v !== "string") {
-      delete map[k];
-    }
-  }
-}
-function isObject(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-export {
-  importMapFrom,
-  parseImportMapFromHtml,
-  parseImportMapFromJson
-};

package/dist/resolve.mjs

@@ -1,46 +0,0 @@
-function resolve(importMap, specifier, containingFile) {
-  const { baseURL, imports, scopes } = importMap;
-  const { origin, pathname } = new URL(containingFile, baseURL);
-  const sameOriginScopes = [];
-  for (const scopeName in scopes ?? {}) {
-    const scopeUrl = new URL(scopeName, baseURL);
-    if (scopeUrl.origin === origin) {
-      sameOriginScopes.push([scopeUrl.pathname, (scopes ?? {})[scopeName]]);
-    }
-  }
-  sameOriginScopes.sort(([a], [b]) => b.split("/").length - a.split("/").length);
-  if (sameOriginScopes.length > 0) {
-    for (const [scopePathname, scopeImports] of sameOriginScopes) {
-      if (pathname.startsWith(scopePathname)) {
-        const url = matchImport(specifier, scopeImports);
-        if (url) {
-          return [url, true];
-        }
-      }
-    }
-  }
-  if (origin === baseURL.origin) {
-    const url = matchImport(specifier, imports);
-    if (url) {
-      return [url, true];
-    }
-  }
-  return [specifier, false];
-}
-function matchImport(specifier, imports) {
-  if (specifier in imports) {
-    return imports[specifier];
-  }
-  let bestMatch = null;
-  let bestKeyLength = -1;
-  for (const [k, v] of Object.entries(imports)) {
-    if (k.endsWith("/") && specifier.startsWith(k) && k.length > bestKeyLength) {
-      bestMatch = v + specifier.slice(k.length);
-      bestKeyLength = k.length;
-    }
-  }
-  return bestMatch;
-}
-export {
-  resolve
-};

package/dist/support.mjs

@@ -1,6 +0,0 @@
-function isSupportImportMap() {
-  return !!globalThis.HTMLScriptElement?.supports?.("importmap");
-}
-export {
-  isSupportImportMap
-};