@tinacms/schema-tools 0.0.0-00f6525-20241015065741

package/dist/index.js

@@ -0,0 +1,2714 @@
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("yup"), require("url-pattern"), require("zod")) : typeof define === "function" && define.amd ? define(["exports", "yup", "url-pattern", "zod"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["@tinacms/schema-tools"] = {}, global.NOOP, global.NOOP, global.NOOP));
+})(this, function(exports2, yup, UrlPattern, z) {
+  "use strict";
+  function _interopNamespaceDefault(e) {
+    const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+    if (e) {
+      for (const k in e) {
+        if (k !== "default") {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          Object.defineProperty(n, k, d.get ? d : {
+            enumerable: true,
+            get: () => e[k]
+          });
+        }
+      }
+    }
+    n.default = e;
+    return Object.freeze(n);
+  }
+  const yup__namespace = /* @__PURE__ */ _interopNamespaceDefault(yup);
+  function addNamespaceToSchema(maybeNode, namespace = []) {
+    if (typeof maybeNode === "string") {
+      return maybeNode;
+    }
+    if (typeof maybeNode === "boolean") {
+      return maybeNode;
+    }
+    if (typeof maybeNode === "function") {
+      return maybeNode;
+    }
+    const newNode = { ...maybeNode };
+    const keys = Object.keys(maybeNode);
+    Object.values(maybeNode).map((m, index) => {
+      const key = keys[index];
+      if (Array.isArray(m)) {
+        newNode[key] = m.map((element) => {
+          if (!element) {
+            return;
+          }
+          if (!element.hasOwnProperty("name")) {
+            return element;
+          }
+          const value = element.name || element.value;
+          return addNamespaceToSchema(element, [...namespace, value]);
+        });
+      } else {
+        if (!m) {
+          return;
+        }
+        if (!m.hasOwnProperty("name")) {
+          newNode[key] = m;
+        } else {
+          newNode[key] = addNamespaceToSchema(m, [...namespace, m.name]);
+        }
+      }
+    });
+    return { ...newNode, 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: {
+      "***": "*",
+      "**/**": "**",
+      "**/**/**": "**"
+    },
+    // 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(exports3) {
+    const {
+      REGEX_BACKSLASH,
+      REGEX_REMOVE_BACKSLASH,
+      REGEX_SPECIAL_CHARS,
+      REGEX_SPECIAL_CHARS_GLOBAL
+    } = constants$2;
+    exports3.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
+    exports3.hasRegexChars = (str) => REGEX_SPECIAL_CHARS.test(str);
+    exports3.isRegexChar = (str) => str.length === 1 && exports3.hasRegexChars(str);
+    exports3.escapeRegex = (str) => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1");
+    exports3.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/");
+    exports3.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;
+    };
+    exports3.removeBackslashes = (str) => {
+      return str.replace(REGEX_REMOVE_BACKSLASH, (match) => {
+        return match === "\\" ? "" : match;
+      });
+    };
+    exports3.escapeLast = (input, char, lastIdx) => {
+      const idx = input.lastIndexOf(char, lastIdx);
+      if (idx === -1)
+        return input;
+      if (input[idx - 1] === "\\")
+        return exports3.escapeLast(input, char, idx - 1);
+      return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+    };
+    exports3.removePrefix = (input, state = {}) => {
+      let output = input;
+      if (output.startsWith("./")) {
+        output = output.slice(2);
+        state.prefix = "./";
+      }
+      return output;
+    };
+    exports3.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;
+    };
+    exports3.basename = (path, { windows } = {}) => {
+      const segs = path.split(windows ? /[\\/]/ : "/");
+      const last = segs[segs.length - 1];
+      if (last === "") {
+        return segs[segs.length - 2];
+      }
+      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;
+        code = advance();
+        if (code === CHAR_LEFT_CURLY_BRACE) {
+          braceEscaped = true;
+        }
+        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();
+            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;
+        }
+        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;
+        }
+        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 (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;
+          }
+          if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+            isBracket = token.isBracket = true;
+            isGlob = token.isGlob = true;
+            finished = true;
+            break;
+          }
+        }
+        if (scanToEnd === true) {
+          continue;
+        }
+        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;
+            }
+          }
+          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;
+          }
+          depth(tokens[idx]);
+          state.maxDepth += tokens[idx].depth;
+        }
+        if (idx !== 0 || value !== "") {
+          parts.push(value);
+        }
+        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;
+    }
+    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();
+    };
+    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;
+    };
+    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 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}`;
+        }
+        if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+          const expression = parse$1(rest, { ...options, fastpaths: false }).output;
+          output = token.close = `)${expression})${extglobStar})`;
+        }
+        if (token.prev.type === "bos") {
+          state.negatedExtglob = true;
+        }
+      }
+      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 ? QMARK2.repeat(rest.length) : "");
+          }
+          if (index === 0) {
+            return qmarkNoDot + (rest ? QMARK2.repeat(rest.length) : "");
+          }
+          return QMARK2.repeat(chars.length);
+        }
+        if (first === ".") {
+          return DOT_LITERAL2.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 ? "\\" : "";
+          });
+        }
+      }
+      if (output === input && opts.contains === true) {
+        state.output = input;
+        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 });
+          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 (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;
+                }
+                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", "]"));
+          }
+          value = `\\${value}`;
+        } else {
+          increment("brackets");
+        }
+        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}` });
+          continue;
+        }
+        if (state.brackets === 0) {
+          if (opts.strictBrackets === true) {
+            throw new SyntaxError(syntaxError("opening", "["));
+          }
+          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)) {
+          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;
+          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 });
+          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;
+      }
+      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;
+          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;
+          continue;
+        }
+        if (state.braces + state.parens === 0 && prev.type !== "bos" && prev.type !== "slash") {
+          push({ type: "text", value, output: DOT_LITERAL2 });
+          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);
+          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_DOT2 });
+          continue;
+        }
+        push({ type: "qmark", value, output: QMARK2 });
+        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 (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_LITERAL2 });
+          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_LITERAL2 });
+        continue;
+      }
+      if (value === "@") {
+        if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+          push({ type: "at", extglob: true, value, output: "" });
+          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);
+          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: "" });
+          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_LITERAL2}|${SLASH_LITERAL2}${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_LITERAL2}|${globstar(opts)}${SLASH_LITERAL2})`;
+          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.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;
+        }
+        push(token);
+        continue;
+      }
+      if (prev && (prev.type === "bracket" || prev.type === "paren") && opts.regex === true) {
+        token.output = value;
+        push(token);
+        continue;
+      }
+      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;
+        }
+      }
+      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;
+        }
+      }
+    }
+    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}).)*?)`;
+    };
+    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];
+        }
+      }
+    };
+    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;
+        }
+        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 ? 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 (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;
+      }
+      if (typeof opts.onMatch === "function") {
+        opts.onMatch(result);
+      }
+      return returnObject ? result : true;
+    };
+    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);
+      }
+    }
+    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);
+  }
+  Object.assign(picomatch, pico);
+  var picomatch_1 = picomatch;
+  const picomatch$1 = /* @__PURE__ */ getDefaultExportFromCjs(picomatch_1);
+  function assertShape(value, yupSchema, errorMessage) {
+    const shape = yupSchema(yup__namespace);
+    try {
+      shape.validateSync(value);
+    } catch (e) {
+      const message = errorMessage || `Failed to assertShape - ${e.message}`;
+      throw new Error(message);
+    }
+  }
+  const lastItem = (arr) => {
+    if (typeof arr === "undefined") {
+      throw new Error("Can not call lastItem when arr is undefined");
+    }
+    return arr[arr.length - 1];
+  };
+  const capitalize = (s) => {
+    if (typeof s !== "string")
+      return "";
+    return s.charAt(0).toUpperCase() + s.slice(1);
+  };
+  const generateNamespacedFieldName = (names, suffix = "") => {
+    return (suffix ? [...names, suffix] : names).map(capitalize).join("");
+  };
+  const NAMER = {
+    dataFilterTypeNameOn: (namespace) => {
+      return generateNamespacedFieldName(namespace, "_FilterOn");
+    },
+    dataFilterTypeName: (namespace) => {
+      return generateNamespacedFieldName(namespace, "Filter");
+    },
+    dataMutationTypeNameOn: (namespace) => {
+      return generateNamespacedFieldName(namespace, "_MutationOn");
+    },
+    dataMutationTypeName: (namespace) => {
+      return generateNamespacedFieldName(namespace, "Mutation");
+    },
+    updateName: (namespace) => {
+      return "update" + generateNamespacedFieldName(namespace, "Document");
+    },
+    createName: (namespace) => {
+      return "create" + generateNamespacedFieldName(namespace, "Document");
+    },
+    queryName: (namespace) => {
+      return "get" + generateNamespacedFieldName(namespace, "Document");
+    },
+    generateQueryListName: (namespace) => {
+      return "get" + generateNamespacedFieldName(namespace, "List");
+    },
+    fragmentName: (namespace) => {
+      return generateNamespacedFieldName(namespace, "") + "Parts";
+    },
+    collectionTypeName: (namespace) => {
+      return generateNamespacedFieldName(namespace, "Collection");
+    },
+    documentTypeName: (namespace) => {
+      return generateNamespacedFieldName(namespace, "Document");
+    },
+    dataTypeName: (namespace) => {
+      return generateNamespacedFieldName(namespace, "");
+    },
+    referenceConnectionType: (namespace) => {
+      return generateNamespacedFieldName(namespace, "Connection");
+    },
+    referenceConnectionEdgesTypeName: (namespace) => {
+      return generateNamespacedFieldName(namespace, "ConnectionEdges");
+    }
+  };
+  function findDuplicates(array = []) {
+    const duplicates = [
+      ...new Set(array.filter((item, index) => array.indexOf(item) !== index))
+    ].map((x) => `"${x}"`);
+    if (duplicates.length) {
+      return duplicates.join(", ");
+    } else
+      return void 0;
+  }
+  const TINA_HOST = "content.tinajs.io";
+  const parseURL = (url) => {
+    if (url.startsWith("/")) {
+      return {
+        branch: null,
+        isLocalClient: false,
+        clientId: null,
+        host: null
+      };
+    }
+    if (url.includes("localhost")) {
+      return {
+        branch: null,
+        isLocalClient: true,
+        clientId: null,
+        host: "localhost"
+      };
+    }
+    const params = new URL(url);
+    const isTinaCloud = params.host.includes("tinajs.dev") || params.host.includes("tina.io") || params.host.includes("tinajs.io");
+    if (!isTinaCloud) {
+      return {
+        branch: null,
+        isLocalClient: true,
+        clientId: null,
+        host: params.host
+      };
+    }
+    const pattern = new UrlPattern("/:v/content/:clientId/github/*", {
+      escapeChar: " ",
+      // extend to allow `.` in version
+      segmentValueCharset: "a-zA-Z0-9-_~ %."
+    });
+    const result = pattern.match(params.pathname);
+    const branch = result == null ? void 0 : result._;
+    const clientId = result == null ? void 0 : result.clientId;
+    if (!branch || !clientId) {
+      throw new Error(
+        `Invalid URL format provided. Expected: https://content.tinajs.io/<Version>/content/<ClientID>/github/<Branch> but but received ${url}`
+      );
+    }
+    return {
+      host: params.host,
+      branch,
+      clientId,
+      isLocalClient: false
+    };
+  };
+  const normalizePath = (filepath) => filepath.replace(/\\/g, "/");
+  class TinaSchema {
+    /**
+     * Create a schema class from a user defined schema object
+     */
+    constructor(config) {
+      this.config = config;
+      this.getIsTitleFieldName = (collection) => {
+        var _a;
+        const col = this.getCollection(collection);
+        const field = (_a = col == null ? void 0 : col.fields) == null ? void 0 : _a.find((x) => x.type === "string" && x.isTitle);
+        return field == null ? void 0 : field.name;
+      };
+      this.getCollectionsByName = (collectionNames) => {
+        return this.schema.collections.filter(
+          (collection) => collectionNames.includes(collection.name)
+        );
+      };
+      this.getCollection = (collectionName) => {
+        const collection = this.schema.collections.find(
+          (collection2) => collection2.name === collectionName
+        );
+        if (!collection) {
+          throw new Error(`Expected to find collection named ${collectionName}`);
+        }
+        const extraFields = {};
+        const templateInfo = this.getTemplatesForCollectable(collection);
+        switch (templateInfo.type) {
+          case "object":
+            extraFields.fields = templateInfo.template.fields;
+            break;
+          case "union":
+            extraFields.templates = templateInfo.templates;
+            break;
+        }
+        return {
+          // @ts-ignore FIXME: backwards compatibility, using `slug` should probably be deprecated
+          slug: collection.name,
+          ...extraFields,
+          ...collection,
+          format: collection.format || "md"
+        };
+      };
+      this.getCollections = () => {
+        return this.schema.collections.map(
+          (collection) => this.getCollection(collection.name)
+        ) || [];
+      };
+      this.getCollectionByFullPath = (filepath) => {
+        const fileExtension = filepath.split(".").pop();
+        const normalizedPath = filepath.replace(/\\/g, "/");
+        const possibleCollections = this.getCollections().filter((collection) => {
+          var _a, _b;
+          if (!normalizedPath.endsWith(`.gitkeep.${collection.format || "md"}`) && fileExtension !== (collection.format || "md")) {
+            return false;
+          }
+          if (((_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(normalizedPath, matches);
+            if (!match) {
+              return false;
+            }
+          }
+          const path = collection.path ? collection.path.replace(/\/?$/, "/") : "";
+          return normalizedPath.startsWith(path);
+        });
+        if (possibleCollections.length === 0) {
+          throw new Error(`Unable to find collection for file at ${filepath}`);
+        }
+        if (possibleCollections.length === 1) {
+          return possibleCollections[0];
+        }
+        if (possibleCollections.length > 1) {
+          const longestMatch = possibleCollections.reduce((acc, collection) => {
+            if (collection.path.length > acc.path.length) {
+              return collection;
+            }
+            return acc;
+          });
+          return longestMatch;
+        }
+      };
+      this.getCollectionAndTemplateByFullPath = (filepath, templateName) => {
+        const collection = this.getCollectionByFullPath(filepath);
+        if (!collection) {
+          return void 0;
+        }
+        let template;
+        const templates = this.getTemplatesForCollectable(collection);
+        if (templates.type === "union") {
+          if (templateName) {
+            template = templates.templates.find(
+              (template2) => lastItem(template2.namespace) === templateName
+            );
+            if (!template) {
+              throw new Error(
+                `Unable to determine template for item at ${filepath}`
+              );
+            }
+          } else {
+            throw new Error(
+              `Unable to determine template for item at ${filepath}, no template name provided for collection with multiple templates`
+            );
+          }
+        }
+        if (templates.type === "object") {
+          template = templates.template;
+        }
+        if (!template) {
+          throw new Error(
+            `Something went wrong while trying to determine template for ${filepath}`
+          );
+        }
+        return { collection, template };
+      };
+      this.getTemplateForData = ({
+        data,
+        collection
+      }) => {
+        const templateInfo = this.getTemplatesForCollectable(collection);
+        switch (templateInfo.type) {
+          case "object":
+            return templateInfo.template;
+          case "union": {
+            assertShape(
+              data,
+              (yup2) => yup2.object({ _template: yup2.string().required() })
+            );
+            const template = templateInfo.templates.find(
+              (template2) => template2.namespace[template2.namespace.length - 1] === data._template
+            );
+            if (!template) {
+              throw new Error(
+                `Expected to find template named '${data._template}' for collection '${lastItem(collection.namespace)}'`
+              );
+            }
+            return template;
+          }
+        }
+      };
+      this.transformPayload = (collectionName, payload) => {
+        const collection = this.getCollection(collectionName);
+        if (collection.templates) {
+          const template = collection.templates.find((template2) => {
+            if (typeof template2 === "string") {
+              throw new Error("Global templates not supported");
+            }
+            return (payload == null ? void 0 : payload._template) === template2.name;
+          });
+          if (!template) {
+            console.error(payload);
+            throw new Error("Unable to find template for payload");
+          }
+          if (typeof template === "string") {
+            throw new Error("Global templates not supported");
+          }
+          return {
+            [collectionName]: {
+              [template.name]: this.transformCollectablePayload(payload, template)
+            }
+          };
+        }
+        return {
+          [collectionName]: this.transformCollectablePayload(payload, collection)
+        };
+      };
+      this.transformCollectablePayload = (payload, collection) => {
+        const accumulator = {};
+        Object.entries(payload).forEach(([key, value]) => {
+          var _a;
+          if (typeof collection.fields === "string") {
+            throw new Error("Global templates not supported");
+          }
+          const field = (_a = collection == null ? void 0 : collection.fields) == null ? void 0 : _a.find((field2) => {
+            if (typeof field2 === "string") {
+              throw new Error("Global templates not supported");
+            }
+            return field2.name === key;
+          });
+          if (field) {
+            accumulator[key] = this.transformField(field, value);
+          }
+        });
+        return accumulator;
+      };
+      this.transformField = (field, value) => {
+        if (field.type === "object")
+          if (field.templates) {
+            if (field.list) {
+              assertShape(
+                value,
+                (yup2) => yup2.array(yup2.object({ _template: yup2.string().required() }))
+              );
+              return value.map((item) => {
+                const { _template, ...rest } = item;
+                const template = field.templates.find((template2) => {
+                  if (typeof template2 === "string") {
+                    return false;
+                  }
+                  return template2.name === _template;
+                });
+                if (typeof template === "string") {
+                  throw new Error("Global templates not supported");
+                }
+                if (!template) {
+                  throw new Error(`Expected to find template named '${_template}'`);
+                }
+                return {
+                  [_template]: this.transformCollectablePayload(rest, template)
+                };
+              });
+            } else {
+              assertShape(
+                value,
+                (yup2) => yup2.object({ _template: yup2.string().required() })
+              );
+              const { _template, ...rest } = value;
+              return { [_template]: this.transformCollectablePayload(rest, field) };
+            }
+          } else {
+            if (field.list) {
+              assertShape(value, (yup2) => yup2.array(yup2.object()));
+              return value.map((item) => {
+                return this.transformCollectablePayload(item, field);
+              });
+            } else {
+              assertShape(value, (yup2) => yup2.object());
+              return this.transformCollectablePayload(value, field);
+            }
+          }
+        else {
+          return value;
+        }
+      };
+      this.isMarkdownCollection = (collectionName) => {
+        const collection = this.getCollection(collectionName);
+        const format = collection.format;
+        if (!format) {
+          return true;
+        }
+        if (["markdown", "md"].includes(format)) {
+          return true;
+        }
+        return false;
+      };
+      this.getTemplatesForCollectable = (collection) => {
+        const extraFields = [];
+        if (collection == null ? void 0 : collection.fields) {
+          const template = collection;
+          if (typeof template.fields === "string" || typeof template.fields === "undefined") {
+            throw new Error("Expected template to have fields but none were found");
+          }
+          return {
+            namespace: collection.namespace,
+            type: "object",
+            template: {
+              ...template,
+              fields: [...template.fields, ...extraFields]
+            }
+          };
+        } else {
+          if (collection == null ? void 0 : collection.templates) {
+            return {
+              namespace: collection.namespace,
+              type: "union",
+              templates: collection.templates.map((templateOrTemplateString) => {
+                const template = templateOrTemplateString;
+                return {
+                  ...template,
+                  fields: [...template.fields, ...extraFields]
+                };
+              })
+            };
+          } else {
+            throw new Error(
+              `Expected either fields or templates array to be defined on collection ${collection.namespace.join(
+                "_"
+              )}`
+            );
+          }
+        }
+      };
+      this.walkFields = (cb) => {
+        const walk = (collectionOrObject, collection, path) => {
+          if (collectionOrObject.templates) {
+            collectionOrObject.templates.forEach((template) => {
+              template.fields.forEach((field) => {
+                cb({ field, collection, path: [...path, template.name] });
+              });
+            });
+          }
+          if (collectionOrObject.fields) {
+            collectionOrObject.fields.forEach((field) => {
+              cb({ field, collection, path: [...path, field.name] });
+              if (field.type === "rich-text" || field.type === "object") {
+                walk(field, collection, [...path, field.name]);
+              }
+            });
+          }
+        };
+        const collections = this.getCollections();
+        collections.forEach((collection) => walk(collection, collection, []));
+      };
+      this.schema = config;
+      this.walkFields(({ field, collection, path }) => {
+        if (!("searchable" in field)) {
+          if (field.type === "image") {
+            field.searchable = false;
+          } else {
+            field.searchable = true;
+          }
+        }
+        if (field.type === "rich-text") {
+          if (field.parser) {
+            return;
+          }
+          if (collection.format === "mdx") {
+            field.parser = { type: "mdx" };
+          } else {
+            field.parser = { type: "markdown" };
+          }
+        }
+        field.uid = field.uid || false;
+      });
+    }
+    /**
+     * This function returns an array of glob matches for a given collection.
+     *
+     * @param collection The collection to get the matches for. Can be a string or a collection object.
+     * @returns An array of glob matches.
+     */
+    getMatches({
+      collection: collectionOrString
+    }) {
+      var _a, _b;
+      const collection = typeof collectionOrString === "string" ? this.getCollection(collectionOrString) : collectionOrString;
+      const normalPath = normalizePath(collection.path);
+      const pathSuffix = normalPath ? "/" : "";
+      const format = collection.format || "md";
+      const matches = [];
+      if ((_a = collection == null ? void 0 : collection.match) == null ? void 0 : _a.include) {
+        const match = `${normalPath}${pathSuffix}${collection.match.include}.${format}`;
+        matches.push(match);
+      }
+      if ((_b = collection == null ? void 0 : collection.match) == null ? void 0 : _b.exclude) {
+        const exclude = `!(${normalPath}${pathSuffix}${collection.match.exclude}.${format})`;
+        matches.push(exclude);
+      }
+      return matches;
+    }
+    matchFiles({
+      collection,
+      files
+    }) {
+      const matches = this.getMatches({ collection });
+      const matcher = picomatch$1(matches);
+      const matchedFiles = files.filter((file) => matcher(file));
+      return matchedFiles;
+    }
+  }
+  const resolveField = (field, schema) => {
+    var _a;
+    const extraFields = field.ui || {};
+    switch (field.type) {
+      case "number":
+        return {
+          component: "number",
+          ...field,
+          ...extraFields
+        };
+      case "datetime":
+        return {
+          component: "date",
+          ...field,
+          ...extraFields
+        };
+      case "boolean":
+        return {
+          component: "toggle",
+          ...field,
+          ...extraFields
+        };
+      case "image":
+        if (field.list) {
+          return {
+            component: "list",
+            field: {
+              component: "image"
+            },
+            ...field,
+            ...extraFields
+          };
+        }
+        return {
+          component: "image",
+          clearable: true,
+          ...field,
+          ...extraFields
+        };
+      case "string":
+        if (field.options) {
+          if (field.list) {
+            return {
+              component: "checkbox-group",
+              ...field,
+              ...extraFields,
+              options: field.options
+            };
+          }
+          if (field.options[0] && typeof field.options[0] === "object" && field.options[0].icon) {
+            return {
+              component: "button-toggle",
+              ...field,
+              ...extraFields,
+              options: field.options
+            };
+          }
+          return {
+            component: "select",
+            ...field,
+            ...extraFields,
+            options: field.ui && field.ui.component !== "select" ? field.options : [{ label: "Choose an option", value: "" }, ...field.options]
+          };
+        }
+        if (field.list) {
+          return {
+            // Allows component to be overridden for scalars
+            component: "list",
+            field: {
+              component: "text"
+            },
+            ...field,
+            ...extraFields
+          };
+        }
+        return {
+          // Allows component to be overridden for scalars
+          component: "text",
+          ...field,
+          ...extraFields
+        };
+      case "object": {
+        const templateInfo = schema.getTemplatesForCollectable(field);
+        if (templateInfo.type === "object") {
+          return {
+            ...field,
+            component: field.list ? "group-list" : "group",
+            fields: templateInfo.template.fields.map(
+              (field2) => resolveField(field2, schema)
+            ),
+            ...extraFields
+          };
+        } else if (templateInfo.type === "union") {
+          const templates2 = {};
+          const typeMap2 = {};
+          templateInfo.templates.forEach((template) => {
+            const extraFields2 = template.ui || {};
+            const templateName = lastItem(template.namespace);
+            typeMap2[templateName] = NAMER.dataTypeName(template.namespace);
+            templates2[lastItem(template.namespace)] = {
+              label: template.label || templateName,
+              key: templateName,
+              namespace: [...field.namespace, templateName],
+              fields: template.fields.map((field2) => resolveField(field2, schema)),
+              ...extraFields2
+            };
+            return true;
+          });
+          return {
+            ...field,
+            typeMap: typeMap2,
+            namespace: field.namespace,
+            component: field.list ? "blocks" : "not-implemented",
+            templates: templates2,
+            ...extraFields
+          };
+        } else {
+          throw new Error(`Unknown object for resolveField function`);
+        }
+      }
+      case "rich-text":
+        const templates = {};
+        (_a = field.templates) == null ? void 0 : _a.forEach((template) => {
+          if (typeof template === "string") {
+            throw new Error(`Global templates not yet supported for rich-text`);
+          } else {
+            const extraFields2 = template.ui || {};
+            const templateName = lastItem(template.namespace);
+            NAMER.dataTypeName(template.namespace);
+            templates[lastItem(template.namespace)] = {
+              label: template.label || templateName,
+              key: templateName,
+              inline: template.inline,
+              name: templateName,
+              match: template.match,
+              fields: template.fields.map((field2) => resolveField(field2, schema)),
+              ...extraFields2
+            };
+            return true;
+          }
+        });
+        return {
+          ...field,
+          templates: Object.values(templates),
+          component: "rich-text",
+          ...extraFields
+        };
+      case "password":
+        return {
+          component: "password",
+          ...field,
+          ...extraFields
+        };
+      case "reference":
+        return {
+          ...field,
+          component: "reference",
+          ...extraFields
+        };
+      default:
+        throw new Error(`Unknown field type ${field.type}`);
+    }
+  };
+  const resolveForm = ({
+    collection,
+    basename,
+    template,
+    schema
+  }) => {
+    return {
+      id: basename,
+      label: collection.label,
+      name: basename,
+      fields: template.fields.map((field) => {
+        return resolveField(field, schema);
+      })
+    };
+  };
+  const parseZodError = ({ zodError }) => {
+    var _a, _b, _c, _d;
+    const errors = zodError.flatten((issue) => {
+      const moreInfo = [];
+      if (issue.code === "invalid_union") {
+        issue.unionErrors.map((unionError) => {
+          moreInfo.push(parseZodError({ zodError: unionError }));
+        });
+      }
+      const errorMessage = `Error ${issue == null ? void 0 : issue.message} at path ${issue.path.join(
+        "."
+      )}`;
+      const errorMessages = [errorMessage, ...moreInfo];
+      return {
+        errors: errorMessages
+      };
+    });
+    const formErrors = errors.formErrors.flatMap((x) => x.errors);
+    const parsedErrors = [
+      ...((_b = (_a = errors.fieldErrors) == null ? void 0 : _a.collections) == null ? void 0 : _b.flatMap((x) => x.errors)) || [],
+      ...((_d = (_c = errors.fieldErrors) == null ? void 0 : _c.config) == null ? void 0 : _d.flatMap((x) => x.errors)) || [],
+      ...formErrors
+    ];
+    return parsedErrors;
+  };
+  const name = z.z.string({
+    required_error: "Name is required but not provided",
+    invalid_type_error: "Name must be a string"
+  }).superRefine((val, ctx) => {
+    if (val.match(/^[a-zA-Z0-9_]*$/) === null) {
+      ctx.addIssue({
+        code: "custom",
+        message: `name, "${val}" must be alphanumeric and can only contain underscores. (No spaces, dashes, special characters, etc.)
+If you only want to display this value in the CMS UI, you can use the label property to customize it.
+
+If you need to use this value in your content you can use the \`nameOverride\` property to customize the value. For example:
+\`\`\`
+{
+  "name": ${val.replace(/[^a-zA-Z0-9]/g, "_")},
+  "nameOverride": ${val},
+  // ...
+}
+\`\`\``
+      });
+    }
+  });
+  const TypeName = [
+    "string",
+    "boolean",
+    "number",
+    "datetime",
+    "image",
+    "object",
+    "reference",
+    "rich-text"
+  ];
+  const typeTypeError = `type must be one of ${TypeName.join(", ")}`;
+  const typeRequiredError = `type is required and must be one of ${TypeName.join(
+    ", "
+  )}`;
+  const Option = z.z.union(
+    [
+      z.z.string(),
+      z.z.object({ label: z.z.string(), value: z.z.string() }),
+      z.z.object({ icon: z.z.any(), value: z.z.string() })
+    ],
+    {
+      errorMap: () => {
+        return {
+          message: "Invalid option array. Must be a string[] or {label: string, value: string}[] or {icon: React.ComponentType<any>, value: string}[]"
+        };
+      }
+    }
+  );
+  const TinaField = z.z.object({
+    name,
+    label: z.z.string().or(z.z.boolean()).optional(),
+    description: z.z.string().optional(),
+    required: z.z.boolean().optional()
+  });
+  const FieldWithList = TinaField.extend({ list: z.z.boolean().optional() });
+  const TinaScalerBase = FieldWithList.extend({
+    options: z.z.array(Option).optional(),
+    uid: z.z.boolean().optional()
+  });
+  const StringField = TinaScalerBase.extend({
+    type: z.z.literal("string", {
+      invalid_type_error: typeTypeError,
+      required_error: typeRequiredError
+    }),
+    isTitle: z.z.boolean().optional()
+  });
+  const PasswordField = TinaScalerBase.extend({
+    type: z.z.literal("password", {
+      invalid_type_error: typeTypeError,
+      required_error: typeRequiredError
+    })
+  });
+  const BooleanField = TinaScalerBase.extend({
+    type: z.z.literal("boolean", {
+      invalid_type_error: typeTypeError,
+      required_error: typeRequiredError
+    })
+  });
+  const NumberField = TinaScalerBase.extend({
+    type: z.z.literal("number", {
+      invalid_type_error: typeTypeError,
+      required_error: typeRequiredError
+    })
+  });
+  const ImageField = TinaScalerBase.extend({
+    type: z.z.literal("image", {
+      invalid_type_error: typeTypeError,
+      required_error: typeRequiredError
+    })
+  });
+  const DateTimeField = TinaScalerBase.extend({
+    type: z.z.literal("datetime", {
+      invalid_type_error: typeTypeError,
+      required_error: typeRequiredError
+    }),
+    dateFormat: z.z.string().optional(),
+    timeFormat: z.z.string().optional()
+  });
+  const ReferenceField = FieldWithList.extend({
+    type: z.z.literal("reference", {
+      invalid_type_error: typeTypeError,
+      required_error: typeRequiredError
+    })
+  });
+  const TinaFieldZod = z.z.lazy(() => {
+    const TemplateTemp = z.z.object({
+      label: z.z.string().optional(),
+      name,
+      fields: z.z.array(TinaFieldZod),
+      match: z.z.object({
+        start: z.z.string(),
+        end: z.z.string(),
+        name: z.z.string().optional()
+      }).optional()
+    }).superRefine((val, ctx) => {
+      const dups = findDuplicates(val == null ? void 0 : val.fields.map((x) => x.name));
+      if (dups) {
+        ctx.addIssue({
+          code: z.z.ZodIssueCode.custom,
+          message: `Fields must have a unique name, duplicate field names: ${dups}`
+        });
+      }
+    });
+    const ObjectField = FieldWithList.extend({
+      // needs to be redefined here to avoid circle deps
+      type: z.z.literal("object", {
+        invalid_type_error: typeTypeError,
+        required_error: typeRequiredError
+      }),
+      fields: z.z.array(TinaFieldZod).min(1).optional().superRefine((val, ctx) => {
+        const dups = findDuplicates(val == null ? void 0 : val.map((x) => x.name));
+        if (dups) {
+          ctx.addIssue({
+            code: z.z.ZodIssueCode.custom,
+            message: `Fields must have a unique name, duplicate field names: ${dups}`
+          });
+        }
+      }),
+      templates: z.z.array(TemplateTemp).min(1).optional().superRefine((val, ctx) => {
+        const dups = findDuplicates(val == null ? void 0 : val.map((x) => x.name));
+        if (dups) {
+          ctx.addIssue({
+            code: z.z.ZodIssueCode.custom,
+            message: `Templates must have a unique name, duplicate template names: ${dups}`
+          });
+        }
+      })
+    });
+    const RichTextField = FieldWithList.extend({
+      type: z.z.literal("rich-text", {
+        invalid_type_error: typeTypeError,
+        required_error: typeRequiredError
+      }),
+      templates: z.z.array(TemplateTemp).optional().superRefine((val, ctx) => {
+        const dups = findDuplicates(val == null ? void 0 : val.map((x) => x.name));
+        if (dups) {
+          ctx.addIssue({
+            code: z.z.ZodIssueCode.custom,
+            message: `Templates must have a unique name, duplicate template names: ${dups}`
+          });
+        }
+      })
+    });
+    return z.z.discriminatedUnion(
+      "type",
+      [
+        StringField,
+        BooleanField,
+        NumberField,
+        ImageField,
+        DateTimeField,
+        ReferenceField,
+        ObjectField,
+        RichTextField,
+        PasswordField
+      ],
+      {
+        errorMap: (issue, ctx) => {
+          var _a;
+          if (issue.code === "invalid_union_discriminator") {
+            return {
+              message: `Invalid \`type\` property. In the schema is 'type: ${(_a = ctx.data) == null ? void 0 : _a.type}' and expected one of ${TypeName.join(", ")}`
+            };
+          }
+          return {
+            message: issue.message || ""
+          };
+        }
+      }
+    ).superRefine((val, ctx) => {
+      if (val.type === "string") {
+        if (val.isTitle) {
+          if (val.list) {
+            ctx.addIssue({
+              code: z.z.ZodIssueCode.custom,
+              message: `Can not have \`list: true\` when using \`isTitle\`. Error in value 
+${JSON.stringify(
+                val,
+                null,
+                2
+              )}
+`
+            });
+          }
+          if (!val.required) {
+            ctx.addIssue({
+              code: z.z.ZodIssueCode.custom,
+              message: `Must have { required: true } when using \`isTitle\` Error in value 
+${JSON.stringify(
+                val,
+                null,
+                2
+              )}
+`
+            });
+          }
+        }
+        if (val.uid) {
+          if (val.list) {
+            ctx.addIssue({
+              code: z.z.ZodIssueCode.custom,
+              message: `Can not have \`list: true\` when using \`uid\`. Error in value 
+${JSON.stringify(
+                val,
+                null,
+                2
+              )}
+`
+            });
+          }
+          if (!val.required) {
+            ctx.addIssue({
+              code: z.z.ZodIssueCode.custom,
+              message: `Must have { required: true } when using \`uid\` Error in value 
+${JSON.stringify(
+                val,
+                null,
+                2
+              )}
+`
+            });
+          }
+        }
+      }
+      if (val.type === "object") {
+        const message = "Must provide one of templates or fields in your collection";
+        let isValid = Boolean(val == null ? void 0 : val.templates) || Boolean(val == null ? void 0 : val.fields);
+        if (!isValid) {
+          ctx.addIssue({
+            code: z.z.ZodIssueCode.custom,
+            message
+          });
+          return false;
+        } else {
+          isValid = !((val == null ? void 0 : val.templates) && (val == null ? void 0 : val.fields));
+          if (!isValid) {
+            ctx.addIssue({
+              code: z.z.ZodIssueCode.custom,
+              message
+            });
+          }
+          return isValid;
+        }
+      }
+      return true;
+    });
+  });
+  const tinaConfigKey = z.object({
+    publicFolder: z.string(),
+    mediaRoot: z.string(),
+    static: z.boolean().nullish()
+  }).strict().optional();
+  const tinaSearchKey = z.object({
+    indexerToken: z.string().optional(),
+    stopwordLanguages: z.array(z.string()).nonempty().optional(),
+    tokenSplitRegex: z.string().optional()
+  }).strict().optional();
+  const tinaConfigZod = z.object({
+    client: z.object({ referenceDepth: z.number().optional() }).optional(),
+    media: z.object({
+      tina: tinaConfigKey,
+      loadCustomStore: z.function().optional()
+    }).optional(),
+    search: z.object({
+      tina: tinaSearchKey,
+      searchClient: z.any().optional(),
+      indexBatchSize: z.number().gte(1).optional(),
+      maxSearchIndexFieldLength: z.number().gte(1).optional()
+    }).optional()
+  });
+  const validateTinaCloudSchemaConfig = (config) => {
+    const newConfig = tinaConfigZod.parse(config);
+    return newConfig;
+  };
+  const FORMATS = [
+    "json",
+    "md",
+    "markdown",
+    "mdx",
+    "toml",
+    "yaml",
+    "yml"
+  ];
+  const Template = z.z.object({
+    label: z.z.string({
+      invalid_type_error: "label must be a string",
+      required_error: "label was not provided but is required"
+    }),
+    name,
+    fields: z.z.array(TinaFieldZod)
+  }).superRefine((val, ctx) => {
+    var _a;
+    const dups = findDuplicates((_a = val.fields) == null ? void 0 : _a.map((x) => x.name));
+    if (dups) {
+      ctx.addIssue({
+        code: z.z.ZodIssueCode.custom,
+        message: `Fields must have a unique name, duplicate field names: ${dups}`
+      });
+    }
+  });
+  const CollectionBaseSchema = z.z.object({
+    label: z.z.string().optional(),
+    name: name.superRefine((val, ctx) => {
+      if (val === "relativePath") {
+        ctx.addIssue({
+          code: z.z.ZodIssueCode.custom,
+          message: `name cannot be 'relativePath'. 'relativePath' is a reserved field name.`
+        });
+      }
+    }),
+    path: z.z.string().transform((val) => val.replace(/^\/|\/$/g, "")).superRefine((val, ctx) => {
+      if (val === ".") {
+        ctx.addIssue({
+          code: z.z.ZodIssueCode.custom,
+          message: `path cannot be '.'. Please use '/' or '' instead. `
+        });
+      }
+    }),
+    format: z.z.enum(FORMATS).optional(),
+    isAuthCollection: z.z.boolean().optional(),
+    isDetached: z.z.boolean().optional()
+  });
+  const TinaCloudCollection = CollectionBaseSchema.extend({
+    fields: z.z.array(TinaFieldZod).min(1).optional().superRefine((val, ctx) => {
+      const dups = findDuplicates(val == null ? void 0 : val.map((x) => x.name));
+      if (dups) {
+        ctx.addIssue({
+          code: z.z.ZodIssueCode.custom,
+          message: `Fields must have a unique name, duplicate field names: ${dups}`
+        });
+      }
+    }).refine(
+      // It is valid if it is 0 or 1
+      (val) => {
+        const arr = (val == null ? void 0 : val.filter((x) => x.type === "string" && x.isTitle)) || [];
+        return arr.length < 2;
+      },
+      {
+        message: "Fields can only have one use of `isTitle`"
+      }
+    ).refine(
+      // It is valid if it is 0 or 1
+      (val) => {
+        const arr = (val == null ? void 0 : val.filter((x) => x.uid)) || [];
+        return arr.length < 2;
+      },
+      {
+        message: "Fields can only have one use of `uid`"
+      }
+    ).refine(
+      // It is valid if it is 0 or 1
+      (val) => {
+        const arr = (val == null ? void 0 : val.filter((x) => x.type === "password")) || [];
+        return arr.length < 2;
+      },
+      {
+        message: "Fields can only have one use of `password` type"
+      }
+    ),
+    templates: z.z.array(Template).min(1).optional().superRefine((val, ctx) => {
+      const dups = findDuplicates(val == null ? void 0 : val.map((x) => x.name));
+      if (dups) {
+        ctx.addIssue({
+          code: z.z.ZodIssueCode.custom,
+          message: `Templates must have a unique name, duplicate template names: ${dups}`
+        });
+      }
+    })
+  }).refine(
+    (val) => {
+      let isValid = Boolean(val == null ? void 0 : val.templates) || Boolean(val == null ? void 0 : val.fields);
+      if (!isValid) {
+        return false;
+      } else {
+        isValid = !((val == null ? void 0 : val.templates) && (val == null ? void 0 : val.fields));
+        return isValid;
+      }
+    },
+    { message: "Must provide one of templates or fields in your collection" }
+  );
+  const TinaCloudSchemaZod = z.z.object({
+    collections: z.z.array(TinaCloudCollection),
+    config: tinaConfigZod.optional()
+  }).superRefine((val, ctx) => {
+    var _a, _b, _c, _d;
+    const dups = findDuplicates((_a = val.collections) == null ? void 0 : _a.map((x) => x.name));
+    if (dups) {
+      ctx.addIssue({
+        code: z.z.ZodIssueCode.custom,
+        message: `${dups} are duplicate names in your collections. Collection names must be unique.`,
+        fatal: true
+      });
+    }
+    if (((_b = val.collections) == null ? void 0 : _b.filter((x) => x.isAuthCollection).length) > 1) {
+      ctx.addIssue({
+        code: z.z.ZodIssueCode.custom,
+        message: `Only one collection can be marked as isAuthCollection`,
+        fatal: true
+      });
+    }
+    const media = (_c = val == null ? void 0 : val.config) == null ? void 0 : _c.media;
+    if (media && media.tina && media.loadCustomStore) {
+      ctx.addIssue({
+        code: z.z.ZodIssueCode.custom,
+        message: "can not have both loadCustomStore and tina. Must use one or the other",
+        fatal: true,
+        path: ["config", "media"]
+      });
+    }
+    const search = (_d = val == null ? void 0 : val.config) == null ? void 0 : _d.search;
+    if (search && search.tina && search.searchClient) {
+      ctx.addIssue({
+        code: z.z.ZodIssueCode.custom,
+        message: "can not have both searchClient and tina. Must use one or the other",
+        fatal: true,
+        path: ["config", "search"]
+      });
+    }
+  });
+  class TinaSchemaValidationError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "TinaSchemaValidationError";
+    }
+  }
+  const validateSchema = ({ schema }) => {
+    try {
+      TinaCloudSchemaZod.parse(schema);
+    } catch (e) {
+      if (e instanceof z.ZodError) {
+        const errors = parseZodError({ zodError: e });
+        throw new TinaSchemaValidationError(errors.join(", \n"));
+      }
+      throw new Error(e);
+    }
+  };
+  exports2.NAMER = NAMER;
+  exports2.TINA_HOST = TINA_HOST;
+  exports2.TinaSchema = TinaSchema;
+  exports2.TinaSchemaValidationError = TinaSchemaValidationError;
+  exports2.addNamespaceToSchema = addNamespaceToSchema;
+  exports2.normalizePath = normalizePath;
+  exports2.parseURL = parseURL;
+  exports2.resolveField = resolveField;
+  exports2.resolveForm = resolveForm;
+  exports2.validateSchema = validateSchema;
+  exports2.validateTinaCloudSchemaConfig = validateTinaCloudSchemaConfig;
+  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+});