@tinacms/schema-tools 0.0.0-00d7b85-20251222014449

package/dist/index.js

@@ -0,0 +1,2789 @@
+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;
+};
+import * as yup from "yup";
+import UrlPattern from "url-pattern";
+import z$1, { z, ZodError } from "zod";
+function addNamespaceToSchema(maybeNode, namespace = []) {
+  if (typeof maybeNode !== "object" || maybeNode === null) {
+    return maybeNode;
+  }
+  const newNode = { ...maybeNode, namespace: [...namespace] };
+  Object.entries(maybeNode).forEach(([key, value]) => {
+    if (Array.isArray(value)) {
+      newNode[key] = value.map((element) => {
+        if (element && typeof element === "object" && "name" in element) {
+          const valueName = element.name || element.value;
+          return addNamespaceToSchema(element, [...namespace, valueName]);
+        }
+        return element;
+      });
+    } else if (value && typeof value === "object" && "name" in value) {
+      newNode[key] = addNamespaceToSchema(value, [...namespace, value.name]);
+    } else {
+      newNode[key] = value;
+    }
+  });
+  return newNode;
+}
+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;
+  };
+  exports.removeBackslashes = (str) => {
+    return str.replace(REGEX_REMOVE_BACKSLASH, (match) => {
+      return match === "\\" ? "" : match;
+    });
+  };
+  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)}`;
+  };
+  exports.removePrefix = (input, state = {}) => {
+    let output = input;
+    if (output.startsWith("./")) {
+      output = output.slice(2);
+      state.prefix = "./";
+    }
+    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;
+  };
+  exports.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);
+  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, "/");
+const canonicalPath = (filepath) => {
+  return normalizePath(filepath).split("/").filter((name2) => name2 !== "").join("/");
+};
+class TinaSchema {
+  /**
+   * Create a schema class from a user defined schema object
+   */
+  constructor(config) {
+    __publicField(this, "schema");
+    __publicField(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;
+    });
+    __publicField(this, "getCollectionsByName", (collectionNames) => {
+      return this.schema.collections.filter(
+        (collection) => collectionNames.includes(collection.name)
+      );
+    });
+    __publicField(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"
+      };
+    });
+    __publicField(this, "getCollections", () => {
+      return this.schema.collections.map(
+        (collection) => this.getCollection(collection.name)
+      ) || [];
+    });
+    __publicField(this, "getCollectionByFullPath", (filepath) => {
+      const fileExtension = filepath.split(".").pop();
+      const canonicalFilepath = canonicalPath(filepath);
+      const possibleCollections = this.getCollections().filter((collection) => {
+        var _a, _b;
+        if (!canonicalFilepath.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(canonicalFilepath, matches);
+          if (!match) {
+            return false;
+          }
+        }
+        const collectionPath = canonicalPath(collection.path);
+        return collectionPath === "" || canonicalFilepath.startsWith(`${collectionPath}/`);
+      });
+      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;
+      }
+    });
+    __publicField(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 };
+    });
+    __publicField(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;
+        }
+      }
+    });
+    __publicField(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)
+      };
+    });
+    __publicField(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;
+    });
+    __publicField(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;
+      }
+    });
+    __publicField(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;
+    });
+    /**
+     * Gets the template or templates from the item.
+     * Both `object` fields and collections support
+     * the ability for an object to be polymorphic,
+     * and if it is, we need to build unions, which
+     * are more of a headache for non-polymorphic
+     * needs, so we also need the ability to just
+     * build object types
+     *
+     *
+     */
+    __publicField(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(
+              "_"
+            )}`
+          );
+        }
+      }
+    });
+    /**
+     * Walk all fields in Tina Schema
+     *
+     * This is a legacy version to preserve backwards compatibility for the tina generated schema. It does not
+     * traverse fields in object lists in rich-text templates.
+     *
+     * @param cb callback function invoked for each field
+     */
+    __publicField(this, "legacyWalkFields", (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.config = config;
+    this.schema = config;
+    this.legacyWalkFields(({ field, collection }) => {
+      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;
+    });
+  }
+  findReferencesFromCollection(name2) {
+    const result = {};
+    this.walkFields(({ field, collection: c, path }) => {
+      if (c.name !== name2) {
+        return;
+      }
+      if (field.type === "reference") {
+        field.collections.forEach((name22) => {
+          if (result[name22] === void 0) {
+            result[name22] = [];
+          }
+          result[name22].push(path);
+        });
+      }
+    });
+    return result;
+  }
+  /**
+   * Walk all fields in tina schema
+   *
+   * @param cb callback function invoked for each field
+   */
+  walkFields(cb) {
+    const walk = (collectionOrObject, collection, path = "$") => {
+      if (collectionOrObject.templates) {
+        collectionOrObject.templates.forEach((template) => {
+          const templatePath = `${path}.${template.name}`;
+          template.fields.forEach((field) => {
+            const fieldPath = field.list ? `${templatePath}[*].${field.name}` : `${templatePath}.${field.name}`;
+            cb({ field, collection, path: fieldPath });
+            if (field.type === "object") {
+              walk(field, collection, fieldPath);
+            }
+          });
+        });
+      }
+      if (collectionOrObject.fields) {
+        collectionOrObject.fields.forEach((field) => {
+          const fieldPath = field.list ? `${path}.${field.name}[*]` : `${path}.${field.name}`;
+          cb({ field, collection, path: fieldPath });
+          if (field.type === "object" && field.fields) {
+            walk(field, collection, fieldPath);
+          } else if (field.templates) {
+            field.templates.forEach((template) => {
+              const templatePath = `${fieldPath}.${template.name}`;
+              template.fields.forEach((field2) => {
+                const fieldPath2 = field2.list ? `${templatePath}[*].${field2.name}` : `${templatePath}.${field2.name}`;
+                cb({ field: field2, collection, path: fieldPath2 });
+                if (field2.type === "object") {
+                  walk(field2, collection, fieldPath2);
+                }
+              });
+            });
+          }
+        });
+      }
+    };
+    this.getCollections().forEach((collection) => {
+      walk(collection, collection);
+    });
+  }
+  /**
+   * 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 collectionPath = canonicalPath(collection.path);
+    const pathSuffix = collectionPath ? "/" : "";
+    const format = collection.format || "md";
+    const matches = [];
+    if ((_a = collection == null ? void 0 : collection.match) == null ? void 0 : _a.include) {
+      const match = `${collectionPath}${pathSuffix}${collection.match.include}.${format}`;
+      matches.push(match);
+    }
+    if ((_b = collection == null ? void 0 : collection.match) == null ? void 0 : _b.exclude) {
+      const exclude = `!(${collectionPath}${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 CONTENT_FORMATS = [
+  "mdx",
+  "md",
+  "markdown",
+  "json",
+  "yaml",
+  "yml",
+  "toml"
+];
+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 = `${issue == null ? void 0 : issue.message}
+Additional information: 
+	- Error found 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.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 duplicateFieldErrorMessage = (fields) => `Fields must have unique names. Found duplicate field names: [${fields}]`;
+const duplicateTemplateErrorMessage = (templates) => `Templates must have unique names. Found duplicate template names: [${templates}]`;
+const duplicateCollectionErrorMessage = (collection) => `Collections must have unique names. Found duplicate collection names: [${collection}]`;
+const TypeName = [
+  "string",
+  "boolean",
+  "number",
+  "datetime",
+  "image",
+  "object",
+  "reference",
+  "rich-text"
+];
+const formattedTypes = `  - ${TypeName.join("\n  - ")}`;
+const typeTypeError = `Invalid \`type\` property. \`type\` expected to be one of the following values:
+${formattedTypes}`;
+const typeRequiredError = `Missing \`type\` property. Please add a \`type\` property with one of the following:
+${formattedTypes}`;
+const Option = z.union(
+  [
+    z.string(),
+    z.object({ label: z.string(), value: z.string() }),
+    z.object({ icon: z.any(), value: 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.object({
+  name,
+  label: z.string().or(z.boolean()).optional(),
+  description: z.string().optional(),
+  required: z.boolean().optional()
+});
+const FieldWithList = TinaField.extend({ list: z.boolean().optional() });
+const TinaScalerBase = FieldWithList.extend({
+  options: z.array(Option).optional(),
+  uid: z.boolean().optional()
+});
+const StringField = TinaScalerBase.extend({
+  type: z.literal("string", {
+    invalid_type_error: typeTypeError,
+    required_error: typeRequiredError
+  }),
+  isTitle: z.boolean().optional()
+});
+const PasswordField = TinaScalerBase.extend({
+  type: z.literal("password", {
+    invalid_type_error: typeTypeError,
+    required_error: typeRequiredError
+  })
+});
+const BooleanField = TinaScalerBase.extend({
+  type: z.literal("boolean", {
+    invalid_type_error: typeTypeError,
+    required_error: typeRequiredError
+  })
+});
+const NumberField = TinaScalerBase.extend({
+  type: z.literal("number", {
+    invalid_type_error: typeTypeError,
+    required_error: typeRequiredError
+  })
+});
+const ImageField = TinaScalerBase.extend({
+  type: z.literal("image", {
+    invalid_type_error: typeTypeError,
+    required_error: typeRequiredError
+  }),
+  uploadDir: z.function().args(z.any()).returns(z.string()).optional()
+});
+const DateTimeField = TinaScalerBase.extend({
+  type: z.literal("datetime", {
+    invalid_type_error: typeTypeError,
+    required_error: typeRequiredError
+  }),
+  dateFormat: z.string().optional(),
+  timeFormat: z.string().optional()
+});
+const ReferenceField = FieldWithList.extend({
+  type: z.literal("reference", {
+    invalid_type_error: typeTypeError,
+    required_error: typeRequiredError
+  })
+});
+const TinaFieldZod = z.lazy(() => {
+  const TemplateTemp = z.object({
+    label: z.string().optional(),
+    name,
+    fields: z.array(TinaFieldZod),
+    match: z.object({
+      start: z.string(),
+      end: z.string(),
+      name: 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.ZodIssueCode.custom,
+        message: duplicateFieldErrorMessage(dups)
+      });
+    }
+  });
+  const ObjectField = FieldWithList.extend({
+    // needs to be redefined here to avoid circle deps
+    type: z.literal("object", {
+      invalid_type_error: typeTypeError,
+      required_error: typeRequiredError
+    }),
+    fields: z.array(TinaFieldZod).min(1, "Property `fields` cannot be empty.").optional().superRefine((val, ctx) => {
+      const dups = findDuplicates(val == null ? void 0 : val.map((x) => x.name));
+      if (dups) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: duplicateFieldErrorMessage(dups)
+        });
+      }
+    }),
+    templates: z.array(TemplateTemp).min(1, "Property `templates` cannot be empty.").optional().superRefine((val, ctx) => {
+      const dups = findDuplicates(val == null ? void 0 : val.map((x) => x.name));
+      if (dups) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: duplicateTemplateErrorMessage(dups)
+        });
+      }
+    })
+  });
+  const RichTextField = FieldWithList.extend({
+    type: z.literal("rich-text", {
+      invalid_type_error: typeTypeError,
+      required_error: typeRequiredError
+    }),
+    templates: 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.ZodIssueCode.custom,
+          message: duplicateTemplateErrorMessage(dups)
+        });
+      }
+    })
+  });
+  return z.discriminatedUnion(
+    "type",
+    [
+      StringField,
+      BooleanField,
+      NumberField,
+      ImageField,
+      DateTimeField,
+      ReferenceField,
+      ObjectField,
+      RichTextField,
+      PasswordField
+    ],
+    {
+      errorMap: (issue, ctx) => {
+        var _a, _b;
+        if (issue.code === "invalid_union_discriminator") {
+          if (!((_a = ctx.data) == null ? void 0 : _a.type)) {
+            return {
+              message: `Missing \`type\` property in field \`${ctx.data.name}\`. Please add a \`type\` property with one of the following:
+${formattedTypes}`
+            };
+          }
+          return {
+            message: `Invalid \`type\` property in field \`${ctx.data.name}\`. In the schema is 'type: ${(_b = ctx.data) == null ? void 0 : _b.type}' but expected one of the following:
+${formattedTypes}`
+          };
+        }
+        return {
+          message: issue.message || ""
+        };
+      }
+    }
+  ).superRefine((val, ctx) => {
+    if (val.type === "string") {
+      const stringifiedField = JSON.stringify(val, null, 2);
+      if (val.isTitle && val.list) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `\`list: true\` is not allowed when using \`isTitle\` for fields of \`type: string\`. Error found in field:
+${stringifiedField}`
+        });
+      }
+      if (val.isTitle && !val.required) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `Property \`required: true\` is required when using \`isTitle\` for fields of \`type: string\`. Error found in field:
+${stringifiedField}`
+        });
+      }
+      if (val.uid && val.list) {
+        if (val.list) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `\`list: true\` is not allowed when using \`uid\` for fields of \`type: string\`. Error found in field:
+${stringifiedField}`
+          });
+        }
+      }
+      if (val.uid && !val.required) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `Property \`required: true\` is required when using \`uid\` for fields of \`type: string\`. Error found in field:
+${stringifiedField}`
+        });
+      }
+    }
+    if (val.type === "object") {
+      if (!(val == null ? void 0 : val.templates) && !(val == null ? void 0 : val.fields)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: "Fields of `type: object` must have either `templates` or `fields` property."
+        });
+        return false;
+      }
+      if ((val == null ? void 0 : val.templates) && (val == null ? void 0 : val.fields)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: "Fields of `type: object` must have either `templates` or `fields` property, not both."
+        });
+        return false;
+      }
+    }
+    return true;
+  });
+});
+const tinaConfigKey = z$1.object({
+  publicFolder: z$1.string(),
+  mediaRoot: z$1.string(),
+  static: z$1.boolean().nullish()
+}).strict().optional();
+const tinaSearchKey = z$1.object({
+  indexerToken: z$1.string().optional(),
+  stopwordLanguages: z$1.array(z$1.string()).nonempty().optional(),
+  tokenSplitRegex: z$1.string().optional(),
+  fuzzyEnabled: z$1.boolean().optional(),
+  fuzzyOptions: z$1.object({
+    maxDistance: z$1.number().optional(),
+    minSimilarity: z$1.number().optional(),
+    maxResults: z$1.number().optional(),
+    useTranspositions: z$1.boolean().optional(),
+    caseSensitive: z$1.boolean().optional()
+  }).strict().optional()
+}).strict().optional();
+const tinaConfigZod = z$1.object({
+  client: z$1.object({ referenceDepth: z$1.number().optional() }).optional(),
+  media: z$1.object({
+    tina: tinaConfigKey,
+    loadCustomStore: z$1.function().optional()
+  }).optional(),
+  search: z$1.object({
+    tina: tinaSearchKey,
+    searchClient: z$1.any().optional(),
+    indexBatchSize: z$1.number().gte(1).optional(),
+    maxSearchIndexFieldLength: z$1.number().gte(1).optional()
+  }).optional(),
+  ui: z$1.object({
+    previewUrl: z$1.function().optional(),
+    optOutOfUpdateCheck: z$1.boolean().optional(),
+    regexValidation: z$1.object({
+      folderNameRegex: z$1.string().refine(
+        (val) => {
+          try {
+            new RegExp(val);
+            return true;
+          } catch (error) {
+            return false;
+          }
+        },
+        { message: "folderNameRegex is not a valid regex pattern" }
+      ).optional()
+    }).optional()
+  }).optional()
+});
+const validateTinaCloudSchemaConfig = (config) => {
+  const newConfig = tinaConfigZod.parse(config);
+  return newConfig;
+};
+const Template = z.object({
+  label: z.string({
+    invalid_type_error: "Invalid data type for property `label`. Must be of type `string`",
+    required_error: "Missing `label` property. Property `label` is required."
+  }),
+  name,
+  fields: 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.ZodIssueCode.custom,
+      message: duplicateFieldErrorMessage(dups)
+    });
+  }
+});
+const CollectionBaseSchema = z.object({
+  label: z.string().optional(),
+  name: name.superRefine((val, ctx) => {
+    if (val === "relativePath") {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Invalid `name` property. `name` cannot be 'relativePath' as it is a reserved field name."
+      });
+    }
+  }),
+  path: z.string().transform((val) => val.replace(/^\/|\/$/g, "")).superRefine((val, ctx) => {
+    if (val === ".") {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Invalid `path` property. `path` cannot be '.'. Please use '/' or '' instead."
+      });
+    }
+  }),
+  format: z.enum(CONTENT_FORMATS).optional(),
+  isAuthCollection: z.boolean().optional(),
+  isDetached: z.boolean().optional()
+});
+const TinaCloudCollection = CollectionBaseSchema.extend({
+  fields: z.array(TinaFieldZod).min(1, "Property `fields` cannot be empty.").optional().superRefine((val, ctx) => {
+    const dups = findDuplicates(val == null ? void 0 : val.map((x) => x.name));
+    if (dups) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: duplicateFieldErrorMessage(dups)
+      });
+    }
+  }).superRefine((val, ctx) => {
+    const arr = (val == null ? void 0 : val.filter((x) => x.type === "string" && x.isTitle)) || [];
+    if (arr.length > 1) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `The following fields have the property \`isTitle\`: [${arr.map((field) => field.name).join(", ")}]. Only one can contain the property \`isTitle\`.`
+      });
+    }
+  }).superRefine((val, ctx) => {
+    const arr = (val == null ? void 0 : val.filter((x) => x.uid)) || [];
+    if (arr.length > 2) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `The following fields have the property \`uid\`: [${arr.map((field) => field.name).join(", ")}]. Only one can contain the property \`uid\`.`
+      });
+    }
+  }).superRefine((val, ctx) => {
+    const arr = (val == null ? void 0 : val.filter((x) => x.type === "password")) || [];
+    if (arr.length > 2) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `The following fields have \`type: password\`: [${arr.map((field) => field.name).join(", ")}]. Only one can be of \`type: password\`.`
+      });
+    }
+  }),
+  templates: z.array(Template).min(1, "Property `templates` cannot be empty.").optional().superRefine((val, ctx) => {
+    const dups = findDuplicates(val == null ? void 0 : val.map((x) => x.name));
+    if (dups) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: duplicateFieldErrorMessage(dups)
+      });
+    }
+  })
+}).superRefine((val, ctx) => {
+  if (!(val == null ? void 0 : val.templates) && !(val == null ? void 0 : val.fields)) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "Fields of `type: object` must have either `templates` or `fields` property."
+    });
+    return false;
+  }
+  if ((val == null ? void 0 : val.templates) && (val == null ? void 0 : val.fields)) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "Fields of `type: object` must have either `templates` or `fields` property, not both."
+    });
+    return false;
+  }
+});
+const TinaCloudSchemaZod = z.object({
+  collections: 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.ZodIssueCode.custom,
+      message: duplicateCollectionErrorMessage(dups),
+      fatal: true
+    });
+  }
+  if (((_b = val.collections) == null ? void 0 : _b.filter((x) => x.isAuthCollection).length) > 1) {
+    ctx.addIssue({
+      code: 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.ZodIssueCode.custom,
+      message: "Cannot 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.ZodIssueCode.custom,
+      message: "Cannot 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 ZodError) {
+      const errors = parseZodError({ zodError: e });
+      throw new TinaSchemaValidationError(errors.join("\n"));
+    }
+    throw new Error(e);
+  }
+};
+export {
+  CONTENT_FORMATS,
+  NAMER,
+  TINA_HOST,
+  TinaSchema,
+  TinaSchemaValidationError,
+  addNamespaceToSchema,
+  canonicalPath,
+  normalizePath,
+  parseURL,
+  resolveField,
+  resolveForm,
+  validateSchema,
+  validateTinaCloudSchemaConfig
+};