@storybook/react-native-web-vite 11.0.0-alpha.4 → 11.0.0-alpha.6

package/dist/_node-chunks/chunk-VH5OJ6KV.js

@@ -0,0 +1,1846 @@
+import CJS_COMPAT_NODE_URL_pgrik10hrqk from 'node:url';
+import CJS_COMPAT_NODE_PATH_pgrik10hrqk from 'node:path';
+import CJS_COMPAT_NODE_MODULE_pgrik10hrqk from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_pgrik10hrqk.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_pgrik10hrqk.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_pgrik10hrqk.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Storybook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./chunk-GLJIOED3.js";
+
+// ../../../node_modules/ms/index.js
+var require_ms = __commonJS({
+  "../../../node_modules/ms/index.js"(exports, module) {
+    var s = 1e3, m = s * 60, h = m * 60, d = h * 24, w = d * 7, y = d * 365.25;
+    module.exports = function(val, options) {
+      options = options || {};
+      var type = typeof val;
+      if (type === "string" && val.length > 0)
+        return parse3(val);
+      if (type === "number" && isFinite(val))
+        return options.long ? fmtLong(val) : fmtShort(val);
+      throw new Error(
+        "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+      );
+    };
+    function parse3(str) {
+      if (str = String(str), !(str.length > 100)) {
+        var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+          str
+        );
+        if (match) {
+          var n = parseFloat(match[1]), type = (match[2] || "ms").toLowerCase();
+          switch (type) {
+            case "years":
+            case "year":
+            case "yrs":
+            case "yr":
+            case "y":
+              return n * y;
+            case "weeks":
+            case "week":
+            case "w":
+              return n * w;
+            case "days":
+            case "day":
+            case "d":
+              return n * d;
+            case "hours":
+            case "hour":
+            case "hrs":
+            case "hr":
+            case "h":
+              return n * h;
+            case "minutes":
+            case "minute":
+            case "mins":
+            case "min":
+            case "m":
+              return n * m;
+            case "seconds":
+            case "second":
+            case "secs":
+            case "sec":
+            case "s":
+              return n * s;
+            case "milliseconds":
+            case "millisecond":
+            case "msecs":
+            case "msec":
+            case "ms":
+              return n;
+            default:
+              return;
+          }
+        }
+      }
+    }
+    function fmtShort(ms) {
+      var msAbs = Math.abs(ms);
+      return msAbs >= d ? Math.round(ms / d) + "d" : msAbs >= h ? Math.round(ms / h) + "h" : msAbs >= m ? Math.round(ms / m) + "m" : msAbs >= s ? Math.round(ms / s) + "s" : ms + "ms";
+    }
+    function fmtLong(ms) {
+      var msAbs = Math.abs(ms);
+      return msAbs >= d ? plural(ms, msAbs, d, "day") : msAbs >= h ? plural(ms, msAbs, h, "hour") : msAbs >= m ? plural(ms, msAbs, m, "minute") : msAbs >= s ? plural(ms, msAbs, s, "second") : ms + " ms";
+    }
+    function plural(ms, msAbs, n, name) {
+      var isPlural = msAbs >= n * 1.5;
+      return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
+    }
+  }
+});
+
+// ../../../node_modules/debug/src/common.js
+var require_common = __commonJS({
+  "../../../node_modules/debug/src/common.js"(exports, module) {
+    function setup(env) {
+      createDebug2.debug = createDebug2, createDebug2.default = createDebug2, createDebug2.coerce = coerce, createDebug2.disable = disable, createDebug2.enable = enable, createDebug2.enabled = enabled, createDebug2.humanize = require_ms(), createDebug2.destroy = destroy, Object.keys(env).forEach((key) => {
+        createDebug2[key] = env[key];
+      }), createDebug2.names = [], createDebug2.skips = [], createDebug2.formatters = {};
+      function selectColor(namespace) {
+        let hash = 0;
+        for (let i = 0; i < namespace.length; i++)
+          hash = (hash << 5) - hash + namespace.charCodeAt(i), hash |= 0;
+        return createDebug2.colors[Math.abs(hash) % createDebug2.colors.length];
+      }
+      createDebug2.selectColor = selectColor;
+      function createDebug2(namespace) {
+        let prevTime, enableOverride = null, namespacesCache, enabledCache;
+        function debug2(...args) {
+          if (!debug2.enabled)
+            return;
+          let self = debug2, curr = Number(/* @__PURE__ */ new Date()), ms = curr - (prevTime || curr);
+          self.diff = ms, self.prev = prevTime, self.curr = curr, prevTime = curr, args[0] = createDebug2.coerce(args[0]), typeof args[0] != "string" && args.unshift("%O");
+          let index = 0;
+          args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+            if (match === "%%")
+              return "%";
+            index++;
+            let formatter = createDebug2.formatters[format];
+            if (typeof formatter == "function") {
+              let val = args[index];
+              match = formatter.call(self, val), args.splice(index, 1), index--;
+            }
+            return match;
+          }), createDebug2.formatArgs.call(self, args), (self.log || createDebug2.log).apply(self, args);
+        }
+        return debug2.namespace = namespace, debug2.useColors = createDebug2.useColors(), debug2.color = createDebug2.selectColor(namespace), debug2.extend = extend, debug2.destroy = createDebug2.destroy, Object.defineProperty(debug2, "enabled", {
+          enumerable: !0,
+          configurable: !1,
+          get: () => enableOverride !== null ? enableOverride : (namespacesCache !== createDebug2.namespaces && (namespacesCache = createDebug2.namespaces, enabledCache = createDebug2.enabled(namespace)), enabledCache),
+          set: (v) => {
+            enableOverride = v;
+          }
+        }), typeof createDebug2.init == "function" && createDebug2.init(debug2), debug2;
+      }
+      function extend(namespace, delimiter) {
+        let newDebug = createDebug2(this.namespace + (typeof delimiter > "u" ? ":" : delimiter) + namespace);
+        return newDebug.log = this.log, newDebug;
+      }
+      function enable(namespaces) {
+        createDebug2.save(namespaces), createDebug2.namespaces = namespaces, createDebug2.names = [], createDebug2.skips = [];
+        let split = (typeof namespaces == "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+        for (let ns of split)
+          ns[0] === "-" ? createDebug2.skips.push(ns.slice(1)) : createDebug2.names.push(ns);
+      }
+      function matchesTemplate(search, template) {
+        let searchIndex = 0, templateIndex = 0, starIndex = -1, matchIndex = 0;
+        for (; searchIndex < search.length; )
+          if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*"))
+            template[templateIndex] === "*" ? (starIndex = templateIndex, matchIndex = searchIndex, templateIndex++) : (searchIndex++, templateIndex++);
+          else if (starIndex !== -1)
+            templateIndex = starIndex + 1, matchIndex++, searchIndex = matchIndex;
+          else
+            return !1;
+        for (; templateIndex < template.length && template[templateIndex] === "*"; )
+          templateIndex++;
+        return templateIndex === template.length;
+      }
+      function disable() {
+        let namespaces = [
+          ...createDebug2.names,
+          ...createDebug2.skips.map((namespace) => "-" + namespace)
+        ].join(",");
+        return createDebug2.enable(""), namespaces;
+      }
+      function enabled(name) {
+        for (let skip of createDebug2.skips)
+          if (matchesTemplate(name, skip))
+            return !1;
+        for (let ns of createDebug2.names)
+          if (matchesTemplate(name, ns))
+            return !0;
+        return !1;
+      }
+      function coerce(val) {
+        return val instanceof Error ? val.stack || val.message : val;
+      }
+      function destroy() {
+        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+      }
+      return createDebug2.enable(createDebug2.load()), createDebug2;
+    }
+    module.exports = setup;
+  }
+});
+
+// ../../../node_modules/debug/src/browser.js
+var require_browser = __commonJS({
+  "../../../node_modules/debug/src/browser.js"(exports, module) {
+    exports.formatArgs = formatArgs;
+    exports.save = save;
+    exports.load = load;
+    exports.useColors = useColors;
+    exports.storage = localstorage();
+    exports.destroy = /* @__PURE__ */ (() => {
+      let warned = !1;
+      return () => {
+        warned || (warned = !0, console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."));
+      };
+    })();
+    exports.colors = [
+      "#0000CC",
+      "#0000FF",
+      "#0033CC",
+      "#0033FF",
+      "#0066CC",
+      "#0066FF",
+      "#0099CC",
+      "#0099FF",
+      "#00CC00",
+      "#00CC33",
+      "#00CC66",
+      "#00CC99",
+      "#00CCCC",
+      "#00CCFF",
+      "#3300CC",
+      "#3300FF",
+      "#3333CC",
+      "#3333FF",
+      "#3366CC",
+      "#3366FF",
+      "#3399CC",
+      "#3399FF",
+      "#33CC00",
+      "#33CC33",
+      "#33CC66",
+      "#33CC99",
+      "#33CCCC",
+      "#33CCFF",
+      "#6600CC",
+      "#6600FF",
+      "#6633CC",
+      "#6633FF",
+      "#66CC00",
+      "#66CC33",
+      "#9900CC",
+      "#9900FF",
+      "#9933CC",
+      "#9933FF",
+      "#99CC00",
+      "#99CC33",
+      "#CC0000",
+      "#CC0033",
+      "#CC0066",
+      "#CC0099",
+      "#CC00CC",
+      "#CC00FF",
+      "#CC3300",
+      "#CC3333",
+      "#CC3366",
+      "#CC3399",
+      "#CC33CC",
+      "#CC33FF",
+      "#CC6600",
+      "#CC6633",
+      "#CC9900",
+      "#CC9933",
+      "#CCCC00",
+      "#CCCC33",
+      "#FF0000",
+      "#FF0033",
+      "#FF0066",
+      "#FF0099",
+      "#FF00CC",
+      "#FF00FF",
+      "#FF3300",
+      "#FF3333",
+      "#FF3366",
+      "#FF3399",
+      "#FF33CC",
+      "#FF33FF",
+      "#FF6600",
+      "#FF6633",
+      "#FF9900",
+      "#FF9933",
+      "#FFCC00",
+      "#FFCC33"
+    ];
+    function useColors() {
+      if (typeof window < "u" && window.process && (window.process.type === "renderer" || window.process.__nwjs))
+        return !0;
+      if (typeof navigator < "u" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/))
+        return !1;
+      let m;
+      return typeof document < "u" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+      typeof window < "u" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+      typeof navigator < "u" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+      typeof navigator < "u" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+    }
+    function formatArgs(args) {
+      if (args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff), !this.useColors)
+        return;
+      let c = "color: " + this.color;
+      args.splice(1, 0, c, "color: inherit");
+      let index = 0, lastC = 0;
+      args[0].replace(/%[a-zA-Z%]/g, (match) => {
+        match !== "%%" && (index++, match === "%c" && (lastC = index));
+      }), args.splice(lastC, 0, c);
+    }
+    exports.log = console.debug || console.log || (() => {
+    });
+    function save(namespaces) {
+      try {
+        namespaces ? exports.storage.setItem("debug", namespaces) : exports.storage.removeItem("debug");
+      } catch {
+      }
+    }
+    function load() {
+      let r;
+      try {
+        r = exports.storage.getItem("debug") || exports.storage.getItem("DEBUG");
+      } catch {
+      }
+      return !r && typeof process < "u" && "env" in process && (r = process.env.DEBUG), r;
+    }
+    function localstorage() {
+      try {
+        return localStorage;
+      } catch {
+      }
+    }
+    module.exports = require_common()(exports);
+    var { formatters } = module.exports;
+    formatters.j = function(v) {
+      try {
+        return JSON.stringify(v);
+      } catch (error) {
+        return "[UnexpectedJSONParseError]: " + error.message;
+      }
+    };
+  }
+});
+
+// ../../../node_modules/has-flag/index.js
+var require_has_flag = __commonJS({
+  "../../../node_modules/has-flag/index.js"(exports, module) {
+    "use strict";
+    module.exports = (flag, argv = process.argv) => {
+      let prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--", position = argv.indexOf(prefix + flag), terminatorPosition = argv.indexOf("--");
+      return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+    };
+  }
+});
+
+// ../../../node_modules/supports-color/index.js
+var require_supports_color = __commonJS({
+  "../../../node_modules/supports-color/index.js"(exports, module) {
+    "use strict";
+    var os2 = __require("os"), tty = __require("tty"), hasFlag = require_has_flag(), { env } = process, forceColor;
+    hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never") ? forceColor = 0 : (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) && (forceColor = 1);
+    "FORCE_COLOR" in env && (env.FORCE_COLOR === "true" ? forceColor = 1 : env.FORCE_COLOR === "false" ? forceColor = 0 : forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3));
+    function translateLevel(level) {
+      return level === 0 ? !1 : {
+        level,
+        hasBasic: !0,
+        has256: level >= 2,
+        has16m: level >= 3
+      };
+    }
+    function supportsColor(haveStream, streamIsTTY) {
+      if (forceColor === 0)
+        return 0;
+      if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor"))
+        return 3;
+      if (hasFlag("color=256"))
+        return 2;
+      if (haveStream && !streamIsTTY && forceColor === void 0)
+        return 0;
+      let min = forceColor || 0;
+      if (env.TERM === "dumb")
+        return min;
+      if (process.platform === "win32") {
+        let osRelease = os2.release().split(".");
+        return Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586 ? Number(osRelease[2]) >= 14931 ? 3 : 2 : 1;
+      }
+      if ("CI" in env)
+        return ["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => sign in env) || env.CI_NAME === "codeship" ? 1 : min;
+      if ("TEAMCITY_VERSION" in env)
+        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+      if (env.COLORTERM === "truecolor")
+        return 3;
+      if ("TERM_PROGRAM" in env) {
+        let version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+        switch (env.TERM_PROGRAM) {
+          case "iTerm.app":
+            return version >= 3 ? 3 : 2;
+          case "Apple_Terminal":
+            return 2;
+        }
+      }
+      return /-256(color)?$/i.test(env.TERM) ? 2 : /^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM) || "COLORTERM" in env ? 1 : min;
+    }
+    function getSupportLevel(stream) {
+      let level = supportsColor(stream, stream && stream.isTTY);
+      return translateLevel(level);
+    }
+    module.exports = {
+      supportsColor: getSupportLevel,
+      stdout: translateLevel(supportsColor(!0, tty.isatty(1))),
+      stderr: translateLevel(supportsColor(!0, tty.isatty(2)))
+    };
+  }
+});
+
+// ../../../node_modules/debug/src/node.js
+var require_node = __commonJS({
+  "../../../node_modules/debug/src/node.js"(exports, module) {
+    var tty = __require("tty"), util = __require("util");
+    exports.init = init;
+    exports.log = log;
+    exports.formatArgs = formatArgs;
+    exports.save = save;
+    exports.load = load;
+    exports.useColors = useColors;
+    exports.destroy = util.deprecate(
+      () => {
+      },
+      "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."
+    );
+    exports.colors = [6, 2, 3, 4, 5, 1];
+    try {
+      let supportsColor = require_supports_color();
+      supportsColor && (supportsColor.stderr || supportsColor).level >= 2 && (exports.colors = [
+        20,
+        21,
+        26,
+        27,
+        32,
+        33,
+        38,
+        39,
+        40,
+        41,
+        42,
+        43,
+        44,
+        45,
+        56,
+        57,
+        62,
+        63,
+        68,
+        69,
+        74,
+        75,
+        76,
+        77,
+        78,
+        79,
+        80,
+        81,
+        92,
+        93,
+        98,
+        99,
+        112,
+        113,
+        128,
+        129,
+        134,
+        135,
+        148,
+        149,
+        160,
+        161,
+        162,
+        163,
+        164,
+        165,
+        166,
+        167,
+        168,
+        169,
+        170,
+        171,
+        172,
+        173,
+        178,
+        179,
+        184,
+        185,
+        196,
+        197,
+        198,
+        199,
+        200,
+        201,
+        202,
+        203,
+        204,
+        205,
+        206,
+        207,
+        208,
+        209,
+        214,
+        215,
+        220,
+        221
+      ]);
+    } catch {
+    }
+    exports.inspectOpts = Object.keys(process.env).filter((key) => /^debug_/i.test(key)).reduce((obj, key) => {
+      let prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => k.toUpperCase()), val = process.env[key];
+      return /^(yes|on|true|enabled)$/i.test(val) ? val = !0 : /^(no|off|false|disabled)$/i.test(val) ? val = !1 : val === "null" ? val = null : val = Number(val), obj[prop] = val, obj;
+    }, {});
+    function useColors() {
+      return "colors" in exports.inspectOpts ? !!exports.inspectOpts.colors : tty.isatty(process.stderr.fd);
+    }
+    function formatArgs(args) {
+      let { namespace: name, useColors: useColors2 } = this;
+      if (useColors2) {
+        let c = this.color, colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c), prefix = `  ${colorCode};1m${name} \x1B[0m`;
+        args[0] = prefix + args[0].split(`
+`).join(`
+` + prefix), args.push(colorCode + "m+" + module.exports.humanize(this.diff) + "\x1B[0m");
+      } else
+        args[0] = getDate() + name + " " + args[0];
+    }
+    function getDate() {
+      return exports.inspectOpts.hideDate ? "" : (/* @__PURE__ */ new Date()).toISOString() + " ";
+    }
+    function log(...args) {
+      return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + `
+`);
+    }
+    function save(namespaces) {
+      namespaces ? process.env.DEBUG = namespaces : delete process.env.DEBUG;
+    }
+    function load() {
+      return process.env.DEBUG;
+    }
+    function init(debug2) {
+      debug2.inspectOpts = {};
+      let keys = Object.keys(exports.inspectOpts);
+      for (let i = 0; i < keys.length; i++)
+        debug2.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+    }
+    module.exports = require_common()(exports);
+    var { formatters } = module.exports;
+    formatters.o = function(v) {
+      return this.inspectOpts.colors = this.useColors, util.inspect(v, this.inspectOpts).split(`
+`).map((str) => str.trim()).join(" ");
+    };
+    formatters.O = function(v) {
+      return this.inspectOpts.colors = this.useColors, util.inspect(v, this.inspectOpts);
+    };
+  }
+});
+
+// ../../../node_modules/debug/src/index.js
+var require_src = __commonJS({
+  "../../../node_modules/debug/src/index.js"(exports, module) {
+    typeof process > "u" || process.type === "renderer" || process.browser === !0 || process.__nwjs ? module.exports = require_browser() : module.exports = require_node();
+  }
+});
+
+// ../../../node_modules/globrex/index.js
+var require_globrex = __commonJS({
+  "../../../node_modules/globrex/index.js"(exports, module) {
+    var isWin = process.platform === "win32", SEP = isWin ? "\\\\+" : "\\/", SEP_ESC = isWin ? "\\\\" : "/", GLOBSTAR = "((?:[^/]*(?:/|$))*)", WILDCARD = "([^/]*)", GLOBSTAR_SEGMENT = `((?:[^${SEP_ESC}]*(?:${SEP_ESC}|$))*)`, WILDCARD_SEGMENT = `([^${SEP_ESC}]*)`;
+    function globrex(glob, { extended = !1, globstar = !1, strict = !1, filepath = !1, flags = "" } = {}) {
+      let regex = "", segment = "", path8 = { regex: "", segments: [] }, inGroup = !1, inRange = !1, ext = [];
+      function add(str, { split, last, only } = {}) {
+        only !== "path" && (regex += str), filepath && only !== "regex" && (path8.regex += str === "\\/" ? SEP : str, split ? (last && (segment += str), segment !== "" && (flags.includes("g") || (segment = `^${segment}$`), path8.segments.push(new RegExp(segment, flags))), segment = "") : segment += str);
+      }
+      let c, n;
+      for (let i = 0; i < glob.length; i++) {
+        if (c = glob[i], n = glob[i + 1], ["\\", "$", "^", ".", "="].includes(c)) {
+          add(`\\${c}`);
+          continue;
+        }
+        if (c === "/") {
+          add(`\\${c}`, { split: !0 }), n === "/" && !strict && (regex += "?");
+          continue;
+        }
+        if (c === "(") {
+          if (ext.length) {
+            add(c);
+            continue;
+          }
+          add(`\\${c}`);
+          continue;
+        }
+        if (c === ")") {
+          if (ext.length) {
+            add(c);
+            let type = ext.pop();
+            add(type === "@" ? "{1}" : type === "!" ? "([^/]*)" : type);
+            continue;
+          }
+          add(`\\${c}`);
+          continue;
+        }
+        if (c === "|") {
+          if (ext.length) {
+            add(c);
+            continue;
+          }
+          add(`\\${c}`);
+          continue;
+        }
+        if (c === "+") {
+          if (n === "(" && extended) {
+            ext.push(c);
+            continue;
+          }
+          add(`\\${c}`);
+          continue;
+        }
+        if (c === "@" && extended && n === "(") {
+          ext.push(c);
+          continue;
+        }
+        if (c === "!") {
+          if (extended) {
+            if (inRange) {
+              add("^");
+              continue;
+            }
+            if (n === "(") {
+              ext.push(c), add("(?!"), i++;
+              continue;
+            }
+            add(`\\${c}`);
+            continue;
+          }
+          add(`\\${c}`);
+          continue;
+        }
+        if (c === "?") {
+          if (extended) {
+            n === "(" ? ext.push(c) : add(".");
+            continue;
+          }
+          add(`\\${c}`);
+          continue;
+        }
+        if (c === "[") {
+          if (inRange && n === ":") {
+            i++;
+            let value = "";
+            for (; glob[++i] !== ":"; ) value += glob[i];
+            value === "alnum" ? add("(\\w|\\d)") : value === "space" ? add("\\s") : value === "digit" && add("\\d"), i++;
+            continue;
+          }
+          if (extended) {
+            inRange = !0, add(c);
+            continue;
+          }
+          add(`\\${c}`);
+          continue;
+        }
+        if (c === "]") {
+          if (extended) {
+            inRange = !1, add(c);
+            continue;
+          }
+          add(`\\${c}`);
+          continue;
+        }
+        if (c === "{") {
+          if (extended) {
+            inGroup = !0, add("(");
+            continue;
+          }
+          add(`\\${c}`);
+          continue;
+        }
+        if (c === "}") {
+          if (extended) {
+            inGroup = !1, add(")");
+            continue;
+          }
+          add(`\\${c}`);
+          continue;
+        }
+        if (c === ",") {
+          if (inGroup) {
+            add("|");
+            continue;
+          }
+          add(`\\${c}`);
+          continue;
+        }
+        if (c === "*") {
+          if (n === "(" && extended) {
+            ext.push(c);
+            continue;
+          }
+          let prevChar = glob[i - 1], starCount = 1;
+          for (; glob[i + 1] === "*"; )
+            starCount++, i++;
+          let nextChar = glob[i + 1];
+          globstar ? starCount > 1 && // multiple "*"'s
+          (prevChar === "/" || prevChar === void 0) && // from the start of the segment
+          (nextChar === "/" || nextChar === void 0) ? (add(GLOBSTAR, { only: "regex" }), add(GLOBSTAR_SEGMENT, { only: "path", last: !0, split: !0 }), i++) : (add(WILDCARD, { only: "regex" }), add(WILDCARD_SEGMENT, { only: "path" })) : add(".*");
+          continue;
+        }
+        add(c);
+      }
+      flags.includes("g") || (regex = `^${regex}$`, segment = `^${segment}$`, filepath && (path8.regex = `^${path8.regex}$`));
+      let result = { regex: new RegExp(regex, flags) };
+      return filepath && (path8.segments.push(new RegExp(segment, flags)), path8.regex = new RegExp(path8.regex, flags), path8.globstar = new RegExp(flags.includes("g") ? GLOBSTAR_SEGMENT : `^${GLOBSTAR_SEGMENT}$`, flags), result.path = path8), result;
+    }
+    module.exports = globrex;
+  }
+});
+
+// ../../../node_modules/vite-tsconfig-paths/dist/index.js
+var import_debug = __toESM(require_src(), 1), import_globrex = __toESM(require_globrex(), 1);
+import * as fs22 from "fs";
+import * as vite2 from "vite";
+import { createWriteStream, statSync, writeFileSync } from "fs";
+import * as os from "os";
+import * as path7 from "path";
+import * as vite from "vite";
+import * as fs4 from "fs";
+import { readdir as readdir2 } from "fs/promises";
+import { isAbsolute as isAbsolute2, join as join2, relative as relative2 } from "path";
+import { inspect } from "util";
+
+// ../../../node_modules/tsconfck/src/find.js
+import path2 from "node:path";
+import fs2 from "node:fs";
+
+// ../../../node_modules/tsconfck/src/util.js
+import path from "node:path";
+import { promises as fs } from "node:fs";
+var POSIX_SEP_RE = new RegExp("\\" + path.posix.sep, "g"), NATIVE_SEP_RE = new RegExp("\\" + path.sep, "g"), PATTERN_REGEX_CACHE = /* @__PURE__ */ new Map(), GLOB_ALL_PATTERN = "**/*", TS_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts"], JS_EXTENSIONS = [".js", ".jsx", ".mjs", ".cjs"], TSJS_EXTENSIONS = TS_EXTENSIONS.concat(JS_EXTENSIONS), TS_EXTENSIONS_RE_GROUP = `\\.(?:${TS_EXTENSIONS.map((ext) => ext.substring(1)).join("|")})`, TSJS_EXTENSIONS_RE_GROUP = `\\.(?:${TSJS_EXTENSIONS.map((ext) => ext.substring(1)).join(
+  "|"
+)})`, IS_POSIX = path.posix.sep === path.sep;
+function makePromise() {
+  let resolve3, reject;
+  return { promise: new Promise((res, rej) => {
+    resolve3 = res, reject = rej;
+  }), resolve: resolve3, reject };
+}
+async function loadTS() {
+  try {
+    return import("typescript").then((m) => m.default);
+  } catch (e) {
+    throw console.error('typescript must be installed to use "native" functions'), e;
+  }
+}
+async function resolveTSConfigJson(filename, cache) {
+  if (path.extname(filename) !== ".json")
+    return;
+  let tsconfig = path.resolve(filename);
+  return cache && (cache.hasParseResult(tsconfig) || cache.hasParseResult(filename)) ? tsconfig : fs.stat(tsconfig).then((stat) => {
+    if (stat.isFile() || stat.isFIFO())
+      return tsconfig;
+    throw new Error(`${filename} exists but is not a regular file.`);
+  });
+}
+var isInNodeModules = IS_POSIX ? (dir) => dir.includes("/node_modules/") : (dir) => dir.match(/[/\\]node_modules[/\\]/), posix2native = IS_POSIX ? (filename) => filename : (filename) => filename.replace(POSIX_SEP_RE, path.sep), native2posix = IS_POSIX ? (filename) => filename : (filename) => filename.replace(NATIVE_SEP_RE, path.posix.sep), resolve2posix = IS_POSIX ? (dir, filename) => dir ? path.resolve(dir, filename) : path.resolve(filename) : (dir, filename) => native2posix(
+  dir ? path.resolve(posix2native(dir), posix2native(filename)) : path.resolve(posix2native(filename))
+);
+function resolveReferencedTSConfigFiles(result, options) {
+  let dir = path.dirname(result.tsconfigFile);
+  return result.tsconfig.references.map((ref) => {
+    let refPath = ref.path.endsWith(".json") ? ref.path : path.join(ref.path, options?.configName ?? "tsconfig.json");
+    return resolve2posix(dir, refPath);
+  });
+}
+function resolveSolutionTSConfig(filename, result) {
+  let extensions = result.tsconfig.compilerOptions?.allowJs ? TSJS_EXTENSIONS : TS_EXTENSIONS;
+  if (result.referenced && extensions.some((ext) => filename.endsWith(ext)) && !isIncluded(filename, result)) {
+    let solutionTSConfig = result.referenced.find(
+      (referenced) => isIncluded(filename, referenced)
+    );
+    if (solutionTSConfig)
+      return solutionTSConfig;
+  }
+  return result;
+}
+function isIncluded(filename, result) {
+  let dir = native2posix(path.dirname(result.tsconfigFile)), files = (result.tsconfig.files || []).map((file) => resolve2posix(dir, file)), absoluteFilename = resolve2posix(null, filename);
+  if (files.includes(filename))
+    return !0;
+  let allowJs = result.tsconfig.compilerOptions?.allowJs;
+  return isGlobMatch(
+    absoluteFilename,
+    dir,
+    result.tsconfig.include || (result.tsconfig.files ? [] : [GLOB_ALL_PATTERN]),
+    allowJs
+  ) ? !isGlobMatch(absoluteFilename, dir, result.tsconfig.exclude || [], allowJs) : !1;
+}
+function isGlobMatch(filename, dir, patterns, allowJs) {
+  let extensions = allowJs ? TSJS_EXTENSIONS : TS_EXTENSIONS;
+  return patterns.some((pattern) => {
+    let lastWildcardIndex = pattern.length, hasWildcard = !1, hasExtension = !1, hasSlash = !1, lastSlashIndex = -1;
+    for (let i = pattern.length - 1; i > -1; i--) {
+      let c = pattern[i];
+      if (hasWildcard || (c === "*" || c === "?") && (lastWildcardIndex = i, hasWildcard = !0), hasSlash || (c === "." ? hasExtension = !0 : c === "/" && (lastSlashIndex = i, hasSlash = !0)), hasWildcard && hasSlash)
+        break;
+    }
+    if (!hasExtension && (!hasWildcard || lastWildcardIndex < lastSlashIndex) && (pattern += `${pattern.endsWith("/") ? "" : "/"}${GLOB_ALL_PATTERN}`, lastWildcardIndex = pattern.length - 1, hasWildcard = !0), lastWildcardIndex < pattern.length - 1 && !filename.endsWith(pattern.slice(lastWildcardIndex + 1)) || pattern.endsWith("*") && !extensions.some((ext) => filename.endsWith(ext)))
+      return !1;
+    if (pattern === GLOB_ALL_PATTERN)
+      return filename.startsWith(`${dir}/`);
+    let resolvedPattern = resolve2posix(dir, pattern), firstWildcardIndex = -1;
+    for (let i = 0; i < resolvedPattern.length; i++)
+      if (resolvedPattern[i] === "*" || resolvedPattern[i] === "?") {
+        firstWildcardIndex = i, hasWildcard = !0;
+        break;
+      }
+    if (firstWildcardIndex > 1 && !filename.startsWith(resolvedPattern.slice(0, firstWildcardIndex - 1)))
+      return !1;
+    if (hasWildcard) {
+      if (firstWildcardIndex + GLOB_ALL_PATTERN.length === resolvedPattern.length - (pattern.length - 1 - lastWildcardIndex) && resolvedPattern.slice(firstWildcardIndex, firstWildcardIndex + GLOB_ALL_PATTERN.length) === GLOB_ALL_PATTERN)
+        return !0;
+    } else return filename === resolvedPattern;
+    if (PATTERN_REGEX_CACHE.has(resolvedPattern))
+      return PATTERN_REGEX_CACHE.get(resolvedPattern).test(filename);
+    let regex = pattern2regex(resolvedPattern, allowJs);
+    return PATTERN_REGEX_CACHE.set(resolvedPattern, regex), regex.test(filename);
+  });
+}
+function pattern2regex(resolvedPattern, allowJs) {
+  let regexStr = "^";
+  for (let i = 0; i < resolvedPattern.length; i++) {
+    let char = resolvedPattern[i];
+    if (char === "?") {
+      regexStr += "[^\\/]";
+      continue;
+    }
+    if (char === "*") {
+      if (resolvedPattern[i + 1] === "*" && resolvedPattern[i + 2] === "/") {
+        i += 2, regexStr += "(?:[^\\/]*\\/)*";
+        continue;
+      }
+      regexStr += "[^\\/]*";
+      continue;
+    }
+    "/.+^${}()|[]\\".includes(char) && (regexStr += "\\"), regexStr += char;
+  }
+  return resolvedPattern.endsWith("*") && (regexStr += allowJs ? TSJS_EXTENSIONS_RE_GROUP : TS_EXTENSIONS_RE_GROUP), regexStr += "$", new RegExp(regexStr);
+}
+function replaceTokens(result) {
+  result.tsconfig && (result.tsconfig = JSON.parse(
+    JSON.stringify(result.tsconfig).replaceAll(/"\${configDir}/g, `"${native2posix(path.dirname(result.tsconfigFile))}`)
+  ));
+}
+
+// ../../../node_modules/tsconfck/src/find.js
+async function find(filename, options) {
+  let dir = path2.dirname(path2.resolve(filename));
+  if (options?.ignoreNodeModules && isInNodeModules(dir))
+    return null;
+  let cache = options?.cache, configName = options?.configName ?? "tsconfig.json";
+  if (cache?.hasConfigPath(dir, configName))
+    return cache.getConfigPath(dir, configName);
+  let {
+    /** @type {Promise<string|null>} */
+    promise,
+    resolve: resolve3,
+    reject
+  } = makePromise();
+  return options?.root && !path2.isAbsolute(options.root) && (options.root = path2.resolve(options.root)), findUp(dir, { promise, resolve: resolve3, reject }, options), promise;
+}
+function findUp(dir, { resolve: resolve3, reject, promise }, options) {
+  let { cache, root, configName } = options ?? {};
+  if (cache)
+    if (cache.hasConfigPath(dir, configName)) {
+      let cached;
+      try {
+        cached = cache.getConfigPath(dir, configName);
+      } catch (e) {
+        reject(e);
+        return;
+      }
+      cached?.then ? cached.then(resolve3).catch(reject) : resolve3(cached);
+    } else
+      cache.setConfigPath(dir, promise, configName);
+  let tsconfig = path2.join(dir, options?.configName ?? "tsconfig.json");
+  fs2.stat(tsconfig, (err, stats) => {
+    if (stats && (stats.isFile() || stats.isFIFO()))
+      resolve3(tsconfig);
+    else if (err?.code !== "ENOENT")
+      reject(err);
+    else {
+      let parent;
+      root === dir || (parent = path2.dirname(dir)) === dir ? resolve3(null) : findUp(parent, { promise, resolve: resolve3, reject }, options);
+    }
+  });
+}
+
+// ../../../node_modules/tsconfck/src/find-all.js
+import path3 from "node:path";
+import { readdir } from "node:fs";
+var sep = path3.sep;
+async function findAll(dir, options) {
+  let state = {
+    files: [],
+    calls: 0,
+    skip: options?.skip,
+    err: !1,
+    configNames: options?.configNames ?? ["tsconfig.json"]
+  };
+  return new Promise((resolve3, reject) => {
+    walk(path3.resolve(dir), state, (err, files) => err ? reject(err) : resolve3(files));
+  });
+}
+function walk(dir, state, done) {
+  state.err || (state.calls++, readdir(dir, { withFileTypes: !0 }, (err, entries = []) => {
+    if (!state.err)
+      if (err && !(err.code === "ENOENT" || err.code === "EACCES" || err.code === "EPERM"))
+        state.err = !0, done(err);
+      else {
+        for (let ent of entries)
+          ent.isDirectory() && !state.skip?.(ent.name) ? walk(`${dir}${sep}${ent.name}`, state, done) : ent.isFile() && state.configNames.includes(ent.name) && state.files.push(`${dir}${sep}${ent.name}`);
+        --state.calls === 0 && (state.err || done(null, state.files));
+      }
+  }));
+}
+
+// ../../../node_modules/tsconfck/src/to-json.js
+function toJson(tsconfigJson) {
+  let stripped = stripDanglingComma(stripJsonComments(stripBom(tsconfigJson)));
+  return stripped.trim() === "" ? "{}" : stripped;
+}
+function stripDanglingComma(pseudoJson) {
+  let insideString = !1, offset = 0, result = "", danglingCommaPos = null;
+  for (let i = 0; i < pseudoJson.length; i++) {
+    let currentCharacter = pseudoJson[i];
+    if (currentCharacter === '"' && (isEscaped(pseudoJson, i) || (insideString = !insideString)), insideString) {
+      danglingCommaPos = null;
+      continue;
+    }
+    if (currentCharacter === ",") {
+      danglingCommaPos = i;
+      continue;
+    }
+    danglingCommaPos && (currentCharacter === "}" || currentCharacter === "]" ? (result += pseudoJson.slice(offset, danglingCommaPos) + " ", offset = danglingCommaPos + 1, danglingCommaPos = null) : currentCharacter.match(/\s/) || (danglingCommaPos = null));
+  }
+  return result + pseudoJson.substring(offset);
+}
+function isEscaped(jsonString, quotePosition) {
+  let index = quotePosition - 1, backslashCount = 0;
+  for (; jsonString[index] === "\\"; )
+    index -= 1, backslashCount += 1;
+  return !!(backslashCount % 2);
+}
+function strip(string, start, end) {
+  return string.slice(start, end).replace(/\S/g, " ");
+}
+var singleComment = /* @__PURE__ */ Symbol("singleComment"), multiComment = /* @__PURE__ */ Symbol("multiComment");
+function stripJsonComments(jsonString) {
+  let isInsideString = !1, isInsideComment = !1, offset = 0, result = "";
+  for (let index = 0; index < jsonString.length; index++) {
+    let currentCharacter = jsonString[index], nextCharacter = jsonString[index + 1];
+    !isInsideComment && currentCharacter === '"' && (isEscaped(jsonString, index) || (isInsideString = !isInsideString)), !isInsideString && (!isInsideComment && currentCharacter + nextCharacter === "//" ? (result += jsonString.slice(offset, index), offset = index, isInsideComment = singleComment, index++) : isInsideComment === singleComment && currentCharacter + nextCharacter === `\r
+` ? (index++, isInsideComment = !1, result += strip(jsonString, offset, index), offset = index) : isInsideComment === singleComment && currentCharacter === `
+` ? (isInsideComment = !1, result += strip(jsonString, offset, index), offset = index) : !isInsideComment && currentCharacter + nextCharacter === "/*" ? (result += jsonString.slice(offset, index), offset = index, isInsideComment = multiComment, index++) : isInsideComment === multiComment && currentCharacter + nextCharacter === "*/" && (index++, isInsideComment = !1, result += strip(jsonString, offset, index + 1), offset = index + 1));
+  }
+  return result + (isInsideComment ? strip(jsonString.slice(offset)) : jsonString.slice(offset));
+}
+function stripBom(string) {
+  return string.charCodeAt(0) === 65279 ? string.slice(1) : string;
+}
+
+// ../../../node_modules/tsconfck/src/parse.js
+import path4 from "node:path";
+import { promises as fs3 } from "node:fs";
+import { createRequire } from "module";
+var not_found_result = {
+  tsconfigFile: null,
+  tsconfig: {}
+};
+async function parse(filename, options) {
+  let cache = options?.cache;
+  if (cache?.hasParseResult(filename))
+    return getParsedDeep(filename, cache, options);
+  let {
+    resolve: resolve3,
+    reject,
+    /** @type {Promise<import('./public.d.ts').TSConfckParseResult>}*/
+    promise
+  } = makePromise();
+  cache?.setParseResult(filename, promise, !0);
+  try {
+    let tsconfigFile = await resolveTSConfigJson(filename, cache) || await find(filename, options);
+    if (!tsconfigFile)
+      return resolve3(not_found_result), promise;
+    let result;
+    filename !== tsconfigFile && cache?.hasParseResult(tsconfigFile) ? result = await getParsedDeep(tsconfigFile, cache, options) : (result = await parseFile(tsconfigFile, cache, filename === tsconfigFile), await Promise.all([parseExtends(result, cache), parseReferences(result, options)])), replaceTokens(result), resolve3(resolveSolutionTSConfig(filename, result));
+  } catch (e) {
+    reject(e);
+  }
+  return promise;
+}
+async function getParsedDeep(filename, cache, options) {
+  let result = await cache.getParseResult(filename);
+  if (result.tsconfig.extends && !result.extended || result.tsconfig.references && !result.referenced) {
+    let promise = Promise.all([
+      parseExtends(result, cache),
+      parseReferences(result, options)
+    ]).then(() => result);
+    return cache.setParseResult(filename, promise, !0), promise;
+  }
+  return result;
+}
+async function parseFile(tsconfigFile, cache, skipCache) {
+  if (!skipCache && cache?.hasParseResult(tsconfigFile) && !cache.getParseResult(tsconfigFile)._isRootFile_)
+    return cache.getParseResult(tsconfigFile);
+  let promise = fs3.readFile(tsconfigFile, "utf-8").then(toJson).then((json) => {
+    let parsed = JSON.parse(json);
+    return applyDefaults(parsed, tsconfigFile), {
+      tsconfigFile,
+      tsconfig: normalizeTSConfig(parsed, path4.dirname(tsconfigFile))
+    };
+  }).catch((e) => {
+    throw new TSConfckParseError(
+      `parsing ${tsconfigFile} failed: ${e}`,
+      "PARSE_FILE",
+      tsconfigFile,
+      e
+    );
+  });
+  return !skipCache && (!cache?.hasParseResult(tsconfigFile) || !cache.getParseResult(tsconfigFile)._isRootFile_) && cache?.setParseResult(tsconfigFile, promise), promise;
+}
+function normalizeTSConfig(tsconfig, dir) {
+  let baseUrl = tsconfig.compilerOptions?.baseUrl;
+  return baseUrl && !baseUrl.startsWith("${") && !path4.isAbsolute(baseUrl) && (tsconfig.compilerOptions.baseUrl = resolve2posix(dir, baseUrl)), tsconfig;
+}
+async function parseReferences(result, options) {
+  if (!result.tsconfig.references)
+    return;
+  let referencedFiles = resolveReferencedTSConfigFiles(result, options), referenced = await Promise.all(
+    referencedFiles.map((file) => parseFile(file, options?.cache))
+  );
+  await Promise.all(referenced.map((ref) => parseExtends(ref, options?.cache))), referenced.forEach((ref) => {
+    ref.solution = result, replaceTokens(ref);
+  }), result.referenced = referenced;
+}
+async function parseExtends(result, cache) {
+  if (!result.tsconfig.extends)
+    return;
+  let extended = [
+    { tsconfigFile: result.tsconfigFile, tsconfig: JSON.parse(JSON.stringify(result.tsconfig)) }
+  ], pos = 0, extendsPath = [], currentBranchDepth = 0;
+  for (; pos < extended.length; ) {
+    let extending = extended[pos];
+    if (extendsPath.push(extending.tsconfigFile), extending.tsconfig.extends) {
+      currentBranchDepth += 1;
+      let resolvedExtends;
+      Array.isArray(extending.tsconfig.extends) ? resolvedExtends = extending.tsconfig.extends.reverse().map((ex) => resolveExtends(ex, extending.tsconfigFile)) : resolvedExtends = [resolveExtends(extending.tsconfig.extends, extending.tsconfigFile)];
+      let circularExtends = resolvedExtends.find(
+        (tsconfigFile) => extendsPath.includes(tsconfigFile)
+      );
+      if (circularExtends) {
+        let circle = extendsPath.concat([circularExtends]).join(" -> ");
+        throw new TSConfckParseError(
+          `Circular dependency in "extends": ${circle}`,
+          "EXTENDS_CIRCULAR",
+          result.tsconfigFile
+        );
+      }
+      extended.splice(
+        pos + 1,
+        0,
+        ...await Promise.all(resolvedExtends.map((file) => parseFile(file, cache)))
+      );
+    } else
+      extendsPath.splice(-currentBranchDepth), currentBranchDepth = 0;
+    pos = pos + 1;
+  }
+  result.extended = extended;
+  for (let ext of result.extended.slice(1))
+    extendTSConfig(result, ext);
+}
+function resolveExtends(extended, from) {
+  [".", ".."].includes(extended) && (extended = extended + "/tsconfig.json");
+  let req = createRequire(from), error;
+  try {
+    return req.resolve(extended);
+  } catch (e) {
+    error = e;
+  }
+  if (extended[0] !== "." && !path4.isAbsolute(extended))
+    try {
+      return req.resolve(`${extended}/tsconfig.json`);
+    } catch (e) {
+      error = e;
+    }
+  throw new TSConfckParseError(
+    `failed to resolve "extends":"${extended}" in ${from}`,
+    "EXTENDS_RESOLVE",
+    from,
+    error
+  );
+}
+var EXTENDABLE_KEYS = [
+  "compilerOptions",
+  "files",
+  "include",
+  "exclude",
+  "watchOptions",
+  "compileOnSave",
+  "typeAcquisition",
+  "buildOptions"
+];
+function extendTSConfig(extending, extended) {
+  let extendingConfig = extending.tsconfig, extendedConfig = extended.tsconfig, relativePath = native2posix(
+    path4.relative(path4.dirname(extending.tsconfigFile), path4.dirname(extended.tsconfigFile))
+  );
+  for (let key of Object.keys(extendedConfig).filter((key2) => EXTENDABLE_KEYS.includes(key2)))
+    if (key === "compilerOptions") {
+      extendingConfig.compilerOptions || (extendingConfig.compilerOptions = {});
+      for (let option of Object.keys(extendedConfig.compilerOptions))
+        Object.prototype.hasOwnProperty.call(extendingConfig.compilerOptions, option) || (extendingConfig.compilerOptions[option] = rebaseRelative(
+          option,
+          extendedConfig.compilerOptions[option],
+          relativePath
+        ));
+    } else if (extendingConfig[key] === void 0)
+      if (key === "watchOptions") {
+        extendingConfig.watchOptions = {};
+        for (let option of Object.keys(extendedConfig.watchOptions))
+          extendingConfig.watchOptions[option] = rebaseRelative(
+            option,
+            extendedConfig.watchOptions[option],
+            relativePath
+          );
+      } else
+        extendingConfig[key] = rebaseRelative(key, extendedConfig[key], relativePath);
+}
+var REBASE_KEYS = [
+  // root
+  "files",
+  "include",
+  "exclude",
+  // compilerOptions
+  "baseUrl",
+  "rootDir",
+  "rootDirs",
+  "typeRoots",
+  "outDir",
+  "outFile",
+  "declarationDir",
+  // watchOptions
+  "excludeDirectories",
+  "excludeFiles"
+];
+function rebaseRelative(key, value, prependPath) {
+  return REBASE_KEYS.includes(key) ? Array.isArray(value) ? value.map((x) => rebasePath(x, prependPath)) : rebasePath(value, prependPath) : value;
+}
+function rebasePath(value, prependPath) {
+  return path4.isAbsolute(value) || value.startsWith("${configDir}") ? value : path4.posix.normalize(path4.posix.join(prependPath, value));
+}
+var TSConfckParseError = class _TSConfckParseError extends Error {
+  /**
+   * error code
+   * @type {string}
+   */
+  code;
+  /**
+   * error cause
+   * @type { Error | undefined}
+   */
+  cause;
+  /**
+   * absolute path of tsconfig file where the error happened
+   * @type {string}
+   */
+  tsconfigFile;
+  /**
+   *
+   * @param {string} message - error message
+   * @param {string} code - error code
+   * @param {string} tsconfigFile - path to tsconfig file
+   * @param {Error?} cause - cause of this error
+   */
+  constructor(message, code, tsconfigFile, cause) {
+    super(message), Object.setPrototypeOf(this, _TSConfckParseError.prototype), this.name = _TSConfckParseError.name, this.code = code, this.cause = cause, this.tsconfigFile = tsconfigFile;
+  }
+};
+function applyDefaults(tsconfig, tsconfigFile) {
+  isJSConfig(tsconfigFile) && (tsconfig.compilerOptions = {
+    ...DEFAULT_JSCONFIG_COMPILER_OPTIONS,
+    ...tsconfig.compilerOptions
+  });
+}
+var DEFAULT_JSCONFIG_COMPILER_OPTIONS = {
+  allowJs: !0,
+  maxNodeModuleJsDepth: 2,
+  allowSyntheticDefaultImports: !0,
+  skipLibCheck: !0,
+  noEmit: !0
+};
+function isJSConfig(configFileName) {
+  return path4.basename(configFileName) === "jsconfig.json";
+}
+
+// ../../../node_modules/tsconfck/src/find-native.js
+import path5 from "node:path";
+async function findNative(filename, options) {
+  let dir = native2posix(path5.dirname(path5.resolve(filename)));
+  if (options?.ignoreNodeModules && isInNodeModules(dir))
+    return null;
+  let cache = options?.cache, root = options?.root ? native2posix(path5.resolve(options.root)) : void 0, configName = options?.configName ?? "tsconfig.json";
+  if (cache?.hasConfigPath(dir, configName))
+    return cache.getConfigPath(dir, configName);
+  let ts = await loadTS(), { findConfigFile, sys } = ts, tsconfigFile = findConfigFile(dir, sys.fileExists, configName);
+  return (!tsconfigFile || is_out_of_root(tsconfigFile, root)) && (tsconfigFile = null), cache && cache_result(tsconfigFile, dir, cache, root, configName), tsconfigFile;
+}
+function is_out_of_root(tsconfigFile, root) {
+  return root && !tsconfigFile.startsWith(root);
+}
+function cache_result(tsconfigFile, fileDir, cache, root, configName) {
+  let tsconfigDir = tsconfigFile ? path5.dirname(tsconfigFile) : root, directories = [], dir = fileDir;
+  for (; dir; ) {
+    directories.push(dir);
+    let parent = path5.dirname(dir);
+    if (tsconfigDir === dir || parent === dir)
+      break;
+    dir = parent;
+  }
+  directories.forEach((d) => {
+    cache.setConfigPath(d, Promise.resolve(tsconfigFile), configName);
+  });
+}
+
+// ../../../node_modules/tsconfck/src/parse-native.js
+import path6 from "node:path";
+var notFoundResult = {
+  tsconfigFile: null,
+  tsconfig: {},
+  result: null
+};
+async function parseNative(filename, options) {
+  let cache = options?.cache;
+  if (cache?.hasParseResult(filename))
+    return cache.getParseResult(filename);
+  let {
+    resolve: resolve3,
+    reject,
+    /** @type {Promise<import('./public.d.ts').TSConfckParseNativeResult>}*/
+    promise
+  } = makePromise();
+  cache?.setParseResult(filename, promise);
+  try {
+    let tsconfigFile = await resolveTSConfigJson(filename, cache) || await findNative(filename, options);
+    if (!tsconfigFile)
+      return resolve3(notFoundResult), promise;
+    let result;
+    if (filename !== tsconfigFile && cache?.hasParseResult(tsconfigFile))
+      result = await cache.getParseResult(tsconfigFile);
+    else {
+      let ts = await loadTS();
+      result = await parseFile2(tsconfigFile, ts, options, filename === tsconfigFile), await parseReferences2(result, ts, options), cache?.setParseResult(tsconfigFile, Promise.resolve(result));
+    }
+    return resolve3(resolveSolutionTSConfig(filename, result)), promise;
+  } catch (e) {
+    return reject(e), promise;
+  }
+}
+function parseFile2(tsconfigFile, ts, options, skipCache) {
+  let cache = options?.cache;
+  if (!skipCache && cache?.hasParseResult(tsconfigFile))
+    return cache.getParseResult(tsconfigFile);
+  let posixTSConfigFile = native2posix(tsconfigFile), { parseJsonConfigFileContent, readConfigFile, sys } = ts, { config, error } = readConfigFile(posixTSConfigFile, sys.readFile);
+  if (error)
+    throw new TSConfckParseNativeError(error, tsconfigFile, null);
+  let host = {
+    useCaseSensitiveFileNames: !1,
+    readDirectory: sys.readDirectory,
+    fileExists: sys.fileExists,
+    readFile: sys.readFile
+  };
+  options?.ignoreSourceFiles && (config.files = [], config.include = []);
+  let nativeResult = parseJsonConfigFileContent(
+    config,
+    host,
+    path6.dirname(posixTSConfigFile),
+    void 0,
+    posixTSConfigFile
+  );
+  checkErrors(nativeResult, tsconfigFile);
+  let result = {
+    tsconfigFile,
+    tsconfig: result2tsconfig(nativeResult, ts, tsconfigFile),
+    result: nativeResult
+  };
+  return skipCache || cache?.setParseResult(tsconfigFile, Promise.resolve(result)), result;
+}
+async function parseReferences2(result, ts, options) {
+  if (!result.tsconfig.references)
+    return;
+  let referencedFiles = resolveReferencedTSConfigFiles(result, options);
+  result.referenced = await Promise.all(
+    referencedFiles.map((file) => parseFile2(file, ts, options))
+  ), result.referenced.forEach((ref) => ref.solution = result);
+}
+function checkErrors(nativeResult, tsconfigFile) {
+  let ignoredErrorCodes = [
+    // see https://github.com/microsoft/TypeScript/blob/main/src/compiler/diagnosticMessages.json
+    18002,
+    // empty files list
+    18003
+    // no inputs
+  ], criticalError = nativeResult.errors?.find(
+    (error) => error.category === 1 && !ignoredErrorCodes.includes(error.code)
+  );
+  if (criticalError)
+    throw new TSConfckParseNativeError(criticalError, tsconfigFile, nativeResult);
+}
+function result2tsconfig(result, ts, tsconfigFile) {
+  let tsconfig = JSON.parse(JSON.stringify(result.raw)), ignoredOptions = ["configFilePath", "pathsBasePath"];
+  if (result.options && Object.keys(result.options).some((o) => !ignoredOptions.includes(o))) {
+    tsconfig.compilerOptions = {
+      ...result.options
+    };
+    for (let ignored of ignoredOptions)
+      delete tsconfig.compilerOptions[ignored];
+  }
+  let compilerOptions = tsconfig.compilerOptions;
+  if (compilerOptions) {
+    compilerOptions.lib != null && (compilerOptions.lib = compilerOptions.lib.map(
+      (x) => x.replace(/^lib\./, "").replace(/\.d\.ts$/, "")
+    ));
+    let enumProperties = [
+      { name: "importsNotUsedAsValues", enumeration: ts.ImportsNotUsedAsValues },
+      { name: "module", enumeration: ts.ModuleKind },
+      {
+        name: "moduleResolution",
+        enumeration: {
+          ...ts.ModuleResolutionKind,
+          2: "node"
+          /*ts.ModuleResolutionKind uses "Node10" but in tsconfig it is just node"*/
+        }
+      },
+      {
+        name: "newLine",
+        enumeration: { 0: "crlf", 1: "lf" }
+        /*ts.NewLineKind uses different names*/
+      },
+      { name: "target", enumeration: ts.ScriptTarget }
+    ];
+    for (let prop of enumProperties)
+      compilerOptions[prop.name] != null && typeof compilerOptions[prop.name] == "number" && (compilerOptions[prop.name] = prop.enumeration[compilerOptions[prop.name]].toLowerCase());
+    compilerOptions.target === "latest" && (compilerOptions.target = "esnext");
+  }
+  result.watchOptions && (tsconfig.watchOptions = {
+    ...result.watchOptions
+  });
+  let watchOptions = tsconfig.watchOptions;
+  if (watchOptions) {
+    let enumProperties = [
+      { name: "watchFile", enumeration: ts.WatchFileKind },
+      { name: "watchDirectory", enumeration: ts.WatchDirectoryKind },
+      { name: "fallbackPolling", enumeration: ts.PollingWatchKind }
+    ];
+    for (let prop of enumProperties)
+      if (watchOptions[prop.name] != null && typeof watchOptions[prop.name] == "number") {
+        let enumVal = prop.enumeration[watchOptions[prop.name]];
+        watchOptions[prop.name] = enumVal.charAt(0).toLowerCase() + enumVal.slice(1);
+      }
+  }
+  tsconfig.compileOnSave === !1 && delete tsconfig.compileOnSave;
+  let parseResult = { tsconfig, tsconfigFile };
+  return replaceTokens(parseResult), parseResult.tsconfig;
+}
+var TSConfckParseNativeError = class _TSConfckParseNativeError extends Error {
+  /**
+   *
+   * @param {TSDiagnosticError} diagnostic - diagnostics of ts
+   * @param {string} tsconfigFile - file that errored
+   * @param {any?} result  - parsed result, if any
+   */
+  constructor(diagnostic, tsconfigFile, result) {
+    super(diagnostic.messageText), Object.setPrototypeOf(this, _TSConfckParseNativeError.prototype), this.name = _TSConfckParseNativeError.name, this.code = `TS ${diagnostic.code}`, this.diagnostic = diagnostic, this.result = result, this.tsconfigFile = tsconfigFile;
+  }
+  /**
+   * code of typescript diagnostic, prefixed with "TS "
+   * @type {string}
+   */
+  code;
+  /**
+   * full ts diagnostic that caused this error
+   * @type {TSDiagnosticError}
+   */
+  diagnostic;
+  /**
+   * absolute path of tsconfig file where the error happened
+   * @type {string}
+   */
+  tsconfigFile;
+  /**
+   * native result if present, contains all errors in result.errors
+   * @type {any|undefined}
+   */
+  result;
+};
+
+// ../../../node_modules/vite-tsconfig-paths/dist/index.js
+import { resolve as resolve2 } from "path";
+var debug = (0, import_debug.default)("vite-tsconfig-paths");
+process.env.TEST === "vite-tsconfig-paths" && import_debug.default.enable("vite-tsconfig-paths");
+function createLogFile(logFilePath) {
+  let mtime;
+  try {
+    mtime = statSync(logFilePath).mtime.getTime();
+  } catch {
+  }
+  (!mtime || Date.now() - mtime > 1e4) && (debug("Clearing log file:", logFilePath), writeFileSync(logFilePath, ""));
+  let logFile = createWriteStream(logFilePath, {
+    flags: "a",
+    encoding: "utf-8"
+  });
+  return {
+    write(...event) {
+      logFile.write(event[0] + ": " + JSON.stringify(event[1]) + `
+`);
+    }
+  };
+}
+var isWindows = os.platform() == "win32", normalize = (p) => {
+  let output = vite.normalizePath(p);
+  return isWindows && output[1] === ":" && (output = output[0].toUpperCase() + output.substring(1)), output;
+}, parse22 = path7.parse, resolve = isWindows ? (...paths) => normalize(path7.win32.resolve(...paths)) : path7.posix.resolve, isAbsolute = isWindows ? path7.win32.isAbsolute : path7.posix.isAbsolute, join = path7.posix.join, relative = path7.posix.relative, basename = path7.posix.basename, dirname2 = path7.dirname, relativeImportRE = /^\.\.?(\/|$)/;
+function resolvePathMappings(paths, base) {
+  let sortedPatterns = Object.keys(paths).sort(
+    (a, b) => getPrefixLength(b) - getPrefixLength(a)
+  ), resolved = [];
+  for (let pattern of sortedPatterns) {
+    let relativePaths = paths[pattern];
+    pattern = escapeStringRegexp(pattern).replace(/\*/g, "(.+)"), resolved.push({
+      pattern: new RegExp("^" + pattern + "$"),
+      paths: relativePaths.map((relativePath) => resolve2(base, relativePath))
+    });
+  }
+  return resolved;
+}
+function getPrefixLength(pattern) {
+  let prefixLength = pattern.indexOf("*");
+  return pattern.substr(0, prefixLength).length;
+}
+function escapeStringRegexp(string) {
+  return string.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/-/g, "\\x2d");
+}
+var notApplicable = [void 0, !1], notFound = [void 0, !0], emptyDirectory = {
+  projects: Object.freeze([]),
+  lazyDiscovery: !1
+};
+function createTsconfigResolvers({
+  projectRoot,
+  workspaceRoot,
+  skip = () => !1,
+  logFile,
+  logger,
+  ...opts
+}) {
+  let initializing, directoryCache, resolversByProject, isFirstParseError = !0, hasTypeScriptDep = !1;
+  if (opts.parseNative)
+    try {
+      let pkgJson = fs4.readFileSync(
+        join2(workspaceRoot, "package.json"),
+        "utf8"
+      ), pkg = JSON.parse(pkgJson);
+      hasTypeScriptDep = "typescript" in { ...pkg.dependencies, ...pkg.devDependencies };
+    } catch (e) {
+      if (e.code != "ENOENT")
+        throw e;
+    }
+  let configNames = opts.configNames || ["tsconfig.json", "jsconfig.json"];
+  debug(
+    "Only tsconfig files with a name in this list are discoverable:",
+    configNames
+  );
+  let parseProject = async (tsconfigFile) => {
+    tsconfigFile = normalize(tsconfigFile);
+    try {
+      return hasTypeScriptDep ? await parseNative(tsconfigFile) : await parse(tsconfigFile);
+    } catch (error) {
+      return opts.ignoreConfigErrors ? (debug("[!] Failed to parse tsconfig file at %s", tsconfigFile), isFirstParseError && debug("Remove the `ignoreConfigErrors` option to see the error.")) : (logger.error(
+        '[tsconfig-paths] An error occurred while parsing "' + tsconfigFile + '". See below for details.' + (isFirstParseError ? " To disable this message, set the `ignoreConfigErrors` option to true." : ""),
+        { error }
+      ), logger.hasErrorLogged(error) || console.error(error)), isFirstParseError = !1, null;
+    }
+  }, onBeforeAddProject, onParseError, addProject = (project, data) => {
+    let tsconfigFile = project.tsconfigFile, dir = normalize(dirname2(tsconfigFile));
+    if (data ?? (data = directoryCache.get(dir)), data?.projects.some((p) => p.tsconfigFile === tsconfigFile))
+      return;
+    onBeforeAddProject?.(project), project.referenced && (project.referenced.forEach((projectRef) => {
+      addProject(projectRef);
+    }), data = directoryCache.get(dir));
+    let resolver = createResolver(project, opts, logFile);
+    resolver && resolversByProject.set(project, resolver), (!data || data === emptyDirectory) && directoryCache.set(
+      dir,
+      data = {
+        projects: [],
+        lazyDiscovery: null
+      }
+    ), data.projects.push(project);
+  }, loadProject = async (tsconfigFile, data) => {
+    let project = await parseProject(tsconfigFile);
+    project ? addProject(project, data) : onParseError?.(tsconfigFile);
+  }, sortProjects = (projects) => {
+    projects.sort(
+      (left, right) => left.tsconfigFile.localeCompare(right.tsconfigFile)
+    );
+  }, processConfigFile = async (dir, name, data = directoryCache.get(dir)) => {
+    if (!data)
+      return;
+    let file = join(dir, name);
+    data.projects.some((p) => p.tsconfigFile === file) || await loadProject(file, data);
+  }, loadEagerProjects = async () => {
+    let projectPaths;
+    if (opts.projects)
+      projectPaths = opts.projects.map((file) => (file.endsWith(".json") || (file = join2(file, "tsconfig.json")), resolve(projectRoot, file)));
+    else {
+      if (opts.projectDiscovery === "lazy")
+        return;
+      projectPaths = await findAll(workspaceRoot, {
+        configNames,
+        skip
+      });
+    }
+    debug("Eagerly parsing these projects:", projectPaths), await Promise.all(Array.from(new Set(projectPaths), (p) => loadProject(p)));
+    for (let data of directoryCache.values())
+      sortProjects(data.projects);
+  }, resetResolvers = () => {
+    directoryCache = /* @__PURE__ */ new Map(), resolversByProject = /* @__PURE__ */ new WeakMap(), initializing = loadEagerProjects();
+  }, discoverProjects = async (dir, data) => {
+    debug("Searching directory for tsconfig files:", dir);
+    let names = await readdir2(dir).catch(() => []);
+    await Promise.all(
+      names.filter((name) => configNames.includes(name)).map((name) => processConfigFile(dir, name, data))
+    ), data.projects.length ? (sortProjects(data.projects), debug.enabled && debug(
+      `Directory "${dir}" contains the following tsconfig files:`,
+      data.projects.map((p) => basename(p.tsconfigFile))
+    )) : (directoryCache.set(dir, emptyDirectory), debug("No tsconfig files found in directory:", dir));
+  };
+  return {
+    reset: resetResolvers,
+    get: async function* (importer) {
+      var _a;
+      await initializing;
+      let dir = normalize(importer), { root } = parse22(dir);
+      for (; dir !== (dir = dirname2(dir)) && dir !== root; ) {
+        let data = directoryCache.get(dir);
+        if (opts.projectDiscovery === "lazy") {
+          if (!data) {
+            if (skip(basename(dir))) {
+              directoryCache.set(dir, emptyDirectory);
+              continue;
+            }
+            directoryCache.set(
+              dir,
+              data = {
+                projects: [],
+                lazyDiscovery: null
+              }
+            );
+          }
+          await ((_a = data.lazyDiscovery) != null ? _a : data.lazyDiscovery = discoverProjects(dir, data));
+        } else if (!data)
+          continue;
+        for (let project of data.projects) {
+          let resolver = resolversByProject.get(project);
+          resolver && (yield resolver);
+        }
+      }
+    },
+    watch: (watcher) => {
+      onBeforeAddProject = (project) => {
+        var _a;
+        watcher.add(project.tsconfigFile), (_a = project.extended) == null || _a.forEach((parent) => {
+          watcher.add(parent.tsconfigFile);
+        });
+      }, onParseError = (tsconfigFile) => {
+        watcher.add(tsconfigFile);
+      }, watcher.on("all", (event, file) => {
+        let normalizedFile = normalize(file);
+        !normalizedFile.endsWith(".json") || !isAbsolute(normalizedFile) || (event === "add" ? configNames.includes(basename(normalizedFile)) && processConfigFile(
+          dirname2(normalizedFile),
+          basename(normalizedFile)
+        ).catch(console.error) : (event === "change" || event === "unlink") && invalidateConfigFile(
+          dirname2(normalizedFile),
+          basename(normalizedFile),
+          event
+        ));
+      });
+      function invalidateConfigFile(dir, name, event) {
+        let data = directoryCache.get(dir);
+        if (!data)
+          return;
+        let file = join(dir, name), index = data.projects.findIndex(
+          (project) => project.tsconfigFile === file
+        );
+        if (index !== -1) {
+          let project = data.projects[index];
+          debug(
+            `Unloading project because of ${event} event:`,
+            project.tsconfigFile
+          ), resolversByProject.delete(project), data.projects.splice(index, 1), event === "change" && (opts.projectDiscovery === "lazy" ? data.lazyDiscovery = null : loadProject(project.tsconfigFile, data).then(() => {
+            sortProjects(data.projects);
+          }).catch(console.error));
+        }
+      }
+    }
+  };
+}
+function createResolver(project, opts, logFile) {
+  var _a, _b, _c, _d, _e;
+  let configPath = project.tsconfigFile, config = project.tsconfig;
+  if (debug("Config loaded:", inspect({ configPath, config }, !1, 10, !0)), ((_a = config.files) == null ? void 0 : _a.length) == 0 && !((_b = config.include) != null && _b.length))
+    return debug(
+      `[!] Skipping "${configPath}" as no files can be matched since "files" is empty and "include" is missing or empty.`
+    ), null;
+  let compilerOptions = config.compilerOptions || {}, { baseUrl, paths } = compilerOptions, resolveWithBaseUrl = baseUrl ? async (viteResolve, id, importer) => {
+    if (id[0] === "/")
+      return;
+    let absoluteId = join2(baseUrl, id), resolvedId = await viteResolve(absoluteId, importer);
+    if (resolvedId)
+      return resolvedId.endsWith(".json") && !id.endsWith(".json") ? void 0 : (logFile?.write("resolvedWithBaseUrl", {
+        importer,
+        id,
+        resolvedId,
+        configPath
+      }), resolvedId);
+  } : void 0, resolveId;
+  if (paths) {
+    let pathsRootDir = resolvePathsRootDir(project), pathMappings = resolvePathMappings(paths, pathsRootDir), resolveWithPaths = async (viteResolve, id, importer) => {
+      let candidates = logFile ? [] : null;
+      for (let mapping of pathMappings) {
+        let match = id.match(mapping.pattern);
+        if (match)
+          for (let pathTemplate of mapping.paths) {
+            let starCount = 0, mappedId = pathTemplate.replace(/\*/g, () => {
+              let matchIndex = Math.min(++starCount, match.length - 1);
+              return match[matchIndex];
+            });
+            candidates?.push(mappedId);
+            let resolvedId = await viteResolve(mappedId, importer);
+            if (resolvedId)
+              return logFile?.write("resolvedWithPaths", {
+                importer,
+                id,
+                resolvedId,
+                configPath
+              }), resolvedId;
+          }
+      }
+      logFile?.write("notFound", {
+        importer,
+        id,
+        candidates,
+        configPath
+      });
+    };
+    resolveWithBaseUrl ? resolveId = async (viteResolve, id, importer) => {
+      var _a2;
+      return (_a2 = await resolveWithPaths(viteResolve, id, importer)) != null ? _a2 : await resolveWithBaseUrl(viteResolve, id, importer);
+    } : resolveId = resolveWithPaths;
+  } else if (resolveWithBaseUrl)
+    resolveId = resolveWithBaseUrl;
+  else
+    return debug(`[!] Skipping "${configPath}" as no paths or baseUrl are defined.`), null;
+  let configDir = normalize(dirname2(configPath)), outDir = compilerOptions.outDir && normalize(compilerOptions.outDir);
+  outDir && isAbsolute(outDir) && (outDir = relative(configDir, outDir));
+  let isIncludedRelative = getIncluder(
+    (_c = config.include) == null ? void 0 : _c.map((p) => ensureRelative(configDir, p)),
+    (_d = config.exclude) == null ? void 0 : _d.map((p) => ensureRelative(configDir, p)),
+    outDir
+  ), isImporterSupported = opts.loose ? () => !0 : (_e = opts.importerFilter) != null ? _e : (() => {
+    let extensionFilter = compilerOptions.allowJs || basename(configPath).startsWith("jsconfig.") ? /\.(astro|mdx|svelte|vue|[mc]?[jt]sx?)$/ : /\.[mc]?tsx?$/;
+    return (importer) => extensionFilter.test(importer);
+  })(), resolutionCache = /* @__PURE__ */ new Map(), hashQueryPattern = /[#?].+$/, queryPattern = /\?.+$/, dtsPattern = /\.d\.ts(\?|$)/;
+  return async (viteResolve, id, importer) => {
+    var _a2;
+    let importerFile = normalize(importer.replace(hashQueryPattern, ""));
+    if (!isImporterSupported(importerFile))
+      return logFile?.write("unsupportedExtension", { importer, id }), notApplicable;
+    let relativeImporterFile = relative(configDir, importerFile);
+    if (!isIncludedRelative(relativeImporterFile))
+      return logFile?.write("configMismatch", { importer, id, configPath }), notApplicable;
+    let query = (_a2 = queryPattern.exec(id)) == null ? void 0 : _a2[0];
+    query && (id = id.slice(0, -query.length));
+    let resolvedId = resolutionCache.get(id);
+    if (resolvedId)
+      logFile?.write("resolvedFromCache", {
+        importer,
+        id,
+        resolvedId,
+        configPath
+      });
+    else {
+      if (resolvedId = await resolveId(viteResolve, id, importer), !resolvedId)
+        return notFound;
+      resolutionCache.set(id, resolvedId);
+    }
+    return dtsPattern.test(resolvedId) ? (logFile?.write("resolvedToDeclarationFile", {
+      importer,
+      id,
+      resolvedId,
+      configPath
+    }), notApplicable) : (query && (resolvedId += query), [resolvedId, !0]);
+  };
+}
+function resolvePathsRootDir(project) {
+  var _a, _b;
+  if (project.result) {
+    let { options } = project.result;
+    return options && typeof options.pathsBasePath == "string" ? options.pathsBasePath : dirname2(project.tsconfigFile);
+  }
+  let baseUrl = (_a = project.tsconfig.compilerOptions) == null ? void 0 : _a.baseUrl;
+  if (baseUrl)
+    return baseUrl;
+  let projectWithPaths = (_b = project.extended) == null ? void 0 : _b.find(
+    (project2) => {
+      var _a2;
+      return (_a2 = project2.tsconfig.compilerOptions) == null ? void 0 : _a2.paths;
+    }
+  );
+  return dirname2((projectWithPaths ?? project).tsconfigFile);
+}
+var defaultInclude = ["**/*"], defaultExclude = [
+  "**/node_modules",
+  "**/bower_components",
+  "**/jspm_packages"
+];
+function getIncluder(includePaths = defaultInclude, excludePaths = defaultExclude, outDir) {
+  if (outDir && (excludePaths = excludePaths.concat(outDir)), includePaths.length || excludePaths.length) {
+    let includers = [], excluders = [];
+    return includePaths.forEach(addCompiledGlob, includers), excludePaths.forEach(addCompiledGlob, excluders), debug.enabled && debug("Compiled tsconfig globs:", {
+      include: {
+        globs: includePaths,
+        regexes: includers
+      },
+      exclude: {
+        globs: excludePaths,
+        regexes: excluders
+      }
+    }), (id) => {
+      id = id.replace(/\?.+$/, ""), relativeImportRE.test(id) || (id = "./" + id);
+      let test = (glob) => glob.test(id);
+      return includers.some(test) && !excluders.some(test);
+    };
+  }
+  return () => !0;
+}
+function addCompiledGlob(glob) {
+  let endsWithGlob = glob.split("/").pop().includes("*"), relativeGlob = relativeImportRE.test(glob) ? glob : "./" + glob;
+  endsWithGlob ? this.push(compileGlob(relativeGlob)) : (this.push(compileGlob(relativeGlob + "/**")), /\.\w+$/.test(glob) && this.push(compileGlob(relativeGlob)));
+}
+function compileGlob(glob) {
+  return (0, import_globrex.default)(glob, {
+    extended: !0,
+    globstar: !0
+  }).regex;
+}
+function ensureRelative(dir, path22) {
+  return isAbsolute2(path22) ? relative2(dir, path22) : path22;
+}
+var src_default = (opts = {}) => {
+  let tsconfigResolvers, isFirstBuild = !0, logFile = opts.logFile ? createLogFile(
+    opts.logFile === !0 ? "vite-tsconfig-paths.log" : opts.logFile
+  ) : null;
+  return debug("Plugin options:", opts), {
+    name: "vite-tsconfig-paths",
+    enforce: "pre",
+    configResolved(config) {
+      let projectRoot, workspaceRoot;
+      opts.root ? projectRoot = workspaceRoot = resolve(config.root, opts.root) : (projectRoot = normalize(config.root), workspaceRoot = normalize(vite2.searchForWorkspaceRoot(config.root))), debug("Project root:  ", projectRoot), debug("Workspace root:", workspaceRoot), tsconfigResolvers = createTsconfigResolvers({
+        ...opts,
+        projectRoot,
+        workspaceRoot,
+        logFile,
+        logger: config.logger,
+        skip(dir) {
+          return dir === ".git" || dir === "node_modules" ? !0 : typeof opts.skip == "function" ? opts.skip(dir) : !1;
+        }
+      }), tsconfigResolvers.reset();
+    },
+    configureServer(server) {
+      tsconfigResolvers.watch(server.watcher);
+    },
+    buildStart() {
+      if (isFirstBuild) {
+        isFirstBuild = !1;
+        return;
+      }
+      tsconfigResolvers.reset();
+    },
+    async resolveId(id, importer, options) {
+      if (!importer) {
+        logFile?.write("emptyImporter", { importer, id });
+        return;
+      }
+      if (relativeImportRE.test(id)) {
+        logFile?.write("relativeId", { importer, id });
+        return;
+      }
+      if (id.includes("\0")) {
+        logFile?.write("virtualId", { importer, id });
+        return;
+      }
+      let importerFile = importer;
+      if (importer[0] === "\0") {
+        let index = importer.indexOf("?");
+        if (index !== -1) {
+          let query = normalize(importer.slice(index + 1));
+          if (isAbsolute(query) && fs22.existsSync(query))
+            debug("Rewriting virtual importer to real file:", importer), importerFile = query;
+          else {
+            logFile?.write("virtualImporter", { importer, id });
+            return;
+          }
+        } else {
+          logFile?.write("virtualImporter", { importer, id });
+          return;
+        }
+      }
+      let resolveOptions = { ...options, skipSelf: !0 }, viteResolve = async (id2, importer2) => {
+        var _a;
+        return (_a = await this.resolve(id2, importer2, resolveOptions)) == null ? void 0 : _a.id;
+      };
+      for await (let resolveId of tsconfigResolvers.get(importerFile)) {
+        let [resolved, matched] = await resolveId(
+          viteResolve,
+          id,
+          importerFile
+        );
+        if (resolved)
+          return resolved;
+        if (matched)
+          break;
+      }
+    }
+  };
+};
+
+export {
+  src_default
+};