@startracex/node-resolve 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 startracex
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,35 @@
+# node-resolve
+
+```ts
+import { ModuleResolver } from "@startracex/node-resolve";
+import fs from "node:fs";
+import path from "node:path";
+
+const resolver = new ModuleResolver({
+  extensions: [".js"],
+  isCoreModule: (id) => id.startsWith("node:"),
+  mainFields: ["main"],
+  path: path,
+  fs: fs,
+});
+
+const resolved = resolver.resolve("@scope/pkg", "/dir/of/resolver"); // /dir/node_modules/@scope/pkg/index.js
+```
+
+```go
+import (
+	"strings"
+	resolve "github.com/startracex/node-resolve"
+)
+
+func main() {
+	resolver := resolve.NewModuleResolver(&resolve.ResolverConfig{
+		Extensions: []string{".js"},
+		IsCoreModule: func(s string) bool {
+			return strings.HasPrefix(s, "node:")
+		},
+		MainFields: []string{"main"},
+	})
+	resolved := resolver.Resolve("@scope/pkg", "/dir/of/resolver") // /dir/node_modules/@scope/pkg/index.js
+}
+```

package/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./specifier.js";
+export * from "./module-resolver.js";
+export * from "./subpath-resolver.js";
+//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC"}

package/index.js

@@ -0,0 +1,3 @@
+export * from "./specifier.js";
+export * from "./module-resolver.js";
+export * from "./subpath-resolver.js";

package/index.ts

@@ -0,0 +1,3 @@
+export * from "./specifier.js";
+export * from "./module-resolver.js";
+export * from "./subpath-resolver.js";

package/module-resolver.d.ts

@@ -0,0 +1,34 @@
+import { SubpathResolver } from "./subpath-resolver.js";
+import { Specifier } from "./specifier.js";
+export declare class ModuleResolver extends SubpathResolver {
+    extensions?: string[];
+    modulesDirectoryName: string;
+    manifestFileName: string;
+    mainFields: string[];
+    isCoreModule: (id: string) => boolean;
+    path: {
+        dirname: (path: string) => string;
+        join: (...paths: string[]) => string;
+    };
+    fs: {
+        statSync: (path: string) => {
+            isFile: () => boolean;
+            isDirectory: () => boolean;
+        };
+        readFileSync: (path: string) => string | {};
+    };
+    index: string;
+    constructor({ extensions, isCoreModule, modulesDirectoryName, manifestFileName, mainFields, index, path, fs, ...args }?: Partial<ModuleResolver>);
+    modulesPaths(start?: string, name?: string): string[];
+    resolve(path: string, base: string): string | undefined;
+    resolveModuleSpecifier({ name, path }: Specifier, base?: string): string | undefined;
+    protected resolveFile(filePath: string): string | undefined;
+    protected resolveDir(dirPath: string, entry?: string): string | undefined;
+    protected resolveFileOrDir(subPath: string, entry?: string): string | undefined;
+    protected readJSON(fullPath: string): Record<string, any>;
+    protected stat(path: string): {
+        isFile(): boolean;
+        isDirectory(): boolean;
+    } | null;
+}
+//# sourceMappingURL=module-resolver.d.ts.map

