@modern-js/babel-plugin-module-resolver 2.35.1 → 2.36.0

package/dist/cjs/index.js

@@ -1,30 +1,43 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function _export(target, all) {
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
   for (var name in all)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name]
-    });
-}
-_export(exports, {
-  resolvePath: function() {
-    return _resolvePath.default;
-  },
-  default: function() {
-    return _default;
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  default: () => src_default,
+  resolvePath: () => import_resolvePath.default
 });
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _normalizeOptions = /* @__PURE__ */ _interop_require_default._(require("./normalizeOptions"));
-const _resolvePath = /* @__PURE__ */ _interop_require_default._(require("./resolvePath"));
-const _call = /* @__PURE__ */ _interop_require_default._(require("./transformers/call"));
-const _import = /* @__PURE__ */ _interop_require_default._(require("./transformers/import"));
+module.exports = __toCommonJS(src_exports);
+var import_normalizeOptions = __toESM(require("./normalizeOptions"));
+var import_resolvePath = __toESM(require("./resolvePath"));
+var import_call = __toESM(require("./transformers/call"));
+var import_import = __toESM(require("./transformers/import"));
 const importVisitors = {
-  CallExpression: _call.default,
-  "ImportDeclaration|ExportDeclaration": _import.default
+  CallExpression: import_call.default,
+  "ImportDeclaration|ExportDeclaration": import_import.default
 };
 const visitor = {
   Program: {
@@ -36,7 +49,7 @@ const visitor = {
     }
   }
 };
-const _default = ({ types }) => ({
+var src_default = ({ types }) => ({
   name: "module-resolver",
   manipulateOptions(opts) {
     if (opts.filename === void 0) {
@@ -46,7 +59,7 @@ const _default = ({ types }) => ({
   pre(file) {
     this.types = types;
     const currentFile = file.opts.filename;
-    this.normalizedOpts = (0, _normalizeOptions.default)(currentFile, this.opts);
+    this.normalizedOpts = (0, import_normalizeOptions.default)(currentFile, this.opts);
     this.moduleResolverVisited = /* @__PURE__ */ new Set();
   },
   visitor,
@@ -54,3 +67,7 @@ const _default = ({ types }) => ({
     this.moduleResolverVisited.clear();
   }
 });
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolvePath
+});

package/dist/cjs/log.js

@@ -1,13 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "warn", {
-  enumerable: true,
-  get: function() {
-    return warn;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var log_exports = {};
+__export(log_exports, {
+  warn: () => warn
 });
+module.exports = __toCommonJS(log_exports);
 function warn(...args) {
   console.warn(...args);
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  warn
+});

package/dist/cjs/mapPath.js

@@ -1,22 +1,43 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "default", {
-  enumerable: true,
-  get: function() {
-    return mapPathString;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mapPath_exports = {};
+__export(mapPath_exports, {
+  default: () => mapPathString
 });
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _resolvePath = /* @__PURE__ */ _interop_require_default._(require("./resolvePath"));
+module.exports = __toCommonJS(mapPath_exports);
+var import_resolvePath = __toESM(require("./resolvePath"));
 function mapPathString(nodePath, state) {
   if (!state.types.isStringLiteral(nodePath)) {
     return;
   }
   const sourcePath = nodePath.node.value;
   const currentFile = state.file.opts.filename;
-  const resolvePath = state.normalizedOpts.customResolvePath || _resolvePath.default;
+  const resolvePath = state.normalizedOpts.customResolvePath || import_resolvePath.default;
   const modulePath = resolvePath(sourcePath, currentFile, state.opts);
   if (modulePath) {
     if (nodePath.node.pathResolved) {

package/dist/cjs/mapToRelative.js

@@ -1,21 +1,42 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "default", {
-  enumerable: true,
-  get: function() {
-    return mapToRelative;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mapToRelative_exports = {};
+__export(mapToRelative_exports, {
+  default: () => mapToRelative
 });
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _path = /* @__PURE__ */ _interop_require_default._(require("path"));
-const _utils = require("./utils");
-function mapToRelative(cwd, currentFile, module) {
-  let from = _path.default.dirname(currentFile);
-  let to = _path.default.normalize(module);
-  from = _path.default.resolve(cwd, from);
-  to = _path.default.resolve(cwd, to);
-  const moduleMapped = _path.default.relative(from, to);
-  return (0, _utils.toPosixPath)(moduleMapped);
+module.exports = __toCommonJS(mapToRelative_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("./utils");
+function mapToRelative(cwd, currentFile, module2) {
+  let from = import_path.default.dirname(currentFile);
+  let to = import_path.default.normalize(module2);
+  from = import_path.default.resolve(cwd, from);
+  to = import_path.default.resolve(cwd, to);
+  const moduleMapped = import_path.default.relative(from, to);
+  return (0, import_utils.toPosixPath)(moduleMapped);
 }

package/dist/cjs/normalizeOptions.js

@@ -1,20 +1,41 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "default", {
-  enumerable: true,
-  get: function() {
-    return _default;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var normalizeOptions_exports = {};
+__export(normalizeOptions_exports, {
+  default: () => normalizeOptions_default
 });
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _fs = /* @__PURE__ */ _interop_require_default._(require("fs"));
-const _path = /* @__PURE__ */ _interop_require_default._(require("path"));
-const _reselect = require("reselect");
-const _glob = /* @__PURE__ */ _interop_require_default._(require("glob"));
-const _pkgup = /* @__PURE__ */ _interop_require_default._(require("pkg-up"));
-const _utils = require("./utils");
+module.exports = __toCommonJS(normalizeOptions_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_reselect = require("reselect");
+var import_glob = __toESM(require("glob"));
+var import_pkg_up = __toESM(require("pkg-up"));
+var import_utils = require("./utils");
 const defaultExtensions = [
   ".js",
   ".jsx",
@@ -44,7 +65,7 @@ function isRegExp(string) {
 }
 const specialCwd = {
   babelrc: () => null,
-  packagejson: (startPath) => _pkgup.default.sync({
+  packagejson: (startPath) => import_pkg_up.default.sync({
     cwd: startPath
   })
 };
@@ -53,7 +74,7 @@ function normalizeCwd(optsCwd, currentFile) {
   if (optsCwd in specialCwd) {
     const startPath = currentFile === "unknown" ? "./" : currentFile;
     const computedCwd = specialCwd[optsCwd](startPath);
-    cwd = computedCwd ? _path.default.dirname(computedCwd) : null;
+    cwd = computedCwd ? import_path.default.dirname(computedCwd) : null;
   } else {
     cwd = optsCwd;
   }
@@ -66,9 +87,9 @@ function normalizeRoot(optsRoot, cwd) {
   const rootArray = Array.isArray(optsRoot) ? optsRoot : [
     optsRoot
   ];
-  return rootArray.map((dirPath) => _path.default.resolve(cwd, dirPath)).reduce((resolvedDirs, absDirPath) => {
-    if (_glob.default.hasMagic(absDirPath)) {
-      const roots = _glob.default.sync(absDirPath).filter((resolvedPath) => _fs.default.lstatSync(resolvedPath).isDirectory());
+  return rootArray.map((dirPath) => import_path.default.resolve(cwd, dirPath)).reduce((resolvedDirs, absDirPath) => {
+    if (import_glob.default.hasMagic(absDirPath)) {
+      const roots = import_glob.default.sync(absDirPath).filter((resolvedPath) => import_fs.default.lstatSync(resolvedPath).isDirectory());
       return [
         ...resolvedDirs,
         ...roots
@@ -81,7 +102,7 @@ function normalizeRoot(optsRoot, cwd) {
   }, []);
 }
 function getAliasTarget(key, isKeyRegExp) {
-  const regExpPattern = isKeyRegExp ? key : `^${(0, _utils.escapeRegExp)(key)}(/.*|)$`;
+  const regExpPattern = isKeyRegExp ? key : `^${(0, import_utils.escapeRegExp)(key)}(/.*|)$`;
   return new RegExp(regExpPattern);
 }
 function getAliasSubstitute(value, isKeyRegExp) {
@@ -130,9 +151,9 @@ function normalizeTransformedFunctions(optsTransformFunctions) {
 function normalizeLoglevel(optsLoglevel) {
   return optsLoglevel || "warn";
 }
-const _default = (0, _reselect.createSelector)(
+var normalizeOptions_default = (0, import_reselect.createSelector)(
   // The currentFile should have an extension; otherwise it's considered a special value
-  (currentFile) => currentFile.includes(".") ? _path.default.dirname(currentFile) : currentFile,
+  (currentFile) => currentFile.includes(".") ? import_path.default.dirname(currentFile) : currentFile,
   (_, opts) => opts,
   (currentFile, opts) => {
     const cwd = normalizeCwd(opts.cwd, currentFile);

package/dist/cjs/resolvePath.js

@@ -1,32 +1,53 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "default", {
-  enumerable: true,
-  get: function() {
-    return resolvePath;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var resolvePath_exports = {};
+__export(resolvePath_exports, {
+  default: () => resolvePath
 });
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _path = /* @__PURE__ */ _interop_require_default._(require("path"));
-const _log = require("./log");
-const _mapToRelative = /* @__PURE__ */ _interop_require_default._(require("./mapToRelative"));
-const _normalizeOptions = /* @__PURE__ */ _interop_require_default._(require("./normalizeOptions"));
-const _utils = require("./utils");
+module.exports = __toCommonJS(resolvePath_exports);
+var import_path = __toESM(require("path"));
+var import_log = require("./log");
+var import_mapToRelative = __toESM(require("./mapToRelative"));
+var import_normalizeOptions = __toESM(require("./normalizeOptions"));
+var import_utils = require("./utils");
 function getRelativePath(sourcePath, currentFile, absFileInRoot, opts) {
-  const realSourceFileExtension = _path.default.extname(absFileInRoot);
-  const sourceFileExtension = _path.default.extname(sourcePath);
-  let relativePath = (0, _mapToRelative.default)(opts.cwd, currentFile, absFileInRoot);
+  const realSourceFileExtension = import_path.default.extname(absFileInRoot);
+  const sourceFileExtension = import_path.default.extname(sourcePath);
+  let relativePath = (0, import_mapToRelative.default)(opts.cwd, currentFile, absFileInRoot);
   if (realSourceFileExtension !== sourceFileExtension) {
-    relativePath = (0, _utils.replaceExtension)(relativePath, opts);
+    relativePath = (0, import_utils.replaceExtension)(relativePath, opts);
   }
-  return (0, _utils.toLocalPath)((0, _utils.toPosixPath)(relativePath));
+  return (0, import_utils.toLocalPath)((0, import_utils.toPosixPath)(relativePath));
 }
 function findPathInRoots(sourcePath, { extensions, root }) {
   let resolvedSourceFile;
   root.some((basedir) => {
-    resolvedSourceFile = (0, _utils.nodeResolvePath)(`./${sourcePath}`, basedir, extensions);
+    resolvedSourceFile = (0, import_utils.nodeResolvePath)(`./${sourcePath}`, basedir, extensions);
     return resolvedSourceFile !== null;
   });
   return resolvedSourceFile;
@@ -39,9 +60,9 @@ function resolvePathFromRootConfig(sourcePath, currentFile, opts) {
   return getRelativePath(sourcePath, currentFile, absFileInRoot, opts);
 }
 function checkIfPackageExists(modulePath, currentFile, extensions, loglevel) {
-  const resolvedPath = (0, _utils.nodeResolvePath)(modulePath, currentFile, extensions);
+  const resolvedPath = (0, import_utils.nodeResolvePath)(modulePath, currentFile, extensions);
   if (resolvedPath === null && loglevel !== "silent") {
-    (0, _log.warn)(`Could not resolve "${modulePath}" in file ${currentFile}.`);
+    (0, import_log.warn)(`Could not resolve "${modulePath}" in file ${currentFile}.`);
   }
 }
 function resolvePathFromAliasConfig(sourcePath, currentFile, opts) {
@@ -59,14 +80,14 @@ function resolvePathFromAliasConfig(sourcePath, currentFile, opts) {
   }
   if (Array.isArray(aliasedSourceFile)) {
     return aliasedSourceFile.map((asf) => {
-      if ((0, _utils.isRelativePath)(asf)) {
-        return (0, _utils.toLocalPath)((0, _utils.toPosixPath)((0, _mapToRelative.default)(opts.cwd, currentFile, asf)));
+      if ((0, import_utils.isRelativePath)(asf)) {
+        return (0, import_utils.toLocalPath)((0, import_utils.toPosixPath)((0, import_mapToRelative.default)(opts.cwd, currentFile, asf)));
       }
       return asf;
-    }).find((src) => (0, _utils.nodeResolvePath)(src, _path.default.dirname(currentFile), opts.extensions));
+    }).find((src) => (0, import_utils.nodeResolvePath)(src, import_path.default.dirname(currentFile), opts.extensions));
   }
-  if ((0, _utils.isRelativePath)(aliasedSourceFile)) {
-    return (0, _utils.toLocalPath)((0, _utils.toPosixPath)((0, _mapToRelative.default)(opts.cwd, currentFile, aliasedSourceFile)));
+  if ((0, import_utils.isRelativePath)(aliasedSourceFile)) {
+    return (0, import_utils.toLocalPath)((0, import_utils.toPosixPath)((0, import_mapToRelative.default)(opts.cwd, currentFile, aliasedSourceFile)));
   }
   if (process.env.NODE_ENV !== "production") {
     checkIfPackageExists(aliasedSourceFile, currentFile, opts.extensions, opts.loglevel);
@@ -78,11 +99,11 @@ const resolvers = [
   resolvePathFromRootConfig
 ];
 function resolvePath(sourcePath, currentFile, opts) {
-  if ((0, _utils.isRelativePath)(sourcePath)) {
+  if ((0, import_utils.isRelativePath)(sourcePath)) {
     return sourcePath;
   }
-  const normalizedOpts = (0, _normalizeOptions.default)(currentFile, opts);
-  const absoluteCurrentFile = _path.default.resolve(currentFile);
+  const normalizedOpts = (0, import_normalizeOptions.default)(currentFile, opts);
+  const absoluteCurrentFile = import_path.default.resolve(currentFile);
   let resolvedPath = null;
   resolvers.some((resolver) => {
     resolvedPath = resolver(sourcePath, absoluteCurrentFile, normalizedOpts);

package/dist/cjs/transformers/call.js

@@ -1,24 +1,45 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "default", {
-  enumerable: true,
-  get: function() {
-    return transformCall;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var call_exports = {};
+__export(call_exports, {
+  default: () => transformCall
 });
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _utils = require("../utils");
-const _mapPath = /* @__PURE__ */ _interop_require_default._(require("../mapPath"));
+module.exports = __toCommonJS(call_exports);
+var import_utils = require("../utils");
+var import_mapPath = __toESM(require("../mapPath"));
 function transformCall(nodePath, state) {
   if (state.moduleResolverVisited.has(nodePath)) {
     return;
   }
   const calleePath = nodePath.get("callee");
-  const isNormalCall = state.normalizedOpts.transformFunctions.some((pattern) => (0, _utils.matchesPattern)(state.types, calleePath, pattern));
-  if (isNormalCall || (0, _utils.isImportCall)(state.types, nodePath)) {
+  const isNormalCall = state.normalizedOpts.transformFunctions.some((pattern) => (0, import_utils.matchesPattern)(state.types, calleePath, pattern));
+  if (isNormalCall || (0, import_utils.isImportCall)(state.types, nodePath)) {
     state.moduleResolverVisited.add(nodePath);
-    (0, _mapPath.default)(nodePath.get("arguments.0"), state);
+    (0, import_mapPath.default)(nodePath.get("arguments.0"), state);
   }
 }

package/dist/cjs/transformers/import.js

@@ -1,19 +1,40 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "default", {
-  enumerable: true,
-  get: function() {
-    return transformImport;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var import_exports = {};
+__export(import_exports, {
+  default: () => transformImport
 });
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _mapPath = /* @__PURE__ */ _interop_require_default._(require("../mapPath"));
+module.exports = __toCommonJS(import_exports);
+var import_mapPath = __toESM(require("../mapPath"));
 function transformImport(nodePath, state) {
   if (state.moduleResolverVisited.has(nodePath)) {
     return;
   }
   state.moduleResolverVisited.add(nodePath);
-  (0, _mapPath.default)(nodePath.get("source"), state);
+  (0, import_mapPath.default)(nodePath.get("source"), state);
 }

package/dist/cjs/utils.js

@@ -1,49 +1,48 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function _export(target, all) {
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
   for (var name in all)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name]
-    });
-}
-_export(exports, {
-  nodeResolvePath: function() {
-    return nodeResolvePath;
-  },
-  isRelativePath: function() {
-    return isRelativePath;
-  },
-  toPosixPath: function() {
-    return toPosixPath;
-  },
-  toLocalPath: function() {
-    return toLocalPath;
-  },
-  stripExtension: function() {
-    return stripExtension;
-  },
-  replaceExtension: function() {
-    return replaceExtension;
-  },
-  matchesPattern: function() {
-    return matchesPattern;
-  },
-  isImportCall: function() {
-    return isImportCall;
-  },
-  escapeRegExp: function() {
-    return escapeRegExp;
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  escapeRegExp: () => escapeRegExp,
+  isImportCall: () => isImportCall,
+  isRelativePath: () => isRelativePath,
+  matchesPattern: () => matchesPattern,
+  nodeResolvePath: () => nodeResolvePath,
+  replaceExtension: () => replaceExtension,
+  stripExtension: () => stripExtension,
+  toLocalPath: () => toLocalPath,
+  toPosixPath: () => toPosixPath
 });
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _path = /* @__PURE__ */ _interop_require_default._(require("path"));
-const _resolve = /* @__PURE__ */ _interop_require_default._(require("resolve"));
+module.exports = __toCommonJS(utils_exports);
+var import_path = __toESM(require("path"));
+var import_resolve = __toESM(require("resolve"));
 function nodeResolvePath(modulePath, basedir, extensions) {
   try {
-    return _resolve.default.sync(modulePath, {
+    return import_resolve.default.sync(modulePath, {
       basedir,
       extensions
     });
@@ -65,7 +64,7 @@ function toLocalPath(modulePath) {
   return localPath;
 }
 function stripExtension(modulePath, stripExtensions) {
-  let name = _path.default.basename(modulePath);
+  let name = import_path.default.basename(modulePath);
   stripExtensions.some((extension) => {
     if (name.endsWith(extension)) {
       name = name.slice(0, name.length - extension.length);
@@ -77,7 +76,7 @@ function stripExtension(modulePath, stripExtensions) {
 }
 function replaceExtension(modulePath, opts) {
   const filename = stripExtension(modulePath, opts.stripExtensions);
-  return _path.default.join(_path.default.dirname(modulePath), filename);
+  return import_path.default.join(import_path.default.dirname(modulePath), filename);
 }
 function matchesPattern(types, calleePath, pattern) {
   const { node } = calleePath;
@@ -96,3 +95,15 @@ function isImportCall(types, calleePath) {
 function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  escapeRegExp,
+  isImportCall,
+  isRelativePath,
+  matchesPattern,
+  nodeResolvePath,
+  replaceExtension,
+  stripExtension,
+  toLocalPath,
+  toPosixPath
+});

package/dist/esm/index.js

@@ -2,7 +2,6 @@ import normalizeOptions from "./normalizeOptions";
 import resolvePath from "./resolvePath";
 import transformCall from "./transformers/call";
 import transformImport from "./transformers/import";
-export { resolvePath };
 var importVisitors = {
   CallExpression: transformCall,
   "ImportDeclaration|ExportDeclaration": transformImport
@@ -17,7 +16,7 @@ var visitor = {
     }
   }
 };
-export default function(param) {
+function src_default(param) {
   var types = param.types;
   return {
     name: "module-resolver",
@@ -32,10 +31,14 @@ export default function(param) {
       this.normalizedOpts = normalizeOptions(currentFile, this.opts);
       this.moduleResolverVisited = /* @__PURE__ */ new Set();
     },
-    visitor: visitor,
+    visitor,
     post: function post() {
       this.moduleResolverVisited.clear();
     }
   };
 }
 ;
+export {
+  src_default as default,
+  resolvePath
+};

package/dist/esm/log.js

@@ -1,8 +1,11 @@
 import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
-export function warn() {
+function warn() {
   for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
     args[_key] = arguments[_key];
   }
   var _console;
   (_console = console).warn.apply(_console, _to_consumable_array(args));
 }
+export {
+  warn
+};

package/dist/esm/mapPath.js

@@ -1,5 +1,5 @@
 import defaultResolvePath from "./resolvePath";
-export default function mapPathString(nodePath, state) {
+function mapPathString(nodePath, state) {
   if (!state.types.isStringLiteral(nodePath)) {
     return;
   }
@@ -15,3 +15,6 @@ export default function mapPathString(nodePath, state) {
     nodePath.node.pathResolved = true;
   }
 }
+export {
+  mapPathString as default
+};

package/dist/esm/mapToRelative.js

@@ -1,6 +1,6 @@
 import path from "path";
 import { toPosixPath } from "./utils";
-export default function mapToRelative(cwd, currentFile, module) {
+function mapToRelative(cwd, currentFile, module) {
   var from = path.dirname(currentFile);
   var to = path.normalize(module);
   from = path.resolve(cwd, from);
@@ -8,3 +8,6 @@ export default function mapToRelative(cwd, currentFile, module) {
   var moduleMapped = path.relative(from, to);
   return toPosixPath(moduleMapped);
 }
+export {
+  mapToRelative as default
+};

package/dist/esm/normalizeOptions.js

@@ -131,7 +131,7 @@ function normalizeTransformedFunctions(optsTransformFunctions) {
 function normalizeLoglevel(optsLoglevel) {
   return optsLoglevel || "warn";
 }
-export default createSelector(
+var normalizeOptions_default = createSelector(
   // The currentFile should have an extension; otherwise it's considered a special value
   function(currentFile) {
     return currentFile.includes(".") ? path.dirname(currentFile) : currentFile;
@@ -148,14 +148,17 @@ export default createSelector(
     var extensions = opts.extensions || defaultExtensions;
     var stripExtensions = opts.stripExtensions || extensions;
     return {
-      cwd: cwd,
-      root: root,
-      alias: alias,
-      loglevel: loglevel,
-      transformFunctions: transformFunctions,
-      extensions: extensions,
-      stripExtensions: stripExtensions,
+      cwd,
+      root,
+      alias,
+      loglevel,
+      transformFunctions,
+      extensions,
+      stripExtensions,
       customResolvePath: opts.resolvePath
     };
   }
 );
+export {
+  normalizeOptions_default as default
+};

package/dist/esm/resolvePath.js

@@ -71,7 +71,7 @@ var resolvers = [
   resolvePathFromAliasConfig,
   resolvePathFromRootConfig
 ];
-export default function resolvePath(sourcePath, currentFile, opts) {
+function resolvePath(sourcePath, currentFile, opts) {
   if (isRelativePath(sourcePath)) {
     return sourcePath;
   }
@@ -84,3 +84,6 @@ export default function resolvePath(sourcePath, currentFile, opts) {
   });
   return resolvedPath;
 }
+export {
+  resolvePath as default
+};

package/dist/esm/transformers/call.js

@@ -1,6 +1,6 @@
 import { matchesPattern, isImportCall } from "../utils";
 import mapPathString from "../mapPath";
-export default function transformCall(nodePath, state) {
+function transformCall(nodePath, state) {
   if (state.moduleResolverVisited.has(nodePath)) {
     return;
   }
@@ -13,3 +13,6 @@ export default function transformCall(nodePath, state) {
     mapPathString(nodePath.get("arguments.0"), state);
   }
 }
+export {
+  transformCall as default
+};

package/dist/esm/transformers/import.js

@@ -1,8 +1,11 @@
 import mapPathString from "../mapPath";
-export default function transformImport(nodePath, state) {
+function transformImport(nodePath, state) {
   if (state.moduleResolverVisited.has(nodePath)) {
     return;
   }
   state.moduleResolverVisited.add(nodePath);
   mapPathString(nodePath.get("source"), state);
 }
+export {
+  transformImport as default
+};

package/dist/esm/utils.js

@@ -1,29 +1,29 @@
 import path from "path";
 import resolve from "resolve";
-export function nodeResolvePath(modulePath, basedir, extensions) {
+function nodeResolvePath(modulePath, basedir, extensions) {
   try {
     return resolve.sync(modulePath, {
-      basedir: basedir,
-      extensions: extensions
+      basedir,
+      extensions
     });
   } catch (e) {
     return null;
   }
 }
-export function isRelativePath(nodePath) {
+function isRelativePath(nodePath) {
   return nodePath.match(/^\.?\.\//);
 }
-export function toPosixPath(modulePath) {
+function toPosixPath(modulePath) {
   return modulePath.replace(/\\/g, "/");
 }
-export function toLocalPath(modulePath) {
+function toLocalPath(modulePath) {
   var localPath = modulePath.replace(/\/index$/, "");
   if (!isRelativePath(localPath)) {
     localPath = "./".concat(localPath);
   }
   return localPath;
 }
-export function stripExtension(modulePath, stripExtensions) {
+function stripExtension(modulePath, stripExtensions) {
   var name = path.basename(modulePath);
   stripExtensions.some(function(extension) {
     if (name.endsWith(extension)) {
@@ -34,11 +34,11 @@ export function stripExtension(modulePath, stripExtensions) {
   });
   return name;
 }
-export function replaceExtension(modulePath, opts) {
+function replaceExtension(modulePath, opts) {
   var filename = stripExtension(modulePath, opts.stripExtensions);
   return path.join(path.dirname(modulePath), filename);
 }
-export function matchesPattern(types, calleePath, pattern) {
+function matchesPattern(types, calleePath, pattern) {
   var node = calleePath.node;
   if (types.isMemberExpression(node)) {
     return calleePath.matchesPattern(pattern);
@@ -49,9 +49,20 @@ export function matchesPattern(types, calleePath, pattern) {
   var name = pattern.split(".")[0];
   return node.name === name;
 }
-export function isImportCall(types, calleePath) {
+function isImportCall(types, calleePath) {
   return types.isImport(calleePath.node.callee);
 }
-export function escapeRegExp(string) {
+function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+export {
+  escapeRegExp,
+  isImportCall,
+  isRelativePath,
+  matchesPattern,
+  nodeResolvePath,
+  replaceExtension,
+  stripExtension,
+  toLocalPath,
+  toPosixPath
+};

package/dist/esm-node/index.js

@@ -2,7 +2,6 @@ import normalizeOptions from "./normalizeOptions";
 import resolvePath from "./resolvePath";
 import transformCall from "./transformers/call";
 import transformImport from "./transformers/import";
-export { resolvePath };
 const importVisitors = {
   CallExpression: transformCall,
   "ImportDeclaration|ExportDeclaration": transformImport
@@ -17,7 +16,7 @@ const visitor = {
     }
   }
 };
-export default ({ types }) => ({
+var src_default = ({ types }) => ({
   name: "module-resolver",
   manipulateOptions(opts) {
     if (opts.filename === void 0) {
@@ -35,3 +34,7 @@ export default ({ types }) => ({
     this.moduleResolverVisited.clear();
   }
 });
+export {
+  src_default as default,
+  resolvePath
+};

package/dist/esm-node/log.js

@@ -1,3 +1,6 @@
-export function warn(...args) {
+function warn(...args) {
   console.warn(...args);
 }
+export {
+  warn
+};

package/dist/esm-node/mapPath.js

@@ -1,5 +1,5 @@
 import defaultResolvePath from "./resolvePath";
-export default function mapPathString(nodePath, state) {
+function mapPathString(nodePath, state) {
   if (!state.types.isStringLiteral(nodePath)) {
     return;
   }
@@ -15,3 +15,6 @@ export default function mapPathString(nodePath, state) {
     nodePath.node.pathResolved = true;
   }
 }
+export {
+  mapPathString as default
+};

package/dist/esm-node/mapToRelative.js

@@ -1,6 +1,6 @@
 import path from "path";
 import { toPosixPath } from "./utils";
-export default function mapToRelative(cwd, currentFile, module) {
+function mapToRelative(cwd, currentFile, module) {
   let from = path.dirname(currentFile);
   let to = path.normalize(module);
   from = path.resolve(cwd, from);
@@ -8,3 +8,6 @@ export default function mapToRelative(cwd, currentFile, module) {
   const moduleMapped = path.relative(from, to);
   return toPosixPath(moduleMapped);
 }
+export {
+  mapToRelative as default
+};

package/dist/esm-node/normalizeOptions.js

@@ -119,7 +119,7 @@ function normalizeTransformedFunctions(optsTransformFunctions) {
 function normalizeLoglevel(optsLoglevel) {
   return optsLoglevel || "warn";
 }
-export default createSelector(
+var normalizeOptions_default = createSelector(
   // The currentFile should have an extension; otherwise it's considered a special value
   (currentFile) => currentFile.includes(".") ? path.dirname(currentFile) : currentFile,
   (_, opts) => opts,
@@ -143,3 +143,6 @@ export default createSelector(
     };
   }
 );
+export {
+  normalizeOptions_default as default
+};

package/dist/esm-node/resolvePath.js

@@ -66,7 +66,7 @@ const resolvers = [
   resolvePathFromAliasConfig,
   resolvePathFromRootConfig
 ];
-export default function resolvePath(sourcePath, currentFile, opts) {
+function resolvePath(sourcePath, currentFile, opts) {
   if (isRelativePath(sourcePath)) {
     return sourcePath;
   }
@@ -79,3 +79,6 @@ export default function resolvePath(sourcePath, currentFile, opts) {
   });
   return resolvedPath;
 }
+export {
+  resolvePath as default
+};

package/dist/esm-node/transformers/call.js

@@ -1,6 +1,6 @@
 import { matchesPattern, isImportCall } from "../utils";
 import mapPathString from "../mapPath";
-export default function transformCall(nodePath, state) {
+function transformCall(nodePath, state) {
   if (state.moduleResolverVisited.has(nodePath)) {
     return;
   }
@@ -11,3 +11,6 @@ export default function transformCall(nodePath, state) {
     mapPathString(nodePath.get("arguments.0"), state);
   }
 }
+export {
+  transformCall as default
+};

package/dist/esm-node/transformers/import.js

@@ -1,8 +1,11 @@
 import mapPathString from "../mapPath";
-export default function transformImport(nodePath, state) {
+function transformImport(nodePath, state) {
   if (state.moduleResolverVisited.has(nodePath)) {
     return;
   }
   state.moduleResolverVisited.add(nodePath);
   mapPathString(nodePath.get("source"), state);
 }
+export {
+  transformImport as default
+};

package/dist/esm-node/utils.js

@@ -1,6 +1,6 @@
 import path from "path";
 import resolve from "resolve";
-export function nodeResolvePath(modulePath, basedir, extensions) {
+function nodeResolvePath(modulePath, basedir, extensions) {
   try {
     return resolve.sync(modulePath, {
       basedir,
@@ -10,20 +10,20 @@ export function nodeResolvePath(modulePath, basedir, extensions) {
     return null;
   }
 }
-export function isRelativePath(nodePath) {
+function isRelativePath(nodePath) {
   return nodePath.match(/^\.?\.\//);
 }
-export function toPosixPath(modulePath) {
+function toPosixPath(modulePath) {
   return modulePath.replace(/\\/g, "/");
 }
-export function toLocalPath(modulePath) {
+function toLocalPath(modulePath) {
   let localPath = modulePath.replace(/\/index$/, "");
   if (!isRelativePath(localPath)) {
     localPath = `./${localPath}`;
   }
   return localPath;
 }
-export function stripExtension(modulePath, stripExtensions) {
+function stripExtension(modulePath, stripExtensions) {
   let name = path.basename(modulePath);
   stripExtensions.some((extension) => {
     if (name.endsWith(extension)) {
@@ -34,11 +34,11 @@ export function stripExtension(modulePath, stripExtensions) {
   });
   return name;
 }
-export function replaceExtension(modulePath, opts) {
+function replaceExtension(modulePath, opts) {
   const filename = stripExtension(modulePath, opts.stripExtensions);
   return path.join(path.dirname(modulePath), filename);
 }
-export function matchesPattern(types, calleePath, pattern) {
+function matchesPattern(types, calleePath, pattern) {
   const { node } = calleePath;
   if (types.isMemberExpression(node)) {
     return calleePath.matchesPattern(pattern);
@@ -49,9 +49,20 @@ export function matchesPattern(types, calleePath, pattern) {
   const name = pattern.split(".")[0];
   return node.name === name;
 }
-export function isImportCall(types, calleePath) {
+function isImportCall(types, calleePath) {
   return types.isImport(calleePath.node.callee);
 }
-export function escapeRegExp(string) {
+function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+export {
+  escapeRegExp,
+  isImportCall,
+  isRelativePath,
+  matchesPattern,
+  nodeResolvePath,
+  replaceExtension,
+  stripExtension,
+  toLocalPath,
+  toPosixPath
+};

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.35.1",
+  "version": "2.36.0",
   "jsnext:source": "./src/index.js",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -44,8 +44,8 @@
     "@babel/preset-env": "^7.22.15",
     "common-tags": "^1.8.2",
     "jest": "^29.3.1",
-    "@scripts/build": "2.35.1",
-    "@scripts/jest-config": "2.35.1"
+    "@scripts/build": "2.36.0",
+    "@scripts/jest-config": "2.36.0"
   },
   "sideEffects": false,
   "publishConfig": {