@esmx/import 3.0.0-rc.11 → 3.0.0-rc.111

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 Vanelink
+Copyright (c) 2020 Esmx Team
 
 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

@@ -0,0 +1,141 @@
+<div align="center">
+  <img src="https://esmx.dev/logo.svg?t=2025" width="120" alt="Esmx Logo" />
+  <h1>@esmx/import</h1>
+  
+  <div>
+    <a href="https://www.npmjs.com/package/@esmx/import">
+      <img src="https://img.shields.io/npm/v/@esmx/import.svg" alt="npm version" />
+    </a>
+    <a href="https://github.com/esmnext/esmx/actions/workflows/build.yml">
+      <img src="https://github.com/esmnext/esmx/actions/workflows/build.yml/badge.svg" alt="Build" />
+    </a>
+    <a href="https://esmx.dev/coverage/">
+      <img src="https://img.shields.io/badge/coverage-live%20report-brightgreen" alt="Coverage Report" />
+    </a>
+    <a href="https://nodejs.org/">
+      <img src="https://img.shields.io/node/v/@esmx/import.svg" alt="node version" />
+    </a>
+    <a href="https://bundlephobia.com/package/@esmx/import">
+      <img src="https://img.shields.io/bundlephobia/minzip/@esmx/import" alt="size" />
+    </a>
+  </div>
+  
+  <p>Node.js server-side implementation of Import Maps for the Esmx framework</p>
+  
+  <p>
+    English | <a href="https://github.com/esmnext/esmx/blob/master/packages/import/README.zh-CN.md">中文</a>
+  </p>
+</div>
+
+## 🚀 Features
+
+- **Dual Implementation** - VM mode for development and Loader mode for production
+- **Hot Reload Support** - VM mode supports multiple creation for development flexibility
+- **High Performance** - Loader mode optimized for production deployment
+- **Node.js Focused** - Specifically designed for Node.js server-side environments
+- **TypeScript Ready** - Full TypeScript support with excellent type safety
+- **ESM Standards** - Fully compliant with Import Maps specification
+
+## 📦 Installation
+
+```bash
+# npm
+npm install @esmx/import
+
+# pnpm
+pnpm add @esmx/import
+
+# yarn
+yarn add @esmx/import
+```
+
+## 🚀 Quick Start
+
+```typescript
+import { createVmImport } from '@esmx/import';
+import { pathToFileURL } from 'node:url';
+
+const vmImport = createVmImport(baseURL, importMap);
+const module = await vmImport('my-app/src/utils', import.meta.url);
+```
+
+## 📖 Mode Comparison
+
+`@esmx/import` provides two different Import Maps implementation approaches:
+
+| Feature | VM Mode | Loader Mode |
+|---------|---------|-------------|
+| **Function** | `createVmImport()` | `createLoaderImport()` |
+| **Environment** | Development | Production |
+| **Hot Reload** | ✅ Supports multiple creation | ❌ Can only be created once |
+| **Performance** | Relatively slower | High performance |
+| **Isolation** | Fully isolated VM environment | Uses Node.js native Loader |
+| **Debugging** | Easy for development debugging | Suitable for production deployment |
+
+## 🔧 Usage Examples
+
+### VM Mode (Development)
+
+```typescript
+import { createVmImport } from '@esmx/import';
+import { pathToFileURL } from 'node:url';
+
+const baseURL = pathToFileURL('/project');
+const importMap = {
+  imports: {
+    'my-app/src/utils': '/project/src/utils.mjs'
+  }
+};
+
+const vmImport = createVmImport(baseURL, importMap);
+const module = await vmImport('my-app/src/utils', import.meta.url);
+```
+
+### Loader Mode (Production)
+
+```typescript
+import { createLoaderImport } from '@esmx/import';
+import { pathToFileURL } from 'node:url';
+
+const baseURL = pathToFileURL('/app/dist/server');
+const importMap = {
+  imports: {
+    'my-app/src/utils': '/app/dist/server/my-app/src/utils.mjs'
+  }
+};
+
+const loaderImport = createLoaderImport(baseURL, importMap);
+const module = await loaderImport('my-app/src/utils');
+```
+
+## 📚 API Reference
+
+### createVmImport(baseURL, importMap?)
+Creates a VM-based import function with hot reload support.
+```typescript
+const vmImport = createVmImport(baseURL, importMap);
+const module = await vmImport(specifier, parent, sandbox?, options?);
+```
+
+### createLoaderImport(baseURL, importMap?)
+Creates a Loader-based import function with high performance, can only be created once.
+```typescript
+const loaderImport = createLoaderImport(baseURL, importMap);
+const module = await loaderImport(specifier);
+```
+
+### ImportMap Format
+```typescript
+interface ImportMap {
+  imports?: Record<string, string>;
+  scopes?: Record<string, Record<string, string>>;
+}
+```
+
+**Important Notes:**
+- Only supports Node.js environment, not browser
+- Paths must be absolute paths or complete URLs
+
+## 📄 License
+
+MIT © [Esmx Team](https://github.com/esmnext/esmx) 

package/README.zh-CN.md

@@ -0,0 +1,141 @@
+<div align="center">
+  <img src="https://esmx.dev/logo.svg?t=2025" width="120" alt="Esmx Logo" />
+  <h1>@esmx/import</h1>
+  
+  <div>
+    <a href="https://www.npmjs.com/package/@esmx/import">
+      <img src="https://img.shields.io/npm/v/@esmx/import.svg" alt="npm version" />
+    </a>
+    <a href="https://github.com/esmnext/esmx/actions/workflows/build.yml">
+      <img src="https://github.com/esmnext/esmx/actions/workflows/build.yml/badge.svg" alt="Build" />
+    </a>
+    <a href="https://esmx.dev/coverage/">
+      <img src="https://img.shields.io/badge/coverage-live%20report-brightgreen" alt="Coverage Report" />
+    </a>
+    <a href="https://nodejs.org/">
+      <img src="https://img.shields.io/node/v/@esmx/import.svg" alt="node version" />
+    </a>
+    <a href="https://bundlephobia.com/package/@esmx/import">
+      <img src="https://img.shields.io/bundlephobia/minzip/@esmx/import" alt="size" />
+    </a>
+  </div>
+  
+  <p>为 Esmx 框架提供 Import Maps 的 Node.js 服务端实现</p>
+  
+  <p>
+    <a href="https://github.com/esmnext/esmx/blob/master/packages/import/README.md">English</a> | 中文
+  </p>
+</div>
+
+## 🚀 特性
+
+- **双重实现** - 开发环境使用 VM 模式，生产环境使用 Loader 模式
+- **热重载支持** - VM 模式支持多次创建，提供开发灵活性
+- **高性能** - Loader 模式为生产部署优化
+- **Node.js 专注** - 专为 Node.js 服务端环境设计
+- **TypeScript 就绪** - 完整的 TypeScript 支持，出色的类型安全
+- **ESM 标准** - 完全符合 Import Maps 规范
+
+## 📦 安装
+
+```bash
+# npm
+npm install @esmx/import
+
+# pnpm
+pnpm add @esmx/import
+
+# yarn
+yarn add @esmx/import
+```
+
+## 🚀 快速开始
+
+```typescript
+import { createVmImport } from '@esmx/import';
+import { pathToFileURL } from 'node:url';
+
+const vmImport = createVmImport(baseURL, importMap);
+const module = await vmImport('my-app/src/utils', import.meta.url);
+```
+
+## 📖 模式对比
+
+`@esmx/import` 提供两种不同的 Import Maps 实现方式：
+
+| 特性 | VM 模式 | Loader 模式 |
+|------|---------|-------------|
+| **函数** | `createVmImport()` | `createLoaderImport()` |
+| **适用环境** | 开发环境 | 生产环境 |
+| **热重载** | ✅ 支持多次创建 | ❌ 只能创建一次 |
+| **性能** | 相对较慢 | 高性能 |
+| **隔离性** | 完全隔离的 VM 环境 | 使用 Node.js 原生 Loader |
+| **调试** | 便于开发调试 | 适合生产部署 |
+
+## 🔧 使用示例
+
+### VM 模式 (开发环境)
+
+```typescript
+import { createVmImport } from '@esmx/import';
+import { pathToFileURL } from 'node:url';
+
+const baseURL = pathToFileURL('/project');
+const importMap = {
+  imports: {
+    'my-app/src/utils': '/project/src/utils.mjs'
+  }
+};
+
+const vmImport = createVmImport(baseURL, importMap);
+const module = await vmImport('my-app/src/utils', import.meta.url);
+```
+
+### Loader 模式 (生产环境)
+
+```typescript
+import { createLoaderImport } from '@esmx/import';
+import { pathToFileURL } from 'node:url';
+
+const baseURL = pathToFileURL('/app/dist/server');
+const importMap = {
+  imports: {
+    'my-app/src/utils': '/app/dist/server/my-app/src/utils.mjs'
+  }
+};
+
+const loaderImport = createLoaderImport(baseURL, importMap);
+const module = await loaderImport('my-app/src/utils');
+```
+
+## 📚 API 参考
+
+### createVmImport(baseURL, importMap?)
+创建基于 VM 的导入函数，支持热重载。
+```typescript
+const vmImport = createVmImport(baseURL, importMap);
+const module = await vmImport(specifier, parent, sandbox?, options?);
+```
+
+### createLoaderImport(baseURL, importMap?)
+创建基于 Loader 的导入函数，高性能，只能创建一次。
+```typescript
+const loaderImport = createLoaderImport(baseURL, importMap);
+const module = await loaderImport(specifier);
+```
+
+### ImportMap 格式
+```typescript
+interface ImportMap {
+  imports?: Record<string, string>;
+  scopes?: Record<string, Record<string, string>>;
+}
+```
+
+**注意事项：**
+- 仅支持 Node.js 环境，不支持浏览器
+- 路径必须为绝对路径或完整 URL
+
+## 📄 许可证
+
+MIT © [Esmx Team](https://github.com/esmnext/esmx) 

package/dist/error.d.ts

@@ -0,0 +1,14 @@
+export declare const formatCircularDependency: (moduleIds: string[], targetModule: string) => string;
+export declare const formatModuleChain: (moduleIds: string[], targetModule: string, originalError?: Error) => string;
+export declare class ModuleLoadingError extends Error {
+    moduleIds: string[];
+    targetModule: string;
+    originalError?: Error | undefined;
+    constructor(message: string, moduleIds: string[], targetModule: string, originalError?: Error | undefined);
+}
+export declare class CircularDependencyError extends ModuleLoadingError {
+    constructor(message: string, moduleIds: string[], targetModule: string);
+}
+export declare class FileReadError extends ModuleLoadingError {
+    constructor(message: string, moduleIds: string[], targetModule: string, originalError?: Error);
+}

package/dist/error.mjs

@@ -0,0 +1,104 @@
+import path from "node:path";
+const Colors = {
+  RED: "\x1B[31m",
+  YELLOW: "\x1B[33m",
+  CYAN: "\x1B[36m",
+  GRAY: "\x1B[90m",
+  RESET: "\x1B[0m",
+  BOLD: "\x1B[1m"
+};
+const supportsColor = () => {
+  return !!(process.stdout?.isTTY && process.env.TERM !== "dumb") || process.env.FORCE_COLOR === "1" || process.env.FORCE_COLOR === "true";
+};
+const useColors = supportsColor() && process.env.NO_COLOR !== "1";
+const colorize = (text, color) => {
+  return useColors ? `${color}${text}${Colors.RESET}` : text;
+};
+const getRelativeFromCwd = (filePath) => {
+  return path.relative(process.cwd(), filePath);
+};
+export const formatCircularDependency = (moduleIds, targetModule) => {
+  const fullChain = [...moduleIds, targetModule];
+  return `${colorize(colorize("Module dependency chain (circular reference found):", Colors.BOLD), Colors.RED)}
+${fullChain.map((module, index) => {
+    const isLastModule = index === fullChain.length - 1;
+    const prefix = index === 0 ? "\u250C\u2500 " : index === fullChain.length - 1 ? "\u2514\u2500 " : "\u251C\u2500 ";
+    const displayPath = getRelativeFromCwd(module);
+    const isCircularModule = fullChain.filter((m) => m === module).length > 1;
+    const coloredFile = isCircularModule ? colorize(colorize(displayPath, Colors.BOLD), Colors.RED) : colorize(displayPath, Colors.CYAN);
+    const suffix = isLastModule ? ` ${colorize("\u{1F504} Creates circular reference", Colors.YELLOW)}` : "";
+    return `${colorize(prefix, Colors.GRAY)}${coloredFile}${suffix}`;
+  }).join("\n")}`;
+};
+export const formatModuleChain = (moduleIds, targetModule, originalError) => {
+  let result = "";
+  if (moduleIds.length === 0) {
+    const displayPath = getRelativeFromCwd(targetModule);
+    result = `${colorize("Failed to load:", Colors.CYAN)} ${colorize(displayPath, Colors.RED)}`;
+  } else {
+    const chain = [...moduleIds, targetModule];
+    result = `${colorize(colorize("Module loading path:", Colors.BOLD), Colors.CYAN)}
+${chain.map((module, index) => {
+      const indent = "  ".repeat(index);
+      const connector = index === 0 ? "" : "\u2514\u2500 ";
+      const displayPath = getRelativeFromCwd(module);
+      const isFailedFile = index === chain.length - 1;
+      const coloredFile = isFailedFile ? colorize(colorize(displayPath, Colors.BOLD), Colors.RED) : colorize(displayPath, Colors.CYAN);
+      const status = isFailedFile ? ` ${colorize(colorize("\u274C Loading failed", Colors.BOLD), Colors.RED)}` : "";
+      return `${colorize(indent + connector, Colors.GRAY)}${coloredFile}${status}`;
+    }).join("\n")}`;
+  }
+  if (originalError) {
+    result += `
+
+${colorize("Error details:", Colors.YELLOW)} ${originalError.message}`;
+  }
+  return result;
+};
+export class ModuleLoadingError extends Error {
+  constructor(message, moduleIds, targetModule, originalError) {
+    super(message);
+    this.moduleIds = moduleIds;
+    this.targetModule = targetModule;
+    this.originalError = originalError;
+    this.name = "ModuleLoadingError";
+    Object.defineProperty(this, "moduleIds", {
+      value: moduleIds,
+      writable: false,
+      enumerable: false,
+      configurable: true
+    });
+    Object.defineProperty(this, "targetModule", {
+      value: targetModule,
+      writable: false,
+      enumerable: false,
+      configurable: true
+    });
+    if (originalError) {
+      Object.defineProperty(this, "originalError", {
+        value: originalError,
+        writable: false,
+        enumerable: false,
+        configurable: true
+      });
+    }
+  }
+}
+export class CircularDependencyError extends ModuleLoadingError {
+  constructor(message, moduleIds, targetModule) {
+    super(message, moduleIds, targetModule);
+    this.name = "CircularDependencyError";
+    this.stack = `${this.name}: ${message}
+
+${formatCircularDependency(moduleIds, targetModule)}`;
+  }
+}
+export class FileReadError extends ModuleLoadingError {
+  constructor(message, moduleIds, targetModule, originalError) {
+    super(message, moduleIds, targetModule, originalError);
+    this.name = "FileReadError";
+    this.stack = `${this.name}: ${message}
+
+${formatModuleChain(moduleIds, targetModule, originalError)}`;
+  }
+}

package/dist/error.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/error.test.mjs

@@ -0,0 +1,167 @@
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+  CircularDependencyError,
+  FileReadError,
+  formatCircularDependency,
+  formatModuleChain,
+  ModuleLoadingError
+} from "./error.mjs";
+describe("Module Loading Errors", () => {
+  let originalEnv;
+  beforeEach(() => {
+    originalEnv = process.env.NO_COLOR;
+    process.env.NO_COLOR = "1";
+  });
+  afterEach(() => {
+    if (originalEnv !== void 0) {
+      process.env.NO_COLOR = originalEnv;
+    } else {
+      process.env.NO_COLOR = void 0;
+    }
+  });
+  describe("CircularDependencyError", () => {
+    it("should create circular dependency error with correct properties", () => {
+      const moduleIds = ["/src/A.js", "/src/B.js"];
+      const targetModule = "/src/A.js";
+      const error = new CircularDependencyError(
+        "Test circular dependency",
+        moduleIds,
+        targetModule
+      );
+      expect(error.name).toBe("CircularDependencyError");
+      expect(error.message).toBe("Test circular dependency");
+      expect(error.stack).toContain("Test circular dependency");
+      expect(error.stack).toContain(
+        "Module dependency chain (circular reference found):"
+      );
+      expect(error.stack).toContain("\u250C\u2500");
+      expect(error.stack).toContain("\u2514\u2500");
+      expect(error.stack).toContain("\u{1F504} Creates circular reference");
+      expect(error.moduleIds).toEqual(moduleIds);
+      expect(error.targetModule).toBe(targetModule);
+      expect(error instanceof ModuleLoadingError).toBe(true);
+    });
+    it("should format circular dependency in toString", () => {
+      const moduleIds = ["/src/A.js", "/src/B.js"];
+      const targetModule = "/src/A.js";
+      const error = new CircularDependencyError(
+        "Circular dependency detected",
+        moduleIds,
+        targetModule
+      );
+      const formatted = error.toString();
+      expect(formatted).toContain("CircularDependencyError");
+      expect(formatted).toContain("Circular dependency detected");
+    });
+  });
+  describe("FileReadError", () => {
+    it("should create file read error with correct properties", () => {
+      const moduleIds = ["/src/main.js", "/src/components/App.js"];
+      const targetModule = "/src/missing.js";
+      const originalError = new Error(
+        "ENOENT: no such file or directory"
+      );
+      const error = new FileReadError(
+        "Failed to read module",
+        moduleIds,
+        targetModule,
+        originalError
+      );
+      expect(error.name).toBe("FileReadError");
+      expect(error.message).toBe("Failed to read module");
+      expect(error.stack).toContain("Failed to read module");
+      expect(error.stack).toContain("Module loading path:");
+      expect(error.stack).toContain("main.js");
+      expect(error.stack).toContain("App.js");
+      expect(error.stack).toContain("missing.js");
+      expect(error.stack).toContain("\u274C Loading failed");
+      expect(error.stack).toContain("Error details:");
+      expect(error.stack).toContain("ENOENT");
+      expect(error.moduleIds).toEqual(moduleIds);
+      expect(error.targetModule).toBe(targetModule);
+      expect(error.originalError).toBe(originalError);
+      expect(error instanceof ModuleLoadingError).toBe(true);
+    });
+    it("should format module chain in toString", () => {
+      const moduleIds = ["/src/main.js", "/src/components/App.js"];
+      const targetModule = "/src/missing.js";
+      const originalError = new Error(
+        "ENOENT: no such file or directory"
+      );
+      const error = new FileReadError(
+        "Failed to read module",
+        moduleIds,
+        targetModule,
+        originalError
+      );
+      const formatted = error.toString();
+      expect(formatted).toContain("FileReadError");
+      expect(formatted).toContain("Failed to read module");
+    });
+  });
+  describe("Formatting Functions", () => {
+    it("should format circular dependency correctly", () => {
+      const moduleIds = ["/src/A.js", "/src/B.js", "/src/C.js"];
+      const targetModule = "/src/A.js";
+      const formatted = formatCircularDependency(moduleIds, targetModule);
+      const relativeA = path.relative(process.cwd(), "/src/A.js");
+      const relativeB = path.relative(process.cwd(), "/src/B.js");
+      const relativeC = path.relative(process.cwd(), "/src/C.js");
+      expect(formatted).toContain(
+        "Module dependency chain (circular reference found):"
+      );
+      expect(formatted).toContain(`\u250C\u2500 ${relativeA}`);
+      expect(formatted).toContain(`\u251C\u2500 ${relativeB}`);
+      expect(formatted).toContain(`\u251C\u2500 ${relativeC}`);
+      expect(formatted).toContain(`\u2514\u2500 ${relativeA}`);
+      expect(formatted).toContain("\u{1F504} Creates circular reference");
+    });
+    it("should format module chain correctly", () => {
+      const moduleIds = ["/src/main.js", "/src/app.js"];
+      const targetModule = "/src/missing.js";
+      const originalError = new Error("File not found");
+      const formatted = formatModuleChain(
+        moduleIds,
+        targetModule,
+        originalError
+      );
+      expect(formatted).toContain("Module loading path:");
+      expect(formatted).toContain("main.js");
+      expect(formatted).toContain("app.js");
+      expect(formatted).toContain("missing.js");
+      expect(formatted).toContain("\u274C Loading failed");
+      expect(formatted).toContain("Error details:");
+      expect(formatted).toContain("File not found");
+    });
+    it("should handle empty moduleIds in formatModuleChain", () => {
+      const moduleIds = [];
+      const targetModule = "/src/standalone.js";
+      const formatted = formatModuleChain(moduleIds, targetModule);
+      expect(formatted).toContain("Failed to load:");
+      expect(formatted).toContain("standalone.js");
+    });
+    it("should handle deep module chains", () => {
+      const moduleIds = [
+        "/src/a.js",
+        "/src/b.js",
+        "/src/c.js",
+        "/src/d.js"
+      ];
+      const targetModule = "/src/e.js";
+      const formatted = formatModuleChain(moduleIds, targetModule);
+      const relativeA = path.relative(process.cwd(), "/src/a.js");
+      const relativeB = path.relative(process.cwd(), "/src/b.js");
+      const relativeC = path.relative(process.cwd(), "/src/c.js");
+      const relativeD = path.relative(process.cwd(), "/src/d.js");
+      const relativeE = path.relative(process.cwd(), "/src/e.js");
+      expect(formatted).toContain(relativeA);
+      expect(formatted).toContain(`  \u2514\u2500 ${relativeB}`);
+      expect(formatted).toContain(`    \u2514\u2500 ${relativeC}`);
+      expect(formatted).toContain(`      \u2514\u2500 ${relativeD}`);
+      expect(formatted).toContain(
+        `        \u2514\u2500 ${relativeE} \u274C Loading failed`
+      );
+    });
+  });
+});

package/dist/import-loader.d.ts

@@ -3,10 +3,9 @@ interface Data {
     baseURL: string;
     importMap: ImportMap;
 }
-/**
- * 创建一个使用 loader 实现的 importmap 的 import 函数，只能创建一次，无热更新，适合生产使用。
- */
 export declare function createLoaderImport(baseURL: URL, importMap?: ImportMap): (specifier: string) => Promise<Record<string, any>>;
 export declare function initialize(data: Data): void;
-export declare function resolve(specifier: string, context: Record<string, any>, nextResolve: Function): any;
+export declare function resolve(specifier: string, context: {
+    parentURL: string;
+}, nextResolve: Function): any;
 export {};

package/dist/import-loader.mjs

@@ -1,10 +1,9 @@
 import module from "node:module";
-import { fileURLToPath } from "node:url";
-import IM from "@import-maps/resolve";
+import { createImportMapResolver } from "./import-map-resolve.mjs";
 let registered = "";
 export function createLoaderImport(baseURL, importMap = {}) {
   if (!registered) {
-    module.register(fileURLToPath(import.meta.url), {
+    module.register(import.meta.url, {
       parentURL: baseURL,
       data: {
         baseURL: baseURL.href,
@@ -18,20 +17,18 @@ export function createLoaderImport(baseURL, importMap = {}) {
     );
   }
   return (specifier) => {
-    return import(specifier);
+    try {
+      return import(specifier);
+    } catch (e) {
+      throw new Error(`Failed to import '${specifier}'`);
+    }
   };
 }
-let loaderBaseURL = new URL("file:");
-let loaderParsedImportMap = {};
+let importMapResolver = null;
 export function initialize(data) {
-  loaderBaseURL = new URL(data.baseURL);
-  loaderParsedImportMap = IM.parse(data.importMap, loaderBaseURL);
+  importMapResolver = createImportMapResolver(data.baseURL, data.importMap);
 }
 export function resolve(specifier, context, nextResolve) {
-  const scriptURL = new URL(context.parentURL);
-  const result = IM.resolve(specifier, loaderParsedImportMap, scriptURL);
-  if (result.matched && result.resolvedImport) {
-    return nextResolve(result.resolvedImport.href);
-  }
-  return nextResolve(specifier, context);
+  const result = importMapResolver?.(specifier, context.parentURL);
+  return nextResolve(result ?? specifier, context);
 }

package/dist/import-map-resolve.d.ts

@@ -0,0 +1,2 @@
+import type { ImportMap, ImportMapResolver } from './types';
+export declare function createImportMapResolver(base: string, importMap: ImportMap): ImportMapResolver;

package/dist/import-map-resolve.mjs

@@ -0,0 +1,13 @@
+import { pathToFileURL } from "node:url";
+import { parse, resolve } from "@import-maps/resolve";
+export function createImportMapResolver(base, importMap) {
+  const baseURL = pathToFileURL(base);
+  const parsedImportMap = parse(importMap, baseURL);
+  return (specifier, scriptURL) => {
+    const result = resolve(specifier, parsedImportMap, new URL(scriptURL));
+    if (result.resolvedImport) {
+      return result.resolvedImport.href;
+    }
+    return null;
+  };
+}

package/dist/import-map-resolve.test.d.ts

@@ -0,0 +1 @@
+export {};