package/module-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-resolver.d.ts","sourceRoot":"","sources":["module-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAkB,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3D,qBAAa,cAAe,SAAQ,eAAe;IACjD,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,YAAY,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC;IACtC,IAAI,EAAE;QACJ,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;QAClC,IAAI,EAAE,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,KAAK,MAAM,CAAC;KACtC,CAAC;IACF,EAAE,EAAE;QACF,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK;YAC1B,MAAM,EAAE,MAAM,OAAO,CAAC;YACtB,WAAW,EAAE,MAAM,OAAO,CAAC;SAC5B,CAAC;QACF,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,EAAE,CAAC;KAC7C,CAAC;IACF,KAAK,EAAE,MAAM,CAAC;gBAEF,EACV,UAAU,EACV,YAA0B,EAC1B,oBAAqC,EACrC,gBAAiC,EACjC,UAAqB,EACrB,KAAe,EACf,IAAI,EACJ,EAAE,EACF,GAAG,IAAI,EACR,GAAE,OAAO,CAAC,cAAc,CAAM;IAY/B,YAAY,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,IAAI,SAAK,GAAG,MAAM,EAAE;IAmBjD,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IA2BvD,sBAAsB,CACpB,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,SAAS,EACzB,IAAI,CAAC,EAAE,MAAM,GACZ,MAAM,GAAG,SAAS;IAarB,SAAS,CAAC,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAgB3D,SAAS,CAAC,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IA0CzE,SAAS,CAAC,gBAAgB,CACxB,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,MAAM,GACb,MAAM,GAAG,SAAS;IAIrB,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAIzD,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG;QAC5B,MAAM,IAAI,OAAO,CAAC;QAClB,WAAW,IAAI,OAAO,CAAC;KACxB,GAAG,IAAI;CAOT"}

package/module-resolver.js

@@ -0,0 +1,141 @@
+import { SubpathResolver } from "./subpath-resolver.js";
+import { parseSpecifier } from "./specifier.js";
+export class ModuleResolver extends SubpathResolver {
+    extensions;
+    modulesDirectoryName;
+    manifestFileName;
+    mainFields;
+    isCoreModule;
+    path;
+    fs;
+    index;
+    constructor({ extensions, isCoreModule = () => false, modulesDirectoryName = "node_modules", manifestFileName = "package.json", mainFields = ["main"], index = "index", path, fs, ...args } = {}) {
+        super(args);
+        this.extensions = extensions;
+        this.isCoreModule = isCoreModule;
+        this.modulesDirectoryName = modulesDirectoryName;
+        this.manifestFileName = manifestFileName;
+        this.mainFields = mainFields;
+        this.path = path;
+        this.fs = fs;
+        this.index = index;
+    }
+    modulesPaths(start, name = "") {
+        const paths = [];
+        if (!start) {
+            return paths;
+        }
+        for (;;) {
+            paths.push(this.path.join(start, this.modulesDirectoryName, name));
+            const parent = this.path.dirname(start);
+            if (parent === start) {
+                break;
+            }
+            start = parent;
+        }
+        return paths;
+    }
+    resolve(path, base) {
+        if (this.isCoreModule?.(path)) {
+            return path;
+        }
+        if (path.startsWith("#")) {
+            const paths = this.resolveImports(path);
+            if (paths) {
+                for (const p of paths) {
+                    const rd = this.resolveFileOrDir(p);
+                    if (rd) {
+                        return rd;
+                    }
+                }
+            }
+            return;
+        }
+        const spec = parseSpecifier(path);
+        if (spec?.name) {
+            return this.resolveModuleSpecifier(spec, base);
+        }
+        return this.resolveFileOrDir(this.path.join(base, path));
+    }
+    resolveModuleSpecifier({ name, path }, base) {
+        const dirs = this.modulesPaths(base, name);
+        for (const dir of dirs) {
+            const stat = this.stat(dir);
+            if (stat?.isDirectory()) {
+                const rd = this.resolveDir(dir, path);
+                if (rd) {
+                    return rd;
+                }
+            }
+        }
+    }
+    resolveFile(filePath) {
+        const candidates = [
+            filePath,
+            ...(this.extensions || []).map((ext) => filePath + ext),
+        ];
+        for (const file of candidates) {
+            const stat = this.stat(file);
+            if (!stat || stat.isDirectory()) {
+                continue;
+            }
+            if (stat.isFile()) {
+                return file;
+            }
+        }
+    }
+    resolveDir(dirPath, entry) {
+        const packageJsonPath = this.path.join(dirPath, this.manifestFileName);
+        const stat = this.stat(packageJsonPath);
+        if (!stat?.isFile()) {
+            return this.resolveFile(this.path.join(dirPath, this.index));
+        }
+        const pkg = this.readJSON(packageJsonPath);
+        if (pkg.exports) {
+            const exportsMatchArray = new SubpathResolver({
+                exports: pkg.exports,
+                conditions: this.conditions,
+            }).resolveExports(entry);
+            if (exportsMatchArray) {
+                for (let match of exportsMatchArray) {
+                    match = this.path.join(dirPath, match);
+                    const stat = this.stat(match);
+                    if (stat?.isFile()) {
+                        return match;
+                    }
+                }
+            }
+            return;
+        }
+        if (!entry) {
+            for (const field of this.mainFields) {
+                let main = pkg[field];
+                if (!main) {
+                    continue;
+                }
+                main = this.path.join(dirPath, main);
+                const stat = this.stat(main);
+                if (stat?.isFile()) {
+                    return main;
+                }
+            }
+            return;
+        }
+        const subPath = this.path.join(dirPath, entry);
+        return this.resolveFileOrDir(subPath);
+    }
+    resolveFileOrDir(subPath, entry) {
+        return this.resolveFile(subPath) || this.resolveDir(subPath, entry);
+    }
+    readJSON(fullPath) {
+        return JSON.parse(this.fs.readFileSync(fullPath).toString());
+    }
+    stat(path) {
+        try {
+            return this.fs.statSync(path);
+        }
+        catch (e) {
+            return null;
+        }
+    }
+}

