ts-swc-transform 2.8.1 → 2.8.2

package/dist/cjs/lib/resolveCJS.d.cts

@@ -0,0 +1,17 @@
+/**
+ * CJS resolver
+ *
+ * Uses the `resolve` npm package for CommonJS-style module resolution.
+ * Handles main field, index.js, etc.
+ *
+ * Note: CJS does not support subpath imports (#prefix) - those are ESM-only.
+ */
+/**
+ * Resolve a CJS specifier to an absolute file path
+ *
+ * @param specifier - The require specifier (e.g., 'lodash', 'lodash/get')
+ * @param basedir - The directory to resolve from
+ * @returns The resolved absolute file path
+ * @throws Error if module cannot be found
+ */
+export default function resolveCJS(specifier: string, basedir: string): string;

package/dist/cjs/lib/resolveCJS.d.ts

@@ -0,0 +1,17 @@
+/**
+ * CJS resolver
+ *
+ * Uses the `resolve` npm package for CommonJS-style module resolution.
+ * Handles main field, index.js, etc.
+ *
+ * Note: CJS does not support subpath imports (#prefix) - those are ESM-only.
+ */
+/**
+ * Resolve a CJS specifier to an absolute file path
+ *
+ * @param specifier - The require specifier (e.g., 'lodash', 'lodash/get')
+ * @param basedir - The directory to resolve from
+ * @returns The resolved absolute file path
+ * @throws Error if module cannot be found
+ */
+export default function resolveCJS(specifier: string, basedir: string): string;

package/dist/cjs/lib/resolveCJS.js

