storybook 10.1.0-alpha.2 → 10.1.0-alpha.3

package/dist/_node-chunks/{chunk-GWSFLQQQ.js → chunk-NCHBSJG3.js}

@@ -1,20 +1,20 @@
-import CJS_COMPAT_NODE_URL_gimmxetvr7 from 'node:url';
-import CJS_COMPAT_NODE_PATH_gimmxetvr7 from 'node:path';
-import CJS_COMPAT_NODE_MODULE_gimmxetvr7 from "node:module";
+import CJS_COMPAT_NODE_URL_bqgqh4d46dd from 'node:url';
+import CJS_COMPAT_NODE_PATH_bqgqh4d46dd from 'node:path';
+import CJS_COMPAT_NODE_MODULE_bqgqh4d46dd from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_gimmxetvr7.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_gimmxetvr7.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_gimmxetvr7.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_bqgqh4d46dd.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_bqgqh4d46dd.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_bqgqh4d46dd.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
 // ------------------------------------------------------------
 import {
   require_picomatch
-} from "./chunk-XVXUF5GE.js";
+} from "./chunk-TZ7GUTJ4.js";
 import {
   versions_default
-} from "./chunk-N3ZE2FCS.js";
+} from "./chunk-LPNJ7PJY.js";
 import {
   BUN_LOCKFILE,
   BUN_LOCKFILE_BINARY,
@@ -27,42 +27,42 @@ import {
   getProjectRoot,
   normalizeStoryPath,
   require_cross_spawn
-} from "./chunk-S6RYOO4I.js";
+} from "./chunk-B63HGQAB.js";
 import {
   any,
   from,
   up2 as up
-} from "./chunk-3AR5SJTX.js";
+} from "./chunk-5KDXQR2J.js";
 import {
   invariant
-} from "./chunk-D43KJFPO.js";
+} from "./chunk-5X7FGASE.js";
 import {
   importModule,
   resolveModulePath,
   resolvePackageDir,
   safeResolveModule
-} from "./chunk-ZI3WVJBS.js";
+} from "./chunk-TSKLBMF3.js";
 import {
   join,
   parse,
   resolve
-} from "./chunk-LJPS53G5.js";
+} from "./chunk-6U2QTN2E.js";
 import {
   require_prompts
-} from "./chunk-BB3ZKTWJ.js";
+} from "./chunk-NYXHMPY4.js";
 import {
   glob,
   globSync
-} from "./chunk-Q5JSLT56.js";
+} from "./chunk-JKWP2FKQ.js";
 import {
   slash
-} from "./chunk-EKPHXLN6.js";
+} from "./chunk-MPUDYIDW.js";
 import {
   require_dist
-} from "./chunk-IK3K67LJ.js";
+} from "./chunk-S32G4TCP.js";
 import {
   require_picocolors
-} from "./chunk-2L3QAN3W.js";
+} from "./chunk-2JHIUWIN.js";
 import {
   __commonJS,
   __esm,
@@ -71,7 +71,1275 @@ import {
   __require,
   __toCommonJS,
   __toESM
-} from "./chunk-RUJOX3JR.js";
+} from "./chunk-T7KB265F.js";
+
+// node_modules/resolve/lib/homedir.js
+var require_homedir = __commonJS({
+  "node_modules/resolve/lib/homedir.js"(exports, module) {
+    "use strict";
+    var os2 = __require("os");
+    module.exports = os2.homedir || /* @__PURE__ */ __name(function homedir() {
+      var home = process.env.HOME;
+      var user = process.env.LOGNAME || process.env.USER || process.env.LNAME || process.env.USERNAME;
+      if (process.platform === "win32") {
+        return process.env.USERPROFILE || process.env.HOMEDRIVE + process.env.HOMEPATH || home || null;
+      }
+      if (process.platform === "darwin") {
+        return home || (user ? "/Users/" + user : null);
+      }
+      if (process.platform === "linux") {
+        return home || (process.getuid() === 0 ? "/root" : user ? "/home/" + user : null);
+      }
+      return home || null;
+    }, "homedir");
+  }
+});
+
+// node_modules/resolve/lib/caller.js
+var require_caller = __commonJS({
+  "node_modules/resolve/lib/caller.js"(exports, module) {
+    module.exports = function() {
+      var origPrepareStackTrace = Error.prepareStackTrace;
+      Error.prepareStackTrace = function(_, stack2) {
+        return stack2;
+      };
+      var stack = new Error().stack;
+      Error.prepareStackTrace = origPrepareStackTrace;
+      return stack[2].getFileName();
+    };
+  }
+});
+
+// ../node_modules/path-parse/index.js
+var require_path_parse = __commonJS({
+  "../node_modules/path-parse/index.js"(exports, module) {
+    "use strict";
+    var isWindows = process.platform === "win32";
+    var splitWindowsRe = /^(((?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?[\\\/]?)(?:[^\\\/]*[\\\/])*)((\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))[\\\/]*$/;
+    var win32 = {};
+    function win32SplitPath(filename) {
+      return splitWindowsRe.exec(filename).slice(1);
+    }
+    __name(win32SplitPath, "win32SplitPath");
+    win32.parse = function(pathString) {
+      if (typeof pathString !== "string") {
+        throw new TypeError(
+          "Parameter 'pathString' must be a string, not " + typeof pathString
+        );
+      }
+      var allParts = win32SplitPath(pathString);
+      if (!allParts || allParts.length !== 5) {
+        throw new TypeError("Invalid path '" + pathString + "'");
+      }
+      return {
+        root: allParts[1],
+        dir: allParts[0] === allParts[1] ? allParts[0] : allParts[0].slice(0, -1),
+        base: allParts[2],
+        ext: allParts[4],
+        name: allParts[3]
+      };
+    };
+    var splitPathRe = /^((\/?)(?:[^\/]*\/)*)((\.{1,2}|[^\/]+?|)(\.[^.\/]*|))[\/]*$/;
+    var posix4 = {};
+    function posixSplitPath(filename) {
+      return splitPathRe.exec(filename).slice(1);
+    }
+    __name(posixSplitPath, "posixSplitPath");
+    posix4.parse = function(pathString) {
+      if (typeof pathString !== "string") {
+        throw new TypeError(
+          "Parameter 'pathString' must be a string, not " + typeof pathString
+        );
+      }
+      var allParts = posixSplitPath(pathString);
+      if (!allParts || allParts.length !== 5) {
+        throw new TypeError("Invalid path '" + pathString + "'");
+      }
+      return {
+        root: allParts[1],
+        dir: allParts[0].slice(0, -1),
+        base: allParts[2],
+        ext: allParts[4],
+        name: allParts[3]
+      };
+    };
+    if (isWindows)
+      module.exports = win32.parse;
+    else
+      module.exports = posix4.parse;
+    module.exports.posix = posix4.parse;
+    module.exports.win32 = win32.parse;
+  }
+});
+
+// node_modules/resolve/lib/node-modules-paths.js
+var require_node_modules_paths = __commonJS({
+  "node_modules/resolve/lib/node-modules-paths.js"(exports, module) {
+    var path = __require("path");
+    var parse4 = path.parse || require_path_parse();
+    var driveLetterRegex = /^([A-Za-z]:)/;
+    var uncPathRegex = /^\\\\/;
+    var getNodeModulesDirs = /* @__PURE__ */ __name(function getNodeModulesDirs2(absoluteStart, modules) {
+      var prefix = "/";
+      if (driveLetterRegex.test(absoluteStart)) {
+        prefix = "";
+      } else if (uncPathRegex.test(absoluteStart)) {
+        prefix = "\\\\";
+      }
+      var paths = [absoluteStart];
+      var parsed = parse4(absoluteStart);
+      while (parsed.dir !== paths[paths.length - 1]) {
+        paths.push(parsed.dir);
+        parsed = parse4(parsed.dir);
+      }
+      return paths.reduce(function(dirs, aPath) {
+        return dirs.concat(modules.map(function(moduleDir) {
+          return path.resolve(prefix, aPath, moduleDir);
+        }));
+      }, []);
+    }, "getNodeModulesDirs");
+    module.exports = /* @__PURE__ */ __name(function nodeModulesPaths(start, opts, request) {
+      var modules = opts && opts.moduleDirectory ? [].concat(opts.moduleDirectory) : ["node_modules"];
+      if (opts && typeof opts.paths === "function") {
+        return opts.paths(
+          request,
+          start,
+          function() {
+            return getNodeModulesDirs(start, modules);
+          },
+          opts
+        );
+      }
+      var dirs = getNodeModulesDirs(start, modules);
+      return opts && opts.paths ? dirs.concat(opts.paths) : dirs;
+    }, "nodeModulesPaths");
+  }
+});
+
+// node_modules/resolve/lib/normalize-options.js
+var require_normalize_options = __commonJS({
+  "node_modules/resolve/lib/normalize-options.js"(exports, module) {
+    var path = __require("path");
+    module.exports = function(_, opts) {
+      opts = opts || {};
+      if (opts.forceNodeResolution || !process.versions.pnp)
+        return opts;
+      const { findPnpApi } = __require("module");
+      const runPnpResolution = /* @__PURE__ */ __name((request, basedir) => {
+        const parts = request.match(/^((?:@[^/]+\/)?[^/]+)(\/.*)?/);
+        if (!parts)
+          throw new Error(`Assertion failed: Expected the "resolve" package to call the "paths" callback with package names only (got "${request}")`);
+        if (basedir.charAt(basedir.length - 1) !== `/`)
+          basedir = path.join(basedir, `/`);
+        const api = findPnpApi(basedir);
+        if (api === null)
+          return void 0;
+        let manifestPath;
+        try {
+          manifestPath = api.resolveToUnqualified(`${parts[1]}/package.json`, basedir, { considerBuiltins: false });
+        } catch (err) {
+          return null;
+        }
+        if (manifestPath === null)
+          throw new Error(`Assertion failed: The resolution thinks that "${parts[1]}" is a Node builtin`);
+        const packagePath = path.dirname(manifestPath);
+        const unqualifiedPath = typeof parts[2] !== `undefined` ? path.join(packagePath, parts[2]) : packagePath;
+        return { packagePath, unqualifiedPath };
+      }, "runPnpResolution");
+      const runPnpResolutionOnArray = /* @__PURE__ */ __name((request, paths2) => {
+        for (let i = 0; i < paths2.length; i++) {
+          const resolution = runPnpResolution(request, paths2[i]);
+          if (resolution || i === paths2.length - 1) {
+            return resolution;
+          }
+        }
+        return null;
+      }, "runPnpResolutionOnArray");
+      const originalPaths = Array.isArray(opts.paths) ? opts.paths : [];
+      const packageIterator = /* @__PURE__ */ __name((request, basedir, getCandidates, opts2) => {
+        const pathsToTest = [basedir].concat(originalPaths);
+        const resolution = runPnpResolutionOnArray(request, pathsToTest);
+        if (resolution == null)
+          return getCandidates();
+        return [resolution.unqualifiedPath];
+      }, "packageIterator");
+      const paths = /* @__PURE__ */ __name((request, basedir, getNodeModulePaths, opts2) => {
+        const pathsToTest = [basedir].concat(originalPaths);
+        const resolution = runPnpResolutionOnArray(request, pathsToTest);
+        if (resolution == null)
+          return getNodeModulePaths().concat(originalPaths);
+        let nodeModules = path.dirname(resolution.packagePath);
+        if (request.match(/^@[^/]+\//))
+          nodeModules = path.dirname(nodeModules);
+        return [nodeModules];
+      }, "paths");
+      let isInsideIterator = false;
+      if (!opts.__skipPackageIterator) {
+        opts.packageIterator = function(request, basedir, getCandidates, opts2) {
+          isInsideIterator = true;
+          try {
+            return packageIterator(request, basedir, getCandidates, opts2);
+          } finally {
+            isInsideIterator = false;
+          }
+        };
+      }
+      opts.paths = function(request, basedir, getNodeModulePaths, opts2) {
+        if (isInsideIterator)
+          return getNodeModulePaths().concat(originalPaths);
+        return paths(request, basedir, getNodeModulePaths, opts2);
+      };
+      return opts;
+    };
+  }
+});
+
+// ../node_modules/function-bind/implementation.js
+var require_implementation = __commonJS({
+  "../node_modules/function-bind/implementation.js"(exports, module) {
+    "use strict";
+    var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ";
+    var toStr = Object.prototype.toString;
+    var max = Math.max;
+    var funcType = "[object Function]";
+    var concatty = /* @__PURE__ */ __name(function concatty2(a, b) {
+      var arr = [];
+      for (var i = 0; i < a.length; i += 1) {
+        arr[i] = a[i];
+      }
+      for (var j = 0; j < b.length; j += 1) {
+        arr[j + a.length] = b[j];
+      }
+      return arr;
+    }, "concatty");
+    var slicy = /* @__PURE__ */ __name(function slicy2(arrLike, offset) {
+      var arr = [];
+      for (var i = offset || 0, j = 0; i < arrLike.length; i += 1, j += 1) {
+        arr[j] = arrLike[i];
+      }
+      return arr;
+    }, "slicy");
+    var joiny = /* @__PURE__ */ __name(function(arr, joiner) {
+      var str = "";
+      for (var i = 0; i < arr.length; i += 1) {
+        str += arr[i];
+        if (i + 1 < arr.length) {
+          str += joiner;
+        }
+      }
+      return str;
+    }, "joiny");
+    module.exports = /* @__PURE__ */ __name(function bind(that) {
+      var target = this;
+      if (typeof target !== "function" || toStr.apply(target) !== funcType) {
+        throw new TypeError(ERROR_MESSAGE + target);
+      }
+      var args = slicy(arguments, 1);
+      var bound;
+      var binder = /* @__PURE__ */ __name(function() {
+        if (this instanceof bound) {
+          var result = target.apply(
+            this,
+            concatty(args, arguments)
+          );
+          if (Object(result) === result) {
+            return result;
+          }
+          return this;
+        }
+        return target.apply(
+          that,
+          concatty(args, arguments)
+        );
+      }, "binder");
+      var boundLength = max(0, target.length - args.length);
+      var boundArgs = [];
+      for (var i = 0; i < boundLength; i++) {
+        boundArgs[i] = "$" + i;
+      }
+      bound = Function("binder", "return function (" + joiny(boundArgs, ",") + "){ return binder.apply(this,arguments); }")(binder);
+      if (target.prototype) {
+        var Empty = /* @__PURE__ */ __name(function Empty2() {
+        }, "Empty");
+        Empty.prototype = target.prototype;
+        bound.prototype = new Empty();
+        Empty.prototype = null;
+      }
+      return bound;
+    }, "bind");
+  }
+});
+
+// ../node_modules/function-bind/index.js
+var require_function_bind = __commonJS({
+  "../node_modules/function-bind/index.js"(exports, module) {
+    "use strict";
+    var implementation = require_implementation();
+    module.exports = Function.prototype.bind || implementation;
+  }
+});
+
+// ../node_modules/hasown/index.js
+var require_hasown = __commonJS({
+  "../node_modules/hasown/index.js"(exports, module) {
+    "use strict";
+    var call = Function.prototype.call;
+    var $hasOwn = Object.prototype.hasOwnProperty;
+    var bind = require_function_bind();
+    module.exports = bind.call(call, $hasOwn);
+  }
+});
+
+// ../node_modules/is-core-module/core.json
+var require_core = __commonJS({
+  "../node_modules/is-core-module/core.json"(exports, module) {
+    module.exports = {
+      assert: true,
+      "node:assert": [">= 14.18 && < 15", ">= 16"],
+      "assert/strict": ">= 15",
+      "node:assert/strict": ">= 16",
+      async_hooks: ">= 8",
+      "node:async_hooks": [">= 14.18 && < 15", ">= 16"],
+      buffer_ieee754: ">= 0.5 && < 0.9.7",
+      buffer: true,
+      "node:buffer": [">= 14.18 && < 15", ">= 16"],
+      child_process: true,
+      "node:child_process": [">= 14.18 && < 15", ">= 16"],
+      cluster: ">= 0.5",
+      "node:cluster": [">= 14.18 && < 15", ">= 16"],
+      console: true,
+      "node:console": [">= 14.18 && < 15", ">= 16"],
+      constants: true,
+      "node:constants": [">= 14.18 && < 15", ">= 16"],
+      crypto: true,
+      "node:crypto": [">= 14.18 && < 15", ">= 16"],
+      _debug_agent: ">= 1 && < 8",
+      _debugger: "< 8",
+      dgram: true,
+      "node:dgram": [">= 14.18 && < 15", ">= 16"],
+      diagnostics_channel: [">= 14.17 && < 15", ">= 15.1"],
+      "node:diagnostics_channel": [">= 14.18 && < 15", ">= 16"],
+      dns: true,
+      "node:dns": [">= 14.18 && < 15", ">= 16"],
+      "dns/promises": ">= 15",
+      "node:dns/promises": ">= 16",
+      domain: ">= 0.7.12",
+      "node:domain": [">= 14.18 && < 15", ">= 16"],
+      events: true,
+      "node:events": [">= 14.18 && < 15", ">= 16"],
+      freelist: "< 6",
+      fs: true,
+      "node:fs": [">= 14.18 && < 15", ">= 16"],
+      "fs/promises": [">= 10 && < 10.1", ">= 14"],
+      "node:fs/promises": [">= 14.18 && < 15", ">= 16"],
+      _http_agent: ">= 0.11.1",
+      "node:_http_agent": [">= 14.18 && < 15", ">= 16"],
+      _http_client: ">= 0.11.1",
+      "node:_http_client": [">= 14.18 && < 15", ">= 16"],
+      _http_common: ">= 0.11.1",
+      "node:_http_common": [">= 14.18 && < 15", ">= 16"],
+      _http_incoming: ">= 0.11.1",
+      "node:_http_incoming": [">= 14.18 && < 15", ">= 16"],
+      _http_outgoing: ">= 0.11.1",
+      "node:_http_outgoing": [">= 14.18 && < 15", ">= 16"],
+      _http_server: ">= 0.11.1",
+      "node:_http_server": [">= 14.18 && < 15", ">= 16"],
+      http: true,
+      "node:http": [">= 14.18 && < 15", ">= 16"],
+      http2: ">= 8.8",
+      "node:http2": [">= 14.18 && < 15", ">= 16"],
+      https: true,
+      "node:https": [">= 14.18 && < 15", ">= 16"],
+      inspector: ">= 8",
+      "node:inspector": [">= 14.18 && < 15", ">= 16"],
+      "inspector/promises": [">= 19"],
+      "node:inspector/promises": [">= 19"],
+      _linklist: "< 8",
+      module: true,
+      "node:module": [">= 14.18 && < 15", ">= 16"],
+      net: true,
+      "node:net": [">= 14.18 && < 15", ">= 16"],
+      "node-inspect/lib/_inspect": ">= 7.6 && < 12",
+      "node-inspect/lib/internal/inspect_client": ">= 7.6 && < 12",
+      "node-inspect/lib/internal/inspect_repl": ">= 7.6 && < 12",
+      os: true,
+      "node:os": [">= 14.18 && < 15", ">= 16"],
+      path: true,
+      "node:path": [">= 14.18 && < 15", ">= 16"],
+      "path/posix": ">= 15.3",
+      "node:path/posix": ">= 16",
+      "path/win32": ">= 15.3",
+      "node:path/win32": ">= 16",
+      perf_hooks: ">= 8.5",
+      "node:perf_hooks": [">= 14.18 && < 15", ">= 16"],
+      process: ">= 1",
+      "node:process": [">= 14.18 && < 15", ">= 16"],
+      punycode: ">= 0.5",
+      "node:punycode": [">= 14.18 && < 15", ">= 16"],
+      querystring: true,
+      "node:querystring": [">= 14.18 && < 15", ">= 16"],
+      readline: true,
+      "node:readline": [">= 14.18 && < 15", ">= 16"],
+      "readline/promises": ">= 17",
+      "node:readline/promises": ">= 17",
+      repl: true,
+      "node:repl": [">= 14.18 && < 15", ">= 16"],
+      "node:sea": [">= 20.12 && < 21", ">= 21.7"],
+      smalloc: ">= 0.11.5 && < 3",
+      "node:sqlite": [">= 22.13 && < 23", ">= 23.4"],
+      _stream_duplex: ">= 0.9.4",
+      "node:_stream_duplex": [">= 14.18 && < 15", ">= 16"],
+      _stream_transform: ">= 0.9.4",
+      "node:_stream_transform": [">= 14.18 && < 15", ">= 16"],
+      _stream_wrap: ">= 1.4.1",
+      "node:_stream_wrap": [">= 14.18 && < 15", ">= 16"],
+      _stream_passthrough: ">= 0.9.4",
+      "node:_stream_passthrough": [">= 14.18 && < 15", ">= 16"],
+      _stream_readable: ">= 0.9.4",
+      "node:_stream_readable": [">= 14.18 && < 15", ">= 16"],
+      _stream_writable: ">= 0.9.4",
+      "node:_stream_writable": [">= 14.18 && < 15", ">= 16"],
+      stream: true,
+      "node:stream": [">= 14.18 && < 15", ">= 16"],
+      "stream/consumers": ">= 16.7",
+      "node:stream/consumers": ">= 16.7",
+      "stream/promises": ">= 15",
+      "node:stream/promises": ">= 16",
+      "stream/web": ">= 16.5",
+      "node:stream/web": ">= 16.5",
+      string_decoder: true,
+      "node:string_decoder": [">= 14.18 && < 15", ">= 16"],
+      sys: [">= 0.4 && < 0.7", ">= 0.8"],
+      "node:sys": [">= 14.18 && < 15", ">= 16"],
+      "test/reporters": ">= 19.9 && < 20.2",
+      "node:test/reporters": [">= 18.17 && < 19", ">= 19.9", ">= 20"],
+      "test/mock_loader": ">= 22.3 && < 22.7",
+      "node:test/mock_loader": ">= 22.3 && < 22.7",
+      "node:test": [">= 16.17 && < 17", ">= 18"],
+      timers: true,
+      "node:timers": [">= 14.18 && < 15", ">= 16"],
+      "timers/promises": ">= 15",
+      "node:timers/promises": ">= 16",
+      _tls_common: ">= 0.11.13",
+      "node:_tls_common": [">= 14.18 && < 15", ">= 16"],
+      _tls_legacy: ">= 0.11.3 && < 10",
+      _tls_wrap: ">= 0.11.3",
+      "node:_tls_wrap": [">= 14.18 && < 15", ">= 16"],
+      tls: true,
+      "node:tls": [">= 14.18 && < 15", ">= 16"],
+      trace_events: ">= 10",
+      "node:trace_events": [">= 14.18 && < 15", ">= 16"],
+      tty: true,
+      "node:tty": [">= 14.18 && < 15", ">= 16"],
+      url: true,
+      "node:url": [">= 14.18 && < 15", ">= 16"],
+      util: true,
+      "node:util": [">= 14.18 && < 15", ">= 16"],
+      "util/types": ">= 15.3",
+      "node:util/types": ">= 16",
+      "v8/tools/arguments": ">= 10 && < 12",
+      "v8/tools/codemap": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+      "v8/tools/consarray": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+      "v8/tools/csvparser": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+      "v8/tools/logreader": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+      "v8/tools/profile_view": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+      "v8/tools/splaytree": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+      v8: ">= 1",
+      "node:v8": [">= 14.18 && < 15", ">= 16"],
+      vm: true,
+      "node:vm": [">= 14.18 && < 15", ">= 16"],
+      wasi: [">= 13.4 && < 13.5", ">= 18.17 && < 19", ">= 20"],
+      "node:wasi": [">= 18.17 && < 19", ">= 20"],
+      worker_threads: ">= 11.7",
+      "node:worker_threads": [">= 14.18 && < 15", ">= 16"],
+      zlib: ">= 0.5",
+      "node:zlib": [">= 14.18 && < 15", ">= 16"]
+    };
+  }
+});
+
+// ../node_modules/is-core-module/index.js
+var require_is_core_module = __commonJS({
+  "../node_modules/is-core-module/index.js"(exports, module) {
+    "use strict";
+    var hasOwn = require_hasown();
+    function specifierIncluded(current, specifier) {
+      var nodeParts = current.split(".");
+      var parts = specifier.split(" ");
+      var op = parts.length > 1 ? parts[0] : "=";
+      var versionParts = (parts.length > 1 ? parts[1] : parts[0]).split(".");
+      for (var i = 0; i < 3; ++i) {
+        var cur = parseInt(nodeParts[i] || 0, 10);
+        var ver = parseInt(versionParts[i] || 0, 10);
+        if (cur === ver) {
+          continue;
+        }
+        if (op === "<") {
+          return cur < ver;
+        }
+        if (op === ">=") {
+          return cur >= ver;
+        }
+        return false;
+      }
+      return op === ">=";
+    }
+    __name(specifierIncluded, "specifierIncluded");
+    function matchesRange(current, range) {
+      var specifiers = range.split(/ ?&& ?/);
+      if (specifiers.length === 0) {
+        return false;
+      }
+      for (var i = 0; i < specifiers.length; ++i) {
+        if (!specifierIncluded(current, specifiers[i])) {
+          return false;
+        }
+      }
+      return true;
+    }
+    __name(matchesRange, "matchesRange");
+    function versionIncluded(nodeVersion, specifierValue) {
+      if (typeof specifierValue === "boolean") {
+        return specifierValue;
+      }
+      var current = typeof nodeVersion === "undefined" ? process.versions && process.versions.node : nodeVersion;
+      if (typeof current !== "string") {
+        throw new TypeError(typeof nodeVersion === "undefined" ? "Unable to determine current node version" : "If provided, a valid node version is required");
+      }
+      if (specifierValue && typeof specifierValue === "object") {
+        for (var i = 0; i < specifierValue.length; ++i) {
+          if (matchesRange(current, specifierValue[i])) {
+            return true;
+          }
+        }
+        return false;
+      }
+      return matchesRange(current, specifierValue);
+    }
+    __name(versionIncluded, "versionIncluded");
+    var data = require_core();
+    module.exports = /* @__PURE__ */ __name(function isCore(x, nodeVersion) {
+      return hasOwn(data, x) && versionIncluded(nodeVersion, data[x]);
+    }, "isCore");
+  }
+});
+
+// node_modules/resolve/lib/async.js
+var require_async = __commonJS({
+  "node_modules/resolve/lib/async.js"(exports, module) {
+    var fs = __require("fs");
+    var getHomedir = require_homedir();
+    var path = __require("path");
+    var caller = require_caller();
+    var nodeModulesPaths = require_node_modules_paths();
+    var normalizeOptions = require_normalize_options();
+    var isCore = require_is_core_module();
+    var realpathFS = process.platform !== "win32" && fs.realpath && typeof fs.realpath.native === "function" ? fs.realpath.native : fs.realpath;
+    var relativePathRegex = /^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/;
+    var windowsDriveRegex = /^\w:[/\\]*$/;
+    var nodeModulesRegex = /[/\\]node_modules[/\\]*$/;
+    var homedir = getHomedir();
+    var defaultPaths = /* @__PURE__ */ __name(function() {
+      return [
+        path.join(homedir, ".node_modules"),
+        path.join(homedir, ".node_libraries")
+      ];
+    }, "defaultPaths");
+    var defaultIsFile = /* @__PURE__ */ __name(function isFile(file, cb) {
+      fs.stat(file, function(err, stat) {
+        if (!err) {
+          return cb(null, stat.isFile() || stat.isFIFO());
+        }
+        if (err.code === "ENOENT" || err.code === "ENOTDIR") return cb(null, false);
+        return cb(err);
+      });
+    }, "isFile");
+    var defaultIsDir = /* @__PURE__ */ __name(function isDirectory2(dir, cb) {
+      fs.stat(dir, function(err, stat) {
+        if (!err) {
+          return cb(null, stat.isDirectory());
+        }
+        if (err.code === "ENOENT" || err.code === "ENOTDIR") return cb(null, false);
+        return cb(err);
+      });
+    }, "isDirectory");
+    var defaultRealpath = /* @__PURE__ */ __name(function realpath2(x, cb) {
+      realpathFS(x, function(realpathErr, realPath) {
+        if (realpathErr && realpathErr.code !== "ENOENT") cb(realpathErr);
+        else cb(null, realpathErr ? x : realPath);
+      });
+    }, "realpath");
+    var maybeRealpath = /* @__PURE__ */ __name(function maybeRealpath2(realpath2, x, opts, cb) {
+      if (opts && opts.preserveSymlinks === false) {
+        realpath2(x, cb);
+      } else {
+        cb(null, x);
+      }
+    }, "maybeRealpath");
+    var defaultReadPackage = /* @__PURE__ */ __name(function defaultReadPackage2(readFile7, pkgfile, cb) {
+      readFile7(pkgfile, function(readFileErr, body) {
+        if (readFileErr) cb(readFileErr);
+        else {
+          try {
+            var pkg = JSON.parse(body);
+            cb(null, pkg);
+          } catch (jsonErr) {
+            cb(null);
+          }
+        }
+      });
+    }, "defaultReadPackage");
+    var getPackageCandidates = /* @__PURE__ */ __name(function getPackageCandidates2(x, start, opts) {
+      var dirs = nodeModulesPaths(start, opts, x);
+      for (var i = 0; i < dirs.length; i++) {
+        dirs[i] = path.join(dirs[i], x);
+      }
+      return dirs;
+    }, "getPackageCandidates");
+    module.exports = /* @__PURE__ */ __name(function resolve9(x, options, callback) {
+      var cb = callback;
+      var opts = options;
+      if (typeof options === "function") {
+        cb = opts;
+        opts = {};
+      }
+      if (typeof x !== "string") {
+        var err = new TypeError("Path must be a string.");
+        return process.nextTick(function() {
+          cb(err);
+        });
+      }
+      opts = normalizeOptions(x, opts);
+      var isFile = opts.isFile || defaultIsFile;
+      var isDirectory2 = opts.isDirectory || defaultIsDir;
+      var readFile7 = opts.readFile || fs.readFile;
+      var realpath2 = opts.realpath || defaultRealpath;
+      var readPackage = opts.readPackage || defaultReadPackage;
+      if (opts.readFile && opts.readPackage) {
+        var conflictErr = new TypeError("`readFile` and `readPackage` are mutually exclusive.");
+        return process.nextTick(function() {
+          cb(conflictErr);
+        });
+      }
+      var packageIterator = opts.packageIterator;
+      var extensions = opts.extensions || [".js"];
+      var includeCoreModules = opts.includeCoreModules !== false;
+      var basedir = opts.basedir || path.dirname(caller());
+      var parent = opts.filename || basedir;
+      opts.paths = opts.paths || defaultPaths();
+      var absoluteStart = path.resolve(basedir);
+      maybeRealpath(
+        realpath2,
+        absoluteStart,
+        opts,
+        function(err2, realStart) {
+          if (err2) cb(err2);
+          else init(realStart);
+        }
+      );
+      var res;
+      function init(basedir2) {
+        if (relativePathRegex.test(x)) {
+          res = path.resolve(basedir2, x);
+          if (x === "." || x === ".." || x.slice(-1) === "/") res += "/";
+          if (x.slice(-1) === "/" && res === basedir2) {
+            loadAsDirectory(res, opts.package, onfile);
+          } else loadAsFile(res, opts.package, onfile);
+        } else if (includeCoreModules && isCore(x)) {
+          return cb(null, x);
+        } else loadNodeModules(x, basedir2, function(err2, n, pkg) {
+          if (err2) cb(err2);
+          else if (n) {
+            return maybeRealpath(realpath2, n, opts, function(err3, realN) {
+              if (err3) {
+                cb(err3);
+              } else {
+                cb(null, realN, pkg);
+              }
+            });
+          } else {
+            var moduleError = new Error("Cannot find module '" + x + "' from '" + parent + "'");
+            moduleError.code = "MODULE_NOT_FOUND";
+            cb(moduleError);
+          }
+        });
+      }
+      __name(init, "init");
+      function onfile(err2, m, pkg) {
+        if (err2) cb(err2);
+        else if (m) cb(null, m, pkg);
+        else loadAsDirectory(res, function(err3, d, pkg2) {
+          if (err3) cb(err3);
+          else if (d) {
+            maybeRealpath(realpath2, d, opts, function(err4, realD) {
+              if (err4) {
+                cb(err4);
+              } else {
+                cb(null, realD, pkg2);
+              }
+            });
+          } else {
+            var moduleError = new Error("Cannot find module '" + x + "' from '" + parent + "'");
+            moduleError.code = "MODULE_NOT_FOUND";
+            cb(moduleError);
+          }
+        });
+      }
+      __name(onfile, "onfile");
+      function loadAsFile(x2, thePackage, callback2) {
+        var loadAsFilePackage = thePackage;
+        var cb2 = callback2;
+        if (typeof loadAsFilePackage === "function") {
+          cb2 = loadAsFilePackage;
+          loadAsFilePackage = void 0;
+        }
+        var exts = [""].concat(extensions);
+        load(exts, x2, loadAsFilePackage);
+        function load(exts2, x3, loadPackage) {
+          if (exts2.length === 0) return cb2(null, void 0, loadPackage);
+          var file = x3 + exts2[0];
+          var pkg = loadPackage;
+          if (pkg) onpkg(null, pkg);
+          else loadpkg(path.dirname(file), onpkg);
+          function onpkg(err2, pkg_, dir) {
+            pkg = pkg_;
+            if (err2) return cb2(err2);
+            if (dir && pkg && opts.pathFilter) {
+              var rfile = path.relative(dir, file);
+              var rel = rfile.slice(0, rfile.length - exts2[0].length);
+              var r = opts.pathFilter(pkg, x3, rel);
+              if (r) return load(
+                [""].concat(extensions.slice()),
+                path.resolve(dir, r),
+                pkg
+              );
+            }
+            isFile(file, onex);
+          }
+          __name(onpkg, "onpkg");
+          function onex(err2, ex) {
+            if (err2) return cb2(err2);
+            if (ex) return cb2(null, file, pkg);
+            load(exts2.slice(1), x3, pkg);
+          }
+          __name(onex, "onex");
+        }
+        __name(load, "load");
+      }
+      __name(loadAsFile, "loadAsFile");
+      function loadpkg(dir, cb2) {
+        if (dir === "" || dir === "/") return cb2(null);
+        if (process.platform === "win32" && windowsDriveRegex.test(dir)) {
+          return cb2(null);
+        }
+        if (nodeModulesRegex.test(dir)) return cb2(null);
+        maybeRealpath(realpath2, dir, opts, function(unwrapErr, pkgdir) {
+          if (unwrapErr) return loadpkg(path.dirname(dir), cb2);
+          var pkgfile = path.join(pkgdir, "package.json");
+          isFile(pkgfile, function(err2, ex) {
+            if (!ex) return loadpkg(path.dirname(dir), cb2);
+            readPackage(readFile7, pkgfile, function(err3, pkgParam) {
+              if (err3) cb2(err3);
+              var pkg = pkgParam;
+              if (pkg && opts.packageFilter) {
+                pkg = opts.packageFilter(pkg, pkgfile);
+              }
+              cb2(null, pkg, dir);
+            });
+          });
+        });
+      }
+      __name(loadpkg, "loadpkg");
+      function loadAsDirectory(x2, loadAsDirectoryPackage, callback2) {
+        var cb2 = callback2;
+        var fpkg = loadAsDirectoryPackage;
+        if (typeof fpkg === "function") {
+          cb2 = fpkg;
+          fpkg = opts.package;
+        }
+        maybeRealpath(realpath2, x2, opts, function(unwrapErr, pkgdir) {
+          if (unwrapErr) return cb2(unwrapErr);
+          var pkgfile = path.join(pkgdir, "package.json");
+          isFile(pkgfile, function(err2, ex) {
+            if (err2) return cb2(err2);
+            if (!ex) return loadAsFile(path.join(x2, "index"), fpkg, cb2);
+            readPackage(readFile7, pkgfile, function(err3, pkgParam) {
+              if (err3) return cb2(err3);
+              var pkg = pkgParam;
+              if (pkg && opts.packageFilter) {
+                pkg = opts.packageFilter(pkg, pkgfile);
+              }
+              if (pkg && pkg.main) {
+                if (typeof pkg.main !== "string") {
+                  var mainError = new TypeError("package \u201C" + pkg.name + "\u201D `main` must be a string");
+                  mainError.code = "INVALID_PACKAGE_MAIN";
+                  return cb2(mainError);
+                }
+                if (pkg.main === "." || pkg.main === "./") {
+                  pkg.main = "index";
+                }
+                loadAsFile(path.resolve(x2, pkg.main), pkg, function(err4, m, pkg2) {
+                  if (err4) return cb2(err4);
+                  if (m) return cb2(null, m, pkg2);
+                  if (!pkg2) return loadAsFile(path.join(x2, "index"), pkg2, cb2);
+                  var dir = path.resolve(x2, pkg2.main);
+                  loadAsDirectory(dir, pkg2, function(err5, n, pkg3) {
+                    if (err5) return cb2(err5);
+                    if (n) return cb2(null, n, pkg3);
+                    loadAsFile(path.join(x2, "index"), pkg3, cb2);
+                  });
+                });
+                return;
+              }
+              loadAsFile(path.join(x2, "/index"), pkg, cb2);
+            });
+          });
+        });
+      }
+      __name(loadAsDirectory, "loadAsDirectory");
+      function processDirs(cb2, dirs) {
+        if (dirs.length === 0) return cb2(null, void 0);
+        var dir = dirs[0];
+        isDirectory2(path.dirname(dir), isdir);
+        function isdir(err2, isdir2) {
+          if (err2) return cb2(err2);
+          if (!isdir2) return processDirs(cb2, dirs.slice(1));
+          loadAsFile(dir, opts.package, onfile2);
+        }
+        __name(isdir, "isdir");
+        function onfile2(err2, m, pkg) {
+          if (err2) return cb2(err2);
+          if (m) return cb2(null, m, pkg);
+          loadAsDirectory(dir, opts.package, ondir);
+        }
+        __name(onfile2, "onfile");
+        function ondir(err2, n, pkg) {
+          if (err2) return cb2(err2);
+          if (n) return cb2(null, n, pkg);
+          processDirs(cb2, dirs.slice(1));
+        }
+        __name(ondir, "ondir");
+      }
+      __name(processDirs, "processDirs");
+      function loadNodeModules(x2, start, cb2) {
+        var thunk = /* @__PURE__ */ __name(function() {
+          return getPackageCandidates(x2, start, opts);
+        }, "thunk");
+        processDirs(
+          cb2,
+          packageIterator ? packageIterator(x2, start, thunk, opts) : thunk()
+        );
+      }
+      __name(loadNodeModules, "loadNodeModules");
+    }, "resolve");
+  }
+});
+
+// node_modules/resolve/lib/core.json
+var require_core2 = __commonJS({
+  "node_modules/resolve/lib/core.json"(exports, module) {
+    module.exports = {
+      assert: true,
+      "node:assert": [">= 14.18 && < 15", ">= 16"],
+      "assert/strict": ">= 15",
+      "node:assert/strict": ">= 16",
+      async_hooks: ">= 8",
+      "node:async_hooks": [">= 14.18 && < 15", ">= 16"],
+      buffer_ieee754: ">= 0.5 && < 0.9.7",
+      buffer: true,
+      "node:buffer": [">= 14.18 && < 15", ">= 16"],
+      child_process: true,
+      "node:child_process": [">= 14.18 && < 15", ">= 16"],
+      cluster: ">= 0.5",
+      "node:cluster": [">= 14.18 && < 15", ">= 16"],
+      console: true,
+      "node:console": [">= 14.18 && < 15", ">= 16"],
+      constants: true,
+      "node:constants": [">= 14.18 && < 15", ">= 16"],
+      crypto: true,
+      "node:crypto": [">= 14.18 && < 15", ">= 16"],
+      _debug_agent: ">= 1 && < 8",
+      _debugger: "< 8",
+      dgram: true,
+      "node:dgram": [">= 14.18 && < 15", ">= 16"],
+      diagnostics_channel: [">= 14.17 && < 15", ">= 15.1"],
+      "node:diagnostics_channel": [">= 14.18 && < 15", ">= 16"],
+      dns: true,
+      "node:dns": [">= 14.18 && < 15", ">= 16"],
+      "dns/promises": ">= 15",
+      "node:dns/promises": ">= 16",
+      domain: ">= 0.7.12",
+      "node:domain": [">= 14.18 && < 15", ">= 16"],
+      events: true,
+      "node:events": [">= 14.18 && < 15", ">= 16"],
+      freelist: "< 6",
+      fs: true,
+      "node:fs": [">= 14.18 && < 15", ">= 16"],
+      "fs/promises": [">= 10 && < 10.1", ">= 14"],
+      "node:fs/promises": [">= 14.18 && < 15", ">= 16"],
+      _http_agent: ">= 0.11.1",
+      "node:_http_agent": [">= 14.18 && < 15", ">= 16"],
+      _http_client: ">= 0.11.1",
+      "node:_http_client": [">= 14.18 && < 15", ">= 16"],
+      _http_common: ">= 0.11.1",
+      "node:_http_common": [">= 14.18 && < 15", ">= 16"],
+      _http_incoming: ">= 0.11.1",
+      "node:_http_incoming": [">= 14.18 && < 15", ">= 16"],
+      _http_outgoing: ">= 0.11.1",
+      "node:_http_outgoing": [">= 14.18 && < 15", ">= 16"],
+      _http_server: ">= 0.11.1",
+      "node:_http_server": [">= 14.18 && < 15", ">= 16"],
+      http: true,
+      "node:http": [">= 14.18 && < 15", ">= 16"],
+      http2: ">= 8.8",
+      "node:http2": [">= 14.18 && < 15", ">= 16"],
+      https: true,
+      "node:https": [">= 14.18 && < 15", ">= 16"],
+      inspector: ">= 8",
+      "node:inspector": [">= 14.18 && < 15", ">= 16"],
+      "inspector/promises": [">= 19"],
+      "node:inspector/promises": [">= 19"],
+      _linklist: "< 8",
+      module: true,
+      "node:module": [">= 14.18 && < 15", ">= 16"],
+      net: true,
+      "node:net": [">= 14.18 && < 15", ">= 16"],
+      "node-inspect/lib/_inspect": ">= 7.6 && < 12",
+      "node-inspect/lib/internal/inspect_client": ">= 7.6 && < 12",
+      "node-inspect/lib/internal/inspect_repl": ">= 7.6 && < 12",
+      os: true,
+      "node:os": [">= 14.18 && < 15", ">= 16"],
+      path: true,
+      "node:path": [">= 14.18 && < 15", ">= 16"],
+      "path/posix": ">= 15.3",
+      "node:path/posix": ">= 16",
+      "path/win32": ">= 15.3",
+      "node:path/win32": ">= 16",
+      perf_hooks: ">= 8.5",
+      "node:perf_hooks": [">= 14.18 && < 15", ">= 16"],
+      process: ">= 1",
+      "node:process": [">= 14.18 && < 15", ">= 16"],
+      punycode: ">= 0.5",
+      "node:punycode": [">= 14.18 && < 15", ">= 16"],
+      querystring: true,
+      "node:querystring": [">= 14.18 && < 15", ">= 16"],
+      readline: true,
+      "node:readline": [">= 14.18 && < 15", ">= 16"],
+      "readline/promises": ">= 17",
+      "node:readline/promises": ">= 17",
+      repl: true,
+      "node:repl": [">= 14.18 && < 15", ">= 16"],
+      "node:sea": [">= 20.12 && < 21", ">= 21.7"],
+      smalloc: ">= 0.11.5 && < 3",
+      "node:sqlite": [">= 22.13 && < 23", ">= 23.4"],
+      _stream_duplex: ">= 0.9.4",
+      "node:_stream_duplex": [">= 14.18 && < 15", ">= 16"],
+      _stream_transform: ">= 0.9.4",
+      "node:_stream_transform": [">= 14.18 && < 15", ">= 16"],
+      _stream_wrap: ">= 1.4.1",
+      "node:_stream_wrap": [">= 14.18 && < 15", ">= 16"],
+      _stream_passthrough: ">= 0.9.4",
+      "node:_stream_passthrough": [">= 14.18 && < 15", ">= 16"],
+      _stream_readable: ">= 0.9.4",
+      "node:_stream_readable": [">= 14.18 && < 15", ">= 16"],
+      _stream_writable: ">= 0.9.4",
+      "node:_stream_writable": [">= 14.18 && < 15", ">= 16"],
+      stream: true,
+      "node:stream": [">= 14.18 && < 15", ">= 16"],
+      "stream/consumers": ">= 16.7",
+      "node:stream/consumers": ">= 16.7",
+      "stream/promises": ">= 15",
+      "node:stream/promises": ">= 16",
+      "stream/web": ">= 16.5",
+      "node:stream/web": ">= 16.5",
+      string_decoder: true,
+      "node:string_decoder": [">= 14.18 && < 15", ">= 16"],
+      sys: [">= 0.4 && < 0.7", ">= 0.8"],
+      "node:sys": [">= 14.18 && < 15", ">= 16"],
+      "test/reporters": ">= 19.9 && < 20.2",
+      "node:test/reporters": [">= 18.17 && < 19", ">= 19.9", ">= 20"],
+      "test/mock_loader": ">= 22.3 && < 22.7",
+      "node:test/mock_loader": ">= 22.3 && < 22.7",
+      "node:test": [">= 16.17 && < 17", ">= 18"],
+      timers: true,
+      "node:timers": [">= 14.18 && < 15", ">= 16"],
+      "timers/promises": ">= 15",
+      "node:timers/promises": ">= 16",
+      _tls_common: ">= 0.11.13",
+      "node:_tls_common": [">= 14.18 && < 15", ">= 16"],
+      _tls_legacy: ">= 0.11.3 && < 10",
+      _tls_wrap: ">= 0.11.3",
+      "node:_tls_wrap": [">= 14.18 && < 15", ">= 16"],
+      tls: true,
+      "node:tls": [">= 14.18 && < 15", ">= 16"],
+      trace_events: ">= 10",
+      "node:trace_events": [">= 14.18 && < 15", ">= 16"],
+      tty: true,
+      "node:tty": [">= 14.18 && < 15", ">= 16"],
+      url: true,
+      "node:url": [">= 14.18 && < 15", ">= 16"],
+      util: true,
+      "node:util": [">= 14.18 && < 15", ">= 16"],
+      "util/types": ">= 15.3",
+      "node:util/types": ">= 16",
+      "v8/tools/arguments": ">= 10 && < 12",
+      "v8/tools/codemap": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+      "v8/tools/consarray": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+      "v8/tools/csvparser": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+      "v8/tools/logreader": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+      "v8/tools/profile_view": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+      "v8/tools/splaytree": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+      v8: ">= 1",
+      "node:v8": [">= 14.18 && < 15", ">= 16"],
+      vm: true,
+      "node:vm": [">= 14.18 && < 15", ">= 16"],
+      wasi: [">= 13.4 && < 13.5", ">= 18.17 && < 19", ">= 20"],
+      "node:wasi": [">= 18.17 && < 19", ">= 20"],
+      worker_threads: ">= 11.7",
+      "node:worker_threads": [">= 14.18 && < 15", ">= 16"],
+      zlib: ">= 0.5",
+      "node:zlib": [">= 14.18 && < 15", ">= 16"]
+    };
+  }
+});
+
+// node_modules/resolve/lib/core.js
+var require_core3 = __commonJS({
+  "node_modules/resolve/lib/core.js"(exports, module) {
+    "use strict";
+    var isCoreModule = require_is_core_module();
+    var data = require_core2();
+    var core = {};
+    for (mod in data) {
+      if (Object.prototype.hasOwnProperty.call(data, mod)) {
+        core[mod] = isCoreModule(mod);
+      }
+    }
+    var mod;
+    module.exports = core;
+  }
+});
+
+// node_modules/resolve/lib/is-core.js
+var require_is_core = __commonJS({
+  "node_modules/resolve/lib/is-core.js"(exports, module) {
+    var isCoreModule = require_is_core_module();
+    module.exports = /* @__PURE__ */ __name(function isCore(x) {
+      return isCoreModule(x);
+    }, "isCore");
+  }
+});
+
+// node_modules/resolve/lib/sync.js
+var require_sync = __commonJS({
+  "node_modules/resolve/lib/sync.js"(exports, module) {
+    var isCore = require_is_core_module();
+    var fs = __require("fs");
+    var path = __require("path");
+    var getHomedir = require_homedir();
+    var caller = require_caller();
+    var nodeModulesPaths = require_node_modules_paths();
+    var normalizeOptions = require_normalize_options();
+    var realpathFS = process.platform !== "win32" && fs.realpathSync && typeof fs.realpathSync.native === "function" ? fs.realpathSync.native : fs.realpathSync;
+    var relativePathRegex = /^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/;
+    var windowsDriveRegex = /^\w:[/\\]*$/;
+    var nodeModulesRegex = /[/\\]node_modules[/\\]*$/;
+    var homedir = getHomedir();
+    var defaultPaths = /* @__PURE__ */ __name(function() {
+      return [
+        path.join(homedir, ".node_modules"),
+        path.join(homedir, ".node_libraries")
+      ];
+    }, "defaultPaths");
+    var defaultIsFile = /* @__PURE__ */ __name(function isFile(file) {
+      try {
+        var stat = fs.statSync(file, { throwIfNoEntry: false });
+      } catch (e) {
+        if (e && (e.code === "ENOENT" || e.code === "ENOTDIR")) return false;
+        throw e;
+      }
+      return !!stat && (stat.isFile() || stat.isFIFO());
+    }, "isFile");
+    var defaultIsDir = /* @__PURE__ */ __name(function isDirectory2(dir) {
+      try {
+        var stat = fs.statSync(dir, { throwIfNoEntry: false });
+      } catch (e) {
+        if (e && (e.code === "ENOENT" || e.code === "ENOTDIR")) return false;
+        throw e;
+      }
+      return !!stat && stat.isDirectory();
+    }, "isDirectory");
+    var defaultRealpathSync = /* @__PURE__ */ __name(function realpathSync(x) {
+      try {
+        return realpathFS(x);
+      } catch (realpathErr) {
+        if (realpathErr.code !== "ENOENT") {
+          throw realpathErr;
+        }
+      }
+      return x;
+    }, "realpathSync");
+    var maybeRealpathSync = /* @__PURE__ */ __name(function maybeRealpathSync2(realpathSync, x, opts) {
+      if (opts && opts.preserveSymlinks === false) {
+        return realpathSync(x);
+      }
+      return x;
+    }, "maybeRealpathSync");
+    var defaultReadPackageSync = /* @__PURE__ */ __name(function defaultReadPackageSync2(readFileSync10, pkgfile) {
+      var body = readFileSync10(pkgfile);
+      try {
+        var pkg = JSON.parse(body);
+        return pkg;
+      } catch (jsonErr) {
+      }
+    }, "defaultReadPackageSync");
+    var getPackageCandidates = /* @__PURE__ */ __name(function getPackageCandidates2(x, start, opts) {
+      var dirs = nodeModulesPaths(start, opts, x);
+      for (var i = 0; i < dirs.length; i++) {
+        dirs[i] = path.join(dirs[i], x);
+      }
+      return dirs;
+    }, "getPackageCandidates");
+    module.exports = /* @__PURE__ */ __name(function resolveSync(x, options) {
+      if (typeof x !== "string") {
+        throw new TypeError("Path must be a string.");
+      }
+      var opts = normalizeOptions(x, options);
+      var isFile = opts.isFile || defaultIsFile;
+      var readFileSync10 = opts.readFileSync || fs.readFileSync;
+      var isDirectory2 = opts.isDirectory || defaultIsDir;
+      var realpathSync = opts.realpathSync || defaultRealpathSync;
+      var readPackageSync = opts.readPackageSync || defaultReadPackageSync;
+      if (opts.readFileSync && opts.readPackageSync) {
+        throw new TypeError("`readFileSync` and `readPackageSync` are mutually exclusive.");
+      }
+      var packageIterator = opts.packageIterator;
+      var extensions = opts.extensions || [".js"];
+      var includeCoreModules = opts.includeCoreModules !== false;
+      var basedir = opts.basedir || path.dirname(caller());
+      var parent = opts.filename || basedir;
+      opts.paths = opts.paths || defaultPaths();
+      var absoluteStart = maybeRealpathSync(realpathSync, path.resolve(basedir), opts);
+      if (relativePathRegex.test(x)) {
+        var res = path.resolve(absoluteStart, x);
+        if (x === "." || x === ".." || x.slice(-1) === "/") res += "/";
+        var m = loadAsFileSync(res) || loadAsDirectorySync(res);
+        if (m) return maybeRealpathSync(realpathSync, m, opts);
+      } else if (includeCoreModules && isCore(x)) {
+        return x;
+      } else {
+        var n = loadNodeModulesSync(x, absoluteStart);
+        if (n) return maybeRealpathSync(realpathSync, n, opts);
+      }
+      var err = new Error("Cannot find module '" + x + "' from '" + parent + "'");
+      err.code = "MODULE_NOT_FOUND";
+      throw err;
+      function loadAsFileSync(x2) {
+        var pkg = loadpkg(path.dirname(x2));
+        if (pkg && pkg.dir && pkg.pkg && opts.pathFilter) {
+          var rfile = path.relative(pkg.dir, x2);
+          var r = opts.pathFilter(pkg.pkg, x2, rfile);
+          if (r) {
+            x2 = path.resolve(pkg.dir, r);
+          }
+        }
+        if (isFile(x2)) {
+          return x2;
+        }
+        for (var i = 0; i < extensions.length; i++) {
+          var file = x2 + extensions[i];
+          if (isFile(file)) {
+            return file;
+          }
+        }
+      }
+      __name(loadAsFileSync, "loadAsFileSync");
+      function loadpkg(dir) {
+        if (dir === "" || dir === "/") return;
+        if (process.platform === "win32" && windowsDriveRegex.test(dir)) {
+          return;
+        }
+        if (nodeModulesRegex.test(dir)) return;
+        var pkgfile = path.join(maybeRealpathSync(realpathSync, dir, opts), "package.json");
+        if (!isFile(pkgfile)) {
+          return loadpkg(path.dirname(dir));
+        }
+        var pkg = readPackageSync(readFileSync10, pkgfile);
+        if (pkg && opts.packageFilter) {
+          pkg = opts.packageFilter(
+            pkg,
+            /*pkgfile,*/
+            dir
+          );
+        }
+        return { pkg, dir };
+      }
+      __name(loadpkg, "loadpkg");
+      function loadAsDirectorySync(x2) {
+        var pkgfile = path.join(maybeRealpathSync(realpathSync, x2, opts), "/package.json");
+        if (isFile(pkgfile)) {
+          try {
+            var pkg = readPackageSync(readFileSync10, pkgfile);
+          } catch (e) {
+          }
+          if (pkg && opts.packageFilter) {
+            pkg = opts.packageFilter(
+              pkg,
+              /*pkgfile,*/
+              x2
+            );
+          }
+          if (pkg && pkg.main) {
+            if (typeof pkg.main !== "string") {
+              var mainError = new TypeError("package \u201C" + pkg.name + "\u201D `main` must be a string");
+              mainError.code = "INVALID_PACKAGE_MAIN";
+              throw mainError;
+            }
+            if (pkg.main === "." || pkg.main === "./") {
+              pkg.main = "index";
+            }
+            try {
+              var m2 = loadAsFileSync(path.resolve(x2, pkg.main));
+              if (m2) return m2;
+              var n2 = loadAsDirectorySync(path.resolve(x2, pkg.main));
+              if (n2) return n2;
+            } catch (e) {
+            }
+          }
+        }
+        return loadAsFileSync(path.join(x2, "/index"));
+      }
+      __name(loadAsDirectorySync, "loadAsDirectorySync");
+      function loadNodeModulesSync(x2, start) {
+        var thunk = /* @__PURE__ */ __name(function() {
+          return getPackageCandidates(x2, start, opts);
+        }, "thunk");
+        var dirs = packageIterator ? packageIterator(x2, start, thunk, opts) : thunk();
+        for (var i = 0; i < dirs.length; i++) {
+          var dir = dirs[i];
+          if (isDirectory2(path.dirname(dir))) {
+            var m2 = loadAsFileSync(dir);
+            if (m2) return m2;
+            var n2 = loadAsDirectorySync(dir);
+            if (n2) return n2;
+          }
+        }
+      }
+      __name(loadNodeModulesSync, "loadNodeModulesSync");
+    }, "resolveSync");
+  }
+});
+
+// node_modules/resolve/index.js
+var require_resolve = __commonJS({
+  "node_modules/resolve/index.js"(exports, module) {
+    var async = require_async();
+    async.core = require_core3();
+    async.isCore = require_is_core();
+    async.sync = require_sync();
+    module.exports = async;
+  }
+});
 
 // ../node_modules/@yarnpkg/fslib/node_modules/tslib/tslib.es6.js
 var tslib_es6_exports = {};
@@ -135,12 +1403,12 @@ function __metadata(metadataKey, metadataValue) {
 }
 function __awaiter(thisArg, _arguments, P, generator) {
   function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve8) {
-      resolve8(value);
+    return value instanceof P ? value : new P(function(resolve9) {
+      resolve9(value);
     });
   }
   __name(adopt, "adopt");
-  return new (P || (P = Promise))(function(resolve8, reject) {
+  return new (P || (P = Promise))(function(resolve9, reject) {
     function fulfilled(value) {
       try {
         step(generator.next(value));
@@ -158,7 +1426,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
     }
     __name(rejected, "rejected");
     function step(result) {
-      result.done ? resolve8(result.value) : adopt(result.value).then(fulfilled, rejected);
+      result.done ? resolve9(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
     __name(step, "step");
     step((generator = generator.apply(thisArg, _arguments || [])).next());
@@ -346,15 +1614,15 @@ function __asyncValues(o) {
   }, i);
   function verb(n) {
     i[n] = o[n] && function(v) {
-      return new Promise(function(resolve8, reject) {
-        v = o[n](v), settle(resolve8, reject, v.done, v.value);
+      return new Promise(function(resolve9, reject) {
+        v = o[n](v), settle(resolve9, reject, v.done, v.value);
       });
     };
   }
   __name(verb, "verb");
-  function settle(resolve8, reject, d, v) {
+  function settle(resolve9, reject, d, v) {
     Promise.resolve(v).then(function(v2) {
-      resolve8({ value: v2, done: d });
+      resolve9({ value: v2, done: d });
     }, reject);
   }
   __name(settle, "settle");
@@ -1210,7 +2478,7 @@ var require_FakeFS = __commonJS({
               if (error.code !== `EBUSY` && error.code !== `ENOTEMPTY`) {
                 throw error;
               } else if (t2 < maxRetries) {
-                await new Promise((resolve8) => setTimeout(resolve8, t2 * 100));
+                await new Promise((resolve9) => setTimeout(resolve9, t2 * 100));
               }
             }
           }
@@ -1444,7 +2712,7 @@ var require_FakeFS = __commonJS({
                 }
               }
               if (Date.now() - startTime < 60 * 1e3) {
-                await new Promise((resolve8) => setTimeout(resolve8, interval));
+                await new Promise((resolve9) => setTimeout(resolve9, interval));
               } else {
                 throw new Error(`Couldn't acquire a lock in a reasonable time (via ${lockPath})`);
               }
@@ -1576,19 +2844,19 @@ var require_NodeFS = __commonJS({
         return path_1.ppath.resolve(p);
       }
       async openPromise(p, flags, mode) {
-        return await new Promise((resolve8, reject) => {
-          this.realFs.open(path_1.npath.fromPortablePath(p), flags, mode, this.makeCallback(resolve8, reject));
+        return await new Promise((resolve9, reject) => {
+          this.realFs.open(path_1.npath.fromPortablePath(p), flags, mode, this.makeCallback(resolve9, reject));
         });
       }
       openSync(p, flags, mode) {
         return this.realFs.openSync(path_1.npath.fromPortablePath(p), flags, mode);
       }
       async opendirPromise(p, opts) {
-        return await new Promise((resolve8, reject) => {
+        return await new Promise((resolve9, reject) => {
           if (typeof opts !== `undefined`) {
-            this.realFs.opendir(path_1.npath.fromPortablePath(p), opts, this.makeCallback(resolve8, reject));
+            this.realFs.opendir(path_1.npath.fromPortablePath(p), opts, this.makeCallback(resolve9, reject));
           } else {
-            this.realFs.opendir(path_1.npath.fromPortablePath(p), this.makeCallback(resolve8, reject));
+            this.realFs.opendir(path_1.npath.fromPortablePath(p), this.makeCallback(resolve9, reject));
           }
         }).then((dir) => {
           return Object.defineProperty(dir, `path`, { value: p, configurable: true, writable: true });
@@ -1599,12 +2867,12 @@ var require_NodeFS = __commonJS({
         return Object.defineProperty(dir, `path`, { value: p, configurable: true, writable: true });
       }
       async readPromise(fd, buffer, offset = 0, length = 0, position = -1) {
-        return await new Promise((resolve8, reject) => {
+        return await new Promise((resolve9, reject) => {
           this.realFs.read(fd, buffer, offset, length, position, (error, bytesRead) => {
             if (error) {
               reject(error);
             } else {
-              resolve8(bytesRead);
+              resolve9(bytesRead);
             }
           });
         });
@@ -1613,11 +2881,11 @@ var require_NodeFS = __commonJS({
         return this.realFs.readSync(fd, buffer, offset, length, position);
       }
       async writePromise(fd, buffer, offset, length, position) {
-        return await new Promise((resolve8, reject) => {
+        return await new Promise((resolve9, reject) => {
           if (typeof buffer === `string`) {
-            return this.realFs.write(fd, buffer, offset, this.makeCallback(resolve8, reject));
+            return this.realFs.write(fd, buffer, offset, this.makeCallback(resolve9, reject));
           } else {
-            return this.realFs.write(fd, buffer, offset, length, position, this.makeCallback(resolve8, reject));
+            return this.realFs.write(fd, buffer, offset, length, position, this.makeCallback(resolve9, reject));
           }
         });
       }
@@ -1629,8 +2897,8 @@ var require_NodeFS = __commonJS({
         }
       }
       async closePromise(fd) {
-        await new Promise((resolve8, reject) => {
-          this.realFs.close(fd, this.makeCallback(resolve8, reject));
+        await new Promise((resolve9, reject) => {
+          this.realFs.close(fd, this.makeCallback(resolve9, reject));
         });
       }
       closeSync(fd) {
@@ -1645,8 +2913,8 @@ var require_NodeFS = __commonJS({
         return this.realFs.createWriteStream(realPath, opts);
       }
       async realpathPromise(p) {
-        return await new Promise((resolve8, reject) => {
-          this.realFs.realpath(path_1.npath.fromPortablePath(p), {}, this.makeCallback(resolve8, reject));
+        return await new Promise((resolve9, reject) => {
+          this.realFs.realpath(path_1.npath.fromPortablePath(p), {}, this.makeCallback(resolve9, reject));
         }).then((path) => {
           return path_1.npath.toPortablePath(path);
         });
@@ -1655,27 +2923,27 @@ var require_NodeFS = __commonJS({
         return path_1.npath.toPortablePath(this.realFs.realpathSync(path_1.npath.fromPortablePath(p), {}));
       }
       async existsPromise(p) {
-        return await new Promise((resolve8) => {
-          this.realFs.exists(path_1.npath.fromPortablePath(p), resolve8);
+        return await new Promise((resolve9) => {
+          this.realFs.exists(path_1.npath.fromPortablePath(p), resolve9);
         });
       }
       accessSync(p, mode) {
         return this.realFs.accessSync(path_1.npath.fromPortablePath(p), mode);
       }
       async accessPromise(p, mode) {
-        return await new Promise((resolve8, reject) => {
-          this.realFs.access(path_1.npath.fromPortablePath(p), mode, this.makeCallback(resolve8, reject));
+        return await new Promise((resolve9, reject) => {
+          this.realFs.access(path_1.npath.fromPortablePath(p), mode, this.makeCallback(resolve9, reject));
         });
       }
       existsSync(p) {
         return this.realFs.existsSync(path_1.npath.fromPortablePath(p));
       }
       async statPromise(p, opts) {
-        return await new Promise((resolve8, reject) => {
+        return await new Promise((resolve9, reject) => {
           if (opts) {
-            this.realFs.stat(path_1.npath.fromPortablePath(p), opts, this.makeCallback(resolve8, reject));
+            this.realFs.stat(path_1.npath.fromPortablePath(p), opts, this.makeCallback(resolve9, reject));
           } else {
-            this.realFs.stat(path_1.npath.fromPortablePath(p), this.makeCallback(resolve8, reject));
+            this.realFs.stat(path_1.npath.fromPortablePath(p), this.makeCallback(resolve9, reject));
           }
         });
       }
@@ -1687,11 +2955,11 @@ var require_NodeFS = __commonJS({
         }
       }
       async fstatPromise(fd, opts) {
-        return await new Promise((resolve8, reject) => {
+        return await new Promise((resolve9, reject) => {
           if (opts) {
-            this.realFs.fstat(fd, opts, this.makeCallback(resolve8, reject));
+            this.realFs.fstat(fd, opts, this.makeCallback(resolve9, reject));
           } else {
-            this.realFs.fstat(fd, this.makeCallback(resolve8, reject));
+            this.realFs.fstat(fd, this.makeCallback(resolve9, reject));
           }
         });
       }
@@ -1703,11 +2971,11 @@ var require_NodeFS = __commonJS({
         }
       }
       async lstatPromise(p, opts) {
-        return await new Promise((resolve8, reject) => {
+        return await new Promise((resolve9, reject) => {
           if (opts) {
-            this.realFs.lstat(path_1.npath.fromPortablePath(p), opts, this.makeCallback(resolve8, reject));
+            this.realFs.lstat(path_1.npath.fromPortablePath(p), opts, this.makeCallback(resolve9, reject));
           } else {
-            this.realFs.lstat(path_1.npath.fromPortablePath(p), this.makeCallback(resolve8, reject));
+            this.realFs.lstat(path_1.npath.fromPortablePath(p), this.makeCallback(resolve9, reject));
           }
         });
       }
@@ -1719,60 +2987,60 @@ var require_NodeFS = __commonJS({
         }
       }
       async fchmodPromise(fd, mask) {
-        return await new Promise((resolve8, reject) => {
-          this.realFs.fchmod(fd, mask, this.makeCallback(resolve8, reject));
+        return await new Promise((resolve9, reject) => {
+          this.realFs.fchmod(fd, mask, this.makeCallback(resolve9, reject));
         });
       }
       fchmodSync(fd, mask) {
         return this.realFs.fchmodSync(fd, mask);
       }
       async chmodPromise(p, mask) {
-        return await new Promise((resolve8, reject) => {
-          this.realFs.chmod(path_1.npath.fromPortablePath(p), mask, this.makeCallback(resolve8, reject));
+        return await new Promise((resolve9, reject) => {
+          this.realFs.chmod(path_1.npath.fromPortablePath(p), mask, this.makeCallback(resolve9, reject));
         });
       }
       chmodSync(p, mask) {
         return this.realFs.chmodSync(path_1.npath.fromPortablePath(p), mask);
       }
       async fchownPromise(fd, uid, gid) {
-        return await new Promise((resolve8, reject) => {
-          this.realFs.fchown(fd, uid, gid, this.makeCallback(resolve8, reject));
+        return await new Promise((resolve9, reject) => {
+          this.realFs.fchown(fd, uid, gid, this.makeCallback(resolve9, reject));
         });
       }
       fchownSync(fd, uid, gid) {
         return this.realFs.fchownSync(fd, uid, gid);
       }
       async chownPromise(p, uid, gid) {
-        return await new Promise((resolve8, reject) => {
-          this.realFs.chown(path_1.npath.fromPortablePath(p), uid, gid, this.makeCallback(resolve8, reject));
+        return await new Promise((resolve9, reject) => {
+          this.realFs.chown(path_1.npath.fromPortablePath(p), uid, gid, this.makeCallback(resolve9, reject));
         });
       }
       chownSync(p, uid, gid) {
         return this.realFs.chownSync(path_1.npath.fromPortablePath(p), uid, gid);
       }
       async renamePromise(oldP, newP) {
-        return await new Promise((resolve8, reject) => {
-          this.realFs.rename(path_1.npath.fromPortablePath(oldP), path_1.npath.fromPortablePath(newP), this.makeCallback(resolve8, reject));
+        return await new Promise((resolve9, reject) => {
+          this.realFs.rename(path_1.npath.fromPortablePath(oldP), path_1.npath.fromPortablePath(newP), this.makeCallback(resolve9, reject));
         });
       }
       renameSync(oldP, newP) {
         return this.realFs.renameSync(path_1.npath.fromPortablePath(oldP), path_1.npath.fromPortablePath(newP));
       }
       async copyFilePromise(sourceP, destP, flags = 0) {
-        return await new Promise((resolve8, reject) => {
-          this.realFs.copyFile(path_1.npath.fromPortablePath(sourceP), path_1.npath.fromPortablePath(destP), flags, this.makeCallback(resolve8, reject));
+        return await new Promise((resolve9, reject) => {
+          this.realFs.copyFile(path_1.npath.fromPortablePath(sourceP), path_1.npath.fromPortablePath(destP), flags, this.makeCallback(resolve9, reject));
         });
       }
       copyFileSync(sourceP, destP, flags = 0) {
         return this.realFs.copyFileSync(path_1.npath.fromPortablePath(sourceP), path_1.npath.fromPortablePath(destP), flags);
       }
       async appendFilePromise(p, content, opts) {
-        return await new Promise((resolve8, reject) => {
+        return await new Promise((resolve9, reject) => {
           const fsNativePath = typeof p === `string` ? path_1.npath.fromPortablePath(p) : p;
           if (opts) {
-            this.realFs.appendFile(fsNativePath, content, opts, this.makeCallback(resolve8, reject));
+            this.realFs.appendFile(fsNativePath, content, opts, this.makeCallback(resolve9, reject));
           } else {
-            this.realFs.appendFile(fsNativePath, content, this.makeCallback(resolve8, reject));
+            this.realFs.appendFile(fsNativePath, content, this.makeCallback(resolve9, reject));
           }
         });
       }
@@ -1785,12 +3053,12 @@ var require_NodeFS = __commonJS({
         }
       }
       async writeFilePromise(p, content, opts) {
-        return await new Promise((resolve8, reject) => {
+        return await new Promise((resolve9, reject) => {
           const fsNativePath = typeof p === `string` ? path_1.npath.fromPortablePath(p) : p;
           if (opts) {
-            this.realFs.writeFile(fsNativePath, content, opts, this.makeCallback(resolve8, reject));
+            this.realFs.writeFile(fsNativePath, content, opts, this.makeCallback(resolve9, reject));
           } else {
-            this.realFs.writeFile(fsNativePath, content, this.makeCallback(resolve8, reject));
+            this.realFs.writeFile(fsNativePath, content, this.makeCallback(resolve9, reject));
           }
         });
       }
@@ -1803,16 +3071,16 @@ var require_NodeFS = __commonJS({
         }
       }
       async unlinkPromise(p) {
-        return await new Promise((resolve8, reject) => {
-          this.realFs.unlink(path_1.npath.fromPortablePath(p), this.makeCallback(resolve8, reject));
+        return await new Promise((resolve9, reject) => {
+          this.realFs.unlink(path_1.npath.fromPortablePath(p), this.makeCallback(resolve9, reject));
         });
       }
       unlinkSync(p) {
         return this.realFs.unlinkSync(path_1.npath.fromPortablePath(p));
       }
       async utimesPromise(p, atime, mtime) {
-        return await new Promise((resolve8, reject) => {
-          this.realFs.utimes(path_1.npath.fromPortablePath(p), atime, mtime, this.makeCallback(resolve8, reject));
+        return await new Promise((resolve9, reject) => {
+          this.realFs.utimes(path_1.npath.fromPortablePath(p), atime, mtime, this.makeCallback(resolve9, reject));
         });
       }
       utimesSync(p, atime, mtime) {
@@ -1822,8 +3090,8 @@ var require_NodeFS = __commonJS({
         const lutimes = this.realFs.lutimes;
         if (typeof lutimes === `undefined`)
           throw (0, errors_1.ENOSYS)(`unavailable Node binding`, `lutimes '${p}'`);
-        return await new Promise((resolve8, reject) => {
-          lutimes.call(this.realFs, path_1.npath.fromPortablePath(p), atime, mtime, this.makeCallback(resolve8, reject));
+        return await new Promise((resolve9, reject) => {
+          lutimes.call(this.realFs, path_1.npath.fromPortablePath(p), atime, mtime, this.makeCallback(resolve9, reject));
         });
       }
       lutimesSyncImpl(p, atime, mtime) {
@@ -1833,19 +3101,19 @@ var require_NodeFS = __commonJS({
         lutimesSync.call(this.realFs, path_1.npath.fromPortablePath(p), atime, mtime);
       }
       async mkdirPromise(p, opts) {
-        return await new Promise((resolve8, reject) => {
-          this.realFs.mkdir(path_1.npath.fromPortablePath(p), opts, this.makeCallback(resolve8, reject));
+        return await new Promise((resolve9, reject) => {
+          this.realFs.mkdir(path_1.npath.fromPortablePath(p), opts, this.makeCallback(resolve9, reject));
         });
       }
       mkdirSync(p, opts) {
         return this.realFs.mkdirSync(path_1.npath.fromPortablePath(p), opts);
       }
       async rmdirPromise(p, opts) {
-        return await new Promise((resolve8, reject) => {
+        return await new Promise((resolve9, reject) => {
           if (opts) {
-            this.realFs.rmdir(path_1.npath.fromPortablePath(p), opts, this.makeCallback(resolve8, reject));
+            this.realFs.rmdir(path_1.npath.fromPortablePath(p), opts, this.makeCallback(resolve9, reject));
           } else {
-            this.realFs.rmdir(path_1.npath.fromPortablePath(p), this.makeCallback(resolve8, reject));
+            this.realFs.rmdir(path_1.npath.fromPortablePath(p), this.makeCallback(resolve9, reject));
           }
         });
       }
@@ -1853,25 +3121,25 @@ var require_NodeFS = __commonJS({
         return this.realFs.rmdirSync(path_1.npath.fromPortablePath(p), opts);
       }
       async linkPromise(existingP, newP) {
-        return await new Promise((resolve8, reject) => {
-          this.realFs.link(path_1.npath.fromPortablePath(existingP), path_1.npath.fromPortablePath(newP), this.makeCallback(resolve8, reject));
+        return await new Promise((resolve9, reject) => {
+          this.realFs.link(path_1.npath.fromPortablePath(existingP), path_1.npath.fromPortablePath(newP), this.makeCallback(resolve9, reject));
         });
       }
       linkSync(existingP, newP) {
         return this.realFs.linkSync(path_1.npath.fromPortablePath(existingP), path_1.npath.fromPortablePath(newP));
       }
       async symlinkPromise(target, p, type) {
-        return await new Promise((resolve8, reject) => {
-          this.realFs.symlink(path_1.npath.fromPortablePath(target.replace(/\/+$/, ``)), path_1.npath.fromPortablePath(p), type, this.makeCallback(resolve8, reject));
+        return await new Promise((resolve9, reject) => {
+          this.realFs.symlink(path_1.npath.fromPortablePath(target.replace(/\/+$/, ``)), path_1.npath.fromPortablePath(p), type, this.makeCallback(resolve9, reject));
         });
       }
       symlinkSync(target, p, type) {
         return this.realFs.symlinkSync(path_1.npath.fromPortablePath(target.replace(/\/+$/, ``)), path_1.npath.fromPortablePath(p), type);
       }
       async readFilePromise(p, encoding) {
-        return await new Promise((resolve8, reject) => {
+        return await new Promise((resolve9, reject) => {
           const fsNativePath = typeof p === `string` ? path_1.npath.fromPortablePath(p) : p;
-          this.realFs.readFile(fsNativePath, encoding, this.makeCallback(resolve8, reject));
+          this.realFs.readFile(fsNativePath, encoding, this.makeCallback(resolve9, reject));
         });
       }
       readFileSync(p, encoding) {
@@ -1879,11 +3147,11 @@ var require_NodeFS = __commonJS({
         return this.realFs.readFileSync(fsNativePath, encoding);
       }
       async readdirPromise(p, opts) {
-        return await new Promise((resolve8, reject) => {
+        return await new Promise((resolve9, reject) => {
           if (opts === null || opts === void 0 ? void 0 : opts.withFileTypes) {
-            this.realFs.readdir(path_1.npath.fromPortablePath(p), { withFileTypes: true }, this.makeCallback(resolve8, reject));
+            this.realFs.readdir(path_1.npath.fromPortablePath(p), { withFileTypes: true }, this.makeCallback(resolve9, reject));
           } else {
-            this.realFs.readdir(path_1.npath.fromPortablePath(p), this.makeCallback((value) => resolve8(value), reject));
+            this.realFs.readdir(path_1.npath.fromPortablePath(p), this.makeCallback((value) => resolve9(value), reject));
           }
         });
       }
@@ -1895,8 +3163,8 @@ var require_NodeFS = __commonJS({
         }
       }
       async readlinkPromise(p) {
-        return await new Promise((resolve8, reject) => {
-          this.realFs.readlink(path_1.npath.fromPortablePath(p), this.makeCallback(resolve8, reject));
+        return await new Promise((resolve9, reject) => {
+          this.realFs.readlink(path_1.npath.fromPortablePath(p), this.makeCallback(resolve9, reject));
         }).then((path) => {
           return path_1.npath.toPortablePath(path);
         });
@@ -1905,16 +3173,16 @@ var require_NodeFS = __commonJS({
         return path_1.npath.toPortablePath(this.realFs.readlinkSync(path_1.npath.fromPortablePath(p)));
       }
       async truncatePromise(p, len) {
-        return await new Promise((resolve8, reject) => {
-          this.realFs.truncate(path_1.npath.fromPortablePath(p), len, this.makeCallback(resolve8, reject));
+        return await new Promise((resolve9, reject) => {
+          this.realFs.truncate(path_1.npath.fromPortablePath(p), len, this.makeCallback(resolve9, reject));
         });
       }
       truncateSync(p, len) {
         return this.realFs.truncateSync(path_1.npath.fromPortablePath(p), len);
       }
       async ftruncatePromise(fd, len) {
-        return await new Promise((resolve8, reject) => {
-          this.realFs.ftruncate(fd, len, this.makeCallback(resolve8, reject));
+        return await new Promise((resolve9, reject) => {
+          this.realFs.ftruncate(fd, len, this.makeCallback(resolve9, reject));
         });
       }
       ftruncateSync(fd, len) {
@@ -1939,12 +3207,12 @@ var require_NodeFS = __commonJS({
       unwatchFile(p, cb) {
         return this.realFs.unwatchFile(path_1.npath.fromPortablePath(p), cb);
       }
-      makeCallback(resolve8, reject) {
+      makeCallback(resolve9, reject) {
         return (err, result) => {
           if (err) {
             reject(err);
           } else {
-            resolve8(result);
+            resolve9(result);
           }
         };
       }
@@ -2877,13 +4145,13 @@ var require_ZipFS = __commonJS({
               this.fileSources.set(index, data);
               return data;
             } else if (opts.asyncDecompress) {
-              return new Promise((resolve8, reject) => {
+              return new Promise((resolve9, reject) => {
                 zlib_1.default.inflateRaw(data, (error, result) => {
                   if (error) {
                     reject(error);
                   } else {
                     this.fileSources.set(index, result);
-                    resolve8(result);
+                    resolve9(result);
                   }
                 });
               });
@@ -5203,8 +6471,8 @@ var require_FileHandle = __commonJS({
             this[kClosePromise] = void 0;
           });
         } else {
-          this[kClosePromise] = new Promise((resolve8, reject) => {
-            this[kCloseResolve] = resolve8;
+          this[kClosePromise] = new Promise((resolve9, reject) => {
+            this[kCloseResolve] = resolve9;
             this[kCloseReject] = reject;
           }).finally(() => {
             this[kClosePromise] = void 0;
@@ -5774,12 +7042,12 @@ function __metadata2(metadataKey, metadataValue) {
 }
 function __awaiter2(thisArg, _arguments, P, generator) {
   function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve8) {
-      resolve8(value);
+    return value instanceof P ? value : new P(function(resolve9) {
+      resolve9(value);
     });
   }
   __name(adopt, "adopt");
-  return new (P || (P = Promise))(function(resolve8, reject) {
+  return new (P || (P = Promise))(function(resolve9, reject) {
     function fulfilled(value) {
       try {
         step(generator.next(value));
@@ -5797,7 +7065,7 @@ function __awaiter2(thisArg, _arguments, P, generator) {
     }
     __name(rejected, "rejected");
     function step(result) {
-      result.done ? resolve8(result.value) : adopt(result.value).then(fulfilled, rejected);
+      result.done ? resolve9(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
     __name(step, "step");
     step((generator = generator.apply(thisArg, _arguments || [])).next());
@@ -5985,15 +7253,15 @@ function __asyncValues2(o) {
   }, i);
   function verb(n) {
     i[n] = o[n] && function(v) {
-      return new Promise(function(resolve8, reject) {
-        v = o[n](v), settle(resolve8, reject, v.done, v.value);
+      return new Promise(function(resolve9, reject) {
+        v = o[n](v), settle(resolve9, reject, v.done, v.value);
       });
     };
   }
   __name(verb, "verb");
-  function settle(resolve8, reject, d, v) {
+  function settle(resolve9, reject, d, v) {
     Promise.resolve(v).then(function(v2) {
-      resolve8({ value: v2, done: d });
+      resolve9({ value: v2, done: d });
     }, reject);
   }
   __name(settle, "settle");
@@ -6088,8 +7356,8 @@ var require_libzipSync = __commonJS({
         createModule2 = createModule2 || {};
         var Module = typeof createModule2 !== "undefined" ? createModule2 : {};
         var readyPromiseResolve, readyPromiseReject;
-        Module["ready"] = new Promise(function(resolve8, reject) {
-          readyPromiseResolve = resolve8;
+        Module["ready"] = new Promise(function(resolve9, reject) {
+          readyPromiseResolve = resolve9;
           readyPromiseReject = reject;
         });
         var moduleOverrides = {};
@@ -10536,7 +11804,7 @@ var require_makeInterface = __commonJS({
 });
 
 // ../node_modules/@yarnpkg/libzip/lib/sync.js
-var require_sync = __commonJS({
+var require_sync2 = __commonJS({
   "../node_modules/@yarnpkg/libzip/lib/sync.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -10566,21 +11834,48 @@ import { CriticalPresetLoadError } from "storybook/internal/server-errors";
 var import_ts_dedent2 = __toESM(require_dist(), 1);
 
 // src/common/utils/interpret-files.ts
+var import_resolve = __toESM(require_resolve(), 1);
 import { existsSync } from "node:fs";
+import { extname } from "node:path";
 var supportedExtensions = [
   ".js",
-  ".mjs",
-  ".cjs",
-  ".jsx",
   ".ts",
+  ".jsx",
+  ".tsx",
+  ".mjs",
   ".mts",
+  ".mtsx",
+  ".cjs",
   ".cts",
-  ".tsx"
+  ".ctsx"
 ];
 function getInterpretedFile(pathToFile) {
   return supportedExtensions.map((ext) => pathToFile.endsWith(ext) ? pathToFile : `${pathToFile}${ext}`).find((candidate) => existsSync(candidate));
 }
 __name(getInterpretedFile, "getInterpretedFile");
+function resolveImport(id, options) {
+  const mergedOptions = {
+    extensions: supportedExtensions,
+    packageFilter(pkg) {
+      if (pkg.module) {
+        pkg.main = pkg.module;
+      }
+      return pkg;
+    },
+    ...options
+  };
+  try {
+    return import_resolve.default.sync(id, { ...mergedOptions });
+  } catch (error) {
+    const ext = extname(id);
+    const newId = [".js", ".mjs", ".cjs"].includes(ext) ? `${id.slice(0, -2)}ts` : ext === ".jsx" ? `${id.slice(0, -3)}tsx` : null;
+    if (!newId) {
+      throw error;
+    }
+    return import_resolve.default.sync(newId, { ...mergedOptions, extensions: [] });
+  }
+}
+__name(resolveImport, "resolveImport");
 
 // src/common/utils/strip-abs-node-modules-path.ts
 import { posix, sep } from "node:path";
@@ -10595,19 +11890,19 @@ function stripAbsNodeModulesPath(absPath) {
 __name(stripAbsNodeModulesPath, "stripAbsNodeModulesPath");
 
 // src/common/utils/validate-configuration-files.ts
-import { resolve as resolve2 } from "node:path";
+import { resolve as resolve3 } from "node:path";
 import { once } from "storybook/internal/node-logger";
 import { MainFileMissingError } from "storybook/internal/server-errors";
 var import_ts_dedent = __toESM(require_dist(), 1);
 async function validateConfigurationFiles(configDir, cwd) {
   const extensionsPattern = `{${Array.from(supportedExtensions).join(",")}}`;
-  const mainConfigMatches = await glob(slash(resolve2(configDir, `main${extensionsPattern}`)), {
+  const mainConfigMatches = await glob(slash(resolve3(configDir, `main${extensionsPattern}`)), {
     cwd: cwd ?? process.cwd()
   });
   const [mainConfigPath] = mainConfigMatches;
   if (mainConfigMatches.length > 1) {
     once.warn(import_ts_dedent.dedent`
-      Multiple main files found in your configDir (${resolve2(configDir)}).
+      Multiple main files found in your configDir (${resolve3(configDir)}).
       Storybook will use the first one found and ignore the others. Please remove the extra files.
     `);
   }
@@ -11169,7 +12464,7 @@ import { dirname as dirname3, join as join6 } from "node:path";
 
 // src/common/js-package-manager/JsPackageManager.ts
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname2, isAbsolute, join as join5, resolve as resolve3 } from "node:path";
+import { dirname as dirname2, isAbsolute, join as join5, resolve as resolve4 } from "node:path";
 import { logger as logger2, prompt } from "storybook/internal/node-logger";
 var import_picocolors = __toESM(require_picocolors(), 1);
 import { gt, satisfies } from "semver";
@@ -11287,7 +12582,7 @@ var JsPackageManager = class _JsPackageManager {
     });
     const content = `${JSON.stringify(packageJsonToWrite, null, 2)}
 `;
-    writeFileSync2(resolve3(directory, "package.json"), content, "utf8");
+    writeFileSync2(resolve4(directory, "package.json"), content, "utf8");
   }
   getAllDependencies() {
     const allDependencies = {};
@@ -11708,7 +13003,7 @@ var JsPackageManager = class _JsPackageManager {
         return packageJsonPath;
       }
     }
-    return this.packageJsonPaths[0] ?? resolve3(this.cwd, "package.json");
+    return this.packageJsonPaths[0] ?? resolve4(this.cwd, "package.json");
   }
   /** List all package.json files starting from the given directory and stopping at the project root. */
   static listAllPackageJsonPaths(instanceDir, storiesPaths) {
@@ -11914,13 +13209,13 @@ var createLogStream = /* @__PURE__ */ __name(async (logFileName = "storybook.log
   const finalLogPath = join7(process.cwd(), logFileName);
   const temporaryLogPath = await temporaryFile({ name: logFileName });
   const logStream = createWriteStream(temporaryLogPath, { encoding: "utf8" });
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     logStream.once("open", () => {
       const clearLogFile = /* @__PURE__ */ __name(async () => writeFile2(temporaryLogPath, ""), "clearLogFile");
       const removeLogFile = /* @__PURE__ */ __name(async () => rm2(temporaryLogPath, { recursive: true, force: true }), "removeLogFile");
       const readLogFile = /* @__PURE__ */ __name(async () => readFile2(temporaryLogPath, { encoding: "utf8" }), "readLogFile");
       const moveLogFile = /* @__PURE__ */ __name(async () => copyFile(temporaryLogPath, finalLogPath).then(removeLogFile), "moveLogFile");
-      resolve8({ logStream, moveLogFile, clearLogFile, removeLogFile, readLogFile });
+      resolve9({ logStream, moveLogFile, clearLogFile, removeLogFile, readLogFile });
     });
     logStream.once("error", reject);
   });
@@ -12209,7 +13504,7 @@ __name(serverRequire, "serverRequire");
 // src/common/utils/load-main-config.ts
 var import_ts_dedent4 = __toESM(require_dist(), 1);
 import { readFile as readFile4, rm as rm3, writeFile as writeFile3 } from "node:fs/promises";
-import { join as join9, parse as parse2, relative, resolve as resolve4 } from "node:path";
+import { join as join9, parse as parse2, relative, resolve as resolve5 } from "node:path";
 import { logger as logger5 } from "storybook/internal/node-logger";
 import { MainFileEvaluationError } from "storybook/internal/server-errors";
 async function loadMainConfig({
@@ -12218,7 +13513,7 @@ async function loadMainConfig({
   skipCache
 }) {
   await validateConfigurationFiles(configDir, cwd);
-  const mainPath = getInterpretedFile(resolve4(configDir, "main"));
+  const mainPath = getInterpretedFile(resolve5(configDir, "main"));
   try {
     const out = await importModule(mainPath, { skipCache });
     return out;
@@ -12264,17 +13559,17 @@ __name(loadMainConfig, "loadMainConfig");
 
 // src/common/utils/load-manager-or-addons-file.ts
 var import_ts_dedent5 = __toESM(require_dist(), 1);
-import { resolve as resolve5 } from "node:path";
+import { resolve as resolve6 } from "node:path";
 import { logger as logger6 } from "storybook/internal/node-logger";
 function loadManagerOrAddonsFile({ configDir }) {
-  const storybookCustomAddonsPath = getInterpretedFile(resolve5(configDir, "addons"));
-  const storybookCustomManagerPath = getInterpretedFile(resolve5(configDir, "manager"));
+  const storybookCustomAddonsPath = getInterpretedFile(resolve6(configDir, "addons"));
+  const storybookCustomManagerPath = getInterpretedFile(resolve6(configDir, "manager"));
   if (storybookCustomAddonsPath || storybookCustomManagerPath) {
     logger6.info("=> Loading custom manager config");
   }
   if (storybookCustomAddonsPath && storybookCustomManagerPath) {
     throw new Error(import_ts_dedent5.dedent`
-      You have both a "addons.js" and a "manager.js", remove the "addons.js" file from your configDir (${resolve5(
+      You have both a "addons.js" and a "manager.js", remove the "addons.js" file from your configDir (${resolve6(
       configDir,
       "addons"
     )})`);
@@ -12285,13 +13580,13 @@ __name(loadManagerOrAddonsFile, "loadManagerOrAddonsFile");
 
 // src/common/utils/load-preview-or-config-file.ts
 var import_ts_dedent6 = __toESM(require_dist(), 1);
-import { resolve as resolve6 } from "node:path";
+import { resolve as resolve7 } from "node:path";
 function loadPreviewOrConfigFile({ configDir }) {
-  const storybookConfigPath = getInterpretedFile(resolve6(configDir, "config"));
-  const storybookPreviewPath = getInterpretedFile(resolve6(configDir, "preview"));
+  const storybookConfigPath = getInterpretedFile(resolve7(configDir, "config"));
+  const storybookPreviewPath = getInterpretedFile(resolve7(configDir, "preview"));
   if (storybookConfigPath && storybookPreviewPath) {
     throw new Error(import_ts_dedent6.dedent`
-      You have both a "config.js" and a "preview.js", remove the "config.js" file from your configDir (${resolve6(
+      You have both a "config.js" and a "preview.js", remove the "config.js" file from your configDir (${resolve7(
       configDir,
       "config"
     )})`);
@@ -12363,13 +13658,13 @@ __name(logConfig, "logConfig");
 // src/common/utils/normalize-stories.ts
 var pico2 = __toESM(require_picomatch(), 1);
 import { lstatSync } from "node:fs";
-import { basename, dirname as dirname5, relative as relative2, resolve as resolve7 } from "node:path";
+import { basename, dirname as dirname5, relative as relative2, resolve as resolve8 } from "node:path";
 import { InvalidStoriesEntryError } from "storybook/internal/server-errors";
 var DEFAULT_TITLE_PREFIX = "";
 var DEFAULT_FILES_PATTERN = "**/*.@(mdx|stories.@(js|jsx|mjs|ts|tsx))";
 var isDirectory = /* @__PURE__ */ __name((configDir, entry) => {
   try {
-    return lstatSync(resolve7(configDir, entry)).isDirectory();
+    return lstatSync(resolve8(configDir, entry)).isDirectory();
   } catch (err) {
     return false;
   }
@@ -12379,7 +13674,7 @@ var getDirectoryFromWorkingDir = /* @__PURE__ */ __name(({
   workingDir,
   directory
 }) => {
-  const directoryFromConfig = resolve7(configDir, directory);
+  const directoryFromConfig = resolve8(configDir, directory);
   const directoryFromWorking = relative2(workingDir, directoryFromConfig);
   return normalizeStoryPath(directoryFromWorking);
 }, "getDirectoryFromWorkingDir");
@@ -13704,7 +14999,7 @@ var Yarn1Proxy = class extends JsPackageManager {
 
 // src/common/js-package-manager/Yarn2Proxy.ts
 var import_fslib = __toESM(require_lib(), 1);
-var import_libzip = __toESM(require_sync(), 1);
+var import_libzip = __toESM(require_sync2(), 1);
 import { readFileSync as readFileSync9 } from "node:fs";
 import { join as join14 } from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
@@ -14164,7 +15459,7 @@ async function scanAndTransformFiles({
     initial: defaultGlob
   });
   console.log("Scanning for affected files...");
-  const globby = (await import("./globby-I54LIY47.js")).globby;
+  const globby = (await import("./globby-CVPDLQ5Z.js")).globby;
   const sourceFiles = await globby([glob2], {
     ...commonGlobOptions(""),
     ignore: ["**/node_modules/**"],
@@ -14194,7 +15489,7 @@ function transformImports(source, renamedImports) {
 __name(transformImports, "transformImports");
 var transformImportFiles = /* @__PURE__ */ __name(async (files, renamedImports, dryRun) => {
   const errors = [];
-  const { default: pLimit } = await import("./p-limit-2NBKFARM.js");
+  const { default: pLimit } = await import("./p-limit-I2XW6GST.js");
   const limit = pLimit(10);
   await Promise.all(
     files.map(
@@ -14214,11 +15509,30 @@ var transformImportFiles = /* @__PURE__ */ __name(async (files, renamedImports,
   return errors;
 }, "transformImportFiles");
 
+// src/common/utils/utils.ts
+var groupBy = /* @__PURE__ */ __name((items, keySelector) => {
+  return items.reduce(
+    (acc, item, index) => {
+      const key = keySelector(item, index);
+      acc[key] ??= [];
+      acc[key].push(item);
+      return acc;
+    },
+    {}
+  );
+}, "groupBy");
+function invariant2(condition, message) {
+  if (condition) {
+    return;
+  }
+  throw new Error((typeof message === "function" ? message() : message) ?? "Invariant failed");
+}
+__name(invariant2, "invariant");
+
 export {
-  userOrAutoTitleFromSpecifier,
-  up2 as up,
   supportedExtensions,
   getInterpretedFile,
+  resolveImport,
   validateConfigurationFiles,
   filterPresetsConfig,
   resolveAddonName,
@@ -14227,6 +15541,7 @@ export {
   loadAllPresets,
   FileSystemCache,
   createFileSystemCache,
+  up2 as up,
   resolvePathInStorybookCache,
   cache2 as cache,
   HandledError,
@@ -14282,6 +15597,7 @@ export {
   satisfies2 as satisfies,
   getPrettier,
   formatFileContent,
+  userOrAutoTitleFromSpecifier,
   posix3 as posix,
   getStoryId,
   getStoryTitle,
@@ -14290,5 +15606,7 @@ export {
   getSyncedStorybookAddons,
   JsPackageManagerFactory,
   scanAndTransformFiles,
-  transformImportFiles
+  transformImportFiles,
+  groupBy,
+  invariant2 as invariant
 };