package/module-resolver.ts

@@ -0,0 +1,186 @@
+import { SubpathResolver } from "./subpath-resolver.js";
+import { parseSpecifier, Specifier } from "./specifier.js";
+
+export class ModuleResolver extends SubpathResolver {
+  extensions?: string[];
+  modulesDirectoryName: string;
+  manifestFileName: string;
+  mainFields: string[];
+  isCoreModule: (id: string) => boolean;
+  path: {
+    dirname: (path: string) => string;
+    join: (...paths: string[]) => string;
+  };
+  fs: {
+    statSync: (path: string) => {
+      isFile: () => boolean;
+      isDirectory: () => boolean;
+    };
+    readFileSync: (path: string) => string | {};
+  };
+  index: string;
+
+  constructor({
+    extensions,
+    isCoreModule = () => false,
+    modulesDirectoryName = "node_modules",
+    manifestFileName = "package.json",
+    mainFields = ["main"],
+    index = "index",
+    path,
+    fs,
+    ...args
+  }: Partial<ModuleResolver> = {}) {
+    super(args);
+    this.extensions = extensions;
+    this.isCoreModule = isCoreModule;
+    this.modulesDirectoryName = modulesDirectoryName;
+    this.manifestFileName = manifestFileName;
+    this.mainFields = mainFields;
+    this.path = path;
+    this.fs = fs;
+    this.index = index;
+  }
+
+  modulesPaths(start?: string, name = ""): string[] {
+    const paths: string[] = [];
+
+    if (!start) {
+      return paths;
+    }
+
+    for (;;) {
+      paths.push(this.path.join(start, this.modulesDirectoryName, name));
+      const parent = this.path.dirname(start);
+      if (parent === start) {
+        break;
+      }
+      start = parent;
+    }
+
+    return paths;
+  }
+
+  resolve(path: string, base: string): string | undefined {
+    if (this.isCoreModule?.(path)) {
+      return path;
+    }
+
+    if (path.startsWith("#")) {
+      const paths = this.resolveImports(path);
+      if (paths) {
+        for (const p of paths) {
+          const rd = this.resolveFileOrDir(p);
+          if (rd) {
+            return rd;
+          }
+        }
+      }
+      return;
+    }
+
+    const spec = parseSpecifier(path);
+
+    if (spec?.name) {
+      return this.resolveModuleSpecifier(spec, base);
+    }
+
+    return this.resolveFileOrDir(this.path.join(base, path));
+  }
+
+  resolveModuleSpecifier(
+    { name, path }: Specifier,
+    base?: string,
+  ): string | undefined {
+    const dirs = this.modulesPaths(base, name);
+    for (const dir of dirs) {
+      const stat = this.stat(dir);
+      if (stat?.isDirectory()) {
+        const rd = this.resolveDir(dir, path);
+        if (rd) {
+          return rd;
+        }
+      }
+    }
+  }
+
+  protected resolveFile(filePath: string): string | undefined {
+    const candidates = [
+      filePath,
+      ...(this.extensions || []).map((ext) => filePath + ext),
+    ];
+    for (const file of candidates) {
+      const stat = this.stat(file);
+      if (!stat || stat.isDirectory()) {
+        continue;
+      }
+      if (stat.isFile()) {
+        return file;
+      }
+    }
+  }
+
+  protected resolveDir(dirPath: string, entry?: string): string | undefined {
+    const packageJsonPath = this.path.join(dirPath, this.manifestFileName);
+    const stat = this.stat(packageJsonPath);
+    if (!stat?.isFile()) {
+      return this.resolveFile(this.path.join(dirPath, this.index));
+    }
+
+    const pkg = this.readJSON(packageJsonPath);
+    if (pkg.exports) {
+      const exportsMatchArray = new SubpathResolver({
+        exports: pkg.exports,
+        conditions: this.conditions,
+      }).resolveExports(entry);
+      if (exportsMatchArray) {
+        for (let match of exportsMatchArray) {
+          match = this.path.join(dirPath, match);
+          const stat = this.stat(match);
+          if (stat?.isFile()) {
+            return match;
+          }
+        }
+      }
+      return;
+    }
+    if (!entry) {
+      for (const field of this.mainFields) {
+        let main = pkg[field];
+        if (!main) {
+          continue;
+        }
+        main = this.path.join(dirPath, main);
+        const stat = this.stat(main);
+        if (stat?.isFile()) {
+          return main;
+        }
+      }
+      return;
+    }
+    const subPath = this.path.join(dirPath, entry);
+    return this.resolveFileOrDir(subPath);
+  }
+
+  protected resolveFileOrDir(
+    subPath: string,
+    entry?: string,
+  ): string | undefined {
+    return this.resolveFile(subPath) || this.resolveDir(subPath, entry);
+  }
+
+  protected readJSON(fullPath: string): Record<string, any> {
+    return JSON.parse(this.fs.readFileSync(fullPath).toString());
+  }
+
+  protected stat(path: string): {
+    isFile(): boolean;
+    isDirectory(): boolean;
+  } | null {
+    try {
+      return this.fs.statSync(path);
+    } catch (e) {
+      return null;
+    }
+  }
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@startracex/node-resolve",
+  "version": "0.0.0",
+  "description": "Node resolve algorithm",
+  "type": "module",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "fmt": "dprint fmt",
+    "check": "dprint check"
+  },
+  "devDependencies": {
+    "@startracex/dev-config": "^0.2.2",
+    "dprint": "^0.50.0",
+    "typescript": "^5.8.3"
+  },
+  "keywords": [
+    "node",
+    "resolve",
+    "algorithm",
+    "exports"
+  ],
+  "author": "startracex",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/startracex/node-resolve.git"
+  },
+  "files": [
+    "*.{js,ts}+(|.map)"
+  ],
+  "packageManager": "pnpm@10.11.0"
+}

