@caiquecamargo/vite-plugin-netlify-cms 0.0.1

package/dist/index.es.js

@@ -0,0 +1,1245 @@
+import "fs/promises";
+import { fileURLToPath as Ne } from "url";
+const Ae = {}, oe = Symbol.for("yaml.alias"), ke = Symbol.for("yaml.document"), D = Symbol.for("yaml.map"), ye = Symbol.for("yaml.pair"), le = Symbol.for("yaml.scalar"), q = Symbol.for("yaml.seq"), k = Symbol.for("yaml.node.type"), W = (t) => !!t && typeof t == "object" && t[k] === oe, fe = (t) => !!t && typeof t == "object" && t[k] === ke, we = (t) => !!t && typeof t == "object" && t[k] === D, j = (t) => !!t && typeof t == "object" && t[k] === ye, L = (t) => !!t && typeof t == "object" && t[k] === le, ce = (t) => !!t && typeof t == "object" && t[k] === q;
+function A(t) {
+  if (t && typeof t == "object")
+    switch (t[k]) {
+      case D:
+      case q:
+        return !0;
+    }
+  return !1;
+}
+function N(t) {
+  if (t && typeof t == "object")
+    switch (t[k]) {
+      case oe:
+      case D:
+      case le:
+      case q:
+        return !0;
+    }
+  return !1;
+}
+const Ce = (t) => (L(t) || A(t)) && !!t.anchor;
+class ae {
+  constructor(e) {
+    Object.defineProperty(this, k, { value: e });
+  }
+  /** Create a copy of this node.  */
+  clone() {
+    const e = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
+    return this.range && (e.range = this.range.slice()), e;
+  }
+}
+const B = Symbol("break visit"), Me = Symbol("skip children"), Q = Symbol("remove node");
+function V(t, e) {
+  const n = Pe(e);
+  fe(t) ? J(null, t.contents, n, Object.freeze([t])) === Q && (t.contents = null) : J(null, t, n, Object.freeze([]));
+}
+V.BREAK = B;
+V.SKIP = Me;
+V.REMOVE = Q;
+function J(t, e, n, s) {
+  const i = Ie(t, e, n, s);
+  if (N(i) || j(i))
+    return Be(t, s, i), J(t, i, n, s);
+  if (typeof i != "symbol") {
+    if (A(e)) {
+      s = Object.freeze(s.concat(e));
+      for (let r = 0; r < e.items.length; ++r) {
+        const o = J(r, e.items[r], n, s);
+        if (typeof o == "number")
+          r = o - 1;
+        else {
+          if (o === B)
+            return B;
+          o === Q && (e.items.splice(r, 1), r -= 1);
+        }
+      }
+    } else if (j(e)) {
+      s = Object.freeze(s.concat(e));
+      const r = J("key", e.key, n, s);
+      if (r === B)
+        return B;
+      r === Q && (e.key = null);
+      const o = J("value", e.value, n, s);
+      if (o === B)
+        return B;
+      o === Q && (e.value = null);
+    }
+  }
+  return i;
+}
+function Pe(t) {
+  return typeof t == "object" && (t.Collection || t.Node || t.Value) ? Object.assign({
+    Alias: t.Node,
+    Map: t.Node,
+    Scalar: t.Node,
+    Seq: t.Node
+  }, t.Value && {
+    Map: t.Value,
+    Scalar: t.Value,
+    Seq: t.Value
+  }, t.Collection && {
+    Map: t.Collection,
+    Seq: t.Collection
+  }, t) : t;
+}
+function Ie(t, e, n, s) {
+  if (typeof n == "function")
+    return n(t, e, s);
+  if (we(e))
+    return n.Map?.(t, e, s);
+  if (ce(e))
+    return n.Seq?.(t, e, s);
+  if (j(e))
+    return n.Pair?.(t, e, s);
+  if (L(e))
+    return n.Scalar?.(t, e, s);
+  if (W(e))
+    return n.Alias?.(t, e, s);
+}
+function Be(t, e, n) {
+  const s = e[e.length - 1];
+  if (A(s))
+    s.items[t] = n;
+  else if (j(s))
+    t === "key" ? s.key = n : s.value = n;
+  else if (fe(s))
+    s.contents = n;
+  else {
+    const i = W(s) ? "alias" : "scalar";
+    throw new Error(`Cannot replace node with ${i} parent`);
+  }
+}
+function Se(t) {
+  if (/[\x00-\x19\s,[\]{}]/.test(t)) {
+    const n = `Anchor must not contain whitespace or control characters: ${JSON.stringify(t)}`;
+    throw new Error(n);
+  }
+  return !0;
+}
+class Fe extends ae {
+  constructor(e) {
+    super(oe), this.source = e, Object.defineProperty(this, "tag", {
+      set() {
+        throw new Error("Alias nodes cannot have tags");
+      }
+    });
+  }
+  /**
+   * Resolve the value of this alias within `doc`, finding the last
+   * instance of the `source` anchor before this node.
+   */
+  resolve(e) {
+    let n;
+    return V(e, {
+      Node: (s, i) => {
+        if (i === this)
+          return V.BREAK;
+        i.anchor === this.source && (n = i);
+      }
+    }), n;
+  }
+  toJSON(e, n) {
+    if (!n)
+      return { source: this.source };
+    const { anchors: s, doc: i, maxAliasCount: r } = n, o = this.resolve(i);
+    if (!o) {
+      const l = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
+      throw new ReferenceError(l);
+    }
+    const f = s.get(o);
+    if (!f || f.res === void 0) {
+      const l = "This should not happen: Alias anchor was not resolved?";
+      throw new ReferenceError(l);
+    }
+    if (r >= 0 && (f.count += 1, f.aliasCount === 0 && (f.aliasCount = z(i, o, s)), f.count * f.aliasCount > r)) {
+      const l = "Excessive alias count indicates a resource exhaustion attack";
+      throw new ReferenceError(l);
+    }
+    return f.res;
+  }
+  toString(e, n, s) {
+    const i = `*${this.source}`;
+    if (e) {
+      if (Se(this.source), e.options.verifyAliasOrder && !e.anchors.has(this.source)) {
+        const r = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
+        throw new Error(r);
+      }
+      if (e.implicitKey)
+        return `${i} `;
+    }
+    return i;
+  }
+}
+function z(t, e, n) {
+  if (W(e)) {
+    const s = e.resolve(t), i = n && s && n.get(s);
+    return i ? i.count * i.aliasCount : 0;
+  } else if (A(e)) {
+    let s = 0;
+    for (const i of e.items) {
+      const r = z(t, i, n);
+      r > s && (s = r);
+    }
+    return s;
+  } else if (j(e)) {
+    const s = z(t, e.key, n), i = z(t, e.value, n);
+    return Math.max(s, i);
+  }
+  return 1;
+}
+function C(t, e, n) {
+  if (Array.isArray(t))
+    return t.map((s, i) => C(s, String(i), n));
+  if (t && typeof t.toJSON == "function") {
+    if (!n || !Ce(t))
+      return t.toJSON(e, n);
+    const s = { aliasCount: 0, count: 1, res: void 0 };
+    n.anchors.set(t, s), n.onCreate = (r) => {
+      s.res = r, delete n.onCreate;
+    };
+    const i = t.toJSON(e, n);
+    return n.onCreate && n.onCreate(i), i;
+  }
+  return typeof t == "bigint" && !n?.keep ? Number(t) : t;
+}
+const Oe = (t) => !t || typeof t != "function" && typeof t != "object";
+class E extends ae {
+  constructor(e) {
+    super(le), this.value = e;
+  }
+  toJSON(e, n) {
+    return n?.keep ? this.value : C(this.value, e, n);
+  }
+  toString() {
+    return String(this.value);
+  }
+}
+E.BLOCK_FOLDED = "BLOCK_FOLDED";
+E.BLOCK_LITERAL = "BLOCK_LITERAL";
+E.PLAIN = "PLAIN";
+E.QUOTE_DOUBLE = "QUOTE_DOUBLE";
+E.QUOTE_SINGLE = "QUOTE_SINGLE";
+const Te = "tag:yaml.org,2002:";
+function De(t, e, n) {
+  if (e) {
+    const s = n.filter((r) => r.tag === e), i = s.find((r) => !r.format) ?? s[0];
+    if (!i)
+      throw new Error(`Tag ${e} not found`);
+    return i;
+  }
+  return n.find((s) => s.identify?.(t) && !s.format);
+}
+function _e(t, e, n) {
+  if (fe(t) && (t = t.contents), N(t))
+    return t;
+  if (j(t)) {
+    const d = n.schema[D].createNode?.(n.schema, null, n);
+    return d.items.push(t), d;
+  }
+  (t instanceof String || t instanceof Number || t instanceof Boolean || typeof BigInt < "u" && t instanceof BigInt) && (t = t.valueOf());
+  const { aliasDuplicateObjects: s, onAnchor: i, onTagObj: r, schema: o, sourceObjects: f } = n;
+  let l;
+  if (s && t && typeof t == "object") {
+    if (l = f.get(t), l)
+      return l.anchor || (l.anchor = i(t)), new Fe(l.anchor);
+    l = { anchor: null, node: null }, f.set(t, l);
+  }
+  e?.startsWith("!!") && (e = Te + e.slice(2));
+  let u = De(t, e, o.tags);
+  if (!u) {
+    if (t && typeof t.toJSON == "function" && (t = t.toJSON()), !t || typeof t != "object") {
+      const d = new E(t);
+      return l && (l.node = d), d;
+    }
+    u = t instanceof Map ? o[D] : Symbol.iterator in Object(t) ? o[q] : o[D];
+  }
+  r && (r(u), delete n.onTagObj);
+  const b = u?.createNode ? u.createNode(n.schema, t, n) : new E(t);
+  return e && (b.tag = e), l && (l.node = b), b;
+}
+function pe(t, e, n) {
+  let s = n;
+  for (let i = e.length - 1; i >= 0; --i) {
+    const r = e[i];
+    if (typeof r == "number" && Number.isInteger(r) && r >= 0) {
+      const o = [];
+      o[r] = s, s = o;
+    } else
+      s = /* @__PURE__ */ new Map([[r, s]]);
+  }
+  return _e(s, void 0, {
+    aliasDuplicateObjects: !1,
+    keepUndefined: !1,
+    onAnchor: () => {
+      throw new Error("This should not happen, please report a bug.");
+    },
+    schema: t,
+    sourceObjects: /* @__PURE__ */ new Map()
+  });
+}
+const Je = (t) => t == null || typeof t == "object" && !!t[Symbol.iterator]().next().done;
+class v extends ae {
+  constructor(e, n) {
+    super(e), Object.defineProperty(this, "schema", {
+      value: n,
+      configurable: !0,
+      enumerable: !1,
+      writable: !0
+    });
+  }
+  /**
+   * Create a copy of this collection.
+   *
+   * @param schema - If defined, overwrites the original's schema
+   */
+  clone(e) {
+    const n = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
+    return e && (n.schema = e), n.items = n.items.map((s) => N(s) || j(s) ? s.clone(e) : s), this.range && (n.range = this.range.slice()), n;
+  }
+  /**
+   * Adds a value to the collection. For `!!map` and `!!omap` the value must
+   * be a Pair instance or a `{ key, value }` object, which may not have a key
+   * that already exists in the map.
+   */
+  addIn(e, n) {
+    if (Je(e))
+      this.add(n);
+    else {
+      const [s, ...i] = e, r = this.get(s, !0);
+      if (A(r))
+        r.addIn(i, n);
+      else if (r === void 0 && this.schema)
+        this.set(s, pe(this.schema, i, n));
+      else
+        throw new Error(`Expected YAML collection at ${s}. Remaining path: ${i}`);
+    }
+  }
+  /**
+   * Removes a value from the collection.
+   * @returns `true` if the item was found and removed.
+   */
+  deleteIn(e) {
+    const [n, ...s] = e;
+    if (s.length === 0)
+      return this.delete(n);
+    const i = this.get(n, !0);
+    if (A(i))
+      return i.deleteIn(s);
+    throw new Error(`Expected YAML collection at ${n}. Remaining path: ${s}`);
+  }
+  /**
+   * Returns item at `key`, or `undefined` if not found. By default unwraps
+   * scalar values from their surrounding node; to disable set `keepScalar` to
+   * `true` (collections are always returned intact).
+   */
+  getIn(e, n) {
+    const [s, ...i] = e, r = this.get(s, !0);
+    return i.length === 0 ? !n && L(r) ? r.value : r : A(r) ? r.getIn(i, n) : void 0;
+  }
+  hasAllNullValues(e) {
+    return this.items.every((n) => {
+      if (!j(n))
+        return !1;
+      const s = n.value;
+      return s == null || e && L(s) && s.value == null && !s.commentBefore && !s.comment && !s.tag;
+    });
+  }
+  /**
+   * Checks if the collection includes a value with the key `key`.
+   */
+  hasIn(e) {
+    const [n, ...s] = e;
+    if (s.length === 0)
+      return this.has(n);
+    const i = this.get(n, !0);
+    return A(i) ? i.hasIn(s) : !1;
+  }
+  /**
+   * Sets a value in this collection. For `!!set`, `value` needs to be a
+   * boolean to add/remove the item from the set.
+   */
+  setIn(e, n) {
+    const [s, ...i] = e;
+    if (i.length === 0)
+      this.set(s, n);
+    else {
+      const r = this.get(s, !0);
+      if (A(r))
+        r.setIn(i, n);
+      else if (r === void 0 && this.schema)
+        this.set(s, pe(this.schema, i, n));
+      else
+        throw new Error(`Expected YAML collection at ${s}. Remaining path: ${i}`);
+    }
+  }
+}
+v.maxFlowStringSingleLineLength = 60;
+const Ke = (t) => t.replace(/^(?!$)(?: $)?/gm, "#");
+function U(t, e) {
+  return /^\n+$/.test(t) ? t.substring(1) : e ? t.replace(/^(?! *$)/gm, e) : t;
+}
+const F = (t, e, n) => t.endsWith(`
+`) ? U(n, e) : n.includes(`
+`) ? `
+` + U(n, e) : (t.endsWith(" ") ? "" : " ") + n, $e = "flow", ie = "block", G = "quoted";
+function x(t, e, n = "flow", { indentAtStart: s, lineWidth: i = 80, minContentWidth: r = 20, onFold: o, onOverflow: f } = {}) {
+  if (!i || i < 0)
+    return t;
+  const l = Math.max(1 + r, 1 + i - e.length);
+  if (t.length <= l)
+    return t;
+  const u = [], b = {};
+  let d = i - e.length;
+  typeof s == "number" && (s > i - Math.max(2, r) ? u.push(0) : d = i - s);
+  let g, c, m = !1, a = -1, h = -1, S = -1;
+  n === ie && (a = me(t, a), a !== -1 && (d = a + l));
+  for (let y; y = t[a += 1]; ) {
+    if (n === G && y === "\\") {
+      switch (h = a, t[a + 1]) {
+        case "x":
+          a += 3;
+          break;
+        case "u":
+          a += 5;
+          break;
+        case "U":
+          a += 9;
+          break;
+        default:
+          a += 1;
+      }
+      S = a;
+    }
+    if (y === `
+`)
+      n === ie && (a = me(t, a)), d = a + l, g = void 0;
+    else {
+      if (y === " " && c && c !== " " && c !== `
+` && c !== "	") {
+        const w = t[a + 1];
+        w && w !== " " && w !== `
+` && w !== "	" && (g = a);
+      }
+      if (a >= d)
+        if (g)
+          u.push(g), d = g + l, g = void 0;
+        else if (n === G) {
+          for (; c === " " || c === "	"; )
+            c = y, y = t[a += 1], m = !0;
+          const w = a > S + 1 ? a - 2 : h - 1;
+          if (b[w])
+            return t;
+          u.push(w), b[w] = !0, d = w + l, g = void 0;
+        } else
+          m = !0;
+    }
+    c = y;
+  }
+  if (m && f && f(), u.length === 0)
+    return t;
+  o && o();
+  let p = t.slice(0, u[0]);
+  for (let y = 0; y < u.length; ++y) {
+    const w = u[y], O = u[y + 1] || t.length;
+    w === 0 ? p = `
+${e}${t.slice(0, O)}` : (n === G && b[w] && (p += `${t[w]}\\`), p += `
+${e}${t.slice(w + 1, O)}`);
+  }
+  return p;
+}
+function me(t, e) {
+  let n = t[e + 1];
+  for (; n === " " || n === "	"; ) {
+    do
+      n = t[e += 1];
+    while (n && n !== `
+`);
+    n = t[e + 1];
+  }
+  return e;
+}
+const ee = (t) => ({
+  indentAtStart: t.indentAtStart,
+  lineWidth: t.options.lineWidth,
+  minContentWidth: t.options.minContentWidth
+}), te = (t) => /^(%|---|\.\.\.)/m.test(t);
+function We(t, e, n) {
+  if (!e || e < 0)
+    return !1;
+  const s = e - n, i = t.length;
+  if (i <= s)
+    return !1;
+  for (let r = 0, o = 0; r < i; ++r)
+    if (t[r] === `
+`) {
+      if (r - o > s)
+        return !0;
+      if (o = r + 1, i - o <= s)
+        return !1;
+    }
+  return !0;
+}
+function R(t, e) {
+  const n = JSON.stringify(t);
+  if (e.options.doubleQuotedAsJSON)
+    return n;
+  const { implicitKey: s } = e, i = e.options.doubleQuotedMinMultiLineLength, r = e.indent || (te(t) ? "  " : "");
+  let o = "", f = 0;
+  for (let l = 0, u = n[l]; u; u = n[++l])
+    if (u === " " && n[l + 1] === "\\" && n[l + 2] === "n" && (o += n.slice(f, l) + "\\ ", l += 1, f = l, u = "\\"), u === "\\")
+      switch (n[l + 1]) {
+        case "u":
+          {
+            o += n.slice(f, l);
+            const b = n.substr(l + 2, 4);
+            switch (b) {
+              case "0000":
+                o += "\\0";
+                break;
+              case "0007":
+                o += "\\a";
+                break;
+              case "000b":
+                o += "\\v";
+                break;
+              case "001b":
+                o += "\\e";
+                break;
+              case "0085":
+                o += "\\N";
+                break;
+              case "00a0":
+                o += "\\_";
+                break;
+              case "2028":
+                o += "\\L";
+                break;
+              case "2029":
+                o += "\\P";
+                break;
+              default:
+                b.substr(0, 2) === "00" ? o += "\\x" + b.substr(2) : o += n.substr(l, 6);
+            }
+            l += 5, f = l + 1;
+          }
+          break;
+        case "n":
+          if (s || n[l + 2] === '"' || n.length < i)
+            l += 1;
+          else {
+            for (o += n.slice(f, l) + `
+
+`; n[l + 2] === "\\" && n[l + 3] === "n" && n[l + 4] !== '"'; )
+              o += `
+`, l += 2;
+            o += r, n[l + 2] === " " && (o += "\\"), l += 1, f = l + 1;
+          }
+          break;
+        default:
+          l += 1;
+      }
+  return o = f ? o + n.slice(f) : n, s ? o : x(o, r, G, ee(e));
+}
+function re(t, e) {
+  if (e.options.singleQuote === !1 || e.implicitKey && t.includes(`
+`) || /[ \t]\n|\n[ \t]/.test(t))
+    return R(t, e);
+  const n = e.indent || (te(t) ? "  " : ""), s = "'" + t.replace(/'/g, "''").replace(/\n+/g, `$&
+${n}`) + "'";
+  return e.implicitKey ? s : x(s, n, $e, ee(e));
+}
+function K(t, e) {
+  const { singleQuote: n } = e.options;
+  let s;
+  if (n === !1)
+    s = R;
+  else {
+    const i = t.includes('"'), r = t.includes("'");
+    i && !r ? s = re : r && !i ? s = R : s = n ? re : R;
+  }
+  return s(t, e);
+}
+function H({ comment: t, type: e, value: n }, s, i, r) {
+  const { blockQuote: o, commentString: f, lineWidth: l } = s.options;
+  if (!o || /\n[\t ]+$/.test(n) || /^\s*$/.test(n))
+    return K(n, s);
+  const u = s.indent || (s.forceBlockIndent || te(n) ? "  " : ""), b = o === "literal" ? !0 : o === "folded" || e === E.BLOCK_FOLDED ? !1 : e === E.BLOCK_LITERAL ? !0 : !We(n, l, u.length);
+  if (!n)
+    return b ? `|
+` : `>
+`;
+  let d, g;
+  for (g = n.length; g > 0; --g) {
+    const $ = n[g - 1];
+    if ($ !== `
+` && $ !== "	" && $ !== " ")
+      break;
+  }
+  let c = n.substring(g);
+  const m = c.indexOf(`
+`);
+  m === -1 ? d = "-" : n === c || m !== c.length - 1 ? (d = "+", r && r()) : d = "", c && (n = n.slice(0, -c.length), c[c.length - 1] === `
+` && (c = c.slice(0, -1)), c = c.replace(/\n+(?!\n|$)/g, `$&${u}`));
+  let a = !1, h, S = -1;
+  for (h = 0; h < n.length; ++h) {
+    const $ = n[h];
+    if ($ === " ")
+      a = !0;
+    else if ($ === `
+`)
+      S = h;
+    else
+      break;
+  }
+  let p = n.substring(0, S < h ? S + 1 : h);
+  p && (n = n.substring(p.length), p = p.replace(/\n+/g, `$&${u}`));
+  let w = (b ? "|" : ">") + (a ? u ? "2" : "1" : "") + d;
+  if (t && (w += " " + f(t.replace(/ ?[\r\n]+/g, " ")), i && i()), b)
+    return n = n.replace(/\n+/g, `$&${u}`), `${w}
+${u}${p}${n}${c}`;
+  n = n.replace(/\n+/g, `
+$&`).replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, "$1$2").replace(/\n+/g, `$&${u}`);
+  const O = x(`${p}${n}${c}`, u, ie, ee(s));
+  return `${w}
+${u}${O}`;
+}
+function Qe(t, e, n, s) {
+  const { type: i, value: r } = t, { actualString: o, implicitKey: f, indent: l, indentStep: u, inFlow: b } = e;
+  if (f && /[\n[\]{},]/.test(r) || b && /[[\]{},]/.test(r))
+    return K(r, e);
+  if (!r || /^[\n\t ,[\]{}#&*!|>'"%@`]|^[?-]$|^[?-][ \t]|[\n:][ \t]|[ \t]\n|[\n\t ]#|[\n\t :]$/.test(r))
+    return f || b || !r.includes(`
+`) ? K(r, e) : H(t, e, n, s);
+  if (!f && !b && i !== E.PLAIN && r.includes(`
+`))
+    return H(t, e, n, s);
+  if (te(r)) {
+    if (l === "")
+      return e.forceBlockIndent = !0, H(t, e, n, s);
+    if (f && l === u)
+      return K(r, e);
+  }
+  const d = r.replace(/\n+/g, `$&
+${l}`);
+  if (o) {
+    const g = (a) => a.default && a.tag !== "tag:yaml.org,2002:str" && a.test?.test(d), { compat: c, tags: m } = e.doc.schema;
+    if (m.some(g) || c?.some(g))
+      return K(r, e);
+  }
+  return f ? d : x(d, l, $e, ee(e));
+}
+function Re(t, e, n, s) {
+  const { implicitKey: i, inFlow: r } = e, o = typeof t.value == "string" ? t : Object.assign({}, t, { value: String(t.value) });
+  let { type: f } = t;
+  f !== E.QUOTE_DOUBLE && /[\x00-\x08\x0b-\x1f\x7f-\x9f\u{D800}-\u{DFFF}]/u.test(o.value) && (f = E.QUOTE_DOUBLE);
+  const l = (b) => {
+    switch (b) {
+      case E.BLOCK_FOLDED:
+      case E.BLOCK_LITERAL:
+        return i || r ? K(o.value, e) : H(o, e, n, s);
+      case E.QUOTE_DOUBLE:
+        return R(o.value, e);
+      case E.QUOTE_SINGLE:
+        return re(o.value, e);
+      case E.PLAIN:
+        return Qe(o, e, n, s);
+      default:
+        return null;
+    }
+  };
+  let u = l(f);
+  if (u === null) {
+    const { defaultKeyType: b, defaultStringType: d } = e.options, g = i && b || d;
+    if (u = l(g), u === null)
+      throw new Error(`Unsupported default string type ${g}`);
+  }
+  return u;
+}
+function Ve(t, e) {
+  const n = Object.assign({
+    blockQuote: !0,
+    commentString: Ke,
+    defaultKeyType: null,
+    defaultStringType: "PLAIN",
+    directives: null,
+    doubleQuotedAsJSON: !1,
+    doubleQuotedMinMultiLineLength: 40,
+    falseStr: "false",
+    flowCollectionPadding: !0,
+    indentSeq: !0,
+    lineWidth: 80,
+    minContentWidth: 20,
+    nullStr: "null",
+    simpleKeys: !1,
+    singleQuote: null,
+    trueStr: "true",
+    verifyAliasOrder: !0
+  }, t.schema.toStringOptions, e);
+  let s;
+  switch (n.collectionStyle) {
+    case "block":
+      s = !1;
+      break;
+    case "flow":
+      s = !0;
+      break;
+    default:
+      s = null;
+  }
+  return {
+    anchors: /* @__PURE__ */ new Set(),
+    doc: t,
+    flowCollectionPadding: n.flowCollectionPadding ? " " : "",
+    indent: "",
+    indentStep: typeof n.indent == "number" ? " ".repeat(n.indent) : "  ",
+    inFlow: s,
+    options: n
+  };
+}
+function Ue(t, e) {
+  if (e.tag) {
+    const i = t.filter((r) => r.tag === e.tag);
+    if (i.length > 0)
+      return i.find((r) => r.format === e.format) ?? i[0];
+  }
+  let n, s;
+  if (L(e)) {
+    s = e.value;
+    const i = t.filter((r) => r.identify?.(s));
+    n = i.find((r) => r.format === e.format) ?? i.find((r) => !r.format);
+  } else
+    s = e, n = t.find((i) => i.nodeClass && s instanceof i.nodeClass);
+  if (!n) {
+    const i = s?.constructor?.name ?? typeof s;
+    throw new Error(`Tag not resolved for ${i} value`);
+  }
+  return n;
+}
+function qe(t, e, { anchors: n, doc: s }) {
+  if (!s.directives)
+    return "";
+  const i = [], r = (L(t) || A(t)) && t.anchor;
+  r && Se(r) && (n.add(r), i.push(`&${r}`));
+  const o = t.tag ? t.tag : e.default ? null : e.tag;
+  return o && i.push(s.directives.tagString(o)), i.join(" ");
+}
+function X(t, e, n, s) {
+  if (j(t))
+    return t.toString(e, n, s);
+  if (W(t)) {
+    if (e.doc.directives)
+      return t.toString(e);
+    if (e.resolvedAliases?.has(t))
+      throw new TypeError("Cannot stringify circular structure without alias nodes");
+    e.resolvedAliases ? e.resolvedAliases.add(t) : e.resolvedAliases = /* @__PURE__ */ new Set([t]), t = t.resolve(e.doc);
+  }
+  let i;
+  const r = N(t) ? t : e.doc.createNode(t, { onTagObj: (l) => i = l });
+  i || (i = Ue(e.doc.schema.tags, r));
+  const o = qe(r, i, e);
+  o.length > 0 && (e.indentAtStart = (e.indentAtStart ?? 0) + o.length + 1);
+  const f = typeof i.stringify == "function" ? i.stringify(r, e, n, s) : L(r) ? Re(r, e, n, s) : r.toString(e, n, s);
+  return o ? L(r) || f[0] === "{" || f[0] === "[" ? `${o} ${f}` : `${o}
+${e.indent}${f}` : f;
+}
+function Ye({ key: t, value: e }, n, s, i) {
+  const { allNullValues: r, doc: o, indent: f, indentStep: l, options: { commentString: u, indentSeq: b, simpleKeys: d } } = n;
+  let g = N(t) && t.comment || null;
+  if (d) {
+    if (g)
+      throw new Error("With simple keys, key nodes cannot have comments");
+    if (A(t)) {
+      const P = "With simple keys, collection cannot be used as a key value";
+      throw new Error(P);
+    }
+  }
+  let c = !d && (!t || g && e == null && !n.inFlow || A(t) || (L(t) ? t.type === E.BLOCK_FOLDED || t.type === E.BLOCK_LITERAL : typeof t == "object"));
+  n = Object.assign({}, n, {
+    allNullValues: !1,
+    implicitKey: !c && (d || !r),
+    indent: f + l
+  });
+  let m = !1, a = !1, h = X(t, n, () => m = !0, () => a = !0);
+  if (!c && !n.inFlow && h.length > 1024) {
+    if (d)
+      throw new Error("With simple keys, single line scalar must not span more than 1024 characters");
+    c = !0;
+  }
+  if (n.inFlow) {
+    if (r || e == null)
+      return m && s && s(), h === "" ? "?" : c ? `? ${h}` : h;
+  } else if (r && !d || e == null && c)
+    return h = `? ${h}`, g && !m ? h += F(h, n.indent, u(g)) : a && i && i(), h;
+  m && (g = null), c ? (g && (h += F(h, n.indent, u(g))), h = `? ${h}
+${f}:`) : (h = `${h}:`, g && (h += F(h, n.indent, u(g))));
+  let S, p, y;
+  N(e) ? (S = !!e.spaceBefore, p = e.commentBefore, y = e.comment) : (S = !1, p = null, y = null, e && typeof e == "object" && (e = o.createNode(e))), n.implicitKey = !1, !c && !g && L(e) && (n.indentAtStart = h.length + 1), a = !1, !b && l.length >= 2 && !n.inFlow && !c && ce(e) && !e.flow && !e.tag && !e.anchor && (n.indent = n.indent.substring(2));
+  let w = !1;
+  const O = X(e, n, () => w = !0, () => a = !0);
+  let $ = " ";
+  if (g || S || p) {
+    if ($ = S ? `
+` : "", p) {
+      const P = u(p);
+      $ += `
+${U(P, n.indent)}`;
+    }
+    O === "" && !n.inFlow ? $ === `
+` && ($ = `
+
+`) : $ += `
+${n.indent}`;
+  } else if (!c && A(e)) {
+    const P = O[0], ne = O.indexOf(`
+`), ge = ne !== -1, je = n.inFlow ?? e.flow ?? e.items.length === 0;
+    if (ge || !je) {
+      let he = !1;
+      if (ge && (P === "&" || P === "!")) {
+        let I = O.indexOf(" ");
+        P === "&" && I !== -1 && I < ne && O[I + 1] === "!" && (I = O.indexOf(" ", I + 1)), (I === -1 || ne < I) && (he = !0);
+      }
+      he || ($ = `
+${n.indent}`);
+    }
+  } else
+    (O === "" || O[0] === `
+`) && ($ = "");
+  return h += $ + O, n.inFlow ? w && s && s() : y && !w ? h += F(h, n.indent, u(y)) : a && i && i(), h;
+}
+function ze(t, e) {
+  (t === "debug" || t === "warn") && (typeof process < "u" && process.emitWarning ? process.emitWarning(e) : console.warn(e));
+}
+const be = "<<";
+function Ee(t, e, { key: n, value: s }) {
+  if (t?.doc.schema.merge && Ge(n))
+    if (s = W(s) ? s.resolve(t.doc) : s, ce(s))
+      for (const i of s.items)
+        se(t, e, i);
+    else if (Array.isArray(s))
+      for (const i of s)
+        se(t, e, i);
+    else
+      se(t, e, s);
+  else {
+    const i = C(n, "", t);
+    if (e instanceof Map)
+      e.set(i, C(s, i, t));
+    else if (e instanceof Set)
+      e.add(i);
+    else {
+      const r = He(n, i, t), o = C(s, r, t);
+      r in e ? Object.defineProperty(e, r, {
+        value: o,
+        writable: !0,
+        enumerable: !0,
+        configurable: !0
+      }) : e[r] = o;
+    }
+  }
+  return e;
+}
+const Ge = (t) => t === be || L(t) && t.value === be && (!t.type || t.type === E.PLAIN);
+function se(t, e, n) {
+  const s = t && W(n) ? n.resolve(t.doc) : n;
+  if (!we(s))
+    throw new Error("Merge sources must be maps or map aliases");
+  const i = s.toJSON(null, t, Map);
+  for (const [r, o] of i)
+    e instanceof Map ? e.has(r) || e.set(r, o) : e instanceof Set ? e.add(r) : Object.prototype.hasOwnProperty.call(e, r) || Object.defineProperty(e, r, {
+      value: o,
+      writable: !0,
+      enumerable: !0,
+      configurable: !0
+    });
+  return e;
+}
+function He(t, e, n) {
+  if (e === null)
+    return "";
+  if (typeof e != "object")
+    return String(e);
+  if (N(t) && n && n.doc) {
+    const s = Ve(n.doc, {});
+    s.anchors = /* @__PURE__ */ new Set();
+    for (const r of n.anchors.keys())
+      s.anchors.add(r.anchor);
+    s.inFlow = !0, s.inStringifyKey = !0;
+    const i = t.toString(s);
+    if (!n.mapKeyWarned) {
+      let r = JSON.stringify(i);
+      r.length > 40 && (r = r.substring(0, 36) + '..."'), ze(n.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${r}. Set mapAsMap: true to use object keys.`), n.mapKeyWarned = !0;
+    }
+    return i;
+  }
+  return JSON.stringify(e);
+}
+class M {
+  constructor(e, n = null) {
+    Object.defineProperty(this, k, { value: ye }), this.key = e, this.value = n;
+  }
+  clone(e) {
+    let { key: n, value: s } = this;
+    return N(n) && (n = n.clone(e)), N(s) && (s = s.clone(e)), new M(n, s);
+  }
+  toJSON(e, n) {
+    const s = n?.mapAsMap ? /* @__PURE__ */ new Map() : {};
+    return Ee(n, s, this);
+  }
+  toString(e, n, s) {
+    return e?.doc ? Ye(this, e, n, s) : JSON.stringify(this);
+  }
+}
+function Le(t, e, n) {
+  return (e.inFlow ?? t.flow ? Ze : Xe)(t, e, n);
+}
+function Xe({ comment: t, items: e }, n, { blockItemPrefix: s, flowChars: i, itemIndent: r, onChompKeep: o, onComment: f }) {
+  const { indent: l, options: { commentString: u } } = n, b = Object.assign({}, n, { indent: r, type: null });
+  let d = !1;
+  const g = [];
+  for (let m = 0; m < e.length; ++m) {
+    const a = e[m];
+    let h = null;
+    if (N(a))
+      !d && a.spaceBefore && g.push(""), Z(n, g, a.commentBefore, d), a.comment && (h = a.comment);
+    else if (j(a)) {
+      const p = N(a.key) ? a.key : null;
+      p && (!d && p.spaceBefore && g.push(""), Z(n, g, p.commentBefore, d));
+    }
+    d = !1;
+    let S = X(a, b, () => h = null, () => d = !0);
+    h && (S += F(S, r, u(h))), d && h && (d = !1), g.push(s + S);
+  }
+  let c;
+  if (g.length === 0)
+    c = i.start + i.end;
+  else {
+    c = g[0];
+    for (let m = 1; m < g.length; ++m) {
+      const a = g[m];
+      c += a ? `
+${l}${a}` : `
+`;
+    }
+  }
+  return t ? (c += `
+` + U(u(t), l), f && f()) : d && o && o(), c;
+}
+function Ze({ comment: t, items: e }, n, { flowChars: s, itemIndent: i, onComment: r }) {
+  const { indent: o, indentStep: f, flowCollectionPadding: l, options: { commentString: u } } = n;
+  i += f;
+  const b = Object.assign({}, n, {
+    indent: i,
+    inFlow: !0,
+    type: null
+  });
+  let d = !1, g = 0;
+  const c = [];
+  for (let S = 0; S < e.length; ++S) {
+    const p = e[S];
+    let y = null;
+    if (N(p))
+      p.spaceBefore && c.push(""), Z(n, c, p.commentBefore, !1), p.comment && (y = p.comment);
+    else if (j(p)) {
+      const O = N(p.key) ? p.key : null;
+      O && (O.spaceBefore && c.push(""), Z(n, c, O.commentBefore, !1), O.comment && (d = !0));
+      const $ = N(p.value) ? p.value : null;
+      $ ? ($.comment && (y = $.comment), $.commentBefore && (d = !0)) : p.value == null && O && O.comment && (y = O.comment);
+    }
+    y && (d = !0);
+    let w = X(p, b, () => y = null);
+    S < e.length - 1 && (w += ","), y && (w += F(w, i, u(y))), !d && (c.length > g || w.includes(`
+`)) && (d = !0), c.push(w), g = c.length;
+  }
+  let m;
+  const { start: a, end: h } = s;
+  if (c.length === 0)
+    m = a + h;
+  else if (d || (d = c.reduce((p, y) => p + y.length + 2, 2) > v.maxFlowStringSingleLineLength), d) {
+    m = a;
+    for (const S of c)
+      m += S ? `
+${f}${o}${S}` : `
+`;
+    m += `
+${o}${h}`;
+  } else
+    m = `${a}${l}${c.join(" ")}${l}${h}`;
+  return t && (m += F(m, u(t), o), r && r()), m;
+}
+function Z({ indent: t, options: { commentString: e } }, n, s, i) {
+  if (s && i && (s = s.replace(/^\n+/, "")), s) {
+    const r = U(e(s), t);
+    n.push(r.trimStart());
+  }
+}
+function T(t, e) {
+  const n = L(e) ? e.value : e;
+  for (const s of t)
+    if (j(s) && (s.key === e || s.key === n || L(s.key) && s.key.value === n))
+      return s;
+}
+class _ extends v {
+  static get tagName() {
+    return "tag:yaml.org,2002:map";
+  }
+  constructor(e) {
+    super(D, e), this.items = [];
+  }
+  /**
+   * Adds a value to the collection.
+   *
+   * @param overwrite - If not set `true`, using a key that is already in the
+   *   collection will throw. Otherwise, overwrites the previous value.
+   */
+  add(e, n) {
+    let s;
+    j(e) ? s = e : !e || typeof e != "object" || !("key" in e) ? s = new M(e, e?.value) : s = new M(e.key, e.value);
+    const i = T(this.items, s.key), r = this.schema?.sortMapEntries;
+    if (i) {
+      if (!n)
+        throw new Error(`Key ${s.key} already set`);
+      L(i.value) && Oe(s.value) ? i.value.value = s.value : i.value = s.value;
+    } else if (r) {
+      const o = this.items.findIndex((f) => r(s, f) < 0);
+      o === -1 ? this.items.push(s) : this.items.splice(o, 0, s);
+    } else
+      this.items.push(s);
+  }
+  delete(e) {
+    const n = T(this.items, e);
+    return n ? this.items.splice(this.items.indexOf(n), 1).length > 0 : !1;
+  }
+  get(e, n) {
+    const i = T(this.items, e)?.value;
+    return (!n && L(i) ? i.value : i) ?? void 0;
+  }
+  has(e) {
+    return !!T(this.items, e);
+  }
+  set(e, n) {
+    this.add(new M(e, n), !0);
+  }
+  /**
+   * @param ctx - Conversion context, originally set in Document#toJS()
+   * @param {Class} Type - If set, forces the returned collection type
+   * @returns Instance of Type, Map, or Object
+   */
+  toJSON(e, n, s) {
+    const i = s ? new s() : n?.mapAsMap ? /* @__PURE__ */ new Map() : {};
+    n?.onCreate && n.onCreate(i);
+    for (const r of this.items)
+      Ee(n, i, r);
+    return i;
+  }
+  toString(e, n, s) {
+    if (!e)
+      return JSON.stringify(this);
+    for (const i of this.items)
+      if (!j(i))
+        throw new Error(`Map items must all be pairs; found ${JSON.stringify(i)} instead`);
+    return !e.allNullValues && this.hasAllNullValues(!1) && (e = Object.assign({}, e, { allNullValues: !0 })), Le(this, e, {
+      blockItemPrefix: "",
+      flowChars: { start: "{", end: "}" },
+      itemIndent: e.indent || "",
+      onChompKeep: s,
+      onComment: n
+    });
+  }
+}
+class ve extends v {
+  static get tagName() {
+    return "tag:yaml.org,2002:seq";
+  }
+  constructor(e) {
+    super(q, e), this.items = [];
+  }
+  add(e) {
+    this.items.push(e);
+  }
+  /**
+   * Removes a value from the collection.
+   *
+   * `key` must contain a representation of an integer for this to succeed.
+   * It may be wrapped in a `Scalar`.
+   *
+   * @returns `true` if the item was found and removed.
+   */
+  delete(e) {
+    const n = Y(e);
+    return typeof n != "number" ? !1 : this.items.splice(n, 1).length > 0;
+  }
+  get(e, n) {
+    const s = Y(e);
+    if (typeof s != "number")
+      return;
+    const i = this.items[s];
+    return !n && L(i) ? i.value : i;
+  }
+  /**
+   * Checks if the collection includes a value with the key `key`.
+   *
+   * `key` must contain a representation of an integer for this to succeed.
+   * It may be wrapped in a `Scalar`.
+   */
+  has(e) {
+    const n = Y(e);
+    return typeof n == "number" && n < this.items.length;
+  }
+  /**
+   * Sets a value in this collection. For `!!set`, `value` needs to be a
+   * boolean to add/remove the item from the set.
+   *
+   * If `key` does not contain a representation of an integer, this will throw.
+   * It may be wrapped in a `Scalar`.
+   */
+  set(e, n) {
+    const s = Y(e);
+    if (typeof s != "number")
+      throw new Error(`Expected a valid index, not ${e}.`);
+    const i = this.items[s];
+    L(i) && Oe(n) ? i.value = n : this.items[s] = n;
+  }
+  toJSON(e, n) {
+    const s = [];
+    n?.onCreate && n.onCreate(s);
+    let i = 0;
+    for (const r of this.items)
+      s.push(C(r, String(i++), n));
+    return s;
+  }
+  toString(e, n, s) {
+    return e ? Le(this, e, {
+      blockItemPrefix: "- ",
+      flowChars: { start: "[", end: "]" },
+      itemIndent: (e.indent || "") + "  ",
+      onChompKeep: s,
+      onComment: n
+    }) : JSON.stringify(this);
+  }
+}
+function Y(t) {
+  let e = L(t) ? t.value : t;
+  return e && typeof e == "string" && (e = Number(e)), typeof e == "number" && Number.isInteger(e) && e >= 0 ? e : null;
+}
+class ue extends ve {
+  constructor() {
+    super(), this.add = _.prototype.add.bind(this), this.delete = _.prototype.delete.bind(this), this.get = _.prototype.get.bind(this), this.has = _.prototype.has.bind(this), this.set = _.prototype.set.bind(this), this.tag = ue.tag;
+  }
+  /**
+   * If `ctx` is given, the return type is actually `Map<unknown, unknown>`,
+   * but TypeScript won't allow widening the signature of a child method.
+   */
+  toJSON(e, n) {
+    if (!n)
+      return super.toJSON(e);
+    const s = /* @__PURE__ */ new Map();
+    n?.onCreate && n.onCreate(s);
+    for (const i of this.items) {
+      let r, o;
+      if (j(i) ? (r = C(i.key, "", n), o = C(i.value, r, n)) : r = C(i, "", n), s.has(r))
+        throw new Error("Ordered maps must not include duplicate keys");
+      s.set(r, o);
+    }
+    return s;
+  }
+}
+ue.tag = "tag:yaml.org,2002:omap";
+class de extends _ {
+  constructor(e) {
+    super(e), this.tag = de.tag;
+  }
+  add(e) {
+    let n;
+    j(e) ? n = e : e && typeof e == "object" && "key" in e && "value" in e && e.value === null ? n = new M(e.key, null) : n = new M(e, null), T(this.items, n.key) || this.items.push(n);
+  }
+  /**
+   * If `keepPair` is `true`, returns the Pair matching `key`.
+   * Otherwise, returns the value of that Pair's key.
+   */
+  get(e, n) {
+    const s = T(this.items, e);
+    return !n && j(s) ? L(s.key) ? s.key.value : s.key : s;
+  }
+  set(e, n) {
+    if (typeof n != "boolean")
+      throw new Error(`Expected boolean value for set(key, value) in a YAML set, not ${typeof n}`);
+    const s = T(this.items, e);
+    s && !n ? this.items.splice(this.items.indexOf(s), 1) : !s && n && this.items.push(new M(e));
+  }
+  toJSON(e, n) {
+    return super.toJSON(e, n, Set);
+  }
+  toString(e, n, s) {
+    if (!e)
+      return JSON.stringify(this);
+    if (this.hasAllNullValues(!0))
+      return super.toString(Object.assign({}, e, { allNullValues: !0 }), n, s);
+    throw new Error("Set items must all have null values");
+  }
+}
+de.tag = "tag:yaml.org,2002:set";
+Ae.dirname(Ne(import.meta.url));
+const tt = (t) => t, nt = (t) => t, st = (t) => t, it = (t) => ({
+  widget: "boolean",
+  ...t
+}), rt = (t) => ({
+  widget: "code",
+  ...t
+}), ot = (t) => ({
+  widget: "color",
+  ...t
+}), lt = (t) => ({ widget: "datetime", ...t }), ft = (t) => ({
+  widget: "hidden",
+  ...t
+}), ct = (t) => ({
+  widget: "file",
+  ...t
+}), at = (t) => ({
+  widget: "image",
+  ...t
+}), ut = (t) => ({
+  widget: "list",
+  ...t
+}), dt = (t) => ({
+  widget: "map",
+  ...t
+}), gt = (t) => ({
+  widget: "number",
+  ...t
+}), ht = (t) => ({
+  widget: "object",
+  ...t
+}), pt = (t) => ({ widget: "relation", ...t }), mt = (t) => ({
+  widget: "select",
+  ...t
+}), bt = (t) => ({
+  widget: "string",
+  ...t
+}), yt = (t) => ({
+  widget: "text",
+  ...t
+});
+export {
+  it as defineBooleanWidget,
+  rt as defineCodeWidget,
+  ot as defineColorWidget,
+  tt as defineConfig,
+  lt as defineDateTimeWidget,
+  st as defineFileCollection,
+  ct as defineFileWidget,
+  nt as defineFolderCollection,
+  ft as defineHiddenWidget,
+  at as defineImageWidget,
+  ut as defineListWidget,
+  dt as defineMapWidget,
+  gt as defineNumberWidget,
+  ht as defineObjectWidget,
+  pt as defineRelationWidget,
+  mt as defineSelectWidget,
+  bt as defineStringWidget,
+  yt as defineTextWidget
+};