storybook 10.1.0-alpha.12 → 10.1.0-alpha.14

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

@@ -1,3171 +0,0 @@
-import CJS_COMPAT_NODE_URL_57ru1wfqqjv from 'node:url';
-import CJS_COMPAT_NODE_PATH_57ru1wfqqjv from 'node:path';
-import CJS_COMPAT_NODE_MODULE_57ru1wfqqjv from "node:module";
-
-var __filename = CJS_COMPAT_NODE_URL_57ru1wfqqjv.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_57ru1wfqqjv.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_57ru1wfqqjv.createRequire(import.meta.url);
-
-// ------------------------------------------------------------
-// end of CJS compatibility banner, injected by Storybook's esbuild configuration
-// ------------------------------------------------------------
-import {
-  any,
-  up,
-  up2
-} from "./chunk-DWXTZT3D.js";
-import {
-  __commonJS,
-  __require,
-  __toESM
-} from "./chunk-OP3INKUD.js";
-
-// ../node_modules/tinyglobby/node_modules/picomatch/lib/constants.js
-var require_constants = __commonJS({
-  "../node_modules/tinyglobby/node_modules/picomatch/lib/constants.js"(exports, module) {
-    "use strict";
-    var WIN_NO_SLASH = "[^\\\\/]", ONE_CHAR = "(?=.)", QMARK = "[^/]", END_ANCHOR = "(?:\\/|$)", START_ANCHOR = "(?:^|\\/)", DOTS_SLASH = `\\.{1,2}${END_ANCHOR}`, NO_DOT = "(?!\\.)", NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`, NO_DOT_SLASH = `(?!\\.{0,1}${END_ANCHOR})`, NO_DOTS_SLASH = `(?!${DOTS_SLASH})`, QMARK_NO_DOT = "[^.\\/]", STAR = `${QMARK}*?`, SEP = "/", POSIX_CHARS = {
-      DOT_LITERAL: "\\.",
-      PLUS_LITERAL: "\\+",
-      QMARK_LITERAL: "\\?",
-      SLASH_LITERAL: "\\/",
-      ONE_CHAR,
-      QMARK,
-      END_ANCHOR,
-      DOTS_SLASH,
-      NO_DOT,
-      NO_DOTS,
-      NO_DOT_SLASH,
-      NO_DOTS_SLASH,
-      QMARK_NO_DOT,
-      STAR,
-      START_ANCHOR,
-      SEP
-    }, WINDOWS_CHARS = {
-      ...POSIX_CHARS,
-      SLASH_LITERAL: "[\\\\/]",
-      QMARK: WIN_NO_SLASH,
-      STAR: `${WIN_NO_SLASH}*?`,
-      DOTS_SLASH: "\\.{1,2}(?:[\\\\/]|$)",
-      NO_DOT: "(?!\\.)",
-      NO_DOTS: "(?!(?:^|[\\\\/])\\.{1,2}(?:[\\\\/]|$))",
-      NO_DOT_SLASH: "(?!\\.{0,1}(?:[\\\\/]|$))",
-      NO_DOTS_SLASH: "(?!\\.{1,2}(?:[\\\\/]|$))",
-      QMARK_NO_DOT: "[^.\\\\/]",
-      START_ANCHOR: "(?:^|[\\\\/])",
-      END_ANCHOR: "(?:[\\\\/]|$)",
-      SEP: "\\"
-    }, POSIX_REGEX_SOURCE = {
-      alnum: "a-zA-Z0-9",
-      alpha: "a-zA-Z",
-      ascii: "\\x00-\\x7F",
-      blank: " \\t",
-      cntrl: "\\x00-\\x1F\\x7F",
-      digit: "0-9",
-      graph: "\\x21-\\x7E",
-      lower: "a-z",
-      print: "\\x20-\\x7E ",
-      punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
-      space: " \\t\\r\\n\\v\\f",
-      upper: "A-Z",
-      word: "A-Za-z0-9_",
-      xdigit: "A-Fa-f0-9"
-    };
-    module.exports = {
-      MAX_LENGTH: 1024 * 64,
-      POSIX_REGEX_SOURCE,
-      // regular expressions
-      REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
-      REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
-      REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
-      REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
-      REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
-      REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
-      // Replace globs with equivalent patterns to reduce parsing time.
-      REPLACEMENTS: {
-        __proto__: null,
-        "***": "*",
-        "**/**": "**",
-        "**/**/**": "**"
-      },
-      // Digits
-      CHAR_0: 48,
-      /* 0 */
-      CHAR_9: 57,
-      /* 9 */
-      // Alphabet chars.
-      CHAR_UPPERCASE_A: 65,
-      /* A */
-      CHAR_LOWERCASE_A: 97,
-      /* a */
-      CHAR_UPPERCASE_Z: 90,
-      /* Z */
-      CHAR_LOWERCASE_Z: 122,
-      /* z */
-      CHAR_LEFT_PARENTHESES: 40,
-      /* ( */
-      CHAR_RIGHT_PARENTHESES: 41,
-      /* ) */
-      CHAR_ASTERISK: 42,
-      /* * */
-      // Non-alphabetic chars.
-      CHAR_AMPERSAND: 38,
-      /* & */
-      CHAR_AT: 64,
-      /* @ */
-      CHAR_BACKWARD_SLASH: 92,
-      /* \ */
-      CHAR_CARRIAGE_RETURN: 13,
-      /* \r */
-      CHAR_CIRCUMFLEX_ACCENT: 94,
-      /* ^ */
-      CHAR_COLON: 58,
-      /* : */
-      CHAR_COMMA: 44,
-      /* , */
-      CHAR_DOT: 46,
-      /* . */
-      CHAR_DOUBLE_QUOTE: 34,
-      /* " */
-      CHAR_EQUAL: 61,
-      /* = */
-      CHAR_EXCLAMATION_MARK: 33,
-      /* ! */
-      CHAR_FORM_FEED: 12,
-      /* \f */
-      CHAR_FORWARD_SLASH: 47,
-      /* / */
-      CHAR_GRAVE_ACCENT: 96,
-      /* ` */
-      CHAR_HASH: 35,
-      /* # */
-      CHAR_HYPHEN_MINUS: 45,
-      /* - */
-      CHAR_LEFT_ANGLE_BRACKET: 60,
-      /* < */
-      CHAR_LEFT_CURLY_BRACE: 123,
-      /* { */
-      CHAR_LEFT_SQUARE_BRACKET: 91,
-      /* [ */
-      CHAR_LINE_FEED: 10,
-      /* \n */
-      CHAR_NO_BREAK_SPACE: 160,
-      /* \u00A0 */
-      CHAR_PERCENT: 37,
-      /* % */
-      CHAR_PLUS: 43,
-      /* + */
-      CHAR_QUESTION_MARK: 63,
-      /* ? */
-      CHAR_RIGHT_ANGLE_BRACKET: 62,
-      /* > */
-      CHAR_RIGHT_CURLY_BRACE: 125,
-      /* } */
-      CHAR_RIGHT_SQUARE_BRACKET: 93,
-      /* ] */
-      CHAR_SEMICOLON: 59,
-      /* ; */
-      CHAR_SINGLE_QUOTE: 39,
-      /* ' */
-      CHAR_SPACE: 32,
-      /*   */
-      CHAR_TAB: 9,
-      /* \t */
-      CHAR_UNDERSCORE: 95,
-      /* _ */
-      CHAR_VERTICAL_LINE: 124,
-      /* | */
-      CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
-      /* \uFEFF */
-      /**
-       * Create EXTGLOB_CHARS
-       */
-      extglobChars(chars) {
-        return {
-          "!": { type: "negate", open: "(?:(?!(?:", close: `))${chars.STAR})` },
-          "?": { type: "qmark", open: "(?:", close: ")?" },
-          "+": { type: "plus", open: "(?:", close: ")+" },
-          "*": { type: "star", open: "(?:", close: ")*" },
-          "@": { type: "at", open: "(?:", close: ")" }
-        };
-      },
-      /**
-       * Create GLOB_CHARS
-       */
-      globChars(win32) {
-        return win32 === !0 ? WINDOWS_CHARS : POSIX_CHARS;
-      }
-    };
-  }
-});
-
-// ../node_modules/tinyglobby/node_modules/picomatch/lib/utils.js
-var require_utils = __commonJS({
-  "../node_modules/tinyglobby/node_modules/picomatch/lib/utils.js"(exports) {
-    "use strict";
-    var {
-      REGEX_BACKSLASH,
-      REGEX_REMOVE_BACKSLASH,
-      REGEX_SPECIAL_CHARS,
-      REGEX_SPECIAL_CHARS_GLOBAL
-    } = require_constants();
-    exports.isObject = (val) => val !== null && typeof val == "object" && !Array.isArray(val);
-    exports.hasRegexChars = (str) => REGEX_SPECIAL_CHARS.test(str);
-    exports.isRegexChar = (str) => str.length === 1 && exports.hasRegexChars(str);
-    exports.escapeRegex = (str) => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1");
-    exports.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/");
-    exports.isWindows = () => {
-      if (typeof navigator < "u" && navigator.platform) {
-        let platform = navigator.platform.toLowerCase();
-        return platform === "win32" || platform === "windows";
-      }
-      return typeof process < "u" && process.platform ? process.platform === "win32" : !1;
-    };
-    exports.removeBackslashes = (str) => str.replace(REGEX_REMOVE_BACKSLASH, (match) => match === "\\" ? "" : match);
-    exports.escapeLast = (input, char, lastIdx) => {
-      let idx = input.lastIndexOf(char, lastIdx);
-      return idx === -1 ? input : input[idx - 1] === "\\" ? exports.escapeLast(input, char, idx - 1) : `${input.slice(0, idx)}\\${input.slice(idx)}`;
-    };
-    exports.removePrefix = (input, state = {}) => {
-      let output = input;
-      return output.startsWith("./") && (output = output.slice(2), state.prefix = "./"), output;
-    };
-    exports.wrapOutput = (input, state = {}, options = {}) => {
-      let prepend = options.contains ? "" : "^", append = options.contains ? "" : "$", output = `${prepend}(?:${input})${append}`;
-      return state.negated === !0 && (output = `(?:^(?!${output}).*$)`), output;
-    };
-    exports.basename = (path4, { windows } = {}) => {
-      let segs = path4.split(windows ? /[\\/]/ : "/"), last = segs[segs.length - 1];
-      return last === "" ? segs[segs.length - 2] : last;
-    };
-  }
-});
-
-// ../node_modules/tinyglobby/node_modules/picomatch/lib/scan.js
-var require_scan = __commonJS({
-  "../node_modules/tinyglobby/node_modules/picomatch/lib/scan.js"(exports, module) {
-    "use strict";
-    var utils = require_utils(), {
-      CHAR_ASTERISK,
-      /* * */
-      CHAR_AT,
-      /* @ */
-      CHAR_BACKWARD_SLASH,
-      /* \ */
-      CHAR_COMMA,
-      /* , */
-      CHAR_DOT,
-      /* . */
-      CHAR_EXCLAMATION_MARK,
-      /* ! */
-      CHAR_FORWARD_SLASH,
-      /* / */
-      CHAR_LEFT_CURLY_BRACE,
-      /* { */
-      CHAR_LEFT_PARENTHESES,
-      /* ( */
-      CHAR_LEFT_SQUARE_BRACKET,
-      /* [ */
-      CHAR_PLUS,
-      /* + */
-      CHAR_QUESTION_MARK,
-      /* ? */
-      CHAR_RIGHT_CURLY_BRACE,
-      /* } */
-      CHAR_RIGHT_PARENTHESES,
-      /* ) */
-      CHAR_RIGHT_SQUARE_BRACKET
-      /* ] */
-    } = require_constants(), isPathSeparator = (code) => code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH, depth = (token) => {
-      token.isPrefix !== !0 && (token.depth = token.isGlobstar ? 1 / 0 : 1);
-    }, scan = (input, options) => {
-      let opts = options || {}, length = input.length - 1, scanToEnd = opts.parts === !0 || opts.scanToEnd === !0, slashes = [], tokens = [], parts = [], str = input, index = -1, start = 0, lastIndex = 0, isBrace = !1, isBracket = !1, isGlob = !1, isExtglob = !1, isGlobstar = !1, braceEscaped = !1, backslashes = !1, negated = !1, negatedExtglob = !1, finished = !1, braces = 0, prev, code, token = { value: "", depth: 0, isGlob: !1 }, eos = () => index >= length, peek = () => str.charCodeAt(index + 1), advance = () => (prev = code, str.charCodeAt(++index));
-      for (; index < length; ) {
-        code = advance();
-        let next;
-        if (code === CHAR_BACKWARD_SLASH) {
-          backslashes = token.backslashes = !0, code = advance(), code === CHAR_LEFT_CURLY_BRACE && (braceEscaped = !0);
-          continue;
-        }
-        if (braceEscaped === !0 || code === CHAR_LEFT_CURLY_BRACE) {
-          for (braces++; eos() !== !0 && (code = advance()); ) {
-            if (code === CHAR_BACKWARD_SLASH) {
-              backslashes = token.backslashes = !0, advance();
-              continue;
-            }
-            if (code === CHAR_LEFT_CURLY_BRACE) {
-              braces++;
-              continue;
-            }
-            if (braceEscaped !== !0 && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
-              if (isBrace = token.isBrace = !0, isGlob = token.isGlob = !0, finished = !0, scanToEnd === !0)
-                continue;
-              break;
-            }
-            if (braceEscaped !== !0 && code === CHAR_COMMA) {
-              if (isBrace = token.isBrace = !0, isGlob = token.isGlob = !0, finished = !0, scanToEnd === !0)
-                continue;
-              break;
-            }
-            if (code === CHAR_RIGHT_CURLY_BRACE && (braces--, braces === 0)) {
-              braceEscaped = !1, isBrace = token.isBrace = !0, finished = !0;
-              break;
-            }
-          }
-          if (scanToEnd === !0)
-            continue;
-          break;
-        }
-        if (code === CHAR_FORWARD_SLASH) {
-          if (slashes.push(index), tokens.push(token), token = { value: "", depth: 0, isGlob: !1 }, finished === !0) continue;
-          if (prev === CHAR_DOT && index === start + 1) {
-            start += 2;
-            continue;
-          }
-          lastIndex = index + 1;
-          continue;
-        }
-        if (opts.noext !== !0 && (code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK) === !0 && peek() === CHAR_LEFT_PARENTHESES) {
-          if (isGlob = token.isGlob = !0, isExtglob = token.isExtglob = !0, finished = !0, code === CHAR_EXCLAMATION_MARK && index === start && (negatedExtglob = !0), scanToEnd === !0) {
-            for (; eos() !== !0 && (code = advance()); ) {
-              if (code === CHAR_BACKWARD_SLASH) {
-                backslashes = token.backslashes = !0, code = advance();
-                continue;
-              }
-              if (code === CHAR_RIGHT_PARENTHESES) {
-                isGlob = token.isGlob = !0, finished = !0;
-                break;
-              }
-            }
-            continue;
-          }
-          break;
-        }
-        if (code === CHAR_ASTERISK) {
-          if (prev === CHAR_ASTERISK && (isGlobstar = token.isGlobstar = !0), isGlob = token.isGlob = !0, finished = !0, scanToEnd === !0)
-            continue;
-          break;
-        }
-        if (code === CHAR_QUESTION_MARK) {
-          if (isGlob = token.isGlob = !0, finished = !0, scanToEnd === !0)
-            continue;
-          break;
-        }
-        if (code === CHAR_LEFT_SQUARE_BRACKET) {
-          for (; eos() !== !0 && (next = advance()); ) {
-            if (next === CHAR_BACKWARD_SLASH) {
-              backslashes = token.backslashes = !0, advance();
-              continue;
-            }
-            if (next === CHAR_RIGHT_SQUARE_BRACKET) {
-              isBracket = token.isBracket = !0, isGlob = token.isGlob = !0, finished = !0;
-              break;
-            }
-          }
-          if (scanToEnd === !0)
-            continue;
-          break;
-        }
-        if (opts.nonegate !== !0 && code === CHAR_EXCLAMATION_MARK && index === start) {
-          negated = token.negated = !0, start++;
-          continue;
-        }
-        if (opts.noparen !== !0 && code === CHAR_LEFT_PARENTHESES) {
-          if (isGlob = token.isGlob = !0, scanToEnd === !0) {
-            for (; eos() !== !0 && (code = advance()); ) {
-              if (code === CHAR_LEFT_PARENTHESES) {
-                backslashes = token.backslashes = !0, code = advance();
-                continue;
-              }
-              if (code === CHAR_RIGHT_PARENTHESES) {
-                finished = !0;
-                break;
-              }
-            }
-            continue;
-          }
-          break;
-        }
-        if (isGlob === !0) {
-          if (finished = !0, scanToEnd === !0)
-            continue;
-          break;
-        }
-      }
-      opts.noext === !0 && (isExtglob = !1, isGlob = !1);
-      let base = str, prefix = "", glob = "";
-      start > 0 && (prefix = str.slice(0, start), str = str.slice(start), lastIndex -= start), base && isGlob === !0 && lastIndex > 0 ? (base = str.slice(0, lastIndex), glob = str.slice(lastIndex)) : isGlob === !0 ? (base = "", glob = str) : base = str, base && base !== "" && base !== "/" && base !== str && isPathSeparator(base.charCodeAt(base.length - 1)) && (base = base.slice(0, -1)), opts.unescape === !0 && (glob && (glob = utils.removeBackslashes(glob)), base && backslashes === !0 && (base = utils.removeBackslashes(base)));
-      let state = {
-        prefix,
-        input,
-        start,
-        base,
-        glob,
-        isBrace,
-        isBracket,
-        isGlob,
-        isExtglob,
-        isGlobstar,
-        negated,
-        negatedExtglob
-      };
-      if (opts.tokens === !0 && (state.maxDepth = 0, isPathSeparator(code) || tokens.push(token), state.tokens = tokens), opts.parts === !0 || opts.tokens === !0) {
-        let prevIndex;
-        for (let idx = 0; idx < slashes.length; idx++) {
-          let n = prevIndex ? prevIndex + 1 : start, i = slashes[idx], value = input.slice(n, i);
-          opts.tokens && (idx === 0 && start !== 0 ? (tokens[idx].isPrefix = !0, tokens[idx].value = prefix) : tokens[idx].value = value, depth(tokens[idx]), state.maxDepth += tokens[idx].depth), (idx !== 0 || value !== "") && parts.push(value), prevIndex = i;
-        }
-        if (prevIndex && prevIndex + 1 < input.length) {
-          let value = input.slice(prevIndex + 1);
-          parts.push(value), opts.tokens && (tokens[tokens.length - 1].value = value, depth(tokens[tokens.length - 1]), state.maxDepth += tokens[tokens.length - 1].depth);
-        }
-        state.slashes = slashes, state.parts = parts;
-      }
-      return state;
-    };
-    module.exports = scan;
-  }
-});
-
-// ../node_modules/tinyglobby/node_modules/picomatch/lib/parse.js
-var require_parse = __commonJS({
-  "../node_modules/tinyglobby/node_modules/picomatch/lib/parse.js"(exports, module) {
-    "use strict";
-    var constants3 = require_constants(), utils = require_utils(), {
-      MAX_LENGTH,
-      POSIX_REGEX_SOURCE,
-      REGEX_NON_SPECIAL_CHARS,
-      REGEX_SPECIAL_CHARS_BACKREF,
-      REPLACEMENTS
-    } = constants3, expandRange = (args, options) => {
-      if (typeof options.expandRange == "function")
-        return options.expandRange(...args, options);
-      args.sort();
-      let value = `[${args.join("-")}]`;
-      try {
-        new RegExp(value);
-      } catch {
-        return args.map((v) => utils.escapeRegex(v)).join("..");
-      }
-      return value;
-    }, syntaxError = (type, char) => `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`, parse = (input, options) => {
-      if (typeof input != "string")
-        throw new TypeError("Expected a string");
-      input = REPLACEMENTS[input] || input;
-      let opts = { ...options }, max = typeof opts.maxLength == "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH, len = input.length;
-      if (len > max)
-        throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
-      let bos = { type: "bos", value: "", output: opts.prepend || "" }, tokens = [bos], capture = opts.capture ? "" : "?:", PLATFORM_CHARS = constants3.globChars(opts.windows), EXTGLOB_CHARS = constants3.extglobChars(PLATFORM_CHARS), {
-        DOT_LITERAL,
-        PLUS_LITERAL,
-        SLASH_LITERAL,
-        ONE_CHAR,
-        DOTS_SLASH,
-        NO_DOT,
-        NO_DOT_SLASH,
-        NO_DOTS_SLASH,
-        QMARK,
-        QMARK_NO_DOT,
-        STAR,
-        START_ANCHOR
-      } = PLATFORM_CHARS, globstar = (opts2) => `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`, nodot = opts.dot ? "" : NO_DOT, qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT, star = opts.bash === !0 ? globstar(opts) : STAR;
-      opts.capture && (star = `(${star})`), typeof opts.noext == "boolean" && (opts.noextglob = opts.noext);
-      let state = {
-        input,
-        index: -1,
-        start: 0,
-        dot: opts.dot === !0,
-        consumed: "",
-        output: "",
-        prefix: "",
-        backtrack: !1,
-        negated: !1,
-        brackets: 0,
-        braces: 0,
-        parens: 0,
-        quotes: 0,
-        globstar: !1,
-        tokens
-      };
-      input = utils.removePrefix(input, state), len = input.length;
-      let extglobs = [], braces = [], stack = [], prev = bos, value, eos = () => state.index === len - 1, peek = state.peek = (n = 1) => input[state.index + n], advance = state.advance = () => input[++state.index] || "", remaining = () => input.slice(state.index + 1), consume = (value2 = "", num = 0) => {
-        state.consumed += value2, state.index += num;
-      }, append = (token) => {
-        state.output += token.output != null ? token.output : token.value, consume(token.value);
-      }, negate = () => {
-        let count = 1;
-        for (; peek() === "!" && (peek(2) !== "(" || peek(3) === "?"); )
-          advance(), state.start++, count++;
-        return count % 2 === 0 ? !1 : (state.negated = !0, state.start++, !0);
-      }, increment = (type) => {
-        state[type]++, stack.push(type);
-      }, decrement = (type) => {
-        state[type]--, stack.pop();
-      }, push = (tok) => {
-        if (prev.type === "globstar") {
-          let isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace"), isExtglob = tok.extglob === !0 || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
-          tok.type !== "slash" && tok.type !== "paren" && !isBrace && !isExtglob && (state.output = state.output.slice(0, -prev.output.length), prev.type = "star", prev.value = "*", prev.output = star, state.output += prev.output);
-        }
-        if (extglobs.length && tok.type !== "paren" && (extglobs[extglobs.length - 1].inner += tok.value), (tok.value || tok.output) && append(tok), prev && prev.type === "text" && tok.type === "text") {
-          prev.output = (prev.output || prev.value) + tok.value, prev.value += tok.value;
-          return;
-        }
-        tok.prev = prev, tokens.push(tok), prev = tok;
-      }, extglobOpen = (type, value2) => {
-        let token = { ...EXTGLOB_CHARS[value2], conditions: 1, inner: "" };
-        token.prev = prev, token.parens = state.parens, token.output = state.output;
-        let output = (opts.capture ? "(" : "") + token.open;
-        increment("parens"), push({ type, value: value2, output: state.output ? "" : ONE_CHAR }), push({ type: "paren", extglob: !0, value: advance(), output }), extglobs.push(token);
-      }, extglobClose = (token) => {
-        let output = token.close + (opts.capture ? ")" : ""), rest;
-        if (token.type === "negate") {
-          let extglobStar = star;
-          if (token.inner && token.inner.length > 1 && token.inner.includes("/") && (extglobStar = globstar(opts)), (extglobStar !== star || eos() || /^\)+$/.test(remaining())) && (output = token.close = `)$))${extglobStar}`), token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
-            let expression = parse(rest, { ...options, fastpaths: !1 }).output;
-            output = token.close = `)${expression})${extglobStar})`;
-          }
-          token.prev.type === "bos" && (state.negatedExtglob = !0);
-        }
-        push({ type: "paren", extglob: !0, value, output }), decrement("parens");
-      };
-      if (opts.fastpaths !== !1 && !/(^[*!]|[/()[\]{}"])/.test(input)) {
-        let backslashes = !1, output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => first === "\\" ? (backslashes = !0, m) : first === "?" ? esc ? esc + first + (rest ? QMARK.repeat(rest.length) : "") : index === 0 ? qmarkNoDot + (rest ? QMARK.repeat(rest.length) : "") : QMARK.repeat(chars.length) : first === "." ? DOT_LITERAL.repeat(chars.length) : first === "*" ? esc ? esc + first + (rest ? star : "") : star : esc ? m : `\\${m}`);
-        return backslashes === !0 && (opts.unescape === !0 ? output = output.replace(/\\/g, "") : output = output.replace(/\\+/g, (m) => m.length % 2 === 0 ? "\\\\" : m ? "\\" : "")), output === input && opts.contains === !0 ? (state.output = input, state) : (state.output = utils.wrapOutput(output, state, options), state);
-      }
-      for (; !eos(); ) {
-        if (value = advance(), value === "\0")
-          continue;
-        if (value === "\\") {
-          let next = peek();
-          if (next === "/" && opts.bash !== !0 || next === "." || next === ";")
-            continue;
-          if (!next) {
-            value += "\\", push({ type: "text", value });
-            continue;
-          }
-          let match = /^\\+/.exec(remaining()), slashes = 0;
-          if (match && match[0].length > 2 && (slashes = match[0].length, state.index += slashes, slashes % 2 !== 0 && (value += "\\")), opts.unescape === !0 ? value = advance() : value += advance(), state.brackets === 0) {
-            push({ type: "text", value });
-            continue;
-          }
-        }
-        if (state.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) {
-          if (opts.posix !== !1 && value === ":") {
-            let inner = prev.value.slice(1);
-            if (inner.includes("[") && (prev.posix = !0, inner.includes(":"))) {
-              let idx = prev.value.lastIndexOf("["), pre = prev.value.slice(0, idx), rest2 = prev.value.slice(idx + 2), posix2 = POSIX_REGEX_SOURCE[rest2];
-              if (posix2) {
-                prev.value = pre + posix2, state.backtrack = !0, advance(), !bos.output && tokens.indexOf(prev) === 1 && (bos.output = ONE_CHAR);
-                continue;
-              }
-            }
-          }
-          (value === "[" && peek() !== ":" || value === "-" && peek() === "]") && (value = `\\${value}`), value === "]" && (prev.value === "[" || prev.value === "[^") && (value = `\\${value}`), opts.posix === !0 && value === "!" && prev.value === "[" && (value = "^"), prev.value += value, append({ value });
-          continue;
-        }
-        if (state.quotes === 1 && value !== '"') {
-          value = utils.escapeRegex(value), prev.value += value, append({ value });
-          continue;
-        }
-        if (value === '"') {
-          state.quotes = state.quotes === 1 ? 0 : 1, opts.keepQuotes === !0 && push({ type: "text", value });
-          continue;
-        }
-        if (value === "(") {
-          increment("parens"), push({ type: "paren", value });
-          continue;
-        }
-        if (value === ")") {
-          if (state.parens === 0 && opts.strictBrackets === !0)
-            throw new SyntaxError(syntaxError("opening", "("));
-          let extglob = extglobs[extglobs.length - 1];
-          if (extglob && state.parens === extglob.parens + 1) {
-            extglobClose(extglobs.pop());
-            continue;
-          }
-          push({ type: "paren", value, output: state.parens ? ")" : "\\)" }), decrement("parens");
-          continue;
-        }
-        if (value === "[") {
-          if (opts.nobracket === !0 || !remaining().includes("]")) {
-            if (opts.nobracket !== !0 && opts.strictBrackets === !0)
-              throw new SyntaxError(syntaxError("closing", "]"));
-            value = `\\${value}`;
-          } else
-            increment("brackets");
-          push({ type: "bracket", value });
-          continue;
-        }
-        if (value === "]") {
-          if (opts.nobracket === !0 || prev && prev.type === "bracket" && prev.value.length === 1) {
-            push({ type: "text", value, output: `\\${value}` });
-            continue;
-          }
-          if (state.brackets === 0) {
-            if (opts.strictBrackets === !0)
-              throw new SyntaxError(syntaxError("opening", "["));
-            push({ type: "text", value, output: `\\${value}` });
-            continue;
-          }
-          decrement("brackets");
-          let prevValue = prev.value.slice(1);
-          if (prev.posix !== !0 && prevValue[0] === "^" && !prevValue.includes("/") && (value = `/${value}`), prev.value += value, append({ value }), opts.literalBrackets === !1 || utils.hasRegexChars(prevValue))
-            continue;
-          let escaped = utils.escapeRegex(prev.value);
-          if (state.output = state.output.slice(0, -prev.value.length), opts.literalBrackets === !0) {
-            state.output += escaped, prev.value = escaped;
-            continue;
-          }
-          prev.value = `(${capture}${escaped}|${prev.value})`, state.output += prev.value;
-          continue;
-        }
-        if (value === "{" && opts.nobrace !== !0) {
-          increment("braces");
-          let open = {
-            type: "brace",
-            value,
-            output: "(",
-            outputIndex: state.output.length,
-            tokensIndex: state.tokens.length
-          };
-          braces.push(open), push(open);
-          continue;
-        }
-        if (value === "}") {
-          let brace = braces[braces.length - 1];
-          if (opts.nobrace === !0 || !brace) {
-            push({ type: "text", value, output: value });
-            continue;
-          }
-          let output = ")";
-          if (brace.dots === !0) {
-            let arr = tokens.slice(), range = [];
-            for (let i = arr.length - 1; i >= 0 && (tokens.pop(), arr[i].type !== "brace"); i--)
-              arr[i].type !== "dots" && range.unshift(arr[i].value);
-            output = expandRange(range, opts), state.backtrack = !0;
-          }
-          if (brace.comma !== !0 && brace.dots !== !0) {
-            let out = state.output.slice(0, brace.outputIndex), toks = state.tokens.slice(brace.tokensIndex);
-            brace.value = brace.output = "\\{", value = output = "\\}", state.output = out;
-            for (let t of toks)
-              state.output += t.output || t.value;
-          }
-          push({ type: "brace", value, output }), decrement("braces"), braces.pop();
-          continue;
-        }
-        if (value === "|") {
-          extglobs.length > 0 && extglobs[extglobs.length - 1].conditions++, push({ type: "text", value });
-          continue;
-        }
-        if (value === ",") {
-          let output = value, brace = braces[braces.length - 1];
-          brace && stack[stack.length - 1] === "braces" && (brace.comma = !0, output = "|"), push({ type: "comma", value, output });
-          continue;
-        }
-        if (value === "/") {
-          if (prev.type === "dot" && state.index === state.start + 1) {
-            state.start = state.index + 1, state.consumed = "", state.output = "", tokens.pop(), prev = bos;
-            continue;
-          }
-          push({ type: "slash", value, output: SLASH_LITERAL });
-          continue;
-        }
-        if (value === ".") {
-          if (state.braces > 0 && prev.type === "dot") {
-            prev.value === "." && (prev.output = DOT_LITERAL);
-            let brace = braces[braces.length - 1];
-            prev.type = "dots", prev.output += value, prev.value += value, brace.dots = !0;
-            continue;
-          }
-          if (state.braces + state.parens === 0 && prev.type !== "bos" && prev.type !== "slash") {
-            push({ type: "text", value, output: DOT_LITERAL });
-            continue;
-          }
-          push({ type: "dot", value, output: DOT_LITERAL });
-          continue;
-        }
-        if (value === "?") {
-          if (!(prev && prev.value === "(") && opts.noextglob !== !0 && peek() === "(" && peek(2) !== "?") {
-            extglobOpen("qmark", value);
-            continue;
-          }
-          if (prev && prev.type === "paren") {
-            let next = peek(), output = value;
-            (prev.value === "(" && !/[!=<:]/.test(next) || next === "<" && !/<([!=]|\w+>)/.test(remaining())) && (output = `\\${value}`), push({ type: "text", value, output });
-            continue;
-          }
-          if (opts.dot !== !0 && (prev.type === "slash" || prev.type === "bos")) {
-            push({ type: "qmark", value, output: QMARK_NO_DOT });
-            continue;
-          }
-          push({ type: "qmark", value, output: QMARK });
-          continue;
-        }
-        if (value === "!") {
-          if (opts.noextglob !== !0 && peek() === "(" && (peek(2) !== "?" || !/[!=<:]/.test(peek(3)))) {
-            extglobOpen("negate", value);
-            continue;
-          }
-          if (opts.nonegate !== !0 && state.index === 0) {
-            negate();
-            continue;
-          }
-        }
-        if (value === "+") {
-          if (opts.noextglob !== !0 && peek() === "(" && peek(2) !== "?") {
-            extglobOpen("plus", value);
-            continue;
-          }
-          if (prev && prev.value === "(" || opts.regex === !1) {
-            push({ type: "plus", value, output: PLUS_LITERAL });
-            continue;
-          }
-          if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state.parens > 0) {
-            push({ type: "plus", value });
-            continue;
-          }
-          push({ type: "plus", value: PLUS_LITERAL });
-          continue;
-        }
-        if (value === "@") {
-          if (opts.noextglob !== !0 && peek() === "(" && peek(2) !== "?") {
-            push({ type: "at", extglob: !0, value, output: "" });
-            continue;
-          }
-          push({ type: "text", value });
-          continue;
-        }
-        if (value !== "*") {
-          (value === "$" || value === "^") && (value = `\\${value}`);
-          let match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
-          match && (value += match[0], state.index += match[0].length), push({ type: "text", value });
-          continue;
-        }
-        if (prev && (prev.type === "globstar" || prev.star === !0)) {
-          prev.type = "star", prev.star = !0, prev.value += value, prev.output = star, state.backtrack = !0, state.globstar = !0, consume(value);
-          continue;
-        }
-        let rest = remaining();
-        if (opts.noextglob !== !0 && /^\([^?]/.test(rest)) {
-          extglobOpen("star", value);
-          continue;
-        }
-        if (prev.type === "star") {
-          if (opts.noglobstar === !0) {
-            consume(value);
-            continue;
-          }
-          let prior = prev.prev, before = prior.prev, isStart = prior.type === "slash" || prior.type === "bos", afterStar = before && (before.type === "star" || before.type === "globstar");
-          if (opts.bash === !0 && (!isStart || rest[0] && rest[0] !== "/")) {
-            push({ type: "star", value, output: "" });
-            continue;
-          }
-          let isBrace = state.braces > 0 && (prior.type === "comma" || prior.type === "brace"), isExtglob = extglobs.length && (prior.type === "pipe" || prior.type === "paren");
-          if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) {
-            push({ type: "star", value, output: "" });
-            continue;
-          }
-          for (; rest.slice(0, 3) === "/**"; ) {
-            let after = input[state.index + 4];
-            if (after && after !== "/")
-              break;
-            rest = rest.slice(3), consume("/**", 3);
-          }
-          if (prior.type === "bos" && eos()) {
-            prev.type = "globstar", prev.value += value, prev.output = globstar(opts), state.output = prev.output, state.globstar = !0, consume(value);
-            continue;
-          }
-          if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && eos()) {
-            state.output = state.output.slice(0, -(prior.output + prev.output).length), prior.output = `(?:${prior.output}`, prev.type = "globstar", prev.output = globstar(opts) + (opts.strictSlashes ? ")" : "|$)"), prev.value += value, state.globstar = !0, state.output += prior.output + prev.output, consume(value);
-            continue;
-          }
-          if (prior.type === "slash" && prior.prev.type !== "bos" && rest[0] === "/") {
-            let end = rest[1] !== void 0 ? "|$" : "";
-            state.output = state.output.slice(0, -(prior.output + prev.output).length), prior.output = `(?:${prior.output}`, prev.type = "globstar", prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`, prev.value += value, state.output += prior.output + prev.output, state.globstar = !0, consume(value + advance()), push({ type: "slash", value: "/", output: "" });
-            continue;
-          }
-          if (prior.type === "bos" && rest[0] === "/") {
-            prev.type = "globstar", prev.value += value, prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`, state.output = prev.output, state.globstar = !0, consume(value + advance()), push({ type: "slash", value: "/", output: "" });
-            continue;
-          }
-          state.output = state.output.slice(0, -prev.output.length), prev.type = "globstar", prev.output = globstar(opts), prev.value += value, state.output += prev.output, state.globstar = !0, consume(value);
-          continue;
-        }
-        let token = { type: "star", value, output: star };
-        if (opts.bash === !0) {
-          token.output = ".*?", (prev.type === "bos" || prev.type === "slash") && (token.output = nodot + token.output), push(token);
-          continue;
-        }
-        if (prev && (prev.type === "bracket" || prev.type === "paren") && opts.regex === !0) {
-          token.output = value, push(token);
-          continue;
-        }
-        (state.index === state.start || prev.type === "slash" || prev.type === "dot") && (prev.type === "dot" ? (state.output += NO_DOT_SLASH, prev.output += NO_DOT_SLASH) : opts.dot === !0 ? (state.output += NO_DOTS_SLASH, prev.output += NO_DOTS_SLASH) : (state.output += nodot, prev.output += nodot), peek() !== "*" && (state.output += ONE_CHAR, prev.output += ONE_CHAR)), push(token);
-      }
-      for (; state.brackets > 0; ) {
-        if (opts.strictBrackets === !0) throw new SyntaxError(syntaxError("closing", "]"));
-        state.output = utils.escapeLast(state.output, "["), decrement("brackets");
-      }
-      for (; state.parens > 0; ) {
-        if (opts.strictBrackets === !0) throw new SyntaxError(syntaxError("closing", ")"));
-        state.output = utils.escapeLast(state.output, "("), decrement("parens");
-      }
-      for (; state.braces > 0; ) {
-        if (opts.strictBrackets === !0) throw new SyntaxError(syntaxError("closing", "}"));
-        state.output = utils.escapeLast(state.output, "{"), decrement("braces");
-      }
-      if (opts.strictSlashes !== !0 && (prev.type === "star" || prev.type === "bracket") && push({ type: "maybe_slash", value: "", output: `${SLASH_LITERAL}?` }), state.backtrack === !0) {
-        state.output = "";
-        for (let token of state.tokens)
-          state.output += token.output != null ? token.output : token.value, token.suffix && (state.output += token.suffix);
-      }
-      return state;
-    };
-    parse.fastpaths = (input, options) => {
-      let opts = { ...options }, max = typeof opts.maxLength == "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH, len = input.length;
-      if (len > max)
-        throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
-      input = REPLACEMENTS[input] || input;
-      let {
-        DOT_LITERAL,
-        SLASH_LITERAL,
-        ONE_CHAR,
-        DOTS_SLASH,
-        NO_DOT,
-        NO_DOTS,
-        NO_DOTS_SLASH,
-        STAR,
-        START_ANCHOR
-      } = constants3.globChars(opts.windows), nodot = opts.dot ? NO_DOTS : NO_DOT, slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT, capture = opts.capture ? "" : "?:", state = { negated: !1, prefix: "" }, star = opts.bash === !0 ? ".*?" : STAR;
-      opts.capture && (star = `(${star})`);
-      let globstar = (opts2) => opts2.noglobstar === !0 ? star : `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`, create = (str) => {
-        switch (str) {
-          case "*":
-            return `${nodot}${ONE_CHAR}${star}`;
-          case ".*":
-            return `${DOT_LITERAL}${ONE_CHAR}${star}`;
-          case "*.*":
-            return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
-          case "*/*":
-            return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
-          case "**":
-            return nodot + globstar(opts);
-          case "**/*":
-            return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
-          case "**/*.*":
-            return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
-          case "**/.*":
-            return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
-          default: {
-            let match = /^(.*?)\.(\w+)$/.exec(str);
-            if (!match) return;
-            let source2 = create(match[1]);
-            return source2 ? source2 + DOT_LITERAL + match[2] : void 0;
-          }
-        }
-      }, output = utils.removePrefix(input, state), source = create(output);
-      return source && opts.strictSlashes !== !0 && (source += `${SLASH_LITERAL}?`), source;
-    };
-    module.exports = parse;
-  }
-});
-
-// ../node_modules/tinyglobby/node_modules/picomatch/lib/picomatch.js
-var require_picomatch = __commonJS({
-  "../node_modules/tinyglobby/node_modules/picomatch/lib/picomatch.js"(exports, module) {
-    "use strict";
-    var scan = require_scan(), parse = require_parse(), utils = require_utils(), constants3 = require_constants(), isObject = (val) => val && typeof val == "object" && !Array.isArray(val), picomatch2 = (glob, options, returnState = !1) => {
-      if (Array.isArray(glob)) {
-        let fns = glob.map((input) => picomatch2(input, options, returnState));
-        return (str) => {
-          for (let isMatch of fns) {
-            let state2 = isMatch(str);
-            if (state2) return state2;
-          }
-          return !1;
-        };
-      }
-      let isState = isObject(glob) && glob.tokens && glob.input;
-      if (glob === "" || typeof glob != "string" && !isState)
-        throw new TypeError("Expected pattern to be a non-empty string");
-      let opts = options || {}, posix2 = opts.windows, regex = isState ? picomatch2.compileRe(glob, options) : picomatch2.makeRe(glob, options, !1, !0), state = regex.state;
-      delete regex.state;
-      let isIgnored = () => !1;
-      if (opts.ignore) {
-        let ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
-        isIgnored = picomatch2(opts.ignore, ignoreOpts, returnState);
-      }
-      let matcher = (input, returnObject = !1) => {
-        let { isMatch, match, output } = picomatch2.test(input, regex, options, { glob, posix: posix2 }), result = { glob, state, regex, posix: posix2, input, output, match, isMatch };
-        return typeof opts.onResult == "function" && opts.onResult(result), isMatch === !1 ? (result.isMatch = !1, returnObject ? result : !1) : isIgnored(input) ? (typeof opts.onIgnore == "function" && opts.onIgnore(result), result.isMatch = !1, returnObject ? result : !1) : (typeof opts.onMatch == "function" && opts.onMatch(result), returnObject ? result : !0);
-      };
-      return returnState && (matcher.state = state), matcher;
-    };
-    picomatch2.test = (input, regex, options, { glob, posix: posix2 } = {}) => {
-      if (typeof input != "string")
-        throw new TypeError("Expected input to be a string");
-      if (input === "")
-        return { isMatch: !1, output: "" };
-      let opts = options || {}, format = opts.format || (posix2 ? utils.toPosixSlashes : null), match = input === glob, output = match && format ? format(input) : input;
-      return match === !1 && (output = format ? format(input) : input, match = output === glob), (match === !1 || opts.capture === !0) && (opts.matchBase === !0 || opts.basename === !0 ? match = picomatch2.matchBase(input, regex, options, posix2) : match = regex.exec(output)), { isMatch: !!match, match, output };
-    };
-    picomatch2.matchBase = (input, glob, options) => (glob instanceof RegExp ? glob : picomatch2.makeRe(glob, options)).test(utils.basename(input));
-    picomatch2.isMatch = (str, patterns, options) => picomatch2(patterns, options)(str);
-    picomatch2.parse = (pattern, options) => Array.isArray(pattern) ? pattern.map((p) => picomatch2.parse(p, options)) : parse(pattern, { ...options, fastpaths: !1 });
-    picomatch2.scan = (input, options) => scan(input, options);
-    picomatch2.compileRe = (state, options, returnOutput = !1, returnState = !1) => {
-      if (returnOutput === !0)
-        return state.output;
-      let opts = options || {}, prepend = opts.contains ? "" : "^", append = opts.contains ? "" : "$", source = `${prepend}(?:${state.output})${append}`;
-      state && state.negated === !0 && (source = `^(?!${source}).*$`);
-      let regex = picomatch2.toRegex(source, options);
-      return returnState === !0 && (regex.state = state), regex;
-    };
-    picomatch2.makeRe = (input, options = {}, returnOutput = !1, returnState = !1) => {
-      if (!input || typeof input != "string")
-        throw new TypeError("Expected a non-empty string");
-      let parsed = { negated: !1, fastpaths: !0 };
-      return options.fastpaths !== !1 && (input[0] === "." || input[0] === "*") && (parsed.output = parse.fastpaths(input, options)), parsed.output || (parsed = parse(input, options)), picomatch2.compileRe(parsed, options, returnOutput, returnState);
-    };
-    picomatch2.toRegex = (source, options) => {
-      try {
-        let opts = options || {};
-        return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
-      } catch (err) {
-        if (options && options.debug === !0) throw err;
-        return /$^/;
-      }
-    };
-    picomatch2.constants = constants3;
-    module.exports = picomatch2;
-  }
-});
-
-// ../node_modules/tinyglobby/node_modules/picomatch/index.js
-var require_picomatch2 = __commonJS({
-  "../node_modules/tinyglobby/node_modules/picomatch/index.js"(exports, module) {
-    "use strict";
-    var pico = require_picomatch(), utils = require_utils();
-    function picomatch2(glob, options, returnState = !1) {
-      return options && (options.windows === null || options.windows === void 0) && (options = { ...options, windows: utils.isWindows() }), pico(glob, options, returnState);
-    }
-    Object.assign(picomatch2, pico);
-    module.exports = picomatch2;
-  }
-});
-
-// ../node_modules/isexe/windows.js
-var require_windows = __commonJS({
-  "../node_modules/isexe/windows.js"(exports, module) {
-    module.exports = isexe;
-    isexe.sync = sync2;
-    var fs = __require("fs");
-    function checkPathExt(path4, options) {
-      var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
-      if (!pathext || (pathext = pathext.split(";"), pathext.indexOf("") !== -1))
-        return !0;
-      for (var i = 0; i < pathext.length; i++) {
-        var p = pathext[i].toLowerCase();
-        if (p && path4.substr(-p.length).toLowerCase() === p)
-          return !0;
-      }
-      return !1;
-    }
-    function checkStat(stat, path4, options) {
-      return !stat.isSymbolicLink() && !stat.isFile() ? !1 : checkPathExt(path4, options);
-    }
-    function isexe(path4, options, cb) {
-      fs.stat(path4, function(er, stat) {
-        cb(er, er ? !1 : checkStat(stat, path4, options));
-      });
-    }
-    function sync2(path4, options) {
-      return checkStat(fs.statSync(path4), path4, options);
-    }
-  }
-});
-
-// ../node_modules/isexe/mode.js
-var require_mode = __commonJS({
-  "../node_modules/isexe/mode.js"(exports, module) {
-    module.exports = isexe;
-    isexe.sync = sync2;
-    var fs = __require("fs");
-    function isexe(path4, options, cb) {
-      fs.stat(path4, function(er, stat) {
-        cb(er, er ? !1 : checkStat(stat, options));
-      });
-    }
-    function sync2(path4, options) {
-      return checkStat(fs.statSync(path4), options);
-    }
-    function checkStat(stat, options) {
-      return stat.isFile() && checkMode(stat, options);
-    }
-    function checkMode(stat, options) {
-      var mod = stat.mode, uid = stat.uid, gid = stat.gid, myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid(), myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid(), u = parseInt("100", 8), g = parseInt("010", 8), o = parseInt("001", 8), ug = u | g, ret = mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
-      return ret;
-    }
-  }
-});
-
-// ../node_modules/isexe/index.js
-var require_isexe = __commonJS({
-  "../node_modules/isexe/index.js"(exports, module) {
-    var fs = __require("fs"), core;
-    process.platform === "win32" || global.TESTING_WINDOWS ? core = require_windows() : core = require_mode();
-    module.exports = isexe;
-    isexe.sync = sync2;
-    function isexe(path4, options, cb) {
-      if (typeof options == "function" && (cb = options, options = {}), !cb) {
-        if (typeof Promise != "function")
-          throw new TypeError("callback not provided");
-        return new Promise(function(resolve3, reject) {
-          isexe(path4, options || {}, function(er, is) {
-            er ? reject(er) : resolve3(is);
-          });
-        });
-      }
-      core(path4, options || {}, function(er, is) {
-        er && (er.code === "EACCES" || options && options.ignoreErrors) && (er = null, is = !1), cb(er, is);
-      });
-    }
-    function sync2(path4, options) {
-      try {
-        return core.sync(path4, options || {});
-      } catch (er) {
-        if (options && options.ignoreErrors || er.code === "EACCES")
-          return !1;
-        throw er;
-      }
-    }
-  }
-});
-
-// ../node_modules/which/which.js
-var require_which = __commonJS({
-  "../node_modules/which/which.js"(exports, module) {
-    var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys", path4 = __require("path"), COLON = isWindows ? ";" : ":", isexe = require_isexe(), getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" }), getPathInfo = (cmd, opt) => {
-      let colon = opt.colon || COLON, pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [
-        // windows always checks the cwd first
-        ...isWindows ? [process.cwd()] : [],
-        ...(opt.path || process.env.PATH || /* istanbul ignore next: very unusual */
-        "").split(colon)
-      ], pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "", pathExt = isWindows ? pathExtExe.split(colon) : [""];
-      return isWindows && cmd.indexOf(".") !== -1 && pathExt[0] !== "" && pathExt.unshift(""), {
-        pathEnv,
-        pathExt,
-        pathExtExe
-      };
-    }, which = (cmd, opt, cb) => {
-      typeof opt == "function" && (cb = opt, opt = {}), opt || (opt = {});
-      let { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt), found = [], step = (i) => new Promise((resolve3, reject) => {
-        if (i === pathEnv.length)
-          return opt.all && found.length ? resolve3(found) : reject(getNotFoundError(cmd));
-        let ppRaw = pathEnv[i], pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw, pCmd = path4.join(pathPart, cmd), p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-        resolve3(subStep(p, i, 0));
-      }), subStep = (p, i, ii) => new Promise((resolve3, reject) => {
-        if (ii === pathExt.length)
-          return resolve3(step(i + 1));
-        let ext = pathExt[ii];
-        isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
-          if (!er && is)
-            if (opt.all)
-              found.push(p + ext);
-            else
-              return resolve3(p + ext);
-          return resolve3(subStep(p, i, ii + 1));
-        });
-      });
-      return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
-    }, whichSync = (cmd, opt) => {
-      opt = opt || {};
-      let { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt), found = [];
-      for (let i = 0; i < pathEnv.length; i++) {
-        let ppRaw = pathEnv[i], pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw, pCmd = path4.join(pathPart, cmd), p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-        for (let j = 0; j < pathExt.length; j++) {
-          let cur = p + pathExt[j];
-          try {
-            if (isexe.sync(cur, { pathExt: pathExtExe }))
-              if (opt.all)
-                found.push(cur);
-              else
-                return cur;
-          } catch {
-          }
-        }
-      }
-      if (opt.all && found.length)
-        return found;
-      if (opt.nothrow)
-        return null;
-      throw getNotFoundError(cmd);
-    };
-    module.exports = which;
-    which.sync = whichSync;
-  }
-});
-
-// ../node_modules/path-key/index.js
-var require_path_key = __commonJS({
-  "../node_modules/path-key/index.js"(exports, module) {
-    "use strict";
-    var pathKey2 = (options = {}) => {
-      let environment = options.env || process.env;
-      return (options.platform || process.platform) !== "win32" ? "PATH" : Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
-    };
-    module.exports = pathKey2;
-    module.exports.default = pathKey2;
-  }
-});
-
-// ../node_modules/cross-spawn/lib/util/resolveCommand.js
-var require_resolveCommand = __commonJS({
-  "../node_modules/cross-spawn/lib/util/resolveCommand.js"(exports, module) {
-    "use strict";
-    var path4 = __require("path"), which = require_which(), getPathKey = require_path_key();
-    function resolveCommandAttempt(parsed, withoutPathExt) {
-      let env = parsed.options.env || process.env, cwd = process.cwd(), hasCustomCwd = parsed.options.cwd != null, shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled;
-      if (shouldSwitchCwd)
-        try {
-          process.chdir(parsed.options.cwd);
-        } catch {
-        }
-      let resolved;
-      try {
-        resolved = which.sync(parsed.command, {
-          path: env[getPathKey({ env })],
-          pathExt: withoutPathExt ? path4.delimiter : void 0
-        });
-      } catch {
-      } finally {
-        shouldSwitchCwd && process.chdir(cwd);
-      }
-      return resolved && (resolved = path4.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved)), resolved;
-    }
-    function resolveCommand(parsed) {
-      return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, !0);
-    }
-    module.exports = resolveCommand;
-  }
-});
-
-// ../node_modules/cross-spawn/lib/util/escape.js
-var require_escape = __commonJS({
-  "../node_modules/cross-spawn/lib/util/escape.js"(exports, module) {
-    "use strict";
-    var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
-    function escapeCommand(arg) {
-      return arg = arg.replace(metaCharsRegExp, "^$1"), arg;
-    }
-    function escapeArgument(arg, doubleEscapeMetaChars) {
-      return arg = `${arg}`, arg = arg.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"'), arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1"), arg = `"${arg}"`, arg = arg.replace(metaCharsRegExp, "^$1"), doubleEscapeMetaChars && (arg = arg.replace(metaCharsRegExp, "^$1")), arg;
-    }
-    module.exports.command = escapeCommand;
-    module.exports.argument = escapeArgument;
-  }
-});
-
-// ../node_modules/shebang-regex/index.js
-var require_shebang_regex = __commonJS({
-  "../node_modules/shebang-regex/index.js"(exports, module) {
-    "use strict";
-    module.exports = /^#!(.*)/;
-  }
-});
-
-// ../node_modules/shebang-command/index.js
-var require_shebang_command = __commonJS({
-  "../node_modules/shebang-command/index.js"(exports, module) {
-    "use strict";
-    var shebangRegex = require_shebang_regex();
-    module.exports = (string = "") => {
-      let match = string.match(shebangRegex);
-      if (!match)
-        return null;
-      let [path4, argument] = match[0].replace(/#! ?/, "").split(" "), binary = path4.split("/").pop();
-      return binary === "env" ? argument : argument ? `${binary} ${argument}` : binary;
-    };
-  }
-});
-
-// ../node_modules/cross-spawn/lib/util/readShebang.js
-var require_readShebang = __commonJS({
-  "../node_modules/cross-spawn/lib/util/readShebang.js"(exports, module) {
-    "use strict";
-    var fs = __require("fs"), shebangCommand = require_shebang_command();
-    function readShebang(command) {
-      let buffer = Buffer.alloc(150), fd;
-      try {
-        fd = fs.openSync(command, "r"), fs.readSync(fd, buffer, 0, 150, 0), fs.closeSync(fd);
-      } catch {
-      }
-      return shebangCommand(buffer.toString());
-    }
-    module.exports = readShebang;
-  }
-});
-
-// ../node_modules/cross-spawn/lib/parse.js
-var require_parse2 = __commonJS({
-  "../node_modules/cross-spawn/lib/parse.js"(exports, module) {
-    "use strict";
-    var path4 = __require("path"), resolveCommand = require_resolveCommand(), escape = require_escape(), readShebang = require_readShebang(), isWin2 = process.platform === "win32", isExecutableRegExp = /\.(?:com|exe)$/i, isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
-    function detectShebang(parsed) {
-      parsed.file = resolveCommand(parsed);
-      let shebang = parsed.file && readShebang(parsed.file);
-      return shebang ? (parsed.args.unshift(parsed.file), parsed.command = shebang, resolveCommand(parsed)) : parsed.file;
-    }
-    function parseNonShell(parsed) {
-      if (!isWin2)
-        return parsed;
-      let commandFile = detectShebang(parsed), needsShell = !isExecutableRegExp.test(commandFile);
-      if (parsed.options.forceShell || needsShell) {
-        let needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-        parsed.command = path4.normalize(parsed.command), parsed.command = escape.command(parsed.command), parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
-        let shellCommand = [parsed.command].concat(parsed.args).join(" ");
-        parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`], parsed.command = process.env.comspec || "cmd.exe", parsed.options.windowsVerbatimArguments = !0;
-      }
-      return parsed;
-    }
-    function parse(command, args, options) {
-      args && !Array.isArray(args) && (options = args, args = null), args = args ? args.slice(0) : [], options = Object.assign({}, options);
-      let parsed = {
-        command,
-        args,
-        options,
-        file: void 0,
-        original: {
-          command,
-          args
-        }
-      };
-      return options.shell ? parsed : parseNonShell(parsed);
-    }
-    module.exports = parse;
-  }
-});
-
-// ../node_modules/cross-spawn/lib/enoent.js
-var require_enoent = __commonJS({
-  "../node_modules/cross-spawn/lib/enoent.js"(exports, module) {
-    "use strict";
-    var isWin2 = process.platform === "win32";
-    function notFoundError(original, syscall) {
-      return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
-        code: "ENOENT",
-        errno: "ENOENT",
-        syscall: `${syscall} ${original.command}`,
-        path: original.command,
-        spawnargs: original.args
-      });
-    }
-    function hookChildProcess(cp, parsed) {
-      if (!isWin2)
-        return;
-      let originalEmit = cp.emit;
-      cp.emit = function(name, arg1) {
-        if (name === "exit") {
-          let err = verifyENOENT(arg1, parsed);
-          if (err)
-            return originalEmit.call(cp, "error", err);
-        }
-        return originalEmit.apply(cp, arguments);
-      };
-    }
-    function verifyENOENT(status, parsed) {
-      return isWin2 && status === 1 && !parsed.file ? notFoundError(parsed.original, "spawn") : null;
-    }
-    function verifyENOENTSync(status, parsed) {
-      return isWin2 && status === 1 && !parsed.file ? notFoundError(parsed.original, "spawnSync") : null;
-    }
-    module.exports = {
-      hookChildProcess,
-      verifyENOENT,
-      verifyENOENTSync,
-      notFoundError
-    };
-  }
-});
-
-// ../node_modules/cross-spawn/index.js
-var require_cross_spawn = __commonJS({
-  "../node_modules/cross-spawn/index.js"(exports, module) {
-    "use strict";
-    var cp = __require("child_process"), parse = require_parse2(), enoent = require_enoent();
-    function spawn(command, args, options) {
-      let parsed = parse(command, args, options), spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
-      return enoent.hookChildProcess(spawned, parsed), spawned;
-    }
-    function spawnSync(command, args, options) {
-      let parsed = parse(command, args, options), result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
-      return result.error = result.error || enoent.verifyENOENTSync(result.status, parsed), result;
-    }
-    module.exports = spawn;
-    module.exports.spawn = spawn;
-    module.exports.sync = spawnSync;
-    module.exports._parse = parse;
-    module.exports._enoent = enoent;
-  }
-});
-
-// ../node_modules/merge-stream/index.js
-var require_merge_stream = __commonJS({
-  "../node_modules/merge-stream/index.js"(exports, module) {
-    "use strict";
-    var { PassThrough } = __require("stream");
-    module.exports = function() {
-      var sources = [], output = new PassThrough({ objectMode: !0 });
-      return output.setMaxListeners(0), output.add = add, output.isEmpty = isEmpty, output.on("unpipe", remove), Array.prototype.slice.call(arguments).forEach(add), output;
-      function add(source) {
-        return Array.isArray(source) ? (source.forEach(add), this) : (sources.push(source), source.once("end", remove.bind(null, source)), source.once("error", output.emit.bind(output, "error")), source.pipe(output, { end: !1 }), this);
-      }
-      function isEmpty() {
-        return sources.length == 0;
-      }
-      function remove(source) {
-        sources = sources.filter(function(it) {
-          return it !== source;
-        }), !sources.length && output.readable && output.end();
-      }
-    };
-  }
-});
-
-// src/common/utils/paths.ts
-import { join, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
-
-// ../node_modules/tinyglobby/dist/index.mjs
-import nativeFs2 from "fs";
-import path, { posix } from "path";
-import { fileURLToPath } from "url";
-
-// ../node_modules/tinyglobby/node_modules/fdir/dist/index.mjs
-import { createRequire } from "module";
-import { basename, dirname, normalize, relative, resolve, sep } from "path";
-import * as nativeFs from "fs";
-var __require2 = createRequire(import.meta.url);
-function cleanPath(path4) {
-  let normalized = normalize(path4);
-  return normalized.length > 1 && normalized[normalized.length - 1] === sep && (normalized = normalized.substring(0, normalized.length - 1)), normalized;
-}
-var SLASHES_REGEX = /[\\/]/g;
-function convertSlashes(path4, separator) {
-  return path4.replace(SLASHES_REGEX, separator);
-}
-var WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
-function isRootDirectory(path4) {
-  return path4 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path4);
-}
-function normalizePath(path4, options) {
-  let { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options, pathNeedsCleaning = process.platform === "win32" && path4.includes("/") || path4.startsWith(".");
-  if (resolvePaths && (path4 = resolve(path4)), (normalizePath$1 || pathNeedsCleaning) && (path4 = cleanPath(path4)), path4 === ".") return "";
-  let needsSeperator = path4[path4.length - 1] !== pathSeparator;
-  return convertSlashes(needsSeperator ? path4 + pathSeparator : path4, pathSeparator);
-}
-function joinPathWithBasePath(filename, directoryPath) {
-  return directoryPath + filename;
-}
-function joinPathWithRelativePath(root, options) {
-  return function(filename, directoryPath) {
-    return directoryPath.startsWith(root) ? directoryPath.slice(root.length) + filename : convertSlashes(relative(root, directoryPath), options.pathSeparator) + options.pathSeparator + filename;
-  };
-}
-function joinPath(filename) {
-  return filename;
-}
-function joinDirectoryPath(filename, directoryPath, separator) {
-  return directoryPath + filename + separator;
-}
-function build$7(root, options) {
-  let { relativePaths, includeBasePath } = options;
-  return relativePaths && root ? joinPathWithRelativePath(root, options) : includeBasePath ? joinPathWithBasePath : joinPath;
-}
-function pushDirectoryWithRelativePath(root) {
-  return function(directoryPath, paths) {
-    paths.push(directoryPath.substring(root.length) || ".");
-  };
-}
-function pushDirectoryFilterWithRelativePath(root) {
-  return function(directoryPath, paths, filters) {
-    let relativePath = directoryPath.substring(root.length) || ".";
-    filters.every((filter) => filter(relativePath, !0)) && paths.push(relativePath);
-  };
-}
-var pushDirectory = (directoryPath, paths) => {
-  paths.push(directoryPath || ".");
-}, pushDirectoryFilter = (directoryPath, paths, filters) => {
-  let path4 = directoryPath || ".";
-  filters.every((filter) => filter(path4, !0)) && paths.push(path4);
-}, empty$2 = () => {
-};
-function build$6(root, options) {
-  let { includeDirs, filters, relativePaths } = options;
-  return includeDirs ? relativePaths ? filters && filters.length ? pushDirectoryFilterWithRelativePath(root) : pushDirectoryWithRelativePath(root) : filters && filters.length ? pushDirectoryFilter : pushDirectory : empty$2;
-}
-var pushFileFilterAndCount = (filename, _paths, counts, filters) => {
-  filters.every((filter) => filter(filename, !1)) && counts.files++;
-}, pushFileFilter = (filename, paths, _counts, filters) => {
-  filters.every((filter) => filter(filename, !1)) && paths.push(filename);
-}, pushFileCount = (_filename, _paths, counts, _filters) => {
-  counts.files++;
-}, pushFile = (filename, paths) => {
-  paths.push(filename);
-}, empty$1 = () => {
-};
-function build$5(options) {
-  let { excludeFiles, filters, onlyCounts } = options;
-  return excludeFiles ? empty$1 : filters && filters.length ? onlyCounts ? pushFileFilterAndCount : pushFileFilter : onlyCounts ? pushFileCount : pushFile;
-}
-var getArray = (paths) => paths, getArrayGroup = () => [""].slice(0, 0);
-function build$4(options) {
-  return options.group ? getArrayGroup : getArray;
-}
-var groupFiles = (groups, directory, files) => {
-  groups.push({
-    directory,
-    files,
-    dir: directory
-  });
-}, empty = () => {
-};
-function build$3(options) {
-  return options.group ? groupFiles : empty;
-}
-var resolveSymlinksAsync = function(path4, state, callback$1) {
-  let { queue, fs, options: { suppressErrors } } = state;
-  queue.enqueue(), fs.realpath(path4, (error, resolvedPath) => {
-    if (error) return queue.dequeue(suppressErrors ? null : error, state);
-    fs.stat(resolvedPath, (error$1, stat) => {
-      if (error$1) return queue.dequeue(suppressErrors ? null : error$1, state);
-      if (stat.isDirectory() && isRecursive(path4, resolvedPath, state)) return queue.dequeue(null, state);
-      callback$1(stat, resolvedPath), queue.dequeue(null, state);
-    });
-  });
-}, resolveSymlinks = function(path4, state, callback$1) {
-  let { queue, fs, options: { suppressErrors } } = state;
-  queue.enqueue();
-  try {
-    let resolvedPath = fs.realpathSync(path4), stat = fs.statSync(resolvedPath);
-    if (stat.isDirectory() && isRecursive(path4, resolvedPath, state)) return;
-    callback$1(stat, resolvedPath);
-  } catch (e) {
-    if (!suppressErrors) throw e;
-  }
-};
-function build$2(options, isSynchronous) {
-  return !options.resolveSymlinks || options.excludeSymlinks ? null : isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
-}
-function isRecursive(path4, resolved, state) {
-  if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state);
-  let parent = dirname(path4), depth = 1;
-  for (; parent !== state.root && depth < 2; ) {
-    let resolvedPath = state.symlinks.get(parent);
-    !!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath)) ? depth++ : parent = dirname(parent);
-  }
-  return state.symlinks.set(path4, resolved), depth > 1;
-}
-function isRecursiveUsingRealPaths(resolved, state) {
-  return state.visited.includes(resolved + state.options.pathSeparator);
-}
-var onlyCountsSync = (state) => state.counts, groupsSync = (state) => state.groups, defaultSync = (state) => state.paths, limitFilesSync = (state) => state.paths.slice(0, state.options.maxFiles), onlyCountsAsync = (state, error, callback$1) => (report(error, callback$1, state.counts, state.options.suppressErrors), null), defaultAsync = (state, error, callback$1) => (report(error, callback$1, state.paths, state.options.suppressErrors), null), limitFilesAsync = (state, error, callback$1) => (report(error, callback$1, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors), null), groupsAsync = (state, error, callback$1) => (report(error, callback$1, state.groups, state.options.suppressErrors), null);
-function report(error, callback$1, output, suppressErrors) {
-  callback$1(error && !suppressErrors ? error : null, output);
-}
-function build$1(options, isSynchronous) {
-  let { onlyCounts, group, maxFiles } = options;
-  return onlyCounts ? isSynchronous ? onlyCountsSync : onlyCountsAsync : group ? isSynchronous ? groupsSync : groupsAsync : maxFiles ? isSynchronous ? limitFilesSync : limitFilesAsync : isSynchronous ? defaultSync : defaultAsync;
-}
-var readdirOpts = { withFileTypes: !0 }, walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
-  if (state.queue.enqueue(), currentDepth < 0) return state.queue.dequeue(null, state);
-  let { fs } = state;
-  state.visited.push(crawlPath), state.counts.directories++, fs.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => {
-    callback$1(entries, directoryPath, currentDepth), state.queue.dequeue(state.options.suppressErrors ? null : error, state);
-  });
-}, walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
-  let { fs } = state;
-  if (currentDepth < 0) return;
-  state.visited.push(crawlPath), state.counts.directories++;
-  let entries = [];
-  try {
-    entries = fs.readdirSync(crawlPath || ".", readdirOpts);
-  } catch (e) {
-    if (!state.options.suppressErrors) throw e;
-  }
-  callback$1(entries, directoryPath, currentDepth);
-};
-function build(isSynchronous) {
-  return isSynchronous ? walkSync : walkAsync;
-}
-var Queue = class {
-  count = 0;
-  constructor(onQueueEmpty) {
-    this.onQueueEmpty = onQueueEmpty;
-  }
-  enqueue() {
-    return this.count++, this.count;
-  }
-  dequeue(error, output) {
-    this.onQueueEmpty && (--this.count <= 0 || error) && (this.onQueueEmpty(error, output), error && (output.controller.abort(), this.onQueueEmpty = void 0));
-  }
-}, Counter = class {
-  _files = 0;
-  _directories = 0;
-  set files(num) {
-    this._files = num;
-  }
-  get files() {
-    return this._files;
-  }
-  set directories(num) {
-    this._directories = num;
-  }
-  get directories() {
-    return this._directories;
-  }
-  /**
-  * @deprecated use `directories` instead
-  */
-  /* c8 ignore next 3 */
-  get dirs() {
-    return this._directories;
-  }
-}, Aborter = class {
-  aborted = !1;
-  abort() {
-    this.aborted = !0;
-  }
-}, Walker = class {
-  root;
-  isSynchronous;
-  state;
-  joinPath;
-  pushDirectory;
-  pushFile;
-  getArray;
-  groupFiles;
-  resolveSymlink;
-  walkDirectory;
-  callbackInvoker;
-  constructor(root, options, callback$1) {
-    this.isSynchronous = !callback$1, this.callbackInvoker = build$1(options, this.isSynchronous), this.root = normalizePath(root, options), this.state = {
-      root: isRootDirectory(this.root) ? this.root : this.root.slice(0, -1),
-      paths: [""].slice(0, 0),
-      groups: [],
-      counts: new Counter(),
-      options,
-      queue: new Queue((error, state) => this.callbackInvoker(state, error, callback$1)),
-      symlinks: /* @__PURE__ */ new Map(),
-      visited: [""].slice(0, 0),
-      controller: new Aborter(),
-      fs: options.fs || nativeFs
-    }, this.joinPath = build$7(this.root, options), this.pushDirectory = build$6(this.root, options), this.pushFile = build$5(options), this.getArray = build$4(options), this.groupFiles = build$3(options), this.resolveSymlink = build$2(options, this.isSynchronous), this.walkDirectory = build(this.isSynchronous);
-  }
-  start() {
-    return this.pushDirectory(this.root, this.state.paths, this.state.options.filters), this.walkDirectory(this.state, this.root, this.root, this.state.options.maxDepth, this.walk), this.isSynchronous ? this.callbackInvoker(this.state, null) : null;
-  }
-  walk = (entries, directoryPath, depth) => {
-    let { paths, options: { filters, resolveSymlinks: resolveSymlinks$1, excludeSymlinks, exclude, maxFiles, signal, useRealPaths, pathSeparator }, controller } = this.state;
-    if (controller.aborted || signal && signal.aborted || maxFiles && paths.length > maxFiles) return;
-    let files = this.getArray(this.state.paths);
-    for (let i = 0; i < entries.length; ++i) {
-      let entry = entries[i];
-      if (entry.isFile() || entry.isSymbolicLink() && !resolveSymlinks$1 && !excludeSymlinks) {
-        let filename = this.joinPath(entry.name, directoryPath);
-        this.pushFile(filename, files, this.state.counts, filters);
-      } else if (entry.isDirectory()) {
-        let path4 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
-        if (exclude && exclude(entry.name, path4)) continue;
-        this.pushDirectory(path4, paths, filters), this.walkDirectory(this.state, path4, path4, depth - 1, this.walk);
-      } else if (this.resolveSymlink && entry.isSymbolicLink()) {
-        let path4 = joinPathWithBasePath(entry.name, directoryPath);
-        this.resolveSymlink(path4, this.state, (stat, resolvedPath) => {
-          if (stat.isDirectory()) {
-            if (resolvedPath = normalizePath(resolvedPath, this.state.options), exclude && exclude(entry.name, useRealPaths ? resolvedPath : path4 + pathSeparator)) return;
-            this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path4 + pathSeparator, depth - 1, this.walk);
-          } else {
-            resolvedPath = useRealPaths ? resolvedPath : path4;
-            let filename = basename(resolvedPath), directoryPath$1 = normalizePath(dirname(resolvedPath), this.state.options);
-            resolvedPath = this.joinPath(filename, directoryPath$1), this.pushFile(resolvedPath, files, this.state.counts, filters);
-          }
-        });
-      }
-    }
-    this.groupFiles(this.state.groups, directoryPath, files);
-  };
-};
-function promise(root, options) {
-  return new Promise((resolve$1, reject) => {
-    callback(root, options, (err, output) => {
-      if (err) return reject(err);
-      resolve$1(output);
-    });
-  });
-}
-function callback(root, options, callback$1) {
-  new Walker(root, options, callback$1).start();
-}
-function sync(root, options) {
-  return new Walker(root, options).start();
-}
-var APIBuilder = class {
-  constructor(root, options) {
-    this.root = root, this.options = options;
-  }
-  withPromise() {
-    return promise(this.root, this.options);
-  }
-  withCallback(cb) {
-    callback(this.root, this.options, cb);
-  }
-  sync() {
-    return sync(this.root, this.options);
-  }
-}, pm = null;
-try {
-  __require2.resolve("picomatch"), pm = __require2("picomatch");
-} catch {
-}
-var Builder = class {
-  globCache = {};
-  options = {
-    maxDepth: 1 / 0,
-    suppressErrors: !0,
-    pathSeparator: sep,
-    filters: []
-  };
-  globFunction;
-  constructor(options) {
-    this.options = {
-      ...this.options,
-      ...options
-    }, this.globFunction = this.options.globFunction;
-  }
-  group() {
-    return this.options.group = !0, this;
-  }
-  withPathSeparator(separator) {
-    return this.options.pathSeparator = separator, this;
-  }
-  withBasePath() {
-    return this.options.includeBasePath = !0, this;
-  }
-  withRelativePaths() {
-    return this.options.relativePaths = !0, this;
-  }
-  withDirs() {
-    return this.options.includeDirs = !0, this;
-  }
-  withMaxDepth(depth) {
-    return this.options.maxDepth = depth, this;
-  }
-  withMaxFiles(limit) {
-    return this.options.maxFiles = limit, this;
-  }
-  withFullPaths() {
-    return this.options.resolvePaths = !0, this.options.includeBasePath = !0, this;
-  }
-  withErrors() {
-    return this.options.suppressErrors = !1, this;
-  }
-  withSymlinks({ resolvePaths = !0 } = {}) {
-    return this.options.resolveSymlinks = !0, this.options.useRealPaths = resolvePaths, this.withFullPaths();
-  }
-  withAbortSignal(signal) {
-    return this.options.signal = signal, this;
-  }
-  normalize() {
-    return this.options.normalizePath = !0, this;
-  }
-  filter(predicate) {
-    return this.options.filters.push(predicate), this;
-  }
-  onlyDirs() {
-    return this.options.excludeFiles = !0, this.options.includeDirs = !0, this;
-  }
-  exclude(predicate) {
-    return this.options.exclude = predicate, this;
-  }
-  onlyCounts() {
-    return this.options.onlyCounts = !0, this;
-  }
-  crawl(root) {
-    return new APIBuilder(root || ".", this.options);
-  }
-  withGlobFunction(fn) {
-    return this.globFunction = fn, this;
-  }
-  /**
-  * @deprecated Pass options using the constructor instead:
-  * ```ts
-  * new fdir(options).crawl("/path/to/root");
-  * ```
-  * This method will be removed in v7.0
-  */
-  /* c8 ignore next 4 */
-  crawlWithOptions(root, options) {
-    return this.options = {
-      ...this.options,
-      ...options
-    }, new APIBuilder(root || ".", this.options);
-  }
-  glob(...patterns) {
-    return this.globFunction ? this.globWithOptions(patterns) : this.globWithOptions(patterns, { dot: !0 });
-  }
-  globWithOptions(patterns, ...options) {
-    let globFn = this.globFunction || pm;
-    if (!globFn) throw new Error("Please specify a glob function to use glob matching.");
-    var isMatch = this.globCache[patterns.join("\0")];
-    return isMatch || (isMatch = globFn(patterns, ...options), this.globCache[patterns.join("\0")] = isMatch), this.options.filters.push((path4) => isMatch(path4)), this;
-  }
-};
-
-// ../node_modules/tinyglobby/dist/index.mjs
-var import_picomatch = __toESM(require_picomatch2(), 1), isReadonlyArray = Array.isArray, isWin = process.platform === "win32", ONLY_PARENT_DIRECTORIES = /^(\/?\.\.)+$/;
-function getPartialMatcher(patterns, options = {}) {
-  let patternsCount = patterns.length, patternsParts = Array(patternsCount), matchers = Array(patternsCount), globstarEnabled = !options.noglobstar;
-  for (let i = 0; i < patternsCount; i++) {
-    let parts = splitPattern(patterns[i]);
-    patternsParts[i] = parts;
-    let partsCount = parts.length, partMatchers = Array(partsCount);
-    for (let j = 0; j < partsCount; j++) partMatchers[j] = (0, import_picomatch.default)(parts[j], options);
-    matchers[i] = partMatchers;
-  }
-  return (input) => {
-    let inputParts = input.split("/");
-    if (inputParts[0] === ".." && ONLY_PARENT_DIRECTORIES.test(input)) return !0;
-    for (let i = 0; i < patterns.length; i++) {
-      let patternParts = patternsParts[i], matcher = matchers[i], inputPatternCount = inputParts.length, minParts = Math.min(inputPatternCount, patternParts.length), j = 0;
-      for (; j < minParts; ) {
-        let part = patternParts[j];
-        if (part.includes("/")) return !0;
-        if (!matcher[j](inputParts[j])) break;
-        if (globstarEnabled && part === "**") return !0;
-        j++;
-      }
-      if (j === inputPatternCount) return !0;
-    }
-    return !1;
-  };
-}
-var WIN32_ROOT_DIR = /^[A-Z]:\/$/i, isRoot = isWin ? (p) => WIN32_ROOT_DIR.test(p) : (p) => p === "/";
-function buildFormat(cwd, root, absolute) {
-  if (cwd === root || root.startsWith(`${cwd}/`)) {
-    if (absolute) {
-      let start = isRoot(cwd) ? cwd.length : cwd.length + 1;
-      return (p, isDir) => p.slice(start, isDir ? -1 : void 0) || ".";
-    }
-    let prefix = root.slice(cwd.length + 1);
-    return prefix ? (p, isDir) => {
-      if (p === ".") return prefix;
-      let result = `${prefix}/${p}`;
-      return isDir ? result.slice(0, -1) : result;
-    } : (p, isDir) => isDir && p !== "." ? p.slice(0, -1) : p;
-  }
-  return absolute ? (p) => posix.relative(cwd, p) || "." : (p) => posix.relative(cwd, `${root}/${p}`) || ".";
-}
-function buildRelative(cwd, root) {
-  if (root.startsWith(`${cwd}/`)) {
-    let prefix = root.slice(cwd.length + 1);
-    return (p) => `${prefix}/${p}`;
-  }
-  return (p) => {
-    let result = posix.relative(cwd, `${root}/${p}`);
-    return p.endsWith("/") && result !== "" ? `${result}/` : result || ".";
-  };
-}
-var splitPatternOptions = { parts: !0 };
-function splitPattern(path$1) {
-  var _result$parts;
-  let result = import_picomatch.default.scan(path$1, splitPatternOptions);
-  return !((_result$parts = result.parts) === null || _result$parts === void 0) && _result$parts.length ? result.parts : [path$1];
-}
-var POSIX_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}*?|]|^!|[!+@](?=\()|\\(?![()[\]{}!*+?@|]))/g, WIN32_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}]|^!|[!+@](?=\())/g, escapePosixPath = (path$1) => path$1.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&"), escapeWin32Path = (path$1) => path$1.replace(WIN32_UNESCAPED_GLOB_SYMBOLS, "\\$&"), escapePath = isWin ? escapeWin32Path : escapePosixPath;
-function isDynamicPattern(pattern, options) {
-  if (options?.caseSensitiveMatch === !1) return !0;
-  let scan = import_picomatch.default.scan(pattern);
-  return scan.isGlob || scan.negated;
-}
-function log(...tasks) {
-  console.log(`[tinyglobby ${(/* @__PURE__ */ new Date()).toLocaleTimeString("es")}]`, ...tasks);
-}
-var PARENT_DIRECTORY = /^(\/?\.\.)+/, ESCAPING_BACKSLASHES = /\\(?=[()[\]{}!*+?@|])/g, BACKSLASHES = /\\/g;
-function normalizePattern(pattern, expandDirectories, cwd, props, isIgnore) {
-  let result = pattern;
-  pattern.endsWith("/") && (result = pattern.slice(0, -1)), !result.endsWith("*") && expandDirectories && (result += "/**");
-  let escapedCwd = escapePath(cwd);
-  path.isAbsolute(result.replace(ESCAPING_BACKSLASHES, "")) ? result = posix.relative(escapedCwd, result) : result = posix.normalize(result);
-  let parentDirectoryMatch = PARENT_DIRECTORY.exec(result), parts = splitPattern(result);
-  if (parentDirectoryMatch?.[0]) {
-    let n = (parentDirectoryMatch[0].length + 1) / 3, i = 0, cwdParts = escapedCwd.split("/");
-    for (; i < n && parts[i + n] === cwdParts[cwdParts.length + i - n]; )
-      result = result.slice(0, (n - i - 1) * 3) + result.slice((n - i) * 3 + parts[i + n].length + 1) || ".", i++;
-    let potentialRoot = posix.join(cwd, parentDirectoryMatch[0].slice(i * 3));
-    !potentialRoot.startsWith(".") && props.root.length > potentialRoot.length && (props.root = potentialRoot, props.depthOffset = -n + i);
-  }
-  if (!isIgnore && props.depthOffset >= 0) {
-    var _props$commonPath;
-    (_props$commonPath = props.commonPath) !== null && _props$commonPath !== void 0 || (props.commonPath = parts);
-    let newCommonPath = [], length = Math.min(props.commonPath.length, parts.length);
-    for (let i = 0; i < length; i++) {
-      let part = parts[i];
-      if (part === "**" && !parts[i + 1]) {
-        newCommonPath.pop();
-        break;
-      }
-      if (part !== props.commonPath[i] || isDynamicPattern(part) || i === parts.length - 1) break;
-      newCommonPath.push(part);
-    }
-    props.depthOffset = newCommonPath.length, props.commonPath = newCommonPath, props.root = newCommonPath.length > 0 ? posix.join(cwd, ...newCommonPath) : cwd;
-  }
-  return result;
-}
-function processPatterns({ patterns = ["**/*"], ignore = [], expandDirectories = !0 }, cwd, props) {
-  typeof patterns == "string" && (patterns = [patterns]), typeof ignore == "string" && (ignore = [ignore]);
-  let matchPatterns = [], ignorePatterns = [];
-  for (let pattern of ignore)
-    pattern && (pattern[0] !== "!" || pattern[1] === "(") && ignorePatterns.push(normalizePattern(pattern, expandDirectories, cwd, props, !0));
-  for (let pattern of patterns)
-    pattern && (pattern[0] !== "!" || pattern[1] === "(" ? matchPatterns.push(normalizePattern(pattern, expandDirectories, cwd, props, !1)) : (pattern[1] !== "!" || pattern[2] === "(") && ignorePatterns.push(normalizePattern(pattern.slice(1), expandDirectories, cwd, props, !0)));
-  return {
-    match: matchPatterns,
-    ignore: ignorePatterns
-  };
-}
-function formatPaths(paths, relative3) {
-  for (let i = paths.length - 1; i >= 0; i--) {
-    let path$1 = paths[i];
-    paths[i] = relative3(path$1);
-  }
-  return paths;
-}
-function normalizeCwd(cwd) {
-  return cwd ? cwd instanceof URL ? fileURLToPath(cwd).replace(BACKSLASHES, "/") : path.resolve(cwd).replace(BACKSLASHES, "/") : process.cwd().replace(BACKSLASHES, "/");
-}
-function getCrawler(patterns, inputOptions = {}) {
-  let options = process.env.TINYGLOBBY_DEBUG ? {
-    ...inputOptions,
-    debug: !0
-  } : inputOptions, cwd = normalizeCwd(options.cwd);
-  if (options.debug && log("globbing with:", {
-    patterns,
-    options,
-    cwd
-  }), Array.isArray(patterns) && patterns.length === 0) return [{
-    sync: () => [],
-    withPromise: async () => []
-  }, !1];
-  let props = {
-    root: cwd,
-    commonPath: null,
-    depthOffset: 0
-  }, processed = processPatterns({
-    ...options,
-    patterns
-  }, cwd, props);
-  options.debug && log("internal processing patterns:", processed);
-  let matchOptions = {
-    dot: options.dot,
-    nobrace: options.braceExpansion === !1,
-    nocase: options.caseSensitiveMatch === !1,
-    noextglob: options.extglob === !1,
-    noglobstar: options.globstar === !1,
-    posix: !0
-  }, matcher = (0, import_picomatch.default)(processed.match, {
-    ...matchOptions,
-    ignore: processed.ignore
-  }), ignore = (0, import_picomatch.default)(processed.ignore, matchOptions), partialMatcher = getPartialMatcher(processed.match, matchOptions), format = buildFormat(cwd, props.root, options.absolute), formatExclude = options.absolute ? format : buildFormat(cwd, props.root, !0), fdirOptions = {
-    filters: [options.debug ? (p, isDirectory) => {
-      let path$1 = format(p, isDirectory), matches = matcher(path$1);
-      return matches && log(`matched ${path$1}`), matches;
-    } : (p, isDirectory) => matcher(format(p, isDirectory))],
-    exclude: options.debug ? (_, p) => {
-      let relativePath = formatExclude(p, !0), skipped = relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
-      return log(skipped ? `skipped ${p}` : `crawling ${p}`), skipped;
-    } : (_, p) => {
-      let relativePath = formatExclude(p, !0);
-      return relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
-    },
-    fs: options.fs ? {
-      readdir: options.fs.readdir || nativeFs2.readdir,
-      readdirSync: options.fs.readdirSync || nativeFs2.readdirSync,
-      realpath: options.fs.realpath || nativeFs2.realpath,
-      realpathSync: options.fs.realpathSync || nativeFs2.realpathSync,
-      stat: options.fs.stat || nativeFs2.stat,
-      statSync: options.fs.statSync || nativeFs2.statSync
-    } : void 0,
-    pathSeparator: "/",
-    relativePaths: !0,
-    resolveSymlinks: !0,
-    signal: options.signal
-  };
-  options.deep !== void 0 && (fdirOptions.maxDepth = Math.round(options.deep - props.depthOffset)), options.absolute && (fdirOptions.relativePaths = !1, fdirOptions.resolvePaths = !0, fdirOptions.includeBasePath = !0), options.followSymbolicLinks === !1 && (fdirOptions.resolveSymlinks = !1, fdirOptions.excludeSymlinks = !0), options.onlyDirectories ? (fdirOptions.excludeFiles = !0, fdirOptions.includeDirs = !0) : options.onlyFiles === !1 && (fdirOptions.includeDirs = !0), props.root = props.root.replace(BACKSLASHES, "");
-  let root = props.root;
-  options.debug && log("internal properties:", props);
-  let relative3 = cwd !== root && !options.absolute && buildRelative(cwd, props.root);
-  return [new Builder(fdirOptions).crawl(root), relative3];
-}
-function globSync(patternsOrOptions, options) {
-  if (patternsOrOptions && options?.patterns) throw new Error("Cannot pass patterns as both an argument and an option");
-  let isModern = isReadonlyArray(patternsOrOptions) || typeof patternsOrOptions == "string", opts = isModern ? options : patternsOrOptions, patterns = isModern ? patternsOrOptions : patternsOrOptions.patterns, [crawler, relative3] = getCrawler(patterns, opts);
-  return relative3 ? formatPaths(crawler.sync(), relative3) : crawler.sync();
-}
-
-// src/common/js-package-manager/constants.ts
-var NPM_LOCKFILE = "package-lock.json", PNPM_LOCKFILE = "pnpm-lock.yaml", YARN_LOCKFILE = "yarn.lock", BUN_LOCKFILE = "bun.lock", BUN_LOCKFILE_BINARY = "bun.lockb", LOCK_FILES = [
-  NPM_LOCKFILE,
-  PNPM_LOCKFILE,
-  YARN_LOCKFILE,
-  BUN_LOCKFILE,
-  BUN_LOCKFILE_BINARY
-];
-
-// src/common/utils/paths.ts
-var projectRoot, getProjectRoot = () => {
-  if (projectRoot)
-    return projectRoot;
-  if (process.env.STORYBOOK_PROJECT_ROOT)
-    return process.env.STORYBOOK_PROJECT_ROOT;
-  try {
-    let found = up2(".git") || up2(".svn") || up2(".hg");
-    if (found)
-      return projectRoot = join(found, ".."), projectRoot;
-  } catch (e) {
-    process.stdout.write(`
-error searching for repository root: ${e}
-`);
-  }
-  try {
-    let found = any(LOCK_FILES);
-    if (found)
-      return projectRoot = join(found, ".."), projectRoot;
-  } catch (e) {
-    process.stdout.write(`
-error searching for lock file: ${e}
-`);
-  }
-  try {
-    let [basePath, rest] = __dirname.split(`${sep2}node_modules${sep2}`, 2);
-    if (rest && !basePath.includes(`${sep2}npm-cache${sep2}`) && !relative2(basePath, process.cwd()).startsWith(".."))
-      return projectRoot = basePath, projectRoot;
-  } catch (e) {
-    process.stdout.write(`
-error searching for splitDirname: ${e}
-`);
-  }
-  return projectRoot = process.cwd(), projectRoot;
-}, invalidateProjectRootCache = () => {
-  projectRoot = void 0;
-}, findFilesUp = (matchers, baseDir = process.cwd()) => {
-  let matchingFiles = [];
-  for (let directory of up(baseDir, { last: getProjectRoot() }))
-    matchingFiles.push(...globSync(matchers, { cwd: directory, absolute: !0 }));
-  return matchingFiles;
-}, nodePathsToArray = (nodePath) => nodePath.split(process.platform === "win32" ? ";" : ":").filter(Boolean).map((p) => resolve2("./", p)), relativePattern = /^\.{1,2}([/\\]|$)/;
-function normalizeStoryPath(filename) {
-  return relativePattern.test(filename) ? filename : `.${sep2}${filename}`;
-}
-
-// src/common/utils/envs.ts
-async function loadEnvs(options = {}) {
-  let { getEnvironment } = await import("./lib-5NKX4YGG.js"), defaultNodeEnv = options.production ? "production" : "development", env = {
-    // eslint-disable-next-line @typescript-eslint/dot-notation
-    NODE_ENV: process.env.NODE_ENV || defaultNodeEnv,
-    NODE_PATH: process.env.NODE_PATH || "",
-    STORYBOOK: process.env.STORYBOOK || "true",
-    // This is to support CRA's public folder feature.
-    // In production we set this to dot(.) to allow the browser to access these assets
-    // even when deployed inside a subpath. (like in GitHub pages)
-    // In development this is just empty as we always serves from the root.
-    PUBLIC_URL: options.production ? "." : ""
-  };
-  Object.keys(process.env).filter((name) => /^STORYBOOK_/.test(name)).forEach((name) => {
-    env[name] = process.env[name];
-  });
-  let base = Object.entries(env).reduce(
-    (acc, [k, v]) => Object.assign(acc, { [k]: JSON.stringify(v) }),
-    {}
-  ), { stringified, raw } = getEnvironment({ nodeEnv: env.NODE_ENV }), fullRaw = { ...env, ...raw };
-  return fullRaw.NODE_PATH = nodePathsToArray(fullRaw.NODE_PATH || ""), {
-    stringified: { ...base, ...stringified },
-    raw: fullRaw
-  };
-}
-var stringifyEnvs = (raw) => Object.entries(raw).reduce((acc, [key, value]) => (acc[key] = JSON.stringify(value), acc), {}), stringifyProcessEnvs = (raw) => Object.entries(raw).reduce((acc, [key, value]) => (acc[`process.env.${key}`] = JSON.stringify(value), acc), {}), optionalEnvToBoolean = (input) => {
-  if (input !== void 0)
-    return input.toUpperCase() === "FALSE" || input === "0" ? !1 : input.toUpperCase() === "TRUE" || input === "1" ? !0 : !!input;
-};
-function isCI() {
-  return optionalEnvToBoolean(process.env.CI);
-}
-
-// node_modules/execa/index.js
-var import_cross_spawn = __toESM(require_cross_spawn(), 1);
-import { Buffer as Buffer3 } from "node:buffer";
-import path3 from "node:path";
-import childProcess from "node:child_process";
-import process6 from "node:process";
-
-// ../node_modules/strip-final-newline/index.js
-function stripFinalNewline(input) {
-  let LF = typeof input == "string" ? `
-` : 10, CR = typeof input == "string" ? "\r" : 13;
-  return input[input.length - 1] === LF && (input = input.slice(0, -1)), input[input.length - 1] === CR && (input = input.slice(0, -1)), input;
-}
-
-// node_modules/npm-run-path/index.js
-import process2 from "node:process";
-import path2 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-
-// node_modules/path-key/index.js
-function pathKey(options = {}) {
-  let {
-    env = process.env,
-    platform = process.platform
-  } = options;
-  return platform !== "win32" ? "PATH" : Object.keys(env).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
-}
-
-// node_modules/npm-run-path/index.js
-var npmRunPath = ({
-  cwd = process2.cwd(),
-  path: pathOption = process2.env[pathKey()],
-  preferLocal = !0,
-  execPath = process2.execPath,
-  addExecPath = !0
-} = {}) => {
-  let cwdString = cwd instanceof URL ? fileURLToPath2(cwd) : cwd, cwdPath = path2.resolve(cwdString), result = [];
-  return preferLocal && applyPreferLocal(result, cwdPath), addExecPath && applyExecPath(result, execPath, cwdPath), [...result, pathOption].join(path2.delimiter);
-}, applyPreferLocal = (result, cwdPath) => {
-  let previous;
-  for (; previous !== cwdPath; )
-    result.push(path2.join(cwdPath, "node_modules/.bin")), previous = cwdPath, cwdPath = path2.resolve(cwdPath, "..");
-}, applyExecPath = (result, execPath, cwdPath) => {
-  let execPathString = execPath instanceof URL ? fileURLToPath2(execPath) : execPath;
-  result.push(path2.resolve(cwdPath, execPathString, ".."));
-}, npmRunPathEnv = ({ env = process2.env, ...options } = {}) => {
-  env = { ...env };
-  let pathName = pathKey({ env });
-  return options.path = env[pathName], env[pathName] = npmRunPath(options), env;
-};
-
-// node_modules/mimic-fn/index.js
-var copyProperty = (to, from, property, ignoreNonConfigurable) => {
-  if (property === "length" || property === "prototype" || property === "arguments" || property === "caller")
-    return;
-  let toDescriptor = Object.getOwnPropertyDescriptor(to, property), fromDescriptor = Object.getOwnPropertyDescriptor(from, property);
-  !canCopyProperty(toDescriptor, fromDescriptor) && ignoreNonConfigurable || Object.defineProperty(to, property, fromDescriptor);
-}, canCopyProperty = function(toDescriptor, fromDescriptor) {
-  return toDescriptor === void 0 || toDescriptor.configurable || toDescriptor.writable === fromDescriptor.writable && toDescriptor.enumerable === fromDescriptor.enumerable && toDescriptor.configurable === fromDescriptor.configurable && (toDescriptor.writable || toDescriptor.value === fromDescriptor.value);
-}, changePrototype = (to, from) => {
-  let fromPrototype = Object.getPrototypeOf(from);
-  fromPrototype !== Object.getPrototypeOf(to) && Object.setPrototypeOf(to, fromPrototype);
-}, wrappedToString = (withName, fromBody) => `/* Wrapped ${withName}*/
-${fromBody}`, toStringDescriptor = Object.getOwnPropertyDescriptor(Function.prototype, "toString"), toStringName = Object.getOwnPropertyDescriptor(Function.prototype.toString, "name"), changeToString = (to, from, name) => {
-  let withName = name === "" ? "" : `with ${name.trim()}() `, newToString = wrappedToString.bind(null, withName, from.toString());
-  Object.defineProperty(newToString, "name", toStringName), Object.defineProperty(to, "toString", { ...toStringDescriptor, value: newToString });
-};
-function mimicFunction(to, from, { ignoreNonConfigurable = !1 } = {}) {
-  let { name } = to;
-  for (let property of Reflect.ownKeys(from))
-    copyProperty(to, from, property, ignoreNonConfigurable);
-  return changePrototype(to, from), changeToString(to, from, name), to;
-}
-
-// node_modules/onetime/index.js
-var calledFunctions = /* @__PURE__ */ new WeakMap(), onetime = (function_, options = {}) => {
-  if (typeof function_ != "function")
-    throw new TypeError("Expected a function");
-  let returnValue, callCount = 0, functionName = function_.displayName || function_.name || "<anonymous>", onetime2 = function(...arguments_) {
-    if (calledFunctions.set(onetime2, ++callCount), callCount === 1)
-      returnValue = function_.apply(this, arguments_), function_ = null;
-    else if (options.throw === !0)
-      throw new Error(`Function \`${functionName}\` can only be called once`);
-    return returnValue;
-  };
-  return mimicFunction(onetime2, function_), calledFunctions.set(onetime2, callCount), onetime2;
-};
-onetime.callCount = (function_) => {
-  if (!calledFunctions.has(function_))
-    throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
-  return calledFunctions.get(function_);
-};
-var onetime_default = onetime;
-
-// node_modules/execa/lib/error.js
-import process3 from "node:process";
-
-// node_modules/human-signals/build/src/main.js
-import { constants as constants2 } from "node:os";
-
-// node_modules/human-signals/build/src/realtime.js
-var getRealtimeSignals = () => {
-  let length = SIGRTMAX - SIGRTMIN + 1;
-  return Array.from({ length }, getRealtimeSignal);
-}, getRealtimeSignal = (value, index) => ({
-  name: `SIGRT${index + 1}`,
-  number: SIGRTMIN + index,
-  action: "terminate",
-  description: "Application-specific signal (realtime)",
-  standard: "posix"
-}), SIGRTMIN = 34, SIGRTMAX = 64;
-
-// node_modules/human-signals/build/src/signals.js
-import { constants } from "node:os";
-
-// node_modules/human-signals/build/src/core.js
-var SIGNALS = [
-  {
-    name: "SIGHUP",
-    number: 1,
-    action: "terminate",
-    description: "Terminal closed",
-    standard: "posix"
-  },
-  {
-    name: "SIGINT",
-    number: 2,
-    action: "terminate",
-    description: "User interruption with CTRL-C",
-    standard: "ansi"
-  },
-  {
-    name: "SIGQUIT",
-    number: 3,
-    action: "core",
-    description: "User interruption with CTRL-\\",
-    standard: "posix"
-  },
-  {
-    name: "SIGILL",
-    number: 4,
-    action: "core",
-    description: "Invalid machine instruction",
-    standard: "ansi"
-  },
-  {
-    name: "SIGTRAP",
-    number: 5,
-    action: "core",
-    description: "Debugger breakpoint",
-    standard: "posix"
-  },
-  {
-    name: "SIGABRT",
-    number: 6,
-    action: "core",
-    description: "Aborted",
-    standard: "ansi"
-  },
-  {
-    name: "SIGIOT",
-    number: 6,
-    action: "core",
-    description: "Aborted",
-    standard: "bsd"
-  },
-  {
-    name: "SIGBUS",
-    number: 7,
-    action: "core",
-    description: "Bus error due to misaligned, non-existing address or paging error",
-    standard: "bsd"
-  },
-  {
-    name: "SIGEMT",
-    number: 7,
-    action: "terminate",
-    description: "Command should be emulated but is not implemented",
-    standard: "other"
-  },
-  {
-    name: "SIGFPE",
-    number: 8,
-    action: "core",
-    description: "Floating point arithmetic error",
-    standard: "ansi"
-  },
-  {
-    name: "SIGKILL",
-    number: 9,
-    action: "terminate",
-    description: "Forced termination",
-    standard: "posix",
-    forced: !0
-  },
-  {
-    name: "SIGUSR1",
-    number: 10,
-    action: "terminate",
-    description: "Application-specific signal",
-    standard: "posix"
-  },
-  {
-    name: "SIGSEGV",
-    number: 11,
-    action: "core",
-    description: "Segmentation fault",
-    standard: "ansi"
-  },
-  {
-    name: "SIGUSR2",
-    number: 12,
-    action: "terminate",
-    description: "Application-specific signal",
-    standard: "posix"
-  },
-  {
-    name: "SIGPIPE",
-    number: 13,
-    action: "terminate",
-    description: "Broken pipe or socket",
-    standard: "posix"
-  },
-  {
-    name: "SIGALRM",
-    number: 14,
-    action: "terminate",
-    description: "Timeout or timer",
-    standard: "posix"
-  },
-  {
-    name: "SIGTERM",
-    number: 15,
-    action: "terminate",
-    description: "Termination",
-    standard: "ansi"
-  },
-  {
-    name: "SIGSTKFLT",
-    number: 16,
-    action: "terminate",
-    description: "Stack is empty or overflowed",
-    standard: "other"
-  },
-  {
-    name: "SIGCHLD",
-    number: 17,
-    action: "ignore",
-    description: "Child process terminated, paused or unpaused",
-    standard: "posix"
-  },
-  {
-    name: "SIGCLD",
-    number: 17,
-    action: "ignore",
-    description: "Child process terminated, paused or unpaused",
-    standard: "other"
-  },
-  {
-    name: "SIGCONT",
-    number: 18,
-    action: "unpause",
-    description: "Unpaused",
-    standard: "posix",
-    forced: !0
-  },
-  {
-    name: "SIGSTOP",
-    number: 19,
-    action: "pause",
-    description: "Paused",
-    standard: "posix",
-    forced: !0
-  },
-  {
-    name: "SIGTSTP",
-    number: 20,
-    action: "pause",
-    description: 'Paused using CTRL-Z or "suspend"',
-    standard: "posix"
-  },
-  {
-    name: "SIGTTIN",
-    number: 21,
-    action: "pause",
-    description: "Background process cannot read terminal input",
-    standard: "posix"
-  },
-  {
-    name: "SIGBREAK",
-    number: 21,
-    action: "terminate",
-    description: "User interruption with CTRL-BREAK",
-    standard: "other"
-  },
-  {
-    name: "SIGTTOU",
-    number: 22,
-    action: "pause",
-    description: "Background process cannot write to terminal output",
-    standard: "posix"
-  },
-  {
-    name: "SIGURG",
-    number: 23,
-    action: "ignore",
-    description: "Socket received out-of-band data",
-    standard: "bsd"
-  },
-  {
-    name: "SIGXCPU",
-    number: 24,
-    action: "core",
-    description: "Process timed out",
-    standard: "bsd"
-  },
-  {
-    name: "SIGXFSZ",
-    number: 25,
-    action: "core",
-    description: "File too big",
-    standard: "bsd"
-  },
-  {
-    name: "SIGVTALRM",
-    number: 26,
-    action: "terminate",
-    description: "Timeout or timer",
-    standard: "bsd"
-  },
-  {
-    name: "SIGPROF",
-    number: 27,
-    action: "terminate",
-    description: "Timeout or timer",
-    standard: "bsd"
-  },
-  {
-    name: "SIGWINCH",
-    number: 28,
-    action: "ignore",
-    description: "Terminal window size changed",
-    standard: "bsd"
-  },
-  {
-    name: "SIGIO",
-    number: 29,
-    action: "terminate",
-    description: "I/O is available",
-    standard: "other"
-  },
-  {
-    name: "SIGPOLL",
-    number: 29,
-    action: "terminate",
-    description: "Watched event",
-    standard: "other"
-  },
-  {
-    name: "SIGINFO",
-    number: 29,
-    action: "ignore",
-    description: "Request for process information",
-    standard: "other"
-  },
-  {
-    name: "SIGPWR",
-    number: 30,
-    action: "terminate",
-    description: "Device running out of power",
-    standard: "systemv"
-  },
-  {
-    name: "SIGSYS",
-    number: 31,
-    action: "core",
-    description: "Invalid system call",
-    standard: "other"
-  },
-  {
-    name: "SIGUNUSED",
-    number: 31,
-    action: "terminate",
-    description: "Invalid system call",
-    standard: "other"
-  }
-];
-
-// node_modules/human-signals/build/src/signals.js
-var getSignals = () => {
-  let realtimeSignals = getRealtimeSignals();
-  return [...SIGNALS, ...realtimeSignals].map(normalizeSignal);
-}, normalizeSignal = ({
-  name,
-  number: defaultNumber,
-  description,
-  action,
-  forced = !1,
-  standard
-}) => {
-  let {
-    signals: { [name]: constantSignal }
-  } = constants, supported = constantSignal !== void 0;
-  return { name, number: supported ? constantSignal : defaultNumber, description, supported, action, forced, standard };
-};
-
-// node_modules/human-signals/build/src/main.js
-var getSignalsByName = () => {
-  let signals2 = getSignals();
-  return Object.fromEntries(signals2.map(getSignalByName));
-}, getSignalByName = ({
-  name,
-  number,
-  description,
-  supported,
-  action,
-  forced,
-  standard
-}) => [name, { name, number, description, supported, action, forced, standard }], signalsByName = getSignalsByName(), getSignalsByNumber = () => {
-  let signals2 = getSignals(), length = 65, signalsA = Array.from(
-    { length },
-    (value, number) => getSignalByNumber(number, signals2)
-  );
-  return Object.assign({}, ...signalsA);
-}, getSignalByNumber = (number, signals2) => {
-  let signal = findSignalByNumber(number, signals2);
-  if (signal === void 0)
-    return {};
-  let { name, description, supported, action, forced, standard } = signal;
-  return {
-    [number]: {
-      name,
-      number,
-      description,
-      supported,
-      action,
-      forced,
-      standard
-    }
-  };
-}, findSignalByNumber = (number, signals2) => {
-  let signal = signals2.find(({ name }) => constants2.signals[name] === number);
-  return signal !== void 0 ? signal : signals2.find((signalA) => signalA.number === number);
-}, signalsByNumber = getSignalsByNumber();
-
-// node_modules/execa/lib/error.js
-var getErrorPrefix = ({ timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled }) => timedOut ? `timed out after ${timeout} milliseconds` : isCanceled ? "was canceled" : errorCode !== void 0 ? `failed with ${errorCode}` : signal !== void 0 ? `was killed with ${signal} (${signalDescription})` : exitCode !== void 0 ? `failed with exit code ${exitCode}` : "failed", makeError = ({
-  stdout,
-  stderr,
-  all,
-  error,
-  signal,
-  exitCode,
-  command,
-  escapedCommand,
-  timedOut,
-  isCanceled,
-  killed,
-  parsed: { options: { timeout, cwd = process3.cwd() } }
-}) => {
-  exitCode = exitCode === null ? void 0 : exitCode, signal = signal === null ? void 0 : signal;
-  let signalDescription = signal === void 0 ? void 0 : signalsByName[signal].description, errorCode = error && error.code, execaMessage = `Command ${getErrorPrefix({ timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled })}: ${command}`, isError = Object.prototype.toString.call(error) === "[object Error]", shortMessage = isError ? `${execaMessage}
-${error.message}` : execaMessage, message = [shortMessage, stderr, stdout].filter(Boolean).join(`
-`);
-  return isError ? (error.originalMessage = error.message, error.message = message) : error = new Error(message), error.shortMessage = shortMessage, error.command = command, error.escapedCommand = escapedCommand, error.exitCode = exitCode, error.signal = signal, error.signalDescription = signalDescription, error.stdout = stdout, error.stderr = stderr, error.cwd = cwd, all !== void 0 && (error.all = all), "bufferedData" in error && delete error.bufferedData, error.failed = !0, error.timedOut = !!timedOut, error.isCanceled = isCanceled, error.killed = killed && !timedOut, error;
-};
-
-// node_modules/execa/lib/stdio.js
-var aliases = ["stdin", "stdout", "stderr"], hasAlias = (options) => aliases.some((alias) => options[alias] !== void 0), normalizeStdio = (options) => {
-  if (!options)
-    return;
-  let { stdio } = options;
-  if (stdio === void 0)
-    return aliases.map((alias) => options[alias]);
-  if (hasAlias(options))
-    throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${aliases.map((alias) => `\`${alias}\``).join(", ")}`);
-  if (typeof stdio == "string")
-    return stdio;
-  if (!Array.isArray(stdio))
-    throw new TypeError(`Expected \`stdio\` to be of type \`string\` or \`Array\`, got \`${typeof stdio}\``);
-  let length = Math.max(stdio.length, aliases.length);
-  return Array.from({ length }, (value, index) => stdio[index]);
-};
-
-// node_modules/execa/lib/kill.js
-import os from "node:os";
-
-// node_modules/signal-exit/dist/mjs/signals.js
-var signals = [];
-signals.push("SIGHUP", "SIGINT", "SIGTERM");
-process.platform !== "win32" && signals.push(
-  "SIGALRM",
-  "SIGABRT",
-  "SIGVTALRM",
-  "SIGXCPU",
-  "SIGXFSZ",
-  "SIGUSR2",
-  "SIGTRAP",
-  "SIGSYS",
-  "SIGQUIT",
-  "SIGIOT"
-  // should detect profiler and enable/disable accordingly.
-  // see #21
-  // 'SIGPROF'
-);
-process.platform === "linux" && signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
-
-// node_modules/signal-exit/dist/mjs/index.js
-var processOk = (process7) => !!process7 && typeof process7 == "object" && typeof process7.removeListener == "function" && typeof process7.emit == "function" && typeof process7.reallyExit == "function" && typeof process7.listeners == "function" && typeof process7.kill == "function" && typeof process7.pid == "number" && typeof process7.on == "function", kExitEmitter = Symbol.for("signal-exit emitter"), global2 = globalThis, ObjectDefineProperty = Object.defineProperty.bind(Object), Emitter = class {
-  emitted = {
-    afterExit: !1,
-    exit: !1
-  };
-  listeners = {
-    afterExit: [],
-    exit: []
-  };
-  count = 0;
-  id = Math.random();
-  constructor() {
-    if (global2[kExitEmitter])
-      return global2[kExitEmitter];
-    ObjectDefineProperty(global2, kExitEmitter, {
-      value: this,
-      writable: !1,
-      enumerable: !1,
-      configurable: !1
-    });
-  }
-  on(ev, fn) {
-    this.listeners[ev].push(fn);
-  }
-  removeListener(ev, fn) {
-    let list = this.listeners[ev], i = list.indexOf(fn);
-    i !== -1 && (i === 0 && list.length === 1 ? list.length = 0 : list.splice(i, 1));
-  }
-  emit(ev, code, signal) {
-    if (this.emitted[ev])
-      return !1;
-    this.emitted[ev] = !0;
-    let ret = !1;
-    for (let fn of this.listeners[ev])
-      ret = fn(code, signal) === !0 || ret;
-    return ev === "exit" && (ret = this.emit("afterExit", code, signal) || ret), ret;
-  }
-}, SignalExitBase = class {
-}, signalExitWrap = (handler) => ({
-  onExit(cb, opts) {
-    return handler.onExit(cb, opts);
-  },
-  load() {
-    return handler.load();
-  },
-  unload() {
-    return handler.unload();
-  }
-}), SignalExitFallback = class extends SignalExitBase {
-  onExit() {
-    return () => {
-    };
-  }
-  load() {
-  }
-  unload() {
-  }
-}, SignalExit = class extends SignalExitBase {
-  // "SIGHUP" throws an `ENOSYS` error on Windows,
-  // so use a supported signal instead
-  /* c8 ignore start */
-  #hupSig = process4.platform === "win32" ? "SIGINT" : "SIGHUP";
-  /* c8 ignore stop */
-  #emitter = new Emitter();
-  #process;
-  #originalProcessEmit;
-  #originalProcessReallyExit;
-  #sigListeners = {};
-  #loaded = !1;
-  constructor(process7) {
-    super(), this.#process = process7, this.#sigListeners = {};
-    for (let sig of signals)
-      this.#sigListeners[sig] = () => {
-        let listeners = this.#process.listeners(sig), { count } = this.#emitter, p = process7;
-        if (typeof p.__signal_exit_emitter__ == "object" && typeof p.__signal_exit_emitter__.count == "number" && (count += p.__signal_exit_emitter__.count), listeners.length === count) {
-          this.unload();
-          let ret = this.#emitter.emit("exit", null, sig), s = sig === "SIGHUP" ? this.#hupSig : sig;
-          ret || process7.kill(process7.pid, s);
-        }
-      };
-    this.#originalProcessReallyExit = process7.reallyExit, this.#originalProcessEmit = process7.emit;
-  }
-  onExit(cb, opts) {
-    if (!processOk(this.#process))
-      return () => {
-      };
-    this.#loaded === !1 && this.load();
-    let ev = opts?.alwaysLast ? "afterExit" : "exit";
-    return this.#emitter.on(ev, cb), () => {
-      this.#emitter.removeListener(ev, cb), this.#emitter.listeners.exit.length === 0 && this.#emitter.listeners.afterExit.length === 0 && this.unload();
-    };
-  }
-  load() {
-    if (!this.#loaded) {
-      this.#loaded = !0, this.#emitter.count += 1;
-      for (let sig of signals)
-        try {
-          let fn = this.#sigListeners[sig];
-          fn && this.#process.on(sig, fn);
-        } catch {
-        }
-      this.#process.emit = (ev, ...a) => this.#processEmit(ev, ...a), this.#process.reallyExit = (code) => this.#processReallyExit(code);
-    }
-  }
-  unload() {
-    this.#loaded && (this.#loaded = !1, signals.forEach((sig) => {
-      let listener = this.#sigListeners[sig];
-      if (!listener)
-        throw new Error("Listener not defined for signal: " + sig);
-      try {
-        this.#process.removeListener(sig, listener);
-      } catch {
-      }
-    }), this.#process.emit = this.#originalProcessEmit, this.#process.reallyExit = this.#originalProcessReallyExit, this.#emitter.count -= 1);
-  }
-  #processReallyExit(code) {
-    return processOk(this.#process) ? (this.#process.exitCode = code || 0, this.#emitter.emit("exit", this.#process.exitCode, null), this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode)) : 0;
-  }
-  #processEmit(ev, ...args) {
-    let og = this.#originalProcessEmit;
-    if (ev === "exit" && processOk(this.#process)) {
-      typeof args[0] == "number" && (this.#process.exitCode = args[0]);
-      let ret = og.call(this.#process, ev, ...args);
-      return this.#emitter.emit("exit", this.#process.exitCode, null), ret;
-    } else
-      return og.call(this.#process, ev, ...args);
-  }
-}, process4 = globalThis.process, {
-  /**
-   * Called when the process is exiting, whether via signal, explicit
-   * exit, or running out of stuff to do.
-   *
-   * If the global process object is not suitable for instrumentation,
-   * then this will be a no-op.
-   *
-   * Returns a function that may be used to unload signal-exit.
-   */
-  onExit,
-  /**
-   * Load the listeners.  Likely you never need to call this, unless
-   * doing a rather deep integration with signal-exit functionality.
-   * Mostly exposed for the benefit of testing.
-   *
-   * @internal
-   */
-  load,
-  /**
-   * Unload the listeners.  Likely you never need to call this, unless
-   * doing a rather deep integration with signal-exit functionality.
-   * Mostly exposed for the benefit of testing.
-   *
-   * @internal
-   */
-  unload
-} = signalExitWrap(processOk(process4) ? new SignalExit(process4) : new SignalExitFallback());
-
-// node_modules/execa/lib/kill.js
-var DEFAULT_FORCE_KILL_TIMEOUT = 1e3 * 5, spawnedKill = (kill, signal = "SIGTERM", options = {}) => {
-  let killResult = kill(signal);
-  return setKillTimeout(kill, signal, options, killResult), killResult;
-}, setKillTimeout = (kill, signal, options, killResult) => {
-  if (!shouldForceKill(signal, options, killResult))
-    return;
-  let timeout = getForceKillAfterTimeout(options), t = setTimeout(() => {
-    kill("SIGKILL");
-  }, timeout);
-  t.unref && t.unref();
-}, shouldForceKill = (signal, { forceKillAfterTimeout }, killResult) => isSigterm(signal) && forceKillAfterTimeout !== !1 && killResult, isSigterm = (signal) => signal === os.constants.signals.SIGTERM || typeof signal == "string" && signal.toUpperCase() === "SIGTERM", getForceKillAfterTimeout = ({ forceKillAfterTimeout = !0 }) => {
-  if (forceKillAfterTimeout === !0)
-    return DEFAULT_FORCE_KILL_TIMEOUT;
-  if (!Number.isFinite(forceKillAfterTimeout) || forceKillAfterTimeout < 0)
-    throw new TypeError(`Expected the \`forceKillAfterTimeout\` option to be a non-negative integer, got \`${forceKillAfterTimeout}\` (${typeof forceKillAfterTimeout})`);
-  return forceKillAfterTimeout;
-}, spawnedCancel = (spawned, context) => {
-  spawned.kill() && (context.isCanceled = !0);
-}, timeoutKill = (spawned, signal, reject) => {
-  spawned.kill(signal), reject(Object.assign(new Error("Timed out"), { timedOut: !0, signal }));
-}, setupTimeout = (spawned, { timeout, killSignal = "SIGTERM" }, spawnedPromise) => {
-  if (timeout === 0 || timeout === void 0)
-    return spawnedPromise;
-  let timeoutId, timeoutPromise = new Promise((resolve3, reject) => {
-    timeoutId = setTimeout(() => {
-      timeoutKill(spawned, killSignal, reject);
-    }, timeout);
-  }), safeSpawnedPromise = spawnedPromise.finally(() => {
-    clearTimeout(timeoutId);
-  });
-  return Promise.race([timeoutPromise, safeSpawnedPromise]);
-}, validateTimeout = ({ timeout }) => {
-  if (timeout !== void 0 && (!Number.isFinite(timeout) || timeout < 0))
-    throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${timeout}\` (${typeof timeout})`);
-}, setExitHandler = async (spawned, { cleanup, detached }, timedPromise) => {
-  if (!cleanup || detached)
-    return timedPromise;
-  let removeExitHandler = onExit(() => {
-    spawned.kill();
-  });
-  return timedPromise.finally(() => {
-    removeExitHandler();
-  });
-};
-
-// node_modules/execa/lib/pipe.js
-import { createWriteStream } from "node:fs";
-import { ChildProcess } from "node:child_process";
-
-// node_modules/is-stream/index.js
-function isStream(stream) {
-  return stream !== null && typeof stream == "object" && typeof stream.pipe == "function";
-}
-function isWritableStream(stream) {
-  return isStream(stream) && stream.writable !== !1 && typeof stream._write == "function" && typeof stream._writableState == "object";
-}
-
-// node_modules/execa/lib/pipe.js
-var isExecaChildProcess = (target) => target instanceof ChildProcess && typeof target.then == "function", pipeToTarget = (spawned, streamName, target) => {
-  if (typeof target == "string")
-    return spawned[streamName].pipe(createWriteStream(target)), spawned;
-  if (isWritableStream(target))
-    return spawned[streamName].pipe(target), spawned;
-  if (!isExecaChildProcess(target))
-    throw new TypeError("The second argument must be a string, a stream or an Execa child process.");
-  if (!isWritableStream(target.stdin))
-    throw new TypeError("The target child process's stdin must be available.");
-  return spawned[streamName].pipe(target.stdin), target;
-}, addPipeMethods = (spawned) => {
-  spawned.stdout !== null && (spawned.pipeStdout = pipeToTarget.bind(void 0, spawned, "stdout")), spawned.stderr !== null && (spawned.pipeStderr = pipeToTarget.bind(void 0, spawned, "stderr")), spawned.all !== void 0 && (spawned.pipeAll = pipeToTarget.bind(void 0, spawned, "all"));
-};
-
-// node_modules/execa/lib/stream.js
-import { createReadStream, readFileSync } from "node:fs";
-import { setTimeout as setTimeout2 } from "node:timers/promises";
-
-// node_modules/get-stream/source/contents.js
-var getStreamContents = async (stream, { init, convertChunk, getSize, truncateChunk, addChunk, getFinalChunk, finalize }, { maxBuffer = Number.POSITIVE_INFINITY } = {}) => {
-  if (!isAsyncIterable(stream))
-    throw new Error("The first argument must be a Readable, a ReadableStream, or an async iterable.");
-  let state = init();
-  state.length = 0;
-  try {
-    for await (let chunk of stream) {
-      let chunkType = getChunkType(chunk), convertedChunk = convertChunk[chunkType](chunk, state);
-      appendChunk({ convertedChunk, state, getSize, truncateChunk, addChunk, maxBuffer });
-    }
-    return appendFinalChunk({ state, convertChunk, getSize, truncateChunk, addChunk, getFinalChunk, maxBuffer }), finalize(state);
-  } catch (error) {
-    throw error.bufferedData = finalize(state), error;
-  }
-}, appendFinalChunk = ({ state, getSize, truncateChunk, addChunk, getFinalChunk, maxBuffer }) => {
-  let convertedChunk = getFinalChunk(state);
-  convertedChunk !== void 0 && appendChunk({ convertedChunk, state, getSize, truncateChunk, addChunk, maxBuffer });
-}, appendChunk = ({ convertedChunk, state, getSize, truncateChunk, addChunk, maxBuffer }) => {
-  let chunkSize = getSize(convertedChunk), newLength = state.length + chunkSize;
-  if (newLength <= maxBuffer) {
-    addNewChunk(convertedChunk, state, addChunk, newLength);
-    return;
-  }
-  let truncatedChunk = truncateChunk(convertedChunk, maxBuffer - state.length);
-  throw truncatedChunk !== void 0 && addNewChunk(truncatedChunk, state, addChunk, maxBuffer), new MaxBufferError();
-}, addNewChunk = (convertedChunk, state, addChunk, newLength) => {
-  state.contents = addChunk(convertedChunk, state, newLength), state.length = newLength;
-}, isAsyncIterable = (stream) => typeof stream == "object" && stream !== null && typeof stream[Symbol.asyncIterator] == "function", getChunkType = (chunk) => {
-  let typeOfChunk = typeof chunk;
-  if (typeOfChunk === "string")
-    return "string";
-  if (typeOfChunk !== "object" || chunk === null)
-    return "others";
-  if (globalThis.Buffer?.isBuffer(chunk))
-    return "buffer";
-  let prototypeName = objectToString.call(chunk);
-  return prototypeName === "[object ArrayBuffer]" ? "arrayBuffer" : prototypeName === "[object DataView]" ? "dataView" : Number.isInteger(chunk.byteLength) && Number.isInteger(chunk.byteOffset) && objectToString.call(chunk.buffer) === "[object ArrayBuffer]" ? "typedArray" : "others";
-}, { toString: objectToString } = Object.prototype, MaxBufferError = class extends Error {
-  name = "MaxBufferError";
-  constructor() {
-    super("maxBuffer exceeded");
-  }
-};
-
-// node_modules/get-stream/source/utils.js
-var identity = (value) => value, noop = () => {
-}, getContentsProp = ({ contents }) => contents, throwObjectStream = (chunk) => {
-  throw new Error(`Streams in object mode are not supported: ${String(chunk)}`);
-}, getLengthProp = (convertedChunk) => convertedChunk.length;
-
-// node_modules/get-stream/source/array-buffer.js
-async function getStreamAsArrayBuffer(stream, options) {
-  return getStreamContents(stream, arrayBufferMethods, options);
-}
-var initArrayBuffer = () => ({ contents: new ArrayBuffer(0) }), useTextEncoder = (chunk) => textEncoder.encode(chunk), textEncoder = new TextEncoder(), useUint8Array = (chunk) => new Uint8Array(chunk), useUint8ArrayWithOffset = (chunk) => new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength), truncateArrayBufferChunk = (convertedChunk, chunkSize) => convertedChunk.slice(0, chunkSize), addArrayBufferChunk = (convertedChunk, { contents, length: previousLength }, length) => {
-  let newContents = hasArrayBufferResize() ? resizeArrayBuffer(contents, length) : resizeArrayBufferSlow(contents, length);
-  return new Uint8Array(newContents).set(convertedChunk, previousLength), newContents;
-}, resizeArrayBufferSlow = (contents, length) => {
-  if (length <= contents.byteLength)
-    return contents;
-  let arrayBuffer = new ArrayBuffer(getNewContentsLength(length));
-  return new Uint8Array(arrayBuffer).set(new Uint8Array(contents), 0), arrayBuffer;
-}, resizeArrayBuffer = (contents, length) => {
-  if (length <= contents.maxByteLength)
-    return contents.resize(length), contents;
-  let arrayBuffer = new ArrayBuffer(length, { maxByteLength: getNewContentsLength(length) });
-  return new Uint8Array(arrayBuffer).set(new Uint8Array(contents), 0), arrayBuffer;
-}, getNewContentsLength = (length) => SCALE_FACTOR ** Math.ceil(Math.log(length) / Math.log(SCALE_FACTOR)), SCALE_FACTOR = 2, finalizeArrayBuffer = ({ contents, length }) => hasArrayBufferResize() ? contents : contents.slice(0, length), hasArrayBufferResize = () => "resize" in ArrayBuffer.prototype, arrayBufferMethods = {
-  init: initArrayBuffer,
-  convertChunk: {
-    string: useTextEncoder,
-    buffer: useUint8Array,
-    arrayBuffer: useUint8Array,
-    dataView: useUint8ArrayWithOffset,
-    typedArray: useUint8ArrayWithOffset,
-    others: throwObjectStream
-  },
-  getSize: getLengthProp,
-  truncateChunk: truncateArrayBufferChunk,
-  addChunk: addArrayBufferChunk,
-  getFinalChunk: noop,
-  finalize: finalizeArrayBuffer
-};
-
-// node_modules/get-stream/source/buffer.js
-async function getStreamAsBuffer(stream, options) {
-  if (!("Buffer" in globalThis))
-    throw new Error("getStreamAsBuffer() is only supported in Node.js");
-  try {
-    return arrayBufferToNodeBuffer(await getStreamAsArrayBuffer(stream, options));
-  } catch (error) {
-    throw error.bufferedData !== void 0 && (error.bufferedData = arrayBufferToNodeBuffer(error.bufferedData)), error;
-  }
-}
-var arrayBufferToNodeBuffer = (arrayBuffer) => globalThis.Buffer.from(arrayBuffer);
-
-// node_modules/get-stream/source/string.js
-async function getStreamAsString(stream, options) {
-  return getStreamContents(stream, stringMethods, options);
-}
-var initString = () => ({ contents: "", textDecoder: new TextDecoder() }), useTextDecoder = (chunk, { textDecoder }) => textDecoder.decode(chunk, { stream: !0 }), addStringChunk = (convertedChunk, { contents }) => contents + convertedChunk, truncateStringChunk = (convertedChunk, chunkSize) => convertedChunk.slice(0, chunkSize), getFinalStringChunk = ({ textDecoder }) => {
-  let finalChunk = textDecoder.decode();
-  return finalChunk === "" ? void 0 : finalChunk;
-}, stringMethods = {
-  init: initString,
-  convertChunk: {
-    string: identity,
-    buffer: useTextDecoder,
-    arrayBuffer: useTextDecoder,
-    dataView: useTextDecoder,
-    typedArray: useTextDecoder,
-    others: throwObjectStream
-  },
-  getSize: getLengthProp,
-  truncateChunk: truncateStringChunk,
-  addChunk: addStringChunk,
-  getFinalChunk: getFinalStringChunk,
-  finalize: getContentsProp
-};
-
-// node_modules/execa/lib/stream.js
-var import_merge_stream = __toESM(require_merge_stream(), 1), validateInputOptions = (input) => {
-  if (input !== void 0)
-    throw new TypeError("The `input` and `inputFile` options cannot be both set.");
-}, getInputSync = ({ input, inputFile }) => typeof inputFile != "string" ? input : (validateInputOptions(input), readFileSync(inputFile)), handleInputSync = (options) => {
-  let input = getInputSync(options);
-  if (isStream(input))
-    throw new TypeError("The `input` option cannot be a stream in sync mode");
-  return input;
-}, getInput = ({ input, inputFile }) => typeof inputFile != "string" ? input : (validateInputOptions(input), createReadStream(inputFile)), handleInput = (spawned, options) => {
-  let input = getInput(options);
-  input !== void 0 && (isStream(input) ? input.pipe(spawned.stdin) : spawned.stdin.end(input));
-}, makeAllStream = (spawned, { all }) => {
-  if (!all || !spawned.stdout && !spawned.stderr)
-    return;
-  let mixed = (0, import_merge_stream.default)();
-  return spawned.stdout && mixed.add(spawned.stdout), spawned.stderr && mixed.add(spawned.stderr), mixed;
-}, getBufferedData = async (stream, streamPromise) => {
-  if (!(!stream || streamPromise === void 0)) {
-    await setTimeout2(0), stream.destroy();
-    try {
-      return await streamPromise;
-    } catch (error) {
-      return error.bufferedData;
-    }
-  }
-}, getStreamPromise = (stream, { encoding, buffer, maxBuffer }) => {
-  if (!(!stream || !buffer))
-    return encoding === "utf8" || encoding === "utf-8" ? getStreamAsString(stream, { maxBuffer }) : encoding === null || encoding === "buffer" ? getStreamAsBuffer(stream, { maxBuffer }) : applyEncoding(stream, maxBuffer, encoding);
-}, applyEncoding = async (stream, maxBuffer, encoding) => (await getStreamAsBuffer(stream, { maxBuffer })).toString(encoding), getSpawnedResult = async ({ stdout, stderr, all }, { encoding, buffer, maxBuffer }, processDone) => {
-  let stdoutPromise = getStreamPromise(stdout, { encoding, buffer, maxBuffer }), stderrPromise = getStreamPromise(stderr, { encoding, buffer, maxBuffer }), allPromise = getStreamPromise(all, { encoding, buffer, maxBuffer: maxBuffer * 2 });
-  try {
-    return await Promise.all([processDone, stdoutPromise, stderrPromise, allPromise]);
-  } catch (error) {
-    return Promise.all([
-      { error, signal: error.signal, timedOut: error.timedOut },
-      getBufferedData(stdout, stdoutPromise),
-      getBufferedData(stderr, stderrPromise),
-      getBufferedData(all, allPromise)
-    ]);
-  }
-};
-
-// node_modules/execa/lib/promise.js
-var nativePromisePrototype = (async () => {
-})().constructor.prototype, descriptors = ["then", "catch", "finally"].map((property) => [
-  property,
-  Reflect.getOwnPropertyDescriptor(nativePromisePrototype, property)
-]), mergePromise = (spawned, promise2) => {
-  for (let [property, descriptor] of descriptors) {
-    let value = typeof promise2 == "function" ? (...args) => Reflect.apply(descriptor.value, promise2(), args) : descriptor.value.bind(promise2);
-    Reflect.defineProperty(spawned, property, { ...descriptor, value });
-  }
-}, getSpawnedPromise = (spawned) => new Promise((resolve3, reject) => {
-  spawned.on("exit", (exitCode, signal) => {
-    resolve3({ exitCode, signal });
-  }), spawned.on("error", (error) => {
-    reject(error);
-  }), spawned.stdin && spawned.stdin.on("error", (error) => {
-    reject(error);
-  });
-});
-
-// node_modules/execa/lib/command.js
-import { Buffer as Buffer2 } from "node:buffer";
-import { ChildProcess as ChildProcess2 } from "node:child_process";
-var normalizeArgs = (file, args = []) => Array.isArray(args) ? [file, ...args] : [file], NO_ESCAPE_REGEXP = /^[\w.-]+$/, escapeArg = (arg) => typeof arg != "string" || NO_ESCAPE_REGEXP.test(arg) ? arg : `"${arg.replaceAll('"', '\\"')}"`, joinCommand = (file, args) => normalizeArgs(file, args).join(" "), getEscapedCommand = (file, args) => normalizeArgs(file, args).map((arg) => escapeArg(arg)).join(" "), SPACES_REGEXP = / +/g, parseCommand = (command) => {
-  let tokens = [];
-  for (let token of command.trim().split(SPACES_REGEXP)) {
-    let previousToken = tokens.at(-1);
-    previousToken && previousToken.endsWith("\\") ? tokens[tokens.length - 1] = `${previousToken.slice(0, -1)} ${token}` : tokens.push(token);
-  }
-  return tokens;
-}, parseExpression = (expression) => {
-  let typeOfExpression = typeof expression;
-  if (typeOfExpression === "string")
-    return expression;
-  if (typeOfExpression === "number")
-    return String(expression);
-  if (typeOfExpression === "object" && expression !== null && !(expression instanceof ChildProcess2) && "stdout" in expression) {
-    let typeOfStdout = typeof expression.stdout;
-    if (typeOfStdout === "string")
-      return expression.stdout;
-    if (Buffer2.isBuffer(expression.stdout))
-      return expression.stdout.toString();
-    throw new TypeError(`Unexpected "${typeOfStdout}" stdout in template expression`);
-  }
-  throw new TypeError(`Unexpected "${typeOfExpression}" in template expression`);
-}, concatTokens = (tokens, nextTokens, isNew) => isNew || tokens.length === 0 || nextTokens.length === 0 ? [...tokens, ...nextTokens] : [
-  ...tokens.slice(0, -1),
-  `${tokens.at(-1)}${nextTokens[0]}`,
-  ...nextTokens.slice(1)
-], parseTemplate = ({ templates, expressions, tokens, index, template }) => {
-  let templateString = template ?? templates.raw[index], templateTokens = templateString.split(SPACES_REGEXP).filter(Boolean), newTokens = concatTokens(
-    tokens,
-    templateTokens,
-    templateString.startsWith(" ")
-  );
-  if (index === expressions.length)
-    return newTokens;
-  let expression = expressions[index], expressionTokens = Array.isArray(expression) ? expression.map((expression2) => parseExpression(expression2)) : [parseExpression(expression)];
-  return concatTokens(
-    newTokens,
-    expressionTokens,
-    templateString.endsWith(" ")
-  );
-}, parseTemplates = (templates, expressions) => {
-  let tokens = [];
-  for (let [index, template] of templates.entries())
-    tokens = parseTemplate({ templates, expressions, tokens, index, template });
-  return tokens;
-};
-
-// node_modules/execa/lib/verbose.js
-import { debuglog } from "node:util";
-import process5 from "node:process";
-var verboseDefault = debuglog("execa").enabled, padField = (field, padding) => String(field).padStart(padding, "0"), getTimestamp = () => {
-  let date = /* @__PURE__ */ new Date();
-  return `${padField(date.getHours(), 2)}:${padField(date.getMinutes(), 2)}:${padField(date.getSeconds(), 2)}.${padField(date.getMilliseconds(), 3)}`;
-}, logCommand = (escapedCommand, { verbose }) => {
-  verbose && process5.stderr.write(`[${getTimestamp()}] ${escapedCommand}
-`);
-};
-
-// node_modules/execa/index.js
-var DEFAULT_MAX_BUFFER = 1e3 * 1e3 * 100, getEnv = ({ env: envOption, extendEnv, preferLocal, localDir, execPath }) => {
-  let env = extendEnv ? { ...process6.env, ...envOption } : envOption;
-  return preferLocal ? npmRunPathEnv({ env, cwd: localDir, execPath }) : env;
-}, handleArguments = (file, args, options = {}) => {
-  let parsed = import_cross_spawn.default._parse(file, args, options);
-  return file = parsed.command, args = parsed.args, options = parsed.options, options = {
-    maxBuffer: DEFAULT_MAX_BUFFER,
-    buffer: !0,
-    stripFinalNewline: !0,
-    extendEnv: !0,
-    preferLocal: !1,
-    localDir: options.cwd || process6.cwd(),
-    execPath: process6.execPath,
-    encoding: "utf8",
-    reject: !0,
-    cleanup: !0,
-    all: !1,
-    windowsHide: !0,
-    verbose: verboseDefault,
-    ...options
-  }, options.env = getEnv(options), options.stdio = normalizeStdio(options), process6.platform === "win32" && path3.basename(file, ".exe") === "cmd" && args.unshift("/q"), { file, args, options, parsed };
-}, handleOutput = (options, value, error) => typeof value != "string" && !Buffer3.isBuffer(value) ? error === void 0 ? void 0 : "" : options.stripFinalNewline ? stripFinalNewline(value) : value;
-function execa(file, args, options) {
-  let parsed = handleArguments(file, args, options), command = joinCommand(file, args), escapedCommand = getEscapedCommand(file, args);
-  logCommand(escapedCommand, parsed.options), validateTimeout(parsed.options);
-  let spawned;
-  try {
-    spawned = childProcess.spawn(parsed.file, parsed.args, parsed.options);
-  } catch (error) {
-    let dummySpawned = new childProcess.ChildProcess(), errorPromise = Promise.reject(makeError({
-      error,
-      stdout: "",
-      stderr: "",
-      all: "",
-      command,
-      escapedCommand,
-      parsed,
-      timedOut: !1,
-      isCanceled: !1,
-      killed: !1
-    }));
-    return mergePromise(dummySpawned, errorPromise), dummySpawned;
-  }
-  let spawnedPromise = getSpawnedPromise(spawned), timedPromise = setupTimeout(spawned, parsed.options, spawnedPromise), processDone = setExitHandler(spawned, parsed.options, timedPromise), context = { isCanceled: !1 };
-  spawned.kill = spawnedKill.bind(null, spawned.kill.bind(spawned)), spawned.cancel = spawnedCancel.bind(null, spawned, context);
-  let handlePromiseOnce = onetime_default(async () => {
-    let [{ error, exitCode, signal, timedOut }, stdoutResult, stderrResult, allResult] = await getSpawnedResult(spawned, parsed.options, processDone), stdout = handleOutput(parsed.options, stdoutResult), stderr = handleOutput(parsed.options, stderrResult), all = handleOutput(parsed.options, allResult);
-    if (error || exitCode !== 0 || signal !== null) {
-      let returnedError = makeError({
-        error,
-        exitCode,
-        signal,
-        stdout,
-        stderr,
-        all,
-        command,
-        escapedCommand,
-        parsed,
-        timedOut,
-        isCanceled: context.isCanceled || (parsed.options.signal ? parsed.options.signal.aborted : !1),
-        killed: spawned.killed
-      });
-      if (!parsed.options.reject)
-        return returnedError;
-      throw returnedError;
-    }
-    return {
-      command,
-      escapedCommand,
-      exitCode: 0,
-      stdout,
-      stderr,
-      all,
-      failed: !1,
-      timedOut: !1,
-      isCanceled: !1,
-      killed: !1
-    };
-  });
-  return handleInput(spawned, parsed.options), spawned.all = makeAllStream(spawned, parsed.options), addPipeMethods(spawned), mergePromise(spawned, handlePromiseOnce), spawned;
-}
-function execaSync(file, args, options) {
-  let parsed = handleArguments(file, args, options), command = joinCommand(file, args), escapedCommand = getEscapedCommand(file, args);
-  logCommand(escapedCommand, parsed.options);
-  let input = handleInputSync(parsed.options), result;
-  try {
-    result = childProcess.spawnSync(parsed.file, parsed.args, { ...parsed.options, input });
-  } catch (error) {
-    throw makeError({
-      error,
-      stdout: "",
-      stderr: "",
-      all: "",
-      command,
-      escapedCommand,
-      parsed,
-      timedOut: !1,
-      isCanceled: !1,
-      killed: !1
-    });
-  }
-  let stdout = handleOutput(parsed.options, result.stdout, result.error), stderr = handleOutput(parsed.options, result.stderr, result.error);
-  if (result.error || result.status !== 0 || result.signal !== null) {
-    let error = makeError({
-      stdout,
-      stderr,
-      error: result.error,
-      signal: result.signal,
-      exitCode: result.status,
-      command,
-      escapedCommand,
-      parsed,
-      timedOut: result.error && result.error.code === "ETIMEDOUT",
-      isCanceled: !1,
-      killed: result.signal !== null
-    });
-    if (!parsed.options.reject)
-      return error;
-    throw error;
-  }
-  return {
-    command,
-    escapedCommand,
-    exitCode: 0,
-    stdout,
-    stderr,
-    failed: !1,
-    timedOut: !1,
-    isCanceled: !1,
-    killed: !1
-  };
-}
-var normalizeScriptStdin = ({ input, inputFile, stdio }) => input === void 0 && inputFile === void 0 && stdio === void 0 ? { stdin: "inherit" } : {}, normalizeScriptOptions = (options = {}) => ({
-  preferLocal: !0,
-  ...normalizeScriptStdin(options),
-  ...options
-});
-function create$(options) {
-  function $2(templatesOrOptions, ...expressions) {
-    if (!Array.isArray(templatesOrOptions))
-      return create$({ ...options, ...templatesOrOptions });
-    let [file, ...args] = parseTemplates(templatesOrOptions, expressions);
-    return execa(file, args, normalizeScriptOptions(options));
-  }
-  return $2.sync = (templates, ...expressions) => {
-    if (!Array.isArray(templates))
-      throw new TypeError("Please use $(options).sync`command` instead of $.sync(options)`command`.");
-    let [file, ...args] = parseTemplates(templates, expressions);
-    return execaSync(file, args, normalizeScriptOptions(options));
-  }, $2;
-}
-var $ = create$();
-function execaCommand(command, options) {
-  let [file, ...args] = parseCommand(command);
-  return execa(file, args, options);
-}
-function execaCommandSync(command, options) {
-  let [file, ...args] = parseCommand(command);
-  return execaSync(file, args, options);
-}
-
-export {
-  NPM_LOCKFILE,
-  PNPM_LOCKFILE,
-  YARN_LOCKFILE,
-  BUN_LOCKFILE,
-  BUN_LOCKFILE_BINARY,
-  getProjectRoot,
-  invalidateProjectRootCache,
-  findFilesUp,
-  nodePathsToArray,
-  normalizeStoryPath,
-  loadEnvs,
-  stringifyEnvs,
-  stringifyProcessEnvs,
-  optionalEnvToBoolean,
-  isCI,
-  require_cross_spawn,
-  execa,
-  execaSync,
-  execaCommand,
-  execaCommandSync
-};