package/specifier.d.ts

@@ -0,0 +1,14 @@
+export type Specifier = {
+    proto?: string;
+    scope?: string;
+    pkg?: string;
+    name?: string;
+    path?: string;
+};
+/**
+ * Parse a input string into a Specifier.
+ *
+ * input can be a npm package name with optional proto, subpath.
+ */
+export declare const parseSpecifier: (input: string) => Specifier | null;
+//# sourceMappingURL=specifier.d.ts.map

package/specifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"specifier.d.ts","sourceRoot":"","sources":["specifier.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAIF;;;;GAIG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,MAAM,KAAG,SAAS,GAAG,IAwB1D,CAAC"}

package/specifier.js

@@ -0,0 +1,28 @@
+const regexp = /^(?:@(\w[\w-.]*)\/)?(\w[\w-.]*)(\/(.*))?/;
+/**
+ * Parse a input string into a Specifier.
+ *
+ * input can be a npm package name with optional proto, subpath.
+ */
+export const parseSpecifier = (input) => {
+    if (!input) {
+        return null;
+    }
+    const sp = input.split(":");
+    const path = sp.pop();
+    const match = path.match(regexp);
+    console.log(match);
+    if (!match || !match[0] || !match[2]) {
+        return null;
+    }
+    const scope = match[1];
+    const pkg = match[2];
+    const result = {
+        name: scope ? `@${scope}/${pkg}` : pkg,
+        scope,
+        pkg,
+        proto: sp.pop(),
+        path: match[4],
+    };
+    return result;
+};

