@storybook/builder-vite 10.0.0-beta.3 → 10.0.0-beta.5

package/dist/index.js

@@ -1,10 +1,10 @@
-import CJS_COMPAT_NODE_URL_cgnweswu0xm from 'node:url';
-import CJS_COMPAT_NODE_PATH_cgnweswu0xm from 'node:path';
-import CJS_COMPAT_NODE_MODULE_cgnweswu0xm from "node:module";
+import CJS_COMPAT_NODE_URL_3n2ithg8g11 from 'node:url';
+import CJS_COMPAT_NODE_PATH_3n2ithg8g11 from 'node:path';
+import CJS_COMPAT_NODE_MODULE_3n2ithg8g11 from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_cgnweswu0xm.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_cgnweswu0xm.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_cgnweswu0xm.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_3n2ithg8g11.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_3n2ithg8g11.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_3n2ithg8g11.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
@@ -16,13 +16,7 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __commonJS = (cb, mod) => function __require2() {
+var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __copyProps = (to, from, except, desc) => {
@@ -188,7 +182,7 @@ var require_brace_expansion = __commonJS({
         var isSequence = isNumericSequence || isAlphaSequence;
         var isOptions = m.body.indexOf(",") >= 0;
         if (!isSequence && !isOptions) {
-          if (m.post.match(/,.*\}/)) {
+          if (m.post.match(/,(?!,).*\}/)) {
             str = m.pre + "{" + m.body + escClose + m.post;
             return expand2(str);
           }
@@ -263,1706 +257,6 @@ var require_brace_expansion = __commonJS({
   }
 });
 
-// ../../node_modules/commondir/index.js
-var require_commondir = __commonJS({
-  "../../node_modules/commondir/index.js"(exports, module) {
-    var path3 = __require("path");
-    module.exports = function(basedir, relfiles) {
-      if (relfiles) {
-        var files = relfiles.map(function(r) {
-          return path3.resolve(basedir, r);
-        });
-      } else {
-        var files = basedir;
-      }
-      var res = files.slice(1).reduce(function(ps, file) {
-        if (!file.match(/^([A-Za-z]:)?\/|\\/)) {
-          throw new Error("relative path without a basedir");
-        }
-        var xs = file.split(/\/+|\\+/);
-        for (var i = 0; ps[i] === xs[i] && i < Math.min(ps.length, xs.length); i++) ;
-        return ps.slice(0, i);
-      }, files[0].split(/\/+|\\+/));
-      return res.length > 1 ? res.join("/") : "/";
-    };
-  }
-});
-
-// ../../node_modules/p-try/index.js
-var require_p_try = __commonJS({
-  "../../node_modules/p-try/index.js"(exports, module) {
-    "use strict";
-    var pTry = /* @__PURE__ */ __name((fn, ...arguments_) => new Promise((resolve3) => {
-      resolve3(fn(...arguments_));
-    }), "pTry");
-    module.exports = pTry;
-    module.exports.default = pTry;
-  }
-});
-
-// ../../node_modules/find-cache-dir/node_modules/p-limit/index.js
-var require_p_limit = __commonJS({
-  "../../node_modules/find-cache-dir/node_modules/p-limit/index.js"(exports, module) {
-    "use strict";
-    var pTry = require_p_try();
-    var pLimit = /* @__PURE__ */ __name((concurrency) => {
-      if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
-        return Promise.reject(new TypeError("Expected `concurrency` to be a number from 1 and up"));
-      }
-      const queue = [];
-      let activeCount = 0;
-      const next = /* @__PURE__ */ __name(() => {
-        activeCount--;
-        if (queue.length > 0) {
-          queue.shift()();
-        }
-      }, "next");
-      const run = /* @__PURE__ */ __name((fn, resolve3, ...args) => {
-        activeCount++;
-        const result = pTry(fn, ...args);
-        resolve3(result);
-        result.then(next, next);
-      }, "run");
-      const enqueue = /* @__PURE__ */ __name((fn, resolve3, ...args) => {
-        if (activeCount < concurrency) {
-          run(fn, resolve3, ...args);
-        } else {
-          queue.push(run.bind(null, fn, resolve3, ...args));
-        }
-      }, "enqueue");
-      const generator = /* @__PURE__ */ __name((fn, ...args) => new Promise((resolve3) => enqueue(fn, resolve3, ...args)), "generator");
-      Object.defineProperties(generator, {
-        activeCount: {
-          get: /* @__PURE__ */ __name(() => activeCount, "get")
-        },
-        pendingCount: {
-          get: /* @__PURE__ */ __name(() => queue.length, "get")
-        },
-        clearQueue: {
-          value: /* @__PURE__ */ __name(() => {
-            queue.length = 0;
-          }, "value")
-        }
-      });
-      return generator;
-    }, "pLimit");
-    module.exports = pLimit;
-    module.exports.default = pLimit;
-  }
-});
-
-// ../../node_modules/find-cache-dir/node_modules/p-locate/index.js
-var require_p_locate = __commonJS({
-  "../../node_modules/find-cache-dir/node_modules/p-locate/index.js"(exports, module) {
-    "use strict";
-    var pLimit = require_p_limit();
-    var EndError = class extends Error {
-      static {
-        __name(this, "EndError");
-      }
-      constructor(value) {
-        super();
-        this.value = value;
-      }
-    };
-    var testElement = /* @__PURE__ */ __name(async (element, tester) => tester(await element), "testElement");
-    var finder = /* @__PURE__ */ __name(async (element) => {
-      const values = await Promise.all(element);
-      if (values[1] === true) {
-        throw new EndError(values[0]);
-      }
-      return false;
-    }, "finder");
-    var pLocate = /* @__PURE__ */ __name(async (iterable, tester, options) => {
-      options = {
-        concurrency: Infinity,
-        preserveOrder: true,
-        ...options
-      };
-      const limit = pLimit(options.concurrency);
-      const items = [...iterable].map((element) => [element, limit(testElement, element, tester)]);
-      const checkLimit = pLimit(options.preserveOrder ? 1 : Infinity);
-      try {
-        await Promise.all(items.map((element) => checkLimit(finder, element)));
-      } catch (error) {
-        if (error instanceof EndError) {
-          return error.value;
-        }
-        throw error;
-      }
-    }, "pLocate");
-    module.exports = pLocate;
-    module.exports.default = pLocate;
-  }
-});
-
-// ../../node_modules/find-cache-dir/node_modules/locate-path/index.js
-var require_locate_path = __commonJS({
-  "../../node_modules/find-cache-dir/node_modules/locate-path/index.js"(exports, module) {
-    "use strict";
-    var path3 = __require("path");
-    var fs = __require("fs");
-    var { promisify } = __require("util");
-    var pLocate = require_p_locate();
-    var fsStat = promisify(fs.stat);
-    var fsLStat = promisify(fs.lstat);
-    var typeMappings = {
-      directory: "isDirectory",
-      file: "isFile"
-    };
-    function checkType({ type }) {
-      if (type in typeMappings) {
-        return;
-      }
-      throw new Error(`Invalid type specified: ${type}`);
-    }
-    __name(checkType, "checkType");
-    var matchType = /* @__PURE__ */ __name((type, stat) => type === void 0 || stat[typeMappings[type]](), "matchType");
-    module.exports = async (paths, options) => {
-      options = {
-        cwd: process.cwd(),
-        type: "file",
-        allowSymlinks: true,
-        ...options
-      };
-      checkType(options);
-      const statFn = options.allowSymlinks ? fsStat : fsLStat;
-      return pLocate(paths, async (path_) => {
-        try {
-          const stat = await statFn(path3.resolve(options.cwd, path_));
-          return matchType(options.type, stat);
-        } catch (_) {
-          return false;
-        }
-      }, options);
-    };
-    module.exports.sync = (paths, options) => {
-      options = {
-        cwd: process.cwd(),
-        allowSymlinks: true,
-        type: "file",
-        ...options
-      };
-      checkType(options);
-      const statFn = options.allowSymlinks ? fs.statSync : fs.lstatSync;
-      for (const path_ of paths) {
-        try {
-          const stat = statFn(path3.resolve(options.cwd, path_));
-          if (matchType(options.type, stat)) {
-            return path_;
-          }
-        } catch (_) {
-        }
-      }
-    };
-  }
-});
-
-// ../../node_modules/find-cache-dir/node_modules/path-exists/index.js
-var require_path_exists = __commonJS({
-  "../../node_modules/find-cache-dir/node_modules/path-exists/index.js"(exports, module) {
-    "use strict";
-    var fs = __require("fs");
-    var { promisify } = __require("util");
-    var pAccess = promisify(fs.access);
-    module.exports = async (path3) => {
-      try {
-        await pAccess(path3);
-        return true;
-      } catch (_) {
-        return false;
-      }
-    };
-    module.exports.sync = (path3) => {
-      try {
-        fs.accessSync(path3);
-        return true;
-      } catch (_) {
-        return false;
-      }
-    };
-  }
-});
-
-// ../../node_modules/find-cache-dir/node_modules/find-up/index.js
-var require_find_up = __commonJS({
-  "../../node_modules/find-cache-dir/node_modules/find-up/index.js"(exports, module) {
-    "use strict";
-    var path3 = __require("path");
-    var locatePath = require_locate_path();
-    var pathExists = require_path_exists();
-    var stop = Symbol("findUp.stop");
-    module.exports = async (name, options = {}) => {
-      let directory = path3.resolve(options.cwd || "");
-      const { root } = path3.parse(directory);
-      const paths = [].concat(name);
-      const runMatcher = /* @__PURE__ */ __name(async (locateOptions) => {
-        if (typeof name !== "function") {
-          return locatePath(paths, locateOptions);
-        }
-        const foundPath = await name(locateOptions.cwd);
-        if (typeof foundPath === "string") {
-          return locatePath([foundPath], locateOptions);
-        }
-        return foundPath;
-      }, "runMatcher");
-      while (true) {
-        const foundPath = await runMatcher({ ...options, cwd: directory });
-        if (foundPath === stop) {
-          return;
-        }
-        if (foundPath) {
-          return path3.resolve(directory, foundPath);
-        }
-        if (directory === root) {
-          return;
-        }
-        directory = path3.dirname(directory);
-      }
-    };
-    module.exports.sync = (name, options = {}) => {
-      let directory = path3.resolve(options.cwd || "");
-      const { root } = path3.parse(directory);
-      const paths = [].concat(name);
-      const runMatcher = /* @__PURE__ */ __name((locateOptions) => {
-        if (typeof name !== "function") {
-          return locatePath.sync(paths, locateOptions);
-        }
-        const foundPath = name(locateOptions.cwd);
-        if (typeof foundPath === "string") {
-          return locatePath.sync([foundPath], locateOptions);
-        }
-        return foundPath;
-      }, "runMatcher");
-      while (true) {
-        const foundPath = runMatcher({ ...options, cwd: directory });
-        if (foundPath === stop) {
-          return;
-        }
-        if (foundPath) {
-          return path3.resolve(directory, foundPath);
-        }
-        if (directory === root) {
-          return;
-        }
-        directory = path3.dirname(directory);
-      }
-    };
-    module.exports.exists = pathExists;
-    module.exports.sync.exists = pathExists.sync;
-    module.exports.stop = stop;
-  }
-});
-
-// ../../node_modules/find-cache-dir/node_modules/pkg-dir/index.js
-var require_pkg_dir = __commonJS({
-  "../../node_modules/find-cache-dir/node_modules/pkg-dir/index.js"(exports, module) {
-    "use strict";
-    var path3 = __require("path");
-    var findUp = require_find_up();
-    var pkgDir = /* @__PURE__ */ __name(async (cwd2) => {
-      const filePath = await findUp("package.json", { cwd: cwd2 });
-      return filePath && path3.dirname(filePath);
-    }, "pkgDir");
-    module.exports = pkgDir;
-    module.exports.default = pkgDir;
-    module.exports.sync = (cwd2) => {
-      const filePath = findUp.sync("package.json", { cwd: cwd2 });
-      return filePath && path3.dirname(filePath);
-    };
-  }
-});
-
-// ../../node_modules/find-cache-dir/node_modules/semver/semver.js
-var require_semver = __commonJS({
-  "../../node_modules/find-cache-dir/node_modules/semver/semver.js"(exports, module) {
-    exports = module.exports = SemVer;
-    var debug;
-    if (typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG)) {
-      debug = /* @__PURE__ */ __name(function() {
-        var args = Array.prototype.slice.call(arguments, 0);
-        args.unshift("SEMVER");
-        console.log.apply(console, args);
-      }, "debug");
-    } else {
-      debug = /* @__PURE__ */ __name(function() {
-      }, "debug");
-    }
-    exports.SEMVER_SPEC_VERSION = "2.0.0";
-    var MAX_LENGTH = 256;
-    var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
-    9007199254740991;
-    var MAX_SAFE_COMPONENT_LENGTH = 16;
-    var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
-    var re = exports.re = [];
-    var safeRe = exports.safeRe = [];
-    var src = exports.src = [];
-    var t = exports.tokens = {};
-    var R = 0;
-    function tok(n2) {
-      t[n2] = R++;
-    }
-    __name(tok, "tok");
-    var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
-    var safeRegexReplacements = [
-      ["\\s", 1],
-      ["\\d", MAX_LENGTH],
-      [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
-    ];
-    function makeSafeRe(value) {
-      for (var i2 = 0; i2 < safeRegexReplacements.length; i2++) {
-        var token = safeRegexReplacements[i2][0];
-        var max = safeRegexReplacements[i2][1];
-        value = value.split(token + "*").join(token + "{0," + max + "}").split(token + "+").join(token + "{1," + max + "}");
-      }
-      return value;
-    }
-    __name(makeSafeRe, "makeSafeRe");
-    tok("NUMERICIDENTIFIER");
-    src[t.NUMERICIDENTIFIER] = "0|[1-9]\\d*";
-    tok("NUMERICIDENTIFIERLOOSE");
-    src[t.NUMERICIDENTIFIERLOOSE] = "\\d+";
-    tok("NONNUMERICIDENTIFIER");
-    src[t.NONNUMERICIDENTIFIER] = "\\d*[a-zA-Z-]" + LETTERDASHNUMBER + "*";
-    tok("MAINVERSION");
-    src[t.MAINVERSION] = "(" + src[t.NUMERICIDENTIFIER] + ")\\.(" + src[t.NUMERICIDENTIFIER] + ")\\.(" + src[t.NUMERICIDENTIFIER] + ")";
-    tok("MAINVERSIONLOOSE");
-    src[t.MAINVERSIONLOOSE] = "(" + src[t.NUMERICIDENTIFIERLOOSE] + ")\\.(" + src[t.NUMERICIDENTIFIERLOOSE] + ")\\.(" + src[t.NUMERICIDENTIFIERLOOSE] + ")";
-    tok("PRERELEASEIDENTIFIER");
-    src[t.PRERELEASEIDENTIFIER] = "(?:" + src[t.NUMERICIDENTIFIER] + "|" + src[t.NONNUMERICIDENTIFIER] + ")";
-    tok("PRERELEASEIDENTIFIERLOOSE");
-    src[t.PRERELEASEIDENTIFIERLOOSE] = "(?:" + src[t.NUMERICIDENTIFIERLOOSE] + "|" + src[t.NONNUMERICIDENTIFIER] + ")";
-    tok("PRERELEASE");
-    src[t.PRERELEASE] = "(?:-(" + src[t.PRERELEASEIDENTIFIER] + "(?:\\." + src[t.PRERELEASEIDENTIFIER] + ")*))";
-    tok("PRERELEASELOOSE");
-    src[t.PRERELEASELOOSE] = "(?:-?(" + src[t.PRERELEASEIDENTIFIERLOOSE] + "(?:\\." + src[t.PRERELEASEIDENTIFIERLOOSE] + ")*))";
-    tok("BUILDIDENTIFIER");
-    src[t.BUILDIDENTIFIER] = LETTERDASHNUMBER + "+";
-    tok("BUILD");
-    src[t.BUILD] = "(?:\\+(" + src[t.BUILDIDENTIFIER] + "(?:\\." + src[t.BUILDIDENTIFIER] + ")*))";
-    tok("FULL");
-    tok("FULLPLAIN");
-    src[t.FULLPLAIN] = "v?" + src[t.MAINVERSION] + src[t.PRERELEASE] + "?" + src[t.BUILD] + "?";
-    src[t.FULL] = "^" + src[t.FULLPLAIN] + "$";
-    tok("LOOSEPLAIN");
-    src[t.LOOSEPLAIN] = "[v=\\s]*" + src[t.MAINVERSIONLOOSE] + src[t.PRERELEASELOOSE] + "?" + src[t.BUILD] + "?";
-    tok("LOOSE");
-    src[t.LOOSE] = "^" + src[t.LOOSEPLAIN] + "$";
-    tok("GTLT");
-    src[t.GTLT] = "((?:<|>)?=?)";
-    tok("XRANGEIDENTIFIERLOOSE");
-    src[t.XRANGEIDENTIFIERLOOSE] = src[t.NUMERICIDENTIFIERLOOSE] + "|x|X|\\*";
-    tok("XRANGEIDENTIFIER");
-    src[t.XRANGEIDENTIFIER] = src[t.NUMERICIDENTIFIER] + "|x|X|\\*";
-    tok("XRANGEPLAIN");
-    src[t.XRANGEPLAIN] = "[v=\\s]*(" + src[t.XRANGEIDENTIFIER] + ")(?:\\.(" + src[t.XRANGEIDENTIFIER] + ")(?:\\.(" + src[t.XRANGEIDENTIFIER] + ")(?:" + src[t.PRERELEASE] + ")?" + src[t.BUILD] + "?)?)?";
-    tok("XRANGEPLAINLOOSE");
-    src[t.XRANGEPLAINLOOSE] = "[v=\\s]*(" + src[t.XRANGEIDENTIFIERLOOSE] + ")(?:\\.(" + src[t.XRANGEIDENTIFIERLOOSE] + ")(?:\\.(" + src[t.XRANGEIDENTIFIERLOOSE] + ")(?:" + src[t.PRERELEASELOOSE] + ")?" + src[t.BUILD] + "?)?)?";
-    tok("XRANGE");
-    src[t.XRANGE] = "^" + src[t.GTLT] + "\\s*" + src[t.XRANGEPLAIN] + "$";
-    tok("XRANGELOOSE");
-    src[t.XRANGELOOSE] = "^" + src[t.GTLT] + "\\s*" + src[t.XRANGEPLAINLOOSE] + "$";
-    tok("COERCE");
-    src[t.COERCE] = "(^|[^\\d])(\\d{1," + MAX_SAFE_COMPONENT_LENGTH + "})(?:\\.(\\d{1," + MAX_SAFE_COMPONENT_LENGTH + "}))?(?:\\.(\\d{1," + MAX_SAFE_COMPONENT_LENGTH + "}))?(?:$|[^\\d])";
-    tok("COERCERTL");
-    re[t.COERCERTL] = new RegExp(src[t.COERCE], "g");
-    safeRe[t.COERCERTL] = new RegExp(makeSafeRe(src[t.COERCE]), "g");
-    tok("LONETILDE");
-    src[t.LONETILDE] = "(?:~>?)";
-    tok("TILDETRIM");
-    src[t.TILDETRIM] = "(\\s*)" + src[t.LONETILDE] + "\\s+";
-    re[t.TILDETRIM] = new RegExp(src[t.TILDETRIM], "g");
-    safeRe[t.TILDETRIM] = new RegExp(makeSafeRe(src[t.TILDETRIM]), "g");
-    var tildeTrimReplace = "$1~";
-    tok("TILDE");
-    src[t.TILDE] = "^" + src[t.LONETILDE] + src[t.XRANGEPLAIN] + "$";
-    tok("TILDELOOSE");
-    src[t.TILDELOOSE] = "^" + src[t.LONETILDE] + src[t.XRANGEPLAINLOOSE] + "$";
-    tok("LONECARET");
-    src[t.LONECARET] = "(?:\\^)";
-    tok("CARETTRIM");
-    src[t.CARETTRIM] = "(\\s*)" + src[t.LONECARET] + "\\s+";
-    re[t.CARETTRIM] = new RegExp(src[t.CARETTRIM], "g");
-    safeRe[t.CARETTRIM] = new RegExp(makeSafeRe(src[t.CARETTRIM]), "g");
-    var caretTrimReplace = "$1^";
-    tok("CARET");
-    src[t.CARET] = "^" + src[t.LONECARET] + src[t.XRANGEPLAIN] + "$";
-    tok("CARETLOOSE");
-    src[t.CARETLOOSE] = "^" + src[t.LONECARET] + src[t.XRANGEPLAINLOOSE] + "$";
-    tok("COMPARATORLOOSE");
-    src[t.COMPARATORLOOSE] = "^" + src[t.GTLT] + "\\s*(" + src[t.LOOSEPLAIN] + ")$|^$";
-    tok("COMPARATOR");
-    src[t.COMPARATOR] = "^" + src[t.GTLT] + "\\s*(" + src[t.FULLPLAIN] + ")$|^$";
-    tok("COMPARATORTRIM");
-    src[t.COMPARATORTRIM] = "(\\s*)" + src[t.GTLT] + "\\s*(" + src[t.LOOSEPLAIN] + "|" + src[t.XRANGEPLAIN] + ")";
-    re[t.COMPARATORTRIM] = new RegExp(src[t.COMPARATORTRIM], "g");
-    safeRe[t.COMPARATORTRIM] = new RegExp(makeSafeRe(src[t.COMPARATORTRIM]), "g");
-    var comparatorTrimReplace = "$1$2$3";
-    tok("HYPHENRANGE");
-    src[t.HYPHENRANGE] = "^\\s*(" + src[t.XRANGEPLAIN] + ")\\s+-\\s+(" + src[t.XRANGEPLAIN] + ")\\s*$";
-    tok("HYPHENRANGELOOSE");
-    src[t.HYPHENRANGELOOSE] = "^\\s*(" + src[t.XRANGEPLAINLOOSE] + ")\\s+-\\s+(" + src[t.XRANGEPLAINLOOSE] + ")\\s*$";
-    tok("STAR");
-    src[t.STAR] = "(<|>)?=?\\s*\\*";
-    for (i = 0; i < R; i++) {
-      debug(i, src[i]);
-      if (!re[i]) {
-        re[i] = new RegExp(src[i]);
-        safeRe[i] = new RegExp(makeSafeRe(src[i]));
-      }
-    }
-    var i;
-    exports.parse = parse3;
-    function parse3(version, options) {
-      if (!options || typeof options !== "object") {
-        options = {
-          loose: !!options,
-          includePrerelease: false
-        };
-      }
-      if (version instanceof SemVer) {
-        return version;
-      }
-      if (typeof version !== "string") {
-        return null;
-      }
-      if (version.length > MAX_LENGTH) {
-        return null;
-      }
-      var r = options.loose ? safeRe[t.LOOSE] : safeRe[t.FULL];
-      if (!r.test(version)) {
-        return null;
-      }
-      try {
-        return new SemVer(version, options);
-      } catch (er) {
-        return null;
-      }
-    }
-    __name(parse3, "parse");
-    exports.valid = valid;
-    function valid(version, options) {
-      var v = parse3(version, options);
-      return v ? v.version : null;
-    }
-    __name(valid, "valid");
-    exports.clean = clean;
-    function clean(version, options) {
-      var s = parse3(version.trim().replace(/^[=v]+/, ""), options);
-      return s ? s.version : null;
-    }
-    __name(clean, "clean");
-    exports.SemVer = SemVer;
-    function SemVer(version, options) {
-      if (!options || typeof options !== "object") {
-        options = {
-          loose: !!options,
-          includePrerelease: false
-        };
-      }
-      if (version instanceof SemVer) {
-        if (version.loose === options.loose) {
-          return version;
-        } else {
-          version = version.version;
-        }
-      } else if (typeof version !== "string") {
-        throw new TypeError("Invalid Version: " + version);
-      }
-      if (version.length > MAX_LENGTH) {
-        throw new TypeError("version is longer than " + MAX_LENGTH + " characters");
-      }
-      if (!(this instanceof SemVer)) {
-        return new SemVer(version, options);
-      }
-      debug("SemVer", version, options);
-      this.options = options;
-      this.loose = !!options.loose;
-      var m = version.trim().match(options.loose ? safeRe[t.LOOSE] : safeRe[t.FULL]);
-      if (!m) {
-        throw new TypeError("Invalid Version: " + version);
-      }
-      this.raw = version;
-      this.major = +m[1];
-      this.minor = +m[2];
-      this.patch = +m[3];
-      if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
-        throw new TypeError("Invalid major version");
-      }
-      if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
-        throw new TypeError("Invalid minor version");
-      }
-      if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
-        throw new TypeError("Invalid patch version");
-      }
-      if (!m[4]) {
-        this.prerelease = [];
-      } else {
-        this.prerelease = m[4].split(".").map(function(id) {
-          if (/^[0-9]+$/.test(id)) {
-            var num = +id;
-            if (num >= 0 && num < MAX_SAFE_INTEGER) {
-              return num;
-            }
-          }
-          return id;
-        });
-      }
-      this.build = m[5] ? m[5].split(".") : [];
-      this.format();
-    }
-    __name(SemVer, "SemVer");
-    SemVer.prototype.format = function() {
-      this.version = this.major + "." + this.minor + "." + this.patch;
-      if (this.prerelease.length) {
-        this.version += "-" + this.prerelease.join(".");
-      }
-      return this.version;
-    };
-    SemVer.prototype.toString = function() {
-      return this.version;
-    };
-    SemVer.prototype.compare = function(other) {
-      debug("SemVer.compare", this.version, this.options, other);
-      if (!(other instanceof SemVer)) {
-        other = new SemVer(other, this.options);
-      }
-      return this.compareMain(other) || this.comparePre(other);
-    };
-    SemVer.prototype.compareMain = function(other) {
-      if (!(other instanceof SemVer)) {
-        other = new SemVer(other, this.options);
-      }
-      return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
-    };
-    SemVer.prototype.comparePre = function(other) {
-      if (!(other instanceof SemVer)) {
-        other = new SemVer(other, this.options);
-      }
-      if (this.prerelease.length && !other.prerelease.length) {
-        return -1;
-      } else if (!this.prerelease.length && other.prerelease.length) {
-        return 1;
-      } else if (!this.prerelease.length && !other.prerelease.length) {
-        return 0;
-      }
-      var i2 = 0;
-      do {
-        var a = this.prerelease[i2];
-        var b = other.prerelease[i2];
-        debug("prerelease compare", i2, a, b);
-        if (a === void 0 && b === void 0) {
-          return 0;
-        } else if (b === void 0) {
-          return 1;
-        } else if (a === void 0) {
-          return -1;
-        } else if (a === b) {
-          continue;
-        } else {
-          return compareIdentifiers(a, b);
-        }
-      } while (++i2);
-    };
-    SemVer.prototype.compareBuild = function(other) {
-      if (!(other instanceof SemVer)) {
-        other = new SemVer(other, this.options);
-      }
-      var i2 = 0;
-      do {
-        var a = this.build[i2];
-        var b = other.build[i2];
-        debug("prerelease compare", i2, a, b);
-        if (a === void 0 && b === void 0) {
-          return 0;
-        } else if (b === void 0) {
-          return 1;
-        } else if (a === void 0) {
-          return -1;
-        } else if (a === b) {
-          continue;
-        } else {
-          return compareIdentifiers(a, b);
-        }
-      } while (++i2);
-    };
-    SemVer.prototype.inc = function(release, identifier) {
-      switch (release) {
-        case "premajor":
-          this.prerelease.length = 0;
-          this.patch = 0;
-          this.minor = 0;
-          this.major++;
-          this.inc("pre", identifier);
-          break;
-        case "preminor":
-          this.prerelease.length = 0;
-          this.patch = 0;
-          this.minor++;
-          this.inc("pre", identifier);
-          break;
-        case "prepatch":
-          this.prerelease.length = 0;
-          this.inc("patch", identifier);
-          this.inc("pre", identifier);
-          break;
-        // If the input is a non-prerelease version, this acts the same as
-        // prepatch.
-        case "prerelease":
-          if (this.prerelease.length === 0) {
-            this.inc("patch", identifier);
-          }
-          this.inc("pre", identifier);
-          break;
-        case "major":
-          if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
-            this.major++;
-          }
-          this.minor = 0;
-          this.patch = 0;
-          this.prerelease = [];
-          break;
-        case "minor":
-          if (this.patch !== 0 || this.prerelease.length === 0) {
-            this.minor++;
-          }
-          this.patch = 0;
-          this.prerelease = [];
-          break;
-        case "patch":
-          if (this.prerelease.length === 0) {
-            this.patch++;
-          }
-          this.prerelease = [];
-          break;
-        // This probably shouldn't be used publicly.
-        // 1.0.0 "pre" would become 1.0.0-0 which is the wrong direction.
-        case "pre":
-          if (this.prerelease.length === 0) {
-            this.prerelease = [0];
-          } else {
-            var i2 = this.prerelease.length;
-            while (--i2 >= 0) {
-              if (typeof this.prerelease[i2] === "number") {
-                this.prerelease[i2]++;
-                i2 = -2;
-              }
-            }
-            if (i2 === -1) {
-              this.prerelease.push(0);
-            }
-          }
-          if (identifier) {
-            if (this.prerelease[0] === identifier) {
-              if (isNaN(this.prerelease[1])) {
-                this.prerelease = [identifier, 0];
-              }
-            } else {
-              this.prerelease = [identifier, 0];
-            }
-          }
-          break;
-        default:
-          throw new Error("invalid increment argument: " + release);
-      }
-      this.format();
-      this.raw = this.version;
-      return this;
-    };
-    exports.inc = inc;
-    function inc(version, release, loose, identifier) {
-      if (typeof loose === "string") {
-        identifier = loose;
-        loose = void 0;
-      }
-      try {
-        return new SemVer(version, loose).inc(release, identifier).version;
-      } catch (er) {
-        return null;
-      }
-    }
-    __name(inc, "inc");
-    exports.diff = diff;
-    function diff(version1, version2) {
-      if (eq(version1, version2)) {
-        return null;
-      } else {
-        var v1 = parse3(version1);
-        var v2 = parse3(version2);
-        var prefix = "";
-        if (v1.prerelease.length || v2.prerelease.length) {
-          prefix = "pre";
-          var defaultResult = "prerelease";
-        }
-        for (var key in v1) {
-          if (key === "major" || key === "minor" || key === "patch") {
-            if (v1[key] !== v2[key]) {
-              return prefix + key;
-            }
-          }
-        }
-        return defaultResult;
-      }
-    }
-    __name(diff, "diff");
-    exports.compareIdentifiers = compareIdentifiers;
-    var numeric = /^[0-9]+$/;
-    function compareIdentifiers(a, b) {
-      var anum = numeric.test(a);
-      var bnum = numeric.test(b);
-      if (anum && bnum) {
-        a = +a;
-        b = +b;
-      }
-      return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
-    }
-    __name(compareIdentifiers, "compareIdentifiers");
-    exports.rcompareIdentifiers = rcompareIdentifiers;
-    function rcompareIdentifiers(a, b) {
-      return compareIdentifiers(b, a);
-    }
-    __name(rcompareIdentifiers, "rcompareIdentifiers");
-    exports.major = major;
-    function major(a, loose) {
-      return new SemVer(a, loose).major;
-    }
-    __name(major, "major");
-    exports.minor = minor;
-    function minor(a, loose) {
-      return new SemVer(a, loose).minor;
-    }
-    __name(minor, "minor");
-    exports.patch = patch;
-    function patch(a, loose) {
-      return new SemVer(a, loose).patch;
-    }
-    __name(patch, "patch");
-    exports.compare = compare;
-    function compare(a, b, loose) {
-      return new SemVer(a, loose).compare(new SemVer(b, loose));
-    }
-    __name(compare, "compare");
-    exports.compareLoose = compareLoose;
-    function compareLoose(a, b) {
-      return compare(a, b, true);
-    }
-    __name(compareLoose, "compareLoose");
-    exports.compareBuild = compareBuild;
-    function compareBuild(a, b, loose) {
-      var versionA = new SemVer(a, loose);
-      var versionB = new SemVer(b, loose);
-      return versionA.compare(versionB) || versionA.compareBuild(versionB);
-    }
-    __name(compareBuild, "compareBuild");
-    exports.rcompare = rcompare;
-    function rcompare(a, b, loose) {
-      return compare(b, a, loose);
-    }
-    __name(rcompare, "rcompare");
-    exports.sort = sort;
-    function sort(list, loose) {
-      return list.sort(function(a, b) {
-        return exports.compareBuild(a, b, loose);
-      });
-    }
-    __name(sort, "sort");
-    exports.rsort = rsort;
-    function rsort(list, loose) {
-      return list.sort(function(a, b) {
-        return exports.compareBuild(b, a, loose);
-      });
-    }
-    __name(rsort, "rsort");
-    exports.gt = gt;
-    function gt(a, b, loose) {
-      return compare(a, b, loose) > 0;
-    }
-    __name(gt, "gt");
-    exports.lt = lt;
-    function lt(a, b, loose) {
-      return compare(a, b, loose) < 0;
-    }
-    __name(lt, "lt");
-    exports.eq = eq;
-    function eq(a, b, loose) {
-      return compare(a, b, loose) === 0;
-    }
-    __name(eq, "eq");
-    exports.neq = neq;
-    function neq(a, b, loose) {
-      return compare(a, b, loose) !== 0;
-    }
-    __name(neq, "neq");
-    exports.gte = gte;
-    function gte(a, b, loose) {
-      return compare(a, b, loose) >= 0;
-    }
-    __name(gte, "gte");
-    exports.lte = lte;
-    function lte(a, b, loose) {
-      return compare(a, b, loose) <= 0;
-    }
-    __name(lte, "lte");
-    exports.cmp = cmp;
-    function cmp(a, op, b, loose) {
-      switch (op) {
-        case "===":
-          if (typeof a === "object")
-            a = a.version;
-          if (typeof b === "object")
-            b = b.version;
-          return a === b;
-        case "!==":
-          if (typeof a === "object")
-            a = a.version;
-          if (typeof b === "object")
-            b = b.version;
-          return a !== b;
-        case "":
-        case "=":
-        case "==":
-          return eq(a, b, loose);
-        case "!=":
-          return neq(a, b, loose);
-        case ">":
-          return gt(a, b, loose);
-        case ">=":
-          return gte(a, b, loose);
-        case "<":
-          return lt(a, b, loose);
-        case "<=":
-          return lte(a, b, loose);
-        default:
-          throw new TypeError("Invalid operator: " + op);
-      }
-    }
-    __name(cmp, "cmp");
-    exports.Comparator = Comparator;
-    function Comparator(comp, options) {
-      if (!options || typeof options !== "object") {
-        options = {
-          loose: !!options,
-          includePrerelease: false
-        };
-      }
-      if (comp instanceof Comparator) {
-        if (comp.loose === !!options.loose) {
-          return comp;
-        } else {
-          comp = comp.value;
-        }
-      }
-      if (!(this instanceof Comparator)) {
-        return new Comparator(comp, options);
-      }
-      comp = comp.trim().split(/\s+/).join(" ");
-      debug("comparator", comp, options);
-      this.options = options;
-      this.loose = !!options.loose;
-      this.parse(comp);
-      if (this.semver === ANY) {
-        this.value = "";
-      } else {
-        this.value = this.operator + this.semver.version;
-      }
-      debug("comp", this);
-    }
-    __name(Comparator, "Comparator");
-    var ANY = {};
-    Comparator.prototype.parse = function(comp) {
-      var r = this.options.loose ? safeRe[t.COMPARATORLOOSE] : safeRe[t.COMPARATOR];
-      var m = comp.match(r);
-      if (!m) {
-        throw new TypeError("Invalid comparator: " + comp);
-      }
-      this.operator = m[1] !== void 0 ? m[1] : "";
-      if (this.operator === "=") {
-        this.operator = "";
-      }
-      if (!m[2]) {
-        this.semver = ANY;
-      } else {
-        this.semver = new SemVer(m[2], this.options.loose);
-      }
-    };
-    Comparator.prototype.toString = function() {
-      return this.value;
-    };
-    Comparator.prototype.test = function(version) {
-      debug("Comparator.test", version, this.options.loose);
-      if (this.semver === ANY || version === ANY) {
-        return true;
-      }
-      if (typeof version === "string") {
-        try {
-          version = new SemVer(version, this.options);
-        } catch (er) {
-          return false;
-        }
-      }
-      return cmp(version, this.operator, this.semver, this.options);
-    };
-    Comparator.prototype.intersects = function(comp, options) {
-      if (!(comp instanceof Comparator)) {
-        throw new TypeError("a Comparator is required");
-      }
-      if (!options || typeof options !== "object") {
-        options = {
-          loose: !!options,
-          includePrerelease: false
-        };
-      }
-      var rangeTmp;
-      if (this.operator === "") {
-        if (this.value === "") {
-          return true;
-        }
-        rangeTmp = new Range(comp.value, options);
-        return satisfies(this.value, rangeTmp, options);
-      } else if (comp.operator === "") {
-        if (comp.value === "") {
-          return true;
-        }
-        rangeTmp = new Range(this.value, options);
-        return satisfies(comp.semver, rangeTmp, options);
-      }
-      var sameDirectionIncreasing = (this.operator === ">=" || this.operator === ">") && (comp.operator === ">=" || comp.operator === ">");
-      var sameDirectionDecreasing = (this.operator === "<=" || this.operator === "<") && (comp.operator === "<=" || comp.operator === "<");
-      var sameSemVer = this.semver.version === comp.semver.version;
-      var differentDirectionsInclusive = (this.operator === ">=" || this.operator === "<=") && (comp.operator === ">=" || comp.operator === "<=");
-      var oppositeDirectionsLessThan = cmp(this.semver, "<", comp.semver, options) && ((this.operator === ">=" || this.operator === ">") && (comp.operator === "<=" || comp.operator === "<"));
-      var oppositeDirectionsGreaterThan = cmp(this.semver, ">", comp.semver, options) && ((this.operator === "<=" || this.operator === "<") && (comp.operator === ">=" || comp.operator === ">"));
-      return sameDirectionIncreasing || sameDirectionDecreasing || sameSemVer && differentDirectionsInclusive || oppositeDirectionsLessThan || oppositeDirectionsGreaterThan;
-    };
-    exports.Range = Range;
-    function Range(range, options) {
-      if (!options || typeof options !== "object") {
-        options = {
-          loose: !!options,
-          includePrerelease: false
-        };
-      }
-      if (range instanceof Range) {
-        if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
-          return range;
-        } else {
-          return new Range(range.raw, options);
-        }
-      }
-      if (range instanceof Comparator) {
-        return new Range(range.value, options);
-      }
-      if (!(this instanceof Range)) {
-        return new Range(range, options);
-      }
-      this.options = options;
-      this.loose = !!options.loose;
-      this.includePrerelease = !!options.includePrerelease;
-      this.raw = range.trim().split(/\s+/).join(" ");
-      this.set = this.raw.split("||").map(function(range2) {
-        return this.parseRange(range2.trim());
-      }, this).filter(function(c) {
-        return c.length;
-      });
-      if (!this.set.length) {
-        throw new TypeError("Invalid SemVer Range: " + this.raw);
-      }
-      this.format();
-    }
-    __name(Range, "Range");
-    Range.prototype.format = function() {
-      this.range = this.set.map(function(comps) {
-        return comps.join(" ").trim();
-      }).join("||").trim();
-      return this.range;
-    };
-    Range.prototype.toString = function() {
-      return this.range;
-    };
-    Range.prototype.parseRange = function(range) {
-      var loose = this.options.loose;
-      var hr = loose ? safeRe[t.HYPHENRANGELOOSE] : safeRe[t.HYPHENRANGE];
-      range = range.replace(hr, hyphenReplace);
-      debug("hyphen replace", range);
-      range = range.replace(safeRe[t.COMPARATORTRIM], comparatorTrimReplace);
-      debug("comparator trim", range, safeRe[t.COMPARATORTRIM]);
-      range = range.replace(safeRe[t.TILDETRIM], tildeTrimReplace);
-      range = range.replace(safeRe[t.CARETTRIM], caretTrimReplace);
-      range = range.split(/\s+/).join(" ");
-      var compRe = loose ? safeRe[t.COMPARATORLOOSE] : safeRe[t.COMPARATOR];
-      var set = range.split(" ").map(function(comp) {
-        return parseComparator(comp, this.options);
-      }, this).join(" ").split(/\s+/);
-      if (this.options.loose) {
-        set = set.filter(function(comp) {
-          return !!comp.match(compRe);
-        });
-      }
-      set = set.map(function(comp) {
-        return new Comparator(comp, this.options);
-      }, this);
-      return set;
-    };
-    Range.prototype.intersects = function(range, options) {
-      if (!(range instanceof Range)) {
-        throw new TypeError("a Range is required");
-      }
-      return this.set.some(function(thisComparators) {
-        return isSatisfiable(thisComparators, options) && range.set.some(function(rangeComparators) {
-          return isSatisfiable(rangeComparators, options) && thisComparators.every(function(thisComparator) {
-            return rangeComparators.every(function(rangeComparator) {
-              return thisComparator.intersects(rangeComparator, options);
-            });
-          });
-        });
-      });
-    };
-    function isSatisfiable(comparators, options) {
-      var result = true;
-      var remainingComparators = comparators.slice();
-      var testComparator = remainingComparators.pop();
-      while (result && remainingComparators.length) {
-        result = remainingComparators.every(function(otherComparator) {
-          return testComparator.intersects(otherComparator, options);
-        });
-        testComparator = remainingComparators.pop();
-      }
-      return result;
-    }
-    __name(isSatisfiable, "isSatisfiable");
-    exports.toComparators = toComparators;
-    function toComparators(range, options) {
-      return new Range(range, options).set.map(function(comp) {
-        return comp.map(function(c) {
-          return c.value;
-        }).join(" ").trim().split(" ");
-      });
-    }
-    __name(toComparators, "toComparators");
-    function parseComparator(comp, options) {
-      debug("comp", comp, options);
-      comp = replaceCarets(comp, options);
-      debug("caret", comp);
-      comp = replaceTildes(comp, options);
-      debug("tildes", comp);
-      comp = replaceXRanges(comp, options);
-      debug("xrange", comp);
-      comp = replaceStars(comp, options);
-      debug("stars", comp);
-      return comp;
-    }
-    __name(parseComparator, "parseComparator");
-    function isX(id) {
-      return !id || id.toLowerCase() === "x" || id === "*";
-    }
-    __name(isX, "isX");
-    function replaceTildes(comp, options) {
-      return comp.trim().split(/\s+/).map(function(comp2) {
-        return replaceTilde(comp2, options);
-      }).join(" ");
-    }
-    __name(replaceTildes, "replaceTildes");
-    function replaceTilde(comp, options) {
-      var r = options.loose ? safeRe[t.TILDELOOSE] : safeRe[t.TILDE];
-      return comp.replace(r, function(_, M, m, p, pr) {
-        debug("tilde", comp, _, M, m, p, pr);
-        var ret;
-        if (isX(M)) {
-          ret = "";
-        } else if (isX(m)) {
-          ret = ">=" + M + ".0.0 <" + (+M + 1) + ".0.0";
-        } else if (isX(p)) {
-          ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
-        } else if (pr) {
-          debug("replaceTilde pr", pr);
-          ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + (+m + 1) + ".0";
-        } else {
-          ret = ">=" + M + "." + m + "." + p + " <" + M + "." + (+m + 1) + ".0";
-        }
-        debug("tilde return", ret);
-        return ret;
-      });
-    }
-    __name(replaceTilde, "replaceTilde");
-    function replaceCarets(comp, options) {
-      return comp.trim().split(/\s+/).map(function(comp2) {
-        return replaceCaret(comp2, options);
-      }).join(" ");
-    }
-    __name(replaceCarets, "replaceCarets");
-    function replaceCaret(comp, options) {
-      debug("caret", comp, options);
-      var r = options.loose ? safeRe[t.CARETLOOSE] : safeRe[t.CARET];
-      return comp.replace(r, function(_, M, m, p, pr) {
-        debug("caret", comp, _, M, m, p, pr);
-        var ret;
-        if (isX(M)) {
-          ret = "";
-        } else if (isX(m)) {
-          ret = ">=" + M + ".0.0 <" + (+M + 1) + ".0.0";
-        } else if (isX(p)) {
-          if (M === "0") {
-            ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
-          } else {
-            ret = ">=" + M + "." + m + ".0 <" + (+M + 1) + ".0.0";
-          }
-        } else if (pr) {
-          debug("replaceCaret pr", pr);
-          if (M === "0") {
-            if (m === "0") {
-              ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + m + "." + (+p + 1);
-            } else {
-              ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + (+m + 1) + ".0";
-            }
-          } else {
-            ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + (+M + 1) + ".0.0";
-          }
-        } else {
-          debug("no pr");
-          if (M === "0") {
-            if (m === "0") {
-              ret = ">=" + M + "." + m + "." + p + " <" + M + "." + m + "." + (+p + 1);
-            } else {
-              ret = ">=" + M + "." + m + "." + p + " <" + M + "." + (+m + 1) + ".0";
-            }
-          } else {
-            ret = ">=" + M + "." + m + "." + p + " <" + (+M + 1) + ".0.0";
-          }
-        }
-        debug("caret return", ret);
-        return ret;
-      });
-    }
-    __name(replaceCaret, "replaceCaret");
-    function replaceXRanges(comp, options) {
-      debug("replaceXRanges", comp, options);
-      return comp.split(/\s+/).map(function(comp2) {
-        return replaceXRange(comp2, options);
-      }).join(" ");
-    }
-    __name(replaceXRanges, "replaceXRanges");
-    function replaceXRange(comp, options) {
-      comp = comp.trim();
-      var r = options.loose ? safeRe[t.XRANGELOOSE] : safeRe[t.XRANGE];
-      return comp.replace(r, function(ret, gtlt, M, m, p, pr) {
-        debug("xRange", comp, ret, gtlt, M, m, p, pr);
-        var xM = isX(M);
-        var xm = xM || isX(m);
-        var xp = xm || isX(p);
-        var anyX = xp;
-        if (gtlt === "=" && anyX) {
-          gtlt = "";
-        }
-        pr = options.includePrerelease ? "-0" : "";
-        if (xM) {
-          if (gtlt === ">" || gtlt === "<") {
-            ret = "<0.0.0-0";
-          } else {
-            ret = "*";
-          }
-        } else if (gtlt && anyX) {
-          if (xm) {
-            m = 0;
-          }
-          p = 0;
-          if (gtlt === ">") {
-            gtlt = ">=";
-            if (xm) {
-              M = +M + 1;
-              m = 0;
-              p = 0;
-            } else {
-              m = +m + 1;
-              p = 0;
-            }
-          } else if (gtlt === "<=") {
-            gtlt = "<";
-            if (xm) {
-              M = +M + 1;
-            } else {
-              m = +m + 1;
-            }
-          }
-          ret = gtlt + M + "." + m + "." + p + pr;
-        } else if (xm) {
-          ret = ">=" + M + ".0.0" + pr + " <" + (+M + 1) + ".0.0" + pr;
-        } else if (xp) {
-          ret = ">=" + M + "." + m + ".0" + pr + " <" + M + "." + (+m + 1) + ".0" + pr;
-        }
-        debug("xRange return", ret);
-        return ret;
-      });
-    }
-    __name(replaceXRange, "replaceXRange");
-    function replaceStars(comp, options) {
-      debug("replaceStars", comp, options);
-      return comp.trim().replace(safeRe[t.STAR], "");
-    }
-    __name(replaceStars, "replaceStars");
-    function hyphenReplace($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) {
-      if (isX(fM)) {
-        from = "";
-      } else if (isX(fm)) {
-        from = ">=" + fM + ".0.0";
-      } else if (isX(fp)) {
-        from = ">=" + fM + "." + fm + ".0";
-      } else {
-        from = ">=" + from;
-      }
-      if (isX(tM)) {
-        to = "";
-      } else if (isX(tm)) {
-        to = "<" + (+tM + 1) + ".0.0";
-      } else if (isX(tp)) {
-        to = "<" + tM + "." + (+tm + 1) + ".0";
-      } else if (tpr) {
-        to = "<=" + tM + "." + tm + "." + tp + "-" + tpr;
-      } else {
-        to = "<=" + to;
-      }
-      return (from + " " + to).trim();
-    }
-    __name(hyphenReplace, "hyphenReplace");
-    Range.prototype.test = function(version) {
-      if (!version) {
-        return false;
-      }
-      if (typeof version === "string") {
-        try {
-          version = new SemVer(version, this.options);
-        } catch (er) {
-          return false;
-        }
-      }
-      for (var i2 = 0; i2 < this.set.length; i2++) {
-        if (testSet(this.set[i2], version, this.options)) {
-          return true;
-        }
-      }
-      return false;
-    };
-    function testSet(set, version, options) {
-      for (var i2 = 0; i2 < set.length; i2++) {
-        if (!set[i2].test(version)) {
-          return false;
-        }
-      }
-      if (version.prerelease.length && !options.includePrerelease) {
-        for (i2 = 0; i2 < set.length; i2++) {
-          debug(set[i2].semver);
-          if (set[i2].semver === ANY) {
-            continue;
-          }
-          if (set[i2].semver.prerelease.length > 0) {
-            var allowed = set[i2].semver;
-            if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
-              return true;
-            }
-          }
-        }
-        return false;
-      }
-      return true;
-    }
-    __name(testSet, "testSet");
-    exports.satisfies = satisfies;
-    function satisfies(version, range, options) {
-      try {
-        range = new Range(range, options);
-      } catch (er) {
-        return false;
-      }
-      return range.test(version);
-    }
-    __name(satisfies, "satisfies");
-    exports.maxSatisfying = maxSatisfying;
-    function maxSatisfying(versions, range, options) {
-      var max = null;
-      var maxSV = null;
-      try {
-        var rangeObj = new Range(range, options);
-      } catch (er) {
-        return null;
-      }
-      versions.forEach(function(v) {
-        if (rangeObj.test(v)) {
-          if (!max || maxSV.compare(v) === -1) {
-            max = v;
-            maxSV = new SemVer(max, options);
-          }
-        }
-      });
-      return max;
-    }
-    __name(maxSatisfying, "maxSatisfying");
-    exports.minSatisfying = minSatisfying;
-    function minSatisfying(versions, range, options) {
-      var min = null;
-      var minSV = null;
-      try {
-        var rangeObj = new Range(range, options);
-      } catch (er) {
-        return null;
-      }
-      versions.forEach(function(v) {
-        if (rangeObj.test(v)) {
-          if (!min || minSV.compare(v) === 1) {
-            min = v;
-            minSV = new SemVer(min, options);
-          }
-        }
-      });
-      return min;
-    }
-    __name(minSatisfying, "minSatisfying");
-    exports.minVersion = minVersion;
-    function minVersion(range, loose) {
-      range = new Range(range, loose);
-      var minver = new SemVer("0.0.0");
-      if (range.test(minver)) {
-        return minver;
-      }
-      minver = new SemVer("0.0.0-0");
-      if (range.test(minver)) {
-        return minver;
-      }
-      minver = null;
-      for (var i2 = 0; i2 < range.set.length; ++i2) {
-        var comparators = range.set[i2];
-        comparators.forEach(function(comparator) {
-          var compver = new SemVer(comparator.semver.version);
-          switch (comparator.operator) {
-            case ">":
-              if (compver.prerelease.length === 0) {
-                compver.patch++;
-              } else {
-                compver.prerelease.push(0);
-              }
-              compver.raw = compver.format();
-            /* fallthrough */
-            case "":
-            case ">=":
-              if (!minver || gt(minver, compver)) {
-                minver = compver;
-              }
-              break;
-            case "<":
-            case "<=":
-              break;
-            /* istanbul ignore next */
-            default:
-              throw new Error("Unexpected operation: " + comparator.operator);
-          }
-        });
-      }
-      if (minver && range.test(minver)) {
-        return minver;
-      }
-      return null;
-    }
-    __name(minVersion, "minVersion");
-    exports.validRange = validRange;
-    function validRange(range, options) {
-      try {
-        return new Range(range, options).range || "*";
-      } catch (er) {
-        return null;
-      }
-    }
-    __name(validRange, "validRange");
-    exports.ltr = ltr;
-    function ltr(version, range, options) {
-      return outside(version, range, "<", options);
-    }
-    __name(ltr, "ltr");
-    exports.gtr = gtr;
-    function gtr(version, range, options) {
-      return outside(version, range, ">", options);
-    }
-    __name(gtr, "gtr");
-    exports.outside = outside;
-    function outside(version, range, hilo, options) {
-      version = new SemVer(version, options);
-      range = new Range(range, options);
-      var gtfn, ltefn, ltfn, comp, ecomp;
-      switch (hilo) {
-        case ">":
-          gtfn = gt;
-          ltefn = lte;
-          ltfn = lt;
-          comp = ">";
-          ecomp = ">=";
-          break;
-        case "<":
-          gtfn = lt;
-          ltefn = gte;
-          ltfn = gt;
-          comp = "<";
-          ecomp = "<=";
-          break;
-        default:
-          throw new TypeError('Must provide a hilo val of "<" or ">"');
-      }
-      if (satisfies(version, range, options)) {
-        return false;
-      }
-      for (var i2 = 0; i2 < range.set.length; ++i2) {
-        var comparators = range.set[i2];
-        var high = null;
-        var low = null;
-        comparators.forEach(function(comparator) {
-          if (comparator.semver === ANY) {
-            comparator = new Comparator(">=0.0.0");
-          }
-          high = high || comparator;
-          low = low || comparator;
-          if (gtfn(comparator.semver, high.semver, options)) {
-            high = comparator;
-          } else if (ltfn(comparator.semver, low.semver, options)) {
-            low = comparator;
-          }
-        });
-        if (high.operator === comp || high.operator === ecomp) {
-          return false;
-        }
-        if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) {
-          return false;
-        } else if (low.operator === ecomp && ltfn(version, low.semver)) {
-          return false;
-        }
-      }
-      return true;
-    }
-    __name(outside, "outside");
-    exports.prerelease = prerelease;
-    function prerelease(version, options) {
-      var parsed = parse3(version, options);
-      return parsed && parsed.prerelease.length ? parsed.prerelease : null;
-    }
-    __name(prerelease, "prerelease");
-    exports.intersects = intersects;
-    function intersects(r1, r2, options) {
-      r1 = new Range(r1, options);
-      r2 = new Range(r2, options);
-      return r1.intersects(r2);
-    }
-    __name(intersects, "intersects");
-    exports.coerce = coerce;
-    function coerce(version, options) {
-      if (version instanceof SemVer) {
-        return version;
-      }
-      if (typeof version === "number") {
-        version = String(version);
-      }
-      if (typeof version !== "string") {
-        return null;
-      }
-      options = options || {};
-      var match2 = null;
-      if (!options.rtl) {
-        match2 = version.match(safeRe[t.COERCE]);
-      } else {
-        var next;
-        while ((next = safeRe[t.COERCERTL].exec(version)) && (!match2 || match2.index + match2[0].length !== version.length)) {
-          if (!match2 || next.index + next[0].length !== match2.index + match2[0].length) {
-            match2 = next;
-          }
-          safeRe[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
-        }
-        safeRe[t.COERCERTL].lastIndex = -1;
-      }
-      if (match2 === null) {
-        return null;
-      }
-      return parse3(match2[2] + "." + (match2[3] || "0") + "." + (match2[4] || "0"), options);
-    }
-    __name(coerce, "coerce");
-  }
-});
-
-// ../../node_modules/find-cache-dir/node_modules/make-dir/index.js
-var require_make_dir = __commonJS({
-  "../../node_modules/find-cache-dir/node_modules/make-dir/index.js"(exports, module) {
-    "use strict";
-    var fs = __require("fs");
-    var path3 = __require("path");
-    var { promisify } = __require("util");
-    var semver = require_semver();
-    var useNativeRecursiveOption = semver.satisfies(process.version, ">=10.12.0");
-    var checkPath = /* @__PURE__ */ __name((pth) => {
-      if (process.platform === "win32") {
-        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path3.parse(pth).root, ""));
-        if (pathHasInvalidWinCharacters) {
-          const error = new Error(`Path contains invalid characters: ${pth}`);
-          error.code = "EINVAL";
-          throw error;
-        }
-      }
-    }, "checkPath");
-    var processOptions = /* @__PURE__ */ __name((options) => {
-      const defaults2 = {
-        mode: 511,
-        fs
-      };
-      return {
-        ...defaults2,
-        ...options
-      };
-    }, "processOptions");
-    var permissionError = /* @__PURE__ */ __name((pth) => {
-      const error = new Error(`operation not permitted, mkdir '${pth}'`);
-      error.code = "EPERM";
-      error.errno = -4048;
-      error.path = pth;
-      error.syscall = "mkdir";
-      return error;
-    }, "permissionError");
-    var makeDir = /* @__PURE__ */ __name(async (input, options) => {
-      checkPath(input);
-      options = processOptions(options);
-      const mkdir2 = promisify(options.fs.mkdir);
-      const stat = promisify(options.fs.stat);
-      if (useNativeRecursiveOption && options.fs.mkdir === fs.mkdir) {
-        const pth = path3.resolve(input);
-        await mkdir2(pth, {
-          mode: options.mode,
-          recursive: true
-        });
-        return pth;
-      }
-      const make = /* @__PURE__ */ __name(async (pth) => {
-        try {
-          await mkdir2(pth, options.mode);
-          return pth;
-        } catch (error) {
-          if (error.code === "EPERM") {
-            throw error;
-          }
-          if (error.code === "ENOENT") {
-            if (path3.dirname(pth) === pth) {
-              throw permissionError(pth);
-            }
-            if (error.message.includes("null bytes")) {
-              throw error;
-            }
-            await make(path3.dirname(pth));
-            return make(pth);
-          }
-          try {
-            const stats = await stat(pth);
-            if (!stats.isDirectory()) {
-              throw new Error("The path is not a directory");
-            }
-          } catch (_) {
-            throw error;
-          }
-          return pth;
-        }
-      }, "make");
-      return make(path3.resolve(input));
-    }, "makeDir");
-    module.exports = makeDir;
-    module.exports.sync = (input, options) => {
-      checkPath(input);
-      options = processOptions(options);
-      if (useNativeRecursiveOption && options.fs.mkdirSync === fs.mkdirSync) {
-        const pth = path3.resolve(input);
-        fs.mkdirSync(pth, {
-          mode: options.mode,
-          recursive: true
-        });
-        return pth;
-      }
-      const make = /* @__PURE__ */ __name((pth) => {
-        try {
-          options.fs.mkdirSync(pth, options.mode);
-        } catch (error) {
-          if (error.code === "EPERM") {
-            throw error;
-          }
-          if (error.code === "ENOENT") {
-            if (path3.dirname(pth) === pth) {
-              throw permissionError(pth);
-            }
-            if (error.message.includes("null bytes")) {
-              throw error;
-            }
-            make(path3.dirname(pth));
-            return make(pth);
-          }
-          try {
-            if (!options.fs.statSync(pth).isDirectory()) {
-              throw new Error("The path is not a directory");
-            }
-          } catch (_) {
-            throw error;
-          }
-        }
-        return pth;
-      }, "make");
-      return make(path3.resolve(input));
-    };
-  }
-});
-
-// ../../node_modules/find-cache-dir/index.js
-var require_find_cache_dir = __commonJS({
-  "../../node_modules/find-cache-dir/index.js"(exports, module) {
-    "use strict";
-    var path3 = __require("path");
-    var fs = __require("fs");
-    var commonDir = require_commondir();
-    var pkgDir = require_pkg_dir();
-    var makeDir = require_make_dir();
-    var { env, cwd: cwd2 } = process;
-    var isWritable2 = /* @__PURE__ */ __name((path4) => {
-      try {
-        fs.accessSync(path4, fs.constants.W_OK);
-        return true;
-      } catch (_) {
-        return false;
-      }
-    }, "isWritable");
-    function useDirectory(directory, options) {
-      if (options.create) {
-        makeDir.sync(directory);
-      }
-      if (options.thunk) {
-        return (...arguments_) => path3.join(directory, ...arguments_);
-      }
-      return directory;
-    }
-    __name(useDirectory, "useDirectory");
-    function getNodeModuleDirectory(directory) {
-      const nodeModules = path3.join(directory, "node_modules");
-      if (!isWritable2(nodeModules) && (fs.existsSync(nodeModules) || !isWritable2(path3.join(directory)))) {
-        return;
-      }
-      return nodeModules;
-    }
-    __name(getNodeModuleDirectory, "getNodeModuleDirectory");
-    module.exports = (options = {}) => {
-      if (env.CACHE_DIR && !["true", "false", "1", "0"].includes(env.CACHE_DIR)) {
-        return useDirectory(path3.join(env.CACHE_DIR, options.name), options);
-      }
-      let { cwd: directory = cwd2() } = options;
-      if (options.files) {
-        directory = commonDir(directory, options.files);
-      }
-      directory = pkgDir.sync(directory);
-      if (!directory) {
-        return;
-      }
-      const nodeModules = getNodeModuleDirectory(directory);
-      if (!nodeModules) {
-        return void 0;
-      }
-      return useDirectory(path3.join(directory, "node_modules", ".cache", options.name), options);
-    };
-  }
-});
-
 // src/index.ts
 import { readFile } from "node:fs/promises";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
