@esm.sh/import-map 0.1.0 → 0.2.0

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2024-2025 Je Xia <i@jex.me>
+Copyright (c) 2025-2026 Je Xia <i@jex.me>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,3 +1,143 @@
-# import-map
+# @esm.sh/import-map
 
-A [import maps](https://wicg.github.io/import-maps/) parser and resolver.
+An [Import Maps](https://wicg.github.io/import-maps/) manager.
+
+- create blank import maps
+- parse import maps from JSON/HTML
+- resolve specifiers with `imports` and `scopes`
+- add npm/jsr/github packages from [esm.sh](https://esm.sh) CDN into an import map
+- maintain optional `integrity` metadata
+
+## Installation
+
+```bash
+npm i @esm.sh/import-map
+```
+
+## API
+
+### `createBlankImportMap(baseURL?: string)`
+
+Create an empty import map:
+
+```ts
+import { createBlankImportMap } from "@esm.sh/import-map";
+
+const im = createBlankImportMap("file:///");
+```
+
+### `importMapFrom(value: any, baseURL?: string)`
+
+Build an import map from a JS object.
+Supports `config`, `imports`, `scopes`, and `integrity`.
+Non-string values inside these maps are removed during validation.
+
+```ts
+import { importMapFrom } from "@esm.sh/import-map";
+
+const im = importMapFrom({
+  imports: { react: "https://esm.sh/react@19.2.4/es2022/react.mjs" },
+  integrity: { "https://esm.sh/react@19.2.4/es2022/react.mjs": "sha384-..." },
+});
+```
+
+### `parseImportMapFromJson(json: string, baseURL?: string)`
+
+Parse an import map from JSON text.
+Preserves and validates `config`, `imports`, `scopes`, and `integrity`.
+
+```ts
+import { parseImportMapFromJson } from "@esm.sh/import-map";
+
+const im = parseImportMapFromJson(`{
+  "imports": {
+    "react": "https://esm.sh/react@19.2.4/es2022/react.mjs"
+  }
+}`);
+```
+
+### `parseImportMapFromHtml(html: string, baseURL?: string)`
+
+Parse the first `<script type="importmap">` from HTML (browser environment). Returns an empty import map if no `importmap` script tag is found.
+
+```ts
+import { parseImportMapFromHtml } from "@esm.sh/import-map";
+
+const im = parseImportMapFromHtml(`<script type="importmap">
+  {
+    "imports": {
+      "react": "https://esm.sh/react@19.2.4/es2022/react.mjs"
+    }
+  }
+</script>`);
+```
+
+> Note: This function requires a browser environment.
+
+### `resolve(importMap: ImportMap, specifier: string, containingFile: string)`
+
+Resolve a specifier using import-map matching rules:
+
+```ts
+import { resolve } from "@esm.sh/import-map";
+
+const [url, ok] = resolve(im, "react", "file:///app/main.ts");
+```
+
+Returns `[resolvedUrl, true]` when matched, otherwise `[originalSpecifier, false]`.
+
+### `addImport(importMap: ImportMap, specifier: string, noSRI?: boolean)`
+
+Fetch package metadata from [esm.sh](https://esm.sh) CDN and add an import entry (plus relevant deps)
+into the map.
+
+Supported specifiers include:
+
+- npm: `react@19.2.4`, `react-dom@19/client`
+- jsr: `jsr:@std/fs@1.0.0`
+- github: `gh:owner/repo@tag`
+
+Behavior highlights:
+
+- adds top-level specifier into `imports`
+- adds nested deps into `scopes` when needed
+- cleans up empty scopes
+- updates `integrity` unless `noSRI` is `true`
+
+```ts
+import { addImport, createBlankImportMap } from "@esm.sh/import-map";
+
+const im = createBlankImportMap();
+await addImport(im, "react-dom@19/client");
+```
+
+### `isSupportImportMap()`
+
+Returns whether the current browser supports import maps.
+
+```ts
+import { isSupportImportMap } from "@esm.sh/import-map";
+
+const supported = isSupportImportMap();
+```
+
+### `isBlankImportMap(importMap: ImportMap)`
+
+Returns `true` when `imports` and `scopes` are empty.
+
+```ts
+import { isBlankImportMap } from "@esm.sh/import-map";
+
+const blank = isBlankImportMap(im);
+```
+
+## Development
+
+```bash
+npm test
+npm run build
+```
+
+## License
+
+MIT

package/dist/add.mjs

@@ -0,0 +1,374 @@
+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

@@ -0,0 +1,17 @@
+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/index.mjs

@@ -0,0 +1,5 @@
+export * from "./add.ts";
+export * from "./blank.ts";
+export * from "./parse.ts";
+export * from "./resolve.ts";
+export * from "./support.ts";

package/dist/parse.mjs

@@ -0,0 +1,88 @@
+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

@@ -0,0 +1,46 @@
+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

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

package/package.json

@@ -1,26 +1,29 @@
 {
   "name": "@esm.sh/import-map",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "A import map parser and resolver.",
   "type": "module",
-  "main": "dist/import-map.mjs",
-  "module": "dist/import-map.mjs",
-  "exports": {
-    ".": {
-      "import": "./dist/import-map.mjs",
-      "types": "./types/import-map.d.ts"
-    },
-    "./generator": {
-      "import": "./dist/generator.mjs",
-      "types": "./types/generator.d.ts"
-    }
-  },
+  "main": "dist/index.mjs",
+  "module": "dist/index.mjs",
+  "types": "types/index.d.ts",
+  "files": [
+    "dist",
+    "types",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
     "prepublishOnly": "npm run build",
-    "build": "esbuild --format=esm --outdir=dist --out-extension:.js=.mjs src/*.ts"
+    "build": "rm -rf dist && esbuild --format=esm --outdir=dist --out-extension:.js=.mjs src/index.ts src/add.ts src/blank.ts src/parse.ts src/resolve.ts src/support.ts",
+    "test": "bun test src/*.test.ts"
+  },
+  "dependencies": {
+    "semver": "^7.7.4"
   },
   "devDependencies": {
-    "esbuild": "^0.25.0"
+    "@types/bun": "^1.3.9",
+    "@types/semver": "^7.7.1",
+    "esbuild": "0.27.3"
   },
   "repository": {
     "type": "git",

package/types/{import-map.d.ts → index.d.ts}

@@ -1,31 +1,39 @@
 /** The import maps follow the spec at https://wicg.github.io/import-maps/. */
 export interface ImportMap {
-  $src?: string;
-  $baseURL: string;
+  baseURL: URL;
+  config?: Record<string, string>;
   imports: Record<string, string>;
-  scopes: Record<string, Record<string, string>>;
+  scopes?: Record<string, Record<string, string>>;
+  integrity?: Record<string, string>;
 }
 
 /** Create a blank import map. */
-export function createBlankImportMap(): ImportMap;
+export function createBlankImportMap(baseURL?: string): ImportMap;
 
 /** Create an import map from the given object. */
 export function importMapFrom(v: any, baseURL?: string): ImportMap;
 
-/** Parse the import map from JSON. */
+/** Parse the import map from a JSON string. */
 export function parseImportMapFromJson(json: string, baseURL?: string): ImportMap;
 
-/** Parse the import map from the given HTML. (requires Browser environment) */
+/** Parse the import map from the given HTML. (Requires Browser environment) */
 export function parseImportMapFromHtml(html: string, baseURL?: string): ImportMap;
 
+/**
+ * Add an import from esm.sh CDN to the import map.
+ *
+ * @param importMap - The import map to add the import to.
+ * @param specifier - The specifier of the import to add.
+ * @param noSRI - Whether to add the import without SRI.
+ * @returns A promise that resolves when the import is added.
+ */
+export function addImport(importMap: ImportMap, specifier: string, noSRI?: boolean): Promise<void>;
+
 /** Resolve the specifier with the import map. */
-export function resolve(importMap: ImportMap, specifier: string, containingFile: string): string;
+export function resolve(importMap: ImportMap, specifier: string, containingFile: string): [url: string, ok: boolean];
 
 /** Check if current browser supports import maps. */
 export function isSupportImportMap(): boolean;
 
 /** Check if the import map is blank. */
 export function isBlankImportMap(importMap: ImportMap): boolean;
-
-/** Check if the given two import maps are the same. */
-export function isSameImportMap(a: ImportMap, b: ImportMap): boolean;

package/dist/generator.mjs

@@ -1,24 +0,0 @@
-let cdnOrigin = "https://esm.sh";
-function setCDNOrigin(origin) {
-  const url = new URL(origin);
-  cdnOrigin = url.origin;
-}
-function add(importMap, specifier) {
-  throw new Error("Not implemented");
-}
-function update(importMap, specifier, version) {
-  throw new Error("Not implemented");
-}
-function remove(importMap) {
-  throw new Error("Not implemented");
-}
-function tidy(importMap) {
-  throw new Error("Not implemented");
-}
-export {
-  add,
-  remove,
-  setCDNOrigin,
-  tidy,
-  update
-};

package/dist/import-map.mjs

@@ -1,159 +0,0 @@
-function createBlankImportMap(baseURL) {
-  return {
-    $baseURL: new URL(baseURL ?? ".", "file:///").href,
-    imports: {},
-    scopes: {}
-  };
-}
-function importMapFrom(v, baseURL) {
-  const im = createBlankImportMap(baseURL);
-  if (isObject(v)) {
-    const { imports, scopes } = v;
-    if (isObject(imports)) {
-      validateImports(imports);
-      im.imports = imports;
-    }
-    if (isObject(scopes)) {
-      validateScopes(scopes);
-      im.scopes = scopes;
-    }
-  }
-  return im;
-}
-function parseImportMapFromJson(json, baseURL) {
-  const importMap = {
-    $baseURL: new URL(baseURL ?? ".", "file:///").href,
-    imports: {},
-    scopes: {}
-  };
-  const v = JSON.parse(json);
-  if (isObject(v)) {
-    const { imports, scopes } = v;
-    if (isObject(imports)) {
-      validateImports(imports);
-      importMap.imports = imports;
-    }
-    if (isObject(scopes)) {
-      validateScopes(scopes);
-      importMap.scopes = scopes;
-    }
-  }
-  return importMap;
-}
-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 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 === new URL($baseURL).origin) {
-    const url = matchImport(specifier, imports);
-    if (url) {
-      return [url, true];
-    }
-  }
-  return [specifier, false];
-}
-function isSupportImportMap() {
-  return !globalThis.HTMLScriptElement?.supports?.("importmap");
-}
-function isBlankImportMap(importMap) {
-  const { imports, scopes } = importMap;
-  if (isObject(imports) && Object.keys(imports).length > 0 || isObject(scopes) && Object.keys(scopes).length > 0) {
-    return false;
-  }
-  return true;
-}
-function isSameImportMap(a, b) {
-  if (!isSameImports(a.imports, b.imports)) {
-    return false;
-  }
-  for (const k in a.scopes) {
-    if (!(k in b.scopes) || !isObject(b.scopes[k])) {
-      return false;
-    }
-    if (!isSameImports(a.scopes[k], b.scopes[k])) {
-      return false;
-    }
-  }
-  return true;
-}
-function matchImport(specifier, imports) {
-  if (specifier in imports) {
-    return imports[specifier];
-  }
-  for (const [k, v] of Object.entries(imports)) {
-    if (k.endsWith("/")) {
-      if (specifier.startsWith(k)) {
-        return v + specifier.slice(k.length);
-      }
-    } else if (specifier.startsWith(k + "/")) {
-      return v + specifier.slice(k.length);
-    }
-  }
-  return null;
-}
-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 isObject(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function isSameImports(a, b) {
-  if (Object.keys(a).length !== Object.keys(b).length) {
-    return false;
-  }
-  for (const k in a) {
-    if (a[k] !== b[k]) {
-      return false;
-    }
-  }
-  return true;
-}
-export {
-  createBlankImportMap,
-  importMapFrom,
-  isBlankImportMap,
-  isSameImportMap,
-  isSupportImportMap,
-  parseImportMapFromHtml,
-  parseImportMapFromJson,
-  resolve
-};

package/src/generator.ts

@@ -1,28 +0,0 @@
-import type { ImportMap } from "../types/import-map.d.ts";
-
-let cdnOrigin = "https://esm.sh";
-
-export function setCDNOrigin(origin: string): void {
-  const url = new URL(origin);
-  cdnOrigin = url.origin;
-}
-
-/** Add a module to the import map. */
-export function add(importMap: ImportMap, specifier: string): Promise<void> {
-  throw new Error("Not implemented");
-}
-
-/** Update a module in the import map. */
-export function update(importMap: ImportMap, specifier: string, version: string): Promise<void> {
-  throw new Error("Not implemented");
-}
-
-/** Remove a module from the import map. */
-export function remove(importMap: ImportMap): Promise<void> {
-  throw new Error("Not implemented");
-}
-
-/** Tidy the import map. */
-export function tidy(importMap: ImportMap): Promise<void> {
-  throw new Error("Not implemented");
-}

package/src/import-map.ts

@@ -1,171 +0,0 @@
-import type { ImportMap } from "../types/import-map.d.ts";
-
-/** Create a blank import map. */
-export function createBlankImportMap(baseURL?: string): ImportMap {
-  return {
-    $baseURL: new URL(baseURL ?? ".", "file:///").href,
-    imports: {},
-    scopes: {},
-  };
-}
-
-/** Create an import map from the given object. */
-export function importMapFrom(v: any, baseURL?: string): ImportMap {
-  const im = createBlankImportMap(baseURL);
-  if (isObject(v)) {
-    const { imports, scopes } = v;
-    if (isObject(imports)) {
-      validateImports(imports);
-      im.imports = imports as ImportMap["imports"];
-    }
-    if (isObject(scopes)) {
-      validateScopes(scopes);
-      im.scopes = scopes as ImportMap["scopes"];
-    }
-  }
-  return im;
-}
-
-/** Parse the import map from JSON. */
-export function parseImportMapFromJson(json: string, baseURL?: string): ImportMap {
-  const importMap: ImportMap = {
-    $baseURL: new URL(baseURL ?? ".", "file:///").href,
-    imports: {},
-    scopes: {},
-  };
-  const v = JSON.parse(json);
-  if (isObject(v)) {
-    const { imports, scopes } = v;
-    if (isObject(imports)) {
-      validateImports(imports);
-      importMap.imports = imports as ImportMap["imports"];
-    }
-    if (isObject(scopes)) {
-      validateScopes(scopes);
-      importMap.scopes = scopes as ImportMap["scopes"];
-    }
-  }
-  return importMap;
-}
-
-/** Parse the import map from the given HTML. (requires Browser environment) */
-export function parseImportMapFromHtml(html: string, baseURL?: string): ImportMap {
-  const tplEl = document.createElement("template");
-  tplEl.innerHTML = html;
-  const scriptEl: HTMLScriptElement | null = tplEl.content.querySelector("script[type='importmap']");
-  if (scriptEl) {
-    return parseImportMapFromJson(scriptEl.textContent!, baseURL);
-  }
-  return createBlankImportMap(baseURL);
-}
-
-/** Resolve the specifier with the import map. */
-export function resolve(importMap: ImportMap, specifier: string, containingFile: string): [string, boolean] {
-  const { $baseURL, imports, scopes } = importMap;
-  const { origin, pathname } = new URL(containingFile, $baseURL);
-  const sameOriginScopes: [string, ImportMap["imports"]][] = [];
-  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 === new URL($baseURL).origin) {
-    const url = matchImport(specifier, imports);
-    if (url) {
-      return [url, true];
-    }
-  }
-  return [specifier, false];
-}
-
-/** Check if current browser supports import maps. */
-export function isSupportImportMap(): boolean {
-  return !(globalThis.HTMLScriptElement?.supports?.("importmap"));
-}
-
-/** Check if the import map is blank. */
-export function isBlankImportMap(importMap: ImportMap) {
-  const { imports, scopes } = importMap;
-  if ((isObject(imports) && Object.keys(imports).length > 0) || (isObject(scopes) && Object.keys(scopes).length > 0)) {
-    return false;
-  }
-  return true;
-}
-
-/** Check if the given two import maps are the same. */
-export function isSameImportMap(a: ImportMap, b: ImportMap): boolean {
-  if (!isSameImports(a.imports, b.imports)) {
-    return false;
-  }
-  for (const k in a.scopes) {
-    if (!(k in b.scopes) || !isObject(b.scopes[k])) {
-      return false;
-    }
-    if (!isSameImports(a.scopes[k], b.scopes[k])) {
-      return false;
-    }
-  }
-  return true;
-}
-
-function matchImport(specifier: string, imports: ImportMap["imports"]): string | null {
-  if (specifier in imports) {
-    return imports[specifier];
-  }
-  for (const [k, v] of Object.entries(imports)) {
-    if (k.endsWith("/")) {
-      if (specifier.startsWith(k)) {
-        return v + specifier.slice(k.length);
-      }
-    } else if (specifier.startsWith(k + "/")) {
-      return v + specifier.slice(k.length);
-    }
-  }
-  return null;
-}
-
-function validateImports(imports: Record<string, unknown>) {
-  for (const [k, v] of Object.entries(imports)) {
-    if (!v || typeof v !== "string") {
-      delete imports[k];
-    }
-  }
-}
-
-function validateScopes(imports: Record<string, unknown>) {
-  for (const [k, v] of Object.entries(imports)) {
-    if (isObject(v)) {
-      validateImports(v);
-    } else {
-      delete imports[k];
-    }
-  }
-}
-
-function isObject(v: unknown): v is Record<string, unknown> {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-
-function isSameImports(a: Record<string, string>, b: Record<string, string>): boolean {
-  if (Object.keys(a).length !== Object.keys(b).length) {
-    return false;
-  }
-  for (const k in a) {
-    if (a[k] !== b[k]) {
-      return false;
-    }
-  }
-  return true;
-}

package/types/generator.d.ts

@@ -1,4 +0,0 @@
-import type { ImportMap } from "./import-map.d.ts";
-
-/** Search a NPM package from esm.sh CDN and add it to the import map. */
-export function addImport(importMap: ImportMap, specifier: string): void;