package/specifier.ts

@@ -0,0 +1,40 @@
+export type Specifier = {
+  proto?: string;
+  scope?: string;
+  pkg?: string;
+  name?: string;
+  path?: string;
+};
+
+const regexp = /^(?:@(\w[\w-.]*)\/)?(\w[\w-.]*)(\/(.*))?/;
+
+/**
+ * Parse a input string into a Specifier.
+ *
+ * input can be a npm package name with optional proto, subpath.
+ */
+export const parseSpecifier = (input: string): Specifier | null => {
+  if (!input) {
+    return null;
+  }
+  const sp = input.split(":");
+  const path = sp.pop();
+
+  const match = path.match(regexp);
+
+  console.log(match);
+  if (!match || !match[0] || !match[2]) {
+    return null;
+  }
+
+  const scope = match[1];
+  const pkg = match[2];
+  const result: Specifier = {
+    name: scope ? `@${scope}/${pkg}` : pkg,
+    scope,
+    pkg,
+    proto: sp.pop(),
+    path: match[4],
+  };
+  return result;
+};

package/subpath-resolver.d.ts

@@ -0,0 +1,18 @@
+type Value = string | string[] | {
+    [key: string]: Value;
+};
+export declare const resolveMapping: (mapping: Record<string, Value>, conditions: string[], input: string) => string[] | null;
+export declare class SubpathResolver {
+    conditions: string[];
+    exports: Record<string, Value>;
+    imports: Record<string, Value>;
+    constructor({ exports, imports, conditions, }: {
+        exports?: Value;
+        imports?: Record<string, Value>;
+        conditions?: string[];
+    });
+    resolveExports(entry?: string): string[];
+    resolveImports(entry: string): string[] | null;
+}
+export {};
+//# sourceMappingURL=subpath-resolver.d.ts.map

package/subpath-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subpath-resolver.d.ts","sourceRoot":"","sources":["subpath-resolver.ts"],"names":[],"mappings":"AAAA,KAAK,KAAK,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAA;CAAE,CAAC;AAyE1D,eAAO,MAAM,cAAc,GACzB,SAAS,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EAC9B,YAAY,MAAM,EAAE,EACpB,OAAO,MAAM,KACZ,MAAM,EAAE,GAAG,IA6Bb,CAAC;AAcF,qBAAa,eAAe;IAC1B,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAC/B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;gBAEnB,EACV,OAAO,EACP,OAAO,EACP,UAAwB,GACzB,EAAE;QACD,OAAO,CAAC,EAAE,KAAK,CAAC;QAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QAChC,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;KACvB;IAMD,cAAc,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE;IAIxC,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI;CAM/C"}

package/subpath-resolver.js