@@ -2049,7 +343,7 @@ var withoutVitePlugins = /* @__PURE__ */ __name(async (plugins = [], namesToRemo
 }, "withoutVitePlugins");
 
 // src/vite-config.ts
-import { resolve as resolve2 } from "node:path";
+import { resolve as resolve3 } from "node:path";
 import {
   getBuilderOptions,
   isPreservingSymlinks,
@@ -2130,8 +424,7 @@ function encodeInteger(builder, num, relative4) {
   do {
     let clamped = delta & 31;
     delta >>>= 5;
-    if (delta > 0)
-      clamped |= 32;
+    if (delta > 0) clamped |= 32;
     builder.write(intToChar[clamped]);
   } while (delta > 0);
   return num;
@@ -2182,23 +475,18 @@ function encode(decoded) {
   let namesIndex = 0;
   for (let i = 0; i < decoded.length; i++) {
     const line = decoded[i];
-    if (i > 0)
-      writer.write(semicolon);
-    if (line.length === 0)
-      continue;
+    if (i > 0) writer.write(semicolon);
+    if (line.length === 0) continue;
     let genColumn = 0;
     for (let j = 0; j < line.length; j++) {
       const segment = line[j];
-      if (j > 0)
-        writer.write(comma);
+      if (j > 0) writer.write(comma);
       genColumn = encodeInteger(writer, segment[0], genColumn);
-      if (segment.length === 1)
-        continue;
+      if (segment.length === 1) continue;
       sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
       sourceLine = encodeInteger(writer, segment[2], sourceLine);
       sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
-      if (segment.length === 4)
-        continue;
+      if (segment.length === 4) continue;
       namesIndex = encodeInteger(writer, segment[4], namesIndex);
     }
   }
@@ -2663,6 +951,9 @@ var MagicString = class _MagicString {
       }
       if (chunk.outro.length) mappings.advance(chunk.outro);
     });
+    if (this.outro) {
+      mappings.advance(this.outro);
+    }
     return {
       file: options.file ? options.file.split(/[/\\]/).pop() : void 0,
       sources: [
@@ -3020,10 +1311,13 @@ var MagicString = class _MagicString {
   _split(index) {
     if (this.byStart[index] || this.byEnd[index]) return;
     let chunk = this.lastSearchedChunk;
+    let previousChunk = chunk;
     const searchForward = index > chunk.end;
     while (chunk) {
       if (chunk.contains(index)) return this._splitChunk(chunk, index);
       chunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start];
+      if (chunk === previousChunk) return;
+      previousChunk = chunk;
     }
   }
   _splitChunk(chunk, index) {
@@ -3172,7 +1466,12 @@ var MagicString = class _MagicString {
     const { original } = this;
     const index = original.indexOf(string);
     if (index !== -1) {
-      this.overwrite(index, index + string.length, replacement);
+      if (typeof replacement === "function") {
+        replacement = replacement(string, index, original);
+      }
+      if (string !== replacement) {
+        this.overwrite(index, index + string.length, replacement);
+      }
     }
     return this;
   }
@@ -3187,7 +1486,11 @@ var MagicString = class _MagicString {
     const stringLength = string.length;
     for (let index = original.indexOf(string); index !== -1; index = original.indexOf(string, index + stringLength)) {
       const previous = original.slice(index, index + stringLength);
-      if (previous !== replacement) this.overwrite(index, index + stringLength, replacement);
+      let _replacement = replacement;
+      if (typeof replacement === "function") {
+        _replacement = replacement(previous, index, original);
+      }
+      if (previous !== _replacement) this.overwrite(index, index + stringLength, _replacement);
     }
     return this;
   }
@@ -7107,10 +5410,10 @@ var Minipass = class extends EventEmitter {
    * Return a void Promise that resolves once the stream ends.
    */
   async promise() {
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       this.on(DESTROYED, () => reject(new Error("stream destroyed")));
       this.on("error", (er) => reject(er));
-      this.on("end", () => resolve3());
+      this.on("end", () => resolve4());
     });
   }
   /**
@@ -7134,7 +5437,7 @@ var Minipass = class extends EventEmitter {
         return Promise.resolve({ done: false, value: res });
       if (this[EOF])
         return stop();
-      let resolve3;
+      let resolve4;
       let reject;
       const onerr = /* @__PURE__ */ __name((er) => {
         this.off("data", ondata);
@@ -7148,19 +5451,19 @@ var Minipass = class extends EventEmitter {
         this.off("end", onend);
         this.off(DESTROYED, ondestroy);
         this.pause();
-        resolve3({ value, done: !!this[EOF] });
+        resolve4({ value, done: !!this[EOF] });
       }, "ondata");
       const onend = /* @__PURE__ */ __name(() => {
         this.off("error", onerr);
         this.off("data", ondata);
         this.off(DESTROYED, ondestroy);
         stop();
-        resolve3({ done: true, value: void 0 });
+        resolve4({ done: true, value: void 0 });
       }, "onend");
       const ondestroy = /* @__PURE__ */ __name(() => onerr(new Error("stream destroyed")), "ondestroy");
       return new Promise((res2, rej) => {
         reject = rej;
-        resolve3 = res2;
+        resolve4 = res2;
         this.once(DESTROYED, ondestroy);
         this.once("error", onerr);
         this.once("end", onend);
@@ -8137,9 +6440,9 @@ var PathBase = class {
     if (this.#asyncReaddirInFlight) {
       await this.#asyncReaddirInFlight;
     } else {
-      let resolve3 = /* @__PURE__ */ __name(() => {
+      let resolve4 = /* @__PURE__ */ __name(() => {
       }, "resolve");
-      this.#asyncReaddirInFlight = new Promise((res) => resolve3 = res);
+      this.#asyncReaddirInFlight = new Promise((res) => resolve4 = res);
       try {
         for (const e of await this.#fs.promises.readdir(fullpath, {
           withFileTypes: true
@@ -8152,7 +6455,7 @@ var PathBase = class {
         children.provisional = 0;
       }
       this.#asyncReaddirInFlight = void 0;
-      resolve3();
+      resolve4();
     }
     return children.slice(0, children.provisional);
   }
@@ -9222,13 +7525,13 @@ var Ignore = class {
       const p = new Pattern(parsed, globParts, 0, this.platform);
       const m = new Minimatch(p.globString(), this.mmopts);
       const children = globParts[globParts.length - 1] === "**";
-      const absolute = p.isAbsolute();
-      if (absolute)
+      const absolute2 = p.isAbsolute();
+      if (absolute2)
         this.absolute.push(m);
       else
         this.relative.push(m);
       if (children) {
-        if (absolute)
+        if (absolute2)
           this.absoluteChildren.push(m);
         else
           this.relativeChildren.push(m);
@@ -9294,8 +7597,8 @@ var MatchRecord = class {
     __name(this, "MatchRecord");
   }
   store = /* @__PURE__ */ new Map();
-  add(target, absolute, ifDir) {
-    const n2 = (absolute ? 2 : 0) | (ifDir ? 1 : 0);
+  add(target, absolute2, ifDir) {
+    const n2 = (absolute2 ? 2 : 0) | (ifDir ? 1 : 0);
     const current = this.store.get(target);
     this.store.set(target, current === void 0 ? n2 : n2 & current);
   }
@@ -9362,7 +7665,7 @@ var Processor = class _Processor {
     for (let [t, pattern] of processingSet) {
       this.hasWalkedCache.storeWalked(t, pattern);
       const root = pattern.root();
-      const absolute = pattern.isAbsolute() && this.opts.absolute !== false;
+      const absolute2 = pattern.isAbsolute() && this.opts.absolute !== false;
       if (root) {
         t = t.resolve(root === "/" && this.opts.root !== void 0 ? this.opts.root : root);
         const rest2 = pattern.rest();
@@ -9393,7 +7696,7 @@ var Processor = class _Processor {
       }
       if (typeof p === "string") {
         const ifDir = p === ".." || p === "" || p === ".";
-        this.matches.add(t.resolve(p), absolute, ifDir);
+        this.matches.add(t.resolve(p), absolute2, ifDir);
         continue;
       } else if (p === GLOBSTAR) {
         if (!t.isSymbolicLink() || this.follow || pattern.checkFollowGlobstar()) {
@@ -9402,12 +7705,12 @@ var Processor = class _Processor {
         const rp = rest?.pattern();
         const rrest = rest?.rest();
         if (!rest || (rp === "" || rp === ".") && !rrest) {
-          this.matches.add(t, absolute, rp === "" || rp === ".");
+          this.matches.add(t, absolute2, rp === "" || rp === ".");
         } else {
           if (rp === "..") {
             const tp = t.parent || t;
             if (!rrest)
-              this.matches.add(tp, absolute, true);
+              this.matches.add(tp, absolute2, true);
             else if (!this.hasWalkedCache.hasWalked(tp, rrest)) {
               this.subwalks.add(tp, rrest);
             }
@@ -9434,24 +7737,24 @@ var Processor = class _Processor {
     const results = this.child();
     for (const e of entries) {
       for (const pattern of patterns) {
-        const absolute = pattern.isAbsolute();
+        const absolute2 = pattern.isAbsolute();
         const p = pattern.pattern();
         const rest = pattern.rest();
         if (p === GLOBSTAR) {
-          results.testGlobstar(e, pattern, rest, absolute);
+          results.testGlobstar(e, pattern, rest, absolute2);
         } else if (p instanceof RegExp) {
-          results.testRegExp(e, p, rest, absolute);
+          results.testRegExp(e, p, rest, absolute2);
         } else {
-          results.testString(e, p, rest, absolute);
+          results.testString(e, p, rest, absolute2);
         }
       }
     }
     return results;
   }
-  testGlobstar(e, pattern, rest, absolute) {
+  testGlobstar(e, pattern, rest, absolute2) {
     if (this.dot || !e.name.startsWith(".")) {
       if (!pattern.hasMore()) {
-        this.matches.add(e, absolute, false);
+        this.matches.add(e, absolute2, false);
       }
       if (e.canReaddir()) {
         if (this.follow || !e.isSymbolicLink()) {
@@ -9469,29 +7772,29 @@ var Processor = class _Processor {
       const rp = rest.pattern();
       if (typeof rp === "string" && // dots and empty were handled already
       rp !== ".." && rp !== "" && rp !== ".") {
-        this.testString(e, rp, rest.rest(), absolute);
+        this.testString(e, rp, rest.rest(), absolute2);
       } else if (rp === "..") {
         const ep = e.parent || e;
         this.subwalks.add(ep, rest);
       } else if (rp instanceof RegExp) {
-        this.testRegExp(e, rp, rest.rest(), absolute);
+        this.testRegExp(e, rp, rest.rest(), absolute2);
       }
     }
   }
-  testRegExp(e, p, rest, absolute) {
+  testRegExp(e, p, rest, absolute2) {
     if (!p.test(e.name))
       return;
     if (!rest) {
-      this.matches.add(e, absolute, false);
+      this.matches.add(e, absolute2, false);
     } else {
       this.subwalks.add(e, rest);
     }
   }
-  testString(e, p, rest, absolute) {
+  testString(e, p, rest, absolute2) {
     if (!e.isNamed(p))
       return;
     if (!rest) {
-      this.matches.add(e, absolute, false);
+      this.matches.add(e, absolute2, false);
     } else {
       this.subwalks.add(e, rest);
     }
@@ -9610,14 +7913,14 @@ var GlobUtil = class {
     }
     return this.matchCheckTest(s, ifDir);
   }
-  matchFinish(e, absolute) {
+  matchFinish(e, absolute2) {
     if (this.#ignored(e))
       return;
     if (!this.includeChildMatches && this.#ignore?.add) {
       const ign = `${e.relativePosix()}/**`;
       this.#ignore.add(ign);
     }
-    const abs = this.opts.absolute === void 0 ? absolute : this.opts.absolute;
+    const abs = this.opts.absolute === void 0 ? absolute2 : this.opts.absolute;
     this.seen.add(e);
     const mark = this.opts.mark && e.isDirectory() ? this.#sep : "";
     if (this.opts.withFileTypes) {
@@ -9631,15 +7934,15 @@ var GlobUtil = class {
       this.matchEmit(!rel ? "." + mark : pre + rel + mark);
     }
   }
-  async match(e, absolute, ifDir) {
+  async match(e, absolute2, ifDir) {
     const p = await this.matchCheck(e, ifDir);
     if (p)
-      this.matchFinish(p, absolute);
+      this.matchFinish(p, absolute2);
   }
-  matchSync(e, absolute, ifDir) {
+  matchSync(e, absolute2, ifDir) {
     const p = this.matchCheckSync(e, ifDir);
     if (p)
-      this.matchFinish(p, absolute);
+      this.matchFinish(p, absolute2);
   }
   walkCB(target, patterns, cb) {
     if (this.signal?.aborted)
@@ -9661,11 +7964,11 @@ var GlobUtil = class {
       if (--tasks === 0)
         cb();
     }, "next");
-    for (const [m, absolute, ifDir] of processor.matches.entries()) {
+    for (const [m, absolute2, ifDir] of processor.matches.entries()) {
       if (this.#ignored(m))
         continue;
       tasks++;
-      this.match(m, absolute, ifDir).then(() => next());
+      this.match(m, absolute2, ifDir).then(() => next());
     }
     for (const t of processor.subwalkTargets()) {
       if (this.maxDepth !== Infinity && t.depth() >= this.maxDepth) {
@@ -9688,11 +7991,11 @@ var GlobUtil = class {
       if (--tasks === 0)
         cb();
     }, "next");
-    for (const [m, absolute, ifDir] of processor.matches.entries()) {
+    for (const [m, absolute2, ifDir] of processor.matches.entries()) {
       if (this.#ignored(m))
         continue;
       tasks++;
-      this.match(m, absolute, ifDir).then(() => next());
+      this.match(m, absolute2, ifDir).then(() => next());
     }
     for (const [target2, patterns] of processor.subwalks.entries()) {
       tasks++;
@@ -9720,10 +8023,10 @@ var GlobUtil = class {
       if (--tasks === 0)
         cb();
     }, "next");
-    for (const [m, absolute, ifDir] of processor.matches.entries()) {
+    for (const [m, absolute2, ifDir] of processor.matches.entries()) {
       if (this.#ignored(m))
         continue;
-      this.matchSync(m, absolute, ifDir);
+      this.matchSync(m, absolute2, ifDir);
     }
     for (const t of processor.subwalkTargets()) {
       if (this.maxDepth !== Infinity && t.depth() >= this.maxDepth) {
@@ -9742,10 +8045,10 @@ var GlobUtil = class {
       if (--tasks === 0)
         cb();
     }, "next");
-    for (const [m, absolute, ifDir] of processor.matches.entries()) {
+    for (const [m, absolute2, ifDir] of processor.matches.entries()) {
       if (this.#ignored(m))
         continue;
-      this.matchSync(m, absolute, ifDir);
+      this.matchSync(m, absolute2, ifDir);
     }
     for (const [target2, patterns] of processor.subwalks.entries()) {
       tasks++;
@@ -10470,10 +8773,99 @@ async function csfPlugin(config) {
 __name(csfPlugin, "csfPlugin");
 
 // src/plugins/external-globals-plugin.ts
-import { existsSync } from "node:fs";
+import { existsSync as existsSync3 } from "node:fs";
 import { mkdir, writeFile } from "node:fs/promises";
-import { dirname as dirname2, join as join3 } from "node:path";
-var import_find_cache_dir = __toESM(require_find_cache_dir(), 1);
+import { dirname as dirname4, join as join6 } from "node:path";
+
+// ../../node_modules/empathic/package.mjs
+import { env } from "node:process";
+import { dirname as dirname3, join as join5 } from "node:path";
+import { existsSync as existsSync2, mkdirSync } from "node:fs";
+
+// ../../node_modules/empathic/access.mjs
+import { accessSync, constants } from "node:fs";
+function ok(path3, mode) {
+  try {
+    accessSync(path3, mode);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(ok, "ok");
+function writable(path3) {
+  return ok(path3, constants.W_OK);
+}
+__name(writable, "writable");
+
+// ../../node_modules/empathic/find.mjs
+import { join as join4 } from "node:path";
+import { existsSync, statSync } from "node:fs";
+
+// ../../node_modules/empathic/walk.mjs
+import { dirname as dirname2 } from "node:path";
+
+// ../../node_modules/empathic/resolve.mjs
+import { isAbsolute as isAbsolute3, join as join3, resolve as resolve2 } from "node:path";
+function absolute(input, root) {
+  return isAbsolute3(input) ? input : resolve2(root || ".", input);
+}
+__name(absolute, "absolute");
+
+// ../../node_modules/empathic/walk.mjs
+function up(base, options) {
+  let { last, cwd: cwd2 } = options || {};
+  let tmp = absolute(base, cwd2);
+  let root = absolute(last || "/", cwd2);
+  let prev, arr = [];
+  while (prev !== root) {
+    arr.push(tmp);
+    tmp = dirname2(prev = tmp);
+    if (tmp === prev) break;
+  }
+  return arr;
+}
+__name(up, "up");
+
+// ../../node_modules/empathic/find.mjs
+function up2(name, options) {
+  let dir, tmp;
+  let start2 = options && options.cwd || "";
+  for (dir of up(start2, options)) {
+    tmp = join4(dir, name);
+    if (existsSync(tmp)) return tmp;
+  }
+}
+__name(up2, "up");
+
+// ../../node_modules/empathic/package.mjs
+function up3(options) {
+  return up2("package.json", options);
+}
+__name(up3, "up");
+function cache(name, options) {
+  options = options || {};
+  let dir = env.CACHE_DIR;
+  if (!dir || /^(1|0|true|false)$/.test(dir)) {
+    let pkg = up3(options);
+    if (dir = pkg && dirname3(pkg)) {
+      let mods = join5(dir, "node_modules");
+      let exists = existsSync2(mods);
+      if (!writable(exists ? mods : dir)) return;
+      dir = join5(mods, ".cache");
+    }
+  }
+  if (dir) {
+    dir = join5(dir, name);
+    if (options.create && !existsSync2(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+  }
+}
+__name(cache, "cache");
+
+// src/plugins/external-globals-plugin.ts
 var escapeKeys = /* @__PURE__ */ __name((key) => key.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), "escapeKeys");
 var defaultImportRegExp = "import ([^*{}]+) from";
 var replacementMap = /* @__PURE__ */ new Map([
@@ -10496,16 +8888,13 @@ async function externalGlobalsPlugin(externals) {
         return void 0;
       }
       const newAlias = mergeAlias([], config.resolve?.alias);
-      const cachePath = (0, import_find_cache_dir.default)({
-        name: "sb-vite-plugin-externals",
-        create: true
-      });
+      const cachePath = cache("sb-vite-plugin-externals", { create: true });
       await Promise.all(
         Object.keys(externals).map(async (externalKey) => {
-          const externalCachePath = join3(cachePath, `${externalKey}.js`);
+          const externalCachePath = join6(cachePath, `${externalKey}.js`);
           newAlias.push({ find: new RegExp(`^${externalKey}$`), replacement: externalCachePath });
-          if (!existsSync(externalCachePath)) {
-            const directory = dirname2(externalCachePath);
+          if (!existsSync3(externalCachePath)) {
+            const directory = dirname4(externalCachePath);
             await mkdir(directory, { recursive: true });
           }
           await writeFile(externalCachePath, `module.exports = ${externals[externalKey]};`);
@@ -10652,7 +9041,7 @@ async function commonConfig(options, _type) {
   const configEnv = _type === "development" ? configEnvServe : configEnvBuild;
   const { loadConfigFromFile, mergeConfig, defaultClientConditions = [] } = await import("vite");
   const { viteConfigPath } = await getBuilderOptions(options);
-  const projectRoot = resolve2(options.configDir, "..");
+  const projectRoot = resolve3(options.configDir, "..");
   const { config: { build: buildProperty = void 0, ...userConfig } = {} } = await loadConfigFromFile(configEnv, viteConfigPath, projectRoot) ?? {};
   const sbConfig = {
     configFile: false,
@@ -10896,10 +9285,10 @@ async function getOptimizeDeps(config, options) {
   const absoluteStories = await listStories(options);
   const stories = absoluteStories.map((storyPath) => normalizePath(relative3(root, storyPath)));
   const resolvedConfig = await resolveConfig(config, "serve", "development");
-  const resolve3 = resolvedConfig.createResolver({ asSrc: false });
+  const resolve4 = resolvedConfig.createResolver({ asSrc: false });
   const include = await asyncFilter(
     Array.from(/* @__PURE__ */ new Set([...INCLUDE_CANDIDATES, ...extraOptimizeDeps])),
-    async (id) => Boolean(await resolve3(id))
+    async (id) => Boolean(await resolve4(id))
   );
   const optimizeDeps = {
     ...config.optimizeDeps,