var __defProp = Object.defineProperty;
var __publicField = (obj, key, value) => {
  if (typeof key !== "symbol")
    key += "";
  if (key in obj)
    return __defProp(obj, key, {enumerable: true, configurable: true, writable: true, value});
  return obj[key] = value;
};
import require$$1 from "/-/slash@v3.0.0-TkjbGlbBRQE9sP1Nad24/dist=es2019,mode=imports/optimized/slash.js";
import "/error/node:module?from=jest-resolve";
;
import require$$3 from "/-/url@v0.11.4-Dx3BYvsis28U4PmFuMQr/dist=es2019,mode=imports/optimized/url.js";
import require$$4 from "/-/jest-pnp-resolver@v1.2.3-xDtuFcF1LLWkrSPdJlHj/dist=es2019,mode=imports/optimized/jest-pnp-resolver.js";
import require$$5 from "/-/unrs-resolver@v1.11.1-GFLGm9YaEA3MT09UrDCc/dist=es2019,mode=imports/optimized/unrs-resolver.js";
import require$$6 from "/-/graceful-fs@v4.2.11-cXsltBXAT4B70ZlXsfIM/dist=es2019,mode=imports/optimized/graceful-fs.js";
import require$$7 from "/-/jest-util@v30.3.0-ceLc228BLjI7sNpXMqQ8/dist=es2019,mode=imports/optimized/jest-util.js";
import require$$8 from "/-/chalk@v4.1.2-ph75OinuhcFcBbDGU374/dist=es2019,mode=imports/optimized/chalk.js";
import "/error/node:vm?from=jest-resolve";
;
import require$$10 from "/-/jest-validate@v30.3.0-T8e0u6khIsRlfSJDUphG/dist=es2019,mode=imports/optimized/jest-validate.js";
import "/error/node:node:module?from=jest-resolve";
;
import "/error/node:node:vm?from=jest-resolve";
;
function defaultSetTimout() {
  throw new Error("setTimeout has not been defined");
}
function defaultClearTimeout() {
  throw new Error("clearTimeout has not been defined");
}
var cachedSetTimeout = defaultSetTimout;
var cachedClearTimeout = defaultClearTimeout;
var globalContext;
if (typeof window !== "undefined") {
  globalContext = window;
} else if (typeof self !== "undefined") {
  globalContext = self;
} else {
  globalContext = {};
}
if (typeof globalContext.setTimeout === "function") {
  cachedSetTimeout = setTimeout;
}
if (typeof globalContext.clearTimeout === "function") {
  cachedClearTimeout = clearTimeout;
}
function runTimeout(fun) {
  if (cachedSetTimeout === setTimeout) {
    return setTimeout(fun, 0);
  }
  if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
    cachedSetTimeout = setTimeout;
    return setTimeout(fun, 0);
  }
  try {
    return cachedSetTimeout(fun, 0);
  } catch (e) {
    try {
      return cachedSetTimeout.call(null, fun, 0);
    } catch (e2) {
      return cachedSetTimeout.call(this, fun, 0);
    }
  }
}
function runClearTimeout(marker) {
  if (cachedClearTimeout === clearTimeout) {
    return clearTimeout(marker);
  }
  if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
    cachedClearTimeout = clearTimeout;
    return clearTimeout(marker);
  }
  try {
    return cachedClearTimeout(marker);
  } catch (e) {
    try {
      return cachedClearTimeout.call(null, marker);
    } catch (e2) {
      return cachedClearTimeout.call(this, marker);
    }
  }
}
var queue = [];
var draining = false;
var currentQueue;
var queueIndex = -1;
function cleanUpNextTick() {
  if (!draining || !currentQueue) {
    return;
  }
  draining = false;
  if (currentQueue.length) {
    queue = currentQueue.concat(queue);
  } else {
    queueIndex = -1;
  }
  if (queue.length) {
    drainQueue();
  }
}
function drainQueue() {
  if (draining) {
    return;
  }
  var timeout = runTimeout(cleanUpNextTick);
  draining = true;
  var len = queue.length;
  while (len) {
    currentQueue = queue;
    queue = [];
    while (++queueIndex < len) {
      if (currentQueue) {
        currentQueue[queueIndex].run();
      }
    }
    queueIndex = -1;
    len = queue.length;
  }
  currentQueue = null;
  draining = false;
  runClearTimeout(timeout);
}
function nextTick(fun) {
  var args = new Array(arguments.length - 1);
  if (arguments.length > 1) {
    for (var i = 1; i < arguments.length; i++) {
      args[i - 1] = arguments[i];
    }
  }
  queue.push(new Item(fun, args));
  if (queue.length === 1 && !draining) {
    runTimeout(drainQueue);
  }
}
function Item(fun, array) {
  this.fun = fun;
  this.array = array;
}
Item.prototype.run = function() {
  this.fun.apply(null, this.array);
};
var title = "browser";
var platform = "browser";
var browser = true;
var argv = [];
var version = "";
var versions = {};
var release = {};
var config = {};
function noop() {
}
var on = noop;
var addListener = noop;
var once = noop;
var off = noop;
var removeListener = noop;
var removeAllListeners = noop;
var emit = noop;
function binding(name) {
  throw new Error("process.binding is not supported");
}
function cwd() {
  return "/";
}
function chdir(dir) {
  throw new Error("process.chdir is not supported");
}
function umask() {
  return 0;
}
var performance = globalContext.performance || {};
var performanceNow = performance.now || performance.mozNow || performance.msNow || performance.oNow || performance.webkitNow || function() {
  return new Date().getTime();
};
function hrtime(previousTimestamp) {
  var clocktime = performanceNow.call(performance) * 1e-3;
  var seconds = Math.floor(clocktime);
  var nanoseconds = Math.floor(clocktime % 1 * 1e9);
  if (previousTimestamp) {
    seconds = seconds - previousTimestamp[0];
    nanoseconds = nanoseconds - previousTimestamp[1];
    if (nanoseconds < 0) {
      seconds--;
      nanoseconds += 1e9;
    }
  }
  return [seconds, nanoseconds];
}
var startTime = new Date();
function uptime() {
  var currentTime = new Date();
  var dif = currentTime - startTime;
  return dif / 1e3;
}
var process = {
  nextTick,
  title,
  browser,
  env: {NODE_ENV: "production"},
  argv,
  version,
  versions,
  on,
  addListener,
  once,
  off,
  removeListener,
  removeAllListeners,
  emit,
  binding,
  cwd,
  chdir,
  umask,
  hrtime,
  platform,
  release,
  config,
  uptime
};
function getDefaultExportFromCjs(x) {
  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
}
function createCommonjsModule(fn, basedir, module) {
  return module = {
    path: basedir,
    exports: {},
    require: function(path2, base) {
      return commonjsRequire(path2, base === void 0 || base === null ? module.path : base);
    }
  }, fn(module, module.exports), module.exports;
}
function commonjsRequire() {
  throw new Error("Dynamic requires are not currently supported by @rollup/plugin-commonjs");
}
function normalizeArray(parts, allowAboveRoot) {
  var up = 0;
  for (var i = parts.length - 1; i >= 0; i--) {
    var last = parts[i];
    if (last === ".") {
      parts.splice(i, 1);
    } else if (last === "..") {
      parts.splice(i, 1);
      up++;
    } else if (up) {
      parts.splice(i, 1);
      up--;
    }
  }
  if (allowAboveRoot) {
    for (; up--; up) {
      parts.unshift("..");
    }
  }
  return parts;
}
var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
var splitPath = function(filename) {
  return splitPathRe.exec(filename).slice(1);
};
function resolve() {
  var resolvedPath = "", resolvedAbsolute = false;
  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
    var path2 = i >= 0 ? arguments[i] : "/";
    if (typeof path2 !== "string") {
      throw new TypeError("Arguments to path.resolve must be strings");
    } else if (!path2) {
      continue;
    }
    resolvedPath = path2 + "/" + resolvedPath;
    resolvedAbsolute = path2.charAt(0) === "/";
  }
  resolvedPath = normalizeArray(filter(resolvedPath.split("/"), function(p) {
    return !!p;
  }), !resolvedAbsolute).join("/");
  return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
}
function normalize(path2) {
  var isPathAbsolute = isAbsolute(path2), trailingSlash = substr(path2, -1) === "/";
  path2 = normalizeArray(filter(path2.split("/"), function(p) {
    return !!p;
  }), !isPathAbsolute).join("/");
  if (!path2 && !isPathAbsolute) {
    path2 = ".";
  }
  if (path2 && trailingSlash) {
    path2 += "/";
  }
  return (isPathAbsolute ? "/" : "") + path2;
}
function isAbsolute(path2) {
  return path2.charAt(0) === "/";
}
function join() {
  var paths = Array.prototype.slice.call(arguments, 0);
  return normalize(filter(paths, function(p, index2) {
    if (typeof p !== "string") {
      throw new TypeError("Arguments to path.join must be strings");
    }
    return p;
  }).join("/"));
}
function relative(from, to) {
  from = resolve(from).substr(1);
  to = resolve(to).substr(1);
  function trim(arr) {
    var start = 0;
    for (; start < arr.length; start++) {
      if (arr[start] !== "")
        break;
    }
    var end = arr.length - 1;
    for (; end >= 0; end--) {
      if (arr[end] !== "")
        break;
    }
    if (start > end)
      return [];
    return arr.slice(start, end - start + 1);
  }
  var fromParts = trim(from.split("/"));
  var toParts = trim(to.split("/"));
  var length = Math.min(fromParts.length, toParts.length);
  var samePartsLength = length;
  for (var i = 0; i < length; i++) {
    if (fromParts[i] !== toParts[i]) {
      samePartsLength = i;
      break;
    }
  }
  var outputParts = [];
  for (var i = samePartsLength; i < fromParts.length; i++) {
    outputParts.push("..");
  }
  outputParts = outputParts.concat(toParts.slice(samePartsLength));
  return outputParts.join("/");
}
var sep = "/";
var delimiter = ":";
function dirname(path2) {
  var result = splitPath(path2), root = result[0], dir = result[1];
  if (!root && !dir) {
    return ".";
  }
  if (dir) {
    dir = dir.substr(0, dir.length - 1);
  }
  return root + dir;
}
function basename(path2, ext) {
  var f = splitPath(path2)[2];
  if (ext && f.substr(-1 * ext.length) === ext) {
    f = f.substr(0, f.length - ext.length);
  }
  return f;
}
function extname(path2) {
  return splitPath(path2)[3];
}
var path = {
  extname,
  basename,
  dirname,
  sep,
  delimiter,
  relative,
  join,
  isAbsolute,
  normalize,
  resolve
};
function filter(xs, f) {
  if (xs.filter)
    return xs.filter(f);
  var res = [];
  for (var i = 0; i < xs.length; i++) {
    if (f(xs[i], i, xs))
      res.push(xs[i]);
  }
  return res;
}
var substr = "ab".substr(-1) === "b" ? function(str, start, len) {
  return str.substr(start, len);
} : function(str, start, len) {
  if (start < 0)
    start = str.length + start;
  return str.substr(start, len);
};
var path$1 = /* @__PURE__ */ Object.freeze({
  __proto__: null,
  resolve,
  normalize,
  isAbsolute,
  join,
  relative,
  sep,
  delimiter,
  dirname,
  basename,
  extname,
  default: path
});
var build = createCommonjsModule(function(module) {
  /*!
   * /**
   *  * Copyright (c) Meta Platforms, Inc. and affiliates.
   *  *
   *  * This source code is licensed under the MIT license found in the
   *  * LICENSE file in the root directory of this source tree.
   *  * /
   */
  (() => {
    var __webpack_modules__ = {
      "./src/ModuleNotFoundError.ts"(__unused_webpack_module, exports) {
        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports["default"] = void 0;
        function path2() {
          const data = _interopRequireWildcard(path$1);
          path2 = function() {
            return data;
          };
          return data;
        }
        function _slash() {
          const data = _interopRequireDefault(require$$1);
          _slash = function() {
            return data;
          };
          return data;
        }
        function _interopRequireDefault(e) {
          return e && e.__esModule ? e : {default: e};
        }
        function _interopRequireWildcard(e, t) {
          if (typeof WeakMap == "function")
            var r = new WeakMap(), n = new WeakMap();
          return (_interopRequireWildcard = function(e2, t2) {
            if (!t2 && e2 && e2.__esModule)
              return e2;
            var o, i, f = {__proto__: null, default: e2};
            if (e2 === null || typeof e2 != "object" && typeof e2 != "function")
              return f;
            if (o = t2 ? n : r) {
              if (o.has(e2))
                return o.get(e2);
              o.set(e2, f);
            }
            for (const t3 in e2)
              t3 !== "default" && {}.hasOwnProperty.call(e2, t3) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e2, t3)) && (i.get || i.set) ? o(f, t3, i) : f[t3] = e2[t3]);
            return f;
          })(e, t);
        }
        class ModuleNotFoundError extends Error {
          constructor(message, moduleName) {
            super(message);
            __publicField(this, "code", "MODULE_NOT_FOUND");
            __publicField(this, "hint");
            __publicField(this, "requireStack");
            __publicField(this, "siblingWithSimilarExtensionFound");
            __publicField(this, "moduleName");
            __publicField(this, "_originalMessage");
            this._originalMessage = message;
            this.moduleName = moduleName;
          }
          buildMessage(rootDir) {
            var _a;
            if (!this._originalMessage) {
              this._originalMessage = this.message || "";
            }
            let message = this._originalMessage;
            if (((_a = this.requireStack) == null ? void 0 : _a.length) && this.requireStack.length > 1) {
              message += `

Require stack:
  ${this.requireStack.map((p) => p.replace(`${rootDir}${path2().sep}`, "")).map(_slash().default).join("\n  ")}
`;
            }
            if (this.hint) {
              message += this.hint;
            }
            this.message = message;
          }
          static duckType(error) {
            error.buildMessage = ModuleNotFoundError.prototype.buildMessage;
            return error;
          }
        }
        exports["default"] = ModuleNotFoundError;
      },
      "./src/defaultResolver.ts"(__unused_webpack_module, exports, __webpack_require__2) {
        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports.defaultResolver = exports.defaultAsyncResolver = exports["default"] = void 0;
        function _module() {
          const data = require$$2;
          _module = function() {
            return data;
          };
          return data;
        }
        function _url() {
          const data = require$$3;
          _url = function() {
            return data;
          };
          return data;
        }
        function _jestPnpResolver() {
          const data = _interopRequireDefault(require$$4);
          _jestPnpResolver = function() {
            return data;
          };
          return data;
        }
        function _unrsResolver() {
          const data = require$$5;
          _unrsResolver = function() {
            return data;
          };
          return data;
        }
        var _fileWalkers = __webpack_require__2("./src/fileWalkers.ts");
        function _interopRequireDefault(e) {
          return e && e.__esModule ? e : {default: e};
        }
        const handleResolveResult = (result) => {
          if (result.error) {
            throw new Error(result.error);
          }
          return result.path;
        };
        function baseResolver(path2, options, async) {
          if ((0, _module().isBuiltin)(path2)) {
            return path2;
          }
          if (process.versions.pnp && options.allowPnp !== false) {
            return (0, _jestPnpResolver().default)(path2, options);
          }
          if (path2.startsWith("file://")) {
            path2 = (0, _url().fileURLToPath)(path2);
          }
          let {
            basedir,
            conditions,
            conditionNames,
            modules,
            moduleDirectory,
            paths,
            roots,
            rootDir,
            ...rest
          } = options;
          modules = modules || moduleDirectory;
          const resolveOptions = {
            conditionNames: conditionNames || conditions || ["require", "node", "default"],
            modules,
            roots: roots || (rootDir ? [rootDir] : void 0),
            ...rest
          };
          let unrsResolver = (0, _fileWalkers.getResolver)();
          if (unrsResolver) {
            unrsResolver = unrsResolver.cloneWithOptions(resolveOptions);
          } else {
            unrsResolver = new (_unrsResolver()).ResolverFactory(resolveOptions);
          }
          (0, _fileWalkers.setResolver)(unrsResolver);
          const finalResolver = (resolve2) => {
            const resolveWithPathsFallback = (result2) => {
              if (!result2.path && (paths == null ? void 0 : paths.length)) {
                const modulesArr = modules == null || Array.isArray(modules) ? modules : [modules];
                if (modulesArr == null ? void 0 : modulesArr.length) {
                  paths = paths.filter((p) => !modulesArr.includes(p));
                }
                if (paths.length > 0) {
                  unrsResolver = unrsResolver.cloneWithOptions({
                    ...resolveOptions,
                    modules: paths
                  });
                  (0, _fileWalkers.setResolver)(unrsResolver);
                  return resolve2();
                }
              }
              return result2;
            };
            const result = resolve2();
            if ("then" in result) {
              return result.then(resolveWithPathsFallback).then(handleResolveResult);
            }
            return handleResolveResult(resolveWithPathsFallback(result));
          };
          return finalResolver(() => async ? unrsResolver.async(basedir, path2) : unrsResolver.sync(basedir, path2));
        }
        const defaultResolver = exports.defaultResolver = baseResolver;
        const defaultAsyncResolver = (path2, options) => baseResolver(path2, options, true);
        exports.defaultAsyncResolver = defaultAsyncResolver;
        var _default = exports["default"] = defaultResolver;
      },
      "./src/fileWalkers.ts"(__unused_webpack_module, exports) {
        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports.clearFsCache = clearFsCache;
        exports.findClosestPackageJson = findClosestPackageJson;
        exports.getResolver = getResolver;
        exports.isDirectory = isDirectory;
        exports.isFile = isFile;
        exports.readPackageCached = readPackageCached;
        exports.realpathSync = realpathSync;
        exports.setResolver = setResolver;
        function _path() {
          const data = path$1;
          _path = function() {
            return data;
          };
          return data;
        }
        function fs() {
          const data = _interopRequireWildcard(require$$6);
          fs = function() {
            return data;
          };
          return data;
        }
        function _jestUtil() {
          const data = require$$7;
          _jestUtil = function() {
            return data;
          };
          return data;
        }
        function _interopRequireWildcard(e, t) {
          if (typeof WeakMap == "function")
            var r = new WeakMap(), n = new WeakMap();
          return (_interopRequireWildcard = function(e2, t2) {
            if (!t2 && e2 && e2.__esModule)
              return e2;
            var o, i, f = {__proto__: null, default: e2};
            if (e2 === null || typeof e2 != "object" && typeof e2 != "function")
              return f;
            if (o = t2 ? n : r) {
              if (o.has(e2))
                return o.get(e2);
              o.set(e2, f);
            }
            for (const t3 in e2)
              t3 !== "default" && {}.hasOwnProperty.call(e2, t3) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e2, t3)) && (i.get || i.set) ? o(f, t3, i) : f[t3] = e2[t3]);
            return f;
          })(e, t);
        }
        let unrsResolver;
        function getResolver() {
          return unrsResolver;
        }
        function setResolver(nextResolver) {
          unrsResolver = nextResolver;
        }
        function clearFsCache() {
          unrsResolver == null ? void 0 : unrsResolver.clearCache();
          checkedPaths.clear();
          checkedRealpathPaths.clear();
          packageContents.clear();
        }
        var IPathType = /* @__PURE__ */ function(IPathType2) {
          IPathType2[IPathType2["FILE"] = 1] = "FILE";
          IPathType2[IPathType2["DIRECTORY"] = 2] = "DIRECTORY";
          IPathType2[IPathType2["OTHER"] = 3] = "OTHER";
          return IPathType2;
        }(IPathType || {});
        const checkedPaths = new Map();
        function statSyncCached(path2) {
          const result = checkedPaths.get(path2);
          if (result != null) {
            return result;
          }
          let stat;
          try {
            stat = fs().statSync(path2, {
              throwIfNoEntry: false
            });
          } catch (error) {
            if (!(error && (error.code === "ENOENT" || error.code === "ENOTDIR"))) {
              throw error;
            }
          }
          if (stat) {
            if (stat.isFile() || stat.isFIFO()) {
              checkedPaths.set(path2, IPathType.FILE);
              return IPathType.FILE;
            } else if (stat.isDirectory()) {
              checkedPaths.set(path2, IPathType.DIRECTORY);
              return IPathType.DIRECTORY;
            }
          }
          checkedPaths.set(path2, IPathType.OTHER);
          return IPathType.OTHER;
        }
        const checkedRealpathPaths = new Map();
        function realpathCached(path2) {
          let result = checkedRealpathPaths.get(path2);
          if (result != null) {
            return result;
          }
          result = (0, _jestUtil().tryRealpath)(path2);
          checkedRealpathPaths.set(path2, result);
          if (path2 !== result) {
            checkedRealpathPaths.set(result, result);
          }
          return result;
        }
        const packageContents = new Map();
        function readPackageCached(path2) {
          let result = packageContents.get(path2);
          if (result != null) {
            return result;
          }
          result = JSON.parse(fs().readFileSync(path2, "utf8"));
          packageContents.set(path2, result);
          return result;
        }
        function findClosestPackageJson(start) {
          let dir = (0, _path().resolve)(".", start);
          if (!isDirectory(dir)) {
            dir = (0, _path().dirname)(dir);
          }
          while (true) {
            const pkgJsonFile = (0, _path().resolve)(dir, "./package.json");
            const hasPackageJson = isFile(pkgJsonFile);
            if (hasPackageJson) {
              return pkgJsonFile;
            }
            const prevDir = dir;
            dir = (0, _path().dirname)(dir);
            if (prevDir === dir) {
              return void 0;
            }
          }
        }
        function isFile(file) {
          return statSyncCached(file) === IPathType.FILE;
        }
        function isDirectory(dir) {
          return statSyncCached(dir) === IPathType.DIRECTORY;
        }
        function realpathSync(file) {
          return realpathCached(file);
        }
      },
      "./src/index.ts"(__unused_webpack_module, exports, __webpack_require__2) {
        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        var _exportNames = {};
        exports["default"] = void 0;
        var _resolver = _interopRequireDefault(__webpack_require__2("./src/resolver.ts"));
        var _utils = __webpack_require__2("./src/utils.ts");
        Object.keys(_utils).forEach(function(key) {
          if (key === "default" || key === "__esModule")
            return;
          if (Object.prototype.hasOwnProperty.call(_exportNames, key))
            return;
          if (key in exports && exports[key] === _utils[key])
            return;
          Object.defineProperty(exports, key, {
            enumerable: true,
            get: function() {
              return _utils[key];
            }
          });
        });
        function _interopRequireDefault(e) {
          return e && e.__esModule ? e : {default: e};
        }
        var _default = exports["default"] = _resolver.default;
      },
      "./src/nodeModulesPaths.ts"(__unused_webpack_module, exports) {
        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports.GlobalPaths = void 0;
        exports["default"] = nodeModulesPaths;
        function path2() {
          const data = _interopRequireWildcard(path$1);
          path2 = function() {
            return data;
          };
          return data;
        }
        function _jestUtil() {
          const data = require$$7;
          _jestUtil = function() {
            return data;
          };
          return data;
        }
        function _interopRequireWildcard(e, t) {
          if (typeof WeakMap == "function")
            var r = new WeakMap(), n = new WeakMap();
          return (_interopRequireWildcard = function(e2, t2) {
            if (!t2 && e2 && e2.__esModule)
              return e2;
            var o, i, f = {__proto__: null, default: e2};
            if (e2 === null || typeof e2 != "object" && typeof e2 != "function")
              return f;
            if (o = t2 ? n : r) {
              if (o.has(e2))
                return o.get(e2);
              o.set(e2, f);
            }
            for (const t3 in e2)
              t3 !== "default" && {}.hasOwnProperty.call(e2, t3) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e2, t3)) && (i.get || i.set) ? o(f, t3, i) : f[t3] = e2[t3]);
            return f;
          })(e, t);
        }
        function nodeModulesPaths(basedir, options) {
          const modules = options && options.moduleDirectory ? [...options.moduleDirectory] : ["node_modules"];
          const basedirAbs = path2().resolve(basedir);
          let prefix = "/";
          if (/^([A-Za-z]:)/.test(basedirAbs)) {
            prefix = "";
          } else if (/^\\\\/.test(basedirAbs)) {
            prefix = "\\\\";
          }
          let physicalBasedir;
          try {
            physicalBasedir = (0, _jestUtil().tryRealpath)(basedirAbs);
          } catch {
            physicalBasedir = basedirAbs;
          }
          const paths = [physicalBasedir];
          let parsed = path2().parse(physicalBasedir);
          while (parsed.dir !== paths.at(-1)) {
            paths.push(parsed.dir);
            parsed = path2().parse(parsed.dir);
          }
          const dirs = paths.reduce((dirs2, aPath) => {
            for (const moduleDir of modules) {
              if (path2().isAbsolute(moduleDir)) {
                if (aPath === basedirAbs && moduleDir) {
                  dirs2.push(moduleDir);
                }
              } else {
                dirs2.push(path2().join(prefix, aPath, moduleDir));
              }
            }
            return dirs2;
          }, []);
          if (options.paths) {
            dirs.push(...options.paths);
          }
          return dirs;
        }
        function findGlobalPaths() {
          const {
            root
          } = path2().parse(process.cwd());
          const globalPath = path2().join(root, "node_modules");
          const resolvePaths = require.resolve.paths("/");
          if (resolvePaths) {
            const rootIndex = resolvePaths.indexOf(globalPath);
            return rootIndex === -1 ? [] : resolvePaths.slice(rootIndex + 1);
          }
          return [];
        }
        const GlobalPaths = exports.GlobalPaths = findGlobalPaths();
      },
      "./src/resolver.ts"(__unused_webpack_module, exports, __webpack_require__2) {
        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports["default"] = void 0;
        function _module() {
          const data = require$$2;
          _module = function() {
            return data;
          };
          return data;
        }
        function path2() {
          const data = _interopRequireWildcard(path$1);
          path2 = function() {
            return data;
          };
          return data;
        }
        function _chalk() {
          const data = _interopRequireDefault(require$$8);
          _chalk = function() {
            return data;
          };
          return data;
        }
        function _slash() {
          const data = _interopRequireDefault(require$$1);
          _slash = function() {
            return data;
          };
          return data;
        }
        function _jestUtil() {
          const data = require$$7;
          _jestUtil = function() {
            return data;
          };
          return data;
        }
        var _ModuleNotFoundError = _interopRequireDefault(__webpack_require__2("./src/ModuleNotFoundError.ts"));
        var _defaultResolver = _interopRequireWildcard(__webpack_require__2("./src/defaultResolver.ts"));
        var _fileWalkers = __webpack_require__2("./src/fileWalkers.ts");
        var _nodeModulesPaths = _interopRequireWildcard(__webpack_require__2("./src/nodeModulesPaths.ts"));
        var _shouldLoadAsEsm = _interopRequireWildcard(__webpack_require__2("./src/shouldLoadAsEsm.ts"));
        function _interopRequireDefault(e) {
          return e && e.__esModule ? e : {default: e};
        }
        function _interopRequireWildcard(e, t) {
          if (typeof WeakMap == "function")
            var r = new WeakMap(), n = new WeakMap();
          return (_interopRequireWildcard = function(e2, t2) {
            if (!t2 && e2 && e2.__esModule)
              return e2;
            var o, i, f = {__proto__: null, default: e2};
            if (e2 === null || typeof e2 != "object" && typeof e2 != "function")
              return f;
            if (o = t2 ? n : r) {
              if (o.has(e2))
                return o.get(e2);
              o.set(e2, f);
            }
            for (const t3 in e2)
              t3 !== "default" && {}.hasOwnProperty.call(e2, t3) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e2, t3)) && (i.get || i.set) ? o(f, t3, i) : f[t3] = e2[t3]);
            return f;
          })(e, t);
        }
        const NATIVE_PLATFORM = "native";
        const resolvedCwd = (0, _jestUtil().tryRealpath)(process.cwd());
        const {
          NODE_PATH
        } = process.env;
        const nodePaths = NODE_PATH ? NODE_PATH.split(path2().delimiter).filter(Boolean).map((p) => path2().resolve(resolvedCwd, p)) : void 0;
        const Resolver2 = class {
          constructor(moduleMap, options) {
            __publicField(this, "_options");
            __publicField(this, "_moduleMap");
            __publicField(this, "_moduleIDCache");
            __publicField(this, "_moduleNameCache");
            __publicField(this, "_modulePathCache");
            __publicField(this, "_supportsNativePlatform");
            this._options = {
              defaultPlatform: options.defaultPlatform,
              extensions: options.extensions,
              hasCoreModules: options.hasCoreModules === void 0 ? true : options.hasCoreModules,
              moduleDirectories: options.moduleDirectories || ["node_modules"],
              moduleNameMapper: options.moduleNameMapper,
              modulePaths: options.modulePaths,
              platforms: options.platforms,
              resolver: options.resolver,
              rootDir: options.rootDir
            };
            this._supportsNativePlatform = options.platforms ? options.platforms.includes(NATIVE_PLATFORM) : false;
            this._moduleMap = moduleMap;
            this._moduleIDCache = new Map();
            this._moduleNameCache = new Map();
            this._modulePathCache = new Map();
          }
          static tryCastModuleNotFoundError(error) {
            if (error instanceof _ModuleNotFoundError.default) {
              return error;
            }
            const casted = error;
            if (casted.code === "MODULE_NOT_FOUND") {
              return _ModuleNotFoundError.default.duckType(casted);
            }
            return null;
          }
          static clearDefaultResolverCache() {
            (0, _fileWalkers.clearFsCache)();
            (0, _shouldLoadAsEsm.clearCachedLookups)();
          }
          static findNodeModule(path3, options) {
            const resolverModule = loadResolver(options.resolver);
            let resolver = _defaultResolver.default;
            if (typeof resolverModule === "function") {
              resolver = resolverModule;
            } else if (typeof resolverModule.sync === "function") {
              resolver = resolverModule.sync;
            }
            const paths = options.paths;
            try {
              return resolver(path3, {
                basedir: options.basedir,
                conditions: options.conditions,
                defaultAsyncResolver: _defaultResolver.defaultAsyncResolver,
                defaultResolver: _defaultResolver.default,
                extensions: options.extensions,
                moduleDirectory: options.moduleDirectory,
                paths: paths ? [...nodePaths || [], ...paths] : nodePaths,
                rootDir: options.rootDir
              });
            } catch (error) {
              if (options.throwIfNotFound || path3.startsWith("#")) {
                throw error;
              }
            }
            return null;
          }
          static async findNodeModuleAsync(path3, options) {
            const resolverModule = loadResolver(options.resolver);
            let resolver = _defaultResolver.defaultAsyncResolver;
            if (typeof resolverModule === "function") {
              resolver = resolverModule;
            } else if (typeof resolverModule.async === "function" || typeof resolverModule.sync === "function") {
              const asyncOrSync = resolverModule.async || resolverModule.sync;
              if (asyncOrSync == null) {
                throw new Error(`Unable to load resolver at ${options.resolver}`);
              }
              resolver = asyncOrSync;
            }
            const paths = options.paths;
            try {
              const result = await resolver(path3, {
                basedir: options.basedir,
                conditions: options.conditions,
                defaultAsyncResolver: _defaultResolver.defaultAsyncResolver,
                defaultResolver: _defaultResolver.default,
                extensions: options.extensions,
                moduleDirectory: options.moduleDirectory,
                paths: paths ? [...nodePaths || [], ...paths] : nodePaths,
                rootDir: options.rootDir
              });
              return result;
            } catch (error) {
              if (options.throwIfNotFound || path3.startsWith("#")) {
                throw error;
              }
            }
            return null;
          }
          resolveModuleFromDirIfExists(dirname2, moduleName, options) {
            const {
              extensions,
              key,
              moduleDirectory,
              paths,
              skipResolution
            } = this._prepareForResolution(dirname2, moduleName, options);
            let module2;
            const cacheResult = this._moduleNameCache.get(key);
            if (cacheResult) {
              return cacheResult;
            }
            module2 = this.getModule(moduleName);
            if (module2) {
              this._moduleNameCache.set(key, module2);
              return module2;
            }
            const resolveNodeModule = (name, throwIfNotFound = false) => {
              if (this.isCoreModule(name) && !this._options.resolver) {
                return name;
              }
              return Resolver2.findNodeModule(name, {
                basedir: dirname2,
                conditions: options == null ? void 0 : options.conditions,
                extensions,
                moduleDirectory,
                paths,
                resolver: this._options.resolver,
                rootDir: this._options.rootDir,
                throwIfNotFound
              });
            };
            if (!skipResolution) {
              module2 = resolveNodeModule(moduleName, Boolean(process.versions.pnp));
              if (module2) {
                this._moduleNameCache.set(key, module2);
                return module2;
              }
            }
            try {
              const hasteModulePath = this._getHasteModulePath(moduleName);
              if (hasteModulePath) {
                const resolvedModule = resolveNodeModule(hasteModulePath) || require.resolve(hasteModulePath);
                this._moduleNameCache.set(key, resolvedModule);
                return resolvedModule;
              }
            } catch {
            }
            return null;
          }
          async resolveModuleFromDirIfExistsAsync(dirname2, moduleName, options) {
            const {
              extensions,
              key,
              moduleDirectory,
              paths,
              skipResolution
            } = this._prepareForResolution(dirname2, moduleName, options);
            let module2;
            const cacheResult = this._moduleNameCache.get(key);
            if (cacheResult) {
              return cacheResult;
            }
            module2 = this.getModule(moduleName);
            if (module2) {
              this._moduleNameCache.set(key, module2);
              return module2;
            }
            const resolveNodeModule = async (name, throwIfNotFound = false) => {
              if (this.isCoreModule(name) && !this._options.resolver) {
                return name;
              }
              return Resolver2.findNodeModuleAsync(name, {
                basedir: dirname2,
                conditions: options == null ? void 0 : options.conditions,
                extensions,
                moduleDirectory,
                paths,
                resolver: this._options.resolver,
                rootDir: this._options.rootDir,
                throwIfNotFound
              });
            };
            if (!skipResolution) {
              module2 = await resolveNodeModule(moduleName, Boolean(process.versions.pnp));
              if (module2) {
                this._moduleNameCache.set(key, module2);
                return module2;
              }
            }
            try {
              const hasteModulePath = this._getHasteModulePath(moduleName);
              if (hasteModulePath) {
                const resolvedModule = await resolveNodeModule(hasteModulePath) || require.resolve(hasteModulePath);
                this._moduleNameCache.set(key, resolvedModule);
                return resolvedModule;
              }
            } catch {
            }
            return null;
          }
          resolveModule(from, moduleName, options) {
            const dirname2 = path2().dirname(from);
            const module2 = this.resolveStubModuleName(from, moduleName, options) || this.resolveModuleFromDirIfExists(dirname2, moduleName, options);
            if (module2)
              return module2;
            this._throwModNotFoundError(from, moduleName);
          }
          async resolveModuleAsync(from, moduleName, options) {
            const dirname2 = path2().dirname(from);
            const module2 = await this.resolveStubModuleNameAsync(from, moduleName, options) || await this.resolveModuleFromDirIfExistsAsync(dirname2, moduleName, options);
            if (module2)
              return module2;
            this._throwModNotFoundError(from, moduleName);
          }
          _prepareForResolution(dirname2, moduleName, options) {
            const paths = (options == null ? void 0 : options.paths) || this._options.modulePaths;
            const moduleDirectory = this._options.moduleDirectories;
            const stringifiedOptions = options ? JSON.stringify(options) : "";
            const key = dirname2 + path2().delimiter + moduleName + stringifiedOptions;
            const defaultPlatform = this._options.defaultPlatform;
            const extensions = [...this._options.extensions];
            if (this._supportsNativePlatform) {
              extensions.unshift(...this._options.extensions.map((ext) => `.${NATIVE_PLATFORM}${ext}`));
            }
            if (defaultPlatform) {
              extensions.unshift(...this._options.extensions.map((ext) => `.${defaultPlatform}${ext}`));
            }
            const skipResolution = options && options.skipNodeResolution && !moduleName.includes(path2().sep);
            return {
              extensions,
              key,
              moduleDirectory,
              paths,
              skipResolution
            };
          }
          _getHasteModulePath(moduleName) {
            const parts = moduleName.split("/");
            const hastePackage = this.getPackage(parts.shift());
            if (hastePackage) {
              return path2().join(path2().dirname(hastePackage), ...parts);
            }
            return null;
          }
          _throwModNotFoundError(from, moduleName) {
            const relativePath = (0, _slash().default)(path2().relative(this._options.rootDir, from)) || ".";
            throw new _ModuleNotFoundError.default(`Cannot find module '${moduleName}' from '${relativePath}'`, moduleName);
          }
          _getMapModuleName(matches) {
            return matches ? (moduleName) => moduleName.replaceAll(/\$(\d+)/g, (_, index2) => matches[Number.parseInt(index2, 10)] || "") : (moduleName) => moduleName;
          }
          _isAliasModule(moduleName) {
            const moduleNameMapper = this._options.moduleNameMapper;
            if (!moduleNameMapper) {
              return false;
            }
            return moduleNameMapper.some(({
              regex
            }) => regex.test(moduleName));
          }
          isCoreModule(moduleName) {
            return this._options.hasCoreModules && (0, _module().isBuiltin)(moduleName) && !this._isAliasModule(moduleName);
          }
          normalizeCoreModuleSpecifier(specifier) {
            return specifier.startsWith("node:") ? specifier.slice(5) : specifier;
          }
          getModule(name) {
            return this._moduleMap.getModule(name, this._options.defaultPlatform, this._supportsNativePlatform);
          }
          getModulePath(from, moduleName) {
            if (moduleName[0] !== "." || path2().isAbsolute(moduleName)) {
              return moduleName;
            }
            return path2().normalize(`${path2().dirname(from)}/${moduleName}`);
          }
          getPackage(name) {
            return this._moduleMap.getPackage(name, this._options.defaultPlatform, this._supportsNativePlatform);
          }
          getMockModule(from, name, options) {
            var _a;
            const mock = this._moduleMap.getMockModule(name);
            if (mock) {
              return mock;
            } else {
              const resolvedName = this.resolveStubModuleName(from, name, options);
              if (resolvedName) {
                return (_a = this._moduleMap.getMockModule(resolvedName)) != null ? _a : null;
              }
            }
            return null;
          }
          async getMockModuleAsync(from, name, options) {
            var _a;
            const mock = this._moduleMap.getMockModule(name);
            if (mock) {
              return mock;
            } else {
              const resolvedName = await this.resolveStubModuleNameAsync(from, name, options);
              if (resolvedName) {
                return (_a = this._moduleMap.getMockModule(resolvedName)) != null ? _a : null;
              }
            }
            return null;
          }
          getModulePaths(from) {
            const cachedModule = this._modulePathCache.get(from);
            if (cachedModule) {
              return cachedModule;
            }
            const moduleDirectory = this._options.moduleDirectories;
            const paths = (0, _nodeModulesPaths.default)(from, {
              moduleDirectory
            });
            if (paths.at(-1) === void 0) {
              paths.pop();
            }
            this._modulePathCache.set(from, paths);
            return paths;
          }
          getGlobalPaths(moduleName) {
            if (!moduleName || moduleName[0] === "." || this.isCoreModule(moduleName)) {
              return [];
            }
            return _nodeModulesPaths.GlobalPaths;
          }
          getModuleID(virtualMocks, from, moduleName = "", options) {
            const stringifiedOptions = options ? JSON.stringify(options) : "";
            const key = from + path2().delimiter + moduleName + stringifiedOptions;
            const cachedModuleID = this._moduleIDCache.get(key);
            if (cachedModuleID) {
              return cachedModuleID;
            }
            const moduleType = this._getModuleType(moduleName);
            const absolutePath = this._getAbsolutePath(virtualMocks, from, moduleName, options);
            const mockPath = this._getMockPath(from, moduleName, options);
            const sep2 = path2().delimiter;
            const id = moduleType + sep2 + (absolutePath ? absolutePath + sep2 : "") + (mockPath ? mockPath + sep2 : "") + (stringifiedOptions ? stringifiedOptions + sep2 : "");
            this._moduleIDCache.set(key, id);
            return id;
          }
          async getModuleIDAsync(virtualMocks, from, moduleName = "", options) {
            const stringifiedOptions = options ? JSON.stringify(options) : "";
            const key = from + path2().delimiter + moduleName + stringifiedOptions;
            const cachedModuleID = this._moduleIDCache.get(key);
            if (cachedModuleID) {
              return cachedModuleID;
            }
            if (moduleName.startsWith("data:")) {
              return moduleName;
            }
            const moduleType = this._getModuleType(moduleName);
            const absolutePath = await this._getAbsolutePathAsync(virtualMocks, from, moduleName, options);
            const mockPath = await this._getMockPathAsync(from, moduleName, options);
            const sep2 = path2().delimiter;
            const id = moduleType + sep2 + (absolutePath ? absolutePath + sep2 : "") + (mockPath ? mockPath + sep2 : "") + (stringifiedOptions ? stringifiedOptions + sep2 : "");
            this._moduleIDCache.set(key, id);
            return id;
          }
          _getModuleType(moduleName) {
            return this.isCoreModule(moduleName) ? "node" : "user";
          }
          _getAbsolutePath(virtualMocks, from, moduleName, options) {
            if (this.isCoreModule(moduleName)) {
              return this.normalizeCoreModuleSpecifier(moduleName);
            }
            if (moduleName.startsWith("data:")) {
              return moduleName;
            }
            return this._isModuleResolved(from, moduleName, options) ? this.getModule(moduleName) : this._getVirtualMockPath(virtualMocks, from, moduleName, options);
          }
          async _getAbsolutePathAsync(virtualMocks, from, moduleName, options) {
            if (this.isCoreModule(moduleName)) {
              return this.normalizeCoreModuleSpecifier(moduleName);
            }
            if (moduleName.startsWith("data:")) {
              return moduleName;
            }
            const isModuleResolved = await this._isModuleResolvedAsync(from, moduleName, options);
            return isModuleResolved ? this.getModule(moduleName) : this._getVirtualMockPathAsync(virtualMocks, from, moduleName, options);
          }
          _getMockPath(from, moduleName, options) {
            return this.isCoreModule(moduleName) ? null : this.getMockModule(from, moduleName, options);
          }
          async _getMockPathAsync(from, moduleName, options) {
            return this.isCoreModule(moduleName) ? null : this.getMockModuleAsync(from, moduleName, options);
          }
          _getVirtualMockPath(virtualMocks, from, moduleName, options) {
            const virtualMockPath = this.getModulePath(from, moduleName);
            return virtualMocks.get(virtualMockPath) ? virtualMockPath : moduleName ? this.resolveModule(from, moduleName, options) : from;
          }
          async _getVirtualMockPathAsync(virtualMocks, from, moduleName, options) {
            const virtualMockPath = this.getModulePath(from, moduleName);
            return virtualMocks.get(virtualMockPath) ? virtualMockPath : moduleName ? this.resolveModuleAsync(from, moduleName, options) : from;
          }
          _isModuleResolved(from, moduleName, options) {
            return !!(this.getModule(moduleName) || this.getMockModule(from, moduleName, options));
          }
          async _isModuleResolvedAsync(from, moduleName, options) {
            return !!(this.getModule(moduleName) || await this.getMockModuleAsync(from, moduleName, options));
          }
          resolveStubModuleName(from, moduleName, options) {
            const dirname2 = path2().dirname(from);
            const {
              extensions,
              moduleDirectory,
              paths
            } = this._prepareForResolution(dirname2, moduleName);
            const moduleNameMapper = this._options.moduleNameMapper;
            const resolver = this._options.resolver;
            if (moduleNameMapper) {
              for (const {
                moduleName: mappedModuleName,
                regex
              } of moduleNameMapper) {
                if (regex.test(moduleName)) {
                  const matches = moduleName.match(regex);
                  const mapModuleName = this._getMapModuleName(matches);
                  const possibleModuleNames = Array.isArray(mappedModuleName) ? mappedModuleName : [mappedModuleName];
                  let module2 = null;
                  for (const possibleModuleName of possibleModuleNames) {
                    const updatedName = mapModuleName(possibleModuleName);
                    module2 = this.getModule(updatedName) || Resolver2.findNodeModule(updatedName, {
                      basedir: dirname2,
                      conditions: options == null ? void 0 : options.conditions,
                      extensions,
                      moduleDirectory,
                      paths,
                      resolver,
                      rootDir: this._options.rootDir
                    });
                    if (module2) {
                      break;
                    }
                  }
                  if (!module2) {
                    throw createNoMappedModuleFoundError(moduleName, mapModuleName, mappedModuleName, regex, resolver);
                  }
                  return module2;
                }
              }
            }
            return null;
          }
          async resolveStubModuleNameAsync(from, moduleName, options) {
            if (this.isCoreModule(moduleName)) {
              return this.normalizeCoreModuleSpecifier(moduleName);
            }
            const dirname2 = path2().dirname(from);
            const {
              extensions,
              moduleDirectory,
              paths
            } = this._prepareForResolution(dirname2, moduleName);
            const moduleNameMapper = this._options.moduleNameMapper;
            const resolver = this._options.resolver;
            if (moduleNameMapper) {
              for (const {
                moduleName: mappedModuleName,
                regex
              } of moduleNameMapper) {
                if (regex.test(moduleName)) {
                  const matches = moduleName.match(regex);
                  const mapModuleName = this._getMapModuleName(matches);
                  const possibleModuleNames = Array.isArray(mappedModuleName) ? mappedModuleName : [mappedModuleName];
                  let module2 = null;
                  for (const possibleModuleName of possibleModuleNames) {
                    const updatedName = mapModuleName(possibleModuleName);
                    module2 = this.getModule(updatedName) || await Resolver2.findNodeModuleAsync(updatedName, {
                      basedir: dirname2,
                      conditions: options == null ? void 0 : options.conditions,
                      extensions,
                      moduleDirectory,
                      paths,
                      resolver,
                      rootDir: this._options.rootDir
                    });
                    if (module2) {
                      break;
                    }
                  }
                  if (!module2) {
                    throw createNoMappedModuleFoundError(moduleName, mapModuleName, mappedModuleName, regex, resolver);
                  }
                  return module2;
                }
              }
            }
            return null;
          }
        };
        let Resolver = Resolver2;
        __publicField(Resolver, "ModuleNotFoundError", _ModuleNotFoundError.default);
        __publicField(Resolver, "unstable_shouldLoadAsEsm", _shouldLoadAsEsm.default);
        exports["default"] = Resolver;
        const createNoMappedModuleFoundError = (moduleName, mapModuleName, mappedModuleName, regex, resolver) => {
          const mappedAs = Array.isArray(mappedModuleName) ? JSON.stringify(mappedModuleName.map(mapModuleName), null, 2) : mappedModuleName;
          const original = Array.isArray(mappedModuleName) ? `${JSON.stringify(mappedModuleName, null, 6).slice(0, -1) + " ".repeat(4)}]` : mappedModuleName;
          const error = new Error(_chalk().default.red(`${_chalk().default.bold("Configuration error")}:

Could not locate module ${_chalk().default.bold(moduleName)} mapped as:
${_chalk().default.bold(mappedAs)}.

Please check your configuration for these entries:
{
  "moduleNameMapper": {
    "${regex.toString()}": "${_chalk().default.bold(original)}"
  },
  "resolver": ${_chalk().default.bold(String(resolver))}
}`));
          error.name = "";
          return error;
        };
        function loadResolver(resolver) {
          if (resolver == null) {
            return _defaultResolver.default;
          }
          const loadedResolver = commonjsRequire();
          if (loadedResolver == null) {
            throw new Error(`Resolver located at ${resolver} does not export anything`);
          }
          if (typeof loadedResolver === "function") {
            return loadedResolver;
          }
          if (typeof loadedResolver === "object" && (loadedResolver.sync != null || loadedResolver.async != null)) {
            return loadedResolver;
          }
          throw new Error(`Resolver located at ${resolver} does not export a function or an object with "sync" and "async" props`);
        }
      },
      "./src/shouldLoadAsEsm.ts"(__unused_webpack_module, exports, __webpack_require__2) {
        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports.clearCachedLookups = clearCachedLookups;
        exports["default"] = cachedShouldLoadAsEsm;
        function _path() {
          const data = path$1;
          _path = function() {
            return data;
          };
          return data;
        }
        function _vm() {
          const data = require$$9;
          _vm = function() {
            return data;
          };
          return data;
        }
        var _fileWalkers = __webpack_require__2("./src/fileWalkers.ts");
        const runtimeSupportsVmModules = typeof _vm().SyntheticModule === "function";
        const cachedFileLookups = new Map();
        const cachedDirLookups = new Map();
        const cachedChecks = new Map();
        function clearCachedLookups() {
          cachedFileLookups.clear();
          cachedDirLookups.clear();
          cachedChecks.clear();
        }
        function cachedShouldLoadAsEsm(path2, extensionsToTreatAsEsm) {
          if (!runtimeSupportsVmModules) {
            return false;
          }
          let cachedLookup = cachedFileLookups.get(path2);
          if (cachedLookup === void 0) {
            cachedLookup = shouldLoadAsEsm(path2, extensionsToTreatAsEsm);
            cachedFileLookups.set(path2, cachedLookup);
          }
          return cachedLookup;
        }
        function shouldLoadAsEsm(path2, extensionsToTreatAsEsm) {
          const extension = (0, _path().extname)(path2);
          if (extension === ".mjs") {
            return true;
          }
          if (extension === ".cjs") {
            return false;
          }
          if (extension !== ".js") {
            return extensionsToTreatAsEsm.includes(extension);
          }
          const cwd2 = (0, _path().dirname)(path2);
          let cachedLookup = cachedDirLookups.get(cwd2);
          if (cachedLookup === void 0) {
            cachedLookup = cachedPkgCheck(cwd2);
            cachedFileLookups.set(cwd2, cachedLookup);
          }
          return cachedLookup;
        }
        function cachedPkgCheck(cwd2) {
          const pkgPath = (0, _fileWalkers.findClosestPackageJson)(cwd2);
          if (!pkgPath) {
            return false;
          }
          let hasModuleField = cachedChecks.get(pkgPath);
          if (hasModuleField != null) {
            return hasModuleField;
          }
          try {
            const pkg = (0, _fileWalkers.readPackageCached)(pkgPath);
            hasModuleField = pkg.type === "module";
          } catch {
            hasModuleField = false;
          }
          cachedChecks.set(pkgPath, hasModuleField);
          return hasModuleField;
        }
      },
      "./src/utils.ts"(__unused_webpack_module, exports, __webpack_require__2) {
        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports.resolveWatchPlugin = exports.resolveTestEnvironment = exports.resolveSequencer = exports.resolveRunner = void 0;
        function path2() {
          const data = _interopRequireWildcard(path$1);
          path2 = function() {
            return data;
          };
          return data;
        }
        function _chalk() {
          const data = _interopRequireDefault(require$$8);
          _chalk = function() {
            return data;
          };
          return data;
        }
        function _jestValidate() {
          const data = require$$10;
          _jestValidate = function() {
            return data;
          };
          return data;
        }
        var _resolver = _interopRequireDefault(__webpack_require__2("./src/resolver.ts"));
        function _interopRequireDefault(e) {
          return e && e.__esModule ? e : {default: e};
        }
        function _interopRequireWildcard(e, t) {
          if (typeof WeakMap == "function")
            var r = new WeakMap(), n = new WeakMap();
          return (_interopRequireWildcard = function(e2, t2) {
            if (!t2 && e2 && e2.__esModule)
              return e2;
            var o, i, f = {__proto__: null, default: e2};
            if (e2 === null || typeof e2 != "object" && typeof e2 != "function")
              return f;
            if (o = t2 ? n : r) {
              if (o.has(e2))
                return o.get(e2);
              o.set(e2, f);
            }
            for (const t3 in e2)
              t3 !== "default" && {}.hasOwnProperty.call(e2, t3) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e2, t3)) && (i.get || i.set) ? o(f, t3, i) : f[t3] = e2[t3]);
            return f;
          })(e, t);
        }
        const BULLET = _chalk().default.bold("\u25CF ");
        const DOCUMENTATION_NOTE = `  ${_chalk().default.bold("Configuration Documentation:")}
  https://jestjs.io/docs/configuration
`;
        const createValidationError = (message) => new (_jestValidate()).ValidationError(`${BULLET}Validation Error`, message, DOCUMENTATION_NOTE);
        const replaceRootDirInPath = (rootDir, filePath) => {
          if (!filePath.startsWith("<rootDir>")) {
            return filePath;
          }
          return path2().resolve(rootDir, path2().normalize(`./${filePath.slice("<rootDir>".length)}`));
        };
        const resolveWithPrefix = (resolver, {
          filePath,
          humanOptionName,
          optionName,
          prefix,
          requireResolveFunction,
          rootDir
        }) => {
          const fileName = replaceRootDirInPath(rootDir, filePath);
          let module2 = _resolver.default.findNodeModule(`${prefix}${fileName}`, {
            basedir: rootDir,
            resolver: resolver || void 0
          });
          if (module2) {
            return module2;
          }
          try {
            return requireResolveFunction(`${prefix}${fileName}`);
          } catch {
          }
          module2 = _resolver.default.findNodeModule(fileName, {
            basedir: rootDir,
            resolver: resolver || void 0
          });
          if (module2) {
            return module2;
          }
          try {
            return requireResolveFunction(fileName);
          } catch {
          }
          throw createValidationError(`  ${humanOptionName} ${_chalk().default.bold(fileName)} cannot be found. Make sure the ${_chalk().default.bold(optionName)} configuration option points to an existing node module.`);
        };
        const resolveTestEnvironment2 = ({
          rootDir,
          testEnvironment: filePath,
          requireResolveFunction
        }) => {
          if (filePath === "jsdom") {
            filePath = "jest-environment-jsdom";
          }
          try {
            return resolveWithPrefix(void 0, {
              filePath,
              humanOptionName: "Test environment",
              optionName: "testEnvironment",
              prefix: "jest-environment-",
              requireResolveFunction,
              rootDir
            });
          } catch (error) {
            if (filePath === "jest-environment-jsdom") {
              error.message += '\n\nAs of Jest 28 "jest-environment-jsdom" is no longer shipped by default, make sure to install it separately.';
            }
            throw error;
          }
        };
        exports.resolveTestEnvironment = resolveTestEnvironment2;
        const resolveWatchPlugin2 = (resolver, {
          filePath,
          rootDir,
          requireResolveFunction
        }) => resolveWithPrefix(resolver, {
          filePath,
          humanOptionName: "Watch plugin",
          optionName: "watchPlugins",
          prefix: "jest-watch-",
          requireResolveFunction,
          rootDir
        });
        exports.resolveWatchPlugin = resolveWatchPlugin2;
        const resolveRunner2 = (resolver, {
          filePath,
          rootDir,
          requireResolveFunction
        }) => resolveWithPrefix(resolver, {
          filePath,
          humanOptionName: "Jest Runner",
          optionName: "runner",
          prefix: "jest-runner-",
          requireResolveFunction,
          rootDir
        });
        exports.resolveRunner = resolveRunner2;
        const resolveSequencer2 = (resolver, {
          filePath,
          rootDir,
          requireResolveFunction
        }) => resolveWithPrefix(resolver, {
          filePath,
          humanOptionName: "Jest Sequencer",
          optionName: "testSequencer",
          prefix: "jest-sequencer-",
          requireResolveFunction,
          rootDir
        });
        exports.resolveSequencer = resolveSequencer2;
      }
    };
    var __webpack_module_cache__ = {};
    function __webpack_require__(moduleId) {
      var cachedModule = __webpack_module_cache__[moduleId];
      if (cachedModule !== void 0) {
        return cachedModule.exports;
      }
      var module2 = __webpack_module_cache__[moduleId] = {
        exports: {}
      };
      __webpack_modules__[moduleId](module2, module2.exports, __webpack_require__);
      return module2.exports;
    }
    var __webpack_exports__ = __webpack_require__("./src/index.ts");
    module.exports = __webpack_exports__;
  })();
});
var cjsModule = /* @__PURE__ */ getDefaultExportFromCjs(build);
const resolveRunner = cjsModule.resolveRunner;
const resolveSequencer = cjsModule.resolveSequencer;
const resolveTestEnvironment = cjsModule.resolveTestEnvironment;
const resolveWatchPlugin = cjsModule.resolveWatchPlugin;
var index = cjsModule.default;
export default index;
export {resolveRunner, resolveSequencer, resolveTestEnvironment, resolveWatchPlugin};