@@ -0,0 +1,114 @@
+const normalizeMapping = (m) => {
+    if (!m) {
+        return {};
+    }
+    if (typeof m === "string" || Array.isArray(m)) {
+        return { ".": m };
+    }
+    return m;
+};
+const findWildcardMatch = (mapping, input) => {
+    let bestMatch = null;
+    let replacement = "";
+    for (const key in mapping) {
+        if (key.endsWith("/*")) {
+            const prefix = key.slice(0, -1);
+            if (input.startsWith(prefix)) {
+                const matchLength = prefix.length;
+                if (!bestMatch || matchLength > bestMatch.length) {
+                    bestMatch = { key, length: matchLength };
+                    replacement = input.slice(prefix.length);
+                }
+            }
+        }
+        else if (key.includes("*")) {
+            const [before, after] = key.split("*");
+            if (input.startsWith(before) && input.endsWith(after)) {
+                const matchLength = before.length + after.length;
+                if (!bestMatch || matchLength > bestMatch.length) {
+                    bestMatch = { key, length: matchLength };
+                    replacement = input.slice(before.length, input.length - after.length);
+                }
+            }
+        }
+        else if (key.endsWith("/") && input.startsWith(key)) {
+            const matchLength = key.length;
+            if (!bestMatch || matchLength > bestMatch.length) {
+                bestMatch = { key, length: matchLength };
+                replacement = input.slice(key.length);
+            }
+        }
+    }
+    return bestMatch ? { key: bestMatch.key, replacement } : null;
+};
+const resolveMappingValue = (value, conditions) => {
+    if (!value)
+        return null;
+    if (typeof value === "string") {
+        return [value];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap((v) => resolveMappingValue(v, conditions) || []);
+    }
+    for (const [condition, subValue] of Object.entries(value)) {
+        if (conditions.includes(condition)) {
+            return resolveMappingValue(subValue, conditions);
+        }
+    }
+    return null;
+};
+export const resolveMapping = (mapping, conditions, input) => {
+    let value = mapping[input];
+    let wildcardMatch = null;
+    if (value === undefined) {
+        wildcardMatch = findWildcardMatch(mapping, input);
+        if (wildcardMatch) {
+            value = mapping[wildcardMatch.key];
+        }
+    }
+    const resolved = resolveMappingValue(value, conditions);
+    if (!resolved) {
+        return null;
+    }
+    if (!wildcardMatch) {
+        return resolved;
+    }
+    return resolved.map((r) => {
+        if (r.includes("*")) {
+            return r.replace("*", wildcardMatch.replacement);
+        }
+        if (r.endsWith("/")) {
+            return r + wildcardMatch.replacement;
+        }
+        return r;
+    });
+};
+const subpathPrefix = "./";
+const normalizeEntry = (entry) => {
+    if (!entry || entry === "." || entry === subpathPrefix) {
+        return ".";
+    }
+    if (entry.startsWith(subpathPrefix)) {
+        return entry;
+    }
+    return subpathPrefix + entry;
+};
+export class SubpathResolver {
+    conditions;
+    exports;
+    imports;
+    constructor({ exports, imports, conditions = ["default"], }) {
+        this.imports = imports;
+        this.exports = normalizeMapping(exports);
+        this.conditions = conditions;
+    }
+    resolveExports(entry) {
+        return resolveMapping(this.exports, this.conditions, normalizeEntry(entry));
+    }
+    resolveImports(entry) {
+        if (!this.imports) {
+            return null;
+        }
+        return resolveMapping(this.imports, this.conditions, entry);
+    }
+}

package/subpath-resolver.ts