@@ -0,0 +1,80 @@
+/**
+ * CJS resolver
+ *
+ * Uses the `resolve` npm package for CommonJS-style module resolution.
+ * Handles main field, index.js, etc.
+ *
+ * Note: CJS does not support subpath imports (#prefix) - those are ESM-only.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, /**
+ * Resolve a CJS specifier to an absolute file path
+ *
+ * @param specifier - The require specifier (e.g., 'lodash', 'lodash/get')
+ * @param basedir - The directory to resolve from
+ * @returns The resolved absolute file path
+ * @throws Error if module cannot be found
+ */ "default", {
+    enumerable: true,
+    get: function() {
+        return resolveCJS;
+    }
+});
+var _resolve = /*#__PURE__*/ _interop_require_wildcard(require("resolve"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var _resolve_default;
+var resolveSync = ((_resolve_default = _resolve.default) !== null && _resolve_default !== void 0 ? _resolve_default : _resolve).sync;
+function resolveCJS(specifier, basedir) {
+    return resolveSync(specifier, {
+        basedir: basedir,
+        extensions: [
+            '.js',
+            '.json',
+            '.node',
+            '.mjs'
+        ]
+    });
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/lib/resolveCJS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/typescript/ts-swc-transform/src/lib/resolveCJS.ts"],"sourcesContent":["/**\n * CJS resolver\n *\n * Uses the `resolve` npm package for CommonJS-style module resolution.\n * Handles main field, index.js, etc.\n *\n * Note: CJS does not support subpath imports (#prefix) - those are ESM-only.\n */\n\nimport * as resolve from 'resolve';\n\nconst resolveSync = (resolve.default ?? resolve).sync;\n\n/**\n * Resolve a CJS specifier to an absolute file path\n *\n * @param specifier - The require specifier (e.g., 'lodash', 'lodash/get')\n * @param basedir - The directory to resolve from\n * @returns The resolved absolute file path\n * @throws Error if module cannot be found\n */\nexport default function resolveCJS(specifier: string, basedir: string): string {\n  return resolveSync(specifier, {\n    basedir,\n    extensions: ['.js', '.json', '.node', '.mjs'],\n  });\n}\n"],"names":["resolveCJS","resolve","resolveSync","default","sync","specifier","basedir","extensions"],"mappings":"AAAA;;;;;;;CAOC;;;;+BAMD;;;;;;;CAOC,GACD;;;eAAwBA;;;+DAZC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEJC;AAArB,IAAMC,cAAc,EAACD,mBAAAA,SAAQE,OAAO,cAAfF,8BAAAA,mBAAmBA,UAASG,IAAI;AAUtC,SAASJ,WAAWK,SAAiB,EAAEC,OAAe;IACnE,OAAOJ,YAAYG,WAAW;QAC5BC,SAAAA;QACAC,YAAY;YAAC;YAAO;YAAS;YAAS;SAAO;IAC/C;AACF"}

package/dist/cjs/lib/resolveESM.d.cts

@@ -0,0 +1,19 @@
+/**
+ * Unified ESM resolver
+ *
+ * Handles both:
+ * - Package exports: import x from 'lodash' → uses exports field
+ * - Subpath imports: import x from '#internal' → uses imports field
+ *
+ * Uses resolve.exports.resolve() which automatically detects the specifier type.
+ * Only loaded on Node >= 12.2 where module.createRequire exists.
+ */
+/**
+ * Resolve an ESM specifier to an absolute file path
+ *
+ * @param specifier - The import specifier (e.g., 'lodash', 'lodash/get', '#internal')
+ * @param parentPath - The file path of the importing module
+ * @param conditions - Export conditions (defaults to ['node', 'import'])
+ * @returns The resolved absolute file path, or null if not resolvable
+ */
+export default function resolveESM(specifier: string, parentPath: string, conditions?: string[]): string | null;

package/dist/cjs/lib/resolveESM.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Unified ESM resolver
+ *
+ * Handles both:
+ * - Package exports: import x from 'lodash' → uses exports field
+ * - Subpath imports: import x from '#internal' → uses imports field
+ *
+ * Uses resolve.exports.resolve() which automatically detects the specifier type.
+ * Only loaded on Node >= 12.2 where module.createRequire exists.
+ */
+/**
+ * Resolve an ESM specifier to an absolute file path
+ *
+ * @param specifier - The import specifier (e.g., 'lodash', 'lodash/get', '#internal')
+ * @param parentPath - The file path of the importing module
+ * @param conditions - Export conditions (defaults to ['node', 'import'])
+ * @returns The resolved absolute file path, or null if not resolvable
+ */
+export default function resolveESM(specifier: string, parentPath: string, conditions?: string[]): string | null;

package/dist/cjs/lib/resolveESM.js

@@ -0,0 +1,180 @@
+/**
+ * Unified ESM resolver
+ *
+ * Handles both:
+ * - Package exports: import x from 'lodash' → uses exports field
+ * - Subpath imports: import x from '#internal' → uses imports field
+ *
+ * Uses resolve.exports.resolve() which automatically detects the specifier type.
+ * Only loaded on Node >= 12.2 where module.createRequire exists.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, /**
+ * Resolve an ESM specifier to an absolute file path
+ *
+ * @param specifier - The import specifier (e.g., 'lodash', 'lodash/get', '#internal')
+ * @param parentPath - The file path of the importing module
+ * @param conditions - Export conditions (defaults to ['node', 'import'])
+ * @returns The resolved absolute file path, or null if not resolvable
+ */ "default", {
+    enumerable: true,
+    get: function() {
+        return resolveESM;
+    }
+});
+var _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+var _module = /*#__PURE__*/ _interop_require_default(require("module"));
+var _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var _resolveExports = null;
+function getResolveExports() {
+    if (_resolveExports === null) {
+        try {
+            var _require = typeof require === 'undefined' ? _module.default.createRequire(require("url").pathToFileURL(__filename).toString()) : require;
+            _resolveExports = _require('resolve.exports');
+        } catch (_) {
+            _resolveExports = null;
+        }
+    }
+    return _resolveExports;
+}
+/**
+ * Parse a specifier into package name and subpath
+ * "lodash" → { pkgName: "lodash", subpath: "." }
+ * "lodash/get" → { pkgName: "lodash", subpath: "./get" }
+ * "@scope/pkg" → { pkgName: "@scope/pkg", subpath: "." }
+ * "@scope/pkg/foo" → { pkgName: "@scope/pkg", subpath: "./foo" }
+ */ function parseSpecifier(specifier) {
+    var parts = specifier.split('/');
+    var pkgName = specifier[0] === '@' ? parts.slice(0, 2).join('/') : parts[0];
+    var remainder = specifier.slice(pkgName.length);
+    var subpath = remainder ? ".".concat(remainder) : '.';
+    return {
+        pkgName: pkgName,
+        subpath: subpath
+    };
+}
+/**
+ * Find package.json in node_modules for external packages
+ */ function findPackageInNodeModules(pkgName, basedir) {
+    var dir = basedir;
+    var root = _path.default.parse(dir).root;
+    while(dir !== root){
+        var pkgDir = _path.default.join(dir, 'node_modules', pkgName);
+        var pkgJsonPath = _path.default.join(pkgDir, 'package.json');
+        try {
+            if (_fs.default.existsSync(pkgJsonPath)) {
+                var content = _fs.default.readFileSync(pkgJsonPath, 'utf8');
+                return {
+                    dir: pkgDir,
+                    json: JSON.parse(content)
+                };
+            }
+        } catch (_) {
+        // Ignore filesystem errors
+        }
+        var parent = _path.default.dirname(dir);
+        if (parent === dir) break;
+        dir = parent;
+    }
+    return null;
+}
+/**
+ * Find the containing package.json by walking up from a file path
+ * Used for # subpath imports which are scoped to the containing package
+ */ function findContainingPackage(filePath) {
+    var dir = _path.default.dirname(filePath);
+    var root = _path.default.parse(dir).root;
+    while(dir !== root){
+        var pkgJsonPath = _path.default.join(dir, 'package.json');
+        try {
+            if (_fs.default.existsSync(pkgJsonPath)) {
+                var content = _fs.default.readFileSync(pkgJsonPath, 'utf8');
+                return {
+                    dir: dir,
+                    json: JSON.parse(content)
+                };
+            }
+        } catch (_) {
+        // Ignore filesystem errors
+        }
+        var parent = _path.default.dirname(dir);
+        if (parent === dir) break;
+        dir = parent;
+    }
+    return null;
+}
+function resolveESM(specifier, parentPath) {
+    var conditions = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : [
+        'node',
+        'import'
+    ];
+    var resolveExportsMod = getResolveExports();
+    if (!resolveExportsMod) {
+        return null;
+    }
+    var resolveFn = resolveExportsMod.resolve, legacy = resolveExportsMod.legacy;
+    // Determine how to find the package.json based on specifier type
+    var pkg;
+    var subpath;
+    if (specifier.startsWith('#')) {
+        // Subpath import - find containing package
+        pkg = findContainingPackage(parentPath);
+        subpath = specifier; // resolve.exports expects the full #specifier
+    } else {
+        // External package - find in node_modules
+        var _parseSpecifier = parseSpecifier(specifier), pkgName = _parseSpecifier.pkgName, parsedSubpath = _parseSpecifier.subpath;
+        pkg = findPackageInNodeModules(pkgName, parentPath);
+        subpath = parsedSubpath;
+    }
+    if (!pkg) {
+        return null;
+    }
+    // Use resolve.exports.resolve() which handles both exports and imports
+    try {
+        var resolved = resolveFn(pkg.json, subpath, {
+            conditions: conditions
+        });
+        if (resolved === null || resolved === void 0 ? void 0 : resolved[0]) {
+            return _path.default.join(pkg.dir, resolved[0]);
+        }
+    } catch (_) {
+    // Resolution failed, try legacy
+    }
+    // Try legacy main/module fields for non-# imports
+    if (!specifier.startsWith('#')) {
+        try {
+            var legacyMain = legacy(pkg.json);
+            if (legacyMain) {
+                var mainPath;
+                if (typeof legacyMain === 'string') {
+                    mainPath = legacyMain;
+                } else if (Array.isArray(legacyMain)) {
+                    mainPath = legacyMain[0];
+                }
+                if (mainPath) {
+                    return _path.default.join(pkg.dir, mainPath);
+                }
+            }
+        } catch (_) {
+        // Legacy parsing failed
+        }
+        // Last resort: try index.js
+        var indexPath = _path.default.join(pkg.dir, 'index.js');
+        try {
+            if (_fs.default.existsSync(indexPath)) {
+                return indexPath;
+            }
+        } catch (_) {
+        // Ignore
+        }
+    }
+    return null;
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/lib/resolveESM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/typescript/ts-swc-transform/src/lib/resolveESM.ts"],"sourcesContent":["/**\n * Unified ESM resolver\n *\n * Handles both:\n * - Package exports: import x from 'lodash' → uses exports field\n * - Subpath imports: import x from '#internal' → uses imports field\n *\n * Uses resolve.exports.resolve() which automatically detects the specifier type.\n * Only loaded on Node >= 12.2 where module.createRequire exists.\n */\n\nimport fs from 'fs';\nimport Module from 'module';\nimport path from 'path';\n\n// Lazy-load resolve.exports\ntype ResolveExportsModule = typeof import('resolve.exports');\nlet _resolveExports: ResolveExportsModule | null = null;\n\nfunction getResolveExports(): ResolveExportsModule | null {\n  if (_resolveExports === null) {\n    try {\n      const _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;\n      _resolveExports = _require('resolve.exports') as ResolveExportsModule;\n    } catch (_) {\n      _resolveExports = null;\n    }\n  }\n  return _resolveExports;\n}\n\n/**\n * Parse a specifier into package name and subpath\n * \"lodash\" → { pkgName: \"lodash\", subpath: \".\" }\n * \"lodash/get\" → { pkgName: \"lodash\", subpath: \"./get\" }\n * \"@scope/pkg\" → { pkgName: \"@scope/pkg\", subpath: \".\" }\n * \"@scope/pkg/foo\" → { pkgName: \"@scope/pkg\", subpath: \"./foo\" }\n */\nfunction parseSpecifier(specifier: string): { pkgName: string; subpath: string } {\n  const parts = specifier.split('/');\n  const pkgName = specifier[0] === '@' ? parts.slice(0, 2).join('/') : parts[0];\n  const remainder = specifier.slice(pkgName.length);\n  const subpath = remainder ? `.${remainder}` : '.';\n  return { pkgName, subpath };\n}\n\n/**\n * Find package.json in node_modules for external packages\n */\nfunction findPackageInNodeModules(pkgName: string, basedir: string): { dir: string; json: Record<string, unknown> } | null {\n  let dir = basedir;\n  const root = path.parse(dir).root;\n\n  while (dir !== root) {\n    const pkgDir = path.join(dir, 'node_modules', pkgName);\n    const pkgJsonPath = path.join(pkgDir, 'package.json');\n    try {\n      if (fs.existsSync(pkgJsonPath)) {\n        const content = fs.readFileSync(pkgJsonPath, 'utf8');\n        return { dir: pkgDir, json: JSON.parse(content) };\n      }\n    } catch (_) {\n      // Ignore filesystem errors\n    }\n    const parent = path.dirname(dir);\n    if (parent === dir) break;\n    dir = parent;\n  }\n\n  return null;\n}\n\n/**\n * Find the containing package.json by walking up from a file path\n * Used for # subpath imports which are scoped to the containing package\n */\nfunction findContainingPackage(filePath: string): { dir: string; json: Record<string, unknown> } | null {\n  let dir = path.dirname(filePath);\n  const root = path.parse(dir).root;\n\n  while (dir !== root) {\n    const pkgJsonPath = path.join(dir, 'package.json');\n    try {\n      if (fs.existsSync(pkgJsonPath)) {\n        const content = fs.readFileSync(pkgJsonPath, 'utf8');\n        return { dir, json: JSON.parse(content) };\n      }\n    } catch (_) {\n      // Ignore filesystem errors\n    }\n    const parent = path.dirname(dir);\n    if (parent === dir) break;\n    dir = parent;\n  }\n\n  return null;\n}\n\n/**\n * Resolve an ESM specifier to an absolute file path\n *\n * @param specifier - The import specifier (e.g., 'lodash', 'lodash/get', '#internal')\n * @param parentPath - The file path of the importing module\n * @param conditions - Export conditions (defaults to ['node', 'import'])\n * @returns The resolved absolute file path, or null if not resolvable\n */\nexport default function resolveESM(specifier: string, parentPath: string, conditions: string[] = ['node', 'import']): string | null {\n  const resolveExportsMod = getResolveExports();\n  if (!resolveExportsMod) {\n    return null;\n  }\n\n  const { resolve: resolveFn, legacy } = resolveExportsMod;\n\n  // Determine how to find the package.json based on specifier type\n  let pkg: { dir: string; json: Record<string, unknown> } | null;\n  let subpath: string;\n\n  if (specifier.startsWith('#')) {\n    // Subpath import - find containing package\n    pkg = findContainingPackage(parentPath);\n    subpath = specifier; // resolve.exports expects the full #specifier\n  } else {\n    // External package - find in node_modules\n    const { pkgName, subpath: parsedSubpath } = parseSpecifier(specifier);\n    pkg = findPackageInNodeModules(pkgName, parentPath);\n    subpath = parsedSubpath;\n  }\n\n  if (!pkg) {\n    return null;\n  }\n\n  // Use resolve.exports.resolve() which handles both exports and imports\n  try {\n    const resolved = resolveFn(pkg.json, subpath, { conditions });\n    if (resolved?.[0]) {\n      return path.join(pkg.dir, resolved[0]);\n    }\n  } catch (_) {\n    // Resolution failed, try legacy\n  }\n\n  // Try legacy main/module fields for non-# imports\n  if (!specifier.startsWith('#')) {\n    try {\n      const legacyMain = legacy(pkg.json);\n      if (legacyMain) {\n        let mainPath: string | undefined;\n        if (typeof legacyMain === 'string') {\n          mainPath = legacyMain;\n        } else if (Array.isArray(legacyMain)) {\n          mainPath = legacyMain[0];\n        }\n        if (mainPath) {\n          return path.join(pkg.dir, mainPath);\n        }\n      }\n    } catch (_) {\n      // Legacy parsing failed\n    }\n\n    // Last resort: try index.js\n    const indexPath = path.join(pkg.dir, 'index.js');\n    try {\n      if (fs.existsSync(indexPath)) {\n        return indexPath;\n      }\n    } catch (_) {\n      // Ignore\n    }\n  }\n\n  return null;\n}\n"],"names":["resolveESM","_resolveExports","getResolveExports","_require","require","Module","createRequire","_","parseSpecifier","specifier","parts","split","pkgName","slice","join","remainder","length","subpath","findPackageInNodeModules","basedir","dir","root","path","parse","pkgDir","pkgJsonPath","fs","existsSync","content","readFileSync","json","JSON","parent","dirname","findContainingPackage","filePath","parentPath","conditions","resolveExportsMod","resolve","resolveFn","legacy","pkg","startsWith","parsedSubpath","resolved","legacyMain","mainPath","Array","isArray","indexPath"],"mappings":"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"}

package/dist/cjs/toPath.js

@@ -11,11 +11,11 @@ Object.defineProperty(exports, "default", {
 var _isabsolute = /*#__PURE__*/ _interop_require_default(require("is-absolute"));
 var _module = /*#__PURE__*/ _interop_require_default(require("module"));
 var _path = /*#__PURE__*/ _interop_require_default(require("path"));
-var _resolve = /*#__PURE__*/ _interop_require_wildcard(require("resolve"));
 var _url = /*#__PURE__*/ _interop_require_default(require("url"));
 var _compatts = require("./compat.js");
 var _constantsts = require("./constants.js");
-var _resolvewithexportsts = /*#__PURE__*/ _interop_require_default(require("./lib/resolve-with-exports.js"));
+var _resolveCJSts = /*#__PURE__*/ _interop_require_default(require("./lib/resolveCJS.js"));
+var _resolveESMts = /*#__PURE__*/ _interop_require_default(require("./lib/resolveESM.js"));
 var _urlFileUrlts = /*#__PURE__*/ _interop_require_wildcard(require("./lib/urlFileUrl.js"));
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
@@ -63,40 +63,45 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-var _resolve_default;
-var resolveSync = ((_resolve_default = _resolve.default) !== null && _resolve_default !== void 0 ? _resolve_default : _resolve).sync;
 var useCJS = !_module.default.createRequire;
 var fileURLToPath = _url.default.fileURLToPath || _urlFileUrlts.fileURLToPath;
 function getParentPath(context) {
     if (context.parentPath) return _path.default.dirname(context.parentPath);
     return context.parentURL ? _path.default.dirname(toPath(context.parentURL)) : process.cwd();
 }
+function getParentFilePath(context) {
+    if (context === null || context === void 0 ? void 0 : context.parentPath) return context.parentPath;
+    if (context === null || context === void 0 ? void 0 : context.parentURL) return fileURLToPath(context.parentURL);
+    return _path.default.join(process.cwd(), 'index.js');
+}
 function toPath(specifier, context) {
+    // Handle file:// URLs
     if ((0, _compatts.stringStartsWith)(specifier, 'file:')) return fileURLToPath(specifier);
+    // Handle absolute paths
     if ((0, _isabsolute.default)(specifier)) return specifier;
+    // Handle relative paths
     if (specifier[0] === '.') {
         var parentPath = context ? getParentPath(context) : process.cwd();
         return _path.default.join(parentPath, specifier);
     }
-    if (_constantsts.moduleRegEx.test(specifier)) {
-        var parentPath1 = context ? getParentPath(context) : process.cwd();
-        if (!useCJS) {
-            try {
-                var entryPath = (0, _resolvewithexportsts.default)(specifier, parentPath1);
-                if (entryPath) return entryPath;
-            } catch (_) {
-            /* it may fail due to commonjs edge cases */ }
+    // Handle module specifiers (bare specifiers and # imports)
+    // moduleRegEx matches: bare specifiers like 'lodash', '@scope/pkg'
+    // specifier[0] === '#' matches: subpath imports like '#internal'
+    if (_constantsts.moduleRegEx.test(specifier) || specifier[0] === '#') {
+        var parentFilePath = getParentFilePath(context);
+        var parentDir = _path.default.dirname(parentFilePath);
+        if (useCJS) {
+            // CJS: use resolve package (does not support # imports)
+            if (specifier[0] === '#') {
+                throw new Error("Cannot find module '".concat(specifier, "' from '").concat(parentDir, "' (subpath imports not supported in CJS mode)"));
+            }
+            return (0, _resolveCJSts.default)(specifier, parentDir);
         }
-        var entryPath1 = resolveSync(specifier, {
-            basedir: parentPath1,
-            extensions: [
-                '.js',
-                '.json',
-                '.node',
-                '.mjs'
-            ]
-        });
-        if (entryPath1) return entryPath1;
+        // ESM: use unified resolver that handles both exports and imports
+        var entryPath = (0, _resolveESMts.default)(specifier, parentFilePath);
+        if (entryPath) return entryPath;
+        // If ESM resolver failed, throw meaningful error
+        throw new Error("Cannot find module '".concat(specifier, "' from '").concat(parentDir, "'"));
     }
     return specifier;
 }

package/dist/cjs/toPath.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/typescript/ts-swc-transform/src/toPath.ts"],"sourcesContent":["import isAbsolute from 'is-absolute';\nimport module from 'module';\nimport path from 'path';\nimport * as resolve from 'resolve';\nimport url from 'url';\n\nimport { stringStartsWith } from './compat.ts';\nimport { moduleRegEx } from './constants.ts';\nimport resolveWithExports from './lib/resolve-with-exports.ts';\nimport * as urlPolyfills from './lib/urlFileUrl.ts';\nimport type { Context } from './types.ts';\n\nconst resolveSync = (resolve.default ?? resolve).sync;\n\nconst useCJS = !module.createRequire;\nconst fileURLToPath = url.fileURLToPath || urlPolyfills.fileURLToPath;\n\nfunction getParentPath(context: Context): string {\n  if (context.parentPath) return path.dirname(context.parentPath);\n  return context.parentURL ? path.dirname(toPath(context.parentURL)) : process.cwd();\n}\n\nexport default function toPath(specifier: string, context?: Context): string {\n  if (stringStartsWith(specifier, 'file:')) return fileURLToPath(specifier);\n  if (isAbsolute(specifier)) return specifier;\n  if (specifier[0] === '.') {\n    const parentPath = context ? getParentPath(context) : process.cwd();\n    return path.join(parentPath, specifier);\n  }\n  if (moduleRegEx.test(specifier)) {\n    const parentPath = context ? getParentPath(context) : process.cwd();\n    if (!useCJS) {\n      try {\n        const entryPath = resolveWithExports(specifier, parentPath);\n        if (entryPath) return entryPath;\n      } catch (_) {\n        /* it may fail due to commonjs edge cases */\n      }\n    }\n    const entryPath = resolveSync(specifier, {\n      basedir: parentPath,\n      extensions: ['.js', '.json', '.node', '.mjs'],\n    });\n    if (entryPath) return entryPath;\n  }\n\n  return specifier;\n}\n"],"names":["toPath","resolve","resolveSync","default","sync","useCJS","module","createRequire","fileURLToPath","url","urlPolyfills","getParentPath","context","parentPath","path","dirname","parentURL","process","cwd","specifier","stringStartsWith","isAbsolute","join","moduleRegEx","test","entryPath","resolveWithExports","_","basedir","extensions"],"mappings":";;;;+BAsBA;;;eAAwBA;;;iEAtBD;6DACJ;2DACF;+DACQ;0DACT;wBAEiB;2BACL;2EACG;oEACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGTC;AAArB,IAAMC,cAAc,EAACD,mBAAAA,SAAQE,OAAO,cAAfF,8BAAAA,mBAAmBA,UAASG,IAAI;AAErD,IAAMC,SAAS,CAACC,eAAM,CAACC,aAAa;AACpC,IAAMC,gBAAgBC,YAAG,CAACD,aAAa,IAAIE,cAAaF,aAAa;AAErE,SAASG,cAAcC,OAAgB;IACrC,IAAIA,QAAQC,UAAU,EAAE,OAAOC,aAAI,CAACC,OAAO,CAACH,QAAQC,UAAU;IAC9D,OAAOD,QAAQI,SAAS,GAAGF,aAAI,CAACC,OAAO,CAACf,OAAOY,QAAQI,SAAS,KAAKC,QAAQC,GAAG;AAClF;AAEe,SAASlB,OAAOmB,SAAiB,EAAEP,OAAiB;IACjE,IAAIQ,IAAAA,0BAAgB,EAACD,WAAW,UAAU,OAAOX,cAAcW;IAC/D,IAAIE,IAAAA,mBAAU,EAACF,YAAY,OAAOA;IAClC,IAAIA,SAAS,CAAC,EAAE,KAAK,KAAK;QACxB,IAAMN,aAAaD,UAAUD,cAAcC,WAAWK,QAAQC,GAAG;QACjE,OAAOJ,aAAI,CAACQ,IAAI,CAACT,YAAYM;IAC/B;IACA,IAAII,wBAAW,CAACC,IAAI,CAACL,YAAY;QAC/B,IAAMN,cAAaD,UAAUD,cAAcC,WAAWK,QAAQC,GAAG;QACjE,IAAI,CAACb,QAAQ;YACX,IAAI;gBACF,IAAMoB,YAAYC,IAAAA,6BAAkB,EAACP,WAAWN;gBAChD,IAAIY,WAAW,OAAOA;YACxB,EAAE,OAAOE,GAAG;YACV,0CAA0C,GAC5C;QACF;QACA,IAAMF,aAAYvB,YAAYiB,WAAW;YACvCS,SAASf;YACTgB,YAAY;gBAAC;gBAAO;gBAAS;gBAAS;aAAO;QAC/C;QACA,IAAIJ,YAAW,OAAOA;IACxB;IAEA,OAAON;AACT"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/typescript/ts-swc-transform/src/toPath.ts"],"sourcesContent":["import isAbsolute from 'is-absolute';\nimport module from 'module';\nimport path from 'path';\nimport url from 'url';\n\nimport { stringStartsWith } from './compat.ts';\nimport { moduleRegEx } from './constants.ts';\nimport resolveCJS from './lib/resolveCJS.ts';\nimport resolveESM from './lib/resolveESM.ts';\nimport * as urlPolyfills from './lib/urlFileUrl.ts';\nimport type { Context } from './types.ts';\n\nconst useCJS = !module.createRequire;\nconst fileURLToPath = url.fileURLToPath || urlPolyfills.fileURLToPath;\n\nfunction getParentPath(context: Context): string {\n  if (context.parentPath) return path.dirname(context.parentPath);\n  return context.parentURL ? path.dirname(toPath(context.parentURL)) : process.cwd();\n}\n\nfunction getParentFilePath(context?: Context): string {\n  if (context?.parentPath) return context.parentPath;\n  if (context?.parentURL) return fileURLToPath(context.parentURL);\n  return path.join(process.cwd(), 'index.js');\n}\n\nexport default function toPath(specifier: string, context?: Context): string {\n  // Handle file:// URLs\n  if (stringStartsWith(specifier, 'file:')) return fileURLToPath(specifier);\n\n  // Handle absolute paths\n  if (isAbsolute(specifier)) return specifier;\n\n  // Handle relative paths\n  if (specifier[0] === '.') {\n    const parentPath = context ? getParentPath(context) : process.cwd();\n    return path.join(parentPath, specifier);\n  }\n\n  // Handle module specifiers (bare specifiers and # imports)\n  // moduleRegEx matches: bare specifiers like 'lodash', '@scope/pkg'\n  // specifier[0] === '#' matches: subpath imports like '#internal'\n  if (moduleRegEx.test(specifier) || specifier[0] === '#') {\n    const parentFilePath = getParentFilePath(context);\n    const parentDir = path.dirname(parentFilePath);\n\n    if (useCJS) {\n      // CJS: use resolve package (does not support # imports)\n      if (specifier[0] === '#') {\n        throw new Error(`Cannot find module '${specifier}' from '${parentDir}' (subpath imports not supported in CJS mode)`);\n      }\n      return resolveCJS(specifier, parentDir);\n    }\n    // ESM: use unified resolver that handles both exports and imports\n    const entryPath = resolveESM(specifier, parentFilePath);\n    if (entryPath) return entryPath;\n\n    // If ESM resolver failed, throw meaningful error\n    throw new Error(`Cannot find module '${specifier}' from '${parentDir}'`);\n  }\n\n  return specifier;\n}\n"],"names":["toPath","useCJS","module","createRequire","fileURLToPath","url","urlPolyfills","getParentPath","context","parentPath","path","dirname","parentURL","process","cwd","getParentFilePath","join","specifier","stringStartsWith","isAbsolute","moduleRegEx","test","parentFilePath","parentDir","Error","resolveCJS","entryPath","resolveESM"],"mappings":";;;;+BA0BA;;;eAAwBA;;;iEA1BD;6DACJ;2DACF;0DACD;wBAEiB;2BACL;mEACL;mEACA;oEACO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG9B,IAAMC,SAAS,CAACC,eAAM,CAACC,aAAa;AACpC,IAAMC,gBAAgBC,YAAG,CAACD,aAAa,IAAIE,cAAaF,aAAa;AAErE,SAASG,cAAcC,OAAgB;IACrC,IAAIA,QAAQC,UAAU,EAAE,OAAOC,aAAI,CAACC,OAAO,CAACH,QAAQC,UAAU;IAC9D,OAAOD,QAAQI,SAAS,GAAGF,aAAI,CAACC,OAAO,CAACX,OAAOQ,QAAQI,SAAS,KAAKC,QAAQC,GAAG;AAClF;AAEA,SAASC,kBAAkBP,OAAiB;IAC1C,IAAIA,oBAAAA,8BAAAA,QAASC,UAAU,EAAE,OAAOD,QAAQC,UAAU;IAClD,IAAID,oBAAAA,8BAAAA,QAASI,SAAS,EAAE,OAAOR,cAAcI,QAAQI,SAAS;IAC9D,OAAOF,aAAI,CAACM,IAAI,CAACH,QAAQC,GAAG,IAAI;AAClC;AAEe,SAASd,OAAOiB,SAAiB,EAAET,OAAiB;IACjE,sBAAsB;IACtB,IAAIU,IAAAA,0BAAgB,EAACD,WAAW,UAAU,OAAOb,cAAca;IAE/D,wBAAwB;IACxB,IAAIE,IAAAA,mBAAU,EAACF,YAAY,OAAOA;IAElC,wBAAwB;IACxB,IAAIA,SAAS,CAAC,EAAE,KAAK,KAAK;QACxB,IAAMR,aAAaD,UAAUD,cAAcC,WAAWK,QAAQC,GAAG;QACjE,OAAOJ,aAAI,CAACM,IAAI,CAACP,YAAYQ;IAC/B;IAEA,2DAA2D;IAC3D,mEAAmE;IACnE,iEAAiE;IACjE,IAAIG,wBAAW,CAACC,IAAI,CAACJ,cAAcA,SAAS,CAAC,EAAE,KAAK,KAAK;QACvD,IAAMK,iBAAiBP,kBAAkBP;QACzC,IAAMe,YAAYb,aAAI,CAACC,OAAO,CAACW;QAE/B,IAAIrB,QAAQ;YACV,wDAAwD;YACxD,IAAIgB,SAAS,CAAC,EAAE,KAAK,KAAK;gBACxB,MAAM,IAAIO,MAAM,AAAC,uBAA0CD,OAApBN,WAAU,YAAoB,OAAVM,WAAU;YACvE;YACA,OAAOE,IAAAA,qBAAU,EAACR,WAAWM;QAC/B;QACA,kEAAkE;QAClE,IAAMG,YAAYC,IAAAA,qBAAU,EAACV,WAAWK;QACxC,IAAII,WAAW,OAAOA;QAEtB,iDAAiD;QACjD,MAAM,IAAIF,MAAM,AAAC,uBAA0CD,OAApBN,WAAU,YAAoB,OAAVM,WAAU;IACvE;IAEA,OAAON;AACT"}

package/dist/esm/lib/resolveCJS.d.ts

@@ -0,0 +1,17 @@
+/**
+ * CJS resolver
+ *
+ * Uses the `resolve` npm package for CommonJS-style module resolution.
+ * Handles main field, index.js, etc.
+ *
+ * Note: CJS does not support subpath imports (#prefix) - those are ESM-only.
+ */
+/**
+ * Resolve a CJS specifier to an absolute file path
+ *
+ * @param specifier - The require specifier (e.g., 'lodash', 'lodash/get')
+ * @param basedir - The directory to resolve from
+ * @returns The resolved absolute file path
+ * @throws Error if module cannot be found
+ */
+export default function resolveCJS(specifier: string, basedir: string): string;

package/dist/esm/lib/resolveCJS.js

@@ -0,0 +1,28 @@
+/**
+ * CJS resolver
+ *
+ * Uses the `resolve` npm package for CommonJS-style module resolution.
+ * Handles main field, index.js, etc.
+ *
+ * Note: CJS does not support subpath imports (#prefix) - those are ESM-only.
+ */ import * as resolve from 'resolve';
+var _resolve_default;
+const resolveSync = ((_resolve_default = resolve.default) !== null && _resolve_default !== void 0 ? _resolve_default : resolve).sync;
+/**
+ * Resolve a CJS specifier to an absolute file path
+ *
+ * @param specifier - The require specifier (e.g., 'lodash', 'lodash/get')
+ * @param basedir - The directory to resolve from
+ * @returns The resolved absolute file path
+ * @throws Error if module cannot be found
+ */ export default function resolveCJS(specifier, basedir) {
+    return resolveSync(specifier, {
+        basedir,
+        extensions: [
+            '.js',
+            '.json',
+            '.node',
+            '.mjs'
+        ]
+    });
+}

package/dist/esm/lib/resolveCJS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/typescript/ts-swc-transform/src/lib/resolveCJS.ts"],"sourcesContent":["/**\n * CJS resolver\n *\n * Uses the `resolve` npm package for CommonJS-style module resolution.\n * Handles main field, index.js, etc.\n *\n * Note: CJS does not support subpath imports (#prefix) - those are ESM-only.\n */\n\nimport * as resolve from 'resolve';\n\nconst resolveSync = (resolve.default ?? resolve).sync;\n\n/**\n * Resolve a CJS specifier to an absolute file path\n *\n * @param specifier - The require specifier (e.g., 'lodash', 'lodash/get')\n * @param basedir - The directory to resolve from\n * @returns The resolved absolute file path\n * @throws Error if module cannot be found\n */\nexport default function resolveCJS(specifier: string, basedir: string): string {\n  return resolveSync(specifier, {\n    basedir,\n    extensions: ['.js', '.json', '.node', '.mjs'],\n  });\n}\n"],"names":["resolve","resolveSync","default","sync","resolveCJS","specifier","basedir","extensions"],"mappings":"AAAA;;;;;;;CAOC,GAED,YAAYA,aAAa,UAAU;IAEdA;AAArB,MAAMC,cAAc,EAACD,mBAAAA,QAAQE,OAAO,cAAfF,8BAAAA,mBAAmBA,SAASG,IAAI;AAErD;;;;;;;CAOC,GACD,eAAe,SAASC,WAAWC,SAAiB,EAAEC,OAAe;IACnE,OAAOL,YAAYI,WAAW;QAC5BC;QACAC,YAAY;YAAC;YAAO;YAAS;YAAS;SAAO;IAC/C;AACF"}

package/dist/esm/lib/resolveESM.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Unified ESM resolver
+ *
+ * Handles both:
+ * - Package exports: import x from 'lodash' → uses exports field
+ * - Subpath imports: import x from '#internal' → uses imports field
+ *
+ * Uses resolve.exports.resolve() which automatically detects the specifier type.
+ * Only loaded on Node >= 12.2 where module.createRequire exists.
+ */
+/**
+ * Resolve an ESM specifier to an absolute file path
+ *
+ * @param specifier - The import specifier (e.g., 'lodash', 'lodash/get', '#internal')
+ * @param parentPath - The file path of the importing module
+ * @param conditions - Export conditions (defaults to ['node', 'import'])
+ * @returns The resolved absolute file path, or null if not resolvable
+ */
+export default function resolveESM(specifier: string, parentPath: string, conditions?: string[]): string | null;

package/dist/esm/lib/resolveESM.js

@@ -0,0 +1,163 @@
+/**
+ * Unified ESM resolver
+ *
+ * Handles both:
+ * - Package exports: import x from 'lodash' → uses exports field
+ * - Subpath imports: import x from '#internal' → uses imports field
+ *
+ * Uses resolve.exports.resolve() which automatically detects the specifier type.
+ * Only loaded on Node >= 12.2 where module.createRequire exists.
+ */ import fs from 'fs';
+import Module from 'module';
+import path from 'path';
+let _resolveExports = null;
+function getResolveExports() {
+    if (_resolveExports === null) {
+        try {
+            const _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;
+            _resolveExports = _require('resolve.exports');
+        } catch (_) {
+            _resolveExports = null;
+        }
+    }
+    return _resolveExports;
+}
+/**
+ * Parse a specifier into package name and subpath
+ * "lodash" → { pkgName: "lodash", subpath: "." }
+ * "lodash/get" → { pkgName: "lodash", subpath: "./get" }
+ * "@scope/pkg" → { pkgName: "@scope/pkg", subpath: "." }
+ * "@scope/pkg/foo" → { pkgName: "@scope/pkg", subpath: "./foo" }
+ */ function parseSpecifier(specifier) {
+    const parts = specifier.split('/');
+    const pkgName = specifier[0] === '@' ? parts.slice(0, 2).join('/') : parts[0];
+    const remainder = specifier.slice(pkgName.length);
+    const subpath = remainder ? `.${remainder}` : '.';
+    return {
+        pkgName,
+        subpath
+    };
+}
+/**
+ * Find package.json in node_modules for external packages
+ */ function findPackageInNodeModules(pkgName, basedir) {
+    let dir = basedir;
+    const root = path.parse(dir).root;
+    while(dir !== root){
+        const pkgDir = path.join(dir, 'node_modules', pkgName);
+        const pkgJsonPath = path.join(pkgDir, 'package.json');
+        try {
+            if (fs.existsSync(pkgJsonPath)) {
+                const content = fs.readFileSync(pkgJsonPath, 'utf8');
+                return {
+                    dir: pkgDir,
+                    json: JSON.parse(content)
+                };
+            }
+        } catch (_) {
+        // Ignore filesystem errors
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir) break;
+        dir = parent;
+    }
+    return null;
+}
+/**
+ * Find the containing package.json by walking up from a file path
+ * Used for # subpath imports which are scoped to the containing package
+ */ function findContainingPackage(filePath) {
+    let dir = path.dirname(filePath);
+    const root = path.parse(dir).root;
+    while(dir !== root){
+        const pkgJsonPath = path.join(dir, 'package.json');
+        try {
+            if (fs.existsSync(pkgJsonPath)) {
+                const content = fs.readFileSync(pkgJsonPath, 'utf8');
+                return {
+                    dir,
+                    json: JSON.parse(content)
+                };
+            }
+        } catch (_) {
+        // Ignore filesystem errors
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir) break;
+        dir = parent;
+    }
+    return null;
+}
+/**
+ * Resolve an ESM specifier to an absolute file path
+ *
+ * @param specifier - The import specifier (e.g., 'lodash', 'lodash/get', '#internal')
+ * @param parentPath - The file path of the importing module
+ * @param conditions - Export conditions (defaults to ['node', 'import'])
+ * @returns The resolved absolute file path, or null if not resolvable
+ */ export default function resolveESM(specifier, parentPath, conditions = [
+    'node',
+    'import'
+]) {
+    const resolveExportsMod = getResolveExports();
+    if (!resolveExportsMod) {
+        return null;
+    }
+    const { resolve: resolveFn, legacy } = resolveExportsMod;
+    // Determine how to find the package.json based on specifier type
+    let pkg;
+    let subpath;
+    if (specifier.startsWith('#')) {
+        // Subpath import - find containing package
+        pkg = findContainingPackage(parentPath);
+        subpath = specifier; // resolve.exports expects the full #specifier
+    } else {
+        // External package - find in node_modules
+        const { pkgName, subpath: parsedSubpath } = parseSpecifier(specifier);
+        pkg = findPackageInNodeModules(pkgName, parentPath);
+        subpath = parsedSubpath;
+    }
+    if (!pkg) {
+        return null;
+    }
+    // Use resolve.exports.resolve() which handles both exports and imports
+    try {
+        const resolved = resolveFn(pkg.json, subpath, {
+            conditions
+        });
+        if (resolved === null || resolved === void 0 ? void 0 : resolved[0]) {
+            return path.join(pkg.dir, resolved[0]);
+        }
+    } catch (_) {
+    // Resolution failed, try legacy
+    }
+    // Try legacy main/module fields for non-# imports
+    if (!specifier.startsWith('#')) {
+        try {
+            const legacyMain = legacy(pkg.json);
+            if (legacyMain) {
+                let mainPath;
+                if (typeof legacyMain === 'string') {
+                    mainPath = legacyMain;
+                } else if (Array.isArray(legacyMain)) {
+                    mainPath = legacyMain[0];
+                }
+                if (mainPath) {
+                    return path.join(pkg.dir, mainPath);
+                }
+            }
+        } catch (_) {
+        // Legacy parsing failed
+        }
+        // Last resort: try index.js
+        const indexPath = path.join(pkg.dir, 'index.js');
+        try {
+            if (fs.existsSync(indexPath)) {
+                return indexPath;
+            }
+        } catch (_) {
+        // Ignore
+        }
+    }
+    return null;
+}

package/dist/esm/lib/resolveESM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/typescript/ts-swc-transform/src/lib/resolveESM.ts"],"sourcesContent":["/**\n * Unified ESM resolver\n *\n * Handles both:\n * - Package exports: import x from 'lodash' → uses exports field\n * - Subpath imports: import x from '#internal' → uses imports field\n *\n * Uses resolve.exports.resolve() which automatically detects the specifier type.\n * Only loaded on Node >= 12.2 where module.createRequire exists.\n */\n\nimport fs from 'fs';\nimport Module from 'module';\nimport path from 'path';\n\n// Lazy-load resolve.exports\ntype ResolveExportsModule = typeof import('resolve.exports');\nlet _resolveExports: ResolveExportsModule | null = null;\n\nfunction getResolveExports(): ResolveExportsModule | null {\n  if (_resolveExports === null) {\n    try {\n      const _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;\n      _resolveExports = _require('resolve.exports') as ResolveExportsModule;\n    } catch (_) {\n      _resolveExports = null;\n    }\n  }\n  return _resolveExports;\n}\n\n/**\n * Parse a specifier into package name and subpath\n * \"lodash\" → { pkgName: \"lodash\", subpath: \".\" }\n * \"lodash/get\" → { pkgName: \"lodash\", subpath: \"./get\" }\n * \"@scope/pkg\" → { pkgName: \"@scope/pkg\", subpath: \".\" }\n * \"@scope/pkg/foo\" → { pkgName: \"@scope/pkg\", subpath: \"./foo\" }\n */\nfunction parseSpecifier(specifier: string): { pkgName: string; subpath: string } {\n  const parts = specifier.split('/');\n  const pkgName = specifier[0] === '@' ? parts.slice(0, 2).join('/') : parts[0];\n  const remainder = specifier.slice(pkgName.length);\n  const subpath = remainder ? `.${remainder}` : '.';\n  return { pkgName, subpath };\n}\n\n/**\n * Find package.json in node_modules for external packages\n */\nfunction findPackageInNodeModules(pkgName: string, basedir: string): { dir: string; json: Record<string, unknown> } | null {\n  let dir = basedir;\n  const root = path.parse(dir).root;\n\n  while (dir !== root) {\n    const pkgDir = path.join(dir, 'node_modules', pkgName);\n    const pkgJsonPath = path.join(pkgDir, 'package.json');\n    try {\n      if (fs.existsSync(pkgJsonPath)) {\n        const content = fs.readFileSync(pkgJsonPath, 'utf8');\n        return { dir: pkgDir, json: JSON.parse(content) };\n      }\n    } catch (_) {\n      // Ignore filesystem errors\n    }\n    const parent = path.dirname(dir);\n    if (parent === dir) break;\n    dir = parent;\n  }\n\n  return null;\n}\n\n/**\n * Find the containing package.json by walking up from a file path\n * Used for # subpath imports which are scoped to the containing package\n */\nfunction findContainingPackage(filePath: string): { dir: string; json: Record<string, unknown> } | null {\n  let dir = path.dirname(filePath);\n  const root = path.parse(dir).root;\n\n  while (dir !== root) {\n    const pkgJsonPath = path.join(dir, 'package.json');\n    try {\n      if (fs.existsSync(pkgJsonPath)) {\n        const content = fs.readFileSync(pkgJsonPath, 'utf8');\n        return { dir, json: JSON.parse(content) };\n      }\n    } catch (_) {\n      // Ignore filesystem errors\n    }\n    const parent = path.dirname(dir);\n    if (parent === dir) break;\n    dir = parent;\n  }\n\n  return null;\n}\n\n/**\n * Resolve an ESM specifier to an absolute file path\n *\n * @param specifier - The import specifier (e.g., 'lodash', 'lodash/get', '#internal')\n * @param parentPath - The file path of the importing module\n * @param conditions - Export conditions (defaults to ['node', 'import'])\n * @returns The resolved absolute file path, or null if not resolvable\n */\nexport default function resolveESM(specifier: string, parentPath: string, conditions: string[] = ['node', 'import']): string | null {\n  const resolveExportsMod = getResolveExports();\n  if (!resolveExportsMod) {\n    return null;\n  }\n\n  const { resolve: resolveFn, legacy } = resolveExportsMod;\n\n  // Determine how to find the package.json based on specifier type\n  let pkg: { dir: string; json: Record<string, unknown> } | null;\n  let subpath: string;\n\n  if (specifier.startsWith('#')) {\n    // Subpath import - find containing package\n    pkg = findContainingPackage(parentPath);\n    subpath = specifier; // resolve.exports expects the full #specifier\n  } else {\n    // External package - find in node_modules\n    const { pkgName, subpath: parsedSubpath } = parseSpecifier(specifier);\n    pkg = findPackageInNodeModules(pkgName, parentPath);\n    subpath = parsedSubpath;\n  }\n\n  if (!pkg) {\n    return null;\n  }\n\n  // Use resolve.exports.resolve() which handles both exports and imports\n  try {\n    const resolved = resolveFn(pkg.json, subpath, { conditions });\n    if (resolved?.[0]) {\n      return path.join(pkg.dir, resolved[0]);\n    }\n  } catch (_) {\n    // Resolution failed, try legacy\n  }\n\n  // Try legacy main/module fields for non-# imports\n  if (!specifier.startsWith('#')) {\n    try {\n      const legacyMain = legacy(pkg.json);\n      if (legacyMain) {\n        let mainPath: string | undefined;\n        if (typeof legacyMain === 'string') {\n          mainPath = legacyMain;\n        } else if (Array.isArray(legacyMain)) {\n          mainPath = legacyMain[0];\n        }\n        if (mainPath) {\n          return path.join(pkg.dir, mainPath);\n        }\n      }\n    } catch (_) {\n      // Legacy parsing failed\n    }\n\n    // Last resort: try index.js\n    const indexPath = path.join(pkg.dir, 'index.js');\n    try {\n      if (fs.existsSync(indexPath)) {\n        return indexPath;\n      }\n    } catch (_) {\n      // Ignore\n    }\n  }\n\n  return null;\n}\n"],"names":["fs","Module","path","_resolveExports","getResolveExports","_require","require","createRequire","url","_","parseSpecifier","specifier","parts","split","pkgName","slice","join","remainder","length","subpath","findPackageInNodeModules","basedir","dir","root","parse","pkgDir","pkgJsonPath","existsSync","content","readFileSync","json","JSON","parent","dirname","findContainingPackage","filePath","resolveESM","parentPath","conditions","resolveExportsMod","resolve","resolveFn","legacy","pkg","startsWith","parsedSubpath","resolved","legacyMain","mainPath","Array","isArray","indexPath"],"mappings":"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"}

package/dist/esm/toPath.js

@@ -1,46 +1,51 @@
 import isAbsolute from 'is-absolute';
 import module from 'module';
 import path from 'path';
-import * as resolve from 'resolve';
 import url from 'url';
 import { stringStartsWith } from './compat.js';
 import { moduleRegEx } from './constants.js';
-import resolveWithExports from './lib/resolve-with-exports.js';
+import resolveCJS from './lib/resolveCJS.js';
+import resolveESM from './lib/resolveESM.js';
 import * as urlPolyfills from './lib/urlFileUrl.js';
-var _resolve_default;
-const resolveSync = ((_resolve_default = resolve.default) !== null && _resolve_default !== void 0 ? _resolve_default : resolve).sync;
 const useCJS = !module.createRequire;
 const fileURLToPath = url.fileURLToPath || urlPolyfills.fileURLToPath;
 function getParentPath(context) {
     if (context.parentPath) return path.dirname(context.parentPath);
     return context.parentURL ? path.dirname(toPath(context.parentURL)) : process.cwd();
 }
+function getParentFilePath(context) {
+    if (context === null || context === void 0 ? void 0 : context.parentPath) return context.parentPath;
+    if (context === null || context === void 0 ? void 0 : context.parentURL) return fileURLToPath(context.parentURL);
+    return path.join(process.cwd(), 'index.js');
+}
 export default function toPath(specifier, context) {
+    // Handle file:// URLs
     if (stringStartsWith(specifier, 'file:')) return fileURLToPath(specifier);
+    // Handle absolute paths
     if (isAbsolute(specifier)) return specifier;
+    // Handle relative paths
     if (specifier[0] === '.') {
         const parentPath = context ? getParentPath(context) : process.cwd();
         return path.join(parentPath, specifier);
     }
-    if (moduleRegEx.test(specifier)) {
-        const parentPath = context ? getParentPath(context) : process.cwd();
-        if (!useCJS) {
-            try {
-                const entryPath = resolveWithExports(specifier, parentPath);
-                if (entryPath) return entryPath;
-            } catch (_) {
-            /* it may fail due to commonjs edge cases */ }
+    // Handle module specifiers (bare specifiers and # imports)
+    // moduleRegEx matches: bare specifiers like 'lodash', '@scope/pkg'
+    // specifier[0] === '#' matches: subpath imports like '#internal'
+    if (moduleRegEx.test(specifier) || specifier[0] === '#') {
+        const parentFilePath = getParentFilePath(context);
+        const parentDir = path.dirname(parentFilePath);
+        if (useCJS) {
+            // CJS: use resolve package (does not support # imports)
+            if (specifier[0] === '#') {
+                throw new Error(`Cannot find module '${specifier}' from '${parentDir}' (subpath imports not supported in CJS mode)`);
+            }
+            return resolveCJS(specifier, parentDir);
         }
-        const entryPath = resolveSync(specifier, {
-            basedir: parentPath,
-            extensions: [
-                '.js',
-                '.json',
-                '.node',
-                '.mjs'
-            ]
-        });
+        // ESM: use unified resolver that handles both exports and imports
+        const entryPath = resolveESM(specifier, parentFilePath);
         if (entryPath) return entryPath;
+        // If ESM resolver failed, throw meaningful error
+        throw new Error(`Cannot find module '${specifier}' from '${parentDir}'`);
     }
     return specifier;
 }

package/dist/esm/toPath.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/typescript/ts-swc-transform/src/toPath.ts"],"sourcesContent":["import isAbsolute from 'is-absolute';\nimport module from 'module';\nimport path from 'path';\nimport * as resolve from 'resolve';\nimport url from 'url';\n\nimport { stringStartsWith } from './compat.ts';\nimport { moduleRegEx } from './constants.ts';\nimport resolveWithExports from './lib/resolve-with-exports.ts';\nimport * as urlPolyfills from './lib/urlFileUrl.ts';\nimport type { Context } from './types.ts';\n\nconst resolveSync = (resolve.default ?? resolve).sync;\n\nconst useCJS = !module.createRequire;\nconst fileURLToPath = url.fileURLToPath || urlPolyfills.fileURLToPath;\n\nfunction getParentPath(context: Context): string {\n  if (context.parentPath) return path.dirname(context.parentPath);\n  return context.parentURL ? path.dirname(toPath(context.parentURL)) : process.cwd();\n}\n\nexport default function toPath(specifier: string, context?: Context): string {\n  if (stringStartsWith(specifier, 'file:')) return fileURLToPath(specifier);\n  if (isAbsolute(specifier)) return specifier;\n  if (specifier[0] === '.') {\n    const parentPath = context ? getParentPath(context) : process.cwd();\n    return path.join(parentPath, specifier);\n  }\n  if (moduleRegEx.test(specifier)) {\n    const parentPath = context ? getParentPath(context) : process.cwd();\n    if (!useCJS) {\n      try {\n        const entryPath = resolveWithExports(specifier, parentPath);\n        if (entryPath) return entryPath;\n      } catch (_) {\n        /* it may fail due to commonjs edge cases */\n      }\n    }\n    const entryPath = resolveSync(specifier, {\n      basedir: parentPath,\n      extensions: ['.js', '.json', '.node', '.mjs'],\n    });\n    if (entryPath) return entryPath;\n  }\n\n  return specifier;\n}\n"],"names":["isAbsolute","module","path","resolve","url","stringStartsWith","moduleRegEx","resolveWithExports","urlPolyfills","resolveSync","default","sync","useCJS","createRequire","fileURLToPath","getParentPath","context","parentPath","dirname","parentURL","toPath","process","cwd","specifier","join","test","entryPath","_","basedir","extensions"],"mappings":"AAAA,OAAOA,gBAAgB,cAAc;AACrC,OAAOC,YAAY,SAAS;AAC5B,OAAOC,UAAU,OAAO;AACxB,YAAYC,aAAa,UAAU;AACnC,OAAOC,SAAS,MAAM;AAEtB,SAASC,gBAAgB,QAAQ,cAAc;AAC/C,SAASC,WAAW,QAAQ,iBAAiB;AAC7C,OAAOC,wBAAwB,gCAAgC;AAC/D,YAAYC,kBAAkB,sBAAsB;IAG/BL;AAArB,MAAMM,cAAc,EAACN,mBAAAA,QAAQO,OAAO,cAAfP,8BAAAA,mBAAmBA,SAASQ,IAAI;AAErD,MAAMC,SAAS,CAACX,OAAOY,aAAa;AACpC,MAAMC,gBAAgBV,IAAIU,aAAa,IAAIN,aAAaM,aAAa;AAErE,SAASC,cAAcC,OAAgB;IACrC,IAAIA,QAAQC,UAAU,EAAE,OAAOf,KAAKgB,OAAO,CAACF,QAAQC,UAAU;IAC9D,OAAOD,QAAQG,SAAS,GAAGjB,KAAKgB,OAAO,CAACE,OAAOJ,QAAQG,SAAS,KAAKE,QAAQC,GAAG;AAClF;AAEA,eAAe,SAASF,OAAOG,SAAiB,EAAEP,OAAiB;IACjE,IAAIX,iBAAiBkB,WAAW,UAAU,OAAOT,cAAcS;IAC/D,IAAIvB,WAAWuB,YAAY,OAAOA;IAClC,IAAIA,SAAS,CAAC,EAAE,KAAK,KAAK;QACxB,MAAMN,aAAaD,UAAUD,cAAcC,WAAWK,QAAQC,GAAG;QACjE,OAAOpB,KAAKsB,IAAI,CAACP,YAAYM;IAC/B;IACA,IAAIjB,YAAYmB,IAAI,CAACF,YAAY;QAC/B,MAAMN,aAAaD,UAAUD,cAAcC,WAAWK,QAAQC,GAAG;QACjE,IAAI,CAACV,QAAQ;YACX,IAAI;gBACF,MAAMc,YAAYnB,mBAAmBgB,WAAWN;gBAChD,IAAIS,WAAW,OAAOA;YACxB,EAAE,OAAOC,GAAG;YACV,0CAA0C,GAC5C;QACF;QACA,MAAMD,YAAYjB,YAAYc,WAAW;YACvCK,SAASX;YACTY,YAAY;gBAAC;gBAAO;gBAAS;gBAAS;aAAO;QAC/C;QACA,IAAIH,WAAW,OAAOA;IACxB;IAEA,OAAOH;AACT"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/typescript/ts-swc-transform/src/toPath.ts"],"sourcesContent":["import isAbsolute from 'is-absolute';\nimport module from 'module';\nimport path from 'path';\nimport url from 'url';\n\nimport { stringStartsWith } from './compat.ts';\nimport { moduleRegEx } from './constants.ts';\nimport resolveCJS from './lib/resolveCJS.ts';\nimport resolveESM from './lib/resolveESM.ts';\nimport * as urlPolyfills from './lib/urlFileUrl.ts';\nimport type { Context } from './types.ts';\n\nconst useCJS = !module.createRequire;\nconst fileURLToPath = url.fileURLToPath || urlPolyfills.fileURLToPath;\n\nfunction getParentPath(context: Context): string {\n  if (context.parentPath) return path.dirname(context.parentPath);\n  return context.parentURL ? path.dirname(toPath(context.parentURL)) : process.cwd();\n}\n\nfunction getParentFilePath(context?: Context): string {\n  if (context?.parentPath) return context.parentPath;\n  if (context?.parentURL) return fileURLToPath(context.parentURL);\n  return path.join(process.cwd(), 'index.js');\n}\n\nexport default function toPath(specifier: string, context?: Context): string {\n  // Handle file:// URLs\n  if (stringStartsWith(specifier, 'file:')) return fileURLToPath(specifier);\n\n  // Handle absolute paths\n  if (isAbsolute(specifier)) return specifier;\n\n  // Handle relative paths\n  if (specifier[0] === '.') {\n    const parentPath = context ? getParentPath(context) : process.cwd();\n    return path.join(parentPath, specifier);\n  }\n\n  // Handle module specifiers (bare specifiers and # imports)\n  // moduleRegEx matches: bare specifiers like 'lodash', '@scope/pkg'\n  // specifier[0] === '#' matches: subpath imports like '#internal'\n  if (moduleRegEx.test(specifier) || specifier[0] === '#') {\n    const parentFilePath = getParentFilePath(context);\n    const parentDir = path.dirname(parentFilePath);\n\n    if (useCJS) {\n      // CJS: use resolve package (does not support # imports)\n      if (specifier[0] === '#') {\n        throw new Error(`Cannot find module '${specifier}' from '${parentDir}' (subpath imports not supported in CJS mode)`);\n      }\n      return resolveCJS(specifier, parentDir);\n    }\n    // ESM: use unified resolver that handles both exports and imports\n    const entryPath = resolveESM(specifier, parentFilePath);\n    if (entryPath) return entryPath;\n\n    // If ESM resolver failed, throw meaningful error\n    throw new Error(`Cannot find module '${specifier}' from '${parentDir}'`);\n  }\n\n  return specifier;\n}\n"],"names":["isAbsolute","module","path","url","stringStartsWith","moduleRegEx","resolveCJS","resolveESM","urlPolyfills","useCJS","createRequire","fileURLToPath","getParentPath","context","parentPath","dirname","parentURL","toPath","process","cwd","getParentFilePath","join","specifier","test","parentFilePath","parentDir","Error","entryPath"],"mappings":"AAAA,OAAOA,gBAAgB,cAAc;AACrC,OAAOC,YAAY,SAAS;AAC5B,OAAOC,UAAU,OAAO;AACxB,OAAOC,SAAS,MAAM;AAEtB,SAASC,gBAAgB,QAAQ,cAAc;AAC/C,SAASC,WAAW,QAAQ,iBAAiB;AAC7C,OAAOC,gBAAgB,sBAAsB;AAC7C,OAAOC,gBAAgB,sBAAsB;AAC7C,YAAYC,kBAAkB,sBAAsB;AAGpD,MAAMC,SAAS,CAACR,OAAOS,aAAa;AACpC,MAAMC,gBAAgBR,IAAIQ,aAAa,IAAIH,aAAaG,aAAa;AAErE,SAASC,cAAcC,OAAgB;IACrC,IAAIA,QAAQC,UAAU,EAAE,OAAOZ,KAAKa,OAAO,CAACF,QAAQC,UAAU;IAC9D,OAAOD,QAAQG,SAAS,GAAGd,KAAKa,OAAO,CAACE,OAAOJ,QAAQG,SAAS,KAAKE,QAAQC,GAAG;AAClF;AAEA,SAASC,kBAAkBP,OAAiB;IAC1C,IAAIA,oBAAAA,8BAAAA,QAASC,UAAU,EAAE,OAAOD,QAAQC,UAAU;IAClD,IAAID,oBAAAA,8BAAAA,QAASG,SAAS,EAAE,OAAOL,cAAcE,QAAQG,SAAS;IAC9D,OAAOd,KAAKmB,IAAI,CAACH,QAAQC,GAAG,IAAI;AAClC;AAEA,eAAe,SAASF,OAAOK,SAAiB,EAAET,OAAiB;IACjE,sBAAsB;IACtB,IAAIT,iBAAiBkB,WAAW,UAAU,OAAOX,cAAcW;IAE/D,wBAAwB;IACxB,IAAItB,WAAWsB,YAAY,OAAOA;IAElC,wBAAwB;IACxB,IAAIA,SAAS,CAAC,EAAE,KAAK,KAAK;QACxB,MAAMR,aAAaD,UAAUD,cAAcC,WAAWK,QAAQC,GAAG;QACjE,OAAOjB,KAAKmB,IAAI,CAACP,YAAYQ;IAC/B;IAEA,2DAA2D;IAC3D,mEAAmE;IACnE,iEAAiE;IACjE,IAAIjB,YAAYkB,IAAI,CAACD,cAAcA,SAAS,CAAC,EAAE,KAAK,KAAK;QACvD,MAAME,iBAAiBJ,kBAAkBP;QACzC,MAAMY,YAAYvB,KAAKa,OAAO,CAACS;QAE/B,IAAIf,QAAQ;YACV,wDAAwD;YACxD,IAAIa,SAAS,CAAC,EAAE,KAAK,KAAK;gBACxB,MAAM,IAAII,MAAM,CAAC,oBAAoB,EAAEJ,UAAU,QAAQ,EAAEG,UAAU,6CAA6C,CAAC;YACrH;YACA,OAAOnB,WAAWgB,WAAWG;QAC/B;QACA,kEAAkE;QAClE,MAAME,YAAYpB,WAAWe,WAAWE;QACxC,IAAIG,WAAW,OAAOA;QAEtB,iDAAiD;QACjD,MAAM,IAAID,MAAM,CAAC,oBAAoB,EAAEJ,UAAU,QAAQ,EAAEG,UAAU,CAAC,CAAC;IACzE;IAEA,OAAOH;AACT"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-swc-transform",
-  "version": "2.8.1",
+  "version": "2.8.2",
   "description": "Typescript transformers for swc. Supports Node >= 0.8",
   "keywords": [
     "matcher",
@@ -68,6 +68,7 @@
     "cross-spawn-cb": "^2.0.0",
     "fs-remove-compat": "^1.0.0",
     "mock-exports-only-pkg": "file:test/data/mock-exports-only-pkg",
+    "mock-subpath-imports-pkg": "file:test/data/mock-subpath-imports-pkg",
     "node-version-use": "*",
     "pinkie-promise": "*",
     "react": "^19.2.3",

package/dist/cjs/lib/resolve-with-exports.d.cts

@@ -1,16 +0,0 @@
-/**
- * Lightweight ESM exports field resolver
- * Uses resolve.exports (952 bytes) instead of import-meta-resolve (64KB)
- *
- * Only loaded on Node >= 12.2 where module.createRequire exists.
- * On older Node, toPath.ts skips this and falls back to resolve.sync().
- *
- * This implementation handles packages with ONLY an exports field (no main),
- * which the resolve package cannot handle on its own.
- */
-/**
- * Resolve a module specifier using the exports field in package.json
- * This implementation directly finds the package and reads its exports,
- * bypassing the resolve package which can't handle exports-only packages.
- */
-export default function resolveWithExports(specifier: string, basedir: string, conditions?: string[]): string | null;

package/dist/cjs/lib/resolve-with-exports.d.ts

@@ -1,16 +0,0 @@
-/**
- * Lightweight ESM exports field resolver
- * Uses resolve.exports (952 bytes) instead of import-meta-resolve (64KB)
- *
- * Only loaded on Node >= 12.2 where module.createRequire exists.
- * On older Node, toPath.ts skips this and falls back to resolve.sync().
- *
- * This implementation handles packages with ONLY an exports field (no main),
- * which the resolve package cannot handle on its own.
- */
-/**
- * Resolve a module specifier using the exports field in package.json
- * This implementation directly finds the package and reads its exports,
- * bypassing the resolve package which can't handle exports-only packages.
- */
-export default function resolveWithExports(specifier: string, basedir: string, conditions?: string[]): string | null;

package/dist/cjs/lib/resolve-with-exports.js

@@ -1,157 +0,0 @@
-/**
- * Lightweight ESM exports field resolver
- * Uses resolve.exports (952 bytes) instead of import-meta-resolve (64KB)
- *
- * Only loaded on Node >= 12.2 where module.createRequire exists.
- * On older Node, toPath.ts skips this and falls back to resolve.sync().
- *
- * This implementation handles packages with ONLY an exports field (no main),
- * which the resolve package cannot handle on its own.
- */ "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, /**
- * Resolve a module specifier using the exports field in package.json
- * This implementation directly finds the package and reads its exports,
- * bypassing the resolve package which can't handle exports-only packages.
- */ "default", {
-    enumerable: true,
-    get: function() {
-        return resolveWithExports;
-    }
-});
-var _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
-var _module = /*#__PURE__*/ _interop_require_default(require("module"));
-var _path = /*#__PURE__*/ _interop_require_default(require("path"));
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-var _resolveExports = null;
-function getResolveExports() {
-    if (_resolveExports === null) {
-        try {
-            // Use dynamic require to avoid loading on older Node versions
-            var _require = typeof require === 'undefined' ? _module.default.createRequire(require("url").pathToFileURL(__filename).toString()) : require;
-            _resolveExports = _require('resolve.exports');
-        } catch (_) {
-            // If resolve.exports fails to load, return null
-            // This shouldn't happen on Node >= 12.2, but handle gracefully
-            _resolveExports = null;
-        }
-    }
-    return _resolveExports;
-}
-/**
- * Parse a specifier into package name and subpath
- * "lodash" → { pkgName: "lodash", subpath: "." }
- * "lodash/get" → { pkgName: "lodash", subpath: "./get" }
- * "@scope/pkg" → { pkgName: "@scope/pkg", subpath: "." }
- * "@scope/pkg/foo" → { pkgName: "@scope/pkg", subpath: "./foo" }
- */ function parseSpecifier(specifier) {
-    var parts = specifier.split('/');
-    var pkgName = specifier[0] === '@' ? parts.slice(0, 2).join('/') : parts[0];
-    var remainder = specifier.slice(pkgName.length);
-    var subpath = remainder ? ".".concat(remainder) : '.';
-    return {
-        pkgName: pkgName,
-        subpath: subpath
-    };
-}
-/**
- * Find the package.json for a package by walking up node_modules
- */ function findPackageJson(pkgName, basedir) {
-    var dir = basedir;
-    var root = _path.default.parse(dir).root;
-    while(dir !== root){
-        var candidate = _path.default.join(dir, 'node_modules', pkgName, 'package.json');
-        try {
-            if (_fs.default.existsSync(candidate)) {
-                return candidate;
-            }
-        } catch (_) {
-        // Ignore filesystem errors
-        }
-        var parent = _path.default.dirname(dir);
-        if (parent === dir) break;
-        dir = parent;
-    }
-    return null;
-}
-/**
- * Read and parse a package.json file
- */ function readPackageJson(pkgJsonPath) {
-    try {
-        var content = _fs.default.readFileSync(pkgJsonPath, 'utf8');
-        return JSON.parse(content);
-    } catch (_) {
-        return null;
-    }
-}
-function resolveWithExports(specifier, basedir) {
-    var conditions = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : [
-        'node',
-        'import'
-    ];
-    var resolveExportsMod = getResolveExports();
-    if (!resolveExportsMod) {
-        // resolve.exports not available, return null to trigger fallback
-        return null;
-    }
-    var resolveExportsFn = resolveExportsMod.exports, legacy = resolveExportsMod.legacy;
-    var _parseSpecifier = parseSpecifier(specifier), pkgName = _parseSpecifier.pkgName, subpath = _parseSpecifier.subpath;
-    // Find the package.json
-    var pkgJsonPath = findPackageJson(pkgName, basedir);
-    if (!pkgJsonPath) {
-        return null;
-    }
-    // Read package.json
-    var pkg = readPackageJson(pkgJsonPath);
-    if (!pkg) {
-        return null;
-    }
-    var pkgDir = _path.default.dirname(pkgJsonPath);
-    // Try exports field first
-    try {
-        var resolved = resolveExportsFn(pkg, subpath, {
-            conditions: conditions
-        });
-        if (resolved === null || resolved === void 0 ? void 0 : resolved[0]) {
-            return _path.default.join(pkgDir, resolved[0]);
-        }
-    } catch (_) {
-    // exports field parsing failed, try legacy
-    }
-    // Try legacy main/module fields
-    try {
-        var legacyMain = legacy(pkg);
-        if (legacyMain) {
-            // legacy() can return string, string[], or browser field object
-            var mainPath;
-            if (typeof legacyMain === 'string') {
-                mainPath = legacyMain;
-            } else if (Array.isArray(legacyMain)) {
-                mainPath = legacyMain[0];
-            }
-            // Ignore browser field objects (they map file paths, not entry points)
-            if (mainPath) {
-                return _path.default.join(pkgDir, mainPath);
-            }
-        }
-    } catch (_) {
-    // legacy parsing failed
-    }
-    // Last resort: try index.js
-    var indexPath = _path.default.join(pkgDir, 'index.js');
-    try {
-        if (_fs.default.existsSync(indexPath)) {
-            return indexPath;
-        }
-    } catch (_) {
-    // Ignore
-    }
-    return null;
-}
-/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/lib/resolve-with-exports.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/typescript/ts-swc-transform/src/lib/resolve-with-exports.ts"],"sourcesContent":["/**\n * Lightweight ESM exports field resolver\n * Uses resolve.exports (952 bytes) instead of import-meta-resolve (64KB)\n *\n * Only loaded on Node >= 12.2 where module.createRequire exists.\n * On older Node, toPath.ts skips this and falls back to resolve.sync().\n *\n * This implementation handles packages with ONLY an exports field (no main),\n * which the resolve package cannot handle on its own.\n */\n\nimport fs from 'fs';\nimport Module from 'module';\nimport path from 'path';\n\n// Lazy-load resolve.exports to avoid requiring it on older Node versions\n// resolve.exports requires Node >= 10, but this code only runs on Node >= 12.2\ntype ResolveExportsModule = typeof import('resolve.exports');\nlet _resolveExports: ResolveExportsModule | null = null;\n\nfunction getResolveExports(): ResolveExportsModule | null {\n  if (_resolveExports === null) {\n    try {\n      // Use dynamic require to avoid loading on older Node versions\n      const _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;\n      _resolveExports = _require('resolve.exports') as ResolveExportsModule;\n    } catch (_) {\n      // If resolve.exports fails to load, return null\n      // This shouldn't happen on Node >= 12.2, but handle gracefully\n      _resolveExports = null;\n    }\n  }\n  return _resolveExports;\n}\n\n/**\n * Parse a specifier into package name and subpath\n * \"lodash\" → { pkgName: \"lodash\", subpath: \".\" }\n * \"lodash/get\" → { pkgName: \"lodash\", subpath: \"./get\" }\n * \"@scope/pkg\" → { pkgName: \"@scope/pkg\", subpath: \".\" }\n * \"@scope/pkg/foo\" → { pkgName: \"@scope/pkg\", subpath: \"./foo\" }\n */\nfunction parseSpecifier(specifier: string): { pkgName: string; subpath: string } {\n  const parts = specifier.split('/');\n  const pkgName = specifier[0] === '@' ? parts.slice(0, 2).join('/') : parts[0];\n  const remainder = specifier.slice(pkgName.length);\n  const subpath = remainder ? `.${remainder}` : '.';\n  return { pkgName, subpath };\n}\n\n/**\n * Find the package.json for a package by walking up node_modules\n */\nfunction findPackageJson(pkgName: string, basedir: string): string | null {\n  let dir = basedir;\n  const root = path.parse(dir).root;\n\n  while (dir !== root) {\n    const candidate = path.join(dir, 'node_modules', pkgName, 'package.json');\n    try {\n      if (fs.existsSync(candidate)) {\n        return candidate;\n      }\n    } catch (_) {\n      // Ignore filesystem errors\n    }\n    const parent = path.dirname(dir);\n    if (parent === dir) break;\n    dir = parent;\n  }\n\n  return null;\n}\n\n/**\n * Read and parse a package.json file\n */\nfunction readPackageJson(pkgJsonPath: string): Record<string, unknown> | null {\n  try {\n    const content = fs.readFileSync(pkgJsonPath, 'utf8');\n    return JSON.parse(content);\n  } catch (_) {\n    return null;\n  }\n}\n\n/**\n * Resolve a module specifier using the exports field in package.json\n * This implementation directly finds the package and reads its exports,\n * bypassing the resolve package which can't handle exports-only packages.\n */\nexport default function resolveWithExports(specifier: string, basedir: string, conditions: string[] = ['node', 'import']): string | null {\n  const resolveExportsMod = getResolveExports();\n  if (!resolveExportsMod) {\n    // resolve.exports not available, return null to trigger fallback\n    return null;\n  }\n\n  const { exports: resolveExportsFn, legacy } = resolveExportsMod;\n  const { pkgName, subpath } = parseSpecifier(specifier);\n\n  // Find the package.json\n  const pkgJsonPath = findPackageJson(pkgName, basedir);\n  if (!pkgJsonPath) {\n    return null;\n  }\n\n  // Read package.json\n  const pkg = readPackageJson(pkgJsonPath);\n  if (!pkg) {\n    return null;\n  }\n\n  const pkgDir = path.dirname(pkgJsonPath);\n\n  // Try exports field first\n  try {\n    const resolved = resolveExportsFn(pkg, subpath, { conditions });\n    if (resolved?.[0]) {\n      return path.join(pkgDir, resolved[0]);\n    }\n  } catch (_) {\n    // exports field parsing failed, try legacy\n  }\n\n  // Try legacy main/module fields\n  try {\n    const legacyMain = legacy(pkg);\n    if (legacyMain) {\n      // legacy() can return string, string[], or browser field object\n      let mainPath: string | undefined;\n      if (typeof legacyMain === 'string') {\n        mainPath = legacyMain;\n      } else if (Array.isArray(legacyMain)) {\n        mainPath = legacyMain[0];\n      }\n      // Ignore browser field objects (they map file paths, not entry points)\n      if (mainPath) {\n        return path.join(pkgDir, mainPath);\n      }\n    }\n  } catch (_) {\n    // legacy parsing failed\n  }\n\n  // Last resort: try index.js\n  const indexPath = path.join(pkgDir, 'index.js');\n  try {\n    if (fs.existsSync(indexPath)) {\n      return indexPath;\n    }\n  } catch (_) {\n    // Ignore\n  }\n\n  return null;\n}\n"],"names":["resolveWithExports","_resolveExports","getResolveExports","_require","require","Module","createRequire","_","parseSpecifier","specifier","parts","split","pkgName","slice","join","remainder","length","subpath","findPackageJson","basedir","dir","root","path","parse","candidate","fs","existsSync","parent","dirname","readPackageJson","pkgJsonPath","content","readFileSync","JSON","conditions","resolveExportsMod","exports","resolveExportsFn","legacy","pkg","pkgDir","resolved","legacyMain","mainPath","Array","isArray","indexPath"],"mappings":"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"}

package/dist/esm/lib/resolve-with-exports.d.ts

@@ -1,16 +0,0 @@
-/**
- * Lightweight ESM exports field resolver
- * Uses resolve.exports (952 bytes) instead of import-meta-resolve (64KB)
- *
- * Only loaded on Node >= 12.2 where module.createRequire exists.
- * On older Node, toPath.ts skips this and falls back to resolve.sync().
- *
- * This implementation handles packages with ONLY an exports field (no main),
- * which the resolve package cannot handle on its own.
- */
-/**
- * Resolve a module specifier using the exports field in package.json
- * This implementation directly finds the package and reads its exports,
- * bypassing the resolve package which can't handle exports-only packages.
- */
-export default function resolveWithExports(specifier: string, basedir: string, conditions?: string[]): string | null;

package/dist/esm/lib/resolve-with-exports.js

@@ -1,140 +0,0 @@
-/**
- * Lightweight ESM exports field resolver
- * Uses resolve.exports (952 bytes) instead of import-meta-resolve (64KB)
- *
- * Only loaded on Node >= 12.2 where module.createRequire exists.
- * On older Node, toPath.ts skips this and falls back to resolve.sync().
- *
- * This implementation handles packages with ONLY an exports field (no main),
- * which the resolve package cannot handle on its own.
- */ import fs from 'fs';
-import Module from 'module';
-import path from 'path';
-let _resolveExports = null;
-function getResolveExports() {
-    if (_resolveExports === null) {
-        try {
-            // Use dynamic require to avoid loading on older Node versions
-            const _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;
-            _resolveExports = _require('resolve.exports');
-        } catch (_) {
-            // If resolve.exports fails to load, return null
-            // This shouldn't happen on Node >= 12.2, but handle gracefully
-            _resolveExports = null;
-        }
-    }
-    return _resolveExports;
-}
-/**
- * Parse a specifier into package name and subpath
- * "lodash" → { pkgName: "lodash", subpath: "." }
- * "lodash/get" → { pkgName: "lodash", subpath: "./get" }
- * "@scope/pkg" → { pkgName: "@scope/pkg", subpath: "." }
- * "@scope/pkg/foo" → { pkgName: "@scope/pkg", subpath: "./foo" }
- */ function parseSpecifier(specifier) {
-    const parts = specifier.split('/');
-    const pkgName = specifier[0] === '@' ? parts.slice(0, 2).join('/') : parts[0];
-    const remainder = specifier.slice(pkgName.length);
-    const subpath = remainder ? `.${remainder}` : '.';
-    return {
-        pkgName,
-        subpath
-    };
-}
-/**
- * Find the package.json for a package by walking up node_modules
- */ function findPackageJson(pkgName, basedir) {
-    let dir = basedir;
-    const root = path.parse(dir).root;
-    while(dir !== root){
-        const candidate = path.join(dir, 'node_modules', pkgName, 'package.json');
-        try {
-            if (fs.existsSync(candidate)) {
-                return candidate;
-            }
-        } catch (_) {
-        // Ignore filesystem errors
-        }
-        const parent = path.dirname(dir);
-        if (parent === dir) break;
-        dir = parent;
-    }
-    return null;
-}
-/**
- * Read and parse a package.json file
- */ function readPackageJson(pkgJsonPath) {
-    try {
-        const content = fs.readFileSync(pkgJsonPath, 'utf8');
-        return JSON.parse(content);
-    } catch (_) {
-        return null;
-    }
-}
-/**
- * Resolve a module specifier using the exports field in package.json
- * This implementation directly finds the package and reads its exports,
- * bypassing the resolve package which can't handle exports-only packages.
- */ export default function resolveWithExports(specifier, basedir, conditions = [
-    'node',
-    'import'
-]) {
-    const resolveExportsMod = getResolveExports();
-    if (!resolveExportsMod) {
-        // resolve.exports not available, return null to trigger fallback
-        return null;
-    }
-    const { exports: resolveExportsFn, legacy } = resolveExportsMod;
-    const { pkgName, subpath } = parseSpecifier(specifier);
-    // Find the package.json
-    const pkgJsonPath = findPackageJson(pkgName, basedir);
-    if (!pkgJsonPath) {
-        return null;
-    }
-    // Read package.json
-    const pkg = readPackageJson(pkgJsonPath);
-    if (!pkg) {
-        return null;
-    }
-    const pkgDir = path.dirname(pkgJsonPath);
-    // Try exports field first
-    try {
-        const resolved = resolveExportsFn(pkg, subpath, {
-            conditions
-        });
-        if (resolved === null || resolved === void 0 ? void 0 : resolved[0]) {
-            return path.join(pkgDir, resolved[0]);
-        }
-    } catch (_) {
-    // exports field parsing failed, try legacy
-    }
-    // Try legacy main/module fields
-    try {
-        const legacyMain = legacy(pkg);
-        if (legacyMain) {
-            // legacy() can return string, string[], or browser field object
-            let mainPath;
-            if (typeof legacyMain === 'string') {
-                mainPath = legacyMain;
-            } else if (Array.isArray(legacyMain)) {
-                mainPath = legacyMain[0];
-            }
-            // Ignore browser field objects (they map file paths, not entry points)
-            if (mainPath) {
-                return path.join(pkgDir, mainPath);
-            }
-        }
-    } catch (_) {
-    // legacy parsing failed
-    }
-    // Last resort: try index.js
-    const indexPath = path.join(pkgDir, 'index.js');
-    try {
-        if (fs.existsSync(indexPath)) {
-            return indexPath;
-        }
-    } catch (_) {
-    // Ignore
-    }
-    return null;
-}

package/dist/esm/lib/resolve-with-exports.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/typescript/ts-swc-transform/src/lib/resolve-with-exports.ts"],"sourcesContent":["/**\n * Lightweight ESM exports field resolver\n * Uses resolve.exports (952 bytes) instead of import-meta-resolve (64KB)\n *\n * Only loaded on Node >= 12.2 where module.createRequire exists.\n * On older Node, toPath.ts skips this and falls back to resolve.sync().\n *\n * This implementation handles packages with ONLY an exports field (no main),\n * which the resolve package cannot handle on its own.\n */\n\nimport fs from 'fs';\nimport Module from 'module';\nimport path from 'path';\n\n// Lazy-load resolve.exports to avoid requiring it on older Node versions\n// resolve.exports requires Node >= 10, but this code only runs on Node >= 12.2\ntype ResolveExportsModule = typeof import('resolve.exports');\nlet _resolveExports: ResolveExportsModule | null = null;\n\nfunction getResolveExports(): ResolveExportsModule | null {\n  if (_resolveExports === null) {\n    try {\n      // Use dynamic require to avoid loading on older Node versions\n      const _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;\n      _resolveExports = _require('resolve.exports') as ResolveExportsModule;\n    } catch (_) {\n      // If resolve.exports fails to load, return null\n      // This shouldn't happen on Node >= 12.2, but handle gracefully\n      _resolveExports = null;\n    }\n  }\n  return _resolveExports;\n}\n\n/**\n * Parse a specifier into package name and subpath\n * \"lodash\" → { pkgName: \"lodash\", subpath: \".\" }\n * \"lodash/get\" → { pkgName: \"lodash\", subpath: \"./get\" }\n * \"@scope/pkg\" → { pkgName: \"@scope/pkg\", subpath: \".\" }\n * \"@scope/pkg/foo\" → { pkgName: \"@scope/pkg\", subpath: \"./foo\" }\n */\nfunction parseSpecifier(specifier: string): { pkgName: string; subpath: string } {\n  const parts = specifier.split('/');\n  const pkgName = specifier[0] === '@' ? parts.slice(0, 2).join('/') : parts[0];\n  const remainder = specifier.slice(pkgName.length);\n  const subpath = remainder ? `.${remainder}` : '.';\n  return { pkgName, subpath };\n}\n\n/**\n * Find the package.json for a package by walking up node_modules\n */\nfunction findPackageJson(pkgName: string, basedir: string): string | null {\n  let dir = basedir;\n  const root = path.parse(dir).root;\n\n  while (dir !== root) {\n    const candidate = path.join(dir, 'node_modules', pkgName, 'package.json');\n    try {\n      if (fs.existsSync(candidate)) {\n        return candidate;\n      }\n    } catch (_) {\n      // Ignore filesystem errors\n    }\n    const parent = path.dirname(dir);\n    if (parent === dir) break;\n    dir = parent;\n  }\n\n  return null;\n}\n\n/**\n * Read and parse a package.json file\n */\nfunction readPackageJson(pkgJsonPath: string): Record<string, unknown> | null {\n  try {\n    const content = fs.readFileSync(pkgJsonPath, 'utf8');\n    return JSON.parse(content);\n  } catch (_) {\n    return null;\n  }\n}\n\n/**\n * Resolve a module specifier using the exports field in package.json\n * This implementation directly finds the package and reads its exports,\n * bypassing the resolve package which can't handle exports-only packages.\n */\nexport default function resolveWithExports(specifier: string, basedir: string, conditions: string[] = ['node', 'import']): string | null {\n  const resolveExportsMod = getResolveExports();\n  if (!resolveExportsMod) {\n    // resolve.exports not available, return null to trigger fallback\n    return null;\n  }\n\n  const { exports: resolveExportsFn, legacy } = resolveExportsMod;\n  const { pkgName, subpath } = parseSpecifier(specifier);\n\n  // Find the package.json\n  const pkgJsonPath = findPackageJson(pkgName, basedir);\n  if (!pkgJsonPath) {\n    return null;\n  }\n\n  // Read package.json\n  const pkg = readPackageJson(pkgJsonPath);\n  if (!pkg) {\n    return null;\n  }\n\n  const pkgDir = path.dirname(pkgJsonPath);\n\n  // Try exports field first\n  try {\n    const resolved = resolveExportsFn(pkg, subpath, { conditions });\n    if (resolved?.[0]) {\n      return path.join(pkgDir, resolved[0]);\n    }\n  } catch (_) {\n    // exports field parsing failed, try legacy\n  }\n\n  // Try legacy main/module fields\n  try {\n    const legacyMain = legacy(pkg);\n    if (legacyMain) {\n      // legacy() can return string, string[], or browser field object\n      let mainPath: string | undefined;\n      if (typeof legacyMain === 'string') {\n        mainPath = legacyMain;\n      } else if (Array.isArray(legacyMain)) {\n        mainPath = legacyMain[0];\n      }\n      // Ignore browser field objects (they map file paths, not entry points)\n      if (mainPath) {\n        return path.join(pkgDir, mainPath);\n      }\n    }\n  } catch (_) {\n    // legacy parsing failed\n  }\n\n  // Last resort: try index.js\n  const indexPath = path.join(pkgDir, 'index.js');\n  try {\n    if (fs.existsSync(indexPath)) {\n      return indexPath;\n    }\n  } catch (_) {\n    // Ignore\n  }\n\n  return null;\n}\n"],"names":["fs","Module","path","_resolveExports","getResolveExports","_require","require","createRequire","url","_","parseSpecifier","specifier","parts","split","pkgName","slice","join","remainder","length","subpath","findPackageJson","basedir","dir","root","parse","candidate","existsSync","parent","dirname","readPackageJson","pkgJsonPath","content","readFileSync","JSON","resolveWithExports","conditions","resolveExportsMod","exports","resolveExportsFn","legacy","pkg","pkgDir","resolved","legacyMain","mainPath","Array","isArray","indexPath"],"mappings":"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"}