@jxsuite/parser 1.1.0 → 1.3.0

package/dist/serialize.js

@@ -5607,17 +5607,364 @@ var init_core = __esm(() => {
   subsetToRegexCache = new WeakMap;
 });
 
+// ../../node_modules/stringify-entities/lib/util/to-hexadecimal.js
+function toHexadecimal(code2, next, omit) {
+  const value = "&#x" + code2.toString(16).toUpperCase();
+  return omit && next && !hexadecimalRegex.test(String.fromCharCode(next)) ? value : value + ";";
+}
+var hexadecimalRegex;
+var init_to_hexadecimal = __esm(() => {
+  hexadecimalRegex = /[\dA-Fa-f]/;
+});
+
+// ../../node_modules/stringify-entities/lib/util/to-decimal.js
+function toDecimal(code2, next, omit) {
+  const value = "&#" + String(code2);
+  return omit && next && !decimalRegex.test(String.fromCharCode(next)) ? value : value + ";";
+}
+var decimalRegex;
+var init_to_decimal = __esm(() => {
+  decimalRegex = /\d/;
+});
+
+// ../../node_modules/character-entities-html4/index.js
+var characterEntitiesHtml4;
+var init_character_entities_html4 = __esm(() => {
+  characterEntitiesHtml4 = {
+    nbsp: " ",
+    iexcl: "¡",
+    cent: "¢",
+    pound: "£",
+    curren: "¤",
+    yen: "¥",
+    brvbar: "¦",
+    sect: "§",
+    uml: "¨",
+    copy: "©",
+    ordf: "ª",
+    laquo: "«",
+    not: "¬",
+    shy: "­",
+    reg: "®",
+    macr: "¯",
+    deg: "°",
+    plusmn: "±",
+    sup2: "²",
+    sup3: "³",
+    acute: "´",
+    micro: "µ",
+    para: "¶",
+    middot: "·",
+    cedil: "¸",
+    sup1: "¹",
+    ordm: "º",
+    raquo: "»",
+    frac14: "¼",
+    frac12: "½",
+    frac34: "¾",
+    iquest: "¿",
+    Agrave: "À",
+    Aacute: "Á",
+    Acirc: "Â",
+    Atilde: "Ã",
+    Auml: "Ä",
+    Aring: "Å",
+    AElig: "Æ",
+    Ccedil: "Ç",
+    Egrave: "È",
+    Eacute: "É",
+    Ecirc: "Ê",
+    Euml: "Ë",
+    Igrave: "Ì",
+    Iacute: "Í",
+    Icirc: "Î",
+    Iuml: "Ï",
+    ETH: "Ð",
+    Ntilde: "Ñ",
+    Ograve: "Ò",
+    Oacute: "Ó",
+    Ocirc: "Ô",
+    Otilde: "Õ",
+    Ouml: "Ö",
+    times: "×",
+    Oslash: "Ø",
+    Ugrave: "Ù",
+    Uacute: "Ú",
+    Ucirc: "Û",
+    Uuml: "Ü",
+    Yacute: "Ý",
+    THORN: "Þ",
+    szlig: "ß",
+    agrave: "à",
+    aacute: "á",
+    acirc: "â",
+    atilde: "ã",
+    auml: "ä",
+    aring: "å",
+    aelig: "æ",
+    ccedil: "ç",
+    egrave: "è",
+    eacute: "é",
+    ecirc: "ê",
+    euml: "ë",
+    igrave: "ì",
+    iacute: "í",
+    icirc: "î",
+    iuml: "ï",
+    eth: "ð",
+    ntilde: "ñ",
+    ograve: "ò",
+    oacute: "ó",
+    ocirc: "ô",
+    otilde: "õ",
+    ouml: "ö",
+    divide: "÷",
+    oslash: "ø",
+    ugrave: "ù",
+    uacute: "ú",
+    ucirc: "û",
+    uuml: "ü",
+    yacute: "ý",
+    thorn: "þ",
+    yuml: "ÿ",
+    fnof: "ƒ",
+    Alpha: "Α",
+    Beta: "Β",
+    Gamma: "Γ",
+    Delta: "Δ",
+    Epsilon: "Ε",
+    Zeta: "Ζ",
+    Eta: "Η",
+    Theta: "Θ",
+    Iota: "Ι",
+    Kappa: "Κ",
+    Lambda: "Λ",
+    Mu: "Μ",
+    Nu: "Ν",
+    Xi: "Ξ",
+    Omicron: "Ο",
+    Pi: "Π",
+    Rho: "Ρ",
+    Sigma: "Σ",
+    Tau: "Τ",
+    Upsilon: "Υ",
+    Phi: "Φ",
+    Chi: "Χ",
+    Psi: "Ψ",
+    Omega: "Ω",
+    alpha: "α",
+    beta: "β",
+    gamma: "γ",
+    delta: "δ",
+    epsilon: "ε",
+    zeta: "ζ",
+    eta: "η",
+    theta: "θ",
+    iota: "ι",
+    kappa: "κ",
+    lambda: "λ",
+    mu: "μ",
+    nu: "ν",
+    xi: "ξ",
+    omicron: "ο",
+    pi: "π",
+    rho: "ρ",
+    sigmaf: "ς",
+    sigma: "σ",
+    tau: "τ",
+    upsilon: "υ",
+    phi: "φ",
+    chi: "χ",
+    psi: "ψ",
+    omega: "ω",
+    thetasym: "ϑ",
+    upsih: "ϒ",
+    piv: "ϖ",
+    bull: "•",
+    hellip: "…",
+    prime: "′",
+    Prime: "″",
+    oline: "‾",
+    frasl: "⁄",
+    weierp: "℘",
+    image: "ℑ",
+    real: "ℜ",
+    trade: "™",
+    alefsym: "ℵ",
+    larr: "←",
+    uarr: "↑",
+    rarr: "→",
+    darr: "↓",
+    harr: "↔",
+    crarr: "↵",
+    lArr: "⇐",
+    uArr: "⇑",
+    rArr: "⇒",
+    dArr: "⇓",
+    hArr: "⇔",
+    forall: "∀",
+    part: "∂",
+    exist: "∃",
+    empty: "∅",
+    nabla: "∇",
+    isin: "∈",
+    notin: "∉",
+    ni: "∋",
+    prod: "∏",
+    sum: "∑",
+    minus: "−",
+    lowast: "∗",
+    radic: "√",
+    prop: "∝",
+    infin: "∞",
+    ang: "∠",
+    and: "∧",
+    or: "∨",
+    cap: "∩",
+    cup: "∪",
+    int: "∫",
+    there4: "∴",
+    sim: "∼",
+    cong: "≅",
+    asymp: "≈",
+    ne: "≠",
+    equiv: "≡",
+    le: "≤",
+    ge: "≥",
+    sub: "⊂",
+    sup: "⊃",
+    nsub: "⊄",
+    sube: "⊆",
+    supe: "⊇",
+    oplus: "⊕",
+    otimes: "⊗",
+    perp: "⊥",
+    sdot: "⋅",
+    lceil: "⌈",
+    rceil: "⌉",
+    lfloor: "⌊",
+    rfloor: "⌋",
+    lang: "〈",
+    rang: "〉",
+    loz: "◊",
+    spades: "♠",
+    clubs: "♣",
+    hearts: "♥",
+    diams: "♦",
+    quot: '"',
+    amp: "&",
+    lt: "<",
+    gt: ">",
+    OElig: "Œ",
+    oelig: "œ",
+    Scaron: "Š",
+    scaron: "š",
+    Yuml: "Ÿ",
+    circ: "ˆ",
+    tilde: "˜",
+    ensp: " ",
+    emsp: " ",
+    thinsp: " ",
+    zwnj: "‌",
+    zwj: "‍",
+    lrm: "‎",
+    rlm: "‏",
+    ndash: "–",
+    mdash: "—",
+    lsquo: "‘",
+    rsquo: "’",
+    sbquo: "‚",
+    ldquo: "“",
+    rdquo: "”",
+    bdquo: "„",
+    dagger: "†",
+    Dagger: "‡",
+    permil: "‰",
+    lsaquo: "‹",
+    rsaquo: "›",
+    euro: "€"
+  };
+});
+
+// ../../node_modules/stringify-entities/lib/constant/dangerous.js
+var dangerous;
+var init_dangerous = __esm(() => {
+  dangerous = [
+    "cent",
+    "copy",
+    "divide",
+    "gt",
+    "lt",
+    "not",
+    "para",
+    "times"
+  ];
+});
+
+// ../../node_modules/stringify-entities/lib/util/to-named.js
+function toNamed(code2, next, omit, attribute) {
+  const character = String.fromCharCode(code2);
+  if (own5.call(characters, character)) {
+    const name = characters[character];
+    const value = "&" + name;
+    if (omit && characterEntitiesLegacy.includes(name) && !dangerous.includes(name) && (!attribute || next && next !== 61 && notAlphanumericRegex.test(String.fromCharCode(next)))) {
+      return value;
+    }
+    return value + ";";
+  }
+  return "";
+}
+var own5, characters, key, notAlphanumericRegex;
+var init_to_named = __esm(() => {
+  init_character_entities_legacy();
+  init_character_entities_html4();
+  init_dangerous();
+  own5 = {}.hasOwnProperty;
+  characters = {};
+  for (key in characterEntitiesHtml4) {
+    if (own5.call(characterEntitiesHtml4, key)) {
+      characters[characterEntitiesHtml4[key]] = key;
+    }
+  }
+  notAlphanumericRegex = /[^\dA-Za-z]/;
+});
+
+// ../../node_modules/stringify-entities/lib/util/format-smart.js
+function formatSmart(code2, next, options) {
+  let numeric = toHexadecimal(code2, next, options.omitOptionalSemicolons);
+  let named;
+  if (options.useNamedReferences || options.useShortestReferences) {
+    named = toNamed(code2, next, options.omitOptionalSemicolons, options.attribute);
+  }
+  if ((options.useShortestReferences || !named) && options.useShortestReferences) {
+    const decimal = toDecimal(code2, next, options.omitOptionalSemicolons);
+    if (decimal.length < numeric.length) {
+      numeric = decimal;
+    }
+  }
+  return named && (!options.useShortestReferences || named.length < numeric.length) ? named : numeric;
+}
+var init_format_smart = __esm(() => {
+  init_to_hexadecimal();
+  init_to_decimal();
+  init_to_named();
+});
+
 // ../../node_modules/stringify-entities/lib/util/format-basic.js
 function formatBasic(code2) {
   return "&#x" + code2.toString(16).toUpperCase() + ";";
 }
 
 // ../../node_modules/stringify-entities/lib/index.js
+function stringifyEntities(value, options) {
+  return core(value, Object.assign({ format: formatSmart }, options));
+}
 function stringifyEntitiesLight(value, options) {
   return core(value, Object.assign({ format: formatBasic }, options));
 }
 var init_lib11 = __esm(() => {
   init_core();
+  init_format_smart();
 });
 
 // ../../node_modules/stringify-entities/index.js