@@ -0,0 +1,150 @@
+type Value = string | string[] | { [key: string]: Value };
+
+const normalizeMapping = (m: Value): Record<string, Value> => {
+  if (!m) {
+    return {};
+  }
+  if (typeof m === "string" || Array.isArray(m)) {
+    return { ".": m };
+  }
+  return m;
+};
+
+const findWildcardMatch = (
+  mapping: Record<string, Value>,
+  input: string,
+): { key: string; replacement: string } | null => {
+  let bestMatch: { key: string; length: number } | null = null;
+  let replacement = "";
+
+  for (const key in mapping) {
+    if (key.endsWith("/*")) {
+      const prefix = key.slice(0, -1);
+      if (input.startsWith(prefix)) {
+        const matchLength = prefix.length;
+        if (!bestMatch || matchLength > bestMatch.length) {
+          bestMatch = { key, length: matchLength };
+          replacement = input.slice(prefix.length);
+        }
+      }
+    } else if (key.includes("*")) {
+      const [before, after] = key.split("*");
+      if (input.startsWith(before) && input.endsWith(after)) {
+        const matchLength = before.length + after.length;
+        if (!bestMatch || matchLength > bestMatch.length) {
+          bestMatch = { key, length: matchLength };
+          replacement = input.slice(before.length, input.length - after.length);
+        }
+      }
+    } else if (key.endsWith("/") && input.startsWith(key)) {
+      const matchLength = key.length;
+      if (!bestMatch || matchLength > bestMatch.length) {
+        bestMatch = { key, length: matchLength };
+        replacement = input.slice(key.length);
+      }
+    }
+  }
+
+  return bestMatch ? { key: bestMatch.key, replacement } : null;
+};
+
+const resolveMappingValue = (
+  value: Value | undefined,
+  conditions: string[],
+): string[] | null => {
+  if (!value) return null;
+
+  if (typeof value === "string") {
+    return [value];
+  }
+
+  if (Array.isArray(value)) {
+    return value.flatMap((v) => resolveMappingValue(v, conditions) || []);
+  }
+
+  for (const [condition, subValue] of Object.entries(value)) {
+    if (conditions.includes(condition)) {
+      return resolveMappingValue(subValue, conditions);
+    }
+  }
+
+  return null;
+};
+
+export const resolveMapping = (
+  mapping: Record<string, Value>,
+  conditions: string[],
+  input: string,
+): string[] | null => {
+  let value = mapping[input];
+  let wildcardMatch: { key: string; replacement: string } | null = null;
+
+  if (value === undefined) {
+    wildcardMatch = findWildcardMatch(mapping, input);
+    if (wildcardMatch) {
+      value = mapping[wildcardMatch.key];
+    }
+  }
+
+  const resolved = resolveMappingValue(value, conditions);
+  if (!resolved) {
+    return null;
+  }
+
+  if (!wildcardMatch) {
+    return resolved;
+  }
+
+  return resolved.map((r) => {
+    if (r.includes("*")) {
+      return r.replace("*", wildcardMatch.replacement);
+    }
+    if (r.endsWith("/")) {
+      return r + wildcardMatch.replacement;
+    }
+    return r;
+  });
+};
+
+const subpathPrefix = "./";
+
+const normalizeEntry = (entry: string) => {
+  if (!entry || entry === "." || entry === subpathPrefix) {
+    return ".";
+  }
+  if (entry.startsWith(subpathPrefix)) {
+    return entry;
+  }
+  return subpathPrefix + entry;
+};
+
+export class SubpathResolver {
+  conditions: string[];
+  exports: Record<string, Value>;
+  imports: Record<string, Value>;
+
+  constructor({
+    exports,
+    imports,
+    conditions = ["default"],
+  }: {
+    exports?: Value;
+    imports?: Record<string, Value>;
+    conditions?: string[];
+  }) {
+    this.imports = imports;
+    this.exports = normalizeMapping(exports);
+    this.conditions = conditions;
+  }
+
+  resolveExports(entry?: string): string[] {
+    return resolveMapping(this.exports, this.conditions, normalizeEntry(entry));
+  }
+
+  resolveImports(entry: string): string[] | null {
+    if (!this.imports) {
+      return null;
+    }
+    return resolveMapping(this.imports, this.conditions, entry);
+  }
+}