@esmx/import 3.0.0-rc.44 → 3.0.0-rc.46

package/dist/import-loader.d.ts

@@ -5,5 +5,7 @@ interface Data {
 }
 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,6 +1,5 @@
 import module from "node:module";
-import { pathToFileURL } 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) {
@@ -25,17 +24,11 @@ export function createLoaderImport(baseURL, importMap = {}) {
     }
   };
 }
-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(pathToFileURL(result.resolvedImport.pathname).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 {};

package/dist/import-map-resolve.test.mjs

@@ -0,0 +1,182 @@
+import { describe, expect, it } from "vitest";
+import { createImportMapResolver } from "./import-map-resolve.mjs";
+describe("createImportMapResolver", () => {
+  describe("basic import resolution", () => {
+    it("resolves imports correctly on Windows", () => {
+      const base = "file:///C:/projects/app";
+      const importMap = {
+        imports: {
+          lodash: "https://cdn.skypack.dev/lodash",
+          "utils/": "file:///C:/projects/app/src/utils/",
+          "./components/": "./components/"
+        }
+      };
+      const resolver = createImportMapResolver(base, importMap);
+      expect(resolver("lodash", "file:///C:/projects/app/index.js")).toBe(
+        "https://cdn.skypack.dev/lodash"
+      );
+      expect(
+        resolver("utils/math.js", "file:///C:/projects/app/index.js")
+      ).toBe("file:///C:/projects/app/src/utils/math.js");
+      expect(
+        resolver(
+          "./components/button.js",
+          "file:///C:/projects/app/index.js"
+        )
+      ).toBe("file:///C:/projects/app/components/button.js");
+    });
+    it("resolves imports correctly on Unix", () => {
+      const base = "file:///opt/projects/app";
+      const importMap = {
+        imports: {
+          lodash: "https://cdn.skypack.dev/lodash",
+          "utils/": "file:///opt/projects/app/src/utils/",
+          "./components/": "./components/"
+        }
+      };
+      const resolver = createImportMapResolver(base, importMap);
+      expect(
+        resolver("lodash", "file:///opt/projects/app/index.js")
+      ).toBe("https://cdn.skypack.dev/lodash");
+      expect(
+        resolver("utils/math.js", "file:///opt/projects/app/index.js")
+      ).toBe("file:///opt/projects/app/src/utils/math.js");
+      expect(
+        resolver(
+          "./components/button.js",
+          "file:///opt/projects/app/index.js"
+        )
+      ).toBe("file:///opt/projects/app/components/button.js");
+    });
+  });
+  describe("scopes resolution", () => {
+    it("resolves imports from different scopes", () => {
+      const base = "file:///opt/projects/app";
+      const importMap = {
+        imports: {
+          "components/": "file:///opt/projects/app/src/components/",
+          lodash: "https://cdn.skypack.dev/lodash@4.17.21"
+        },
+        scopes: {
+          "file:///opt/projects/app/src/admin/": {
+            "components/": "file:///opt/projects/app/src/admin/components/",
+            lodash: "https://cdn.skypack.dev/lodash@4.17.15"
+          }
+        }
+      };
+      const resolver = createImportMapResolver(base, importMap);
+      expect(
+        resolver(
+          "components/button.js",
+          "file:///opt/projects/app/index.js"
+        )
+      ).toBe("file:///opt/projects/app/src/components/button.js");
+      expect(
+        resolver("lodash", "file:///opt/projects/app/index.js")
+      ).toBe("https://cdn.skypack.dev/lodash@4.17.21");
+      expect(
+        resolver(
+          "components/button.js",
+          "file:///opt/projects/app/src/admin/index.js"
+        )
+      ).toBe("file:///opt/projects/app/src/admin/components/button.js");
+      expect(
+        resolver(
+          "lodash",
+          "file:///opt/projects/app/src/admin/index.js"
+        )
+      ).toBe("https://cdn.skypack.dev/lodash@4.17.15");
+    });
+  });
+  describe("real world scenarios", () => {
+    it("resolves server-side rendering project imports", () => {
+      const base = "file:///opt/projects/example/server-app";
+      const importMap = {
+        imports: {
+          "app/server/entry": "file:///opt/projects/example/server-app/dist/server/exports/src/entry.server.mjs"
+        },
+        scopes: {
+          "file:///opt/projects/example/server-app/dist/server/": {}
+        }
+      };
+      const resolver = createImportMapResolver(base, importMap);
+      expect(
+        resolver(
+          "app/server/entry",
+          "file:///opt/projects/example/server-app/index.js"
+        )
+      ).toBe(
+        "file:///opt/projects/example/server-app/dist/server/exports/src/entry.server.mjs"
+      );
+      expect(
+        resolver(
+          "app/server/entry",
+          "file:///opt/projects/example/server-app/dist/server/main.js"
+        )
+      ).toBe(
+        "file:///opt/projects/example/server-app/dist/server/exports/src/entry.server.mjs"
+      );
+    });
+  });
+  describe("unresolved specifiers", () => {
+    it("returns null for unresolved specifiers", () => {
+      const base = "file:///opt/projects/app";
+      const importMap = {
+        imports: {
+          "utils/": "file:///opt/projects/app/src/utils/"
+        }
+      };
+      const resolver = createImportMapResolver(base, importMap);
+      expect(
+        resolver(
+          "components/button.js",
+          "file:///opt/projects/app/index.js"
+        )
+      ).toBe(null);
+    });
+  });
+  describe("edge cases", () => {
+    it("handles empty import map", () => {
+      const base = "file:///opt/projects/app";
+      const importMap = {};
+      const resolver = createImportMapResolver(base, importMap);
+      expect(
+        resolver("lodash", "file:///opt/projects/app/index.js")
+      ).toBe(null);
+    });
+    it("handles spaces in paths", () => {
+      const base = "file:///opt/projects/My%20Project/app";
+      const importMap = {
+        imports: {
+          "components/": "file:///opt/projects/My%20Project/app/src/my%20components/"
+        }
+      };
+      const resolver = createImportMapResolver(base, importMap);
+      expect(
+        resolver(
+          "components/button.js",
+          "file:///opt/projects/My%20Project/app/index.js"
+        )
+      ).toBe(
+        "file:///opt/projects/My%20Project/app/src/my%20components/button.js"
+      );
+    });
+    it("handles Unicode characters in paths", () => {
+      const base = "file:///opt/projects/%E5%9B%BD%E9%99%85%E5%8C%96/app";
+      const importMap = {
+        imports: {
+          "\u56FD\u9645\u5316/": "file:///opt/projects/%E5%9B%BD%E9%99%85%E5%8C%96/app/src/%E5%9B%BD%E9%99%85%E5%8C%96/"
+        }
+      };
+      const resolver = createImportMapResolver(base, importMap);
+      expect(
+        resolver(
+          "\u56FD\u9645\u5316/zh.js",
+          "file:///opt/projects/%E5%9B%BD%E9%99%85%E5%8C%96/app/index.js"
+        )
+      ).toBe(
+        "file:///opt/projects/%E5%9B%BD%E9%99%85%E5%8C%96/app/src/%E5%9B%BD%E9%99%85%E5%8C%96/zh.js"
+      );
+    });
+  });
+});

package/dist/import-vm.mjs

@@ -1,10 +1,10 @@
 import fs from "node:fs";
 import { isBuiltin } from "node:module";
 import path from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { fileURLToPath } from "node:url";
 import vm from "node:vm";
-import IM from "@import-maps/resolve";
 import { CircularDependencyError, FileReadError } from "./error.mjs";
+import { createImportMapResolver } from "./import-map-resolve.mjs";
 async function importBuiltinModule(specifier, context) {
   const nodeModule = await import(specifier);
   const keys = Object.keys(nodeModule);
@@ -27,36 +27,33 @@ async function importBuiltinModule(specifier, context) {
   return module;
 }
 export function createVmImport(baseURL, importMap = {}) {
-  const parsedImportMap = IM.parse(importMap, baseURL);
-  const parse = (specifier, parent) => {
-    const result = IM.resolve(specifier, parsedImportMap, new URL(parent));
-    let filename;
-    if (result.matched && result.resolvedImport) {
-      filename = result.resolvedImport.href;
-    } else {
-      filename = import.meta.resolve(specifier, parent);
-    }
-    const url = pathToFileURL(filename);
-    const pathname = fileURLToPath(url);
+  const importMapResolver = createImportMapResolver(baseURL.href, importMap);
+  const buildMeta = (specifier, parent) => {
+    const result = importMapResolver(specifier, parent);
+    const url = result ?? import.meta.resolve(specifier, parent);
+    const filename = fileURLToPath(url);
     return {
       filename,
+      dirname: path.dirname(filename),
       url,
-      pathname
+      resolve: (specifier2, parent2 = url) => {
+        return import.meta.resolve(specifier2, parent2);
+      }
     };
   };
   async function moduleLinker(specifier, parent, context, cache, moduleIds) {
     if (isBuiltin(specifier)) {
       return importBuiltinModule(specifier, context);
     }
-    const parsed = parse(specifier, parent);
-    if (moduleIds.includes(parsed.pathname)) {
+    const meta = buildMeta(specifier, parent);
+    if (moduleIds.includes(meta.filename)) {
       throw new CircularDependencyError(
         "Circular dependency detected",
         moduleIds,
-        parsed.pathname
+        meta.filename
       );
     }
-    const module = cache.get(parsed.pathname);
+    const module = cache.get(meta.filename);
     if (module) {
       return module;
     }
@@ -65,49 +62,43 @@ export function createVmImport(baseURL, importMap = {}) {
         moduleBuild().then(resolve);
       });
     });
-    const dirname = path.dirname(parsed.filename);
-    cache.set(parsed.pathname, modulePromise);
+    cache.set(meta.filename, modulePromise);
     return modulePromise;
     async function moduleBuild() {
       let text;
       try {
-        text = fs.readFileSync(parsed.pathname, "utf-8");
+        text = fs.readFileSync(meta.filename, "utf-8");
       } catch (error) {
         throw new FileReadError(
-          `Failed to read module: ${parsed.pathname}`,
+          `Failed to read module: ${meta.filename}`,
           moduleIds,
-          parsed.pathname,
+          meta.filename,
           error
         );
       }
       const module2 = new vm.SourceTextModule(text, {
-        initializeImportMeta: (meta) => {
-          meta.filename = parsed.filename;
-          meta.dirname = dirname;
-          meta.resolve = (specifier2, parent2 = parsed.url) => {
-            return import.meta.resolve(specifier2, parent2);
-          };
-          meta.url = parsed.url.toString();
+        initializeImportMeta: (importMeta) => {
+          Object.assign(importMeta, meta);
         },
         identifier: specifier,
         context,
         importModuleDynamically: (specifier2, referrer) => {
           return moduleLinker(
             specifier2,
-            parsed.filename,
+            meta.filename,
             referrer.context,
             cache,
-            [...moduleIds, parsed.pathname]
+            [...moduleIds, meta.filename]
           );
         }
       });
       await module2.link((specifier2, referrer) => {
         return moduleLinker(
           specifier2,
-          parsed.filename,
+          meta.filename,
           referrer.context,
           cache,
-          [...moduleIds, parsed.pathname]
+          [...moduleIds, meta.filename]
         );
       });
       await module2.evaluate();

package/dist/types.d.ts

@@ -4,3 +4,4 @@ export interface ImportMap {
     imports?: SpecifierMap;
     scopes?: ScopesMap;
 }
+export type ImportMapResolver = (specifier: string, parent: string) => string | null;

package/package.json

@@ -33,7 +33,7 @@
     },
     "devDependencies": {
         "@biomejs/biome": "1.9.4",
-        "@esmx/lint": "3.0.0-rc.44",
+        "@esmx/lint": "3.0.0-rc.46",
         "@types/node": "^24.0.0",
         "@vitest/coverage-v8": "3.2.4",
         "stylelint": "16.21.0",
@@ -41,7 +41,7 @@
         "unbuild": "3.5.0",
         "vitest": "3.2.4"
     },
-    "version": "3.0.0-rc.44",
+    "version": "3.0.0-rc.46",
     "type": "module",
     "private": false,
     "exports": {
@@ -60,5 +60,5 @@
         "template",
         "public"
     ],
-    "gitHead": "c83ac6a9b183e5f1a98884d9ae18ff99aacf1a54"
+    "gitHead": "dcac010017466e95e1c7db78094d4925c27d54b9"
 }

package/src/import-loader.ts

@@ -1,7 +1,7 @@
 import module from 'node:module';
-import { pathToFileURL } from 'node:url';
 import IM from '@import-maps/resolve';
-import type { ImportMap } from './types';
+import { createImportMapResolver } from './import-map-resolve';
+import type { ImportMap, ImportMapResolver } from './types';
 
 interface Data {
     baseURL: string;
@@ -34,23 +34,17 @@ export function createLoaderImport(baseURL: URL, importMap: ImportMap = {}) {
     };
 }
 
-let loaderBaseURL: URL = new URL('file:');
-let loaderParsedImportMap: IM.ParsedImportMap = {};
+let importMapResolver: ImportMapResolver | null = null;
 
 export function initialize(data: Data) {
-    loaderBaseURL = new URL(data.baseURL);
-    loaderParsedImportMap = IM.parse(data.importMap, loaderBaseURL);
+    importMapResolver = createImportMapResolver(data.baseURL, data.importMap);
 }
 
 export function resolve(
     specifier: string,
-    context: Record<string, any>,
+    context: { parentURL: string },
     nextResolve: Function
 ) {
-    const scriptURL = new URL(context.parentURL);
-    const result = IM.resolve(specifier, loaderParsedImportMap, scriptURL);
-    if (result.matched && result.resolvedImport) {
-        return nextResolve(pathToFileURL(result.resolvedImport.pathname).href);
-    }
-    return nextResolve(specifier, context);
+    const result = importMapResolver?.(specifier, context.parentURL);
+    return nextResolve(result ?? specifier, context);
 }

package/src/import-map-resolve.test.ts

@@ -0,0 +1,224 @@
+import { describe, expect, it } from 'vitest';
+import { createImportMapResolver } from './import-map-resolve';
+import type { ImportMap } from './types';
+
+describe('createImportMapResolver', () => {
+    describe('basic import resolution', () => {
+        it('resolves imports correctly on Windows', () => {
+            const base = 'file:///C:/projects/app';
+
+            const importMap: ImportMap = {
+                imports: {
+                    lodash: 'https://cdn.skypack.dev/lodash',
+                    'utils/': 'file:///C:/projects/app/src/utils/',
+                    './components/': './components/'
+                }
+            };
+
+            const resolver = createImportMapResolver(base, importMap);
+
+            expect(resolver('lodash', 'file:///C:/projects/app/index.js')).toBe(
+                'https://cdn.skypack.dev/lodash'
+            );
+
+            expect(
+                resolver('utils/math.js', 'file:///C:/projects/app/index.js')
+            ).toBe('file:///C:/projects/app/src/utils/math.js');
+
+            expect(
+                resolver(
+                    './components/button.js',
+                    'file:///C:/projects/app/index.js'
+                )
+            ).toBe('file:///C:/projects/app/components/button.js');
+        });
+
+        it('resolves imports correctly on Unix', () => {
+            const base = 'file:///opt/projects/app';
+
+            const importMap: ImportMap = {
+                imports: {
+                    lodash: 'https://cdn.skypack.dev/lodash',
+                    'utils/': 'file:///opt/projects/app/src/utils/',
+                    './components/': './components/'
+                }
+            };
+
+            const resolver = createImportMapResolver(base, importMap);
+
+            expect(
+                resolver('lodash', 'file:///opt/projects/app/index.js')
+            ).toBe('https://cdn.skypack.dev/lodash');
+
+            expect(
+                resolver('utils/math.js', 'file:///opt/projects/app/index.js')
+            ).toBe('file:///opt/projects/app/src/utils/math.js');
+
+            expect(
+                resolver(
+                    './components/button.js',
+                    'file:///opt/projects/app/index.js'
+                )
+            ).toBe('file:///opt/projects/app/components/button.js');
+        });
+    });
+
+    describe('scopes resolution', () => {
+        it('resolves imports from different scopes', () => {
+            const base = 'file:///opt/projects/app';
+
+            const importMap: ImportMap = {
+                imports: {
+                    'components/': 'file:///opt/projects/app/src/components/',
+                    lodash: 'https://cdn.skypack.dev/lodash@4.17.21'
+                },
+                scopes: {
+                    'file:///opt/projects/app/src/admin/': {
+                        'components/':
+                            'file:///opt/projects/app/src/admin/components/',
+                        lodash: 'https://cdn.skypack.dev/lodash@4.17.15'
+                    }
+                }
+            };
+
+            const resolver = createImportMapResolver(base, importMap);
+
+            expect(
+                resolver(
+                    'components/button.js',
+                    'file:///opt/projects/app/index.js'
+                )
+            ).toBe('file:///opt/projects/app/src/components/button.js');
+            expect(
+                resolver('lodash', 'file:///opt/projects/app/index.js')
+            ).toBe('https://cdn.skypack.dev/lodash@4.17.21');
+
+            expect(
+                resolver(
+                    'components/button.js',
+                    'file:///opt/projects/app/src/admin/index.js'
+                )
+            ).toBe('file:///opt/projects/app/src/admin/components/button.js');
+            expect(
+                resolver(
+                    'lodash',
+                    'file:///opt/projects/app/src/admin/index.js'
+                )
+            ).toBe('https://cdn.skypack.dev/lodash@4.17.15');
+        });
+    });
+
+    describe('real world scenarios', () => {
+        it('resolves server-side rendering project imports', () => {
+            const base = 'file:///opt/projects/example/server-app';
+
+            const importMap: ImportMap = {
+                imports: {
+                    'app/server/entry':
+                        'file:///opt/projects/example/server-app/dist/server/exports/src/entry.server.mjs'
+                },
+                scopes: {
+                    'file:///opt/projects/example/server-app/dist/server/': {}
+                }
+            };
+
+            const resolver = createImportMapResolver(base, importMap);
+
+            expect(
+                resolver(
+                    'app/server/entry',
+                    'file:///opt/projects/example/server-app/index.js'
+                )
+            ).toBe(
+                'file:///opt/projects/example/server-app/dist/server/exports/src/entry.server.mjs'
+            );
+
+            expect(
+                resolver(
+                    'app/server/entry',
+                    'file:///opt/projects/example/server-app/dist/server/main.js'
+                )
+            ).toBe(
+                'file:///opt/projects/example/server-app/dist/server/exports/src/entry.server.mjs'
+            );
+        });
+    });
+
+    describe('unresolved specifiers', () => {
+        it('returns null for unresolved specifiers', () => {
+            const base = 'file:///opt/projects/app';
+
+            const importMap: ImportMap = {
+                imports: {
+                    'utils/': 'file:///opt/projects/app/src/utils/'
+                }
+            };
+
+            const resolver = createImportMapResolver(base, importMap);
+
+            expect(
+                resolver(
+                    'components/button.js',
+                    'file:///opt/projects/app/index.js'
+                )
+            ).toBe(null);
+        });
+    });
+
+    describe('edge cases', () => {
+        it('handles empty import map', () => {
+            const base = 'file:///opt/projects/app';
+            const importMap: ImportMap = {};
+
+            const resolver = createImportMapResolver(base, importMap);
+
+            expect(
+                resolver('lodash', 'file:///opt/projects/app/index.js')
+            ).toBe(null);
+        });
+
+        it('handles spaces in paths', () => {
+            const base = 'file:///opt/projects/My%20Project/app';
+
+            const importMap: ImportMap = {
+                imports: {
+                    'components/':
+                        'file:///opt/projects/My%20Project/app/src/my%20components/'
+                }
+            };
+
+            const resolver = createImportMapResolver(base, importMap);
+
+            expect(
+                resolver(
+                    'components/button.js',
+                    'file:///opt/projects/My%20Project/app/index.js'
+                )
+            ).toBe(
+                'file:///opt/projects/My%20Project/app/src/my%20components/button.js'
+            );
+        });
+
+        it('handles Unicode characters in paths', () => {
+            const base = 'file:///opt/projects/%E5%9B%BD%E9%99%85%E5%8C%96/app';
+
+            const importMap: ImportMap = {
+                imports: {
+                    '国际化/':
+                        'file:///opt/projects/%E5%9B%BD%E9%99%85%E5%8C%96/app/src/%E5%9B%BD%E9%99%85%E5%8C%96/'
+                }
+            };
+
+            const resolver = createImportMapResolver(base, importMap);
+
+            expect(
+                resolver(
+                    '国际化/zh.js',
+                    'file:///opt/projects/%E5%9B%BD%E9%99%85%E5%8C%96/app/index.js'
+                )
+            ).toBe(
+                'file:///opt/projects/%E5%9B%BD%E9%99%85%E5%8C%96/app/src/%E5%9B%BD%E9%99%85%E5%8C%96/zh.js'
+            );
+        });
+    });
+});

package/src/import-map-resolve.ts

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

package/src/import-vm.ts

@@ -1,10 +1,10 @@
 import fs from 'node:fs';
 import { isBuiltin } from 'node:module';
 import path from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
+import { fileURLToPath } from 'node:url';
 import vm from 'node:vm';
-import IM from '@import-maps/resolve';
 import { CircularDependencyError, FileReadError } from './error';
+import { createImportMapResolver } from './import-map-resolve';
 import type { ImportMap } from './types';
 
 async function importBuiltinModule(specifier: string, context: vm.Context) {
@@ -30,22 +30,19 @@ async function importBuiltinModule(specifier: string, context: vm.Context) {
 }
 
 export function createVmImport(baseURL: URL, importMap: ImportMap = {}) {
-    const parsedImportMap = IM.parse(importMap, baseURL);
-    const parse = (specifier: string, parent: string) => {
-        const result = IM.resolve(specifier, parsedImportMap, new URL(parent));
+    const importMapResolver = createImportMapResolver(baseURL.href, importMap);
+    const buildMeta = (specifier: string, parent: string): ImportMeta => {
+        const result = importMapResolver(specifier, parent);
 
-        let filename: string;
-        if (result.matched && result.resolvedImport) {
-            filename = result.resolvedImport.href;
-        } else {
-            filename = import.meta.resolve(specifier, parent);
-        }
-        const url = pathToFileURL(filename);
-        const pathname = fileURLToPath(url);
+        const url: string = result ?? import.meta.resolve(specifier, parent);
+        const filename = fileURLToPath(url);
         return {
             filename,
+            dirname: path.dirname(filename),
             url,
-            pathname
+            resolve: (specifier: string, parent: string | URL = url) => {
+                return import.meta.resolve(specifier, parent);
+            }
         };
     };
     async function moduleLinker(
@@ -58,17 +55,17 @@ export function createVmImport(baseURL: URL, importMap: ImportMap = {}) {
         if (isBuiltin(specifier)) {
             return importBuiltinModule(specifier, context);
         }
-        const parsed = parse(specifier, parent);
+        const meta = buildMeta(specifier, parent);
 
-        if (moduleIds.includes(parsed.pathname)) {
+        if (moduleIds.includes(meta.filename)) {
             throw new CircularDependencyError(
                 'Circular dependency detected',
                 moduleIds,
-                parsed.pathname
+                meta.filename
             );
         }
 
-        const module = cache.get(parsed.pathname);
+        const module = cache.get(meta.filename);
         if (module) {
             return module;
         }
@@ -78,53 +75,44 @@ export function createVmImport(baseURL: URL, importMap: ImportMap = {}) {
             });
         });
 
-        const dirname = path.dirname(parsed.filename);
-        cache.set(parsed.pathname, modulePromise);
+        cache.set(meta.filename, modulePromise);
         return modulePromise;
 
         async function moduleBuild(): Promise<vm.SourceTextModule> {
             let text: string;
             try {
-                text = fs.readFileSync(parsed.pathname, 'utf-8');
+                text = fs.readFileSync(meta.filename, 'utf-8');
             } catch (error) {
                 throw new FileReadError(
-                    `Failed to read module: ${parsed.pathname}`,
+                    `Failed to read module: ${meta.filename}`,
                     moduleIds,
-                    parsed.pathname,
+                    meta.filename,
                     error as Error
                 );
             }
             const module = new vm.SourceTextModule(text, {
-                initializeImportMeta: (meta) => {
-                    meta.filename = parsed.filename;
-                    meta.dirname = dirname;
-                    meta.resolve = (
-                        specifier: string,
-                        parent: string | URL = parsed.url
-                    ) => {
-                        return import.meta.resolve(specifier, parent);
-                    };
-                    meta.url = parsed.url.toString();
+                initializeImportMeta: (importMeta) => {
+                    Object.assign(importMeta, meta);
                 },
                 identifier: specifier,
                 context: context,
                 importModuleDynamically: (specifier, referrer) => {
                     return moduleLinker(
                         specifier,
-                        parsed.filename,
+                        meta.filename,
                         referrer.context,
                         cache,
-                        [...moduleIds, parsed.pathname]
+                        [...moduleIds, meta.filename]
                     );
                 }
             });
             await module.link((specifier: string, referrer) => {
                 return moduleLinker(
                     specifier,
-                    parsed.filename,
+                    meta.filename,
                     referrer.context,
                     cache,
-                    [...moduleIds, parsed.pathname]
+                    [...moduleIds, meta.filename]
                 );
             });
             await module.evaluate();

package/src/types.ts

@@ -6,3 +6,8 @@ export interface ImportMap {
     imports?: SpecifierMap;
     scopes?: ScopesMap;
 }
+
+export type ImportMapResolver = (
+    specifier: string,
+    parent: string
+) => string | null;