@@ -5821,13 +6168,13 @@ function directiveToMarkdown(options) {
     let classesFull;
     let classes;
     let id;
-    let key;
-    for (key in attributes2) {
-      if (own5.call(attributes2, key) && attributes2[key] !== undefined && attributes2[key] !== null) {
-        const value = String(attributes2[key]);
-        if (key === "id") {
+    let key2;
+    for (key2 in attributes2) {
+      if (own6.call(attributes2, key2) && attributes2[key2] !== undefined && attributes2[key2] !== null) {
+        const value = String(attributes2[key2]);
+        if (key2 === "id") {
           id = settings.preferShortcut !== false && shortcut.test(value) ? "#" + value : quoted("id", value, node2, state);
-        } else if (key === "class") {
+        } else if (key2 === "class") {
           const list3 = value.split(/[\t\n\r ]+/g);
           const classesFullList = [];
           const classesList = [];
@@ -5838,7 +6185,7 @@ function directiveToMarkdown(options) {
           classesFull = classesFullList.length > 0 ? quoted("class", classesFullList.join(" "), node2, state) : "";
           classes = classesList.length > 0 ? "." + classesList.join(".") : "";
         } else {
-          values2.push(quoted(key, value, node2, state));
+          values2.push(quoted(key2, value, node2, state));
         }
       }
     }
@@ -5853,18 +6200,18 @@ function directiveToMarkdown(options) {
     }
     return values2.length > 0 ? "{" + values2.join(" ") + "}" : "";
   }
-  function quoted(key, value, node2, state) {
+  function quoted(key2, value, node2, state) {
     if (settings.collapseEmptyAttributes !== false && !value)
-      return key;
+      return key2;
     if (settings.preferUnquoted && unquoted.test(value)) {
-      return key + "=" + value;
+      return key2 + "=" + value;
     }
     const preferred = settings.quote || state.options.quote || '"';
     const alternative = preferred === '"' ? "'" : '"';
     const appliedQuote = settings.quoteSmart && ccount(value, preferred) > ccount(value, alternative) ? alternative : preferred;
     const subset = node2.type === "textDirective" ? [appliedQuote] : [appliedQuote, `
 `, "\r"];
-    return key + "=" + appliedQuote + stringifyEntitiesLight(value, { subset }) + appliedQuote;
+    return key2 + "=" + appliedQuote + stringifyEntitiesLight(value, { subset }) + appliedQuote;
   }
 }
 function enterContainer(token) {
@@ -5974,13 +6321,13 @@ function fence(node2) {
   }
   return ":".repeat(size);
 }
-var own5, emptyOptions2, shortcut, unquoted;
+var own6, emptyOptions2, shortcut, unquoted;
 var init_lib13 = __esm(() => {
   init_development();
   init_parse_entities();
   init_stringify_entities();
   init_unist_util_visit_parents2();
-  own5 = {}.hasOwnProperty;
+  own6 = {}.hasOwnProperty;
   emptyOptions2 = {};
   shortcut = /^[^\t\n\r "#'.<=>`}]+$/;
   unquoted = /^[^\t\n\r "'<=>`}]+$/;
@@ -12024,11 +12371,11 @@ var require_visit = __commonJS((exports) => {
   visit2.BREAK = BREAK;
   visit2.SKIP = SKIP4;
   visit2.REMOVE = REMOVE;
-  function visit_(key, node2, visitor, path2) {
-    const ctrl = callVisitor(key, node2, visitor, path2);
+  function visit_(key2, node2, visitor, path2) {
+    const ctrl = callVisitor(key2, node2, visitor, path2);
     if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-      replaceNode(key, path2, ctrl);
-      return visit_(key, ctrl, visitor, path2);
+      replaceNode(key2, path2, ctrl);
+      return visit_(key2, ctrl, visitor, path2);
     }
     if (typeof ctrl !== "symbol") {
       if (identity.isCollection(node2)) {
@@ -12072,11 +12419,11 @@ var require_visit = __commonJS((exports) => {
   visitAsync.BREAK = BREAK;
   visitAsync.SKIP = SKIP4;
   visitAsync.REMOVE = REMOVE;
-  async function visitAsync_(key, node2, visitor, path2) {
-    const ctrl = await callVisitor(key, node2, visitor, path2);
+  async function visitAsync_(key2, node2, visitor, path2) {
+    const ctrl = await callVisitor(key2, node2, visitor, path2);
     if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-      replaceNode(key, path2, ctrl);
-      return visitAsync_(key, ctrl, visitor, path2);
+      replaceNode(key2, path2, ctrl);
+      return visitAsync_(key2, ctrl, visitor, path2);
     }
     if (typeof ctrl !== "symbol") {
       if (identity.isCollection(node2)) {
@@ -12126,27 +12473,27 @@ var require_visit = __commonJS((exports) => {
     }
     return visitor;
   }
-  function callVisitor(key, node2, visitor, path2) {
+  function callVisitor(key2, node2, visitor, path2) {
     if (typeof visitor === "function")
-      return visitor(key, node2, path2);
+      return visitor(key2, node2, path2);
     if (identity.isMap(node2))
-      return visitor.Map?.(key, node2, path2);
+      return visitor.Map?.(key2, node2, path2);
     if (identity.isSeq(node2))
-      return visitor.Seq?.(key, node2, path2);
+      return visitor.Seq?.(key2, node2, path2);
     if (identity.isPair(node2))
-      return visitor.Pair?.(key, node2, path2);
+      return visitor.Pair?.(key2, node2, path2);
     if (identity.isScalar(node2))
-      return visitor.Scalar?.(key, node2, path2);
+      return visitor.Scalar?.(key2, node2, path2);
     if (identity.isAlias(node2))
-      return visitor.Alias?.(key, node2, path2);
+      return visitor.Alias?.(key2, node2, path2);
     return;
   }
-  function replaceNode(key, path2, node2) {
+  function replaceNode(key2, path2, node2) {
     const parent = path2[path2.length - 1];
     if (identity.isCollection(parent)) {
-      parent.items[key] = node2;
+      parent.items[key2] = node2;
     } else if (identity.isPair(parent)) {
-      if (key === "key")
+      if (key2 === "key")
         parent.key = node2;
       else
         parent.value = node2;
@@ -12377,7 +12724,7 @@ var require_anchors = __commonJS((exports) => {
 
 // ../../node_modules/yaml/dist/doc/applyReviver.js
 var require_applyReviver = __commonJS((exports) => {
-  function applyReviver(reviver, obj, key, val) {
+  function applyReviver(reviver, obj, key2, val) {
     if (val && typeof val === "object") {
       if (Array.isArray(val)) {
         for (let i = 0, len = val.length;i < len; ++i) {
@@ -12417,7 +12764,7 @@ var require_applyReviver = __commonJS((exports) => {
         }
       }
     }
-    return reviver.call(obj, key, val);
+    return reviver.call(obj, key2, val);
   }
   exports.applyReviver = applyReviver;
 });
@@ -12748,29 +13095,29 @@ var require_Collection = __commonJS((exports) => {
       if (isEmptyPath(path2))
         this.add(value);
       else {
-        const [key, ...rest] = path2;
-        const node2 = this.get(key, true);
+        const [key2, ...rest] = path2;
+        const node2 = this.get(key2, true);
         if (identity.isCollection(node2))
           node2.addIn(rest, value);
         else if (node2 === undefined && this.schema)
-          this.set(key, collectionFromPath(this.schema, rest, value));
+          this.set(key2, collectionFromPath(this.schema, rest, value));
         else
-          throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+          throw new Error(`Expected YAML collection at ${key2}. Remaining path: ${rest}`);
       }
     }
     deleteIn(path2) {
-      const [key, ...rest] = path2;
+      const [key2, ...rest] = path2;
       if (rest.length === 0)
-        return this.delete(key);
-      const node2 = this.get(key, true);
+        return this.delete(key2);
+      const node2 = this.get(key2, true);
       if (identity.isCollection(node2))
         return node2.deleteIn(rest);
       else
-        throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+        throw new Error(`Expected YAML collection at ${key2}. Remaining path: ${rest}`);
     }
     getIn(path2, keepScalar) {
-      const [key, ...rest] = path2;
-      const node2 = this.get(key, true);
+      const [key2, ...rest] = path2;
+      const node2 = this.get(key2, true);
       if (rest.length === 0)
         return !keepScalar && identity.isScalar(node2) ? node2.value : node2;
       else
@@ -12785,24 +13132,24 @@ var require_Collection = __commonJS((exports) => {
       });
     }
     hasIn(path2) {
-      const [key, ...rest] = path2;
+      const [key2, ...rest] = path2;
       if (rest.length === 0)
-        return this.has(key);
-      const node2 = this.get(key, true);
+        return this.has(key2);
+      const node2 = this.get(key2, true);
       return identity.isCollection(node2) ? node2.hasIn(rest) : false;
     }
     setIn(path2, value) {
-      const [key, ...rest] = path2;
+      const [key2, ...rest] = path2;
       if (rest.length === 0) {
-        this.set(key, value);
+        this.set(key2, value);
       } else {
-        const node2 = this.get(key, true);
+        const node2 = this.get(key2, true);
         if (identity.isCollection(node2))
           node2.setIn(rest, value);
         else if (node2 === undefined && this.schema)
-          this.set(key, collectionFromPath(this.schema, rest, value));
+          this.set(key2, collectionFromPath(this.schema, rest, value));
         else
-          throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+          throw new Error(`Expected YAML collection at ${key2}. Remaining path: ${rest}`);
       }
     }
   }
@@ -13390,19 +13737,19 @@ var require_stringifyPair = __commonJS((exports) => {
   var Scalar = require_Scalar();
   var stringify = require_stringify();
   var stringifyComment = require_stringifyComment();
-  function stringifyPair({ key, value }, ctx, onComment, onChompKeep) {
+  function stringifyPair({ key: key2, value }, ctx, onComment, onChompKeep) {
     const { allNullValues, doc, indent: indent2, indentStep, options: { commentString, indentSeq, simpleKeys } } = ctx;
-    let keyComment = identity.isNode(key) && key.comment || null;
+    let keyComment = identity.isNode(key2) && key2.comment || null;
     if (simpleKeys) {
       if (keyComment) {
         throw new Error("With simple keys, key nodes cannot have comments");
       }
-      if (identity.isCollection(key) || !identity.isNode(key) && typeof key === "object") {
+      if (identity.isCollection(key2) || !identity.isNode(key2) && typeof key2 === "object") {
         const msg = "With simple keys, collection cannot be used as a key value";
         throw new Error(msg);
       }
     }
-    let explicitKey = !simpleKeys && (!key || keyComment && value == null && !ctx.inFlow || identity.isCollection(key) || (identity.isScalar(key) ? key.type === Scalar.Scalar.BLOCK_FOLDED || key.type === Scalar.Scalar.BLOCK_LITERAL : typeof key === "object"));
+    let explicitKey = !simpleKeys && (!key2 || keyComment && value == null && !ctx.inFlow || identity.isCollection(key2) || (identity.isScalar(key2) ? key2.type === Scalar.Scalar.BLOCK_FOLDED || key2.type === Scalar.Scalar.BLOCK_LITERAL : typeof key2 === "object"));
     ctx = Object.assign({}, ctx, {
       allNullValues: false,
       implicitKey: !explicitKey && (simpleKeys || !allNullValues),
@@ -13410,7 +13757,7 @@ var require_stringifyPair = __commonJS((exports) => {
     });
     let keyCommentDone = false;
     let chompKeep = false;
-    let str = stringify.stringify(key, ctx, () => keyCommentDone = true, () => chompKeep = true);
+    let str = stringify.stringify(key2, ctx, () => keyCommentDone = true, () => chompKeep = true);
     if (!explicitKey && !ctx.inFlow && str.length > 1024) {
       if (simpleKeys)
         throw new Error("With simple keys, single line scalar must not span more than 1024 characters");
@@ -13554,7 +13901,7 @@ var require_merge = __commonJS((exports) => {
     }),
     stringify: () => MERGE_KEY
   };
-  var isMergeKey = (ctx, key) => (merge.identify(key) || identity.isScalar(key) && (!key.type || key.type === Scalar.Scalar.PLAIN) && merge.identify(key.value)) && ctx?.doc.schema.tags.some((tag) => tag.tag === merge.tag && tag.default);
+  var isMergeKey = (ctx, key2) => (merge.identify(key2) || identity.isScalar(key2) && (!key2.type || key2.type === Scalar.Scalar.PLAIN) && merge.identify(key2.value)) && ctx?.doc.schema.tags.some((tag) => tag.tag === merge.tag && tag.default);
   function addMergeToJSMap(ctx, map4, value) {
     const source = resolveAliasValue(ctx, value);
     if (identity.isSeq(source))
@@ -13571,14 +13918,14 @@ var require_merge = __commonJS((exports) => {
     if (!identity.isMap(source))
       throw new Error("Merge sources must be maps or map aliases");
     const srcMap = source.toJSON(null, ctx, Map);
-    for (const [key, value2] of srcMap) {
+    for (const [key2, value2] of srcMap) {
       if (map4 instanceof Map) {
-        if (!map4.has(key))
-          map4.set(key, value2);
+        if (!map4.has(key2))
+          map4.set(key2, value2);
       } else if (map4 instanceof Set) {
-        map4.add(key);
-      } else if (!Object.prototype.hasOwnProperty.call(map4, key)) {
-        Object.defineProperty(map4, key, {
+        map4.add(key2);
+      } else if (!Object.prototype.hasOwnProperty.call(map4, key2)) {
+        Object.defineProperty(map4, key2, {
           value: value2,
           writable: true,
           enumerable: true,
@@ -13603,19 +13950,19 @@ var require_addPairToJSMap = __commonJS((exports) => {
   var stringify = require_stringify();
   var identity = require_identity();
   var toJS = require_toJS();
-  function addPairToJSMap(ctx, map4, { key, value }) {
-    if (identity.isNode(key) && key.addToJSMap)
-      key.addToJSMap(ctx, map4, value);
-    else if (merge.isMergeKey(ctx, key))
+  function addPairToJSMap(ctx, map4, { key: key2, value }) {
+    if (identity.isNode(key2) && key2.addToJSMap)
+      key2.addToJSMap(ctx, map4, value);
+    else if (merge.isMergeKey(ctx, key2))
       merge.addMergeToJSMap(ctx, map4, value);
     else {
-      const jsKey = toJS.toJS(key, "", ctx);
+      const jsKey = toJS.toJS(key2, "", ctx);
       if (map4 instanceof Map) {
         map4.set(jsKey, toJS.toJS(value, jsKey, ctx));
       } else if (map4 instanceof Set) {
         map4.add(jsKey);
       } else {
-        const stringKey = stringifyKey(key, jsKey, ctx);
+        const stringKey = stringifyKey(key2, jsKey, ctx);
         const jsValue = toJS.toJS(value, stringKey, ctx);
         if (stringKey in map4)
           Object.defineProperty(map4, stringKey, {
@@ -13630,19 +13977,19 @@ var require_addPairToJSMap = __commonJS((exports) => {
     }
     return map4;
   }
-  function stringifyKey(key, jsKey, ctx) {
+  function stringifyKey(key2, jsKey, ctx) {
     if (jsKey === null)
       return "";
     if (typeof jsKey !== "object")
       return String(jsKey);
-    if (identity.isNode(key) && ctx?.doc) {
+    if (identity.isNode(key2) && ctx?.doc) {
       const strCtx = stringify.createStringifyContext(ctx.doc, {});
       strCtx.anchors = new Set;
       for (const node2 of ctx.anchors.keys())
         strCtx.anchors.add(node2.anchor);
       strCtx.inFlow = true;
       strCtx.inStringifyKey = true;
-      const strKey = key.toString(strCtx);
+      const strKey = key2.toString(strCtx);
       if (!ctx.mapKeyWarned) {
         let jsonStr = JSON.stringify(strKey);
         if (jsonStr.length > 40)
@@ -13663,25 +14010,25 @@ var require_Pair = __commonJS((exports) => {
   var stringifyPair = require_stringifyPair();
   var addPairToJSMap = require_addPairToJSMap();
   var identity = require_identity();
-  function createPair(key, value, ctx) {
-    const k = createNode.createNode(key, undefined, ctx);
+  function createPair(key2, value, ctx) {
+    const k = createNode.createNode(key2, undefined, ctx);
     const v = createNode.createNode(value, undefined, ctx);
     return new Pair(k, v);
   }
 
   class Pair {
-    constructor(key, value = null) {
+    constructor(key2, value = null) {
       Object.defineProperty(this, identity.NODE_TYPE, { value: identity.PAIR });
-      this.key = key;
+      this.key = key2;
       this.value = value;
     }
     clone(schema) {
-      let { key, value } = this;
-      if (identity.isNode(key))
-        key = key.clone(schema);
+      let { key: key2, value } = this;
+      if (identity.isNode(key2))
+        key2 = key2.clone(schema);
       if (identity.isNode(value))
         value = value.clone(schema);
-      return new Pair(key, value);
+      return new Pair(key2, value);
     }
     toJSON(_, ctx) {
       const pair = ctx?.mapAsMap ? new Map : {};
@@ -13855,11 +14202,11 @@ var require_YAMLMap = __commonJS((exports) => {
   var identity = require_identity();
   var Pair = require_Pair();
   var Scalar = require_Scalar();
-  function findPair(items, key) {
-    const k = identity.isScalar(key) ? key.value : key;
+  function findPair(items, key2) {
+    const k = identity.isScalar(key2) ? key2.value : key2;
     for (const it of items) {
       if (identity.isPair(it)) {
-        if (it.key === key || it.key === k)
+        if (it.key === key2 || it.key === k)
           return it;
         if (identity.isScalar(it.key) && it.key.value === k)
           return it;
@@ -13879,20 +14226,20 @@ var require_YAMLMap = __commonJS((exports) => {
     static from(schema, obj, ctx) {
       const { keepUndefined, replacer } = ctx;
       const map4 = new this(schema);
-      const add = (key, value) => {
+      const add = (key2, value) => {
         if (typeof replacer === "function")
-          value = replacer.call(obj, key, value);
-        else if (Array.isArray(replacer) && !replacer.includes(key))
+          value = replacer.call(obj, key2, value);
+        else if (Array.isArray(replacer) && !replacer.includes(key2))
           return;
         if (value !== undefined || keepUndefined)
-          map4.items.push(Pair.createPair(key, value, ctx));
+          map4.items.push(Pair.createPair(key2, value, ctx));
       };
       if (obj instanceof Map) {
-        for (const [key, value] of obj)
-          add(key, value);
+        for (const [key2, value] of obj)
+          add(key2, value);
       } else if (obj && typeof obj === "object") {
-        for (const key of Object.keys(obj))
-          add(key, obj[key]);
+        for (const key2 of Object.keys(obj))
+          add(key2, obj[key2]);
       }
       if (typeof schema.sortMapEntries === "function") {
         map4.items.sort(schema.sortMapEntries);
@@ -13926,23 +14273,23 @@ var require_YAMLMap = __commonJS((exports) => {
         this.items.push(_pair);
       }
     }
-    delete(key) {
-      const it = findPair(this.items, key);
+    delete(key2) {
+      const it = findPair(this.items, key2);
       if (!it)
         return false;
       const del = this.items.splice(this.items.indexOf(it), 1);
       return del.length > 0;
     }
-    get(key, keepScalar) {
-      const it = findPair(this.items, key);
+    get(key2, keepScalar) {
+      const it = findPair(this.items, key2);
       const node2 = it?.value;
       return (!keepScalar && identity.isScalar(node2) ? node2.value : node2) ?? undefined;
     }
-    has(key) {
-      return !!findPair(this.items, key);
+    has(key2) {
+      return !!findPair(this.items, key2);
     }
-    set(key, value) {
-      this.add(new Pair.Pair(key, value), true);
+    set(key2, value) {
+      this.add(new Pair.Pair(key2, value), true);
     }
     toJSON(_, ctx, Type) {
       const map4 = Type ? new Type : ctx?.mapAsMap ? new Map : {};
@@ -14013,28 +14360,28 @@ var require_YAMLSeq = __commonJS((exports) => {
     add(value) {
       this.items.push(value);
     }
-    delete(key) {
-      const idx = asItemIndex(key);
+    delete(key2) {
+      const idx = asItemIndex(key2);
       if (typeof idx !== "number")
         return false;
       const del = this.items.splice(idx, 1);
       return del.length > 0;
     }
-    get(key, keepScalar) {
-      const idx = asItemIndex(key);
+    get(key2, keepScalar) {
+      const idx = asItemIndex(key2);
       if (typeof idx !== "number")
         return;
       const it = this.items[idx];
       return !keepScalar && identity.isScalar(it) ? it.value : it;
     }
-    has(key) {
-      const idx = asItemIndex(key);
+    has(key2) {
+      const idx = asItemIndex(key2);
       return typeof idx === "number" && idx < this.items.length;
     }
-    set(key, value) {
-      const idx = asItemIndex(key);
+    set(key2, value) {
+      const idx = asItemIndex(key2);
       if (typeof idx !== "number")
-        throw new Error(`Expected a valid index, not ${key}.`);
+        throw new Error(`Expected a valid index, not ${key2}.`);
       const prev = this.items[idx];
       if (identity.isScalar(prev) && Scalar.isScalarValue(value))
         prev.value = value;
@@ -14068,8 +14415,8 @@ var require_YAMLSeq = __commonJS((exports) => {
         let i = 0;
         for (let it of obj) {
           if (typeof replacer === "function") {
-            const key = obj instanceof Set ? it : String(i++);
-            it = replacer.call(obj, key, it);
+            const key2 = obj instanceof Set ? it : String(i++);
+            it = replacer.call(obj, key2, it);
           }
           seq.items.push(createNode.createNode(it, undefined, ctx));
         }
@@ -14077,8 +14424,8 @@ var require_YAMLSeq = __commonJS((exports) => {
       return seq;
     }
   }
-  function asItemIndex(key) {
-    let idx = identity.isScalar(key) ? key.value : key;
+  function asItemIndex(key2) {
+    let idx = identity.isScalar(key2) ? key2.value : key2;
     if (idx && typeof idx === "string")
       idx = Number(idx);
     return typeof idx === "number" && Number.isInteger(idx) && idx >= 0 ? idx : null;
@@ -14451,25 +14798,25 @@ ${cn.comment}` : item.comment;
       for (let it of iterable) {
         if (typeof replacer === "function")
           it = replacer.call(iterable, String(i++), it);
-        let key, value;
+        let key2, value;
         if (Array.isArray(it)) {
           if (it.length === 2) {
-            key = it[0];
+            key2 = it[0];
             value = it[1];
           } else
             throw new TypeError(`Expected [key, value] tuple: ${it}`);
         } else if (it && it instanceof Object) {
           const keys = Object.keys(it);
           if (keys.length === 1) {
-            key = keys[0];
-            value = it[key];
+            key2 = keys[0];
+            value = it[key2];
           } else {
             throw new TypeError(`Expected tuple with one key, not ${keys.length} keys`);
           }
         } else {
-          key = it;
+          key2 = it;
         }
-        pairs2.items.push(Pair.createPair(key, value, ctx));
+        pairs2.items.push(Pair.createPair(key2, value, ctx));
       }
     return pairs2;
   }
@@ -14510,16 +14857,16 @@ var require_omap = __commonJS((exports) => {
       if (ctx?.onCreate)
         ctx.onCreate(map4);
       for (const pair of this.items) {
-        let key, value;
+        let key2, value;
         if (identity.isPair(pair)) {
-          key = toJS.toJS(pair.key, "", ctx);
-          value = toJS.toJS(pair.value, key, ctx);
+          key2 = toJS.toJS(pair.key, "", ctx);
+          value = toJS.toJS(pair.value, key2, ctx);
         } else {
-          key = toJS.toJS(pair, "", ctx);
+          key2 = toJS.toJS(pair, "", ctx);
         }
-        if (map4.has(key))
+        if (map4.has(key2))
           throw new Error("Ordered maps must not include duplicate keys");
-        map4.set(key, value);
+        map4.set(key2, value);
       }
       return map4;
     }
@@ -14540,12 +14887,12 @@ var require_omap = __commonJS((exports) => {
     resolve(seq, onError) {
       const pairs$1 = pairs.resolvePairs(seq, onError);
       const seenKeys = [];
-      for (const { key } of pairs$1.items) {
-        if (identity.isScalar(key)) {
-          if (seenKeys.includes(key.value)) {
-            onError(`Ordered maps must not include duplicate keys: ${key.value}`);
+      for (const { key: key2 } of pairs$1.items) {
+        if (identity.isScalar(key2)) {
+          if (seenKeys.includes(key2.value)) {
+            onError(`Ordered maps must not include duplicate keys: ${key2.value}`);
           } else {
-            seenKeys.push(key.value);
+            seenKeys.push(key2.value);
           }
         }
       }
@@ -14719,30 +15066,30 @@ var require_set = __commonJS((exports) => {
       super(schema);
       this.tag = YAMLSet.tag;
     }
-    add(key) {
+    add(key2) {
       let pair;
-      if (identity.isPair(key))
-        pair = key;
-      else if (key && typeof key === "object" && "key" in key && "value" in key && key.value === null)
-        pair = new Pair.Pair(key.key, null);
+      if (identity.isPair(key2))
+        pair = key2;
+      else if (key2 && typeof key2 === "object" && "key" in key2 && "value" in key2 && key2.value === null)
+        pair = new Pair.Pair(key2.key, null);
       else
-        pair = new Pair.Pair(key, null);
+        pair = new Pair.Pair(key2, null);
       const prev = YAMLMap.findPair(this.items, pair.key);
       if (!prev)
         this.items.push(pair);
     }
-    get(key, keepPair) {
-      const pair = YAMLMap.findPair(this.items, key);
+    get(key2, keepPair) {
+      const pair = YAMLMap.findPair(this.items, key2);
       return !keepPair && identity.isPair(pair) ? identity.isScalar(pair.key) ? pair.key.value : pair.key : pair;
     }
-    set(key, value) {
+    set(key2, value) {
       if (typeof value !== "boolean")
         throw new Error(`Expected boolean value for set(key, value) in a YAML set, not ${typeof value}`);
-      const prev = YAMLMap.findPair(this.items, key);
+      const prev = YAMLMap.findPair(this.items, key2);
       if (prev && !value) {
         this.items.splice(this.items.indexOf(prev), 1);
       } else if (!prev && value) {
-        this.items.push(new Pair.Pair(key));
+        this.items.push(new Pair.Pair(key2));
       }
     }
     toJSON(_, ctx) {
@@ -14977,7 +15324,7 @@ var require_tags = __commonJS((exports) => {
       if (Array.isArray(customTags))
         tags = [];
       else {
-        const keys = Array.from(schemas.keys()).filter((key) => key !== "yaml11").map((key) => JSON.stringify(key)).join(", ");
+        const keys = Array.from(schemas.keys()).filter((key2) => key2 !== "yaml11").map((key2) => JSON.stringify(key2)).join(", ");
         throw new Error(`Unknown schema "${schemaName}"; use one of ${keys} or define customTags array`);
       }
     }
@@ -14993,7 +15340,7 @@ var require_tags = __commonJS((exports) => {
       const tagObj = typeof tag === "string" ? tagsByName[tag] : tag;
       if (!tagObj) {
         const tagName = JSON.stringify(tag);
-        const keys = Object.keys(tagsByName).map((key) => JSON.stringify(key)).join(", ");
+        const keys = Object.keys(tagsByName).map((key2) => JSON.stringify(key2)).join(", ");
         throw new Error(`Unknown custom tag ${tagName}; use one of ${keys}`);
       }
       if (!tags2.includes(tagObj))
@@ -15228,13 +15575,13 @@ var require_Document = __commonJS((exports) => {
       setAnchors();
       return node2;
     }
-    createPair(key, value, options = {}) {
-      const k = this.createNode(key, null, options);
+    createPair(key2, value, options = {}) {
+      const k = this.createNode(key2, null, options);
       const v = this.createNode(value, null, options);
       return new Pair.Pair(k, v);
     }
-    delete(key) {
-      return assertCollection(this.contents) ? this.contents.delete(key) : false;
+    delete(key2) {
+      return assertCollection(this.contents) ? this.contents.delete(key2) : false;
     }
     deleteIn(path2) {
       if (Collection.isEmptyPath(path2)) {
@@ -15245,27 +15592,27 @@ var require_Document = __commonJS((exports) => {
       }
       return assertCollection(this.contents) ? this.contents.deleteIn(path2) : false;
     }
-    get(key, keepScalar) {
-      return identity.isCollection(this.contents) ? this.contents.get(key, keepScalar) : undefined;
+    get(key2, keepScalar) {
+      return identity.isCollection(this.contents) ? this.contents.get(key2, keepScalar) : undefined;
     }
     getIn(path2, keepScalar) {
       if (Collection.isEmptyPath(path2))
         return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
       return identity.isCollection(this.contents) ? this.contents.getIn(path2, keepScalar) : undefined;
     }
-    has(key) {
-      return identity.isCollection(this.contents) ? this.contents.has(key) : false;
+    has(key2) {
+      return identity.isCollection(this.contents) ? this.contents.has(key2) : false;
     }
     hasIn(path2) {
       if (Collection.isEmptyPath(path2))
         return this.contents !== undefined;
       return identity.isCollection(this.contents) ? this.contents.hasIn(path2) : false;
     }
-    set(key, value) {
+    set(key2, value) {
       if (this.contents == null) {
-        this.contents = Collection.collectionFromPath(this.schema, [key], value);
+        this.contents = Collection.collectionFromPath(this.schema, [key2], value);
       } else if (assertCollection(this.contents)) {
-        this.contents.set(key, value);
+        this.contents.set(key2, value);
       }
     }
     setIn(path2, value) {
@@ -15547,25 +15894,25 @@ var require_resolve_props = __commonJS((exports) => {
 
 // ../../node_modules/yaml/dist/compose/util-contains-newline.js
 var require_util_contains_newline = __commonJS((exports) => {
-  function containsNewline(key) {
-    if (!key)
+  function containsNewline(key2) {
+    if (!key2)
       return null;
-    switch (key.type) {
+    switch (key2.type) {
       case "alias":
       case "scalar":
       case "double-quoted-scalar":
       case "single-quoted-scalar":
-        if (key.source.includes(`
+        if (key2.source.includes(`
 `))
           return true;
-        if (key.end) {
-          for (const st of key.end)
+        if (key2.end) {
+          for (const st of key2.end)
             if (st.type === "newline")
               return true;
         }
         return false;
       case "flow-collection":
-        for (const it of key.items) {
+        for (const it of key2.items) {
           for (const st of it.start)
             if (st.type === "newline")
               return true;
@@ -15630,10 +15977,10 @@ var require_resolve_block_map = __commonJS((exports) => {
     let offset = bm.offset;
     let commentEnd = null;
     for (const collItem of bm.items) {
-      const { start, key, sep, value } = collItem;
+      const { start, key: key2, sep, value } = collItem;
       const keyProps = resolveProps.resolveProps(start, {
         indicator: "explicit-key-ind",
-        next: key ?? sep?.[0],
+        next: key2 ?? sep?.[0],
         offset,
         onError,
         parentIndent: bm.indent,
@@ -15641,10 +15988,10 @@ var require_resolve_block_map = __commonJS((exports) => {
       });
       const implicitKey = !keyProps.found;
       if (implicitKey) {
-        if (key) {
-          if (key.type === "block-seq")
+        if (key2) {
+          if (key2.type === "block-seq")
             onError(offset, "BLOCK_AS_IMPLICIT_KEY", "A block sequence may not be used as an implicit map key");
-          else if ("indent" in key && key.indent !== bm.indent)
+          else if ("indent" in key2 && key2.indent !== bm.indent)
             onError(offset, "BAD_INDENT", startColMsg);
         }
         if (!keyProps.anchor && !keyProps.tag && !sep) {
@@ -15658,17 +16005,17 @@ var require_resolve_block_map = __commonJS((exports) => {
           }
           continue;
         }
-        if (keyProps.newlineAfterProp || utilContainsNewline.containsNewline(key)) {
-          onError(key ?? start[start.length - 1], "MULTILINE_IMPLICIT_KEY", "Implicit keys need to be on a single line");
+        if (keyProps.newlineAfterProp || utilContainsNewline.containsNewline(key2)) {
+          onError(key2 ?? start[start.length - 1], "MULTILINE_IMPLICIT_KEY", "Implicit keys need to be on a single line");
         }
       } else if (keyProps.found?.indent !== bm.indent) {
         onError(offset, "BAD_INDENT", startColMsg);
       }
       ctx.atKey = true;
       const keyStart = keyProps.end;
-      const keyNode = key ? composeNode(ctx, key, keyProps, onError) : composeEmptyNode(ctx, keyStart, start, null, keyProps, onError);
+      const keyNode = key2 ? composeNode(ctx, key2, keyProps, onError) : composeEmptyNode(ctx, keyStart, start, null, keyProps, onError);
       if (ctx.schema.compat)
-        utilFlowIndentCheck.flowIndentCheck(bm.indent, key, onError);
+        utilFlowIndentCheck.flowIndentCheck(bm.indent, key2, onError);
       ctx.atKey = false;
       if (utilMapIncludes.mapIncludes(ctx, map4.items, keyNode))
         onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
@@ -15678,7 +16025,7 @@ var require_resolve_block_map = __commonJS((exports) => {
         offset: keyNode.range[2],
         onError,
         parentIndent: bm.indent,
-        startOnNewline: !key || key.type === "block-scalar"
+        startOnNewline: !key2 || key2.type === "block-scalar"
       });
       offset = valueProps.end;
       if (valueProps.found) {
@@ -15834,11 +16181,11 @@ var require_resolve_flow_collection = __commonJS((exports) => {
     let offset = fc.offset + fc.start.source.length;
     for (let i = 0;i < fc.items.length; ++i) {
       const collItem = fc.items[i];
-      const { start, key, sep, value } = collItem;
+      const { start, key: key2, sep, value } = collItem;
       const props = resolveProps.resolveProps(start, {
         flow: fcName,
         indicator: "explicit-key-ind",
-        next: key ?? sep?.[0],
+        next: key2 ?? sep?.[0],
         offset,
         onError,
         parentIndent: fc.indent,
@@ -15860,8 +16207,8 @@ var require_resolve_flow_collection = __commonJS((exports) => {
           offset = props.end;
           continue;
         }
-        if (!isMap && ctx.options.strict && utilContainsNewline.containsNewline(key))
-          onError(key, "MULTILINE_IMPLICIT_KEY", "Implicit keys of flow sequence pairs need to be on a single line");
+        if (!isMap && ctx.options.strict && utilContainsNewline.containsNewline(key2))
+          onError(key2, "MULTILINE_IMPLICIT_KEY", "Implicit keys of flow sequence pairs need to be on a single line");
       }
       if (i === 0) {
         if (props.comma)
@@ -15906,8 +16253,8 @@ var require_resolve_flow_collection = __commonJS((exports) => {
       } else {
         ctx.atKey = true;
         const keyStart = props.end;
-        const keyNode = key ? composeNode(ctx, key, props, onError) : composeEmptyNode(ctx, keyStart, start, null, props, onError);
-        if (isBlock(key))
+        const keyNode = key2 ? composeNode(ctx, key2, props, onError) : composeEmptyNode(ctx, keyStart, start, null, props, onError);
+        if (isBlock(key2))
           onError(keyNode.range, "BLOCK_IN_FLOW", blockMsg);
         ctx.atKey = false;
         const valueProps = resolveProps.resolveProps(sep ?? [], {
@@ -17037,9 +17384,9 @@ var require_cst_scalar = __commonJS((exports) => {
       if (!addEndtoBlockProps(props, "end" in token ? token.end : undefined))
         props.push({ type: "newline", offset: -1, indent: indent2, source: `
 ` });
-      for (const key of Object.keys(token))
-        if (key !== "type" && key !== "offset")
-          delete token[key];
+      for (const key2 of Object.keys(token))
+        if (key2 !== "type" && key2 !== "offset")
+          delete token[key2];
       Object.assign(token, { type: "block-scalar", indent: indent2, props, source: body });
     }
   }
@@ -17088,9 +17435,9 @@ var require_cst_scalar = __commonJS((exports) => {
       default: {
         const indent2 = "indent" in token ? token.indent : -1;
         const end = "end" in token && Array.isArray(token.end) ? token.end.filter((st) => st.type === "space" || st.type === "comment" || st.type === "newline") : [];
-        for (const key of Object.keys(token))
-          if (key !== "type" && key !== "offset")
-            delete token[key];
+        for (const key2 of Object.keys(token))
+          if (key2 !== "type" && key2 !== "offset")
+            delete token[key2];
         Object.assign(token, { type, indent: indent2, source, end });
       }
     }
@@ -17142,12 +17489,12 @@ var require_cst_stringify = __commonJS((exports) => {
       }
     }
   }
-  function stringifyItem({ start, key, sep, value }) {
+  function stringifyItem({ start, key: key2, sep, value }) {
     let res = "";
     for (const st of start)
       res += st.source;
-    if (key)
-      res += stringifyToken(key);
+    if (key2)
+      res += stringifyToken(key2);
     if (sep)
       for (const st of sep)
         res += st.source;
@@ -18461,7 +18808,7 @@ var require_parser = __commonJS((exports) => {
                 });
               } else if (isFlowToken(it.key) && !includesToken(it.sep, "newline")) {
                 const start2 = getFirstKeyStartProps(it.start);
-                const key = it.key;
+                const key2 = it.key;
                 const sep = it.sep;
                 sep.push(this.sourceToken);
                 delete it.key;
@@ -18470,7 +18817,7 @@ var require_parser = __commonJS((exports) => {
                   type: "block-map",
                   offset: this.offset,
                   indent: this.indent,
-                  items: [{ start: start2, key, sep }]
+                  items: [{ start: start2, key: key2, sep }]
                 });
               } else if (start.length > 0) {
                 it.sep = it.sep.concat(start, this.sourceToken);
@@ -19025,9 +19372,9 @@ var init_types2 = __esm(() => {
 });
 
 // ../../node_modules/hastscript/node_modules/property-information/lib/util/defined-info.js
-function mark(values2, key, value) {
+function mark(values2, key2, value) {
   if (value) {
-    values2[key] = value;
+    values2[key2] = value;
   }
 }
 var checks, DefinedInfo;
@@ -20145,6 +20492,11 @@ function parse(value) {
   }
   return tokens;
 }
+function stringify(values2, options) {
+  const settings = options || {};
+  const input = values2[values2.length - 1] === "" ? [...values2, ""] : values2;
+  return input.join((settings.padRight ? " " : "") + "," + (settings.padLeft === false ? "" : " ")).trim();
+}
 
 // ../../node_modules/hast-util-parse-selector/lib/index.js
 function parseSelector(selector, defaultTagName) {
@@ -20196,6 +20548,9 @@ function parse2(value) {
   const input = String(value || "").trim();
   return input ? input.split(/[ \t\n\r\f]+/g) : [];
 }
+function stringify2(values2) {
+  return values2.join(" ").trim();
+}
 
 // ../../node_modules/hastscript/lib/create-h.js
 function createH(schema, defaultTagName, caseSensitive) {
@@ -20214,8 +20569,8 @@ function createH(schema, defaultTagName, caseSensitive) {
       if (isChild(properties)) {
         children.unshift(properties);
       } else {
-        for (const [key, value] of Object.entries(properties)) {
-          addProperty(schema, node2.properties, key, value);
+        for (const [key2, value] of Object.entries(properties)) {
+          addProperty(schema, node2.properties, key2, value);
         }
       }
     }
@@ -20238,8 +20593,8 @@ function isChild(value) {
     return false;
   const record = value;
   const keys = Object.keys(value);
-  for (const key of keys) {
-    const value2 = record[key];
+  for (const key2 of keys) {
+    const value2 = record[key2];
     if (value2 && typeof value2 === "object") {
       if (!Array.isArray(value2))
         return true;
@@ -20256,8 +20611,8 @@ function isChild(value) {
   }
   return false;
 }
-function addProperty(schema, properties, key, value) {
-  const info = find(schema, key);
+function addProperty(schema, properties, key2, value) {
+  const info = find(schema, key2);
   let result;
   if (value === null || value === undefined)
     return;
@@ -20324,8 +20679,8 @@ function parsePrimitive(info, name, value) {
 }
 function style(styles) {
   const result = [];
-  for (const [key, value] of Object.entries(styles)) {
-    result.push([key, value].join(": "));
+  for (const [key2, value] of Object.entries(styles)) {
+    result.push([key2, value].join(": "));
   }
   return result.join("; ");
 }
@@ -20485,9 +20840,9 @@ var init_types3 = __esm(() => {
 });
 
 // ../../node_modules/hast-util-from-parse5/node_modules/property-information/lib/util/defined-info.js
-function mark2(values2, key, value) {
+function mark2(values2, key2, value) {
   if (value) {
-    values2[key] = value;
+    values2[key2] = value;
   }
 }
 var checks2, DefinedInfo2;
@@ -21728,7 +22083,7 @@ function element(state, node2) {
   while (++index2 < node2.attrs.length) {
     const attribute = node2.attrs[index2];
     const name = (attribute.prefix ? attribute.prefix + ":" : "") + attribute.name;
-    if (!own6.call(proto, name)) {
+    if (!own7.call(proto, name)) {
       properties[name] = attribute.value;
     }
   }
@@ -21767,11 +22122,11 @@ function createLocation(state, node2, location2) {
     }
     if (state.verbose) {
       const properties = {};
-      let key;
+      let key2;
       if (location2.attrs) {
-        for (key in location2.attrs) {
-          if (own6.call(location2.attrs, key)) {
-            properties[find2(state.schema, key).property] = position2(location2.attrs[key]);
+        for (key2 in location2.attrs) {
+          if (own7.call(location2.attrs, key2)) {
+            properties[find2(state.schema, key2).property] = position2(location2.attrs[key2]);
           }
         }
       }
@@ -21803,14 +22158,14 @@ function position2(loc) {
 function point2(point3) {
   return point3.line && point3.column ? point3 : undefined;
 }
-var own6, proto;
+var own7, proto;
 var init_lib26 = __esm(() => {
   init_development();
   init_hastscript();
   init_property_information2();
   init_vfile_location();
   init_web_namespaces();
-  own6 = {}.hasOwnProperty;
+  own7 = {}.hasOwnProperty;
   proto = Object.prototype;
 });
 
@@ -29828,9 +30183,9 @@ var init_types4 = __esm(() => {
 });
 
 // ../../node_modules/property-information/lib/util/defined-info.js
-function mark3(values2, key, value) {
+function mark3(values2, key2, value) {
   if (value) {
-    values2[key] = value;
+    values2[key2] = value;
   }
 }
 var checks3, DefinedInfo3;
@@ -30985,11 +31340,11 @@ function convertHastNode(node2) {
 function hastPropsToJx(properties) {
   const attrs = {};
   const style2 = {};
-  for (const [key, value] of Object.entries(properties)) {
+  for (const [key2, value] of Object.entries(properties)) {
     if (value === false || value === undefined || value === null) {
       continue;
     }
-    const info = find3(html7, key);
+    const info = find3(html7, key2);
     const name = info.attribute;
     if (name === "style" && typeof value === "string") {
       parseInlineStyle(value, style2);
@@ -31648,8 +32003,8 @@ var require_common = __commonJS((exports, module) => {
     createDebug.enabled = enabled;
     createDebug.humanize = require_ms();
     createDebug.destroy = destroy;
-    Object.keys(env).forEach((key) => {
-      createDebug[key] = env[key];
+    Object.keys(env).forEach((key2) => {
+      createDebug[key2] = env[key2];
     });
     createDebug.names = [];
     createDebug.skips = [];
@@ -32176,13 +32531,13 @@ var require_node = __commonJS((exports, module) => {
       ];
     }
   } catch (error) {}
-  exports.inspectOpts = Object.keys(process.env).filter((key) => {
-    return /^debug_/i.test(key);
-  }).reduce((obj, key) => {
-    const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
+  exports.inspectOpts = Object.keys(process.env).filter((key2) => {
+    return /^debug_/i.test(key2);
+  }).reduce((obj, key2) => {
+    const prop = key2.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
       return k.toUpperCase();
     });
-    let val = process.env[key];
+    let val = process.env[key2];
     if (/^(yes|on|true|enabled)$/i.test(val)) {
       val = true;
     } else if (/^(no|off|false|disabled)$/i.test(val)) {
@@ -32856,7 +33211,7 @@ function compiler(options) {
     index2 = -1;
     while (++index2 < events.length) {
       const handler = config[events[index2][0]];
-      if (own7.call(handler, events[index2][1].type)) {
+      if (own8.call(handler, events[index2][1].type)) {
         handler[events[index2][1].type].call(Object.assign({ sliceSerialize: events[index2][2].sliceSerialize }, context), events[index2][1]);
       }
     }
@@ -33382,29 +33737,29 @@ function configure2(combined, extensions) {
   }
 }
 function extension(combined, extension2) {
-  let key;
-  for (key in extension2) {
-    if (own7.call(extension2, key)) {
-      switch (key) {
+  let key2;
+  for (key2 in extension2) {
+    if (own8.call(extension2, key2)) {
+      switch (key2) {
         case "canContainEols": {
-          const right = extension2[key];
+          const right = extension2[key2];
           if (right) {
-            combined[key].push(...right);
+            combined[key2].push(...right);
           }
           break;
         }
         case "transforms": {
-          const right = extension2[key];
+          const right = extension2[key2];
           if (right) {
-            combined[key].push(...right);
+            combined[key2].push(...right);
           }
           break;
         }
         case "enter":
         case "exit": {
-          const right = extension2[key];
+          const right = extension2[key2];
           if (right) {
-            Object.assign(combined[key], right);
+            Object.assign(combined[key2], right);
           }
           break;
         }
@@ -33419,7 +33774,7 @@ function defaultOnError(left, right) {
     throw new Error("Cannot close document, a token (`" + right.type + "`, " + stringifyPosition({ start: right.start, end: right.end }) + ") is still open");
   }
 }
-var own7;
+var own8;
 var init_lib29 = __esm(() => {
   init_development();
   init_mdast_util_to_string();
@@ -33430,7 +33785,7 @@ var init_lib29 = __esm(() => {
   init_default();
   init_decode_named_character_reference();
   init_unist_util_stringify_position();
-  own7 = {}.hasOwnProperty;
+  own8 = {}.hasOwnProperty;
 });
 
 // ../../node_modules/mdast-util-from-markdown/dev/index.js
@@ -33591,25 +33946,25 @@ function toMatters(options) {
 function matter(option) {
   let result = option;
   if (typeof result === "string") {
-    if (!own8.call(markers, result)) {
+    if (!own9.call(markers, result)) {
       throw fault("Missing matter definition for `%s`", result);
     }
     result = { type: result, marker: markers[result] };
   } else if (typeof result !== "object") {
     throw fault("Expected matter to be an object, not `%j`", result);
   }
-  if (!own8.call(result, "type")) {
+  if (!own9.call(result, "type")) {
     throw fault("Missing `type` in matter `%j`", result);
   }
-  if (!own8.call(result, "fence") && !own8.call(result, "marker")) {
+  if (!own9.call(result, "fence") && !own9.call(result, "marker")) {
     throw fault("Missing `marker` or `fence` in matter `%j`", result);
   }
   return result;
 }
-var own8, markers;
+var own9, markers;
 var init_to_matters = __esm(() => {
   init_fault();
-  own8 = {}.hasOwnProperty;
+  own9 = {}.hasOwnProperty;
   markers = { yaml: "-", toml: "+" };
 });
 
@@ -33910,9 +34265,9 @@ var require_convert = __commonJS((exports, module) => {
   function allFactory(test) {
     return all3;
     function all3(node2) {
-      var key;
-      for (key in test) {
-        if (node2[key] !== test[key])
+      var key2;
+      for (key2 in test) {
+        if (node2[key2] !== test[key2])
           return false;
       }
       return true;
@@ -34152,9 +34507,9 @@ var require_lodash = __commonJS((exports, module) => {
     }
     return false;
   }
-  function baseProperty(key) {
+  function baseProperty(key2) {
     return function(object) {
-      return object == null ? undefined : object[key];
+      return object == null ? undefined : object[key2];
     };
   }
   function baseTimes(n, iteratee2) {
@@ -34169,8 +34524,8 @@ var require_lodash = __commonJS((exports, module) => {
       return func(value2);
     };
   }
-  function getValue(object, key) {
-    return object == null ? undefined : object[key];
+  function getValue(object, key2) {
+    return object == null ? undefined : object[key2];
   }
   function isHostObject(value2) {
     var result = false;
@@ -34183,8 +34538,8 @@ var require_lodash = __commonJS((exports, module) => {
   }
   function mapToArray(map4) {
     var index2 = -1, result = Array(map4.size);
-    map4.forEach(function(value2, key) {
-      result[++index2] = [key, value2];
+    map4.forEach(function(value2, key2) {
+      result[++index2] = [key2, value2];
     });
     return result;
   }
@@ -34247,24 +34602,24 @@ var require_lodash = __commonJS((exports, module) => {
   function hashClear() {
     this.__data__ = nativeCreate ? nativeCreate(null) : {};
   }
-  function hashDelete(key) {
-    return this.has(key) && delete this.__data__[key];
+  function hashDelete(key2) {
+    return this.has(key2) && delete this.__data__[key2];
   }
-  function hashGet(key) {
+  function hashGet(key2) {
     var data = this.__data__;
     if (nativeCreate) {
-      var result = data[key];
+      var result = data[key2];
       return result === HASH_UNDEFINED ? undefined : result;
     }
-    return hasOwnProperty2.call(data, key) ? data[key] : undefined;
+    return hasOwnProperty2.call(data, key2) ? data[key2] : undefined;
   }
-  function hashHas(key) {
+  function hashHas(key2) {
     var data = this.__data__;
-    return nativeCreate ? data[key] !== undefined : hasOwnProperty2.call(data, key);
+    return nativeCreate ? data[key2] !== undefined : hasOwnProperty2.call(data, key2);
   }
-  function hashSet(key, value2) {
+  function hashSet(key2, value2) {
     var data = this.__data__;
-    data[key] = nativeCreate && value2 === undefined ? HASH_UNDEFINED : value2;
+    data[key2] = nativeCreate && value2 === undefined ? HASH_UNDEFINED : value2;
     return this;
   }
   Hash.prototype.clear = hashClear;
@@ -34283,8 +34638,8 @@ var require_lodash = __commonJS((exports, module) => {
   function listCacheClear() {
     this.__data__ = [];
   }
-  function listCacheDelete(key) {
-    var data = this.__data__, index2 = assocIndexOf(data, key);
+  function listCacheDelete(key2) {
+    var data = this.__data__, index2 = assocIndexOf(data, key2);
     if (index2 < 0) {
       return false;
     }
@@ -34296,17 +34651,17 @@ var require_lodash = __commonJS((exports, module) => {
     }
     return true;
   }
-  function listCacheGet(key) {
-    var data = this.__data__, index2 = assocIndexOf(data, key);
+  function listCacheGet(key2) {
+    var data = this.__data__, index2 = assocIndexOf(data, key2);
     return index2 < 0 ? undefined : data[index2][1];
   }
-  function listCacheHas(key) {
-    return assocIndexOf(this.__data__, key) > -1;
+  function listCacheHas(key2) {
+    return assocIndexOf(this.__data__, key2) > -1;
   }
-  function listCacheSet(key, value2) {
-    var data = this.__data__, index2 = assocIndexOf(data, key);
+  function listCacheSet(key2, value2) {
+    var data = this.__data__, index2 = assocIndexOf(data, key2);
     if (index2 < 0) {
-      data.push([key, value2]);
+      data.push([key2, value2]);
     } else {
       data[index2][1] = value2;
     }
@@ -34332,17 +34687,17 @@ var require_lodash = __commonJS((exports, module) => {
       string: new Hash
     };
   }
-  function mapCacheDelete(key) {
-    return getMapData(this, key)["delete"](key);
+  function mapCacheDelete(key2) {
+    return getMapData(this, key2)["delete"](key2);
   }
-  function mapCacheGet(key) {
-    return getMapData(this, key).get(key);
+  function mapCacheGet(key2) {
+    return getMapData(this, key2).get(key2);
   }
-  function mapCacheHas(key) {
-    return getMapData(this, key).has(key);
+  function mapCacheHas(key2) {
+    return getMapData(this, key2).has(key2);
   }
-  function mapCacheSet(key, value2) {
-    getMapData(this, key).set(key, value2);
+  function mapCacheSet(key2, value2) {
+    getMapData(this, key2).set(key2, value2);
     return this;
   }
   MapCache.prototype.clear = mapCacheClear;
@@ -34372,26 +34727,26 @@ var require_lodash = __commonJS((exports, module) => {
   function stackClear() {
     this.__data__ = new ListCache;
   }
-  function stackDelete(key) {
-    return this.__data__["delete"](key);
+  function stackDelete(key2) {
+    return this.__data__["delete"](key2);
   }
-  function stackGet(key) {
-    return this.__data__.get(key);
+  function stackGet(key2) {
+    return this.__data__.get(key2);
   }
-  function stackHas(key) {
-    return this.__data__.has(key);
+  function stackHas(key2) {
+    return this.__data__.has(key2);
   }
-  function stackSet(key, value2) {
+  function stackSet(key2, value2) {
     var cache = this.__data__;
     if (cache instanceof ListCache) {
       var pairs = cache.__data__;
       if (!Map2 || pairs.length < LARGE_ARRAY_SIZE - 1) {
-        pairs.push([key, value2]);
+        pairs.push([key2, value2]);
         return this;
       }
       cache = this.__data__ = new MapCache(pairs);
     }
-    cache.set(key, value2);
+    cache.set(key2, value2);
     return this;
   }
   Stack.prototype.clear = stackClear;
@@ -34402,23 +34757,23 @@ var require_lodash = __commonJS((exports, module) => {
   function arrayLikeKeys(value2, inherited) {
     var result = isArray(value2) || isArguments(value2) ? baseTimes(value2.length, String) : [];
     var length = result.length, skipIndexes = !!length;
-    for (var key in value2) {
-      if ((inherited || hasOwnProperty2.call(value2, key)) && !(skipIndexes && (key == "length" || isIndex(key, length)))) {
-        result.push(key);
+    for (var key2 in value2) {
+      if ((inherited || hasOwnProperty2.call(value2, key2)) && !(skipIndexes && (key2 == "length" || isIndex(key2, length)))) {
+        result.push(key2);
       }
     }
     return result;
   }
-  function assignValue(object, key, value2) {
-    var objValue = object[key];
-    if (!(hasOwnProperty2.call(object, key) && eq(objValue, value2)) || value2 === undefined && !(key in object)) {
-      object[key] = value2;
+  function assignValue(object, key2, value2) {
+    var objValue = object[key2];
+    if (!(hasOwnProperty2.call(object, key2) && eq(objValue, value2)) || value2 === undefined && !(key2 in object)) {
+      object[key2] = value2;
     }
   }
-  function assocIndexOf(array, key) {
+  function assocIndexOf(array, key2) {
     var length = array.length;
     while (length--) {
-      if (eq(array[length][0], key)) {
+      if (eq(array[length][0], key2)) {
         return length;
       }
     }
@@ -34427,10 +34782,10 @@ var require_lodash = __commonJS((exports, module) => {
   function baseAssign(object, source) {
     return object && copyObject(source, keys(source), object);
   }
-  function baseClone(value2, isDeep, isFull, customizer, key, object, stack) {
+  function baseClone(value2, isDeep, isFull, customizer, key2, object, stack) {
     var result;
     if (customizer) {
-      result = object ? customizer(value2, key, object, stack) : customizer(value2);
+      result = object ? customizer(value2, key2, object, stack) : customizer(value2);
     }
     if (result !== undefined) {
       return result;
@@ -34473,12 +34828,12 @@ var require_lodash = __commonJS((exports, module) => {
     if (!isArr) {
       var props = isFull ? getAllKeys(value2) : keys(value2);
     }
-    arrayEach(props || value2, function(subValue, key2) {
+    arrayEach(props || value2, function(subValue, key3) {
       if (props) {
-        key2 = subValue;
-        subValue = value2[key2];
+        key3 = subValue;
+        subValue = value2[key3];
       }
-      assignValue(result, key2, baseClone(subValue, isDeep, isFull, customizer, key2, value2, stack));
+      assignValue(result, key3, baseClone(subValue, isDeep, isFull, customizer, key3, value2, stack));
     });
     return result;
   }
@@ -34500,8 +34855,8 @@ var require_lodash = __commonJS((exports, module) => {
   function baseGetTag(value2) {
     return objectToString.call(value2);
   }
-  function baseHasIn(object, key) {
-    return object != null && key in Object(object);
+  function baseHasIn(object, key2) {
+    return object != null && key2 in Object(object);
   }
   function baseIsEqual(value2, other, customizer, bitmask, stack) {
     if (value2 === other) {
@@ -34555,15 +34910,15 @@ var require_lodash = __commonJS((exports, module) => {
     }
     while (++index2 < length) {
       data = matchData[index2];
-      var key = data[0], objValue = object[key], srcValue = data[1];
+      var key2 = data[0], objValue = object[key2], srcValue = data[1];
       if (noCustomizer && data[2]) {
-        if (objValue === undefined && !(key in object)) {
+        if (objValue === undefined && !(key2 in object)) {
           return false;
         }
       } else {
         var stack = new Stack;
         if (customizer) {
-          var result = customizer(objValue, srcValue, key, object, source, stack);
+          var result = customizer(objValue, srcValue, key2, object, source, stack);
         }
         if (!(result === undefined ? baseIsEqual(srcValue, objValue, customizer, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG, stack) : result)) {
           return false;
@@ -34599,9 +34954,9 @@ var require_lodash = __commonJS((exports, module) => {
       return nativeKeys(object);
     }
     var result = [];
-    for (var key in Object(object)) {
-      if (hasOwnProperty2.call(object, key) && key != "constructor") {
-        result.push(key);
+    for (var key2 in Object(object)) {
+      if (hasOwnProperty2.call(object, key2) && key2 != "constructor") {
+        result.push(key2);
       }
     }
     return result;
@@ -34691,9 +35046,9 @@ var require_lodash = __commonJS((exports, module) => {
     object || (object = {});
     var index2 = -1, length = props.length;
     while (++index2 < length) {
-      var key = props[index2];
-      var newValue = customizer ? customizer(object[key], source[key], key, object, source) : undefined;
-      assignValue(object, key, newValue === undefined ? source[key] : newValue);
+      var key2 = props[index2];
+      var newValue = customizer ? customizer(object[key2], source[key2], key2, object, source) : undefined;
+      assignValue(object, key2, newValue === undefined ? source[key2] : newValue);
     }
     return object;
   }
@@ -34795,8 +35150,8 @@ var require_lodash = __commonJS((exports, module) => {
     }
     var index2 = objLength;
     while (index2--) {
-      var key = objProps[index2];
-      if (!(isPartial ? key in other : hasOwnProperty2.call(other, key))) {
+      var key2 = objProps[index2];
+      if (!(isPartial ? key2 in other : hasOwnProperty2.call(other, key2))) {
         return false;
       }
     }
@@ -34809,16 +35164,16 @@ var require_lodash = __commonJS((exports, module) => {
     stack.set(other, object);
     var skipCtor = isPartial;
     while (++index2 < objLength) {
-      key = objProps[index2];
-      var objValue = object[key], othValue = other[key];
+      key2 = objProps[index2];
+      var objValue = object[key2], othValue = other[key2];
       if (customizer) {
-        var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
+        var compared = isPartial ? customizer(othValue, objValue, key2, other, object, stack) : customizer(objValue, othValue, key2, object, other, stack);
       }
       if (!(compared === undefined ? objValue === othValue || equalFunc(objValue, othValue, customizer, bitmask, stack) : compared)) {
         result = false;
         break;
       }
-      skipCtor || (skipCtor = key == "constructor");
+      skipCtor || (skipCtor = key2 == "constructor");
     }
     if (result && !skipCtor) {
       var objCtor = object.constructor, othCtor = other.constructor;
@@ -34833,20 +35188,20 @@ var require_lodash = __commonJS((exports, module) => {
   function getAllKeys(object) {
     return baseGetAllKeys(object, keys, getSymbols);
   }
-  function getMapData(map4, key) {
+  function getMapData(map4, key2) {
     var data = map4.__data__;
-    return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+    return isKeyable(key2) ? data[typeof key2 == "string" ? "string" : "hash"] : data.map;
   }
   function getMatchData(object) {
     var result = keys(object), length = result.length;
     while (length--) {
-      var key = result[length], value2 = object[key];
-      result[length] = [key, value2, isStrictComparable(value2)];
+      var key2 = result[length], value2 = object[key2];
+      result[length] = [key2, value2, isStrictComparable(value2)];
     }
     return result;
   }
-  function getNative(object, key) {
-    var value2 = getValue(object, key);
+  function getNative(object, key2) {
+    var value2 = getValue(object, key2);
     return baseIsNative(value2) ? value2 : undefined;
   }
   var getSymbols = nativeGetSymbols ? overArg(nativeGetSymbols, Object) : stubArray;
@@ -34875,17 +35230,17 @@ var require_lodash = __commonJS((exports, module) => {
     path2 = isKey(path2, object) ? [path2] : castPath(path2);
     var result, index2 = -1, length = path2.length;
     while (++index2 < length) {
-      var key = toKey(path2[index2]);
-      if (!(result = object != null && hasFunc(object, key))) {
+      var key2 = toKey(path2[index2]);
+      if (!(result = object != null && hasFunc(object, key2))) {
         break;
       }
-      object = object[key];
+      object = object[key2];
     }
     if (result) {
       return result;
     }
     var length = object ? object.length : 0;
-    return !!length && isLength(length) && isIndex(key, length) && (isArray(object) || isArguments(object));
+    return !!length && isLength(length) && isIndex(key2, length) && (isArray(object) || isArguments(object));
   }
   function initCloneArray(array) {
     var length = array.length, result = array.constructor(length);
@@ -34959,12 +35314,12 @@ var require_lodash = __commonJS((exports, module) => {
   function isStrictComparable(value2) {
     return value2 === value2 && !isObject(value2);
   }
-  function matchesStrictComparable(key, srcValue) {
+  function matchesStrictComparable(key2, srcValue) {
     return function(object) {
       if (object == null) {
         return false;
       }
-      return object[key] === srcValue && (srcValue !== undefined || (key in Object(object)));
+      return object[key2] === srcValue && (srcValue !== undefined || (key2 in Object(object)));
     };
   }
   var stringToPath = memoize(function(string3) {
@@ -35001,12 +35356,12 @@ var require_lodash = __commonJS((exports, module) => {
       throw new TypeError(FUNC_ERROR_TEXT);
     }
     var memoized = function() {
-      var args = arguments, key = resolver2 ? resolver2.apply(this, args) : args[0], cache = memoized.cache;
-      if (cache.has(key)) {
-        return cache.get(key);
+      var args = arguments, key2 = resolver2 ? resolver2.apply(this, args) : args[0], cache = memoized.cache;
+      if (cache.has(key2)) {
+        return cache.get(key2);
       }
       var result = func.apply(this, args);
-      memoized.cache = cache.set(key, result);
+      memoized.cache = cache.set(key2, result);
       return result;
     };
     memoized.cache = new (memoize.Cache || MapCache);
@@ -35438,14 +35793,14 @@ ${offset}${err}${errEnd}`;
       this.type = type;
       this.value = null;
     }
-    getPropValue(idx, key, skipKey) {
+    getPropValue(idx, key2, skipKey) {
       if (!this.context)
         return null;
       const {
         src
       } = this.context;
       const prop = this.props[idx];
-      return prop && src[prop.start] === key ? src.slice(prop.start + (skipKey ? 1 : 0), prop.end) : null;
+      return prop && src[prop.start] === key2 ? src.slice(prop.start + (skipKey ? 1 : 0), prop.end) : null;
     }
     get anchor() {
       for (let i = 0;i < this.props.length; ++i) {
@@ -37395,27 +37750,27 @@ ${indent2}${str}`;
       if (isEmptyPath(path2))
         this.add(value2);
       else {
-        const [key, ...rest] = path2;
-        const node2 = this.get(key, true);
+        const [key2, ...rest] = path2;
+        const node2 = this.get(key2, true);
         if (node2 instanceof Collection)
           node2.addIn(rest, value2);
         else if (node2 === undefined && this.schema)
-          this.set(key, collectionFromPath(this.schema, rest, value2));
+          this.set(key2, collectionFromPath(this.schema, rest, value2));
         else
-          throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+          throw new Error(`Expected YAML collection at ${key2}. Remaining path: ${rest}`);
       }
     }
-    deleteIn([key, ...rest]) {
+    deleteIn([key2, ...rest]) {
       if (rest.length === 0)
-        return this.delete(key);
-      const node2 = this.get(key, true);
+        return this.delete(key2);
+      const node2 = this.get(key2, true);
       if (node2 instanceof Collection)
         return node2.deleteIn(rest);
       else
-        throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+        throw new Error(`Expected YAML collection at ${key2}. Remaining path: ${rest}`);
     }
-    getIn([key, ...rest], keepScalar) {
-      const node2 = this.get(key, true);
+    getIn([key2, ...rest], keepScalar) {
+      const node2 = this.get(key2, true);
       if (rest.length === 0)
         return !keepScalar && node2 instanceof Scalar2 ? node2.value : node2;
       else
@@ -37429,23 +37784,23 @@ ${indent2}${str}`;
         return n == null || n instanceof Scalar2 && n.value == null && !n.commentBefore && !n.comment && !n.tag;
       });
     }
-    hasIn([key, ...rest]) {
+    hasIn([key2, ...rest]) {
       if (rest.length === 0)
-        return this.has(key);
-      const node2 = this.get(key, true);
+        return this.has(key2);
+      const node2 = this.get(key2, true);
       return node2 instanceof Collection ? node2.hasIn(rest) : false;
     }
-    setIn([key, ...rest], value2) {
+    setIn([key2, ...rest], value2) {
       if (rest.length === 0) {
-        this.set(key, value2);
+        this.set(key2, value2);
       } else {
-        const node2 = this.get(key, true);
+        const node2 = this.get(key2, true);
         if (node2 instanceof Collection)
           node2.setIn(rest, value2);
         else if (node2 === undefined && this.schema)
-          this.set(key, collectionFromPath(this.schema, rest, value2));
+          this.set(key2, collectionFromPath(this.schema, rest, value2));
         else
-          throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+          throw new Error(`Expected YAML collection at ${key2}. Remaining path: ${rest}`);
       }
     }
     toJSON() {
@@ -37460,7 +37815,7 @@ ${indent2}${str}`;
       const {
         indent: indent2,
         indentStep,
-        stringify
+        stringify: stringify3
       } = ctx;
       const inFlow = this.type === PlainValue.Type.FLOW_MAP || this.type === PlainValue.Type.FLOW_SEQ || ctx.inFlow;
       if (inFlow)
@@ -37495,7 +37850,7 @@ ${indent2}${str}`;
             hasItemWithNewLine = true;
         }
         chompKeep = false;
-        let str2 = stringify(item, ctx, () => comment = null, () => chompKeep = true);
+        let str2 = stringify3(item, ctx, () => comment = null, () => chompKeep = true);
         if (inFlow && !hasItemWithNewLine && str2.includes(`
 `))
           hasItemWithNewLine = true;
@@ -37550,8 +37905,8 @@ ${indent2}${s2}` : `
     }
   }
   PlainValue._defineProperty(Collection, "maxFlowStringSingleLineLength", 60);
-  function asItemIndex(key) {
-    let idx = key instanceof Scalar2 ? key.value : key;
+  function asItemIndex(key2) {
+    let idx = key2 instanceof Scalar2 ? key2.value : key2;
     if (idx && typeof idx === "string")
       idx = Number(idx);
     return Number.isInteger(idx) && idx >= 0 ? idx : null;
@@ -37561,28 +37916,28 @@ ${indent2}${s2}` : `
     add(value2) {
       this.items.push(value2);
     }
-    delete(key) {
-      const idx = asItemIndex(key);
+    delete(key2) {
+      const idx = asItemIndex(key2);
       if (typeof idx !== "number")
         return false;
       const del = this.items.splice(idx, 1);
       return del.length > 0;
     }
-    get(key, keepScalar) {
-      const idx = asItemIndex(key);
+    get(key2, keepScalar) {
+      const idx = asItemIndex(key2);
       if (typeof idx !== "number")
         return;
       const it = this.items[idx];
       return !keepScalar && it instanceof Scalar2 ? it.value : it;
     }
-    has(key) {
-      const idx = asItemIndex(key);
+    has(key2) {
+      const idx = asItemIndex(key2);
       return typeof idx === "number" && idx < this.items.length;
     }
-    set(key, value2) {
-      const idx = asItemIndex(key);
+    set(key2, value2) {
+      const idx = asItemIndex(key2);
       if (typeof idx !== "number")
-        throw new Error(`Expected a valid index, not ${key}.`);
+        throw new Error(`Expected a valid index, not ${key2}.`);
       this.items[idx] = value2;
     }
     toJSON(_, ctx) {
@@ -37608,13 +37963,13 @@ ${indent2}${s2}` : `
       }, onComment, onChompKeep);
     }
   }
-  var stringifyKey = (key, jsKey, ctx) => {
+  var stringifyKey = (key2, jsKey, ctx) => {
     if (jsKey === null)
       return "";
     if (typeof jsKey !== "object")
       return String(jsKey);
-    if (key instanceof Node && ctx && ctx.doc)
-      return key.toString({
+    if (key2 instanceof Node && ctx && ctx.doc)
+      return key2.toString({
         anchors: Object.create(null),
         doc: ctx.doc,
         indent: "",
@@ -37627,9 +37982,9 @@ ${indent2}${s2}` : `
   };
 
   class Pair2 extends Node {
-    constructor(key, value2 = null) {
+    constructor(key2, value2 = null) {
       super();
-      this.key = key;
+      this.key = key2;
       this.value = value2;
       this.type = Pair2.Type.PAIR;
     }
@@ -37647,14 +38002,14 @@ ${indent2}${s2}` : `
       }
     }
     addToJSMap(ctx, map4) {
-      const key = toJSON(this.key, "", ctx);
+      const key2 = toJSON(this.key, "", ctx);
       if (map4 instanceof Map) {
-        const value2 = toJSON(this.value, key, ctx);
-        map4.set(key, value2);
+        const value2 = toJSON(this.value, key2, ctx);
+        map4.set(key2, value2);
       } else if (map4 instanceof Set) {
-        map4.add(key);
+        map4.add(key2);
       } else {
-        const stringKey = stringifyKey(this.key, key, ctx);
+        const stringKey = stringifyKey(this.key, key2, ctx);
         const value2 = toJSON(this.value, stringKey, ctx);
         if (stringKey in map4)
           Object.defineProperty(map4, stringKey, {
@@ -37681,32 +38036,32 @@ ${indent2}${s2}` : `
         simpleKeys
       } = ctx.doc.options;
       let {
-        key,
+        key: key2,
         value: value2
       } = this;
-      let keyComment = key instanceof Node && key.comment;
+      let keyComment = key2 instanceof Node && key2.comment;
       if (simpleKeys) {
         if (keyComment) {
           throw new Error("With simple keys, key nodes cannot have comments");
         }
-        if (key instanceof Collection) {
+        if (key2 instanceof Collection) {
           const msg = "With simple keys, collection cannot be used as a key value";
           throw new Error(msg);
         }
       }
-      let explicitKey = !simpleKeys && (!key || keyComment || (key instanceof Node ? key instanceof Collection || key.type === PlainValue.Type.BLOCK_FOLDED || key.type === PlainValue.Type.BLOCK_LITERAL : typeof key === "object"));
+      let explicitKey = !simpleKeys && (!key2 || keyComment || (key2 instanceof Node ? key2 instanceof Collection || key2.type === PlainValue.Type.BLOCK_FOLDED || key2.type === PlainValue.Type.BLOCK_LITERAL : typeof key2 === "object"));
       const {
         doc,
         indent: indent2,
         indentStep,
-        stringify
+        stringify: stringify3
       } = ctx;
       ctx = Object.assign({}, ctx, {
         implicitKey: !explicitKey,
         indent: indent2 + indentStep
       });
       let chompKeep = false;
-      let str = stringify(key, ctx, () => keyComment = null, () => chompKeep = true);
+      let str = stringify3(key2, ctx, () => keyComment = null, () => chompKeep = true);
       str = addComment(str, ctx.indent, keyComment);
       if (!explicitKey && str.length > 1024) {
         if (simpleKeys)
@@ -37751,7 +38106,7 @@ ${cs}`;
       if (!indentSeq && indentSize >= 2 && !ctx.inFlow && !explicitKey && value2 instanceof YAMLSeq2 && value2.type !== PlainValue.Type.FLOW_SEQ && !value2.tag && !doc.anchors.getName(value2)) {
         ctx.indent = ctx.indent.substr(2);
       }
-      const valueStr = stringify(value2, ctx, () => valueComment = null, () => chompKeep = true);
+      const valueStr = stringify3(value2, ctx, () => valueComment = null, () => chompKeep = true);
       let ws = " ";
       if (vcb || this.comment) {
         ws = `${vcb}
@@ -37854,11 +38209,11 @@ ${ctx.indent}`;
     }
   }
   PlainValue._defineProperty(Alias2, "default", true);
-  function findPair(items, key) {
-    const k = key instanceof Scalar2 ? key.value : key;
+  function findPair(items, key2) {
+    const k = key2 instanceof Scalar2 ? key2.value : key2;
     for (const it of items) {
       if (it instanceof Pair2) {
-        if (it.key === key || it.key === k)
+        if (it.key === key2 || it.key === k)
           return it;
         if (it.key && it.key.value === k)
           return it;
@@ -37890,23 +38245,23 @@ ${ctx.indent}`;
         this.items.push(pair);
       }
     }
-    delete(key) {
-      const it = findPair(this.items, key);
+    delete(key2) {
+      const it = findPair(this.items, key2);
       if (!it)
         return false;
       const del = this.items.splice(this.items.indexOf(it), 1);
       return del.length > 0;
     }
-    get(key, keepScalar) {
-      const it = findPair(this.items, key);
+    get(key2, keepScalar) {
+      const it = findPair(this.items, key2);
       const node2 = it && it.value;
       return !keepScalar && node2 instanceof Scalar2 ? node2.value : node2;
     }
-    has(key) {
-      return !!findPair(this.items, key);
+    has(key2) {
+      return !!findPair(this.items, key2);
     }
-    set(key, value2) {
-      this.add(new Pair2(key, value2), true);
+    set(key2, value2) {
+      this.add(new Pair2(key2, value2), true);
     }
     toJSON(_, ctx, Type) {
       const map4 = Type ? new Type : ctx && ctx.mapAsMap ? new Map : {};
@@ -37959,14 +38314,14 @@ ${ctx.indent}`;
         if (!(source instanceof YAMLMap2))
           throw new Error("Merge sources must be maps");
         const srcMap = source.toJSON(null, ctx, Map);
-        for (const [key, value2] of srcMap) {
+        for (const [key2, value2] of srcMap) {
           if (map4 instanceof Map) {
-            if (!map4.has(key))
-              map4.set(key, value2);
+            if (!map4.has(key2))
+              map4.set(key2, value2);
           } else if (map4 instanceof Set) {
-            map4.add(key);
-          } else if (!Object.prototype.hasOwnProperty.call(map4, key)) {
-            Object.defineProperty(map4, key, {
+            map4.add(key2);
+          } else if (!Object.prototype.hasOwnProperty.call(map4, key2)) {
+            Object.defineProperty(map4, key2, {
               value: value2,
               writable: true,
               enumerable: true,
@@ -38510,8 +38865,8 @@ ${indent2}`);
       errors3.push(new PlainValue.YAMLSemanticError(comment, msg));
     }
   }
-  function getLongKeyError(source, key) {
-    const sk = String(key);
+  function getLongKeyError(source, key2) {
+    const sk = String(key2);
     const k = sk.substr(0, 8) + "..." + sk.substr(-8);
     return new PlainValue.YAMLSemanticError(source, `The "${k}" key is too long`);
   }
@@ -38939,36 +39294,36 @@ ${ca}` : ca;
   function resolveBlockMapItems(doc, cst2) {
     const comments = [];
     const items = [];
-    let key = undefined;
+    let key2 = undefined;
     let keyStart = null;
     for (let i = 0;i < cst2.items.length; ++i) {
       const item = cst2.items[i];
       switch (item.type) {
         case PlainValue.Type.BLANK_LINE:
           comments.push({
-            afterKey: !!key,
+            afterKey: !!key2,
             before: items.length
           });
           break;
         case PlainValue.Type.COMMENT:
           comments.push({
-            afterKey: !!key,
+            afterKey: !!key2,
             before: items.length,
             comment: item.comment
           });
           break;
         case PlainValue.Type.MAP_KEY:
-          if (key !== undefined)
-            items.push(new Pair2(key));
+          if (key2 !== undefined)
+            items.push(new Pair2(key2));
           if (item.error)
             doc.errors.push(item.error);
-          key = resolveNode(doc, item.node);
+          key2 = resolveNode(doc, item.node);
           keyStart = null;
           break;
         case PlainValue.Type.MAP_VALUE:
           {
-            if (key === undefined)
-              key = null;
+            if (key2 === undefined)
+              key2 = null;
             if (item.error)
               doc.errors.push(item.error);
             if (!item.context.atLineStart && item.node && item.node.type === PlainValue.Type.MAP && !item.node.context.atLineStart) {
@@ -38997,21 +39352,21 @@ ${ca}` : ca;
                 valueNode.valueRange.origStart = valueNode.valueRange.origEnd = origPos;
               }
             }
-            const pair = new Pair2(key, resolveNode(doc, valueNode));
+            const pair = new Pair2(key2, resolveNode(doc, valueNode));
             resolvePairComment(item, pair);
             items.push(pair);
-            if (key && typeof keyStart === "number") {
+            if (key2 && typeof keyStart === "number") {
               if (item.range.start > keyStart + 1024)
-                doc.errors.push(getLongKeyError(cst2, key));
+                doc.errors.push(getLongKeyError(cst2, key2));
             }
-            key = undefined;
+            key2 = undefined;
             keyStart = null;
           }
           break;
         default:
-          if (key !== undefined)
-            items.push(new Pair2(key));
-          key = resolveNode(doc, item);
+          if (key2 !== undefined)
+            items.push(new Pair2(key2));
+          key2 = resolveNode(doc, item);
           keyStart = item.range.start;
           if (item.error)
             doc.errors.push(item.error);
@@ -39037,8 +39392,8 @@ ${ca}` : ca;
           }
       }
     }
-    if (key !== undefined)
-      items.push(new Pair2(key));
+    if (key2 !== undefined)
+      items.push(new Pair2(key2));
     return {
       comments,
       items
@@ -39047,7 +39402,7 @@ ${ca}` : ca;
   function resolveFlowMapItems(doc, cst2) {
     const comments = [];
     const items = [];
-    let key = undefined;
+    let key2 = undefined;
     let explicitKey = false;
     let next2 = "{";
     for (let i = 0;i < cst2.items.length; ++i) {
@@ -39057,27 +39412,27 @@ ${ca}` : ca;
           char,
           offset
         } = item;
-        if (char === "?" && key === undefined && !explicitKey) {
+        if (char === "?" && key2 === undefined && !explicitKey) {
           explicitKey = true;
           next2 = ":";
           continue;
         }
         if (char === ":") {
-          if (key === undefined)
-            key = null;
+          if (key2 === undefined)
+            key2 = null;
           if (next2 === ":") {
             next2 = ",";
             continue;
           }
         } else {
           if (explicitKey) {
-            if (key === undefined && char !== ",")
-              key = null;
+            if (key2 === undefined && char !== ",")
+              key2 = null;
             explicitKey = false;
           }
-          if (key !== undefined) {
-            items.push(new Pair2(key));
-            key = undefined;
+          if (key2 !== undefined) {
+            items.push(new Pair2(key2));
+            key2 = undefined;
             if (char === ",") {
               next2 = ":";
               continue;
@@ -39097,31 +39452,31 @@ ${ca}` : ca;
         doc.errors.push(err);
       } else if (item.type === PlainValue.Type.BLANK_LINE) {
         comments.push({
-          afterKey: !!key,
+          afterKey: !!key2,
           before: items.length
         });
       } else if (item.type === PlainValue.Type.COMMENT) {
         checkFlowCommentSpace(doc.errors, item);
         comments.push({
-          afterKey: !!key,
+          afterKey: !!key2,
           before: items.length,
           comment: item.comment
         });
-      } else if (key === undefined) {
+      } else if (key2 === undefined) {
         if (next2 === ",")
           doc.errors.push(new PlainValue.YAMLSemanticError(item, "Separator , missing in flow map"));
-        key = resolveNode(doc, item);
+        key2 = resolveNode(doc, item);
       } else {
         if (next2 !== ",")
           doc.errors.push(new PlainValue.YAMLSemanticError(item, "Indicator : missing in flow map entry"));
-        items.push(new Pair2(key, resolveNode(doc, item)));
-        key = undefined;
+        items.push(new Pair2(key2, resolveNode(doc, item)));
+        key2 = undefined;
         explicitKey = false;
       }
     }
     checkFlowCollectionEnd(doc.errors, cst2);
-    if (key !== undefined)
-      items.push(new Pair2(key));
+    if (key2 !== undefined)
+      items.push(new Pair2(key2));
     return {
       comments,
       items
@@ -39188,7 +39543,7 @@ ${ca}` : ca;
     const comments = [];
     const items = [];
     let explicitKey = false;
-    let key = undefined;
+    let key2 = undefined;
     let keyStart = null;
     let next2 = "[";
     let prevItem = null;
@@ -39199,22 +39554,22 @@ ${ca}` : ca;
           char,
           offset
         } = item;
-        if (char !== ":" && (explicitKey || key !== undefined)) {
-          if (explicitKey && key === undefined)
-            key = next2 ? items.pop() : null;
-          items.push(new Pair2(key));
+        if (char !== ":" && (explicitKey || key2 !== undefined)) {
+          if (explicitKey && key2 === undefined)
+            key2 = next2 ? items.pop() : null;
+          items.push(new Pair2(key2));
           explicitKey = false;
-          key = undefined;
+          key2 = undefined;
           keyStart = null;
         }
         if (char === next2) {
           next2 = null;
         } else if (!next2 && char === "?") {
           explicitKey = true;
-        } else if (next2 !== "[" && char === ":" && key === undefined) {
+        } else if (next2 !== "[" && char === ":" && key2 === undefined) {
           if (next2 === ",") {
-            key = items.pop();
-            if (key instanceof Pair2) {
+            key2 = items.pop();
+            if (key2 instanceof Pair2) {
               const msg = "Chaining flow sequence pairs is invalid";
               const err = new PlainValue.YAMLSemanticError(cst2, msg);
               err.offset = offset;
@@ -39223,7 +39578,7 @@ ${ca}` : ca;
             if (!explicitKey && typeof keyStart === "number") {
               const keyEnd = item.range ? item.range.start : item.offset;
               if (keyEnd > keyStart + 1024)
-                doc.errors.push(getLongKeyError(cst2, key));
+                doc.errors.push(getLongKeyError(cst2, key2));
               const {
                 src
               } = prevItem.context;
@@ -39236,7 +39591,7 @@ ${ca}` : ca;
                 }
             }
           } else {
-            key = null;
+            key2 = null;
           }
           keyStart = null;
           explicitKey = false;
@@ -39263,20 +39618,20 @@ ${ca}` : ca;
           doc.errors.push(new PlainValue.YAMLSemanticError(item, msg));
         }
         const value2 = resolveNode(doc, item);
-        if (key === undefined) {
+        if (key2 === undefined) {
           items.push(value2);
           prevItem = item;
         } else {
-          items.push(new Pair2(key, value2));
-          key = undefined;
+          items.push(new Pair2(key2, value2));
+          key2 = undefined;
         }
         keyStart = item.range.start;
         next2 = ",";
       }
     }
     checkFlowCollectionEnd(doc.errors, cst2);
-    if (key !== undefined)
-      items.push(new Pair2(key));
+    if (key2 !== undefined)
+      items.push(new Pair2(key2));
     return {
       comments,
       items
@@ -39399,24 +39754,24 @@ ${pair.comment}` : item.comment;
     const pairs2 = new resolveSeq.YAMLSeq(schema);
     pairs2.tag = "tag:yaml.org,2002:pairs";
     for (const it of iterable) {
-      let key, value2;
+      let key2, value2;
       if (Array.isArray(it)) {
         if (it.length === 2) {
-          key = it[0];
+          key2 = it[0];
           value2 = it[1];
         } else
           throw new TypeError(`Expected [key, value] tuple: ${it}`);
       } else if (it && it instanceof Object) {
         const keys = Object.keys(it);
         if (keys.length === 1) {
-          key = keys[0];
-          value2 = it[key];
+          key2 = keys[0];
+          value2 = it[key2];
         } else
           throw new TypeError(`Expected { key: value } tuple: ${it}`);
       } else {
-        key = it;
+        key2 = it;
       }
-      const pair = schema.createPair(key, value2, ctx);
+      const pair = schema.createPair(key2, value2, ctx);
       pairs2.items.push(pair);
     }
     return pairs2;
@@ -39443,16 +39798,16 @@ ${pair.comment}` : item.comment;
       if (ctx && ctx.onCreate)
         ctx.onCreate(map4);
       for (const pair of this.items) {
-        let key, value2;
+        let key2, value2;
         if (pair instanceof resolveSeq.Pair) {
-          key = resolveSeq.toJSON(pair.key, "", ctx);
-          value2 = resolveSeq.toJSON(pair.value, key, ctx);
+          key2 = resolveSeq.toJSON(pair.key, "", ctx);
+          value2 = resolveSeq.toJSON(pair.value, key2, ctx);
         } else {
-          key = resolveSeq.toJSON(pair, "", ctx);
+          key2 = resolveSeq.toJSON(pair, "", ctx);
         }
-        if (map4.has(key))
+        if (map4.has(key2))
           throw new Error("Ordered maps must not include duplicate keys");
-        map4.set(key, value2);
+        map4.set(key2, value2);
       }
       return map4;
     }
@@ -39462,14 +39817,14 @@ ${pair.comment}` : item.comment;
     const pairs2 = parsePairs(doc, cst2);
     const seenKeys = [];
     for (const {
-      key
+      key: key2
     } of pairs2.items) {
-      if (key instanceof resolveSeq.Scalar) {
-        if (seenKeys.includes(key.value)) {
+      if (key2 instanceof resolveSeq.Scalar) {
+        if (seenKeys.includes(key2.value)) {
           const msg = "Ordered maps must not include duplicate keys";
           throw new PlainValue.YAMLSemanticError(cst2, msg);
         } else {
-          seenKeys.push(key.value);
+          seenKeys.push(key2.value);
         }
       }
     }
@@ -39495,24 +39850,24 @@ ${pair.comment}` : item.comment;
       super();
       this.tag = YAMLSet.tag;
     }
-    add(key) {
-      const pair = key instanceof resolveSeq.Pair ? key : new resolveSeq.Pair(key);
+    add(key2) {
+      const pair = key2 instanceof resolveSeq.Pair ? key2 : new resolveSeq.Pair(key2);
       const prev = resolveSeq.findPair(this.items, pair.key);
       if (!prev)
         this.items.push(pair);
     }
-    get(key, keepPair) {
-      const pair = resolveSeq.findPair(this.items, key);
+    get(key2, keepPair) {
+      const pair = resolveSeq.findPair(this.items, key2);
       return !keepPair && pair instanceof resolveSeq.Pair ? pair.key instanceof resolveSeq.Scalar ? pair.key.value : pair.key : pair;
     }
-    set(key, value2) {
+    set(key2, value2) {
       if (typeof value2 !== "boolean")
         throw new Error(`Expected boolean value for set(key, value) in a YAML set, not ${typeof value2}`);
-      const prev = resolveSeq.findPair(this.items, key);
+      const prev = resolveSeq.findPair(this.items, key2);
       if (prev && !value2) {
         this.items.splice(this.items.indexOf(prev), 1);
       } else if (!prev && value2) {
-        this.items.push(new resolveSeq.Pair(key));
+        this.items.push(new resolveSeq.Pair(key2));
       }
     }
     toJSON(_, ctx) {
@@ -39670,11 +40025,11 @@ var require_Schema_bcc6c2d7 = __commonJS((exports) => {
   function createMap(schema, obj, ctx) {
     const map5 = new resolveSeq.YAMLMap(schema);
     if (obj instanceof Map) {
-      for (const [key, value2] of obj)
-        map5.items.push(schema.createPair(key, value2, ctx));
+      for (const [key2, value2] of obj)
+        map5.items.push(schema.createPair(key2, value2, ctx));
     } else if (obj && typeof obj === "object") {
-      for (const key of Object.keys(obj))
-        map5.items.push(schema.createPair(key, obj[key], ctx));
+      for (const key2 of Object.keys(obj))
+        map5.items.push(schema.createPair(key2, obj[key2], ctx));
     }
     if (typeof schema.sortMapEntries === "function") {
       map5.items.sort(schema.sortMapEntries);
@@ -40062,7 +40417,7 @@ var require_Schema_bcc6c2d7 = __commonJS((exports) => {
   function getSchemaTags(schemas2, knownTags, customTags, schemaId) {
     let tags2 = schemas2[schemaId.replace(/\W/g, "")];
     if (!tags2) {
-      const keys = Object.keys(schemas2).map((key) => JSON.stringify(key)).join(", ");
+      const keys = Object.keys(schemas2).map((key2) => JSON.stringify(key2)).join(", ");
       throw new Error(`Unknown schema "${schemaId}"; use one of ${keys}`);
     }
     if (Array.isArray(customTags)) {
@@ -40076,7 +40431,7 @@ var require_Schema_bcc6c2d7 = __commonJS((exports) => {
       if (typeof tag === "string") {
         const tagObj = knownTags[tag];
         if (!tagObj) {
-          const keys = Object.keys(knownTags).map((key) => JSON.stringify(key)).join(", ");
+          const keys = Object.keys(knownTags).map((key2) => JSON.stringify(key2)).join(", ");
           throw new Error(`Unknown custom tag "${tag}"; use one of ${keys}`);
         }
         tags2[i] = tagObj;
@@ -40110,12 +40465,12 @@ var require_Schema_bcc6c2d7 = __commonJS((exports) => {
       const createCtx = ctx ? Object.assign(ctx, baseCtx) : baseCtx;
       return createNode(value2, tagName, createCtx);
     }
-    createPair(key, value2, ctx) {
+    createPair(key2, value2, ctx) {
       if (!ctx)
         ctx = {
           wrapScalars: true
         };
-      const k = this.createNode(key, ctx.wrapScalars, null, ctx);
+      const k = this.createNode(key2, ctx.wrapScalars, null, ctx);
       const v = this.createNode(value2, ctx.wrapScalars, null, ctx);
       return new resolveSeq.Pair(k, v);
     }
@@ -40276,7 +40631,7 @@ var require_Document_a8d0fbf9 = __commonJS((exports) => {
     }
     return props.join(" ");
   }
-  function stringify(item, ctx, onComment, onChompKeep) {
+  function stringify3(item, ctx, onComment, onChompKeep) {
     const {
       anchors,
       schema
@@ -40582,9 +40937,9 @@ ${cbNode.commentBefore}` : cb;
       assertCollection(this.contents);
       this.contents.addIn(path2, value2);
     }
-    delete(key) {
+    delete(key2) {
       assertCollection(this.contents);
-      return this.contents.delete(key);
+      return this.contents.delete(key2);
     }
     deleteIn(path2) {
       if (resolveSeq.isEmptyPath(path2)) {
@@ -40599,25 +40954,25 @@ ${cbNode.commentBefore}` : cb;
     getDefaults() {
       return Document2.defaults[this.version] || Document2.defaults[this.options.version] || {};
     }
-    get(key, keepScalar) {
-      return this.contents instanceof resolveSeq.Collection ? this.contents.get(key, keepScalar) : undefined;
+    get(key2, keepScalar) {
+      return this.contents instanceof resolveSeq.Collection ? this.contents.get(key2, keepScalar) : undefined;
     }
     getIn(path2, keepScalar) {
       if (resolveSeq.isEmptyPath(path2))
         return !keepScalar && this.contents instanceof resolveSeq.Scalar ? this.contents.value : this.contents;
       return this.contents instanceof resolveSeq.Collection ? this.contents.getIn(path2, keepScalar) : undefined;
     }
-    has(key) {
-      return this.contents instanceof resolveSeq.Collection ? this.contents.has(key) : false;
+    has(key2) {
+      return this.contents instanceof resolveSeq.Collection ? this.contents.has(key2) : false;
     }
     hasIn(path2) {
       if (resolveSeq.isEmptyPath(path2))
         return this.contents !== undefined;
       return this.contents instanceof resolveSeq.Collection ? this.contents.hasIn(path2) : false;
     }
-    set(key, value2) {
+    set(key2, value2) {
       assertCollection(this.contents);
-      this.contents.set(key, value2);
+      this.contents.set(key2, value2);
     }
     setIn(path2, value2) {
       if (resolveSeq.isEmptyPath(path2))
@@ -40713,7 +41068,7 @@ ${cbNode.commentBefore}` : cb;
         keep,
         mapAsMap: keep && !!mapAsMap,
         maxAliasCount,
-        stringify
+        stringify: stringify3
       };
       const anchorNames = Object.keys(this.anchors.map);
       if (anchorNames.length > 0)
@@ -40775,7 +41130,7 @@ ${cbNode.commentBefore}` : cb;
         doc: this,
         indent: "",
         indentStep: " ".repeat(indentSize),
-        stringify
+        stringify: stringify3
       };
       let chompKeep = false;
       let contentComment = null;
@@ -40789,10 +41144,10 @@ ${cbNode.commentBefore}` : cb;
           contentComment = this.contents.comment;
         }
         const onChompKeep = contentComment ? null : () => chompKeep = true;
-        const body = stringify(this.contents, ctx, () => contentComment = null, onChompKeep);
+        const body = stringify3(this.contents, ctx, () => contentComment = null, onChompKeep);
         lines.push(resolveSeq.addComment(body, "", contentComment));
       } else if (this.contents !== undefined) {
-        lines.push(stringify(this.contents, ctx));
+        lines.push(stringify3(this.contents, ctx));
       }
       if (this.comment) {
         if ((!chompKeep || contentComment) && lines[lines.length - 1] !== "")
@@ -40860,7 +41215,7 @@ var require_dist = __commonJS((exports) => {
       throw doc.errors[0];
     return doc.toJSON();
   }
-  function stringify(value2, options) {
+  function stringify3(value2, options) {
     const doc = new Document2(options);
     doc.contents = value2;
     return String(doc);
@@ -40874,7 +41229,7 @@ var require_dist = __commonJS((exports) => {
     parseCST: parseCst.parse,
     parseDocument,
     scalarOptions: Document$1.scalarOptions,
-    stringify
+    stringify: stringify3
   };
   exports.YAML = YAML;
 });
@@ -41150,10 +41505,10 @@ var require_revalidator = __commonJS((exports, module) => {
                 return true;
               var h2 = {};
               for (var i2 = 0, l2 = a.length;i2 < l2; i2++) {
-                var key = JSON.stringify(a[i2]);
-                if (h2[key])
+                var key2 = JSON.stringify(a[i2]);
+                if (h2[key2])
                   return false;
-                h2[key] = true;
+                h2[key2] = true;
               }
               return true;
             });
@@ -41259,33 +41614,33 @@ var require_dist2 = __commonJS((exports, module) => {
 });
 
 // src/transpile.ts
-function jxKey(key) {
-  if (JX_DOLLAR_KEYS.has(key)) {
-    return `$${key}`;
+function jxKey(key2) {
+  if (JX_DOLLAR_KEYS.has(key2)) {
+    return `$${key2}`;
   }
-  if (key.startsWith("--") && JX_ANNOTATION_KEYS.has(key.slice(2))) {
-    return `$${key.slice(2)}`;
+  if (key2.startsWith("--") && JX_ANNOTATION_KEYS.has(key2.slice(2))) {
+    return `$${key2.slice(2)}`;
   }
-  return key;
+  return key2;
 }
-function mdKey(key) {
-  if (key.startsWith("$") && JX_DOLLAR_KEYS.has(key.slice(1))) {
-    return key.slice(1);
+function mdKey(key2) {
+  if (key2.startsWith("$") && JX_DOLLAR_KEYS.has(key2.slice(1))) {
+    return key2.slice(1);
   }
-  if (key.startsWith("$") && JX_ANNOTATION_KEYS.has(key.slice(1))) {
-    return `--${key.slice(1)}`;
+  if (key2.startsWith("$") && JX_ANNOTATION_KEYS.has(key2.slice(1))) {
+    return `--${key2.slice(1)}`;
   }
-  return key;
+  return key2;
 }
 function expandDotPaths(attrs) {
   const result = {};
-  for (const [key, value2] of Object.entries(attrs)) {
-    const dotIndex = key.indexOf(".");
+  for (const [key2, value2] of Object.entries(attrs)) {
+    const dotIndex = key2.indexOf(".");
     if (dotIndex === -1) {
-      result[jxKey(key)] = value2;
+      result[jxKey(key2)] = value2;
       continue;
     }
-    const segments = key.split(".");
+    const segments = key2.split(".");
     let target = result;
     for (let i = 0;i < segments.length - 1; i++) {
       const seg = jxKey(segments[i]);
@@ -41301,8 +41656,8 @@ function expandDotPaths(attrs) {
 function collapseDotPaths(obj) {
   const result = {};
   function walk(node2, prefix) {
-    for (const [key, value2] of Object.entries(node2)) {
-      const path2 = prefix ? `${prefix}.${key}` : key;
+    for (const [key2, value2] of Object.entries(node2)) {
+      const path2 = prefix ? `${prefix}.${key2}` : key2;
       if (value2 && typeof value2 === "object" && !Array.isArray(value2)) {
         walk(value2, path2);
       } else {
@@ -41315,13 +41670,13 @@ function collapseDotPaths(obj) {
 }
 function applyStyleKeyMapping(styleObj) {
   const result = {};
-  for (const [key, value2] of Object.entries(styleObj)) {
-    if (CSS_PSEUDO_NAMES.has(key)) {
-      result[`:${key}`] = value2;
-    } else if (key.startsWith("--")) {
-      result[`@${key}`] = value2;
+  for (const [key2, value2] of Object.entries(styleObj)) {
+    if (CSS_PSEUDO_NAMES.has(key2)) {
+      result[`:${key2}`] = value2;
+    } else if (key2.startsWith("--")) {
+      result[`@${key2}`] = value2;
     } else {
-      result[key] = value2;
+      result[key2] = value2;
     }
   }
   return result;
@@ -41331,13 +41686,13 @@ function expandStylePaths(attrs) {
 }
 function collapseStylePaths(styleObj) {
   const normalized = {};
-  for (const [key, value2] of Object.entries(styleObj)) {
-    if (key.startsWith(":") && CSS_PSEUDO_NAMES.has(key.slice(1))) {
-      normalized[key.slice(1)] = value2;
-    } else if (key.startsWith("@--")) {
-      normalized[key.slice(1)] = value2;
+  for (const [key2, value2] of Object.entries(styleObj)) {
+    if (key2.startsWith(":") && CSS_PSEUDO_NAMES.has(key2.slice(1))) {
+      normalized[key2.slice(1)] = value2;
+    } else if (key2.startsWith("@--")) {
+      normalized[key2.slice(1)] = value2;
     } else {
-      normalized[key] = value2;
+      normalized[key2] = value2;
     }
   }
   return collapseDotPaths(normalized);
@@ -41356,11 +41711,11 @@ function routeAttributes(attrs) {
   }
   const props = {};
   const attributes4 = {};
-  for (const [key, value2] of Object.entries(expanded)) {
-    if (HTML_ATTR_PATTERN.test(key)) {
-      attributes4[key] = value2;
+  for (const [key2, value2] of Object.entries(expanded)) {
+    if (HTML_ATTR_PATTERN.test(key2)) {
+      attributes4[key2] = value2;
     } else {
-      props[key] = value2;
+      props[key2] = value2;
     }
   }
   return { attributes: attributes4, props };
@@ -41468,6 +41823,14 @@ function mdastNodeToJx(node2) {
     }
     case "table": {
       const rows = convertChildren(node2.children ?? []);
+      const [headerRow] = rows;
+      if (headerRow && typeof headerRow === "object" && Array.isArray(headerRow.children)) {
+        for (const cell of headerRow.children) {
+          if (cell && typeof cell === "object" && cell.tagName === "td") {
+            cell.tagName = "th";
+          }
+        }
+      }
       const thead = rows.length > 0 ? { children: [rows[0]], tagName: "thead" } : null;
       const tbody = rows.length > 1 ? { children: rows.slice(1), tagName: "tbody" } : null;
       el.children = [thead, tbody].filter(Boolean);
@@ -41488,27 +41851,27 @@ function directiveToJx(node2) {
     const { props, attributes: attributes4 } = routeAttributes(node2.attributes);
     const isCustomElement = node2.name.includes("-");
     if (isCustomElement) {
-      for (const [key, value2] of Object.entries(props)) {
-        if (key === "style" || key === "children" || key === "textContent" || key === "innerHTML" || key.startsWith("$")) {
-          el[key] = value2;
-        } else if (key === "props") {
+      for (const [key2, value2] of Object.entries(props)) {
+        if (key2 === "style" || key2 === "children" || key2 === "textContent" || key2 === "innerHTML" || key2.startsWith("$")) {
+          el[key2] = value2;
+        } else if (key2 === "props") {
           el.$props = value2;
         } else {
           if (!el.attributes) {
             el.attributes = {};
           }
-          el.attributes[key] = value2;
+          el.attributes[key2] = value2;
         }
       }
     } else {
-      for (const [key, value2] of Object.entries(props)) {
-        if (key === "style" || key === "children" || key === "textContent" || key === "innerHTML" || key === "id" || key === "className" || key === "hidden" || key === "tabIndex" || key === "lang" || key === "dir" || key.startsWith("$") || key.startsWith("on")) {
-          el[key] = value2;
+      for (const [key2, value2] of Object.entries(props)) {
+        if (key2 === "style" || key2 === "children" || key2 === "textContent" || key2 === "innerHTML" || key2 === "id" || key2 === "className" || key2 === "hidden" || key2 === "tabIndex" || key2 === "lang" || key2 === "dir" || key2.startsWith("$") || key2.startsWith("on")) {
+          el[key2] = value2;
         } else {
           if (!el.attributes) {
             el.attributes = {};
           }
-          el.attributes[key] = value2;
+          el.attributes[key2] = value2;
         }
       }
     }
@@ -41570,11 +41933,11 @@ function prototypeDirectiveToJx(node2) {
   const el = { $prototype: node2.name };
   if (node2.attributes && Object.keys(node2.attributes).length > 0) {
     const expanded = expandDotPaths(node2.attributes);
-    for (const [key, value2] of Object.entries(expanded)) {
-      if (key === "$prototype") {
+    for (const [key2, value2] of Object.entries(expanded)) {
+      if (key2 === "$prototype") {
         continue;
       }
-      el[key] = value2;
+      el[key2] = value2;
     }
   }
   const children = convertChildren(node2.children ?? []);
@@ -41597,8 +41960,8 @@ function transpileJxMarkdown(source) {
   processor.runSync(tree, vfile2);
   const frontmatter2 = vfile2.data?.frontmatter ?? {};
   const doc = {};
-  for (const [key, value2] of Object.entries(frontmatter2)) {
-    doc[key] = value2;
+  for (const [key2, value2] of Object.entries(frontmatter2)) {
+    doc[key2] = value2;
   }
   const bodyNodes = tree.children.filter((n) => n.type !== "yaml" && n.type !== "toml");
   const children = [];
@@ -41618,7 +41981,55 @@ function transpileJxMarkdown(source) {
   }
   return doc;
 }
-var import_remark_parse_frontmatter, JX_DOLLAR_KEYS, PROTOTYPE_DIRECTIVE_NAMES, JX_ANNOTATION_KEYS, CSS_PSEUDO_NAMES, HTML_ATTR_PATTERN, PHRASING_ELEMENTS, JX_TAG_MAP;
+function slugifyHeading(text5) {
+  return text5.toLowerCase().replaceAll(/[^\w\s-]/g, "").replaceAll(/\s+/g, "-").replaceAll(/-+/g, "-").replaceAll(/^-|-$/g, "");
+}
+function jxNodeText(node2) {
+  if (typeof node2 === "string") {
+    return node2;
+  }
+  let out = typeof node2.textContent === "string" ? node2.textContent : "";
+  if (Array.isArray(node2.children)) {
+    for (const child of node2.children) {
+      out += jxNodeText(child);
+    }
+  }
+  return out;
+}
+function assignHeadingIds(children) {
+  const entries = [];
+  const seen = new Map;
+  function walk(nodes) {
+    for (const node2 of nodes) {
+      if (typeof node2 !== "object" || node2 === null) {
+        continue;
+      }
+      const tag = node2.tagName;
+      if (tag && HEADING_TAGS.has(tag)) {
+        const text5 = jxNodeText(node2).trim();
+        let id = typeof node2.id === "string" && node2.id.length > 0 ? node2.id : "";
+        if (id) {
+          seen.set(id, (seen.get(id) ?? 0) + 1);
+        } else {
+          const base2 = slugifyHeading(text5) || "section";
+          const count = seen.get(base2) ?? 0;
+          id = count === 0 ? base2 : `${base2}-${count + 1}`;
+          seen.set(base2, count + 1);
+          node2.id = id;
+        }
+        entries.push({ depth: Number(tag.slice(1)), id, text: text5 });
+      }
+      if (Array.isArray(node2.children)) {
+        walk(node2.children);
+      }
+    }
+  }
+  if (children) {
+    walk(children);
+  }
+  return entries;
+}
+var import_remark_parse_frontmatter, JX_DOLLAR_KEYS, PROTOTYPE_DIRECTIVE_NAMES, JX_ANNOTATION_KEYS, CSS_PSEUDO_NAMES, HTML_ATTR_PATTERN, PHRASING_ELEMENTS, JX_TAG_MAP, HEADING_TAGS;
 var init_transpile = __esm(() => {
   init_unified();
   init_remark_parse();
@@ -41707,6 +42118,7 @@ var init_transpile = __esm(() => {
     tableRow: () => "tr",
     thematicBreak: () => "hr"
   };
+  HEADING_TAGS = new Set(["h1", "h2", "h3", "h4", "h5", "h6"]);
 });
 
 // src/serialize.ts
@@ -41857,11 +42269,11 @@ function prototypeDirectiveToJx2(node2) {
   const el = { $prototype: node2.name };
   if (node2.attributes && Object.keys(node2.attributes).length > 0) {
     const expanded = expandDotPaths(node2.attributes);
-    for (const [key, value2] of Object.entries(expanded)) {
-      if (key === "$prototype") {
+    for (const [key2, value2] of Object.entries(expanded)) {
+      if (key2 === "$prototype") {
         continue;
       }
-      el[key] = value2;
+      el[key2] = value2;
     }
   }
   if (node2.children?.length) {
@@ -41886,8 +42298,8 @@ function normalizeAllowlist(allowlist) {
   return allowlist instanceof Set ? allowlist : new Set(allowlist);
 }
 function hasJxProps(el) {
-  for (const key of Object.keys(el)) {
-    if (key === "tagName" || key === "children" || key === "textContent" || key === "innerHTML" || key === "attributes") {
+  for (const key2 of Object.keys(el)) {
+    if (key2 === "tagName" || key2 === "children" || key2 === "textContent" || key2 === "innerHTML" || key2 === "attributes") {
       continue;
     }
     return true;
@@ -42032,21 +42444,21 @@ function convertJxNode(el, isBlock, allowlist) {
 }
 function collectDirectiveAttrs(el) {
   const propsObj = {};
-  for (const [key, value2] of Object.entries(el)) {
-    if (key === "tagName" || key === "textContent" || key === "innerHTML" || key === "attributes") {
+  for (const [key2, value2] of Object.entries(el)) {
+    if (key2 === "tagName" || key2 === "textContent" || key2 === "innerHTML" || key2 === "attributes") {
       continue;
     }
-    if (key === "children") {
+    if (key2 === "children") {
       if (value2 && typeof value2 === "object" && !Array.isArray(value2)) {
         propsObj.children = value2;
       }
       continue;
     }
-    propsObj[key] = value2;
+    propsObj[key2] = value2;
   }
   if (el.attributes) {
-    for (const [key, value2] of Object.entries(el.attributes)) {
-      propsObj[key] = value2;
+    for (const [key2, value2] of Object.entries(el.attributes)) {
+      propsObj[key2] = value2;
     }
   }
   return collapsePropsToAttrMap(propsObj);
@@ -42099,11 +42511,11 @@ function convertToDirective(el, isBlock, allowlist) {
 }
 function prototypeToDirective(el, isBlock, allowlist) {
   const propsObj = {};
-  for (const [key, value2] of Object.entries(el)) {
-    if (key === "$prototype" || key === "map" || key === "tagName") {
+  for (const [key2, value2] of Object.entries(el)) {
+    if (key2 === "$prototype" || key2 === "map" || key2 === "tagName") {
       continue;
     }
-    propsObj[key] = value2;
+    propsObj[key2] = value2;
   }
   const attrs = collapsePropsToAttrMap(propsObj);
   const mapNode = el.map ? convertJxNode(el.map, isBlock, allowlist) : null;
@@ -42118,25 +42530,25 @@ function prototypeToDirective(el, isBlock, allowlist) {
 function collapsePropsToAttrMap(propsObj) {
   const result = {};
   function walk(obj, prefix) {
-    for (const [key, value2] of Object.entries(obj)) {
-      let mdAttrKey = key;
-      if (JX_DOLLAR_KEYS2.has(key)) {
-        mdAttrKey = key.slice(1);
+    for (const [key2, value2] of Object.entries(obj)) {
+      let mdAttrKey = key2;
+      if (JX_DOLLAR_KEYS2.has(key2)) {
+        mdAttrKey = key2.slice(1);
       }
-      if (JX_ANNOTATION_KEYS2.has(key)) {
-        mdAttrKey = `--${key.slice(1)}`;
+      if (JX_ANNOTATION_KEYS2.has(key2)) {
+        mdAttrKey = `--${key2.slice(1)}`;
       }
-      if (key.startsWith(":") && CSS_PSEUDO_NAMES2.has(key.slice(1))) {
-        mdAttrKey = key.slice(1);
+      if (key2.startsWith(":") && CSS_PSEUDO_NAMES2.has(key2.slice(1))) {
+        mdAttrKey = key2.slice(1);
       }
-      if (key === "@") {
+      if (key2 === "@") {
         if (value2 && typeof value2 === "object" && !Array.isArray(value2)) {
           walk(value2, prefix);
         }
         continue;
       }
-      if (key.startsWith("@--")) {
-        mdAttrKey = key.slice(1);
+      if (key2.startsWith("@--")) {
+        mdAttrKey = key2.slice(1);
       }
       const fullKey = prefix ? `${prefix}.${mdAttrKey}` : mdAttrKey;
       if (value2 && typeof value2 === "object" && !Array.isArray(value2)) {
@@ -42308,12 +42720,12 @@ function inlineComponent(node2, tag, ctx) {
   }
   const props = node2.$props ?? {};
   const stateDefs = { ...def.state };
-  for (const [key, value2] of Object.entries(props)) {
-    if (key in stateDefs) {
-      const existing = stateDefs[key];
-      stateDefs[key] = existing && typeof existing === "object" && !Array.isArray(existing) && "default" in existing ? { ...existing, default: value2 } : value2;
+  for (const [key2, value2] of Object.entries(props)) {
+    if (key2 in stateDefs) {
+      const existing = stateDefs[key2];
+      stateDefs[key2] = existing && typeof existing === "object" && !Array.isArray(existing) && "default" in existing ? { ...existing, default: value2 } : value2;
     } else {
-      stateDefs[key] = value2;
+      stateDefs[key2] = value2;
     }
   }
   const scope = ctx.buildScope?.(stateDefs) ?? null;
@@ -42399,12 +42811,12 @@ function resolveMapNode(node2, item) {
     return node2;
   }
   const result = { ...node2 };
-  for (const [key, value2] of Object.entries(result)) {
+  for (const [key2, value2] of Object.entries(result)) {
     if (value2 && typeof value2 === "object" && value2.$ref) {
       const ref = value2.$ref;
       if (ref.startsWith("$map/")) {
         const path2 = ref.slice("$map/".length);
-        result[key] = resolvePath(item, path2.startsWith("item/") ? path2.slice("item/".length) : path2);
+        result[key2] = resolvePath(item, path2.startsWith("item/") ? path2.slice("item/".length) : path2);
       }
     }
   }
@@ -42719,11 +43131,11 @@ function serializeRoundtrip(doc, opts) {
   const lines = [];
   if (opts.frontmatter !== false) {
     const frontmatter2 = {};
-    for (const [key, value2] of Object.entries(doc)) {
-      if (key === "children") {
+    for (const [key2, value2] of Object.entries(doc)) {
+      if (key2 === "children") {
         continue;
       }
-      frontmatter2[key] = value2;
+      frontmatter2[key2] = value2;
     }
     if (Object.keys(frontmatter2).length > 0) {
       lines.push("---", $stringify(frontmatter2).trim(), "---", "");