@aussieljk/forkbook 0.0.0-stage → 0.0.1-1

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

@@ -0,0 +1,2034 @@
+import CJS_COMPAT_NODE_URL_5ewvyy4zw6m from 'node:url';
+import CJS_COMPAT_NODE_PATH_5ewvyy4zw6m from 'node:path';
+import CJS_COMPAT_NODE_MODULE_5ewvyy4zw6m from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_5ewvyy4zw6m.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_5ewvyy4zw6m.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_5ewvyy4zw6m.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Forkbook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  createServiceRuntime,
+  getRegisteredServices,
+  getService,
+  registerService,
+  resolveStaticPath,
+  serviceRegistryApi,
+  validateSchema
+} from "./chunk-YWMICX2T.js";
+import {
+  argumentsTag,
+  arrayBufferTag,
+  arrayTag,
+  booleanTag,
+  dataViewTag,
+  dateTag,
+  float32ArrayTag,
+  float64ArrayTag,
+  getSymbols,
+  getTag,
+  int16ArrayTag,
+  int32ArrayTag,
+  int8ArrayTag,
+  isBuffer,
+  isPlainObject,
+  isPrimitive,
+  isTypedArray,
+  mapTag,
+  numberTag,
+  objectTag,
+  regexpTag,
+  setTag,
+  stringTag,
+  symbolTag,
+  uint16ArrayTag,
+  uint32ArrayTag,
+  uint8ArrayTag,
+  uint8ClampedArrayTag
+} from "./chunk-SRXCCL2O.js";
+import {
+  any,
+  up,
+  up2
+} from "./chunk-NZ3GOT7V.js";
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-NKAUZU4C.js";
+
+// ../../node_modules/picomatch/lib/constants.js
+var require_constants = __commonJS({
+  "../../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 = {
+      __proto__: null,
+      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 = {
+      DEFAULT_MAX_EXTGLOB_RECURSION: 0,
+      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/picomatch/lib/utils.js
+var require_utils = __commonJS({
+  "../../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 = (path, { windows } = {}) => {
+      let segs = path.split(windows ? /[\\/]/ : "/"), last = segs[segs.length - 1];
+      return last === "" ? segs[segs.length - 2] : last;
+    };
+  }
+});
+
+// ../../node_modules/picomatch/lib/scan.js
+var require_scan = __commonJS({
+  "../../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.tokens === !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) {
+            let parens = 0;
+            for (; eos() !== !0 && (code = advance()); ) {
+              if (code === CHAR_BACKWARD_SLASH) {
+                backslashes = token.backslashes = !0, advance();
+                continue;
+              }
+              if (code === CHAR_LEFT_PARENTHESES) {
+                parens++;
+                continue;
+              }
+              if (code === CHAR_RIGHT_PARENTHESES && --parens === 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) {
+            let parens = 1;
+            for (; eos() !== !0 && (code = advance()); ) {
+              if (code === CHAR_BACKWARD_SLASH) {
+                backslashes = token.backslashes = !0, advance();
+                continue;
+              }
+              if (code === CHAR_LEFT_PARENTHESES) {
+                parens++;
+                continue;
+              }
+              if (code === CHAR_RIGHT_PARENTHESES && --parens === 0) {
+                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 n2 = prevIndex !== void 0 ? prevIndex + 1 : start, i = slashes[idx], value2 = input.slice(n2, i);
+          opts.tokens && (idx === 0 && start !== 0 ? (tokens[idx].isPrefix = !0, tokens[idx].value = prefix) : tokens[idx].value = value2, depth(tokens[idx]), state.maxDepth += tokens[idx].depth), i >= start && (parts.push(value2), prevIndex = i);
+        }
+        let n = prevIndex !== void 0 ? prevIndex + 1 : start, value = input.slice(n);
+        parts.push(value), opts.tokens && prevIndex && prevIndex + 1 < input.length && (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/picomatch/lib/parse.js
+var require_parse = __commonJS({
+  "../../node_modules/picomatch/lib/parse.js"(exports, module) {
+    "use strict";
+    var constants = require_constants(), utils = require_utils(), {
+      MAX_LENGTH,
+      POSIX_REGEX_SOURCE,
+      REGEX_NON_SPECIAL_CHARS,
+      REGEX_SPECIAL_CHARS_BACKREF,
+      REPLACEMENTS
+    } = constants, 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`, splitTopLevel = (input) => {
+      let parts = [], bracket = 0, paren = 0, quote = 0, value = "", escaped = !1;
+      for (let ch of input) {
+        if (escaped === !0) {
+          value += ch, escaped = !1;
+          continue;
+        }
+        if (ch === "\\") {
+          value += ch, escaped = !0;
+          continue;
+        }
+        if (ch === '"') {
+          quote = quote === 1 ? 0 : 1, value += ch;
+          continue;
+        }
+        if (quote === 0) {
+          if (ch === "[")
+            bracket++;
+          else if (ch === "]" && bracket > 0)
+            bracket--;
+          else if (bracket === 0) {
+            if (ch === "(")
+              paren++;
+            else if (ch === ")" && paren > 0)
+              paren--;
+            else if (ch === "|" && paren === 0) {
+              parts.push(value), value = "";
+              continue;
+            }
+          }
+        }
+        value += ch;
+      }
+      return parts.push(value), parts;
+    }, isPlainBranch = (branch) => {
+      let escaped = !1;
+      for (let ch of branch) {
+        if (escaped === !0) {
+          escaped = !1;
+          continue;
+        }
+        if (ch === "\\") {
+          escaped = !0;
+          continue;
+        }
+        if (/[?*+@!()[\]{}]/.test(ch))
+          return !1;
+      }
+      return !0;
+    }, normalizeSimpleBranch = (branch) => {
+      let value = branch.trim(), changed = !0;
+      for (; changed === !0; )
+        changed = !1, /^@\([^\\()[\]{}|]+\)$/.test(value) && (value = value.slice(2, -1), changed = !0);
+      if (isPlainBranch(value))
+        return value.replace(/\\(.)/g, "$1");
+    }, hasRepeatedCharPrefixOverlap = (branches) => {
+      let values = branches.map(normalizeSimpleBranch).filter(Boolean);
+      for (let i = 0; i < values.length; i++)
+        for (let j = i + 1; j < values.length; j++) {
+          let a = values[i], b = values[j], char = a[0];
+          if (!(!char || a !== char.repeat(a.length) || b !== char.repeat(b.length)) && (a === b || a.startsWith(b) || b.startsWith(a)))
+            return !0;
+        }
+      return !1;
+    }, parseRepeatedExtglob = (pattern, requireEnd = !0) => {
+      if (pattern[0] !== "+" && pattern[0] !== "*" || pattern[1] !== "(")
+        return;
+      let bracket = 0, paren = 0, quote = 0, escaped = !1;
+      for (let i = 1; i < pattern.length; i++) {
+        let ch = pattern[i];
+        if (escaped === !0) {
+          escaped = !1;
+          continue;
+        }
+        if (ch === "\\") {
+          escaped = !0;
+          continue;
+        }
+        if (ch === '"') {
+          quote = quote === 1 ? 0 : 1;
+          continue;
+        }
+        if (quote !== 1) {
+          if (ch === "[") {
+            bracket++;
+            continue;
+          }
+          if (ch === "]" && bracket > 0) {
+            bracket--;
+            continue;
+          }
+          if (!(bracket > 0)) {
+            if (ch === "(") {
+              paren++;
+              continue;
+            }
+            if (ch === ")" && (paren--, paren === 0))
+              return requireEnd === !0 && i !== pattern.length - 1 ? void 0 : {
+                type: pattern[0],
+                body: pattern.slice(2, i),
+                end: i
+              };
+          }
+        }
+      }
+    }, buildCharClassStar = (chars) => `${chars.length === 1 ? utils.escapeRegex(chars[0]) : `[${chars.map((ch) => utils.escapeRegex(ch)).join("")}]`}*`, getStarExtglobSequenceChars = (pattern) => {
+      let index = 0, chars = [];
+      for (; index < pattern.length; ) {
+        let match = parseRepeatedExtglob(pattern.slice(index), !1);
+        if (!match || match.type !== "*")
+          return;
+        let branches = splitTopLevel(match.body).map((branch2) => branch2.trim());
+        if (branches.length !== 1)
+          return;
+        let branch = normalizeSimpleBranch(branches[0]);
+        if (!branch || branch.length !== 1)
+          return;
+        chars.push(branch), index += match.end + 1;
+      }
+      if (!(chars.length < 1))
+        return chars;
+    }, repeatedExtglobRecursion = (pattern) => {
+      let depth = 0, value = pattern.trim(), match = parseRepeatedExtglob(value);
+      for (; match; )
+        depth++, value = match.body.trim(), match = parseRepeatedExtglob(value);
+      return depth;
+    }, analyzeRepeatedExtglob = (body, options) => {
+      if (options.maxExtglobRecursion === !1)
+        return { risky: !1 };
+      let max = typeof options.maxExtglobRecursion == "number" ? options.maxExtglobRecursion : constants.DEFAULT_MAX_EXTGLOB_RECURSION, branches = splitTopLevel(body).map((branch) => branch.trim());
+      if (branches.length > 1 && (branches.some((branch) => branch === "") || branches.some((branch) => /^[*?]+$/.test(branch)) || hasRepeatedCharPrefixOverlap(branches)))
+        return { risky: !0 };
+      let safeChars = [], sawStarSequence = !1, combinable = !0;
+      for (let branch of branches) {
+        let chars = getStarExtglobSequenceChars(branch);
+        if (chars) {
+          sawStarSequence = !0, safeChars.push(...chars);
+          continue;
+        }
+        let literal = normalizeSimpleBranch(branch);
+        if (literal && literal.length === 1) {
+          safeChars.push(literal);
+          continue;
+        }
+        if (combinable = !1, repeatedExtglobRecursion(branch) > max)
+          return { risky: !0 };
+      }
+      return sawStarSequence ? combinable ? { risky: !0, safeOutput: buildCharClassStar([...new Set(safeChars)]) } : { risky: !0 } : { risky: !1 };
+    }, 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 = constants.globChars(opts.windows), EXTGLOB_CHARS = constants.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, token.startIndex = state.index, token.tokensIndex = tokens.length;
+        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 literal = input.slice(token.startIndex, state.index + 1), body = input.slice(token.startIndex + 2, state.index), analysis = analyzeRepeatedExtglob(body, opts);
+        if ((token.type === "plus" || token.type === "star") && analysis.risky) {
+          let safeOutput = analysis.safeOutput ? (token.output ? "" : ONE_CHAR) + (opts.capture ? `(${analysis.safeOutput})` : analysis.safeOutput) : void 0, open = tokens[token.tokensIndex];
+          open.type = "text", open.value = literal, open.output = safeOutput || utils.escapeRegex(literal);
+          for (let i = token.tokensIndex + 1; i < tokens.length; i++)
+            tokens[i].value = "", tokens[i].output = "", delete tokens[i].suffix;
+          state.output = token.output + open.output, state.backtrack = !0, push({ type: "paren", extglob: !0, value, output: "" }), decrement("parens");
+          return;
+        }
+        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);
+          }
+          let isEnd = eos() || state.parens > 0 && rest === ")".repeat(state.parens) && !extglobs.some((extglob) => extglob.type === "negate");
+          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 && isEnd) {
+            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
+      } = constants.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/picomatch/lib/picomatch.js
+var require_picomatch = __commonJS({
+  "../../node_modules/picomatch/lib/picomatch.js"(exports, module) {
+    "use strict";
+    var scan = require_scan(), parse = require_parse(), utils = require_utils(), constants = 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, posix2 = options && options.windows) => (glob instanceof RegExp ? glob : picomatch2.makeRe(glob, options)).test(utils.basename(input, { windows: posix2 }));
+    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 = constants;
+    module.exports = picomatch2;
+  }
+});
+
+// ../../node_modules/picomatch/index.js
+var require_picomatch2 = __commonJS({
+  "../../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;
+  }
+});
+
+// src/shared/open-service/server.ts
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "pathe";
+
+// ../../node_modules/es-toolkit/dist/object/clone.mjs
+function clone(obj) {
+  if (isPrimitive(obj)) return obj;
+  if (Array.isArray(obj) || isTypedArray(obj) || obj instanceof ArrayBuffer || typeof SharedArrayBuffer < "u" && obj instanceof SharedArrayBuffer) return obj.slice(0);
+  let prototype = Object.getPrototypeOf(obj);
+  if (prototype == null) return Object.assign(Object.create(prototype), obj);
+  let Constructor = prototype.constructor;
+  if (obj instanceof Date || obj instanceof Map || obj instanceof Set) return new Constructor(obj);
+  if (obj instanceof RegExp) {
+    let newRegExp = new Constructor(obj);
+    return newRegExp.lastIndex = obj.lastIndex, newRegExp;
+  }
+  if (obj instanceof DataView) return new Constructor(obj.buffer.slice(0));
+  if (obj instanceof Error) {
+    let newError;
+    return obj instanceof AggregateError ? newError = new Constructor(obj.errors, obj.message, { cause: obj.cause }) : newError = new Constructor(obj.message, { cause: obj.cause }), newError.stack = obj.stack, Object.assign(newError, obj), newError;
+  }
+  return typeof File < "u" && obj instanceof File ? new Constructor([obj], obj.name, {
+    type: obj.type,
+    lastModified: obj.lastModified
+  }) : typeof obj == "object" ? Object.assign(Object.create(prototype), obj) : obj;
+}
+
+// ../../node_modules/es-toolkit/dist/object/cloneDeepWith.mjs
+function cloneDeepWithImpl(valueToClone, keyToClone, objectToClone, stack = /* @__PURE__ */ new Map(), cloneValue = void 0) {
+  let cloned = cloneValue?.(valueToClone, keyToClone, objectToClone, stack);
+  if (cloned !== void 0) return cloned;
+  if (isPrimitive(valueToClone)) return valueToClone;
+  if (stack.has(valueToClone)) return stack.get(valueToClone);
+  if (Array.isArray(valueToClone)) {
+    let result = new Array(valueToClone.length);
+    stack.set(valueToClone, result);
+    for (let i = 0; i < valueToClone.length; i++) result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
+    return Object.hasOwn(valueToClone, "index") && (result.index = valueToClone.index), Object.hasOwn(valueToClone, "input") && (result.input = valueToClone.input), result;
+  }
+  if (valueToClone instanceof Date) return new Date(valueToClone.getTime());
+  if (valueToClone instanceof RegExp) {
+    let result = new RegExp(valueToClone.source, valueToClone.flags);
+    return result.lastIndex = valueToClone.lastIndex, result;
+  }
+  if (valueToClone instanceof Map) {
+    let result = /* @__PURE__ */ new Map();
+    stack.set(valueToClone, result);
+    for (let [key, value] of valueToClone) result.set(key, cloneDeepWithImpl(value, key, objectToClone, stack, cloneValue));
+    return result;
+  }
+  if (valueToClone instanceof Set) {
+    let result = /* @__PURE__ */ new Set();
+    stack.set(valueToClone, result);
+    for (let value of valueToClone) result.add(cloneDeepWithImpl(value, void 0, objectToClone, stack, cloneValue));
+    return result;
+  }
+  if (isBuffer(valueToClone)) return valueToClone.subarray();
+  if (isTypedArray(valueToClone)) {
+    let result = new (Object.getPrototypeOf(valueToClone)).constructor(valueToClone.length);
+    stack.set(valueToClone, result);
+    for (let i = 0; i < valueToClone.length; i++) result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (valueToClone instanceof ArrayBuffer || typeof SharedArrayBuffer < "u" && valueToClone instanceof SharedArrayBuffer) return valueToClone.slice(0);
+  if (valueToClone instanceof DataView) {
+    let result = new DataView(valueToClone.buffer.slice(0), valueToClone.byteOffset, valueToClone.byteLength);
+    return stack.set(valueToClone, result), copyProperties(result, valueToClone, objectToClone, stack, cloneValue), result;
+  }
+  if (typeof File < "u" && valueToClone instanceof File) {
+    let result = new File([valueToClone], valueToClone.name, { type: valueToClone.type });
+    return stack.set(valueToClone, result), copyProperties(result, valueToClone, objectToClone, stack, cloneValue), result;
+  }
+  if (typeof Blob < "u" && valueToClone instanceof Blob) {
+    let result = new Blob([valueToClone], { type: valueToClone.type });
+    return stack.set(valueToClone, result), copyProperties(result, valueToClone, objectToClone, stack, cloneValue), result;
+  }
+  if (valueToClone instanceof Error) {
+    let result = structuredClone(valueToClone);
+    return stack.set(valueToClone, result), result.message = valueToClone.message, result.name = valueToClone.name, result.stack = valueToClone.stack, result.cause = valueToClone.cause, result.constructor = valueToClone.constructor, copyProperties(result, valueToClone, objectToClone, stack, cloneValue), result;
+  }
+  if (valueToClone instanceof Boolean) {
+    let result = new Boolean(valueToClone.valueOf());
+    return stack.set(valueToClone, result), copyProperties(result, valueToClone, objectToClone, stack, cloneValue), result;
+  }
+  if (valueToClone instanceof Number) {
+    let result = new Number(valueToClone.valueOf());
+    return stack.set(valueToClone, result), copyProperties(result, valueToClone, objectToClone, stack, cloneValue), result;
+  }
+  if (valueToClone instanceof String) {
+    let result = new String(valueToClone.valueOf());
+    return stack.set(valueToClone, result), copyProperties(result, valueToClone, objectToClone, stack, cloneValue), result;
+  }
+  if (typeof valueToClone == "object" && isCloneableObject(valueToClone)) {
+    let result = Object.create(Object.getPrototypeOf(valueToClone));
+    return stack.set(valueToClone, result), copyProperties(result, valueToClone, objectToClone, stack, cloneValue), result;
+  }
+  return valueToClone;
+}
+function copyProperties(target, source, objectToClone = target, stack, cloneValue) {
+  let keys = [...Object.keys(source), ...getSymbols(source)];
+  for (let i = 0; i < keys.length; i++) {
+    let key = keys[i], descriptor = Object.getOwnPropertyDescriptor(target, key);
+    (descriptor == null || descriptor.writable) && (target[key] = cloneDeepWithImpl(source[key], key, objectToClone, stack, cloneValue));
+  }
+}
+function isCloneableObject(object) {
+  switch (getTag(object)) {
+    case argumentsTag:
+    case arrayTag:
+    case arrayBufferTag:
+    case dataViewTag:
+    case booleanTag:
+    case dateTag:
+    case float32ArrayTag:
+    case float64ArrayTag:
+    case int8ArrayTag:
+    case int16ArrayTag:
+    case int32ArrayTag:
+    case mapTag:
+    case numberTag:
+    case objectTag:
+    case regexpTag:
+    case setTag:
+    case stringTag:
+    case symbolTag:
+    case uint8ArrayTag:
+    case uint8ClampedArrayTag:
+    case uint16ArrayTag:
+    case uint32ArrayTag:
+      return !0;
+    default:
+      return !1;
+  }
+}
+
+// ../../node_modules/es-toolkit/dist/object/cloneDeep.mjs
+function cloneDeep(obj) {
+  return cloneDeepWithImpl(obj, void 0, obj, /* @__PURE__ */ new Map(), void 0);
+}
+
+// ../../node_modules/es-toolkit/dist/_internal/isMergeableValue.mjs
+function isMergeableValue(value) {
+  return isPlainObject(value) || Array.isArray(value);
+}
+
+// ../../node_modules/es-toolkit/dist/_internal/isUnsafeProperty.mjs
+function isUnsafeProperty(key) {
+  return key === "__proto__";
+}
+
+// ../../node_modules/es-toolkit/dist/object/mergeWith.mjs
+function mergeWith(target, source, merge2) {
+  let sourceKeys = Object.keys(source);
+  for (let i = 0; i < sourceKeys.length; i++) {
+    let key = sourceKeys[i];
+    if (isUnsafeProperty(key)) continue;
+    let sourceValue = source[key], targetValue = target[key], merged = merge2(targetValue, sourceValue, key, target, source);
+    merged !== void 0 ? target[key] = merged : isMergeableValue(sourceValue) && isMergeableValue(targetValue) ? target[key] = mergeWith(targetValue, sourceValue, merge2) : Array.isArray(sourceValue) ? target[key] = mergeWith([], sourceValue, merge2) : isPlainObject(sourceValue) ? target[key] = mergeWith({}, sourceValue, merge2) : (targetValue === void 0 || sourceValue !== void 0) && (target[key] = sourceValue);
+  }
+  return target;
+}
+
+// ../../node_modules/es-toolkit/dist/object/toMerged.mjs
+function toMerged(target, source) {
+  return mergeWith(cloneDeep(target), source, function mergeRecursively(targetValue, sourceValue) {
+    if (isMergeableValue(sourceValue) && isMergeableValue(targetValue)) return mergeWith(clone(targetValue), sourceValue, mergeRecursively);
+    if (Array.isArray(sourceValue)) return mergeWith([], sourceValue, mergeRecursively);
+    if (isPlainObject(sourceValue)) return mergeWith({}, sourceValue, mergeRecursively);
+  });
+}
+
+// src/shared/open-service/server.ts
+var getService2 = getService;
+function registerService2(definition, registration) {
+  return registerService(definition, registration, { relay: !0 });
+}
+async function buildStaticFiles() {
+  let store = {}, buildTasks = [];
+  for (let service of getRegisteredServices())
+    for (let [queryName, query] of Object.entries(service.queries)) {
+      let { load, staticPath, staticInputs } = query;
+      !staticPath || !load || !staticInputs || buildTasks.push(
+        (async () => {
+          let inputsRuntime = createServiceRuntime(service, { registryApi: serviceRegistryApi }), inputs = await staticInputs(inputsRuntime.loadCtxForStatic);
+          return Promise.all(
+            inputs.map(async (input) => {
+              let buildRuntime = createServiceRuntime(service, {
+                registryApi: serviceRegistryApi
+              }), validatedInput = await validateSchema(query.input, input, {
+                kind: "query",
+                serviceId: service.id,
+                name: queryName,
+                phase: "input"
+              }), path = resolveStaticPath(service.id, queryName, { staticPath }, validatedInput);
+              return await buildRuntime.runLoadOnce(queryName, validatedInput), { path, state: buildRuntime.getStateSnapshot() };
+            })
+          );
+        })()
+      );
+    }
+  let builtStates = (await Promise.all(buildTasks)).flat();
+  for (let { path, state } of builtStates)
+    store[path] = path in store ? toMerged(store[path], state) : state;
+  return store;
+}
+async function writeOpenServiceStaticFiles(outputDir) {
+  let staticStore = await buildStaticFiles();
+  await Promise.all(
+    Object.entries(staticStore).map(async ([relativePath, state]) => {
+      let outputPath = join(outputDir, "services", ...relativePath.split("/"));
+      await mkdir(dirname(outputPath), { recursive: !0 }), await writeFile(outputPath, JSON.stringify(state, null, 2));
+    })
+  );
+}
+
+// src/common/utils/paths.ts
+import { join as join2, relative as relative2, resolve as resolve3, sep as sep2 } from "node:path";
+
+// ../../node_modules/tinyglobby/dist/index.mjs
+import { readdir, readdirSync, realpath, realpathSync, stat, statSync } from "fs";
+import { isAbsolute, posix, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+
+// ../../node_modules/fdir/dist/index.mjs
+import { createRequire } from "module";
+import { basename, dirname as dirname2, normalize, relative, resolve, sep } from "path";
+import * as nativeFs from "fs";
+var __require = createRequire(import.meta.url);
+function cleanPath(path) {
+  let normalized = normalize(path);
+  return normalized.length > 1 && normalized[normalized.length - 1] === sep && (normalized = normalized.substring(0, normalized.length - 1)), normalized;
+}
+var SLASHES_REGEX = /[\\/]/g;
+function convertSlashes(path, separator) {
+  return path.replace(SLASHES_REGEX, separator);
+}
+var WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
+function isRootDirectory(path) {
+  return path === "/" || WINDOWS_ROOT_DIR_REGEX.test(path);
+}
+function normalizePath(path, options) {
+  let { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options, pathNeedsCleaning = process.platform === "win32" && path.includes("/") || path.startsWith(".");
+  if (resolvePaths && (path = resolve(path)), (normalizePath$1 || pathNeedsCleaning) && (path = cleanPath(path)), path === ".") return "";
+  let needsSeperator = path[path.length - 1] !== pathSeparator;
+  return convertSlashes(needsSeperator ? path + pathSeparator : path, 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 path = directoryPath || ".";
+  filters.every((filter) => filter(path, !0)) && paths.push(path);
+}, 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(path, state, callback$1) {
+  let { queue, fs, options: { suppressErrors } } = state;
+  queue.enqueue(), fs.realpath(path, (error, resolvedPath) => {
+    if (error) return queue.dequeue(suppressErrors ? null : error, state);
+    fs.stat(resolvedPath, (error$1, stat2) => {
+      if (error$1) return queue.dequeue(suppressErrors ? null : error$1, state);
+      if (stat2.isDirectory() && isRecursive(path, resolvedPath, state)) return queue.dequeue(null, state);
+      callback$1(stat2, resolvedPath), queue.dequeue(null, state);
+    });
+  });
+}, resolveSymlinks = function(path, state, callback$1) {
+  let { queue, fs, options: { suppressErrors } } = state;
+  queue.enqueue();
+  try {
+    let resolvedPath = fs.realpathSync(path), stat2 = fs.statSync(resolvedPath);
+    if (stat2.isDirectory() && isRecursive(path, resolvedPath, state)) return;
+    callback$1(stat2, resolvedPath);
+  } catch (e) {
+    if (!suppressErrors) throw e;
+  }
+};
+function build$2(options, isSynchronous) {
+  return !options.resolveSymlinks || options.excludeSymlinks ? null : isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
+}
+function isRecursive(path, resolved, state) {
+  if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state);
+  let parent = dirname2(path), 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 = dirname2(parent);
+  }
+  return state.symlinks.set(path, 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 path = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+        if (exclude && exclude(entry.name, path)) continue;
+        this.pushDirectory(path, paths, filters), this.walkDirectory(this.state, path, path, depth - 1, this.walk);
+      } else if (this.resolveSymlink && entry.isSymbolicLink()) {
+        let path = joinPathWithBasePath(entry.name, directoryPath);
+        this.resolveSymlink(path, this.state, (stat2, resolvedPath) => {
+          if (stat2.isDirectory()) {
+            if (resolvedPath = normalizePath(resolvedPath, this.state.options), exclude && exclude(entry.name, useRealPaths ? resolvedPath : path + pathSeparator)) return;
+            this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path + pathSeparator, depth - 1, this.walk);
+          } else {
+            resolvedPath = useRealPaths ? resolvedPath : path;
+            let filename = basename(resolvedPath), directoryPath$1 = normalizePath(dirname2(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 {
+  __require.resolve("picomatch"), pm = __require("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((path) => isMatch(path)), this;
+  }
+};
+
+// ../../node_modules/tinyglobby/dist/index.mjs
+var import_picomatch = __toESM(require_picomatch2(), 1), isReadonlyArray = Array.isArray, BACKSLASHES = /\\/g, DRIVE_RELATIVE_PATH = /^[A-Za-z]:$/, isWin = process.platform === "win32", ONLY_PARENT_DIRECTORIES = /^(\/?\.\.)+$/;
+function getPartialMatcher(patterns, options = {}) {
+  let patternsCount = patterns.length, patternsParts = Array(patternsCount), matchers = Array(patternsCount), i, j;
+  for (i = 0; i < patternsCount; i++) {
+    let parts = splitPattern(patterns[i]);
+    patternsParts[i] = parts;
+    let partsCount = parts.length, partMatchers = Array(partsCount);
+    for (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 (i = 0; i < patternsCount; i++) {
+      let patternParts = patternsParts[i], matcher = matchers[i], inputPatternCount = inputParts.length, minParts = Math.min(inputPatternCount, patternParts.length);
+      for (j = 0; j < minParts; ) {
+        let part = patternParts[j];
+        if (part.includes("/")) return !0;
+        if (!matcher[j](inputParts[j])) break;
+        if (!options.noglobstar && 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 = cwd.length + +!isRoot(cwd);
+      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[p.length - 1] === "/" && result !== "" ? `${result}/` : result || ".";
+  };
+}
+function ensureNonDriveRelativePath(path) {
+  return path.replace(DRIVE_RELATIVE_PATH, (match) => `${match}/`);
+}
+var splitPatternOptions = { parts: !0 };
+function splitPattern(path) {
+  var _result$parts;
+  let result = import_picomatch.default.scan(path, splitPatternOptions);
+  return !((_result$parts = result.parts) === null || _result$parts === void 0) && _result$parts.length ? result.parts : [path];
+}
+var POSIX_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}*?|]|^!|[!+@](?=\()|\\(?![()[\]{}!*+?@|]))/g, WIN32_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}]|^!|[!+@](?=\())/g, escapePosixPath = (path) => path.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&"), escapeWin32Path = (path) => path.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);
+}
+function ensureStringArray(value) {
+  return typeof value == "string" ? [value] : value ?? [];
+}
+var PARENT_DIRECTORY = /^(\/?\.\.)+/, ESCAPING_BACKSLASHES = /\\(?=[()[\]{}!*+?@|])/g;
+function normalizePattern(pattern, opts, props, isIgnore) {
+  var _PARENT_DIRECTORY$exe;
+  let cwd = opts.cwd, result = pattern;
+  pattern[pattern.length - 1] === "/" && (result = pattern.slice(0, -1)), result[result.length - 1] !== "*" && opts.expandDirectories && (result += "/**");
+  let escapedCwd = escapePath(cwd);
+  result = isAbsolute(result.replace(ESCAPING_BACKSLASHES, "")) ? posix.relative(escapedCwd, result) : posix.normalize(result);
+  let parentDir = (_PARENT_DIRECTORY$exe = PARENT_DIRECTORY.exec(result)) === null || _PARENT_DIRECTORY$exe === void 0 ? void 0 : _PARENT_DIRECTORY$exe[0], parts = splitPattern(result);
+  if (parentDir) {
+    let n = (parentDir.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, parentDir.slice(i * 3));
+    potentialRoot[0] !== "." && props.root.length > potentialRoot.length && (props.root = ensureNonDriveRelativePath(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 (i === parts.length - 1 || part !== props.commonPath[i] || isDynamicPattern(part)) break;
+      newCommonPath.push(part);
+    }
+    props.depthOffset = newCommonPath.length, props.commonPath = newCommonPath, props.root = ensureNonDriveRelativePath(newCommonPath.length > 0 ? posix.join(cwd, ...newCommonPath) : cwd);
+  }
+  return result;
+}
+function processPatterns(options, patterns, props) {
+  let matchPatterns = [], ignorePatterns = [];
+  for (let pattern of options.ignore)
+    pattern && (pattern[0] !== "!" || pattern[1] === "(") && ignorePatterns.push(normalizePattern(pattern, options, props, !0));
+  for (let pattern of patterns)
+    pattern && (pattern[0] !== "!" || pattern[1] === "(" ? matchPatterns.push(normalizePattern(pattern, options, props, !1)) : (pattern[1] !== "!" || pattern[2] === "(") && ignorePatterns.push(normalizePattern(pattern.slice(1), options, props, !0)));
+  return {
+    match: matchPatterns,
+    ignore: ignorePatterns
+  };
+}
+function buildCrawler(options, patterns) {
+  let cwd = options.cwd, props = {
+    root: cwd,
+    depthOffset: 0
+  }, processed = processPatterns(options, patterns, props);
+  options.debug && log("internal processing patterns:", processed);
+  let { absolute, caseSensitiveMatch, debug, dot, followSymbolicLinks, onlyDirectories } = options, root = props.root.replace(BACKSLASHES, ""), matchOptions = {
+    dot,
+    nobrace: options.braceExpansion === !1,
+    nocase: !caseSensitiveMatch,
+    noextglob: options.extglob === !1,
+    noglobstar: options.globstar === !1,
+    posix: !0
+  }, matcher = (0, import_picomatch.default)(processed.match, matchOptions), ignore = (0, import_picomatch.default)(processed.ignore, matchOptions), partialMatcher = getPartialMatcher(processed.match, matchOptions), format = buildFormat(cwd, root, absolute), excludeFormatter = absolute ? format : buildFormat(cwd, root, !0), excludePredicate = (_, p) => {
+    let relativePath = excludeFormatter(p, !0);
+    return relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
+  }, maxDepth;
+  options.deep !== void 0 && (maxDepth = Math.round(options.deep - props.depthOffset));
+  let crawler = new Builder({
+    filters: [debug ? (p, isDirectory) => {
+      let path = format(p, isDirectory), matches = matcher(path) && !ignore(path);
+      return matches && log(`matched ${path}`), matches;
+    } : (p, isDirectory) => {
+      let path = format(p, isDirectory);
+      return matcher(path) && !ignore(path);
+    }],
+    exclude: debug ? (_, p) => {
+      let skipped = excludePredicate(_, p);
+      return log(`${skipped ? "skipped" : "crawling"} ${p}`), skipped;
+    } : excludePredicate,
+    fs: options.fs,
+    pathSeparator: "/",
+    relativePaths: !absolute,
+    resolvePaths: absolute,
+    includeBasePath: absolute,
+    resolveSymlinks: followSymbolicLinks,
+    excludeSymlinks: !followSymbolicLinks,
+    excludeFiles: onlyDirectories,
+    includeDirs: onlyDirectories || !options.onlyFiles,
+    maxDepth,
+    signal: options.signal
+  }).crawl(root);
+  return options.debug && log("internal properties:", {
+    ...props,
+    root
+  }), [crawler, cwd !== root && !absolute && buildRelative(cwd, root)];
+}
+function formatPaths(paths, mapper) {
+  if (mapper) for (let i = paths.length - 1; i >= 0; i--) paths[i] = mapper(paths[i]);
+  return paths;
+}
+var defaultOptions = {
+  caseSensitiveMatch: !0,
+  debug: !!process.env.TINYGLOBBY_DEBUG,
+  expandDirectories: !0,
+  followSymbolicLinks: !0,
+  onlyFiles: !0
+};
+function getOptions(options) {
+  let opts = Object.assign({}, options);
+  for (let key in defaultOptions) opts[key] === void 0 && Object.assign(opts, { [key]: defaultOptions[key] });
+  return opts.cwd = (opts.cwd instanceof URL ? fileURLToPath(opts.cwd) : resolve2(opts.cwd || process.cwd())).replace(BACKSLASHES, "/"), opts.ignore = ensureStringArray(opts.ignore), opts.fs && (opts.fs = {
+    readdir: opts.fs.readdir || readdir,
+    readdirSync: opts.fs.readdirSync || readdirSync,
+    realpath: opts.fs.realpath || realpath,
+    realpathSync: opts.fs.realpathSync || realpathSync,
+    stat: opts.fs.stat || stat,
+    statSync: opts.fs.statSync || statSync
+  }), opts.debug && log("globbing with options:", opts), opts;
+}
+function getCrawler(globInput, inputOptions = {}) {
+  var _ref;
+  if (globInput && inputOptions?.patterns) throw new Error("Cannot pass patterns as both an argument and an option");
+  let isModern = isReadonlyArray(globInput) || typeof globInput == "string", patterns = ensureStringArray((_ref = isModern ? globInput : globInput.patterns) !== null && _ref !== void 0 ? _ref : "**/*"), options = getOptions(isModern ? inputOptions : globInput);
+  return patterns.length > 0 ? buildCrawler(options, patterns) : [];
+}
+function globSync(globInput, options) {
+  let [crawler, relative3] = getCrawler(globInput, options);
+  return crawler ? formatPaths(crawler.sync(), relative3) : [];
+}
+
+// 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.FORKBOOK_PROJECT_ROOT)
+    return process.env.FORKBOOK_PROJECT_ROOT;
+  try {
+    let found = up2(".git") || up2(".svn") || up2(".hg");
+    if (found)
+      return projectRoot = join2(found, ".."), projectRoot;
+  } catch (e) {
+    process.stdout.write(`
+error searching for repository root: ${e}
+`);
+  }
+  try {
+    let found = any(LOCK_FILES);
+    if (found)
+      return projectRoot = join2(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) => resolve3("./", p)), relativePattern = /^\.{1,2}([/\\]|$)/;
+function normalizeStoryPath(filename) {
+  return relativePattern.test(filename) ? filename : `.${sep2}${filename}`;
+}
+
+export {
+  getService2 as getService,
+  registerService2 as registerService,
+  writeOpenServiceStaticFiles,
+  require_picomatch2 as require_picomatch,
+  NPM_LOCKFILE,
+  PNPM_LOCKFILE,
+  YARN_LOCKFILE,
+  BUN_LOCKFILE,
+  BUN_LOCKFILE_BINARY,
+  getProjectRoot,
+  invalidateProjectRootCache,
+  findFilesUp,
+  nodePathsToArray,
+  normalizeStoryPath
+};