markdecl 0.1.0

package/dist/index.js

@@ -0,0 +1,3368 @@
+import MarkdownIt from "markdown-it";
+import MarkdownIt$1 from "markdown-it/lib/index.mjs";
+function isAst(value) {
+  return !!value?.$$mdtype;
+}
+function isFunction(value) {
+  return !!(value?.$$mdtype === "Function");
+}
+function isVariable(value) {
+  return !!(value?.$$mdtype === "Variable");
+}
+function* getAstValues(value) {
+  if (value == null || typeof value !== "object") return;
+  if (Array.isArray(value)) for (const v of value) yield* getAstValues(v);
+  if (isAst(value)) yield value;
+  if (Object.getPrototypeOf(value) !== Object.prototype) return;
+  for (const v of Object.values(value)) yield* getAstValues(v);
+}
+function resolve$1(value, config = {}) {
+  if (value == null || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map((item2) => resolve$1(item2, config));
+  if (isAst(value) && value?.resolve instanceof Function) return value.resolve(config);
+  if (Object.getPrototypeOf(value) !== Object.prototype) return value;
+  const output = {};
+  for (const [k, v] of Object.entries(value)) output[k] = resolve$1(v, config);
+  return output;
+}
+const base = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getAstValues,
+  isAst,
+  isFunction,
+  isVariable,
+  resolve: resolve$1
+}, Symbol.toStringTag, { value: "Module" }));
+const _Tag = class _Tag {
+  constructor(name = "div", attributes = {}, children = []) {
+    this.$$mdtype = "Tag";
+    this.name = name;
+    this.attributes = attributes;
+    this.children = children;
+  }
+};
+_Tag.isTag = (tag) => {
+  return !!(tag?.$$mdtype === "Tag");
+};
+let Tag = _Tag;
+class peg$SyntaxError extends SyntaxError {
+  constructor(message, expected, found, location) {
+    super(message);
+    this.expected = expected;
+    this.found = found;
+    this.location = location;
+    this.name = "SyntaxError";
+  }
+  format(sources) {
+    let str = "Error: " + this.message;
+    if (this.location) {
+      let src = null;
+      const st = sources.find((s3) => s3.source === this.location.source);
+      if (st) {
+        src = st.text.split(/\r\n|\n|\r/g);
+      }
+      const s2 = this.location.start;
+      const offset_s = this.location.source && typeof this.location.source.offset === "function" ? this.location.source.offset(s2) : s2;
+      const loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column;
+      if (src) {
+        const e = this.location.end;
+        const filler = "".padEnd(offset_s.line.toString().length, " ");
+        const line = src[s2.line - 1];
+        const last = s2.line === e.line ? e.column : line.length + 1;
+        const hatLen = last - s2.column || 1;
+        str += "\n --> " + loc + "\n" + filler + " |\n" + offset_s.line + " | " + line + "\n" + filler + " | " + "".padEnd(s2.column - 1, " ") + "".padEnd(hatLen, "^");
+      } else {
+        str += "\n at " + loc;
+      }
+    }
+    return str;
+  }
+  static buildMessage(expected, found) {
+    function hex(ch) {
+      return ch.codePointAt(0).toString(16).toUpperCase();
+    }
+    const nonPrintable = Object.prototype.hasOwnProperty.call(RegExp.prototype, "unicode") ? new RegExp("[\\p{C}\\p{Mn}\\p{Mc}]", "gu") : null;
+    function unicodeEscape(s2) {
+      if (nonPrintable) {
+        return s2.replace(nonPrintable, (ch) => "\\u{" + hex(ch) + "}");
+      }
+      return s2;
+    }
+    function literalEscape(s2) {
+      return unicodeEscape(
+        s2.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, (ch) => "\\x0" + hex(ch)).replace(/[\x10-\x1F\x7F-\x9F]/g, (ch) => "\\x" + hex(ch))
+      );
+    }
+    function classEscape(s2) {
+      return unicodeEscape(
+        s2.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, (ch) => "\\x0" + hex(ch)).replace(/[\x10-\x1F\x7F-\x9F]/g, (ch) => "\\x" + hex(ch))
+      );
+    }
+    const DESCRIBE_EXPECTATION_FNS = {
+      literal(expectation) {
+        return '"' + literalEscape(expectation.text) + '"';
+      },
+      class(expectation) {
+        const escapedParts = expectation.parts.map(
+          (part) => Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part)
+        );
+        return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]" + (expectation.unicode ? "u" : "");
+      },
+      any() {
+        return "any character";
+      },
+      end() {
+        return "end of input";
+      },
+      other(expectation) {
+        return expectation.description;
+      }
+    };
+    function describeExpectation(expectation) {
+      return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);
+    }
+    function describeExpected(expected2) {
+      const descriptions = expected2.map(describeExpectation);
+      descriptions.sort();
+      if (descriptions.length > 0) {
+        let j = 1;
+        for (let i = 1; i < descriptions.length; i++) {
+          if (descriptions[i - 1] !== descriptions[i]) {
+            descriptions[j] = descriptions[i];
+            j++;
+          }
+        }
+        descriptions.length = j;
+      }
+      switch (descriptions.length) {
+        case 1:
+          return descriptions[0];
+        case 2:
+          return descriptions[0] + " or " + descriptions[1];
+        default:
+          return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1];
+      }
+    }
+    function describeFound(found2) {
+      return found2 ? '"' + literalEscape(found2) + '"' : "end of input";
+    }
+    return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found.";
+  }
+}
+function peg$parse(input, options) {
+  options = options !== void 0 ? options : {};
+  const peg$FAILED = {};
+  const peg$source = options.grammarSource;
+  const peg$startRuleFunctions = {
+    Top: peg$parseTop
+  };
+  let peg$startRuleFunction = peg$parseTop;
+  const peg$c0 = "/";
+  const peg$c1 = "=";
+  const peg$c2 = "(";
+  const peg$c3 = ")";
+  const peg$c4 = ",";
+  const peg$c5 = ".";
+  const peg$c6 = "[";
+  const peg$c7 = "]";
+  const peg$c8 = "null";
+  const peg$c9 = "true";
+  const peg$c10 = "false";
+  const peg$c11 = "{";
+  const peg$c12 = "}";
+  const peg$c13 = ":";
+  const peg$c15 = '"';
+  const peg$c16 = "\\";
+  const peg$c17 = "n";
+  const peg$c18 = "r";
+  const peg$c19 = "t";
+  const peg$r0 = /^[$@]/;
+  const peg$r1 = /^[0-9]/;
+  const peg$r2 = /^[^\0-\x1F"\\]/;
+  const peg$r3 = /^["\\]/;
+  const peg$r4 = /^[a-zA-Z0-9_\-]/;
+  const peg$r5 = /^[ \n\t]/;
+  const peg$e0 = peg$literalExpectation("/", false);
+  const peg$e1 = peg$otherExpectation("tag name");
+  const peg$e2 = peg$literalExpectation("=", false);
+  const peg$e3 = peg$literalExpectation("(", false);
+  const peg$e4 = peg$literalExpectation(")", false);
+  const peg$e5 = peg$literalExpectation(",", false);
+  const peg$e6 = peg$otherExpectation("variable");
+  const peg$e7 = peg$classExpectation(["$", "@"], false, false, false);
+  const peg$e8 = peg$literalExpectation(".", false);
+  const peg$e9 = peg$literalExpectation("[", false);
+  const peg$e10 = peg$literalExpectation("]", false);
+  const peg$e11 = peg$otherExpectation("null");
+  const peg$e12 = peg$literalExpectation("null", false);
+  const peg$e13 = peg$otherExpectation("boolean");
+  const peg$e14 = peg$literalExpectation("true", false);
+  const peg$e15 = peg$literalExpectation("false", false);
+  const peg$e16 = peg$literalExpectation("{", false);
+  const peg$e17 = peg$literalExpectation("}", false);
+  const peg$e18 = peg$literalExpectation(":", false);
+  const peg$e19 = peg$otherExpectation("number");
+  const peg$e20 = peg$literalExpectation("-", false);
+  const peg$e21 = peg$classExpectation([["0", "9"]], false, false, false);
+  const peg$e22 = peg$otherExpectation("string");
+  const peg$e23 = peg$literalExpectation('"', false);
+  const peg$e24 = peg$classExpectation([["\0", ""], '"', "\\"], true, false, false);
+  const peg$e25 = peg$literalExpectation("\\", false);
+  const peg$e26 = peg$classExpectation(['"', "\\"], false, false, false);
+  const peg$e27 = peg$literalExpectation("n", false);
+  const peg$e28 = peg$literalExpectation("r", false);
+  const peg$e29 = peg$literalExpectation("t", false);
+  const peg$e30 = peg$otherExpectation("identifier");
+  const peg$e31 = peg$classExpectation(
+    [["a", "z"], ["A", "Z"], ["0", "9"], "_", "-"],
+    false,
+    false,
+    false
+  );
+  const peg$e32 = peg$otherExpectation("whitespace");
+  const peg$e33 = peg$classExpectation([" ", "\n", "	"], false, false, false);
+  function peg$f0(variable) {
+    return { type: "variable", meta: { variable } };
+  }
+  function peg$f1(attributes) {
+    return { type: "annotation", meta: { attributes } };
+  }
+  function peg$f2(tag, value) {
+    return value;
+  }
+  function peg$f3(tag, primary, attributes, close) {
+    if (primary) {
+      attributes = attributes || [];
+      attributes.unshift({ type: "attribute", name: "primary", value: primary });
+    }
+    const [type, nesting] = close ? ["tag", 0] : ["tag_open", 1];
+    return { type, nesting, meta: { tag, attributes } };
+  }
+  function peg$f4(tag) {
+    return { type: "tag_close", nesting: -1, meta: { tag } };
+  }
+  function peg$f5(head, tail) {
+    return !head ? [] : [head, ...tail];
+  }
+  function peg$f6(item2) {
+    return item2;
+  }
+  function peg$f7(attribute) {
+    return attribute;
+  }
+  function peg$f8(name, value) {
+    return { type: "attribute", name, value };
+  }
+  function peg$f9(name, head, tail) {
+    return head ? [head, ...tail] : [];
+  }
+  function peg$f10(name, params) {
+    let parameters = {};
+    for (let [index, { name: name2, value }] of params.entries()) parameters[name2 || index] = value;
+    return new Function3(name, parameters);
+  }
+  function peg$f11(name) {
+    return name;
+  }
+  function peg$f12(name, value) {
+    return { name, value };
+  }
+  function peg$f13(value) {
+    return value;
+  }
+  function peg$f14(prefix, head, tail) {
+    if (prefix === "@") return [head, ...tail];
+    return new Variable2([head, ...tail]);
+  }
+  function peg$f15(name) {
+    return name;
+  }
+  function peg$f16(value) {
+    return value;
+  }
+  function peg$f17() {
+    return null;
+  }
+  function peg$f18() {
+    return true;
+  }
+  function peg$f19() {
+    return false;
+  }
+  function peg$f20(head, tail) {
+    return [head, ...tail];
+  }
+  function peg$f21(value) {
+    return value || [];
+  }
+  function peg$f22(value) {
+    return value;
+  }
+  function peg$f23(head, tail) {
+    return Object.assign(head, ...tail);
+  }
+  function peg$f24(value) {
+    return value || {};
+  }
+  function peg$f25(item2) {
+    return item2;
+  }
+  function peg$f26(key, value) {
+    return key === "$$mdtype" ? {} : { [key]: value };
+  }
+  function peg$f27() {
+    return parseFloat(text2());
+  }
+  function peg$f28(value) {
+    return value.join("");
+  }
+  function peg$f29() {
+    return "\n";
+  }
+  function peg$f30() {
+    return "\r";
+  }
+  function peg$f31() {
+    return "	";
+  }
+  function peg$f32(sequence) {
+    return sequence;
+  }
+  let peg$currPos = options.peg$currPos | 0;
+  let peg$savedPos = peg$currPos;
+  const peg$posDetailsCache = [{ line: 1, column: 1 }];
+  let peg$maxFailPos = peg$currPos;
+  let peg$maxFailExpected = options.peg$maxFailExpected || [];
+  let peg$silentFails = options.peg$silentFails | 0;
+  let peg$result;
+  if (options.startRule) {
+    if (!(options.startRule in peg$startRuleFunctions)) {
+      throw new Error(`Can't start parsing from rule "` + options.startRule + '".');
+    }
+    peg$startRuleFunction = peg$startRuleFunctions[options.startRule];
+  }
+  function text2() {
+    return input.substring(peg$savedPos, peg$currPos);
+  }
+  function peg$getUnicode(pos = peg$currPos) {
+    const cp = input.codePointAt(pos);
+    if (cp === void 0) {
+      return "";
+    }
+    return String.fromCodePoint(cp);
+  }
+  function peg$literalExpectation(text3, ignoreCase) {
+    return { type: "literal", text: text3, ignoreCase };
+  }
+  function peg$classExpectation(parts, inverted, ignoreCase, unicode) {
+    return { type: "class", parts, inverted, ignoreCase, unicode };
+  }
+  function peg$endExpectation() {
+    return { type: "end" };
+  }
+  function peg$otherExpectation(description) {
+    return { type: "other", description };
+  }
+  function peg$computePosDetails(pos) {
+    let details = peg$posDetailsCache[pos];
+    let p;
+    if (details) {
+      return details;
+    } else {
+      if (pos >= peg$posDetailsCache.length) {
+        p = peg$posDetailsCache.length - 1;
+      } else {
+        p = pos;
+        while (!peg$posDetailsCache[--p]) {
+        }
+      }
+      details = peg$posDetailsCache[p];
+      details = {
+        line: details.line,
+        column: details.column
+      };
+      while (p < pos) {
+        if (input.charCodeAt(p) === 10) {
+          details.line++;
+          details.column = 1;
+        } else {
+          details.column++;
+        }
+        p++;
+      }
+      peg$posDetailsCache[pos] = details;
+      return details;
+    }
+  }
+  function peg$computeLocation(startPos, endPos, offset) {
+    const startPosDetails = peg$computePosDetails(startPos);
+    const endPosDetails = peg$computePosDetails(endPos);
+    const res = {
+      source: peg$source,
+      start: {
+        offset: startPos,
+        line: startPosDetails.line,
+        column: startPosDetails.column
+      },
+      end: {
+        offset: endPos,
+        line: endPosDetails.line,
+        column: endPosDetails.column
+      }
+    };
+    return res;
+  }
+  function peg$fail(expected) {
+    if (peg$currPos < peg$maxFailPos) {
+      return;
+    }
+    if (peg$currPos > peg$maxFailPos) {
+      peg$maxFailPos = peg$currPos;
+      peg$maxFailExpected = [];
+    }
+    peg$maxFailExpected.push(expected);
+  }
+  function peg$buildStructuredError(expected, found, location) {
+    return new peg$SyntaxError(
+      peg$SyntaxError.buildMessage(expected, found),
+      expected,
+      found,
+      location
+    );
+  }
+  function peg$parseTop() {
+    let s0;
+    s0 = peg$parseTopLevelValue();
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseAnnotation();
+      if (s0 === peg$FAILED) {
+        s0 = peg$parseTagOpen();
+        if (s0 === peg$FAILED) {
+          s0 = peg$parseTagClose();
+        }
+      }
+    }
+    return s0;
+  }
+  function peg$parseTopLevelValue() {
+    let s0, s1;
+    s0 = peg$currPos;
+    s1 = peg$parseVariable();
+    if (s1 === peg$FAILED) {
+      s1 = peg$parseFunction();
+    }
+    if (s1 !== peg$FAILED) {
+      peg$savedPos = s0;
+      s1 = peg$f0(s1);
+    }
+    s0 = s1;
+    return s0;
+  }
+  function peg$parseAnnotation() {
+    let s0, s1, s2, s3;
+    s0 = peg$currPos;
+    s1 = peg$parseTagAttributes();
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$parse_();
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$parse_();
+      }
+      peg$savedPos = s0;
+      s0 = peg$f1(s1);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    return s0;
+  }
+  function peg$parseTagOpen() {
+    let s0, s1, s2, s3, s4, s5, s6;
+    s0 = peg$currPos;
+    s1 = peg$parseTagName();
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$parse_();
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$parse_();
+      }
+      s3 = peg$currPos;
+      s4 = peg$parseValue();
+      if (s4 !== peg$FAILED) {
+        s5 = peg$parse_();
+        if (s5 === peg$FAILED) {
+          s5 = null;
+        }
+        peg$savedPos = s3;
+        s3 = peg$f2(s1, s4);
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      if (s3 === peg$FAILED) {
+        s3 = null;
+      }
+      s4 = peg$parseTagAttributes();
+      if (s4 === peg$FAILED) {
+        s4 = null;
+      }
+      s5 = [];
+      s6 = peg$parse_();
+      while (s6 !== peg$FAILED) {
+        s5.push(s6);
+        s6 = peg$parse_();
+      }
+      if (input.charCodeAt(peg$currPos) === 47) {
+        s6 = peg$c0;
+        peg$currPos++;
+      } else {
+        s6 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e0);
+        }
+      }
+      if (s6 === peg$FAILED) {
+        s6 = null;
+      }
+      peg$savedPos = s0;
+      s0 = peg$f3(s1, s3, s4, s6);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    return s0;
+  }
+  function peg$parseTagClose() {
+    let s0, s1, s2;
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 47) {
+      s1 = peg$c0;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e0);
+      }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseTagName();
+      if (s2 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s0 = peg$f4(s2);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    return s0;
+  }
+  function peg$parseTagName() {
+    let s0;
+    peg$silentFails++;
+    s0 = peg$parseIdentifier();
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e1);
+      }
+    }
+    return s0;
+  }
+  function peg$parseTagAttributes() {
+    let s0, s1, s2, s3;
+    s0 = peg$currPos;
+    s1 = peg$parseTagAttributesItem();
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$parseTagAttributesTail();
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$parseTagAttributesTail();
+      }
+      peg$savedPos = s0;
+      s0 = peg$f5(s1, s2);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    return s0;
+  }
+  function peg$parseTagAttributesTail() {
+    let s0, s1, s2;
+    s0 = peg$currPos;
+    s1 = [];
+    s2 = peg$parse_();
+    if (s2 !== peg$FAILED) {
+      while (s2 !== peg$FAILED) {
+        s1.push(s2);
+        s2 = peg$parse_();
+      }
+    } else {
+      s1 = peg$FAILED;
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseTagAttributesItem();
+      if (s2 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s0 = peg$f6(s2);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    return s0;
+  }
+  function peg$parseTagAttributesItem() {
+    let s0, s1;
+    s0 = peg$currPos;
+    s1 = peg$parseTagAttribute();
+    if (s1 !== peg$FAILED) {
+      peg$savedPos = s0;
+      s1 = peg$f7(s1);
+    }
+    s0 = s1;
+    return s0;
+  }
+  function peg$parseTagAttribute() {
+    let s0, s1, s2, s3;
+    s0 = peg$currPos;
+    s1 = peg$parseIdentifier();
+    if (s1 !== peg$FAILED) {
+      if (input.charCodeAt(peg$currPos) === 61) {
+        s2 = peg$c1;
+        peg$currPos++;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e2);
+        }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseValue();
+        if (s3 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s0 = peg$f8(s1, s3);
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    return s0;
+  }
+  function peg$parseFunction() {
+    let s0, s1, s2, s3, s4, s5, s6, s7;
+    s0 = peg$currPos;
+    s1 = peg$parseIdentifier();
+    if (s1 !== peg$FAILED) {
+      if (input.charCodeAt(peg$currPos) === 40) {
+        s2 = peg$c2;
+        peg$currPos++;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e3);
+        }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = [];
+        s4 = peg$parse_();
+        while (s4 !== peg$FAILED) {
+          s3.push(s4);
+          s4 = peg$parse_();
+        }
+        s4 = peg$currPos;
+        s5 = peg$parseFunctionParameter();
+        if (s5 === peg$FAILED) {
+          s5 = null;
+        }
+        s6 = [];
+        s7 = peg$parseFunctionParameterTail();
+        while (s7 !== peg$FAILED) {
+          s6.push(s7);
+          s7 = peg$parseFunctionParameterTail();
+        }
+        peg$savedPos = s4;
+        s4 = peg$f9(s1, s5, s6);
+        if (input.charCodeAt(peg$currPos) === 41) {
+          s5 = peg$c3;
+          peg$currPos++;
+        } else {
+          s5 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e4);
+          }
+        }
+        if (s5 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s0 = peg$f10(s1, s4);
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    return s0;
+  }
+  function peg$parseFunctionParameter() {
+    let s0, s1, s2, s3;
+    s0 = peg$currPos;
+    s1 = peg$currPos;
+    s2 = peg$parseIdentifier();
+    if (s2 !== peg$FAILED) {
+      if (input.charCodeAt(peg$currPos) === 61) {
+        s3 = peg$c1;
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e2);
+        }
+      }
+      if (s3 !== peg$FAILED) {
+        peg$savedPos = s1;
+        s1 = peg$f11(s2);
+      } else {
+        peg$currPos = s1;
+        s1 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s1;
+      s1 = peg$FAILED;
+    }
+    if (s1 === peg$FAILED) {
+      s1 = null;
+    }
+    s2 = peg$parseValue();
+    if (s2 !== peg$FAILED) {
+      peg$savedPos = s0;
+      s0 = peg$f12(s1, s2);
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    return s0;
+  }
+  function peg$parseFunctionParameterTail() {
+    let s0, s1, s2, s3, s4;
+    s0 = peg$currPos;
+    s1 = [];
+    s2 = peg$parse_();
+    while (s2 !== peg$FAILED) {
+      s1.push(s2);
+      s2 = peg$parse_();
+    }
+    if (input.charCodeAt(peg$currPos) === 44) {
+      s2 = peg$c4;
+      peg$currPos++;
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e5);
+      }
+    }
+    if (s2 !== peg$FAILED) {
+      s3 = [];
+      s4 = peg$parse_();
+      while (s4 !== peg$FAILED) {
+        s3.push(s4);
+        s4 = peg$parse_();
+      }
+      s4 = peg$parseFunctionParameter();
+      if (s4 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s0 = peg$f13(s4);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    return s0;
+  }
+  function peg$parseTrailingComma() {
+    let s0, s1, s2;
+    s0 = peg$currPos;
+    s1 = [];
+    s2 = peg$parse_();
+    while (s2 !== peg$FAILED) {
+      s1.push(s2);
+      s2 = peg$parse_();
+    }
+    if (input.charCodeAt(peg$currPos) === 44) {
+      s2 = peg$c4;
+      peg$currPos++;
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e5);
+      }
+    }
+    if (s2 !== peg$FAILED) {
+      s1 = [s1, s2];
+      s0 = s1;
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = null;
+    }
+    return s0;
+  }
+  function peg$parseVariable() {
+    let s0, s1, s2, s3, s4;
+    peg$silentFails++;
+    s0 = peg$currPos;
+    s1 = input.charAt(peg$currPos);
+    if (peg$r0.test(s1)) {
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e7);
+      }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseIdentifier();
+      if (s2 !== peg$FAILED) {
+        s3 = [];
+        s4 = peg$parseVariableTail();
+        while (s4 !== peg$FAILED) {
+          s3.push(s4);
+          s4 = peg$parseVariableTail();
+        }
+        peg$savedPos = s0;
+        s0 = peg$f14(s1, s2, s3);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e6);
+      }
+    }
+    return s0;
+  }
+  function peg$parseVariableTail() {
+    let s0, s1, s2, s3;
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 46) {
+      s1 = peg$c5;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e8);
+      }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parseIdentifier();
+      if (s2 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s0 = peg$f15(s2);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 91) {
+        s1 = peg$c6;
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e9);
+        }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = peg$parseValueNumber();
+        if (s2 === peg$FAILED) {
+          s2 = peg$parseValueString();
+        }
+        if (s2 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 93) {
+            s3 = peg$c7;
+            peg$currPos++;
+          } else {
+            s3 = peg$FAILED;
+            if (peg$silentFails === 0) {
+              peg$fail(peg$e10);
+            }
+          }
+          if (s3 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s0 = peg$f16(s2);
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    }
+    return s0;
+  }
+  function peg$parseValue() {
+    let s0;
+    s0 = peg$parseValueNull();
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseValueBoolean();
+      if (s0 === peg$FAILED) {
+        s0 = peg$parseValueString();
+        if (s0 === peg$FAILED) {
+          s0 = peg$parseValueNumber();
+          if (s0 === peg$FAILED) {
+            s0 = peg$parseValueArray();
+            if (s0 === peg$FAILED) {
+              s0 = peg$parseValueHash();
+              if (s0 === peg$FAILED) {
+                s0 = peg$parseFunction();
+                if (s0 === peg$FAILED) {
+                  s0 = peg$parseVariable();
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    return s0;
+  }
+  function peg$parseValueNull() {
+    let s0, s1;
+    peg$silentFails++;
+    s0 = peg$currPos;
+    if (input.substr(peg$currPos, 4) === peg$c8) {
+      s1 = peg$c8;
+      peg$currPos += 4;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e12);
+      }
+    }
+    if (s1 !== peg$FAILED) {
+      peg$savedPos = s0;
+      s1 = peg$f17();
+    }
+    s0 = s1;
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e11);
+      }
+    }
+    return s0;
+  }
+  function peg$parseValueBoolean() {
+    let s0, s1;
+    peg$silentFails++;
+    s0 = peg$currPos;
+    if (input.substr(peg$currPos, 4) === peg$c9) {
+      s1 = peg$c9;
+      peg$currPos += 4;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e14);
+      }
+    }
+    if (s1 !== peg$FAILED) {
+      peg$savedPos = s0;
+      s1 = peg$f18();
+    }
+    s0 = s1;
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      if (input.substr(peg$currPos, 5) === peg$c10) {
+        s1 = peg$c10;
+        peg$currPos += 5;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e15);
+        }
+      }
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$f19();
+      }
+      s0 = s1;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e13);
+      }
+    }
+    return s0;
+  }
+  function peg$parseValueArray() {
+    let s0, s1, s2, s3, s4, s5, s6;
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 91) {
+      s1 = peg$c6;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e9);
+      }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$parse_();
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$parse_();
+      }
+      s3 = peg$currPos;
+      s4 = peg$parseValue();
+      if (s4 !== peg$FAILED) {
+        s5 = [];
+        s6 = peg$parseValueArrayTail();
+        while (s6 !== peg$FAILED) {
+          s5.push(s6);
+          s6 = peg$parseValueArrayTail();
+        }
+        s6 = peg$parseTrailingComma();
+        peg$savedPos = s3;
+        s3 = peg$f20(s4, s5);
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      if (s3 === peg$FAILED) {
+        s3 = null;
+      }
+      s4 = [];
+      s5 = peg$parse_();
+      while (s5 !== peg$FAILED) {
+        s4.push(s5);
+        s5 = peg$parse_();
+      }
+      if (input.charCodeAt(peg$currPos) === 93) {
+        s5 = peg$c7;
+        peg$currPos++;
+      } else {
+        s5 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e10);
+        }
+      }
+      if (s5 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s0 = peg$f21(s3);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    return s0;
+  }
+  function peg$parseValueArrayTail() {
+    let s0, s1, s2, s3, s4;
+    s0 = peg$currPos;
+    s1 = [];
+    s2 = peg$parse_();
+    while (s2 !== peg$FAILED) {
+      s1.push(s2);
+      s2 = peg$parse_();
+    }
+    if (input.charCodeAt(peg$currPos) === 44) {
+      s2 = peg$c4;
+      peg$currPos++;
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e5);
+      }
+    }
+    if (s2 !== peg$FAILED) {
+      s3 = [];
+      s4 = peg$parse_();
+      while (s4 !== peg$FAILED) {
+        s3.push(s4);
+        s4 = peg$parse_();
+      }
+      s4 = peg$parseValue();
+      if (s4 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s0 = peg$f22(s4);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    return s0;
+  }
+  function peg$parseValueHash() {
+    let s0, s1, s2, s3, s4, s5, s6;
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 123) {
+      s1 = peg$c11;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e16);
+      }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$parse_();
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$parse_();
+      }
+      s3 = peg$currPos;
+      s4 = peg$parseValueHashItem();
+      if (s4 !== peg$FAILED) {
+        s5 = [];
+        s6 = peg$parseValueHashTail();
+        while (s6 !== peg$FAILED) {
+          s5.push(s6);
+          s6 = peg$parseValueHashTail();
+        }
+        s6 = peg$parseTrailingComma();
+        peg$savedPos = s3;
+        s3 = peg$f23(s4, s5);
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      if (s3 === peg$FAILED) {
+        s3 = null;
+      }
+      s4 = [];
+      s5 = peg$parse_();
+      while (s5 !== peg$FAILED) {
+        s4.push(s5);
+        s5 = peg$parse_();
+      }
+      if (input.charCodeAt(peg$currPos) === 125) {
+        s5 = peg$c12;
+        peg$currPos++;
+      } else {
+        s5 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e17);
+        }
+      }
+      if (s5 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s0 = peg$f24(s3);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    return s0;
+  }
+  function peg$parseValueHashTail() {
+    let s0, s1, s2, s3, s4;
+    s0 = peg$currPos;
+    s1 = [];
+    s2 = peg$parse_();
+    while (s2 !== peg$FAILED) {
+      s1.push(s2);
+      s2 = peg$parse_();
+    }
+    if (input.charCodeAt(peg$currPos) === 44) {
+      s2 = peg$c4;
+      peg$currPos++;
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e5);
+      }
+    }
+    if (s2 !== peg$FAILED) {
+      s3 = [];
+      s4 = peg$parse_();
+      while (s4 !== peg$FAILED) {
+        s3.push(s4);
+        s4 = peg$parse_();
+      }
+      s4 = peg$parseValueHashItem();
+      if (s4 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s0 = peg$f25(s4);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    return s0;
+  }
+  function peg$parseValueHashItem() {
+    let s0, s1, s2, s3, s4;
+    s0 = peg$currPos;
+    s1 = peg$parseIdentifier();
+    if (s1 === peg$FAILED) {
+      s1 = peg$parseValueString();
+    }
+    if (s1 !== peg$FAILED) {
+      if (input.charCodeAt(peg$currPos) === 58) {
+        s2 = peg$c13;
+        peg$currPos++;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e18);
+        }
+      }
+      if (s2 !== peg$FAILED) {
+        s3 = [];
+        s4 = peg$parse_();
+        while (s4 !== peg$FAILED) {
+          s3.push(s4);
+          s4 = peg$parse_();
+        }
+        s4 = peg$parseValue();
+        if (s4 !== peg$FAILED) {
+          peg$savedPos = s0;
+          s0 = peg$f26(s1, s4);
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    return s0;
+  }
+  function peg$parseValueNumber() {
+    let s0, s2, s3, s4, s5, s6;
+    peg$silentFails++;
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 45) {
+      peg$currPos++;
+    } else {
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e20);
+      }
+    }
+    s2 = [];
+    s3 = input.charAt(peg$currPos);
+    if (peg$r1.test(s3)) {
+      peg$currPos++;
+    } else {
+      s3 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e21);
+      }
+    }
+    if (s3 !== peg$FAILED) {
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = input.charAt(peg$currPos);
+        if (peg$r1.test(s3)) {
+          peg$currPos++;
+        } else {
+          s3 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e21);
+          }
+        }
+      }
+    } else {
+      s2 = peg$FAILED;
+    }
+    if (s2 !== peg$FAILED) {
+      s3 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 46) {
+        s4 = peg$c5;
+        peg$currPos++;
+      } else {
+        s4 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e8);
+        }
+      }
+      if (s4 !== peg$FAILED) {
+        s5 = [];
+        s6 = input.charAt(peg$currPos);
+        if (peg$r1.test(s6)) {
+          peg$currPos++;
+        } else {
+          s6 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e21);
+          }
+        }
+        if (s6 !== peg$FAILED) {
+          while (s6 !== peg$FAILED) {
+            s5.push(s6);
+            s6 = input.charAt(peg$currPos);
+            if (peg$r1.test(s6)) {
+              peg$currPos++;
+            } else {
+              s6 = peg$FAILED;
+              if (peg$silentFails === 0) {
+                peg$fail(peg$e21);
+              }
+            }
+          }
+        } else {
+          s5 = peg$FAILED;
+        }
+        if (s5 !== peg$FAILED) {
+          s4 = [s4, s5];
+          s3 = s4;
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      if (s3 === peg$FAILED) {
+        s3 = null;
+      }
+      peg$savedPos = s0;
+      s0 = peg$f27();
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e19);
+      }
+    }
+    return s0;
+  }
+  function peg$parseValueString() {
+    let s0, s1, s2, s3;
+    peg$silentFails++;
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 34) {
+      s1 = peg$c15;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e23);
+      }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$parseValueStringChars();
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$parseValueStringChars();
+      }
+      if (input.charCodeAt(peg$currPos) === 34) {
+        s3 = peg$c15;
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e23);
+        }
+      }
+      if (s3 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s0 = peg$f28(s2);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e22);
+      }
+    }
+    return s0;
+  }
+  function peg$parseValueStringChars() {
+    let s0;
+    s0 = input.charAt(peg$currPos);
+    if (peg$r2.test(s0)) {
+      peg$currPos++;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e24);
+      }
+    }
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseValueStringEscapes();
+    }
+    return s0;
+  }
+  function peg$parseValueStringEscapes() {
+    let s0, s1, s2, s3;
+    s0 = peg$currPos;
+    if (input.charCodeAt(peg$currPos) === 92) {
+      s1 = peg$c16;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e25);
+      }
+    }
+    if (s1 !== peg$FAILED) {
+      s2 = input.charAt(peg$currPos);
+      if (peg$r3.test(s2)) {
+        peg$currPos++;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e26);
+        }
+      }
+      if (s2 === peg$FAILED) {
+        s2 = peg$currPos;
+        if (input.charCodeAt(peg$currPos) === 110) {
+          s3 = peg$c17;
+          peg$currPos++;
+        } else {
+          s3 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e27);
+          }
+        }
+        if (s3 !== peg$FAILED) {
+          peg$savedPos = s2;
+          s3 = peg$f29();
+        }
+        s2 = s3;
+        if (s2 === peg$FAILED) {
+          s2 = peg$currPos;
+          if (input.charCodeAt(peg$currPos) === 114) {
+            s3 = peg$c18;
+            peg$currPos++;
+          } else {
+            s3 = peg$FAILED;
+            if (peg$silentFails === 0) {
+              peg$fail(peg$e28);
+            }
+          }
+          if (s3 !== peg$FAILED) {
+            peg$savedPos = s2;
+            s3 = peg$f30();
+          }
+          s2 = s3;
+          if (s2 === peg$FAILED) {
+            s2 = peg$currPos;
+            if (input.charCodeAt(peg$currPos) === 116) {
+              s3 = peg$c19;
+              peg$currPos++;
+            } else {
+              s3 = peg$FAILED;
+              if (peg$silentFails === 0) {
+                peg$fail(peg$e29);
+              }
+            }
+            if (s3 !== peg$FAILED) {
+              peg$savedPos = s2;
+              s3 = peg$f31();
+            }
+            s2 = s3;
+          }
+        }
+      }
+      if (s2 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s0 = peg$f32(s2);
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+    return s0;
+  }
+  function peg$parseIdentifier() {
+    let s0, s1, s2;
+    peg$silentFails++;
+    s0 = peg$currPos;
+    s1 = [];
+    s2 = input.charAt(peg$currPos);
+    if (peg$r4.test(s2)) {
+      peg$currPos++;
+    } else {
+      s2 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e31);
+      }
+    }
+    if (s2 !== peg$FAILED) {
+      while (s2 !== peg$FAILED) {
+        s1.push(s2);
+        s2 = input.charAt(peg$currPos);
+        if (peg$r4.test(s2)) {
+          peg$currPos++;
+        } else {
+          s2 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e31);
+          }
+        }
+      }
+    } else {
+      s1 = peg$FAILED;
+    }
+    if (s1 !== peg$FAILED) {
+      s0 = input.substring(s0, peg$currPos);
+    } else {
+      s0 = s1;
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      s1 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e30);
+      }
+    }
+    return s0;
+  }
+  function peg$parse_() {
+    let s0;
+    peg$silentFails++;
+    s0 = input.charAt(peg$currPos);
+    if (peg$r5.test(s0)) {
+      peg$currPos++;
+    } else {
+      s0 = peg$FAILED;
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e33);
+      }
+    }
+    peg$silentFails--;
+    if (s0 === peg$FAILED) {
+      if (peg$silentFails === 0) {
+        peg$fail(peg$e32);
+      }
+    }
+    return s0;
+  }
+  const { Variable: Variable2, Function: Function3 } = options;
+  peg$result = peg$startRuleFunction();
+  const peg$success = peg$result !== peg$FAILED && peg$currPos === input.length;
+  function peg$throw() {
+    if (peg$result !== peg$FAILED && peg$currPos < input.length) {
+      peg$fail(peg$endExpectation());
+    }
+    throw peg$buildStructuredError(
+      peg$maxFailExpected,
+      peg$maxFailPos < input.length ? peg$getUnicode(peg$maxFailPos) : null,
+      peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)
+    );
+  }
+  if (options.peg$library) {
+    return (
+      /** @type {any} */
+      {
+        peg$result,
+        peg$currPos,
+        peg$FAILED,
+        peg$maxFailExpected,
+        peg$maxFailPos,
+        peg$success,
+        peg$throw: peg$success ? void 0 : peg$throw
+      }
+    );
+  }
+  if (peg$success) {
+    return peg$result;
+  } else {
+    peg$throw();
+  }
+}
+class Variable {
+  constructor(path = []) {
+    this.$$mdtype = "Variable";
+    this.path = path;
+  }
+  resolve({ variables } = {}) {
+    return variables instanceof Function ? variables(this.path) : this.path.reduce((obj = {}, key) => obj[key], variables);
+  }
+}
+let Function$1 = class Function2 {
+  constructor(name, parameters) {
+    this.$$mdtype = "Function";
+    this.name = name;
+    this.parameters = parameters;
+  }
+  resolve(config = {}) {
+    const fn = config?.functions?.[this.name];
+    if (!fn) return null;
+    const parameters = resolve$1(this.parameters, config);
+    return fn.transform?.(parameters, config);
+  }
+};
+const OPEN$1 = "{%";
+const CLOSE$1 = "%}";
+const IDENTIFIER_REGEX = /^[a-zA-Z0-9_-]+$/;
+function isIdentifier(s2) {
+  return typeof s2 === "string" && IDENTIFIER_REGEX.test(s2);
+}
+function isPromise(a) {
+  return a && typeof a === "object" && typeof a.then === "function";
+}
+function findTagEnd(content, start = 0) {
+  let state = 0;
+  for (let pos = start; pos < content.length; pos++) {
+    const char = content[pos];
+    switch (state) {
+      case 1:
+        switch (char) {
+          case '"':
+            state = 0;
+            break;
+          case "\\":
+            state = 2;
+            break;
+        }
+        break;
+      case 2:
+        state = 1;
+        break;
+      case 0:
+        if (char === '"') state = 1;
+        else if (content.startsWith(CLOSE$1, pos)) return pos;
+    }
+  }
+  return null;
+}
+function parseTag(content, line, contentStart) {
+  try {
+    return peg$parse(content, { Variable, Function: Function$1 });
+  } catch (error2) {
+    if (!(error2 instanceof peg$SyntaxError)) throw error2;
+    const {
+      message,
+      location: { start, end }
+    } = error2;
+    const location = {
+      start: { line, character: start.offset + contentStart },
+      end: { line: line + 1, character: end.offset + contentStart }
+    };
+    return { type: "error", meta: { error: { message, location } } };
+  }
+}
+function parseTags(content, firstLine = 0) {
+  let line = firstLine + 1;
+  const output = [];
+  let start = 0;
+  for (let pos = 0; pos < content.length; pos++) {
+    if (content[pos] === "\n") {
+      line++;
+      continue;
+    }
+    if (!content.startsWith(OPEN$1, pos)) continue;
+    const end = findTagEnd(content, pos);
+    if (end == null) {
+      pos = pos + OPEN$1.length;
+      continue;
+    }
+    const text2 = content.slice(pos, end + CLOSE$1.length);
+    const inner = content.slice(pos + OPEN$1.length, end);
+    const lineStart = content.lastIndexOf("\n", pos);
+    const lineEnd = content.indexOf("\n", end);
+    const lineContent = content.slice(lineStart, lineEnd);
+    const tag = parseTag(inner.trim(), line, pos - lineStart);
+    const precedingTextEnd = lineContent.trim() === text2 ? lineStart : pos;
+    const precedingText = content.slice(start, precedingTextEnd);
+    output.push({
+      type: "text",
+      start,
+      end: pos - 1,
+      content: precedingText
+    });
+    output.push({
+      map: [line, line + 1],
+      position: {
+        start: pos - lineStart,
+        end: pos - lineStart + text2.length
+      },
+      start: pos,
+      end: pos + text2.length - 1,
+      info: text2,
+      ...tag
+    });
+    start = end + CLOSE$1.length;
+    pos = start - 1;
+  }
+  output.push({
+    type: "text",
+    start,
+    end: content.length - 1,
+    content: content.slice(start)
+  });
+  return output;
+}
+const transformer = {
+  findSchema(node2, { nodes: nodes2 = {}, tags: tags2 = {} } = {}) {
+    return node2.tag ? tags2[node2.tag] : nodes2[node2.type];
+  },
+  attributes(node2, config = {}) {
+    const schema = this.findSchema(node2, config) ?? {};
+    const output = {};
+    const attrs = { ...schema.attributes };
+    for (const [key, attr] of Object.entries(attrs)) {
+      if (attr.render == false) continue;
+      const name = typeof attr.render === "string" ? attr.render : key;
+      let value = node2.attributes[key];
+      if (typeof attr.type === "function") {
+        const instance = new attr.type();
+        if (instance.transform) {
+          value = instance.transform(value, config);
+        }
+      }
+      value = value === void 0 ? attr.default : value;
+      if (value === void 0) continue;
+      output[name] = value;
+    }
+    if (schema.slots) {
+      for (const [key, slot2] of Object.entries(schema.slots)) {
+        if (slot2.render === false) continue;
+        const name = typeof slot2.render === "string" ? slot2.render : key;
+        if (node2.slots[key]) output[name] = this.node(node2.slots[key], config);
+      }
+    }
+    return output;
+  },
+  children(node2, config = {}) {
+    const children = node2.children.flatMap(
+      (child) => this.node(child, config)
+    );
+    if (children.some(isPromise)) {
+      return Promise.all(children);
+    }
+    return children;
+  },
+  node(node2, config = {}) {
+    const schema = this.findSchema(node2, config) ?? {};
+    if (schema && schema.transform instanceof Function) return schema.transform(node2, config);
+    const children = this.children(node2, config);
+    if (!schema || !schema.render) return children;
+    const attributes = this.attributes(node2, config);
+    if (isPromise(attributes) || isPromise(children)) {
+      return Promise.all([attributes, children]).then(
+        (values) => new Tag(schema.render, ...values)
+      );
+    }
+    return new Tag(schema.render, attributes, children);
+  }
+};
+class Node {
+  constructor(type = "node", attributes = {}, children = [], tag) {
+    this.$$mdtype = "Node";
+    this.errors = [];
+    this.lines = [];
+    this.inline = false;
+    this.attributes = attributes;
+    this.children = children;
+    this.type = type;
+    this.tag = tag;
+    this.annotations = [];
+    this.slots = {};
+  }
+  *walk() {
+    for (const child of [...Object.values(this.slots), ...this.children]) {
+      yield child;
+      yield* child.walk();
+    }
+  }
+  push(node2) {
+    this.children.push(node2);
+  }
+  resolve(config = {}) {
+    return Object.assign(new Node(), this, {
+      children: this.children.map((child) => child.resolve(config)),
+      attributes: resolve$1(this.attributes, config),
+      slots: Object.fromEntries(
+        Object.entries(this.slots).map(([name, slot2]) => [name, slot2.resolve(config)])
+      )
+    });
+  }
+  findSchema(config = {}) {
+    return transformer.findSchema(this, config);
+  }
+  transformAttributes(config = {}) {
+    return transformer.attributes(this, config);
+  }
+  transformChildren(config) {
+    return transformer.children(this, config);
+  }
+  transform(config) {
+    return transformer.node(this, config);
+  }
+}
+const AstTypes = {
+  Function: Function$1,
+  Node,
+  Variable
+};
+function reviver(_, value) {
+  if (!value) return value;
+  const klass = AstTypes[value.$$mdtype];
+  return klass ? Object.assign(new klass(), value) : value;
+}
+function fromJSON(text2) {
+  return JSON.parse(text2, reviver);
+}
+const Ast = {
+  ...AstTypes,
+  ...base,
+  fromJSON
+};
+const SPACE = " ";
+const SEP = ", ";
+const NL = "\n";
+const OL = ".";
+const UL = "-";
+const MAX_TAG_OPENING_WIDTH = 80;
+const WRAPPING_TYPES = ["strong", "em", "s"];
+const max = (a, b) => Math.max(a, b);
+const increment = (o, n = 2) => ({
+  ...o,
+  indent: (o.indent || 0) + n
+});
+function* formatChildren(a, options) {
+  for (const child of a.children) {
+    yield* formatValue(child, options);
+  }
+}
+function* formatInline(g) {
+  yield [...g].join("").trim();
+}
+function* formatTableRow(items) {
+  yield `| ${items.join(" | ")} |`;
+}
+function formatScalar(v) {
+  if (v === void 0) {
+    return void 0;
+  }
+  if (Ast.isAst(v)) {
+    return format(v);
+  }
+  if (v === null) {
+    return "null";
+  }
+  if (Array.isArray(v)) {
+    return "[" + v.map(formatScalar).join(SEP) + "]";
+  }
+  if (typeof v === "object") {
+    return "{" + Object.entries(v).map(([key, value]) => `${isIdentifier(key) ? key : `"${key}"`}: ${formatScalar(value)}`).join(SEP) + "}";
+  }
+  return JSON.stringify(v);
+}
+function formatAnnotationValue(a) {
+  const formattedValue = formatScalar(a.value);
+  if (formattedValue === void 0) return void 0;
+  if (a.name === "primary") return formattedValue;
+  return `${a.name}=${formattedValue}`;
+}
+function* formatAttributes(n) {
+  for (const [key, value] of Object.entries(n.attributes)) {
+    yield formatAnnotationValue({ name: key, value });
+  }
+}
+function* formatAnnotations(n) {
+  if (n.annotations.length) {
+    yield OPEN$1 + SPACE;
+    yield n.annotations.map(formatAnnotationValue).join(SPACE);
+    yield SPACE + CLOSE$1;
+  }
+}
+function* formatVariable(v) {
+  yield "$";
+  yield v.path.map((p, i) => {
+    if (i === 0) return p;
+    if (isIdentifier(p)) return "." + p;
+    if (typeof p === "number") return `[${p}]`;
+    return `["${p}"]`;
+  }).join("");
+}
+function* formatFunction(f) {
+  yield f.name;
+  yield "(";
+  yield Object.values(f.parameters).map(formatScalar).join(SEP);
+  yield ")";
+}
+function* trimStart(g) {
+  let n;
+  do {
+    const { value, done } = g.next();
+    if (done) return;
+    n = value.trimStart();
+  } while (!n.length);
+  yield n;
+  yield* g;
+}
+function* escapeMarkdownCharacters(s2, characters) {
+  yield s2.replace(characters, "\\$&").replace(new RegExp(" ", "g"), "&nbsp;");
+}
+function* formatNode(n, o = {}) {
+  const no = { ...o, parent: n };
+  const indent = SPACE.repeat(no.indent || 0);
+  switch (n.type) {
+    case "document": {
+      if (n.attributes.frontmatter && n.attributes.frontmatter.length) {
+        yield "---" + NL + n.attributes.frontmatter + NL + "---" + NL + NL;
+      }
+      yield* trimStart(formatChildren(n, no));
+      break;
+    }
+    case "heading": {
+      yield NL;
+      yield indent;
+      yield "#".repeat(n.attributes.level || 1);
+      yield SPACE;
+      yield* trimStart(formatChildren(n, no));
+      yield* formatAnnotations(n);
+      yield NL;
+      break;
+    }
+    case "paragraph": {
+      yield NL;
+      yield* formatChildren(n, no);
+      yield* formatAnnotations(n);
+      yield NL;
+      break;
+    }
+    case "inline": {
+      yield indent;
+      yield* formatChildren(n, no);
+      break;
+    }
+    case "image": {
+      yield "!";
+      yield "[";
+      yield* formatValue(n.attributes.alt, no);
+      yield "]";
+      yield "(";
+      yield* typeof n.attributes.src === "string" ? escapeMarkdownCharacters(n.attributes.src, /[()]/g) : formatValue(n.attributes.src, no);
+      if (n.attributes.title) {
+        yield SPACE + `"${n.attributes.title}"`;
+      }
+      yield ")";
+      break;
+    }
+    case "link": {
+      const children = [...formatChildren(n, no)].join("");
+      if (children === n.attributes.href && !n.attributes.title) {
+        yield `<${n.attributes.href}>`;
+        break;
+      }
+      yield "[";
+      yield children;
+      yield "]";
+      yield "(";
+      yield* typeof n.attributes.href === "string" ? escapeMarkdownCharacters(n.attributes.href, /[()]/g) : formatValue(n.attributes.href, no);
+      if (n.attributes.title) {
+        yield SPACE + `"${n.attributes.title}"`;
+      }
+      yield ")";
+      break;
+    }
+    case "text": {
+      const { content } = n.attributes;
+      if (Ast.isAst(content)) {
+        yield OPEN$1 + SPACE;
+        yield* formatValue(content, no);
+        yield SPACE + CLOSE$1;
+      } else {
+        if (o.parent && WRAPPING_TYPES.includes(o.parent.type)) {
+          yield* escapeMarkdownCharacters(content, /[*_~]/g);
+        } else {
+          yield* escapeMarkdownCharacters(content, /^\*|#+\s|^>/);
+        }
+      }
+      break;
+    }
+    case "blockquote": {
+      const prefix = ">" + SPACE;
+      yield n.children.map((child) => format(child, no).trimStart()).map((d) => NL + indent + prefix + d).join(indent + prefix);
+      break;
+    }
+    case "hr": {
+      yield NL;
+      yield indent;
+      yield "---";
+      yield NL;
+      break;
+    }
+    case "fence": {
+      yield NL;
+      yield indent;
+      const innerFence = n.attributes.content.match(/`{3,}/g) || [];
+      const innerFenceLength = innerFence.map((s2) => s2.length).reduce(max, 0);
+      const boundary = "`".repeat(innerFenceLength ? innerFenceLength + 1 : 3);
+      const needsNlBeforeEndBoundary = !n.attributes.content.endsWith(NL);
+      yield boundary;
+      if (n.attributes.language) yield n.attributes.language;
+      if (n.annotations.length) yield SPACE;
+      yield* formatAnnotations(n);
+      yield NL;
+      yield indent;
+      yield n.attributes.content.split(NL).join(NL + indent);
+      if (needsNlBeforeEndBoundary) {
+        yield NL;
+      }
+      yield boundary;
+      yield NL;
+      break;
+    }
+    case "tag": {
+      if (!n.inline) {
+        yield NL;
+        yield indent;
+      }
+      const open = OPEN$1 + SPACE;
+      const attributes = [...formatAttributes(n)].filter((v) => v !== void 0);
+      const tag = [open + n.tag, ...attributes];
+      const inlineTag = tag.join(SPACE);
+      const isLongTagOpening = inlineTag.length + open.length * 2 > (o.maxTagOpeningWidth || MAX_TAG_OPENING_WIDTH);
+      yield (!n.inline && isLongTagOpening ? tag.join(NL + SPACE.repeat(open.length) + indent) : inlineTag) + SPACE + (n.children.length ? "" : "/") + CLOSE$1;
+      if (n.children.length) {
+        yield* formatChildren(n, no.allowIndentation ? increment(no) : no);
+        if (!n.inline) {
+          yield indent;
+        }
+        yield OPEN$1 + SPACE + "/" + n.tag + SPACE + CLOSE$1;
+      }
+      if (!n.inline) {
+        yield NL;
+      }
+      break;
+    }
+    case "list": {
+      const isLoose = n.children.some((n2) => n2.children.some((c) => c.type === "paragraph"));
+      for (let i = 0; i < n.children.length; i++) {
+        const prefix = (() => {
+          if (!n.attributes.ordered) return n.attributes.marker ?? UL;
+          let number = "1";
+          const startNumber = n.attributes.start ?? 1;
+          if (i === 0) number = startNumber.toString();
+          if (o.orderedListMode === "increment") {
+            number = (parseInt(startNumber) + i).toString();
+          }
+          return `${number}${n.attributes.marker ?? OL}`;
+        })();
+        let d = format(n.children[i], increment(no, prefix.length + 1));
+        if (!isLoose || i === n.children.length - 1) {
+          d = d.trim();
+        }
+        yield NL + indent + prefix + " " + d;
+      }
+      yield NL;
+      break;
+    }
+    case "item": {
+      for (let i = 0; i < n.children.length; i++) {
+        yield* formatValue(n.children[i], no);
+        if (i === 0) yield* formatAnnotations(n);
+      }
+      break;
+    }
+    case "strong": {
+      yield n.attributes.marker ?? "**";
+      yield* formatInline(formatChildren(n, no));
+      yield n.attributes.marker ?? "**";
+      break;
+    }
+    case "em": {
+      yield n.attributes.marker ?? "*";
+      yield* formatInline(formatChildren(n, no));
+      yield n.attributes.marker ?? "*";
+      break;
+    }
+    case "code": {
+      yield "`";
+      yield* formatInline(formatValue(n.attributes.content, no));
+      yield "`";
+      break;
+    }
+    case "s": {
+      yield "~~";
+      yield* formatInline(formatChildren(n, no));
+      yield "~~";
+      break;
+    }
+    case "hardbreak": {
+      yield "\\" + NL;
+      yield indent;
+      break;
+    }
+    case "softbreak": {
+      yield NL;
+      yield indent;
+      break;
+    }
+    case "table": {
+      const table2 = [...formatChildren(n, increment(no))];
+      if (o.parent && o.parent.type === "tag" && o.parent.tag === "table") {
+        for (let i = 0; i < table2.length; i++) {
+          const row = table2[i];
+          if (typeof row === "string") {
+            if (row.trim().length) {
+              yield NL;
+              yield row;
+            }
+          } else {
+            if (i !== 0) {
+              yield NL;
+              yield indent + "---";
+            }
+            for (const d of row) {
+              yield NL + indent + UL + " " + d;
+            }
+          }
+        }
+        yield NL;
+      } else {
+        const widths = [];
+        for (const row of table2) {
+          for (let i = 0; i < row.length; i++) {
+            widths[i] = widths[i] ? Math.max(widths[i], row[i].length) : row[i].length;
+          }
+        }
+        const [head, ...rows] = table2;
+        yield NL;
+        yield* formatTableRow(head.map((cell, i) => cell + SPACE.repeat(widths[i] - cell.length)));
+        yield NL;
+        yield* formatTableRow(head.map((cell, i) => "-".repeat(widths[i])));
+        yield NL;
+        for (const row of rows) {
+          yield* formatTableRow(row.map((cell, i) => cell + SPACE.repeat(widths[i] - cell.length)));
+          yield NL;
+        }
+      }
+      break;
+    }
+    case "thead": {
+      const [head] = [...formatChildren(n, no)];
+      yield head || [];
+      break;
+    }
+    case "tr": {
+      yield [...formatChildren(n, no)];
+      break;
+    }
+    case "td":
+    case "th": {
+      yield [...formatChildren(n, no), ...formatAnnotations(n)].join("").trim();
+      break;
+    }
+    case "tbody": {
+      yield* formatChildren(n, no);
+      break;
+    }
+    case "comment": {
+      yield "<!-- " + n.attributes.content + " -->\n";
+      break;
+    }
+  }
+}
+function* formatValue(v, o = {}) {
+  switch (typeof v) {
+    case "undefined":
+      break;
+    case "boolean":
+    case "number":
+    case "string": {
+      yield v.toString();
+      break;
+    }
+    case "object": {
+      if (v === null) break;
+      if (Array.isArray(v)) {
+        for (const n of v) yield* formatValue(n, o);
+        break;
+      }
+      switch (v.$$mdtype) {
+        case "Function": {
+          yield* formatFunction(v);
+          break;
+        }
+        case "Node":
+          yield* formatNode(v, o);
+          break;
+        case "Variable": {
+          yield* formatVariable(v);
+          break;
+        }
+        default:
+          throw new Error(`Unimplemented: "${v.$$mdtype}"`);
+      }
+      break;
+    }
+  }
+}
+function format(v, options) {
+  let doc = "";
+  for (const s2 of formatValue(v, options)) doc += s2;
+  return doc.trimStart();
+}
+class ConditionalAttributeType {
+  validate(value, _config, key) {
+    if (typeof value === "boolean" || value === null || value === void 0 || typeof value === "object") {
+      return [];
+    }
+    return [
+      {
+        id: "attribute-type-invalid",
+        level: "error",
+        message: `Attribute '${key}' must be type 'boolean | object' (null or undefined are also allowed)`
+      }
+    ];
+  }
+}
+function truthy(value) {
+  return value !== false && value !== void 0 && value !== null;
+}
+function renderConditions(node2) {
+  const conditions = [{ condition: node2.attributes.primary, children: [] }];
+  for (const child of node2.children) {
+    if (child.type === "tag" && child.tag === "else")
+      conditions.push({
+        condition: "primary" in child.attributes ? child.attributes.primary : true,
+        children: []
+      });
+    else conditions[conditions.length - 1].children.push(child);
+  }
+  return conditions;
+}
+const tagIf = {
+  attributes: {
+    primary: { type: ConditionalAttributeType, render: false }
+  },
+  transform(node2, config) {
+    const conditions = renderConditions(node2);
+    for (const { condition, children } of conditions)
+      if (truthy(condition)) {
+        const nodes2 = children.flatMap(
+          (child) => child.transform(config)
+        );
+        if (nodes2.some(isPromise)) {
+          return Promise.all(nodes2).then((nodes22) => nodes22.flat());
+        }
+        return nodes2;
+      }
+    return [];
+  }
+};
+const tagElse = {
+  selfClosing: true,
+  attributes: {
+    primary: { type: ConditionalAttributeType, render: false }
+  }
+};
+const and = {
+  transform(parameters) {
+    return Object.values(parameters).every((x) => truthy(x));
+  }
+};
+const or = {
+  transform(parameters) {
+    return Object.values(parameters).find((x) => truthy(x)) !== void 0;
+  }
+};
+const not = {
+  parameters: {
+    0: { required: true }
+  },
+  transform(parameters) {
+    return !truthy(parameters[0]);
+  }
+};
+const equals = {
+  transform(parameters) {
+    const values = Object.values(parameters);
+    return values.every((v) => v === values[0]);
+  }
+};
+const debug = {
+  transform(parameters) {
+    return JSON.stringify(parameters[0], null, 2);
+  }
+};
+const defaultFn = {
+  transform(parameters) {
+    return parameters[0] === void 0 ? parameters[1] : parameters[0];
+  }
+};
+const functions = { and, or, not, equals, default: defaultFn, debug };
+function convertToRow(node2, cellType = "td") {
+  node2.type = "tr";
+  node2.attributes = {};
+  for (const cell of node2.children) cell.type = cellType;
+  return node2;
+}
+function transform$1(document2) {
+  for (const node2 of document2.walk()) {
+    if (node2.type !== "tag" || node2.tag !== "table") continue;
+    const [first, ...rest] = node2.children;
+    if (!first || first.type === "table") continue;
+    const table2 = new Ast.Node("table", node2.attributes, [
+      new Ast.Node("thead"),
+      new Ast.Node("tbody")
+    ]);
+    const [thead2, tbody2] = table2.children;
+    if (first.type === "list") thead2.push(convertToRow(first, "th"));
+    for (const row of rest) {
+      if (row.type === "list") convertToRow(row);
+      else if (row.type === "tag" && row.tag === "if") {
+        const children = [];
+        for (const child of row.children) {
+          if (child.type === "hr") continue;
+          if (child.type === "list") convertToRow(child);
+          children.push(child);
+        }
+        row.children = children;
+      } else continue;
+      tbody2.push(row);
+    }
+    node2.children = [table2];
+  }
+}
+const transforms = [transform$1];
+const mappings = {
+  ordered_list: "list",
+  bullet_list: "list",
+  code_inline: "code",
+  list_item: "item",
+  variable: "text"
+};
+function annotate(node2, attributes) {
+  for (const attribute of attributes) {
+    node2.annotations.push(attribute);
+    const { name, value, type } = attribute;
+    if (type === "attribute") {
+      if (node2.attributes[name] !== void 0)
+        node2.errors.push({
+          id: "duplicate-attribute",
+          level: "warning",
+          message: `Attribute '${name}' already set`
+        });
+      node2.attributes[name] = value;
+    }
+  }
+}
+function handleAttrs(token, type) {
+  switch (type) {
+    case "heading":
+      return { level: Number((token.tag || "").replace("h", "")) };
+    case "list": {
+      const attrs = token.attrs ? Object.fromEntries(token.attrs) : void 0;
+      const ordered = token.type.startsWith("ordered");
+      return ordered && attrs?.start ? { ordered: true, start: attrs.start, marker: token.markup || "" } : { ordered, marker: token.markup || "" };
+    }
+    case "link": {
+      const attrs = Object.fromEntries(token.attrs || []);
+      return attrs.title ? { href: attrs.href, title: attrs.title } : { href: attrs.href };
+    }
+    case "image": {
+      const attrs = Object.fromEntries(token.attrs || []);
+      return attrs.title ? { alt: token.content || "", src: attrs.src, title: attrs.title } : { alt: token.content || "", src: attrs.src };
+    }
+    case "em":
+    case "strong":
+      return { marker: token.markup };
+    case "text":
+    case "code":
+    case "comment":
+      return { content: (token.meta || {}).variable || token.content || "" };
+    case "fence": {
+      const [language] = (token.info || "").split(" ", 1);
+      return language === "" || language === OPEN$1 ? { content: token.content || "" } : { content: token.content || "", language };
+    }
+    case "td":
+    case "th": {
+      if (token.attrs) {
+        const attrs = Object.fromEntries(token.attrs);
+        let align;
+        if (attrs.style) {
+          if (attrs.style.includes("left")) {
+            align = "left";
+          } else if (attrs.style.includes("center")) {
+            align = "center";
+          } else if (attrs.style.includes("right")) {
+            align = "right";
+          }
+        }
+        if (align) {
+          return { align };
+        }
+      }
+      return {};
+    }
+    default:
+      return {};
+  }
+}
+function handleToken(token, nodes2, file, handleSlots, addLocation, inlineParent) {
+  if (token.type === "frontmatter") {
+    nodes2[0].attributes.frontmatter = token.content;
+    return;
+  }
+  if (token.hidden || token.type === "text" && (token.content || "") === "") return;
+  const errors = token.errors || [];
+  const parent = nodes2[nodes2.length - 1];
+  const { tag, attributes, error: error2 } = token.meta || {};
+  if (token.type === "annotation") {
+    if (inlineParent) return annotate(inlineParent, attributes);
+    return parent.errors.push({
+      id: "no-inline-annotations",
+      level: "error",
+      message: `Can't apply inline annotations to '${parent.type}'`
+    });
+  }
+  let typeName = token.type.replace(/_(open|close)$/, "");
+  if (mappings[typeName]) typeName = mappings[typeName];
+  if (typeName === "error") {
+    const { message, location } = error2;
+    errors.push({ id: "parse-error", level: "critical", message, location });
+  }
+  if ((token.nesting || 0) < 0) {
+    if (parent.type === typeName && parent.tag === tag) {
+      if (parent.lines && token.map) parent.lines.push(...token.map);
+      return nodes2.pop();
+    }
+    errors.push({
+      id: "missing-opening",
+      level: "critical",
+      message: `Node '${typeName}' is missing opening`
+    });
+  }
+  const attrs = handleAttrs(token, typeName);
+  const node2 = new Node(typeName, attrs, void 0, tag || void 0);
+  const { position = {} } = token;
+  node2.errors = errors;
+  if (addLocation !== false) {
+    node2.lines = token.map || parent.lines || [];
+    node2.location = {
+      file,
+      start: {
+        line: node2.lines[0],
+        character: position.start
+      },
+      end: {
+        line: node2.lines[1],
+        character: position.end
+      }
+    };
+  }
+  if (inlineParent) node2.inline = true;
+  if (attributes && ["tag", "fence", "image"].includes(typeName)) annotate(node2, attributes);
+  if (handleSlots && tag === "slot" && typeof node2.attributes.primary === "string")
+    parent.slots[node2.attributes.primary] = node2;
+  else parent.push(node2);
+  if ((token.nesting || 0) > 0) nodes2.push(node2);
+  if (!Array.isArray(token.children)) return;
+  if (node2.type === "inline") inlineParent = parent;
+  nodes2.push(node2);
+  const isLeafNode = typeName === "image";
+  if (!isLeafNode) {
+    for (const child of token.children)
+      handleToken(child, nodes2, file, handleSlots, addLocation, inlineParent);
+  }
+  nodes2.pop();
+}
+function parser(tokens, args) {
+  const doc = new Node("document");
+  const nodes2 = [doc];
+  if (typeof args === "string") args = { file: args };
+  for (const token of tokens) handleToken(token, nodes2, args?.file, args?.slots, args?.location);
+  if (nodes2.length > 1)
+    for (const node2 of nodes2.slice(1))
+      node2.errors.push({
+        id: "missing-closing",
+        level: "critical",
+        message: `Node '${node2.tag || node2.type}' is missing closing`
+      });
+  for (const transform2 of transforms) transform2(doc);
+  return doc;
+}
+const document = {
+  render: "article",
+  children: [
+    "heading",
+    "paragraph",
+    "image",
+    "table",
+    "tag",
+    "fence",
+    "blockquote",
+    "comment",
+    "list",
+    "hr"
+  ],
+  attributes: {
+    frontmatter: { render: false }
+  }
+};
+const heading = {
+  children: ["inline"],
+  attributes: {
+    level: { type: Number, render: false, required: true }
+  },
+  transform(node2, config) {
+    return new Tag(
+      `h${node2.attributes["level"]}`,
+      node2.transformAttributes(config),
+      node2.transformChildren(config)
+    );
+  }
+};
+const paragraph = {
+  render: "p",
+  children: ["inline"]
+};
+const image = {
+  render: "img",
+  attributes: {
+    src: { type: String, required: true },
+    alt: { type: String },
+    title: { type: String }
+    // width/height attributes will need to be to be implemented as an extension to markdown-it
+  }
+};
+const fence$1 = {
+  render: "pre",
+  attributes: {
+    content: { type: String, render: false, required: true },
+    language: { type: String, render: "data-language" },
+    process: { type: Boolean, render: false, default: true }
+  },
+  transform(node2, config) {
+    const attributes = node2.transformAttributes(config);
+    const children = node2.children.length ? node2.transformChildren(config) : [node2.attributes.content];
+    return new Tag("pre", attributes, children);
+  }
+};
+const blockquote = {
+  render: "blockquote",
+  children: ["heading", "paragraph", "image", "table", "tag", "fence", "blockquote", "list", "hr"]
+};
+const item = {
+  render: "li",
+  children: [
+    "inline",
+    "heading",
+    "paragraph",
+    "image",
+    "table",
+    "tag",
+    "fence",
+    "blockquote",
+    "list",
+    "hr"
+  ]
+};
+const list = {
+  children: ["item"],
+  attributes: {
+    ordered: { type: Boolean, render: false, required: true },
+    start: { type: Number },
+    marker: { type: String, render: false }
+  },
+  transform(node2, config) {
+    return new Tag(
+      node2.attributes.ordered ? "ol" : "ul",
+      node2.transformAttributes(config),
+      node2.transformChildren(config)
+    );
+  }
+};
+const hr = {
+  render: "hr"
+};
+const table$1 = {
+  render: "table"
+};
+const td = {
+  render: "td",
+  children: [
+    "inline",
+    "heading",
+    "paragraph",
+    "image",
+    "table",
+    "tag",
+    "fence",
+    "blockquote",
+    "list",
+    "hr"
+  ],
+  attributes: {
+    align: { type: String },
+    colspan: { type: Number, render: "colSpan" },
+    rowspan: { type: Number, render: "rowSpan" }
+  }
+};
+const th = {
+  render: "th",
+  attributes: {
+    width: { type: String },
+    align: { type: String },
+    colspan: { type: Number, render: "colSpan" },
+    rowspan: { type: Number, render: "rowSpan" }
+  }
+};
+const tr = {
+  render: "tr",
+  children: ["th", "td"]
+};
+const tbody = {
+  render: "tbody",
+  children: ["tr", "tag"]
+};
+const thead = {
+  render: "thead",
+  children: ["tr"]
+};
+const strong = {
+  render: "strong",
+  children: ["em", "s", "link", "code", "text", "tag"],
+  attributes: {
+    marker: { type: String, render: false }
+  }
+};
+const em = {
+  render: "em",
+  children: ["strong", "s", "link", "code", "text", "tag"],
+  attributes: {
+    marker: { type: String, render: false }
+  }
+};
+const s = {
+  render: "s",
+  children: ["strong", "em", "link", "code", "text", "tag"]
+};
+const inline$2 = {
+  children: [
+    "strong",
+    "em",
+    "s",
+    "code",
+    "text",
+    "tag",
+    "link",
+    "image",
+    "hardbreak",
+    "softbreak",
+    "comment"
+  ]
+};
+const link = {
+  render: "a",
+  children: ["strong", "em", "s", "code", "text", "tag"],
+  attributes: {
+    href: { type: String, required: true },
+    title: { type: String }
+  }
+};
+const code = {
+  render: "code",
+  attributes: {
+    content: { type: String, render: false, required: true }
+  },
+  transform(node2, config) {
+    const attributes = node2.transformAttributes(config);
+    return new Tag("code", attributes, [node2.attributes.content]);
+  }
+};
+const text = {
+  attributes: {
+    content: { type: String, required: true }
+  },
+  transform(node2) {
+    return node2.attributes.content;
+  }
+};
+const hardbreak = {
+  render: "br"
+};
+const softbreak = {
+  transform() {
+    return " ";
+  }
+};
+const comment = {
+  attributes: {
+    content: { type: String, required: true }
+  }
+};
+const error = {};
+const node = {};
+const nodes = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  blockquote,
+  code,
+  comment,
+  document,
+  em,
+  error,
+  fence: fence$1,
+  hardbreak,
+  heading,
+  hr,
+  image,
+  inline: inline$2,
+  item,
+  link,
+  list,
+  node,
+  paragraph,
+  s,
+  softbreak,
+  strong,
+  table: table$1,
+  tbody,
+  td,
+  text,
+  th,
+  thead,
+  tr
+}, Symbol.toStringTag, { value: "Module" }));
+const { escapeHtml } = MarkdownIt().utils;
+const voidElements = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+function render(node2) {
+  if (typeof node2 === "string" || typeof node2 === "number") return escapeHtml(String(node2));
+  if (Array.isArray(node2)) return node2.map(render).join("");
+  if (node2 === null || typeof node2 !== "object" || !Tag.isTag(node2)) return "";
+  const { name, attributes, children = [] } = node2;
+  if (!name) return render(children);
+  let output = `<${name}`;
+  for (const [k, v] of Object.entries(attributes ?? {}))
+    output += ` ${k.toLowerCase()}="${escapeHtml(String(v))}"`;
+  output += ">";
+  if (voidElements.has(name)) return output;
+  if (children.length) output += render(children);
+  output += `</${name}>`;
+  return output;
+}
+const renderers = { html: render };
+class PartialFile {
+  validate(file, config) {
+    const { partials = {} } = config;
+    const partial2 = partials[file];
+    if (!partial2)
+      return [
+        {
+          id: "attribute-value-invalid",
+          level: "error",
+          message: `Partial \`${file}\` not found. The 'file' attribute must be set in \`config.partials\``
+        }
+      ];
+    return [];
+  }
+}
+const partial = {
+  inline: false,
+  selfClosing: true,
+  attributes: {
+    file: { type: PartialFile, render: false, required: true },
+    variables: { type: Object, render: false }
+  },
+  transform(node2, config) {
+    const { partials = {} } = config;
+    const { file, variables } = node2.attributes;
+    const partial2 = partials[file];
+    if (!partial2) return null;
+    const scopedConfig = {
+      ...config,
+      variables: {
+        ...config.variables,
+        ...variables,
+        ["$$partial:filename"]: file
+      }
+    };
+    const transformChildren = (part) => part.resolve(scopedConfig).transformChildren(scopedConfig);
+    return Array.isArray(partial2) ? partial2.flatMap(transformChildren) : transformChildren(partial2);
+  }
+};
+const table = {
+  children: ["table"],
+  inline: false
+};
+const slot = {
+  attributes: {
+    primary: { type: String, required: true }
+  }
+};
+const tags = {
+  else: tagElse,
+  if: tagIf,
+  partial,
+  slot,
+  table
+};
+function createToken(state, content, contentStart) {
+  try {
+    const { type, meta, nesting = 0 } = peg$parse(content, { Variable, Function: Function$1 });
+    const token = state.push(type, "", nesting);
+    token.info = content;
+    token.meta = meta;
+    if ("delimiters" in state && !state.delimiters) {
+      state.delimiters = [];
+    }
+    return token;
+  } catch (error2) {
+    if (!(error2 instanceof peg$SyntaxError)) throw error2;
+    const {
+      message,
+      location: { start, end }
+    } = error2;
+    const location = contentStart ? {
+      start: { offset: start.offset + contentStart },
+      end: { offset: end.offset + contentStart }
+    } : null;
+    const token = state.push("error", "", 0);
+    token.meta = { error: { message, location } };
+    return token;
+  }
+}
+function block$2(state, startLine, endLine, silent) {
+  const start = state.bMarks[startLine] + state.tShift[startLine];
+  const finish = state.eMarks[startLine];
+  if (!state.src.startsWith(OPEN$1, start)) return false;
+  const tagEnd = findTagEnd(state.src, start);
+  const lastPossible = state.src.slice(0, finish).trim().length;
+  if (!tagEnd || tagEnd < lastPossible - CLOSE$1.length) return false;
+  const contentStart = start + OPEN$1.length;
+  const content = state.src.slice(contentStart, tagEnd).trim();
+  const lines = state.src.slice(start, tagEnd + CLOSE$1.length).split("\n").length;
+  if (content[0] === "$") return false;
+  if (silent) return true;
+  const token = createToken(state, content, contentStart);
+  token.map = [startLine, startLine + lines];
+  state.line += lines;
+  return true;
+}
+function inline$1(state, silent) {
+  if (!state.src.startsWith(OPEN$1, state.pos)) return false;
+  const tagEnd = findTagEnd(state.src, state.pos);
+  if (!tagEnd) return false;
+  const content = state.src.slice(state.pos + OPEN$1.length, tagEnd);
+  if (!silent) createToken(state, content.trim());
+  state.pos = tagEnd + CLOSE$1.length;
+  return true;
+}
+function core(state) {
+  let token;
+  for (token of state.tokens) {
+    if (token.type !== "fence") continue;
+    const info = token.info || "";
+    if (info.includes(OPEN$1)) {
+      const start = info.indexOf(OPEN$1);
+      const end = findTagEnd(info, start);
+      if (end == null) continue;
+      const content = info.slice(start + OPEN$1.length, end);
+      try {
+        const { meta } = peg$parse(content.trim(), { Variable, Function: Function$1 });
+        token.meta = meta;
+      } catch (error2) {
+        if (!(error2 instanceof peg$SyntaxError)) throw error2;
+        if (!token.errors) token.errors = [];
+        token.errors.push({
+          id: "fence-tag-error",
+          level: "error",
+          message: `Syntax error in fence tag: ${error2.message}`
+        });
+      }
+    }
+    if (token?.meta?.attributes?.find(
+      (attr) => attr.name === "process" && !attr.value
+    ))
+      continue;
+    token.children = parseTags(token.content || "", token.map?.[0] || 0);
+  }
+}
+function plugin$2(md) {
+  md.block.ruler.before("paragraph", "annotations", block$2, {
+    alt: ["paragraph", "blockquote"]
+  });
+  md.inline.ruler.push("containers", inline$1);
+  md.core.ruler.push("annotations", core);
+}
+const fence = "---";
+function getLine(state, n) {
+  return state.src.slice(state.bMarks[n], state.eMarks[n]).trim();
+}
+function findClose(state, endLine) {
+  for (let line = 1; line < endLine; line++) if (getLine(state, line) === fence) return line;
+}
+function block$1(state, startLine, endLine, silent) {
+  if (startLine != 0 || getLine(state, 0) != fence) return false;
+  const close = findClose(state, endLine);
+  if (!close) return false;
+  if (silent) return true;
+  const token = state.push("frontmatter", "", 0);
+  token.content = state.src.slice(state.eMarks[0], state.bMarks[close]).trim();
+  token.map = [0, close];
+  token.hidden = true;
+  state.line = close + 1;
+  return true;
+}
+function plugin$1(md) {
+  md.block.ruler.before("hr", "frontmatter", block$1);
+}
+const OPEN = "<!--";
+const CLOSE = "-->";
+function block(state, startLine, endLine, silent) {
+  const start = state.bMarks[startLine] + state.tShift[startLine];
+  if (!state.src.startsWith(OPEN, start)) return false;
+  const close = state.src.indexOf(CLOSE, start);
+  if (close === -1) return false;
+  if (silent) return true;
+  const content = state.src.slice(start + OPEN.length, close);
+  const lines = content.split("\n").length;
+  const token = state.push("comment", "", 0);
+  token.content = content.trim();
+  token.map = [startLine, startLine + lines];
+  state.line += lines;
+  return true;
+}
+function inline(state, silent) {
+  if (!state.src.startsWith(OPEN, state.pos)) return false;
+  const close = state.src.indexOf(CLOSE, state.pos);
+  if (close === -1) return false;
+  if (silent) return true;
+  const content = state.src.slice(state.pos + OPEN.length, close);
+  const token = state.push("comment", "", 0);
+  token.content = content.trim();
+  state.pos = close + CLOSE.length;
+  return true;
+}
+function plugin(md) {
+  md.block.ruler.before("table", "comment", block, { alt: ["paragraph"] });
+  md.inline.ruler.push("comment", inline);
+}
+class Tokenizer {
+  constructor(config = {}) {
+    this.parser = new MarkdownIt$1(config);
+    this.parser.use(plugin$2, "annotations", {});
+    this.parser.use(plugin$1, "frontmatter", {});
+    this.parser.disable([
+      "lheading",
+      // Disable indented `code_block` support https://spec.commonmark.org/0.30/#indented-code-block
+      "code"
+    ]);
+    if (config.allowComments) this.parser.use(plugin, "comments", {});
+  }
+  tokenize(content) {
+    return this.parser.parse(content.toString(), {});
+  }
+}
+const TypeMappings = {
+  String,
+  Number,
+  Array,
+  Object,
+  Boolean
+};
+function validateType(type, value, config, key) {
+  if (!type) return true;
+  if (Ast.isFunction(value) && config.validation?.validateFunctions) {
+    const schema = config.functions?.[value.name];
+    return !schema?.returns ? true : Array.isArray(schema.returns) ? schema.returns.find((t) => t === type) !== void 0 : schema.returns === type;
+  }
+  if (Ast.isAst(value)) return true;
+  if (Array.isArray(type)) return type.some((t) => validateType(t, value, config, key));
+  if (typeof type === "string") type = TypeMappings[type];
+  if (typeof type === "function") {
+    const instance = new type();
+    if (instance.validate) {
+      return instance.validate(value, config, key);
+    }
+  }
+  return value != null && value.constructor === type;
+}
+function typeToString(type) {
+  if (typeof type === "string") return type;
+  if (Array.isArray(type)) return type.map(typeToString).join(" | ");
+  return type.name;
+}
+function validateFunction(fn, config) {
+  const schema = config.functions?.[fn.name];
+  const errors = [];
+  if (!schema)
+    return [
+      {
+        id: "function-undefined",
+        level: "critical",
+        message: `Undefined function: '${fn.name}'`
+      }
+    ];
+  if (schema.validate) errors.push(...schema.validate(fn, config));
+  if (schema.parameters) {
+    for (const [key, value] of Object.entries(fn.parameters)) {
+      const param = schema.parameters?.[key];
+      if (!param) {
+        errors.push({
+          id: "parameter-undefined",
+          level: "error",
+          message: `Invalid parameter: '${key}'`
+        });
+        continue;
+      }
+      if (Ast.isAst(value) && !Ast.isFunction(value)) continue;
+      if (param.type) {
+        const valid = validateType(param.type, value, config, key);
+        if (valid === false) {
+          errors.push({
+            id: "parameter-type-invalid",
+            level: "error",
+            message: `Parameter '${key}' of '${fn.name}' must be type of '${typeToString(param.type)}'`
+          });
+        } else if (Array.isArray(valid)) {
+          errors.push(...valid);
+        }
+      }
+    }
+  }
+  for (const [key, { required }] of Object.entries(schema.parameters ?? {}))
+    if (required && fn.parameters[key] === void 0)
+      errors.push({
+        id: "parameter-missing-required",
+        level: "error",
+        message: `Missing required parameter: '${key}'`
+      });
+  return errors;
+}
+function displayMatches(matches, n) {
+  if (matches.length <= n) return JSON.stringify(matches);
+  const items = matches.slice(0, n).map((item2) => JSON.stringify(item2));
+  return `[${items.join(",")}, ... ${matches.length - n} more]`;
+}
+function validator(node2, config) {
+  const schema = node2.findSchema(config);
+  const errors = [...node2.errors || []];
+  if (!schema) {
+    errors.push({
+      id: node2.tag ? "tag-undefined" : "node-undefined",
+      level: "critical",
+      message: node2.tag ? `Undefined tag: '${node2.tag}'` : `Undefined node: '${node2.type}'`
+    });
+    return errors;
+  }
+  if (schema.inline != void 0 && node2.inline !== schema.inline)
+    errors.push({
+      id: "tag-placement-invalid",
+      level: "critical",
+      message: `'${node2.tag}' tag should be ${schema.inline ? "inline" : "block"}`
+    });
+  if (schema.selfClosing && node2.children.length > 0)
+    errors.push({
+      id: "tag-selfclosing-has-children",
+      level: "critical",
+      message: `'${node2.tag}' tag should be self-closing`
+    });
+  const attributes = {
+    ...schema.attributes
+  };
+  for (const key of Object.keys(node2.slots)) {
+    const slot2 = schema.slots?.[key];
+    if (!slot2)
+      errors.push({
+        id: "slot-undefined",
+        level: "error",
+        message: `Invalid slot: '${key}'`
+      });
+  }
+  for (let [key, value] of Object.entries(node2.attributes)) {
+    const attrib = attributes[key];
+    if (!attrib) {
+      errors.push({
+        id: "attribute-undefined",
+        level: "error",
+        message: `Invalid attribute: '${key}'`
+      });
+      continue;
+    }
+    let { type, matches, errorLevel } = attrib;
+    if (Ast.isAst(value)) {
+      if (Ast.isFunction(value) && config.validation?.validateFunctions)
+        errors.push(...validateFunction(value, config));
+      else if (Ast.isVariable(value) && config.variables) {
+        let missing = false;
+        let variables = config.variables;
+        for (const key2 of value.path) {
+          if (!Object.prototype.hasOwnProperty.call(variables, key2)) {
+            missing = true;
+            break;
+          }
+          variables = variables[key2];
+        }
+        if (missing) {
+          errors.push({
+            id: "variable-undefined",
+            level: "error",
+            message: `Undefined variable: '${value.path.join(".")}'`
+          });
+        }
+      } else continue;
+    }
+    value = value;
+    if (type) {
+      const valid = validateType(type, value, config, key);
+      if (valid === false) {
+        errors.push({
+          id: "attribute-type-invalid",
+          level: errorLevel || "error",
+          message: `Attribute '${key}' must be type of '${typeToString(type)}'`
+        });
+      }
+      if (Array.isArray(valid)) {
+        errors.push(...valid);
+      }
+    }
+    if (typeof matches === "function") matches = matches(config);
+    if (Array.isArray(matches) && !matches.includes(value))
+      errors.push({
+        id: "attribute-value-invalid",
+        level: errorLevel || "error",
+        message: `Attribute '${key}' must match one of ${displayMatches(
+          matches,
+          8
+        )}. Got '${value}' instead.`
+      });
+    if (matches instanceof RegExp && !matches.test(value))
+      errors.push({
+        id: "attribute-value-invalid",
+        level: errorLevel || "error",
+        message: `Attribute '${key}' must match ${matches}. Got '${value}' instead.`
+      });
+    if (typeof attrib.validate === "function") {
+      const attribErrors = attrib.validate(value, config, key);
+      if (Array.isArray(attribErrors)) errors.push(...attribErrors);
+    }
+  }
+  for (const [key, { required }] of Object.entries(attributes))
+    if (required && node2.attributes[key] === void 0)
+      errors.push({
+        id: "attribute-missing-required",
+        level: "error",
+        message: `Missing required attribute: '${key}'`
+      });
+  if (schema.slots) {
+    for (const [key, { required }] of Object.entries(schema.slots))
+      if (required && node2.slots[key] === void 0)
+        errors.push({
+          id: "slot-missing-required",
+          level: "error",
+          message: `Missing required slot: '${key}'`
+        });
+  }
+  for (const { type } of node2.children) {
+    if (schema.children && type !== "error" && !schema.children.includes(type))
+      errors.push({
+        id: "child-invalid",
+        level: "warning",
+        message: `Can't nest '${type}' in '${node2.tag || node2.type}'`
+      });
+  }
+  if (schema.validate) {
+    const schemaErrors = schema.validate(node2, config);
+    if (isPromise(schemaErrors)) {
+      return schemaErrors.then((e) => errors.concat(e));
+    }
+    errors.push(...schemaErrors);
+  }
+  return errors;
+}
+function* walkWithParents(node2, parents = []) {
+  yield [node2, parents];
+  for (const child of [...Object.values(node2.slots), ...node2.children])
+    yield* walkWithParents(child, [...parents, node2]);
+}
+function validateTree(content, config) {
+  const output = [...walkWithParents(content)].map(([node2, parents]) => {
+    const { type, lines, location } = node2;
+    const updatedConfig = {
+      ...config,
+      validation: { ...config.validation, parents }
+    };
+    const errors = validator(node2, updatedConfig);
+    if (isPromise(errors)) {
+      return errors.then((e) => e.map((error2) => ({ type, lines, location, error: error2 })));
+    }
+    return errors.map((error2) => ({ type, lines, location, error: error2 }));
+  });
+  if (output.some(isPromise)) {
+    return Promise.all(output).then((o) => o.flat());
+  }
+  return output.flat();
+}
+const tokenizer = new Tokenizer();
+function mergeConfig(config = {}) {
+  return {
+    ...config,
+    tags: {
+      ...tags,
+      ...config.tags
+    },
+    nodes: {
+      ...nodes,
+      ...config.nodes
+    },
+    functions: {
+      ...functions,
+      ...config.functions
+    }
+  };
+}
+function parse(content, args) {
+  if (typeof content === "string") content = tokenizer.tokenize(content);
+  return parser(content, args);
+}
+function resolve(content, config) {
+  if (Array.isArray(content)) return content.flatMap((child) => child.resolve(config));
+  return content.resolve(config);
+}
+function transform(nodes2, options) {
+  const config = mergeConfig(options);
+  const content = resolve(nodes2, config);
+  if (Array.isArray(content)) return content.flatMap((child) => child.transform(config));
+  return content.transform(config);
+}
+function validate(content, options) {
+  const config = mergeConfig(options);
+  return validateTree(content, config);
+}
+function createElement(name, attributes = {}, ...children) {
+  return { name, attributes, children };
+}
+const _Markdoc = class _Markdoc {
+  constructor(config) {
+    this.parse = parse;
+    this.resolve = (content) => resolve(content, this.config);
+    this.transform = (content) => transform(content, this.config);
+    this.validate = (content) => validate(content, this.config);
+    this.config = config;
+  }
+};
+_Markdoc.nodes = nodes;
+_Markdoc.tags = tags;
+_Markdoc.functions = functions;
+_Markdoc.renderers = renderers;
+_Markdoc.transforms = transforms;
+_Markdoc.Ast = Ast;
+_Markdoc.Tag = Tag;
+_Markdoc.Tokenizer = Tokenizer;
+_Markdoc.parseTags = parseTags;
+_Markdoc.transformer = transformer;
+_Markdoc.validator = validator;
+_Markdoc.parse = parse;
+_Markdoc.transform = transform;
+_Markdoc.validate = validate;
+_Markdoc.createElement = createElement;
+_Markdoc.truthy = truthy;
+_Markdoc.format = format;
+let Markdoc = _Markdoc;
+export {
+  Ast,
+  Node,
+  Tag,
+  Tokenizer,
+  createElement,
+  Markdoc as default,
+  format,
+  functions,
+  nodes,
+  parse,
+  parseTags,
+  renderers,
+  resolve,
+  tags,
+  transform,
+  transformer,
+  transforms,
+  truthy,
+  validate,
+  validator
+};
+//# sourceMappingURL=index.js.map