@tinacms/schema-tools 2.8.2 → 2.9.0

package/dist/index.js

@@ -1,9 +1,6 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import * as yup from "yup";
 import UrlPattern from "url-pattern";
 import z$1, { z, ZodError } from "zod";
@@ -32,419 +29,494 @@ function addNamespaceToSchema(maybeNode, namespace = []) {
 function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
-var utils$4 = {};
-const WIN_SLASH = "\\\\/";
-const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
-const DOT_LITERAL = "\\.";
-const PLUS_LITERAL = "\\+";
-const QMARK_LITERAL = "\\?";
-const SLASH_LITERAL = "\\/";
-const ONE_CHAR = "(?=.)";
-const QMARK = "[^/]";
-const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
-const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
-const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
-const NO_DOT = `(?!${DOT_LITERAL})`;
-const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
-const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
-const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
-const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
-const STAR = `${QMARK}*?`;
-const SEP = "/";
-const 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
-};
-const WINDOWS_CHARS = {
-  ...POSIX_CHARS,
-  SLASH_LITERAL: `[${WIN_SLASH}]`,
-  QMARK: WIN_NO_SLASH,
-  STAR: `${WIN_NO_SLASH}*?`,
-  DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
-  NO_DOT: `(?!${DOT_LITERAL})`,
-  NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
-  NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
-  NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
-  QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
-  START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
-  END_ANCHOR: `(?:[${WIN_SLASH}]|$)`,
-  SEP: "\\"
-};
-const POSIX_REGEX_SOURCE$1 = {
-  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"
-};
-var constants$2 = {
-  MAX_LENGTH: 1024 * 64,
-  POSIX_REGEX_SOURCE: POSIX_REGEX_SOURCE$1,
-  // 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 === true ? WINDOWS_CHARS : POSIX_CHARS;
-  }
-};
-(function(exports) {
-  const {
-    REGEX_BACKSLASH,
-    REGEX_REMOVE_BACKSLASH,
-    REGEX_SPECIAL_CHARS,
-    REGEX_SPECIAL_CHARS_GLOBAL
-  } = constants$2;
-  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 !== "undefined" && navigator.platform) {
-      const platform = navigator.platform.toLowerCase();
-      return platform === "win32" || platform === "windows";
-    }
-    if (typeof process !== "undefined" && process.platform) {
-      return process.platform === "win32";
-    }
-    return false;
+var utils = {};
+var constants;
+var hasRequiredConstants;
+function requireConstants() {
+  if (hasRequiredConstants) return constants;
+  hasRequiredConstants = 1;
+  const WIN_SLASH = "\\\\/";
+  const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+  const DOT_LITERAL = "\\.";
+  const PLUS_LITERAL = "\\+";
+  const QMARK_LITERAL = "\\?";
+  const SLASH_LITERAL = "\\/";
+  const ONE_CHAR = "(?=.)";
+  const QMARK = "[^/]";
+  const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+  const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+  const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+  const NO_DOT = `(?!${DOT_LITERAL})`;
+  const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+  const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+  const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+  const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+  const STAR = `${QMARK}*?`;
+  const SEP = "/";
+  const 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
   };
-  exports.removeBackslashes = (str) => {
-    return str.replace(REGEX_REMOVE_BACKSLASH, (match) => {
-      return match === "\\" ? "" : match;
-    });
+  const WINDOWS_CHARS = {
+    ...POSIX_CHARS,
+    SLASH_LITERAL: `[${WIN_SLASH}]`,
+    QMARK: WIN_NO_SLASH,
+    STAR: `${WIN_NO_SLASH}*?`,
+    DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+    NO_DOT: `(?!${DOT_LITERAL})`,
+    NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+    NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+    NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+    QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+    START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+    END_ANCHOR: `(?:[${WIN_SLASH}]|$)`,
+    SEP: "\\"
   };
-  exports.escapeLast = (input, char, lastIdx) => {
-    const idx = input.lastIndexOf(char, lastIdx);
-    if (idx === -1)
-      return input;
-    if (input[idx - 1] === "\\")
-      return exports.escapeLast(input, char, idx - 1);
-    return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+  const POSIX_REGEX_SOURCE = {
+    alnum: "a-zA-Z0-9",
+    alpha: "a-zA-Z",
+    ascii: "\\x00-\\x7F",
+    blank: " \\t",
+    cntrl: "\\x00-\\x1F\\x7F",
+    digit: "0-9",
+    graph: "\\x21-\\x7E",
+    lower: "a-z",
+    print: "\\x20-\\x7E ",
+    punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
+    space: " \\t\\r\\n\\v\\f",
+    upper: "A-Z",
+    word: "A-Za-z0-9_",
+    xdigit: "A-Fa-f0-9"
   };
-  exports.removePrefix = (input, state = {}) => {
-    let output = input;
-    if (output.startsWith("./")) {
-      output = output.slice(2);
-      state.prefix = "./";
+  constants = {
+    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 === true ? WINDOWS_CHARS : POSIX_CHARS;
     }
-    return output;
   };
-  exports.wrapOutput = (input, state = {}, options = {}) => {
-    const prepend = options.contains ? "" : "^";
-    const append = options.contains ? "" : "$";
-    let output = `${prepend}(?:${input})${append}`;
-    if (state.negated === true) {
-      output = `(?:^(?!${output}).*$)`;
-    }
-    return output;
+  return constants;
+}
+var hasRequiredUtils;
+function requireUtils() {
+  if (hasRequiredUtils) return utils;
+  hasRequiredUtils = 1;
+  (function(exports$1) {
+    const {
+      REGEX_BACKSLASH,
+      REGEX_REMOVE_BACKSLASH,
+      REGEX_SPECIAL_CHARS,
+      REGEX_SPECIAL_CHARS_GLOBAL
+    } = /* @__PURE__ */ requireConstants();
+    exports$1.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
+    exports$1.hasRegexChars = (str) => REGEX_SPECIAL_CHARS.test(str);
+    exports$1.isRegexChar = (str) => str.length === 1 && exports$1.hasRegexChars(str);
+    exports$1.escapeRegex = (str) => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1");
+    exports$1.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/");
+    exports$1.isWindows = () => {
+      if (typeof navigator !== "undefined" && navigator.platform) {
+        const platform = navigator.platform.toLowerCase();
+        return platform === "win32" || platform === "windows";
+      }
+      if (typeof process !== "undefined" && process.platform) {
+        return process.platform === "win32";
+      }
+      return false;
+    };
+    exports$1.removeBackslashes = (str) => {
+      return str.replace(REGEX_REMOVE_BACKSLASH, (match) => {
+        return match === "\\" ? "" : match;
+      });
+    };
+    exports$1.escapeLast = (input, char, lastIdx) => {
+      const idx = input.lastIndexOf(char, lastIdx);
+      if (idx === -1) return input;
+      if (input[idx - 1] === "\\") return exports$1.escapeLast(input, char, idx - 1);
+      return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+    };
+    exports$1.removePrefix = (input, state = {}) => {
+      let output = input;
+      if (output.startsWith("./")) {
+        output = output.slice(2);
+        state.prefix = "./";
+      }
+      return output;
+    };
+    exports$1.wrapOutput = (input, state = {}, options = {}) => {
+      const prepend = options.contains ? "" : "^";
+      const append = options.contains ? "" : "$";
+      let output = `${prepend}(?:${input})${append}`;
+      if (state.negated === true) {
+        output = `(?:^(?!${output}).*$)`;
+      }
+      return output;
+    };
+    exports$1.basename = (path, { windows } = {}) => {
+      const segs = path.split(windows ? /[\\/]/ : "/");
+      const last = segs[segs.length - 1];
+      if (last === "") {
+        return segs[segs.length - 2];
+      }
+      return last;
+    };
+  })(utils);
+  return utils;
+}
+var scan_1;
+var hasRequiredScan;
+function requireScan() {
+  if (hasRequiredScan) return scan_1;
+  hasRequiredScan = 1;
+  const utils2 = /* @__PURE__ */ requireUtils();
+  const {
+    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
+    /* ] */
+  } = /* @__PURE__ */ requireConstants();
+  const isPathSeparator = (code) => {
+    return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
   };
-  exports.basename = (path, { windows } = {}) => {
-    const segs = path.split(windows ? /[\\/]/ : "/");
-    const last = segs[segs.length - 1];
-    if (last === "") {
-      return segs[segs.length - 2];
+  const depth = (token) => {
+    if (token.isPrefix !== true) {
+      token.depth = token.isGlobstar ? Infinity : 1;
     }
-    return last;
   };
-})(utils$4);
-const utils$3 = utils$4;
-const {
-  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
-  /* ] */
-} = constants$2;
-const isPathSeparator = (code) => {
-  return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
-};
-const depth = (token) => {
-  if (token.isPrefix !== true) {
-    token.depth = token.isGlobstar ? Infinity : 1;
-  }
-};
-const scan$1 = (input, options) => {
-  const opts = options || {};
-  const length = input.length - 1;
-  const scanToEnd = opts.parts === true || opts.scanToEnd === true;
-  const slashes = [];
-  const tokens = [];
-  const parts = [];
-  let str = input;
-  let index = -1;
-  let start = 0;
-  let lastIndex = 0;
-  let isBrace = false;
-  let isBracket = false;
-  let isGlob = false;
-  let isExtglob = false;
-  let isGlobstar = false;
-  let braceEscaped = false;
-  let backslashes = false;
-  let negated = false;
-  let negatedExtglob = false;
-  let finished = false;
-  let braces = 0;
-  let prev;
-  let code;
-  let token = { value: "", depth: 0, isGlob: false };
-  const eos = () => index >= length;
-  const peek = () => str.charCodeAt(index + 1);
-  const advance = () => {
-    prev = code;
-    return str.charCodeAt(++index);
-  };
-  while (index < length) {
-    code = advance();
-    let next;
-    if (code === CHAR_BACKWARD_SLASH) {
-      backslashes = token.backslashes = true;
+  const scan = (input, options) => {
+    const opts = options || {};
+    const length = input.length - 1;
+    const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+    const slashes = [];
+    const tokens = [];
+    const parts = [];
+    let str = input;
+    let index = -1;
+    let start = 0;
+    let lastIndex = 0;
+    let isBrace = false;
+    let isBracket = false;
+    let isGlob = false;
+    let isExtglob = false;
+    let isGlobstar = false;
+    let braceEscaped = false;
+    let backslashes = false;
+    let negated = false;
+    let negatedExtglob = false;
+    let finished = false;
+    let braces = 0;
+    let prev;
+    let code;
+    let token = { value: "", depth: 0, isGlob: false };
+    const eos = () => index >= length;
+    const peek = () => str.charCodeAt(index + 1);
+    const advance = () => {
+      prev = code;
+      return str.charCodeAt(++index);
+    };
+    while (index < length) {
       code = advance();
-      if (code === CHAR_LEFT_CURLY_BRACE) {
-        braceEscaped = true;
+      let next;
+      if (code === CHAR_BACKWARD_SLASH) {
+        backslashes = token.backslashes = true;
+        code = advance();
+        if (code === CHAR_LEFT_CURLY_BRACE) {
+          braceEscaped = true;
+        }
+        continue;
       }
-      continue;
-    }
-    if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
-      braces++;
-      while (eos() !== true && (code = advance())) {
-        if (code === CHAR_BACKWARD_SLASH) {
-          backslashes = token.backslashes = true;
-          advance();
+      if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
+        braces++;
+        while (eos() !== true && (code = advance())) {
+          if (code === CHAR_BACKWARD_SLASH) {
+            backslashes = token.backslashes = true;
+            advance();
+            continue;
+          }
+          if (code === CHAR_LEFT_CURLY_BRACE) {
+            braces++;
+            continue;
+          }
+          if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
+            isBrace = token.isBrace = true;
+            isGlob = token.isGlob = true;
+            finished = true;
+            if (scanToEnd === true) {
+              continue;
+            }
+            break;
+          }
+          if (braceEscaped !== true && code === CHAR_COMMA) {
+            isBrace = token.isBrace = true;
+            isGlob = token.isGlob = true;
+            finished = true;
+            if (scanToEnd === true) {
+              continue;
+            }
+            break;
+          }
+          if (code === CHAR_RIGHT_CURLY_BRACE) {
+            braces--;
+            if (braces === 0) {
+              braceEscaped = false;
+              isBrace = token.isBrace = true;
+              finished = true;
+              break;
+            }
+          }
+        }
+        if (scanToEnd === true) {
           continue;
         }
-        if (code === CHAR_LEFT_CURLY_BRACE) {
-          braces++;
+        break;
+      }
+      if (code === CHAR_FORWARD_SLASH) {
+        slashes.push(index);
+        tokens.push(token);
+        token = { value: "", depth: 0, isGlob: false };
+        if (finished === true) continue;
+        if (prev === CHAR_DOT && index === start + 1) {
+          start += 2;
           continue;
         }
-        if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
-          isBrace = token.isBrace = true;
+        lastIndex = index + 1;
+        continue;
+      }
+      if (opts.noext !== true) {
+        const isExtglobChar = code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK;
+        if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
           isGlob = token.isGlob = true;
+          isExtglob = token.isExtglob = true;
           finished = true;
+          if (code === CHAR_EXCLAMATION_MARK && index === start) {
+            negatedExtglob = true;
+          }
           if (scanToEnd === true) {
+            while (eos() !== true && (code = advance())) {
+              if (code === CHAR_BACKWARD_SLASH) {
+                backslashes = token.backslashes = true;
+                code = advance();
+                continue;
+              }
+              if (code === CHAR_RIGHT_PARENTHESES) {
+                isGlob = token.isGlob = true;
+                finished = true;
+                break;
+              }
+            }
             continue;
           }
           break;
         }
-        if (braceEscaped !== true && code === CHAR_COMMA) {
-          isBrace = token.isBrace = true;
-          isGlob = token.isGlob = true;
-          finished = true;
-          if (scanToEnd === true) {
+      }
+      if (code === CHAR_ASTERISK) {
+        if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
+        isGlob = token.isGlob = true;
+        finished = true;
+        if (scanToEnd === true) {
+          continue;
+        }
+        break;
+      }
+      if (code === CHAR_QUESTION_MARK) {
+        isGlob = token.isGlob = true;
+        finished = true;
+        if (scanToEnd === true) {
+          continue;
+        }
+        break;
+      }
+      if (code === CHAR_LEFT_SQUARE_BRACKET) {
+        while (eos() !== true && (next = advance())) {
+          if (next === CHAR_BACKWARD_SLASH) {
+            backslashes = token.backslashes = true;
+            advance();
             continue;
           }
-          break;
-        }
-        if (code === CHAR_RIGHT_CURLY_BRACE) {
-          braces--;
-          if (braces === 0) {
-            braceEscaped = false;
-            isBrace = token.isBrace = true;
+          if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+            isBracket = token.isBracket = true;
+            isGlob = token.isGlob = true;
             finished = true;
             break;
           }
         }
+        if (scanToEnd === true) {
+          continue;
+        }
+        break;
       }
-      if (scanToEnd === true) {
-        continue;
-      }
-      break;
-    }
-    if (code === CHAR_FORWARD_SLASH) {
-      slashes.push(index);
-      tokens.push(token);
-      token = { value: "", depth: 0, isGlob: false };
-      if (finished === true)
-        continue;
-      if (prev === CHAR_DOT && index === start + 1) {
-        start += 2;
+      if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
+        negated = token.negated = true;
+        start++;
         continue;
       }
-      lastIndex = index + 1;
-      continue;
-    }
-    if (opts.noext !== true) {
-      const isExtglobChar = code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK;
-      if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
+      if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
         isGlob = token.isGlob = true;
-        isExtglob = token.isExtglob = true;
-        finished = true;
-        if (code === CHAR_EXCLAMATION_MARK && index === start) {
-          negatedExtglob = true;
-        }
         if (scanToEnd === true) {
           while (eos() !== true && (code = advance())) {
-            if (code === CHAR_BACKWARD_SLASH) {
+            if (code === CHAR_LEFT_PARENTHESES) {
               backslashes = token.backslashes = true;
               code = advance();
               continue;
             }
             if (code === CHAR_RIGHT_PARENTHESES) {
-              isGlob = token.isGlob = true;
               finished = true;
               break;
             }
@@ -453,1087 +525,1038 @@ const scan$1 = (input, options) => {
         }
         break;
       }
-    }
-    if (code === CHAR_ASTERISK) {
-      if (prev === CHAR_ASTERISK)
-        isGlobstar = token.isGlobstar = true;
-      isGlob = token.isGlob = true;
-      finished = true;
-      if (scanToEnd === true) {
-        continue;
-      }
-      break;
-    }
-    if (code === CHAR_QUESTION_MARK) {
-      isGlob = token.isGlob = true;
-      finished = true;
-      if (scanToEnd === true) {
-        continue;
-      }
-      break;
-    }
-    if (code === CHAR_LEFT_SQUARE_BRACKET) {
-      while (eos() !== true && (next = advance())) {
-        if (next === CHAR_BACKWARD_SLASH) {
-          backslashes = token.backslashes = true;
-          advance();
+      if (isGlob === true) {
+        finished = true;
+        if (scanToEnd === true) {
           continue;
         }
-        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
-          isBracket = token.isBracket = true;
-          isGlob = token.isGlob = true;
-          finished = true;
-          break;
-        }
-      }
-      if (scanToEnd === true) {
-        continue;
+        break;
       }
-      break;
-    }
-    if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
-      negated = token.negated = true;
-      start++;
-      continue;
     }
-    if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
-      isGlob = token.isGlob = true;
-      if (scanToEnd === true) {
-        while (eos() !== true && (code = advance())) {
-          if (code === CHAR_LEFT_PARENTHESES) {
-            backslashes = token.backslashes = true;
-            code = advance();
-            continue;
-          }
-          if (code === CHAR_RIGHT_PARENTHESES) {
-            finished = true;
-            break;
+    if (opts.noext === true) {
+      isExtglob = false;
+      isGlob = false;
+    }
+    let base = str;
+    let prefix = "";
+    let glob = "";
+    if (start > 0) {
+      prefix = str.slice(0, start);
+      str = str.slice(start);
+      lastIndex -= start;
+    }
+    if (base && isGlob === true && lastIndex > 0) {
+      base = str.slice(0, lastIndex);
+      glob = str.slice(lastIndex);
+    } else if (isGlob === true) {
+      base = "";
+      glob = str;
+    } else {
+      base = str;
+    }
+    if (base && base !== "" && base !== "/" && base !== str) {
+      if (isPathSeparator(base.charCodeAt(base.length - 1))) {
+        base = base.slice(0, -1);
+      }
+    }
+    if (opts.unescape === true) {
+      if (glob) glob = utils2.removeBackslashes(glob);
+      if (base && backslashes === true) {
+        base = utils2.removeBackslashes(base);
+      }
+    }
+    const state = {
+      prefix,
+      input,
+      start,
+      base,
+      glob,
+      isBrace,
+      isBracket,
+      isGlob,
+      isExtglob,
+      isGlobstar,
+      negated,
+      negatedExtglob
+    };
+    if (opts.tokens === true) {
+      state.maxDepth = 0;
+      if (!isPathSeparator(code)) {
+        tokens.push(token);
+      }
+      state.tokens = tokens;
+    }
+    if (opts.parts === true || opts.tokens === true) {
+      let prevIndex;
+      for (let idx = 0; idx < slashes.length; idx++) {
+        const n = prevIndex ? prevIndex + 1 : start;
+        const i = slashes[idx];
+        const value = input.slice(n, i);
+        if (opts.tokens) {
+          if (idx === 0 && start !== 0) {
+            tokens[idx].isPrefix = true;
+            tokens[idx].value = prefix;
+          } else {
+            tokens[idx].value = value;
           }
+          depth(tokens[idx]);
+          state.maxDepth += tokens[idx].depth;
         }
-        continue;
-      }
-      break;
-    }
-    if (isGlob === true) {
-      finished = true;
-      if (scanToEnd === true) {
-        continue;
-      }
-      break;
-    }
-  }
-  if (opts.noext === true) {
-    isExtglob = false;
-    isGlob = false;
-  }
-  let base = str;
-  let prefix = "";
-  let glob = "";
-  if (start > 0) {
-    prefix = str.slice(0, start);
-    str = str.slice(start);
-    lastIndex -= start;
-  }
-  if (base && isGlob === true && lastIndex > 0) {
-    base = str.slice(0, lastIndex);
-    glob = str.slice(lastIndex);
-  } else if (isGlob === true) {
-    base = "";
-    glob = str;
-  } else {
-    base = str;
-  }
-  if (base && base !== "" && base !== "/" && base !== str) {
-    if (isPathSeparator(base.charCodeAt(base.length - 1))) {
-      base = base.slice(0, -1);
-    }
-  }
-  if (opts.unescape === true) {
-    if (glob)
-      glob = utils$3.removeBackslashes(glob);
-    if (base && backslashes === true) {
-      base = utils$3.removeBackslashes(base);
-    }
-  }
-  const state = {
-    prefix,
-    input,
-    start,
-    base,
-    glob,
-    isBrace,
-    isBracket,
-    isGlob,
-    isExtglob,
-    isGlobstar,
-    negated,
-    negatedExtglob
-  };
-  if (opts.tokens === true) {
-    state.maxDepth = 0;
-    if (!isPathSeparator(code)) {
-      tokens.push(token);
-    }
-    state.tokens = tokens;
-  }
-  if (opts.parts === true || opts.tokens === true) {
-    let prevIndex;
-    for (let idx = 0; idx < slashes.length; idx++) {
-      const n = prevIndex ? prevIndex + 1 : start;
-      const i = slashes[idx];
-      const value = input.slice(n, i);
-      if (opts.tokens) {
-        if (idx === 0 && start !== 0) {
-          tokens[idx].isPrefix = true;
-          tokens[idx].value = prefix;
-        } else {
-          tokens[idx].value = value;
+        if (idx !== 0 || value !== "") {
+          parts.push(value);
         }
-        depth(tokens[idx]);
-        state.maxDepth += tokens[idx].depth;
+        prevIndex = i;
       }
-      if (idx !== 0 || value !== "") {
+      if (prevIndex && prevIndex + 1 < input.length) {
+        const value = input.slice(prevIndex + 1);
         parts.push(value);
+        if (opts.tokens) {
+          tokens[tokens.length - 1].value = value;
+          depth(tokens[tokens.length - 1]);
+          state.maxDepth += tokens[tokens.length - 1].depth;
+        }
       }
-      prevIndex = i;
-    }
-    if (prevIndex && prevIndex + 1 < input.length) {
-      const value = input.slice(prevIndex + 1);
-      parts.push(value);
-      if (opts.tokens) {
-        tokens[tokens.length - 1].value = value;
-        depth(tokens[tokens.length - 1]);
-        state.maxDepth += tokens[tokens.length - 1].depth;
-      }
+      state.slashes = slashes;
+      state.parts = parts;
     }
-    state.slashes = slashes;
-    state.parts = parts;
-  }
-  return state;
-};
-var scan_1 = scan$1;
-const constants$1 = constants$2;
-const utils$2 = utils$4;
-const {
-  MAX_LENGTH,
-  POSIX_REGEX_SOURCE,
-  REGEX_NON_SPECIAL_CHARS,
-  REGEX_SPECIAL_CHARS_BACKREF,
-  REPLACEMENTS
-} = constants$1;
-const expandRange = (args, options) => {
-  if (typeof options.expandRange === "function") {
-    return options.expandRange(...args, options);
-  }
-  args.sort();
-  const value = `[${args.join("-")}]`;
-  try {
-    new RegExp(value);
-  } catch (ex) {
-    return args.map((v) => utils$2.escapeRegex(v)).join("..");
-  }
-  return value;
-};
-const syntaxError = (type, char) => {
-  return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
-};
-const parse$1 = (input, options) => {
-  if (typeof input !== "string") {
-    throw new TypeError("Expected a string");
-  }
-  input = REPLACEMENTS[input] || input;
-  const opts = { ...options };
-  const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
-  let len = input.length;
-  if (len > max) {
-    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
-  }
-  const bos = { type: "bos", value: "", output: opts.prepend || "" };
-  const tokens = [bos];
-  const capture = opts.capture ? "" : "?:";
-  const PLATFORM_CHARS = constants$1.globChars(opts.windows);
-  const EXTGLOB_CHARS = constants$1.extglobChars(PLATFORM_CHARS);
-  const {
-    DOT_LITERAL: DOT_LITERAL2,
-    PLUS_LITERAL: PLUS_LITERAL2,
-    SLASH_LITERAL: SLASH_LITERAL2,
-    ONE_CHAR: ONE_CHAR2,
-    DOTS_SLASH: DOTS_SLASH2,
-    NO_DOT: NO_DOT2,
-    NO_DOT_SLASH: NO_DOT_SLASH2,
-    NO_DOTS_SLASH: NO_DOTS_SLASH2,
-    QMARK: QMARK2,
-    QMARK_NO_DOT: QMARK_NO_DOT2,
-    STAR: STAR2,
-    START_ANCHOR: START_ANCHOR2
-  } = PLATFORM_CHARS;
-  const globstar = (opts2) => {
-    return `(${capture}(?:(?!${START_ANCHOR2}${opts2.dot ? DOTS_SLASH2 : DOT_LITERAL2}).)*?)`;
-  };
-  const nodot = opts.dot ? "" : NO_DOT2;
-  const qmarkNoDot = opts.dot ? QMARK2 : QMARK_NO_DOT2;
-  let star = opts.bash === true ? globstar(opts) : STAR2;
-  if (opts.capture) {
-    star = `(${star})`;
-  }
-  if (typeof opts.noext === "boolean") {
-    opts.noextglob = opts.noext;
-  }
-  const state = {
-    input,
-    index: -1,
-    start: 0,
-    dot: opts.dot === true,
-    consumed: "",
-    output: "",
-    prefix: "",
-    backtrack: false,
-    negated: false,
-    brackets: 0,
-    braces: 0,
-    parens: 0,
-    quotes: 0,
-    globstar: false,
-    tokens
-  };
-  input = utils$2.removePrefix(input, state);
-  len = input.length;
-  const extglobs = [];
-  const braces = [];
-  const stack = [];
-  let prev = bos;
-  let value;
-  const eos = () => state.index === len - 1;
-  const peek = state.peek = (n = 1) => input[state.index + n];
-  const advance = state.advance = () => input[++state.index] || "";
-  const remaining = () => input.slice(state.index + 1);
-  const consume = (value2 = "", num = 0) => {
-    state.consumed += value2;
-    state.index += num;
-  };
-  const append = (token) => {
-    state.output += token.output != null ? token.output : token.value;
-    consume(token.value);
-  };
-  const negate = () => {
-    let count = 1;
-    while (peek() === "!" && (peek(2) !== "(" || peek(3) === "?")) {
-      advance();
-      state.start++;
-      count++;
-    }
-    if (count % 2 === 0) {
-      return false;
-    }
-    state.negated = true;
-    state.start++;
-    return true;
-  };
-  const increment = (type) => {
-    state[type]++;
-    stack.push(type);
-  };
-  const decrement = (type) => {
-    state[type]--;
-    stack.pop();
+    return state;
   };
-  const push = (tok) => {
-    if (prev.type === "globstar") {
-      const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace");
-      const isExtglob = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
-      if (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;
-    }
-    if (tok.value || tok.output)
-      append(tok);
-    if (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;
+  scan_1 = scan;
+  return scan_1;
+}
+var parse_1;
+var hasRequiredParse;
+function requireParse() {
+  if (hasRequiredParse) return parse_1;
+  hasRequiredParse = 1;
+  const constants2 = /* @__PURE__ */ requireConstants();
+  const utils2 = /* @__PURE__ */ requireUtils();
+  const {
+    MAX_LENGTH,
+    POSIX_REGEX_SOURCE,
+    REGEX_NON_SPECIAL_CHARS,
+    REGEX_SPECIAL_CHARS_BACKREF,
+    REPLACEMENTS
+  } = constants2;
+  const expandRange = (args, options) => {
+    if (typeof options.expandRange === "function") {
+      return options.expandRange(...args, options);
+    }
+    args.sort();
+    const value = `[${args.join("-")}]`;
+    try {
+      new RegExp(value);
+    } catch (ex) {
+      return args.map((v) => utils2.escapeRegex(v)).join("..");
+    }
+    return value;
   };
-  const extglobOpen = (type, value2) => {
-    const token = { ...EXTGLOB_CHARS[value2], conditions: 1, inner: "" };
-    token.prev = prev;
-    token.parens = state.parens;
-    token.output = state.output;
-    const output = (opts.capture ? "(" : "") + token.open;
-    increment("parens");
-    push({ type, value: value2, output: state.output ? "" : ONE_CHAR2 });
-    push({ type: "paren", extglob: true, value: advance(), output });
-    extglobs.push(token);
+  const syntaxError = (type, char) => {
+    return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
   };
-  const extglobClose = (token) => {
-    let output = token.close + (opts.capture ? ")" : "");
-    let rest;
-    if (token.type === "negate") {
-      let extglobStar = star;
-      if (token.inner && token.inner.length > 1 && token.inner.includes("/")) {
-        extglobStar = globstar(opts);
-      }
-      if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
-        output = token.close = `)$))${extglobStar}`;
+  const parse = (input, options) => {
+    if (typeof input !== "string") {
+      throw new TypeError("Expected a string");
+    }
+    input = REPLACEMENTS[input] || input;
+    const opts = { ...options };
+    const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+    let len = input.length;
+    if (len > max) {
+      throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+    }
+    const bos = { type: "bos", value: "", output: opts.prepend || "" };
+    const tokens = [bos];
+    const capture = opts.capture ? "" : "?:";
+    const PLATFORM_CHARS = constants2.globChars(opts.windows);
+    const EXTGLOB_CHARS = constants2.extglobChars(PLATFORM_CHARS);
+    const {
+      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;
+    const globstar = (opts2) => {
+      return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+    };
+    const nodot = opts.dot ? "" : NO_DOT;
+    const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+    let star = opts.bash === true ? globstar(opts) : STAR;
+    if (opts.capture) {
+      star = `(${star})`;
+    }
+    if (typeof opts.noext === "boolean") {
+      opts.noextglob = opts.noext;
+    }
+    const state = {
+      input,
+      index: -1,
+      start: 0,
+      dot: opts.dot === true,
+      consumed: "",
+      output: "",
+      prefix: "",
+      backtrack: false,
+      negated: false,
+      brackets: 0,
+      braces: 0,
+      parens: 0,
+      quotes: 0,
+      globstar: false,
+      tokens
+    };
+    input = utils2.removePrefix(input, state);
+    len = input.length;
+    const extglobs = [];
+    const braces = [];
+    const stack = [];
+    let prev = bos;
+    let value;
+    const eos = () => state.index === len - 1;
+    const peek = state.peek = (n = 1) => input[state.index + n];
+    const advance = state.advance = () => input[++state.index] || "";
+    const remaining = () => input.slice(state.index + 1);
+    const consume = (value2 = "", num = 0) => {
+      state.consumed += value2;
+      state.index += num;
+    };
+    const append = (token) => {
+      state.output += token.output != null ? token.output : token.value;
+      consume(token.value);
+    };
+    const negate = () => {
+      let count = 1;
+      while (peek() === "!" && (peek(2) !== "(" || peek(3) === "?")) {
+        advance();
+        state.start++;
+        count++;
+      }
+      if (count % 2 === 0) {
+        return false;
       }
-      if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
-        const expression = parse$1(rest, { ...options, fastpaths: false }).output;
-        output = token.close = `)${expression})${extglobStar})`;
+      state.negated = true;
+      state.start++;
+      return true;
+    };
+    const increment = (type) => {
+      state[type]++;
+      stack.push(type);
+    };
+    const decrement = (type) => {
+      state[type]--;
+      stack.pop();
+    };
+    const push = (tok) => {
+      if (prev.type === "globstar") {
+        const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace");
+        const isExtglob = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
+        if (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 (token.prev.type === "bos") {
-        state.negatedExtglob = true;
+      if (extglobs.length && tok.type !== "paren") {
+        extglobs[extglobs.length - 1].inner += tok.value;
       }
-    }
-    push({ type: "paren", extglob: true, value, output });
-    decrement("parens");
-  };
-  if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
-    let backslashes = false;
-    let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
-      if (first === "\\") {
-        backslashes = true;
-        return m;
+      if (tok.value || tok.output) append(tok);
+      if (prev && prev.type === "text" && tok.type === "text") {
+        prev.output = (prev.output || prev.value) + tok.value;
+        prev.value += tok.value;
+        return;
       }
-      if (first === "?") {
-        if (esc) {
-          return esc + first + (rest ? QMARK2.repeat(rest.length) : "");
+      tok.prev = prev;
+      tokens.push(tok);
+      prev = tok;
+    };
+    const extglobOpen = (type, value2) => {
+      const token = { ...EXTGLOB_CHARS[value2], conditions: 1, inner: "" };
+      token.prev = prev;
+      token.parens = state.parens;
+      token.output = state.output;
+      const output = (opts.capture ? "(" : "") + token.open;
+      increment("parens");
+      push({ type, value: value2, output: state.output ? "" : ONE_CHAR });
+      push({ type: "paren", extglob: true, value: advance(), output });
+      extglobs.push(token);
+    };
+    const extglobClose = (token) => {
+      let output = token.close + (opts.capture ? ")" : "");
+      let rest;
+      if (token.type === "negate") {
+        let extglobStar = star;
+        if (token.inner && token.inner.length > 1 && token.inner.includes("/")) {
+          extglobStar = globstar(opts);
         }
-        if (index === 0) {
-          return qmarkNoDot + (rest ? QMARK2.repeat(rest.length) : "");
+        if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
+          output = token.close = `)$))${extglobStar}`;
+        }
+        if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+          const expression = parse(rest, { ...options, fastpaths: false }).output;
+          output = token.close = `)${expression})${extglobStar})`;
+        }
+        if (token.prev.type === "bos") {
+          state.negatedExtglob = true;
         }
-        return QMARK2.repeat(chars.length);
-      }
-      if (first === ".") {
-        return DOT_LITERAL2.repeat(chars.length);
       }
-      if (first === "*") {
-        if (esc) {
-          return esc + first + (rest ? star : "");
+      push({ type: "paren", extglob: true, value, output });
+      decrement("parens");
+    };
+    if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+      let backslashes = false;
+      let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+        if (first === "\\") {
+          backslashes = true;
+          return m;
+        }
+        if (first === "?") {
+          if (esc) {
+            return esc + first + (rest ? QMARK.repeat(rest.length) : "");
+          }
+          if (index === 0) {
+            return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : "");
+          }
+          return QMARK.repeat(chars.length);
+        }
+        if (first === ".") {
+          return DOT_LITERAL.repeat(chars.length);
+        }
+        if (first === "*") {
+          if (esc) {
+            return esc + first + (rest ? star : "");
+          }
+          return star;
+        }
+        return esc ? m : `\\${m}`;
+      });
+      if (backslashes === true) {
+        if (opts.unescape === true) {
+          output = output.replace(/\\/g, "");
+        } else {
+          output = output.replace(/\\+/g, (m) => {
+            return m.length % 2 === 0 ? "\\\\" : m ? "\\" : "";
+          });
         }
-        return star;
       }
-      return esc ? m : `\\${m}`;
-    });
-    if (backslashes === true) {
-      if (opts.unescape === true) {
-        output = output.replace(/\\/g, "");
-      } else {
-        output = output.replace(/\\+/g, (m) => {
-          return m.length % 2 === 0 ? "\\\\" : m ? "\\" : "";
-        });
+      if (output === input && opts.contains === true) {
+        state.output = input;
+        return state;
       }
-    }
-    if (output === input && opts.contains === true) {
-      state.output = input;
+      state.output = utils2.wrapOutput(output, state, options);
       return state;
     }
-    state.output = utils$2.wrapOutput(output, state, options);
-    return state;
-  }
-  while (!eos()) {
-    value = advance();
-    if (value === "\0") {
-      continue;
-    }
-    if (value === "\\") {
-      const next = peek();
-      if (next === "/" && opts.bash !== true) {
-        continue;
-      }
-      if (next === "." || next === ";") {
-        continue;
-      }
-      if (!next) {
-        value += "\\";
-        push({ type: "text", value });
+    while (!eos()) {
+      value = advance();
+      if (value === "\0") {
         continue;
       }
-      const match = /^\\+/.exec(remaining());
-      let slashes = 0;
-      if (match && match[0].length > 2) {
-        slashes = match[0].length;
-        state.index += slashes;
-        if (slashes % 2 !== 0) {
+      if (value === "\\") {
+        const next = peek();
+        if (next === "/" && opts.bash !== true) {
+          continue;
+        }
+        if (next === "." || next === ";") {
+          continue;
+        }
+        if (!next) {
           value += "\\";
+          push({ type: "text", value });
+          continue;
+        }
+        const match = /^\\+/.exec(remaining());
+        let slashes = 0;
+        if (match && match[0].length > 2) {
+          slashes = match[0].length;
+          state.index += slashes;
+          if (slashes % 2 !== 0) {
+            value += "\\";
+          }
+        }
+        if (opts.unescape === true) {
+          value = advance();
+        } else {
+          value += advance();
+        }
+        if (state.brackets === 0) {
+          push({ type: "text", value });
+          continue;
         }
       }
-      if (opts.unescape === true) {
-        value = advance();
-      } else {
-        value += advance();
-      }
-      if (state.brackets === 0) {
-        push({ type: "text", value });
-        continue;
-      }
-    }
-    if (state.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) {
-      if (opts.posix !== false && value === ":") {
-        const inner = prev.value.slice(1);
-        if (inner.includes("[")) {
-          prev.posix = true;
-          if (inner.includes(":")) {
-            const idx = prev.value.lastIndexOf("[");
-            const pre = prev.value.slice(0, idx);
-            const rest2 = prev.value.slice(idx + 2);
-            const posix = POSIX_REGEX_SOURCE[rest2];
-            if (posix) {
-              prev.value = pre + posix;
-              state.backtrack = true;
-              advance();
-              if (!bos.output && tokens.indexOf(prev) === 1) {
-                bos.output = ONE_CHAR2;
+      if (state.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) {
+        if (opts.posix !== false && value === ":") {
+          const inner = prev.value.slice(1);
+          if (inner.includes("[")) {
+            prev.posix = true;
+            if (inner.includes(":")) {
+              const idx = prev.value.lastIndexOf("[");
+              const pre = prev.value.slice(0, idx);
+              const rest2 = prev.value.slice(idx + 2);
+              const posix = POSIX_REGEX_SOURCE[rest2];
+              if (posix) {
+                prev.value = pre + posix;
+                state.backtrack = true;
+                advance();
+                if (!bos.output && tokens.indexOf(prev) === 1) {
+                  bos.output = ONE_CHAR;
+                }
+                continue;
               }
-              continue;
             }
           }
         }
-      }
-      if (value === "[" && peek() !== ":" || value === "-" && peek() === "]") {
-        value = `\\${value}`;
-      }
-      if (value === "]" && (prev.value === "[" || prev.value === "[^")) {
-        value = `\\${value}`;
-      }
-      if (opts.posix === true && value === "!" && prev.value === "[") {
-        value = "^";
-      }
-      prev.value += value;
-      append({ value });
-      continue;
-    }
-    if (state.quotes === 1 && value !== '"') {
-      value = utils$2.escapeRegex(value);
-      prev.value += value;
-      append({ value });
-      continue;
-    }
-    if (value === '"') {
-      state.quotes = state.quotes === 1 ? 0 : 1;
-      if (opts.keepQuotes === true) {
-        push({ type: "text", value });
-      }
-      continue;
-    }
-    if (value === "(") {
-      increment("parens");
-      push({ type: "paren", value });
-      continue;
-    }
-    if (value === ")") {
-      if (state.parens === 0 && opts.strictBrackets === true) {
-        throw new SyntaxError(syntaxError("opening", "("));
-      }
-      const 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 === true || !remaining().includes("]")) {
-        if (opts.nobracket !== true && opts.strictBrackets === true) {
-          throw new SyntaxError(syntaxError("closing", "]"));
+        if (value === "[" && peek() !== ":" || value === "-" && peek() === "]") {
+          value = `\\${value}`;
         }
-        value = `\\${value}`;
-      } else {
-        increment("brackets");
+        if (value === "]" && (prev.value === "[" || prev.value === "[^")) {
+          value = `\\${value}`;
+        }
+        if (opts.posix === true && value === "!" && prev.value === "[") {
+          value = "^";
+        }
+        prev.value += value;
+        append({ value });
+        continue;
       }
-      push({ type: "bracket", value });
-      continue;
-    }
-    if (value === "]") {
-      if (opts.nobracket === true || prev && prev.type === "bracket" && prev.value.length === 1) {
-        push({ type: "text", value, output: `\\${value}` });
+      if (state.quotes === 1 && value !== '"') {
+        value = utils2.escapeRegex(value);
+        prev.value += value;
+        append({ value });
         continue;
       }
-      if (state.brackets === 0) {
-        if (opts.strictBrackets === true) {
-          throw new SyntaxError(syntaxError("opening", "["));
+      if (value === '"') {
+        state.quotes = state.quotes === 1 ? 0 : 1;
+        if (opts.keepQuotes === true) {
+          push({ type: "text", value });
         }
-        push({ type: "text", value, output: `\\${value}` });
         continue;
       }
-      decrement("brackets");
-      const prevValue = prev.value.slice(1);
-      if (prev.posix !== true && prevValue[0] === "^" && !prevValue.includes("/")) {
-        value = `/${value}`;
-      }
-      prev.value += value;
-      append({ value });
-      if (opts.literalBrackets === false || utils$2.hasRegexChars(prevValue)) {
+      if (value === "(") {
+        increment("parens");
+        push({ type: "paren", value });
         continue;
       }
-      const escaped = utils$2.escapeRegex(prev.value);
-      state.output = state.output.slice(0, -prev.value.length);
-      if (opts.literalBrackets === true) {
-        state.output += escaped;
-        prev.value = escaped;
+      if (value === ")") {
+        if (state.parens === 0 && opts.strictBrackets === true) {
+          throw new SyntaxError(syntaxError("opening", "("));
+        }
+        const 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;
       }
-      prev.value = `(${capture}${escaped}|${prev.value})`;
-      state.output += prev.value;
-      continue;
-    }
-    if (value === "{" && opts.nobrace !== true) {
-      increment("braces");
-      const open = {
-        type: "brace",
-        value,
-        output: "(",
-        outputIndex: state.output.length,
-        tokensIndex: state.tokens.length
-      };
-      braces.push(open);
-      push(open);
-      continue;
-    }
-    if (value === "}") {
-      const brace = braces[braces.length - 1];
-      if (opts.nobrace === true || !brace) {
-        push({ type: "text", value, output: value });
+      if (value === "[") {
+        if (opts.nobracket === true || !remaining().includes("]")) {
+          if (opts.nobracket !== true && opts.strictBrackets === true) {
+            throw new SyntaxError(syntaxError("closing", "]"));
+          }
+          value = `\\${value}`;
+        } else {
+          increment("brackets");
+        }
+        push({ type: "bracket", value });
         continue;
       }
-      let output = ")";
-      if (brace.dots === true) {
-        const arr = tokens.slice();
-        const range = [];
-        for (let i = arr.length - 1; i >= 0; i--) {
-          tokens.pop();
-          if (arr[i].type === "brace") {
-            break;
-          }
-          if (arr[i].type !== "dots") {
-            range.unshift(arr[i].value);
+      if (value === "]") {
+        if (opts.nobracket === true || prev && prev.type === "bracket" && prev.value.length === 1) {
+          push({ type: "text", value, output: `\\${value}` });
+          continue;
+        }
+        if (state.brackets === 0) {
+          if (opts.strictBrackets === true) {
+            throw new SyntaxError(syntaxError("opening", "["));
           }
+          push({ type: "text", value, output: `\\${value}` });
+          continue;
         }
-        output = expandRange(range, opts);
-        state.backtrack = true;
-      }
-      if (brace.comma !== true && brace.dots !== true) {
-        const out = state.output.slice(0, brace.outputIndex);
-        const toks = state.tokens.slice(brace.tokensIndex);
-        brace.value = brace.output = "\\{";
-        value = output = "\\}";
-        state.output = out;
-        for (const t of toks) {
-          state.output += t.output || t.value;
+        decrement("brackets");
+        const prevValue = prev.value.slice(1);
+        if (prev.posix !== true && prevValue[0] === "^" && !prevValue.includes("/")) {
+          value = `/${value}`;
         }
-      }
-      push({ type: "brace", value, output });
-      decrement("braces");
-      braces.pop();
-      continue;
-    }
-    if (value === "|") {
-      if (extglobs.length > 0) {
-        extglobs[extglobs.length - 1].conditions++;
-      }
-      push({ type: "text", value });
-      continue;
-    }
-    if (value === ",") {
-      let output = value;
-      const brace = braces[braces.length - 1];
-      if (brace && stack[stack.length - 1] === "braces") {
-        brace.comma = true;
-        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;
+        prev.value += value;
+        append({ value });
+        if (opts.literalBrackets === false || utils2.hasRegexChars(prevValue)) {
+          continue;
+        }
+        const escaped = utils2.escapeRegex(prev.value);
+        state.output = state.output.slice(0, -prev.value.length);
+        if (opts.literalBrackets === true) {
+          state.output += escaped;
+          prev.value = escaped;
+          continue;
+        }
+        prev.value = `(${capture}${escaped}|${prev.value})`;
+        state.output += prev.value;
         continue;
       }
-      push({ type: "slash", value, output: SLASH_LITERAL2 });
-      continue;
-    }
-    if (value === ".") {
-      if (state.braces > 0 && prev.type === "dot") {
-        if (prev.value === ".")
-          prev.output = DOT_LITERAL2;
-        const brace = braces[braces.length - 1];
-        prev.type = "dots";
-        prev.output += value;
-        prev.value += value;
-        brace.dots = true;
+      if (value === "{" && opts.nobrace !== true) {
+        increment("braces");
+        const open = {
+          type: "brace",
+          value,
+          output: "(",
+          outputIndex: state.output.length,
+          tokensIndex: state.tokens.length
+        };
+        braces.push(open);
+        push(open);
         continue;
       }
-      if (state.braces + state.parens === 0 && prev.type !== "bos" && prev.type !== "slash") {
-        push({ type: "text", value, output: DOT_LITERAL2 });
+      if (value === "}") {
+        const brace = braces[braces.length - 1];
+        if (opts.nobrace === true || !brace) {
+          push({ type: "text", value, output: value });
+          continue;
+        }
+        let output = ")";
+        if (brace.dots === true) {
+          const arr = tokens.slice();
+          const range = [];
+          for (let i = arr.length - 1; i >= 0; i--) {
+            tokens.pop();
+            if (arr[i].type === "brace") {
+              break;
+            }
+            if (arr[i].type !== "dots") {
+              range.unshift(arr[i].value);
+            }
+          }
+          output = expandRange(range, opts);
+          state.backtrack = true;
+        }
+        if (brace.comma !== true && brace.dots !== true) {
+          const out = state.output.slice(0, brace.outputIndex);
+          const toks = state.tokens.slice(brace.tokensIndex);
+          brace.value = brace.output = "\\{";
+          value = output = "\\}";
+          state.output = out;
+          for (const t of toks) {
+            state.output += t.output || t.value;
+          }
+        }
+        push({ type: "brace", value, output });
+        decrement("braces");
+        braces.pop();
         continue;
       }
-      push({ type: "dot", value, output: DOT_LITERAL2 });
-      continue;
-    }
-    if (value === "?") {
-      const isGroup = prev && prev.value === "(";
-      if (!isGroup && opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
-        extglobOpen("qmark", value);
+      if (value === "|") {
+        if (extglobs.length > 0) {
+          extglobs[extglobs.length - 1].conditions++;
+        }
+        push({ type: "text", value });
         continue;
       }
-      if (prev && prev.type === "paren") {
-        const next = peek();
+      if (value === ",") {
         let output = value;
-        if (prev.value === "(" && !/[!=<:]/.test(next) || next === "<" && !/<([!=]|\w+>)/.test(remaining())) {
-          output = `\\${value}`;
+        const brace = braces[braces.length - 1];
+        if (brace && stack[stack.length - 1] === "braces") {
+          brace.comma = true;
+          output = "|";
         }
-        push({ type: "text", value, output });
+        push({ type: "comma", value, output });
         continue;
       }
-      if (opts.dot !== true && (prev.type === "slash" || prev.type === "bos")) {
-        push({ type: "qmark", value, output: QMARK_NO_DOT2 });
+      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;
       }
-      push({ type: "qmark", value, output: QMARK2 });
-      continue;
-    }
-    if (value === "!") {
-      if (opts.noextglob !== true && peek() === "(") {
-        if (peek(2) !== "?" || !/[!=<:]/.test(peek(3))) {
-          extglobOpen("negate", value);
+      if (value === ".") {
+        if (state.braces > 0 && prev.type === "dot") {
+          if (prev.value === ".") prev.output = DOT_LITERAL;
+          const brace = braces[braces.length - 1];
+          prev.type = "dots";
+          prev.output += value;
+          prev.value += value;
+          brace.dots = true;
           continue;
         }
-      }
-      if (opts.nonegate !== true && state.index === 0) {
-        negate();
+        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 (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
-        extglobOpen("plus", value);
+      if (value === "?") {
+        const isGroup = prev && prev.value === "(";
+        if (!isGroup && opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+          extglobOpen("qmark", value);
+          continue;
+        }
+        if (prev && prev.type === "paren") {
+          const next = peek();
+          let output = value;
+          if (prev.value === "(" && !/[!=<:]/.test(next) || next === "<" && !/<([!=]|\w+>)/.test(remaining())) {
+            output = `\\${value}`;
+          }
+          push({ type: "text", value, output });
+          continue;
+        }
+        if (opts.dot !== true && (prev.type === "slash" || prev.type === "bos")) {
+          push({ type: "qmark", value, output: QMARK_NO_DOT });
+          continue;
+        }
+        push({ type: "qmark", value, output: QMARK });
         continue;
       }
-      if (prev && prev.value === "(" || opts.regex === false) {
-        push({ type: "plus", value, output: PLUS_LITERAL2 });
-        continue;
+      if (value === "!") {
+        if (opts.noextglob !== true && peek() === "(") {
+          if (peek(2) !== "?" || !/[!=<:]/.test(peek(3))) {
+            extglobOpen("negate", value);
+            continue;
+          }
+        }
+        if (opts.nonegate !== true && state.index === 0) {
+          negate();
+          continue;
+        }
       }
-      if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state.parens > 0) {
-        push({ type: "plus", value });
+      if (value === "+") {
+        if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+          extglobOpen("plus", value);
+          continue;
+        }
+        if (prev && prev.value === "(" || opts.regex === false) {
+          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;
       }
-      push({ type: "plus", value: PLUS_LITERAL2 });
-      continue;
-    }
-    if (value === "@") {
-      if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
-        push({ type: "at", extglob: true, value, output: "" });
+      if (value === "@") {
+        if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+          push({ type: "at", extglob: true, value, output: "" });
+          continue;
+        }
+        push({ type: "text", value });
         continue;
       }
-      push({ type: "text", value });
-      continue;
-    }
-    if (value !== "*") {
-      if (value === "$" || value === "^") {
-        value = `\\${value}`;
-      }
-      const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
-      if (match) {
-        value += match[0];
-        state.index += match[0].length;
-      }
-      push({ type: "text", value });
-      continue;
-    }
-    if (prev && (prev.type === "globstar" || prev.star === true)) {
-      prev.type = "star";
-      prev.star = true;
-      prev.value += value;
-      prev.output = star;
-      state.backtrack = true;
-      state.globstar = true;
-      consume(value);
-      continue;
-    }
-    let rest = remaining();
-    if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
-      extglobOpen("star", value);
-      continue;
-    }
-    if (prev.type === "star") {
-      if (opts.noglobstar === true) {
-        consume(value);
+      if (value !== "*") {
+        if (value === "$" || value === "^") {
+          value = `\\${value}`;
+        }
+        const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+        if (match) {
+          value += match[0];
+          state.index += match[0].length;
+        }
+        push({ type: "text", value });
         continue;
       }
-      const prior = prev.prev;
-      const before = prior.prev;
-      const isStart = prior.type === "slash" || prior.type === "bos";
-      const afterStar = before && (before.type === "star" || before.type === "globstar");
-      if (opts.bash === true && (!isStart || rest[0] && rest[0] !== "/")) {
-        push({ type: "star", value, output: "" });
+      if (prev && (prev.type === "globstar" || prev.star === true)) {
+        prev.type = "star";
+        prev.star = true;
+        prev.value += value;
+        prev.output = star;
+        state.backtrack = true;
+        state.globstar = true;
+        consume(value);
         continue;
       }
-      const isBrace = state.braces > 0 && (prior.type === "comma" || prior.type === "brace");
-      const isExtglob = extglobs.length && (prior.type === "pipe" || prior.type === "paren");
-      if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) {
-        push({ type: "star", value, output: "" });
+      let rest = remaining();
+      if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
+        extglobOpen("star", value);
         continue;
       }
-      while (rest.slice(0, 3) === "/**") {
-        const after = input[state.index + 4];
-        if (after && after !== "/") {
-          break;
+      if (prev.type === "star") {
+        if (opts.noglobstar === true) {
+          consume(value);
+          continue;
         }
-        rest = rest.slice(3);
-        consume("/**", 3);
-      }
-      if (prior.type === "bos" && eos()) {
+        const prior = prev.prev;
+        const before = prior.prev;
+        const isStart = prior.type === "slash" || prior.type === "bos";
+        const afterStar = before && (before.type === "star" || before.type === "globstar");
+        if (opts.bash === true && (!isStart || rest[0] && rest[0] !== "/")) {
+          push({ type: "star", value, output: "" });
+          continue;
+        }
+        const isBrace = state.braces > 0 && (prior.type === "comma" || prior.type === "brace");
+        const isExtglob = extglobs.length && (prior.type === "pipe" || prior.type === "paren");
+        if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) {
+          push({ type: "star", value, output: "" });
+          continue;
+        }
+        while (rest.slice(0, 3) === "/**") {
+          const after = input[state.index + 4];
+          if (after && after !== "/") {
+            break;
+          }
+          rest = rest.slice(3);
+          consume("/**", 3);
+        }
+        if (prior.type === "bos" && eos()) {
+          prev.type = "globstar";
+          prev.value += value;
+          prev.output = globstar(opts);
+          state.output = prev.output;
+          state.globstar = true;
+          consume(value);
+          continue;
+        }
+        if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && eos()) {
+          state.output = state.output.slice(0, -(prior.output + prev.output).length);
+          prior.output = `(?:${prior.output}`;
+          prev.type = "globstar";
+          prev.output = globstar(opts) + (opts.strictSlashes ? ")" : "|$)");
+          prev.value += value;
+          state.globstar = true;
+          state.output += prior.output + prev.output;
+          consume(value);
+          continue;
+        }
+        if (prior.type === "slash" && prior.prev.type !== "bos" && rest[0] === "/") {
+          const 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 = true;
+          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 = true;
+          consume(value + advance());
+          push({ type: "slash", value: "/", output: "" });
+          continue;
+        }
+        state.output = state.output.slice(0, -prev.output.length);
         prev.type = "globstar";
-        prev.value += value;
         prev.output = globstar(opts);
-        state.output = prev.output;
-        state.globstar = true;
-        consume(value);
-        continue;
-      }
-      if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && eos()) {
-        state.output = state.output.slice(0, -(prior.output + prev.output).length);
-        prior.output = `(?:${prior.output}`;
-        prev.type = "globstar";
-        prev.output = globstar(opts) + (opts.strictSlashes ? ")" : "|$)");
         prev.value += value;
+        state.output += prev.output;
         state.globstar = true;
-        state.output += prior.output + prev.output;
         consume(value);
         continue;
       }
-      if (prior.type === "slash" && prior.prev.type !== "bos" && rest[0] === "/") {
-        const 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_LITERAL2}|${SLASH_LITERAL2}${end})`;
-        prev.value += value;
-        state.output += prior.output + prev.output;
-        state.globstar = true;
-        consume(value + advance());
-        push({ type: "slash", value: "/", output: "" });
+      const token = { type: "star", value, output: star };
+      if (opts.bash === true) {
+        token.output = ".*?";
+        if (prev.type === "bos" || prev.type === "slash") {
+          token.output = nodot + token.output;
+        }
+        push(token);
         continue;
       }
-      if (prior.type === "bos" && rest[0] === "/") {
-        prev.type = "globstar";
-        prev.value += value;
-        prev.output = `(?:^|${SLASH_LITERAL2}|${globstar(opts)}${SLASH_LITERAL2})`;
-        state.output = prev.output;
-        state.globstar = true;
-        consume(value + advance());
-        push({ type: "slash", value: "/", output: "" });
+      if (prev && (prev.type === "bracket" || prev.type === "paren") && opts.regex === true) {
+        token.output = value;
+        push(token);
         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 = true;
-      consume(value);
-      continue;
-    }
-    const token = { type: "star", value, output: star };
-    if (opts.bash === true) {
-      token.output = ".*?";
-      if (prev.type === "bos" || prev.type === "slash") {
-        token.output = nodot + token.output;
+      if (state.index === state.start || prev.type === "slash" || prev.type === "dot") {
+        if (prev.type === "dot") {
+          state.output += NO_DOT_SLASH;
+          prev.output += NO_DOT_SLASH;
+        } else if (opts.dot === true) {
+          state.output += NO_DOTS_SLASH;
+          prev.output += NO_DOTS_SLASH;
+        } else {
+          state.output += nodot;
+          prev.output += nodot;
+        }
+        if (peek() !== "*") {
+          state.output += ONE_CHAR;
+          prev.output += ONE_CHAR;
+        }
       }
       push(token);
-      continue;
     }
-    if (prev && (prev.type === "bracket" || prev.type === "paren") && opts.regex === true) {
-      token.output = value;
-      push(token);
-      continue;
+    while (state.brackets > 0) {
+      if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
+      state.output = utils2.escapeLast(state.output, "[");
+      decrement("brackets");
     }
-    if (state.index === state.start || prev.type === "slash" || prev.type === "dot") {
-      if (prev.type === "dot") {
-        state.output += NO_DOT_SLASH2;
-        prev.output += NO_DOT_SLASH2;
-      } else if (opts.dot === true) {
-        state.output += NO_DOTS_SLASH2;
-        prev.output += NO_DOTS_SLASH2;
-      } else {
-        state.output += nodot;
-        prev.output += nodot;
-      }
-      if (peek() !== "*") {
-        state.output += ONE_CHAR2;
-        prev.output += ONE_CHAR2;
-      }
+    while (state.parens > 0) {
+      if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", ")"));
+      state.output = utils2.escapeLast(state.output, "(");
+      decrement("parens");
     }
-    push(token);
-  }
-  while (state.brackets > 0) {
-    if (opts.strictBrackets === true)
-      throw new SyntaxError(syntaxError("closing", "]"));
-    state.output = utils$2.escapeLast(state.output, "[");
-    decrement("brackets");
-  }
-  while (state.parens > 0) {
-    if (opts.strictBrackets === true)
-      throw new SyntaxError(syntaxError("closing", ")"));
-    state.output = utils$2.escapeLast(state.output, "(");
-    decrement("parens");
-  }
-  while (state.braces > 0) {
-    if (opts.strictBrackets === true)
-      throw new SyntaxError(syntaxError("closing", "}"));
-    state.output = utils$2.escapeLast(state.output, "{");
-    decrement("braces");
-  }
-  if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) {
-    push({ type: "maybe_slash", value: "", output: `${SLASH_LITERAL2}?` });
-  }
-  if (state.backtrack === true) {
-    state.output = "";
-    for (const token of state.tokens) {
-      state.output += token.output != null ? token.output : token.value;
-      if (token.suffix) {
-        state.output += token.suffix;
+    while (state.braces > 0) {
+      if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "}"));
+      state.output = utils2.escapeLast(state.output, "{");
+      decrement("braces");
+    }
+    if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) {
+      push({ type: "maybe_slash", value: "", output: `${SLASH_LITERAL}?` });
+    }
+    if (state.backtrack === true) {
+      state.output = "";
+      for (const token of state.tokens) {
+        state.output += token.output != null ? token.output : token.value;
+        if (token.suffix) {
+          state.output += token.suffix;
+        }
       }
     }
-  }
-  return state;
-};
-parse$1.fastpaths = (input, options) => {
-  const opts = { ...options };
-  const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
-  const len = input.length;
-  if (len > max) {
-    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
-  }
-  input = REPLACEMENTS[input] || input;
-  const {
-    DOT_LITERAL: DOT_LITERAL2,
-    SLASH_LITERAL: SLASH_LITERAL2,
-    ONE_CHAR: ONE_CHAR2,
-    DOTS_SLASH: DOTS_SLASH2,
-    NO_DOT: NO_DOT2,
-    NO_DOTS: NO_DOTS2,
-    NO_DOTS_SLASH: NO_DOTS_SLASH2,
-    STAR: STAR2,
-    START_ANCHOR: START_ANCHOR2
-  } = constants$1.globChars(opts.windows);
-  const nodot = opts.dot ? NO_DOTS2 : NO_DOT2;
-  const slashDot = opts.dot ? NO_DOTS_SLASH2 : NO_DOT2;
-  const capture = opts.capture ? "" : "?:";
-  const state = { negated: false, prefix: "" };
-  let star = opts.bash === true ? ".*?" : STAR2;
-  if (opts.capture) {
-    star = `(${star})`;
-  }
-  const globstar = (opts2) => {
-    if (opts2.noglobstar === true)
-      return star;
-    return `(${capture}(?:(?!${START_ANCHOR2}${opts2.dot ? DOTS_SLASH2 : DOT_LITERAL2}).)*?)`;
+    return state;
   };
-  const create = (str) => {
-    switch (str) {
-      case "*":
-        return `${nodot}${ONE_CHAR2}${star}`;
-      case ".*":
-        return `${DOT_LITERAL2}${ONE_CHAR2}${star}`;
-      case "*.*":
-        return `${nodot}${star}${DOT_LITERAL2}${ONE_CHAR2}${star}`;
-      case "*/*":
-        return `${nodot}${star}${SLASH_LITERAL2}${ONE_CHAR2}${slashDot}${star}`;
-      case "**":
-        return nodot + globstar(opts);
-      case "**/*":
-        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL2})?${slashDot}${ONE_CHAR2}${star}`;
-      case "**/*.*":
-        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL2})?${slashDot}${star}${DOT_LITERAL2}${ONE_CHAR2}${star}`;
-      case "**/.*":
-        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL2})?${DOT_LITERAL2}${ONE_CHAR2}${star}`;
-      default: {
-        const match = /^(.*?)\.(\w+)$/.exec(str);
-        if (!match)
-          return;
-        const source2 = create(match[1]);
-        if (!source2)
-          return;
-        return source2 + DOT_LITERAL2 + match[2];
+  parse.fastpaths = (input, options) => {
+    const opts = { ...options };
+    const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+    const len = input.length;
+    if (len > max) {
+      throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+    }
+    input = REPLACEMENTS[input] || input;
+    const {
+      DOT_LITERAL,
+      SLASH_LITERAL,
+      ONE_CHAR,
+      DOTS_SLASH,
+      NO_DOT,
+      NO_DOTS,
+      NO_DOTS_SLASH,
+      STAR,
+      START_ANCHOR
+    } = constants2.globChars(opts.windows);
+    const nodot = opts.dot ? NO_DOTS : NO_DOT;
+    const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+    const capture = opts.capture ? "" : "?:";
+    const state = { negated: false, prefix: "" };
+    let star = opts.bash === true ? ".*?" : STAR;
+    if (opts.capture) {
+      star = `(${star})`;
+    }
+    const globstar = (opts2) => {
+      if (opts2.noglobstar === true) return star;
+      return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+    };
+    const 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: {
+          const match = /^(.*?)\.(\w+)$/.exec(str);
+          if (!match) return;
+          const source2 = create(match[1]);
+          if (!source2) return;
+          return source2 + DOT_LITERAL + match[2];
+        }
       }
+    };
+    const output = utils2.removePrefix(input, state);
+    let source = create(output);
+    if (source && opts.strictSlashes !== true) {
+      source += `${SLASH_LITERAL}?`;
     }
+    return source;
   };
-  const output = utils$2.removePrefix(input, state);
-  let source = create(output);
-  if (source && opts.strictSlashes !== true) {
-    source += `${SLASH_LITERAL2}?`;
-  }
-  return source;
-};
-var parse_1 = parse$1;
-const scan = scan_1;
-const parse = parse_1;
-const utils$1 = utils$4;
-const constants = constants$2;
-const isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
-const picomatch$2 = (glob, options, returnState = false) => {
-  if (Array.isArray(glob)) {
-    const fns = glob.map((input) => picomatch$2(input, options, returnState));
-    const arrayMatcher = (str) => {
-      for (const isMatch of fns) {
-        const state2 = isMatch(str);
-        if (state2)
-          return state2;
+  parse_1 = parse;
+  return parse_1;
+}
+var picomatch_1$1;
+var hasRequiredPicomatch$1;
+function requirePicomatch$1() {
+  if (hasRequiredPicomatch$1) return picomatch_1$1;
+  hasRequiredPicomatch$1 = 1;
+  const scan = /* @__PURE__ */ requireScan();
+  const parse = /* @__PURE__ */ requireParse();
+  const utils2 = /* @__PURE__ */ requireUtils();
+  const constants2 = /* @__PURE__ */ requireConstants();
+  const isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
+  const picomatch2 = (glob, options, returnState = false) => {
+    if (Array.isArray(glob)) {
+      const fns = glob.map((input) => picomatch2(input, options, returnState));
+      const arrayMatcher = (str) => {
+        for (const isMatch of fns) {
+          const state2 = isMatch(str);
+          if (state2) return state2;
+        }
+        return false;
+      };
+      return arrayMatcher;
+    }
+    const isState = isObject(glob) && glob.tokens && glob.input;
+    if (glob === "" || typeof glob !== "string" && !isState) {
+      throw new TypeError("Expected pattern to be a non-empty string");
+    }
+    const opts = options || {};
+    const posix = opts.windows;
+    const regex = isState ? picomatch2.compileRe(glob, options) : picomatch2.makeRe(glob, options, false, true);
+    const state = regex.state;
+    delete regex.state;
+    let isIgnored = () => false;
+    if (opts.ignore) {
+      const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
+      isIgnored = picomatch2(opts.ignore, ignoreOpts, returnState);
+    }
+    const matcher = (input, returnObject = false) => {
+      const { isMatch, match, output } = picomatch2.test(input, regex, options, { glob, posix });
+      const result = { glob, state, regex, posix, input, output, match, isMatch };
+      if (typeof opts.onResult === "function") {
+        opts.onResult(result);
+      }
+      if (isMatch === false) {
+        result.isMatch = false;
+        return returnObject ? result : false;
+      }
+      if (isIgnored(input)) {
+        if (typeof opts.onIgnore === "function") {
+          opts.onIgnore(result);
+        }
+        result.isMatch = false;
+        return returnObject ? result : false;
       }
-      return false;
+      if (typeof opts.onMatch === "function") {
+        opts.onMatch(result);
+      }
+      return returnObject ? result : true;
     };
-    return arrayMatcher;
-  }
-  const isState = isObject(glob) && glob.tokens && glob.input;
-  if (glob === "" || typeof glob !== "string" && !isState) {
-    throw new TypeError("Expected pattern to be a non-empty string");
-  }
-  const opts = options || {};
-  const posix = opts.windows;
-  const regex = isState ? picomatch$2.compileRe(glob, options) : picomatch$2.makeRe(glob, options, false, true);
-  const state = regex.state;
-  delete regex.state;
-  let isIgnored = () => false;
-  if (opts.ignore) {
-    const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
-    isIgnored = picomatch$2(opts.ignore, ignoreOpts, returnState);
-  }
-  const matcher = (input, returnObject = false) => {
-    const { isMatch, match, output } = picomatch$2.test(input, regex, options, { glob, posix });
-    const result = { glob, state, regex, posix, input, output, match, isMatch };
-    if (typeof opts.onResult === "function") {
-      opts.onResult(result);
+    if (returnState) {
+      matcher.state = state;
     }
-    if (isMatch === false) {
-      result.isMatch = false;
-      return returnObject ? result : false;
+    return matcher;
+  };
+  picomatch2.test = (input, regex, options, { glob, posix } = {}) => {
+    if (typeof input !== "string") {
+      throw new TypeError("Expected input to be a string");
     }
-    if (isIgnored(input)) {
-      if (typeof opts.onIgnore === "function") {
-        opts.onIgnore(result);
-      }
-      result.isMatch = false;
-      return returnObject ? result : false;
+    if (input === "") {
+      return { isMatch: false, output: "" };
     }
-    if (typeof opts.onMatch === "function") {
-      opts.onMatch(result);
+    const opts = options || {};
+    const format = opts.format || (posix ? utils2.toPosixSlashes : null);
+    let match = input === glob;
+    let output = match && format ? format(input) : input;
+    if (match === false) {
+      output = format ? format(input) : input;
+      match = output === glob;
+    }
+    if (match === false || opts.capture === true) {
+      if (opts.matchBase === true || opts.basename === true) {
+        match = picomatch2.matchBase(input, regex, options, posix);
+      } else {
+        match = regex.exec(output);
+      }
     }
-    return returnObject ? result : true;
+    return { isMatch: Boolean(match), match, output };
   };
-  if (returnState) {
-    matcher.state = state;
-  }
-  return matcher;
-};
-picomatch$2.test = (input, regex, options, { glob, posix } = {}) => {
-  if (typeof input !== "string") {
-    throw new TypeError("Expected input to be a string");
-  }
-  if (input === "") {
-    return { isMatch: false, output: "" };
-  }
-  const opts = options || {};
-  const format = opts.format || (posix ? utils$1.toPosixSlashes : null);
-  let match = input === glob;
-  let output = match && format ? format(input) : input;
-  if (match === false) {
-    output = format ? format(input) : input;
-    match = output === glob;
-  }
-  if (match === false || opts.capture === true) {
-    if (opts.matchBase === true || opts.basename === true) {
-      match = picomatch$2.matchBase(input, regex, options, posix);
-    } else {
-      match = regex.exec(output);
+  picomatch2.matchBase = (input, glob, options) => {
+    const regex = glob instanceof RegExp ? glob : picomatch2.makeRe(glob, options);
+    return regex.test(utils2.basename(input));
+  };
+  picomatch2.isMatch = (str, patterns, options) => picomatch2(patterns, options)(str);
+  picomatch2.parse = (pattern, options) => {
+    if (Array.isArray(pattern)) return pattern.map((p) => picomatch2.parse(p, options));
+    return parse(pattern, { ...options, fastpaths: false });
+  };
+  picomatch2.scan = (input, options) => scan(input, options);
+  picomatch2.compileRe = (state, options, returnOutput = false, returnState = false) => {
+    if (returnOutput === true) {
+      return state.output;
     }
-  }
-  return { isMatch: Boolean(match), match, output };
-};
-picomatch$2.matchBase = (input, glob, options) => {
-  const regex = glob instanceof RegExp ? glob : picomatch$2.makeRe(glob, options);
-  return regex.test(utils$1.basename(input));
-};
-picomatch$2.isMatch = (str, patterns, options) => picomatch$2(patterns, options)(str);
-picomatch$2.parse = (pattern, options) => {
-  if (Array.isArray(pattern))
-    return pattern.map((p) => picomatch$2.parse(p, options));
-  return parse(pattern, { ...options, fastpaths: false });
-};
-picomatch$2.scan = (input, options) => scan(input, options);
-picomatch$2.compileRe = (state, options, returnOutput = false, returnState = false) => {
-  if (returnOutput === true) {
-    return state.output;
-  }
-  const opts = options || {};
-  const prepend = opts.contains ? "" : "^";
-  const append = opts.contains ? "" : "$";
-  let source = `${prepend}(?:${state.output})${append}`;
-  if (state && state.negated === true) {
-    source = `^(?!${source}).*$`;
-  }
-  const regex = picomatch$2.toRegex(source, options);
-  if (returnState === true) {
-    regex.state = state;
-  }
-  return regex;
-};
-picomatch$2.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
-  if (!input || typeof input !== "string") {
-    throw new TypeError("Expected a non-empty string");
-  }
-  let parsed = { negated: false, fastpaths: true };
-  if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) {
-    parsed.output = parse.fastpaths(input, options);
-  }
-  if (!parsed.output) {
-    parsed = parse(input, options);
-  }
-  return picomatch$2.compileRe(parsed, options, returnOutput, returnState);
-};
-picomatch$2.toRegex = (source, options) => {
-  try {
     const opts = options || {};
-    return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
-  } catch (err) {
-    if (options && options.debug === true)
-      throw err;
-    return /$^/;
-  }
-};
-picomatch$2.constants = constants;
-var picomatch_1$1 = picomatch$2;
-const pico = picomatch_1$1;
-const utils = utils$4;
-function picomatch(glob, options, returnState = false) {
-  if (options && (options.windows === null || options.windows === void 0)) {
-    options = { ...options, windows: utils.isWindows() };
-  }
-  return pico(glob, options, returnState);
+    const prepend = opts.contains ? "" : "^";
+    const append = opts.contains ? "" : "$";
+    let source = `${prepend}(?:${state.output})${append}`;
+    if (state && state.negated === true) {
+      source = `^(?!${source}).*$`;
+    }
+    const regex = picomatch2.toRegex(source, options);
+    if (returnState === true) {
+      regex.state = state;
+    }
+    return regex;
+  };
+  picomatch2.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+    if (!input || typeof input !== "string") {
+      throw new TypeError("Expected a non-empty string");
+    }
+    let parsed = { negated: false, fastpaths: true };
+    if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) {
+      parsed.output = parse.fastpaths(input, options);
+    }
+    if (!parsed.output) {
+      parsed = parse(input, options);
+    }
+    return picomatch2.compileRe(parsed, options, returnOutput, returnState);
+  };
+  picomatch2.toRegex = (source, options) => {
+    try {
+      const opts = options || {};
+      return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
+    } catch (err) {
+      if (options && options.debug === true) throw err;
+      return /$^/;
+    }
+  };
+  picomatch2.constants = constants2;
+  picomatch_1$1 = picomatch2;
+  return picomatch_1$1;
+}
+var picomatch_1;
+var hasRequiredPicomatch;
+function requirePicomatch() {
+  if (hasRequiredPicomatch) return picomatch_1;
+  hasRequiredPicomatch = 1;
+  const pico = /* @__PURE__ */ requirePicomatch$1();
+  const utils2 = /* @__PURE__ */ requireUtils();
+  function picomatch2(glob, options, returnState = false) {
+    if (options && (options.windows === null || options.windows === void 0)) {
+      options = { ...options, windows: utils2.isWindows() };
+    }
+    return pico(glob, options, returnState);
+  }
+  Object.assign(picomatch2, pico);
+  picomatch_1 = picomatch2;
+  return picomatch_1;
 }
-Object.assign(picomatch, pico);
-var picomatch_1 = picomatch;
-const picomatch$1 = /* @__PURE__ */ getDefaultExportFromCjs(picomatch_1);
+var picomatchExports = /* @__PURE__ */ requirePicomatch();
+const picomatch = /* @__PURE__ */ getDefaultExportFromCjs(picomatchExports);
 function assertShape(value, yupSchema, errorMessage) {
   const shape = yupSchema(yup);
   try {
     shape.validateSync(value);
   } catch (e) {
-    const message = errorMessage || `Failed to assertShape - ${e.message}`;
+    const message = `Failed to assertShape - ${e.message}`;
     throw new Error(message);
   }
 }
@@ -1544,8 +1567,7 @@ const lastItem = (arr) => {
   return arr[arr.length - 1];
 };
 const capitalize = (s) => {
-  if (typeof s !== "string")
-    return "";
+  if (typeof s !== "string") return "";
   return s.charAt(0).toUpperCase() + s.slice(1);
 };
 const generateNamespacedFieldName = (names, suffix = "") => {
@@ -1601,8 +1623,7 @@ function findDuplicates(array = []) {
   ].map((x) => `"${x}"`);
   if (duplicates.length) {
     return duplicates.join(", ");
-  } else
-    return void 0;
+  } else return void 0;
 }
 const TINA_HOST = "content.tinajs.io";
 const parseURL = (url) => {
@@ -1716,7 +1737,7 @@ class TinaSchema {
         );
         if (!isFolderPlaceholder && (((_a = collection == null ? void 0 : collection.match) == null ? void 0 : _a.include) || ((_b = collection == null ? void 0 : collection.match) == null ? void 0 : _b.exclude))) {
           const matches = this.getMatches({ collection });
-          const match = picomatch$1.isMatch(canonicalFilepath, matches);
+          const match = picomatch.isMatch(canonicalFilepath, matches);
           if (!match) {
             return false;
           }
@@ -2094,7 +2115,7 @@ class TinaSchema {
     files
   }) {
     const matches = this.getMatches({ collection });
-    const matcher = picomatch$1(matches);
+    const matcher = picomatch(matches);
     const matchedFiles = files.filter((file) => matcher(file));
     return matchedFiles;
   }
@@ -2812,6 +2833,9 @@ const validateSchema = ({ schema }) => {
     throw new Error(e);
   }
 };
+const RELATIVE_PATH_REGEX = /^[a-zA-Z0-9\-_./]+$/;
+const RELATIVE_PATH_ALLOWED_CHARS_MESSAGE = "Must contain only a-z, A-Z, 0-9, -, _, ., or /.";
+const isValidRelativePath = (value) => RELATIVE_PATH_REGEX.test(value);
 const isHeadingLevel = (value) => {
   switch (value) {
     case "h1":
@@ -2828,21 +2852,41 @@ const isHeadingLevel = (value) => {
 const normalizeHeadingLevels = (configured) => {
   const seen = /* @__PURE__ */ new Set();
   for (const level of configured) {
-    if (isHeadingLevel(level))
-      seen.add(level);
+    if (isHeadingLevel(level)) seen.add(level);
   }
   return Array.from(seen);
 };
+const ERR_ALREADY_EXISTS = "already exists";
+const ASYNC_POLLER_ERROR = {
+  CANCELLED: "AsyncPoller: cancelled",
+  TIMEOUT: "AsyncPoller: reached timeout",
+  STATUS_UNKNOWN: "AsyncPoller: status unknown for too long, please check indexing progress on the TinaCloud dashboard"
+};
+const ERR_PATH_TRAVERSAL = "Path traversal detected";
+const ERR_HAS_REFERENCES = "has references";
+const ERR_NOT_INDEXED = "has not been indexed by TinaCloud";
+const ERR_BRANCH_EXISTS = "already exists";
+const ERR_BRANCH_CONFLICT = "conflict";
 export {
   ALL_HEADING_LEVELS,
+  ASYNC_POLLER_ERROR,
   CONTENT_FORMATS,
+  ERR_ALREADY_EXISTS,
+  ERR_BRANCH_CONFLICT,
+  ERR_BRANCH_EXISTS,
+  ERR_HAS_REFERENCES,
+  ERR_NOT_INDEXED,
+  ERR_PATH_TRAVERSAL,
   NAMER,
+  RELATIVE_PATH_ALLOWED_CHARS_MESSAGE,
+  RELATIVE_PATH_REGEX,
   TINA_HOST,
   TinaSchema,
   TinaSchemaValidationError,
   addNamespaceToSchema,
   canonicalPath,
   isHeadingLevel,
+  isValidRelativePath,
   normalizeHeadingLevels,
   normalizePath,
   parseURL,