@jxsuite/parser 1.8.2 → 2.0.1

package/dist/serialize.js

@@ -923,6 +923,102 @@ var init_guards = __esm(() => {
   ]);
 });
 
+// ../../node_modules/unist-util-is/lib/index.js
+function anyFactory(tests) {
+  const checks = [];
+  let index = -1;
+  while (++index < tests.length) {
+    checks[index] = convert(tests[index]);
+  }
+  return castFactory(any);
+  function any(...parameters) {
+    let index = -1;
+    while (++index < checks.length) {
+      if (checks[index].apply(this, parameters))
+        return true;
+    }
+    return false;
+  }
+}
+function propertiesFactory(check) {
+  const checkAsRecord = check;
+  return castFactory(all);
+  function all(node) {
+    const nodeAsRecord = node;
+    let key;
+    for (key in check) {
+      if (nodeAsRecord[key] !== checkAsRecord[key])
+        return false;
+    }
+    return true;
+  }
+}
+function typeFactory(check) {
+  return castFactory(type);
+  function type(node) {
+    return node && node.type === check;
+  }
+}
+function castFactory(testFunction) {
+  return check;
+  function check(value, index, parent) {
+    return Boolean(looksLikeANode(value) && testFunction.call(this, value, typeof index === "number" ? index : undefined, parent || undefined));
+  }
+}
+function ok2() {
+  return true;
+}
+function looksLikeANode(value) {
+  return value !== null && typeof value === "object" && "type" in value;
+}
+var convert = function(test) {
+  if (test === null || test === undefined) {
+    return ok2;
+  }
+  if (typeof test === "function") {
+    return castFactory(test);
+  }
+  if (typeof test === "object") {
+    return Array.isArray(test) ? anyFactory(test) : propertiesFactory(test);
+  }
+  if (typeof test === "string") {
+    return typeFactory(test);
+  }
+  throw new Error("Expected function, string, or object as test");
+};
+
+// ../../node_modules/unist-util-is/index.js
+var init_unist_util_is = () => {};
+
+// ../../node_modules/mdast-util-phrasing/lib/index.js
+var phrasing;
+var init_lib4 = __esm(() => {
+  init_unist_util_is();
+  phrasing = convert([
+    "break",
+    "delete",
+    "emphasis",
+    "footnote",
+    "footnoteReference",
+    "image",
+    "imageReference",
+    "inlineCode",
+    "inlineMath",
+    "link",
+    "linkReference",
+    "mdxJsxTextElement",
+    "mdxTextExpression",
+    "strong",
+    "text",
+    "textDirective"
+  ]);
+});
+
+// ../../node_modules/mdast-util-phrasing/index.js
+var init_mdast_util_phrasing = __esm(() => {
+  init_lib4();
+});
+
 // ../../node_modules/zwitch/index.js
 function zwitch(key, options) {
   const settings = options || {};
@@ -1035,9 +1131,10 @@ function listInScope(stack, list, none) {
 function hardBreak(_, _1, state, info) {
   let index = -1;
   while (++index < state.unsafe.length) {
-    if (state.unsafe[index].character === `
-` && patternInScope(state.stack, state.unsafe[index])) {
-      return /[ \t]/.test(info.before) ? "" : " ";
+    const pattern = state.unsafe[index];
+    if (pattern.character === `
+` && !pattern.before && !pattern.after && patternInScope(state.stack, pattern)) {
+      return /[\t ]/.test(info.before) ? "" : " ";
     }
   }
   return "\\\n";
@@ -1070,7 +1167,7 @@ function longestStreak(value, substring) {
 
 // ../../node_modules/mdast-util-to-markdown/lib/util/format-code-as-indented.js
 function formatCodeAsIndented(node, state) {
-  return Boolean(state.options.fences === false && node.value && !node.lang && /[^ \r\n]/.test(node.value) && !/^[\t ]*(?:[\r\n]|$)|(?:^|[\r\n])[\t ]*$/.test(node.value));
+  return Boolean(state.options.fences === false && node.value && !node.lang && /[^\n\r ]/.test(node.value) && !/^[\t ]*(?:[\n\r]|$)|(?:^|[\n\r])[\t ]*$/.test(node.value));
 }
 
 // ../../node_modules/mdast-util-to-markdown/lib/util/check-fence.js
@@ -1086,7 +1183,6 @@ function checkFence(state) {
 function code(node, _, state, info) {
   const marker = checkFence(state);
   const raw = node.value || "";
-  const suffix = marker === "`" ? "GraveAccent" : "Tilde";
   if (formatCodeAsIndented(node, state)) {
     const exit = state.enter("codeIndented");
     const value = state.indentLines(raw, map3);
@@ -1096,6 +1192,7 @@ function code(node, _, state, info) {
   const tracker = state.createTracker(info);
   const sequence = marker.repeat(Math.max(longestStreak(raw, marker) + 1, 3));
   const exit = state.enter("codeFenced");
+  const suffix = marker === "`" ? "GraveAccent" : "Tilde";
   let value = tracker.move(sequence);
   if (node.lang) {
     const subexit = state.enter(`codeFencedLang${suffix}`);
@@ -1198,691 +1295,139 @@ function checkEmphasis(state) {
   return marker;
 }
 
+// ../../node_modules/mdast-util-to-markdown/lib/handle/emphasis.js
+function emphasis(node, _, state, info) {
+  const exit = state.enter("phrasing");
+  const value = state.containerPhrasing({ type: "root", children: [node] }, info);
+  exit();
+  return value;
+}
+function attention(_, state) {
+  const marker = checkEmphasis(state);
+  return {
+    construct: "emphasis",
+    markers: marker === "*" ? ["*", "_"] : ["_", "*"],
+    sizes: [1]
+  };
+}
+function peek(_, _1, state) {
+  return state.options.emphasis || "*";
+}
+var init_emphasis = __esm(() => {
+  emphasis.attention = attention;
+  emphasis.peek = peek;
+});
+
 // ../../node_modules/mdast-util-to-markdown/lib/util/encode-character-reference.js
 function encodeCharacterReference(code) {
   return "&#x" + code.toString(16).toUpperCase() + ";";
 }
 
-// ../../node_modules/micromark-util-symbol/lib/codes.js
-var codes;
-var init_codes = __esm(() => {
-  codes = {
-    carriageReturn: -5,
-    lineFeed: -4,
-    carriageReturnLineFeed: -3,
-    horizontalTab: -2,
-    virtualSpace: -1,
-    eof: null,
-    nul: 0,
-    soh: 1,
-    stx: 2,
-    etx: 3,
-    eot: 4,
-    enq: 5,
-    ack: 6,
-    bel: 7,
-    bs: 8,
-    ht: 9,
-    lf: 10,
-    vt: 11,
-    ff: 12,
-    cr: 13,
-    so: 14,
-    si: 15,
-    dle: 16,
-    dc1: 17,
-    dc2: 18,
-    dc3: 19,
-    dc4: 20,
-    nak: 21,
-    syn: 22,
-    etb: 23,
-    can: 24,
-    em: 25,
-    sub: 26,
-    esc: 27,
-    fs: 28,
-    gs: 29,
-    rs: 30,
-    us: 31,
-    space: 32,
-    exclamationMark: 33,
-    quotationMark: 34,
-    numberSign: 35,
-    dollarSign: 36,
-    percentSign: 37,
-    ampersand: 38,
-    apostrophe: 39,
-    leftParenthesis: 40,
-    rightParenthesis: 41,
-    asterisk: 42,
-    plusSign: 43,
-    comma: 44,
-    dash: 45,
-    dot: 46,
-    slash: 47,
-    digit0: 48,
-    digit1: 49,
-    digit2: 50,
-    digit3: 51,
-    digit4: 52,
-    digit5: 53,
-    digit6: 54,
-    digit7: 55,
-    digit8: 56,
-    digit9: 57,
-    colon: 58,
-    semicolon: 59,
-    lessThan: 60,
-    equalsTo: 61,
-    greaterThan: 62,
-    questionMark: 63,
-    atSign: 64,
-    uppercaseA: 65,
-    uppercaseB: 66,
-    uppercaseC: 67,
-    uppercaseD: 68,
-    uppercaseE: 69,
-    uppercaseF: 70,
-    uppercaseG: 71,
-    uppercaseH: 72,
-    uppercaseI: 73,
-    uppercaseJ: 74,
-    uppercaseK: 75,
-    uppercaseL: 76,
-    uppercaseM: 77,
-    uppercaseN: 78,
-    uppercaseO: 79,
-    uppercaseP: 80,
-    uppercaseQ: 81,
-    uppercaseR: 82,
-    uppercaseS: 83,
-    uppercaseT: 84,
-    uppercaseU: 85,
-    uppercaseV: 86,
-    uppercaseW: 87,
-    uppercaseX: 88,
-    uppercaseY: 89,
-    uppercaseZ: 90,
-    leftSquareBracket: 91,
-    backslash: 92,
-    rightSquareBracket: 93,
-    caret: 94,
-    underscore: 95,
-    graveAccent: 96,
-    lowercaseA: 97,
-    lowercaseB: 98,
-    lowercaseC: 99,
-    lowercaseD: 100,
-    lowercaseE: 101,
-    lowercaseF: 102,
-    lowercaseG: 103,
-    lowercaseH: 104,
-    lowercaseI: 105,
-    lowercaseJ: 106,
-    lowercaseK: 107,
-    lowercaseL: 108,
-    lowercaseM: 109,
-    lowercaseN: 110,
-    lowercaseO: 111,
-    lowercaseP: 112,
-    lowercaseQ: 113,
-    lowercaseR: 114,
-    lowercaseS: 115,
-    lowercaseT: 116,
-    lowercaseU: 117,
-    lowercaseV: 118,
-    lowercaseW: 119,
-    lowercaseX: 120,
-    lowercaseY: 121,
-    lowercaseZ: 122,
-    leftCurlyBrace: 123,
-    verticalBar: 124,
-    rightCurlyBrace: 125,
-    tilde: 126,
-    del: 127,
-    byteOrderMarker: 65279,
-    replacementCharacter: 65533
-  };
+// ../../node_modules/unist-util-visit/node_modules/unist-util-visit-parents/lib/color.node.js
+function color(d) {
+  return "\x1B[33m" + d + "\x1B[39m";
+}
+
+// ../../node_modules/unist-util-visit/node_modules/unist-util-visit-parents/lib/index.js
+function visitParents(tree, test, visitor, reverse) {
+  let check;
+  if (typeof test === "function" && typeof visitor !== "function") {
+    reverse = visitor;
+    visitor = test;
+  } else {
+    check = test;
+  }
+  const is = convert(check);
+  const step = reverse ? -1 : 1;
+  factory(tree, undefined, [])();
+  function factory(node, index, parents) {
+    const value = node && typeof node === "object" ? node : {};
+    if (typeof value.type === "string") {
+      const name = typeof value.tagName === "string" ? value.tagName : typeof value.name === "string" ? value.name : undefined;
+      Object.defineProperty(visit, "name", {
+        value: "node (" + color(node.type + (name ? "<" + name + ">" : "")) + ")"
+      });
+    }
+    return visit;
+    function visit() {
+      let result = empty;
+      let subresult;
+      let offset;
+      let grandparents;
+      if (!test || is(node, index, parents[parents.length - 1] || undefined)) {
+        result = toResult(visitor(node, parents));
+        if (result[0] === EXIT) {
+          return result;
+        }
+      }
+      if ("children" in node && node.children) {
+        const nodeAsParent = node;
+        if (nodeAsParent.children && result[0] !== SKIP) {
+          offset = (reverse ? nodeAsParent.children.length : -1) + step;
+          grandparents = parents.concat(nodeAsParent);
+          while (offset > -1 && offset < nodeAsParent.children.length) {
+            const child = nodeAsParent.children[offset];
+            subresult = factory(child, offset, grandparents)();
+            if (subresult[0] === EXIT) {
+              return subresult;
+            }
+            offset = typeof subresult[1] === "number" ? subresult[1] : offset + step;
+          }
+        }
+      }
+      return result;
+    }
+  }
+}
+function toResult(value) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (typeof value === "number") {
+    return [CONTINUE, value];
+  }
+  return value === null || value === undefined ? empty : [value];
+}
+var empty, CONTINUE = true, EXIT = false, SKIP = "skip";
+var init_lib5 = __esm(() => {
+  init_unist_util_is();
+  empty = [];
 });
 
-// ../../node_modules/micromark-util-symbol/lib/constants.js
-var constants;
-var init_constants = __esm(() => {
-  constants = {
-    attentionSideAfter: 2,
-    attentionSideBefore: 1,
-    atxHeadingOpeningFenceSizeMax: 6,
-    autolinkDomainSizeMax: 63,
-    autolinkSchemeSizeMax: 32,
-    cdataOpeningString: "CDATA[",
-    characterGroupPunctuation: 2,
-    characterGroupWhitespace: 1,
-    characterReferenceDecimalSizeMax: 7,
-    characterReferenceHexadecimalSizeMax: 6,
-    characterReferenceNamedSizeMax: 31,
-    codeFencedSequenceSizeMin: 3,
-    contentTypeContent: "content",
-    contentTypeDocument: "document",
-    contentTypeFlow: "flow",
-    contentTypeString: "string",
-    contentTypeText: "text",
-    hardBreakPrefixSizeMin: 2,
-    htmlBasic: 6,
-    htmlCdata: 5,
-    htmlComment: 2,
-    htmlComplete: 7,
-    htmlDeclaration: 4,
-    htmlInstruction: 3,
-    htmlRawSizeMax: 8,
-    htmlRaw: 1,
-    linkResourceDestinationBalanceMax: 32,
-    linkReferenceSizeMax: 999,
-    listItemValueSizeMax: 10,
-    numericBaseDecimal: 10,
-    numericBaseHexadecimal: 16,
-    tabSize: 4,
-    thematicBreakMarkerCountMin: 3,
-    v8MaxSafeChunkSize: 1e4
-  };
+// ../../node_modules/unist-util-visit/node_modules/unist-util-visit-parents/index.js
+var init_unist_util_visit_parents = __esm(() => {
+  init_lib5();
 });
 
-// ../../node_modules/micromark-util-symbol/lib/types.js
-var types;
-var init_types = __esm(() => {
-  types = {
-    data: "data",
-    whitespace: "whitespace",
-    lineEnding: "lineEnding",
-    lineEndingBlank: "lineEndingBlank",
-    linePrefix: "linePrefix",
-    lineSuffix: "lineSuffix",
-    atxHeading: "atxHeading",
-    atxHeadingSequence: "atxHeadingSequence",
-    atxHeadingText: "atxHeadingText",
-    autolink: "autolink",
-    autolinkEmail: "autolinkEmail",
-    autolinkMarker: "autolinkMarker",
-    autolinkProtocol: "autolinkProtocol",
-    characterEscape: "characterEscape",
-    characterEscapeValue: "characterEscapeValue",
-    characterReference: "characterReference",
-    characterReferenceMarker: "characterReferenceMarker",
-    characterReferenceMarkerNumeric: "characterReferenceMarkerNumeric",
-    characterReferenceMarkerHexadecimal: "characterReferenceMarkerHexadecimal",
-    characterReferenceValue: "characterReferenceValue",
-    codeFenced: "codeFenced",
-    codeFencedFence: "codeFencedFence",
-    codeFencedFenceSequence: "codeFencedFenceSequence",
-    codeFencedFenceInfo: "codeFencedFenceInfo",
-    codeFencedFenceMeta: "codeFencedFenceMeta",
-    codeFlowValue: "codeFlowValue",
-    codeIndented: "codeIndented",
-    codeText: "codeText",
-    codeTextData: "codeTextData",
-    codeTextPadding: "codeTextPadding",
-    codeTextSequence: "codeTextSequence",
-    content: "content",
-    definition: "definition",
-    definitionDestination: "definitionDestination",
-    definitionDestinationLiteral: "definitionDestinationLiteral",
-    definitionDestinationLiteralMarker: "definitionDestinationLiteralMarker",
-    definitionDestinationRaw: "definitionDestinationRaw",
-    definitionDestinationString: "definitionDestinationString",
-    definitionLabel: "definitionLabel",
-    definitionLabelMarker: "definitionLabelMarker",
-    definitionLabelString: "definitionLabelString",
-    definitionMarker: "definitionMarker",
-    definitionTitle: "definitionTitle",
-    definitionTitleMarker: "definitionTitleMarker",
-    definitionTitleString: "definitionTitleString",
-    emphasis: "emphasis",
-    emphasisSequence: "emphasisSequence",
-    emphasisText: "emphasisText",
-    escapeMarker: "escapeMarker",
-    hardBreakEscape: "hardBreakEscape",
-    hardBreakTrailing: "hardBreakTrailing",
-    htmlFlow: "htmlFlow",
-    htmlFlowData: "htmlFlowData",
-    htmlText: "htmlText",
-    htmlTextData: "htmlTextData",
-    image: "image",
-    label: "label",
-    labelText: "labelText",
-    labelLink: "labelLink",
-    labelImage: "labelImage",
-    labelMarker: "labelMarker",
-    labelImageMarker: "labelImageMarker",
-    labelEnd: "labelEnd",
-    link: "link",
-    paragraph: "paragraph",
-    reference: "reference",
-    referenceMarker: "referenceMarker",
-    referenceString: "referenceString",
-    resource: "resource",
-    resourceDestination: "resourceDestination",
-    resourceDestinationLiteral: "resourceDestinationLiteral",
-    resourceDestinationLiteralMarker: "resourceDestinationLiteralMarker",
-    resourceDestinationRaw: "resourceDestinationRaw",
-    resourceDestinationString: "resourceDestinationString",
-    resourceMarker: "resourceMarker",
-    resourceTitle: "resourceTitle",
-    resourceTitleMarker: "resourceTitleMarker",
-    resourceTitleString: "resourceTitleString",
-    setextHeading: "setextHeading",
-    setextHeadingText: "setextHeadingText",
-    setextHeadingLine: "setextHeadingLine",
-    setextHeadingLineSequence: "setextHeadingLineSequence",
-    strong: "strong",
-    strongSequence: "strongSequence",
-    strongText: "strongText",
-    thematicBreak: "thematicBreak",
-    thematicBreakSequence: "thematicBreakSequence",
-    blockQuote: "blockQuote",
-    blockQuotePrefix: "blockQuotePrefix",
-    blockQuoteMarker: "blockQuoteMarker",
-    blockQuotePrefixWhitespace: "blockQuotePrefixWhitespace",
-    listOrdered: "listOrdered",
-    listUnordered: "listUnordered",
-    listItemIndent: "listItemIndent",
-    listItemMarker: "listItemMarker",
-    listItemPrefix: "listItemPrefix",
-    listItemPrefixWhitespace: "listItemPrefixWhitespace",
-    listItemValue: "listItemValue",
-    chunkDocument: "chunkDocument",
-    chunkContent: "chunkContent",
-    chunkFlow: "chunkFlow",
-    chunkText: "chunkText",
-    chunkString: "chunkString"
-  };
-});
-
-// ../../node_modules/micromark-util-symbol/lib/values.js
-var values;
-var init_values = __esm(() => {
-  values = {
-    ht: "\t",
-    lf: `
-`,
-    cr: "\r",
-    space: " ",
-    exclamationMark: "!",
-    quotationMark: '"',
-    numberSign: "#",
-    dollarSign: "$",
-    percentSign: "%",
-    ampersand: "&",
-    apostrophe: "'",
-    leftParenthesis: "(",
-    rightParenthesis: ")",
-    asterisk: "*",
-    plusSign: "+",
-    comma: ",",
-    dash: "-",
-    dot: ".",
-    slash: "/",
-    digit0: "0",
-    digit1: "1",
-    digit2: "2",
-    digit3: "3",
-    digit4: "4",
-    digit5: "5",
-    digit6: "6",
-    digit7: "7",
-    digit8: "8",
-    digit9: "9",
-    colon: ":",
-    semicolon: ";",
-    lessThan: "<",
-    equalsTo: "=",
-    greaterThan: ">",
-    questionMark: "?",
-    atSign: "@",
-    uppercaseA: "A",
-    uppercaseB: "B",
-    uppercaseC: "C",
-    uppercaseD: "D",
-    uppercaseE: "E",
-    uppercaseF: "F",
-    uppercaseG: "G",
-    uppercaseH: "H",
-    uppercaseI: "I",
-    uppercaseJ: "J",
-    uppercaseK: "K",
-    uppercaseL: "L",
-    uppercaseM: "M",
-    uppercaseN: "N",
-    uppercaseO: "O",
-    uppercaseP: "P",
-    uppercaseQ: "Q",
-    uppercaseR: "R",
-    uppercaseS: "S",
-    uppercaseT: "T",
-    uppercaseU: "U",
-    uppercaseV: "V",
-    uppercaseW: "W",
-    uppercaseX: "X",
-    uppercaseY: "Y",
-    uppercaseZ: "Z",
-    leftSquareBracket: "[",
-    backslash: "\\",
-    rightSquareBracket: "]",
-    caret: "^",
-    underscore: "_",
-    graveAccent: "`",
-    lowercaseA: "a",
-    lowercaseB: "b",
-    lowercaseC: "c",
-    lowercaseD: "d",
-    lowercaseE: "e",
-    lowercaseF: "f",
-    lowercaseG: "g",
-    lowercaseH: "h",
-    lowercaseI: "i",
-    lowercaseJ: "j",
-    lowercaseK: "k",
-    lowercaseL: "l",
-    lowercaseM: "m",
-    lowercaseN: "n",
-    lowercaseO: "o",
-    lowercaseP: "p",
-    lowercaseQ: "q",
-    lowercaseR: "r",
-    lowercaseS: "s",
-    lowercaseT: "t",
-    lowercaseU: "u",
-    lowercaseV: "v",
-    lowercaseW: "w",
-    lowercaseX: "x",
-    lowercaseY: "y",
-    lowercaseZ: "z",
-    leftCurlyBrace: "{",
-    verticalBar: "|",
-    rightCurlyBrace: "}",
-    tilde: "~",
-    replacementCharacter: "�"
-  };
-});
-
-// ../../node_modules/micromark-util-symbol/lib/default.js
-var init_default = __esm(() => {
-  init_codes();
-  init_constants();
-  init_types();
-  init_values();
-});
-
-// ../../node_modules/micromark-util-character/dev/index.js
-function asciiControl(code) {
-  return code !== null && (code < codes.space || code === codes.del);
-}
-function markdownLineEnding(code) {
-  return code !== null && code < codes.horizontalTab;
-}
-function markdownLineEndingOrSpace(code) {
-  return code !== null && (code < codes.nul || code === codes.space);
-}
-function markdownSpace(code) {
-  return code === codes.horizontalTab || code === codes.virtualSpace || code === codes.space;
-}
-function regexCheck(regex) {
-  return check;
-  function check(code) {
-    return code !== null && code > -1 && regex.test(String.fromCharCode(code));
-  }
-}
-var asciiAlpha, asciiAlphanumeric, asciiAtext, asciiDigit, asciiHexDigit, asciiPunctuation, unicodePunctuation, unicodeWhitespace;
-var init_dev = __esm(() => {
-  init_default();
-  asciiAlpha = regexCheck(/[A-Za-z]/);
-  asciiAlphanumeric = regexCheck(/[\dA-Za-z]/);
-  asciiAtext = regexCheck(/[#-'*+\--9=?A-Z^-~]/);
-  asciiDigit = regexCheck(/\d/);
-  asciiHexDigit = regexCheck(/[\dA-Fa-f]/);
-  asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);
-  unicodePunctuation = regexCheck(/\p{P}|\p{S}/u);
-  unicodeWhitespace = regexCheck(/\s/);
-});
-
-// ../../node_modules/micromark-util-classify-character/dev/index.js
-function classifyCharacter(code) {
-  if (code === codes.eof || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {
-    return constants.characterGroupWhitespace;
-  }
-  if (unicodePunctuation(code)) {
-    return constants.characterGroupPunctuation;
-  }
-}
-var init_dev2 = __esm(() => {
-  init_dev();
-  init_default();
-});
-
-// ../../node_modules/mdast-util-to-markdown/lib/util/encode-info.js
-function encodeInfo(outside, inside, marker) {
-  const outsideKind = classifyCharacter(outside);
-  const insideKind = classifyCharacter(inside);
-  if (outsideKind === undefined) {
-    return insideKind === undefined ? marker === "_" ? { inside: true, outside: true } : { inside: false, outside: false } : insideKind === 1 ? { inside: true, outside: true } : { inside: false, outside: true };
-  }
-  if (outsideKind === 1) {
-    return insideKind === undefined ? { inside: false, outside: false } : insideKind === 1 ? { inside: true, outside: true } : { inside: false, outside: false };
-  }
-  return insideKind === undefined ? { inside: false, outside: false } : insideKind === 1 ? { inside: true, outside: false } : { inside: false, outside: false };
-}
-var init_encode_info = __esm(() => {
-  init_dev2();
-});
-
-// ../../node_modules/mdast-util-to-markdown/lib/handle/emphasis.js
-function emphasis(node, _, state, info) {
-  const marker = checkEmphasis(state);
-  const exit = state.enter("emphasis");
-  const tracker = state.createTracker(info);
-  const before = tracker.move(marker);
-  let between = tracker.move(state.containerPhrasing(node, {
-    after: marker,
-    before,
-    ...tracker.current()
-  }));
-  const betweenHead = between.charCodeAt(0);
-  const open = encodeInfo(info.before.charCodeAt(info.before.length - 1), betweenHead, marker);
-  if (open.inside) {
-    between = encodeCharacterReference(betweenHead) + between.slice(1);
-  }
-  const betweenTail = between.charCodeAt(between.length - 1);
-  const close = encodeInfo(info.after.charCodeAt(0), betweenTail, marker);
-  if (close.inside) {
-    between = between.slice(0, -1) + encodeCharacterReference(betweenTail);
-  }
-  const after = tracker.move(marker);
-  exit();
-  state.attentionEncodeSurroundingInfo = {
-    after: close.outside,
-    before: open.outside
-  };
-  return before + between + after;
-}
-function emphasisPeek(_, _1, state) {
-  return state.options.emphasis || "*";
-}
-var init_emphasis = __esm(() => {
-  init_encode_info();
-  emphasis.peek = emphasisPeek;
-});
-
-// ../../node_modules/unist-util-is/lib/index.js
-function anyFactory(tests) {
-  const checks = [];
-  let index = -1;
-  while (++index < tests.length) {
-    checks[index] = convert(tests[index]);
-  }
-  return castFactory(any);
-  function any(...parameters) {
-    let index = -1;
-    while (++index < checks.length) {
-      if (checks[index].apply(this, parameters))
-        return true;
-    }
-    return false;
-  }
-}
-function propertiesFactory(check) {
-  const checkAsRecord = check;
-  return castFactory(all);
-  function all(node) {
-    const nodeAsRecord = node;
-    let key;
-    for (key in check) {
-      if (nodeAsRecord[key] !== checkAsRecord[key])
-        return false;
-    }
-    return true;
-  }
-}
-function typeFactory(check) {
-  return castFactory(type);
-  function type(node) {
-    return node && node.type === check;
-  }
-}
-function castFactory(testFunction) {
-  return check;
-  function check(value, index, parent) {
-    return Boolean(looksLikeANode(value) && testFunction.call(this, value, typeof index === "number" ? index : undefined, parent || undefined));
-  }
-}
-function ok2() {
-  return true;
-}
-function looksLikeANode(value) {
-  return value !== null && typeof value === "object" && "type" in value;
-}
-var convert = function(test) {
-  if (test === null || test === undefined) {
-    return ok2;
-  }
-  if (typeof test === "function") {
-    return castFactory(test);
-  }
-  if (typeof test === "object") {
-    return Array.isArray(test) ? anyFactory(test) : propertiesFactory(test);
-  }
-  if (typeof test === "string") {
-    return typeFactory(test);
-  }
-  throw new Error("Expected function, string, or object as test");
-};
-
-// ../../node_modules/unist-util-is/index.js
-var init_unist_util_is = () => {};
-
-// ../../node_modules/unist-util-visit/node_modules/unist-util-visit-parents/lib/color.node.js
-function color(d) {
-  return "\x1B[33m" + d + "\x1B[39m";
-}
-
-// ../../node_modules/unist-util-visit/node_modules/unist-util-visit-parents/lib/index.js
-function visitParents(tree, test, visitor, reverse) {
-  let check;
-  if (typeof test === "function" && typeof visitor !== "function") {
-    reverse = visitor;
-    visitor = test;
-  } else {
-    check = test;
-  }
-  const is = convert(check);
-  const step = reverse ? -1 : 1;
-  factory(tree, undefined, [])();
-  function factory(node, index, parents) {
-    const value = node && typeof node === "object" ? node : {};
-    if (typeof value.type === "string") {
-      const name = typeof value.tagName === "string" ? value.tagName : typeof value.name === "string" ? value.name : undefined;
-      Object.defineProperty(visit, "name", {
-        value: "node (" + color(node.type + (name ? "<" + name + ">" : "")) + ")"
-      });
-    }
-    return visit;
-    function visit() {
-      let result = empty;
-      let subresult;
-      let offset;
-      let grandparents;
-      if (!test || is(node, index, parents[parents.length - 1] || undefined)) {
-        result = toResult(visitor(node, parents));
-        if (result[0] === EXIT) {
-          return result;
-        }
-      }
-      if ("children" in node && node.children) {
-        const nodeAsParent = node;
-        if (nodeAsParent.children && result[0] !== SKIP) {
-          offset = (reverse ? nodeAsParent.children.length : -1) + step;
-          grandparents = parents.concat(nodeAsParent);
-          while (offset > -1 && offset < nodeAsParent.children.length) {
-            const child = nodeAsParent.children[offset];
-            subresult = factory(child, offset, grandparents)();
-            if (subresult[0] === EXIT) {
-              return subresult;
-            }
-            offset = typeof subresult[1] === "number" ? subresult[1] : offset + step;
-          }
-        }
-      }
-      return result;
-    }
-  }
-}
-function toResult(value) {
-  if (Array.isArray(value)) {
-    return value;
-  }
-  if (typeof value === "number") {
-    return [CONTINUE, value];
-  }
-  return value === null || value === undefined ? empty : [value];
-}
-var empty, CONTINUE = true, EXIT = false, SKIP = "skip";
-var init_lib4 = __esm(() => {
-  init_unist_util_is();
-  empty = [];
-});
-
-// ../../node_modules/unist-util-visit/node_modules/unist-util-visit-parents/index.js
-var init_unist_util_visit_parents = __esm(() => {
-  init_lib4();
-});
-
-// ../../node_modules/unist-util-visit/lib/index.js
-function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {
-  let reverse;
-  let test;
-  let visitor;
-  if (typeof testOrVisitor === "function" && typeof visitorOrReverse !== "function") {
-    test = undefined;
-    visitor = testOrVisitor;
-    reverse = visitorOrReverse;
-  } else {
-    test = testOrVisitor;
-    visitor = visitorOrReverse;
-    reverse = maybeReverse;
-  }
-  visitParents(tree, test, overload, reverse);
-  function overload(node, parents) {
-    const parent = parents[parents.length - 1];
-    const index = parent ? parent.children.indexOf(node) : undefined;
-    return visitor(node, index, parent);
-  }
-}
-var init_lib5 = __esm(() => {
-  init_unist_util_visit_parents();
-  init_unist_util_visit_parents();
+// ../../node_modules/unist-util-visit/lib/index.js
+function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {
+  let reverse;
+  let test;
+  let visitor;
+  if (typeof testOrVisitor === "function" && typeof visitorOrReverse !== "function") {
+    test = undefined;
+    visitor = testOrVisitor;
+    reverse = visitorOrReverse;
+  } else {
+    test = testOrVisitor;
+    visitor = visitorOrReverse;
+    reverse = maybeReverse;
+  }
+  visitParents(tree, test, overload, reverse);
+  function overload(node, parents) {
+    const parent = parents[parents.length - 1];
+    const index = parent ? parent.children.indexOf(node) : undefined;
+    return visitor(node, index, parent);
+  }
+}
+var init_lib6 = __esm(() => {
+  init_unist_util_visit_parents();
+  init_unist_util_visit_parents();
 });
 
 // ../../node_modules/unist-util-visit/index.js
 var init_unist_util_visit = __esm(() => {
-  init_lib5();
+  init_lib6();
 });
 
 // ../../node_modules/mdast-util-to-string/lib/index.js
@@ -1921,13 +1466,13 @@ function node(value) {
   return Boolean(value && typeof value === "object");
 }
 var emptyOptions;
-var init_lib6 = __esm(() => {
+var init_lib7 = __esm(() => {
   emptyOptions = {};
 });
 
 // ../../node_modules/mdast-util-to-string/index.js
 var init_mdast_util_to_string = __esm(() => {
-  init_lib6();
+  init_lib7();
 });
 
 // ../../node_modules/mdast-util-to-markdown/lib/util/format-heading-as-setext.js
@@ -1976,8 +1521,9 @@ function heading(node, _, state, info) {
 `,
     ...tracker.current()
   });
-  if (/^[\t ]/.test(value)) {
-    value = encodeCharacterReference(value.charCodeAt(0)) + value.slice(1);
+  const head = value.charCodeAt(0);
+  if (head === 9 || head === 32) {
+    value = encodeCharacterReference(head) + value.slice(1);
   }
   value = value ? sequence + " " + value : sequence;
   if (state.options.closeAtx) {
@@ -2064,7 +1610,9 @@ function imageReference(node, _, state, info) {
   value += tracker.move(alt + "][");
   subexit();
   const stack = state.stack;
-  state.stack = [];
+  state.stack = stack.filter(function(d) {
+    return d !== "phrasing";
+  });
   subexit = state.enter("reference");
   const reference = state.safe(state.associationId(node), {
     before: value,
@@ -2098,15 +1646,15 @@ function inlineCode(node, _, state) {
   while (new RegExp("(^|[^`])" + sequence + "([^`]|$)").test(value)) {
     sequence += "`";
   }
-  if (/[^ \r\n]/.test(value) && (/^[ \r\n]/.test(value) && /[ \r\n]$/.test(value) || /^`|`$/.test(value))) {
+  if (/[^\n\r ]/.test(value) && (/^[\n\r ]/.test(value) && /[\n\r ]$/.test(value) || /^`|`$/.test(value))) {
     value = " " + value + " ";
   }
   while (++index < state.unsafe.length) {
     const pattern = state.unsafe[index];
     const expression = state.compilePattern(pattern);
-    let match;
     if (!pattern.atBreak)
       continue;
+    let match;
     while (match = expression.exec(value)) {
       let position = match.index;
       if (value.charCodeAt(position) === 10 && value.charCodeAt(position - 1) === 13) {
@@ -2127,7 +1675,7 @@ var init_inline_code = __esm(() => {
 // ../../node_modules/mdast-util-to-markdown/lib/util/format-link-as-autolink.js
 function formatLinkAsAutolink(node, state) {
   const raw = toString(node);
-  return Boolean(!state.options.resourceLink && node.url && !node.title && node.children && node.children.length === 1 && node.children[0].type === "text" && (raw === node.url || "mailto:" + raw === node.url) && /^[a-z][a-z+.-]+:/i.test(node.url) && !/[\0- <>\u007F]/.test(node.url));
+  return Boolean(!state.options.resourceLink && node.url && !node.title && node.children && node.children.length === 1 && node.children[0].type === "text" && (raw === node.url || "mailto:" + raw === node.url) && /^[a-z][+\-.a-z]+:/i.test(node.url) && !/[\0- <>\u007F]/.test(node.url));
 }
 var init_format_link_as_autolink = __esm(() => {
   init_mdast_util_to_string();
@@ -2138,12 +1686,12 @@ function link(node, _, state, info) {
   const quote = checkQuote(state);
   const suffix = quote === '"' ? "Quote" : "Apostrophe";
   const tracker = state.createTracker(info);
-  let exit;
-  let subexit;
   if (formatLinkAsAutolink(node, state)) {
     const stack = state.stack;
-    state.stack = [];
-    exit = state.enter("autolink");
+    state.stack = stack.filter(function(d) {
+      return d !== "phrasing";
+    });
+    const exit = state.enter("autolink");
     let value = tracker.move("<");
     value += tracker.move(state.containerPhrasing(node, {
       before: value,
@@ -2155,8 +1703,8 @@ function link(node, _, state, info) {
     state.stack = stack;
     return value;
   }
-  exit = state.enter("link");
-  subexit = state.enter("label");
+  const exit = state.enter("link");
+  let subexit = state.enter("label");
   let value = tracker.move("[");
   value += tracker.move(state.containerPhrasing(node, {
     before: value,
@@ -2217,7 +1765,9 @@ function linkReference(node, _, state, info) {
   value += tracker.move(text + "][");
   subexit();
   const stack = state.stack;
-  state.stack = [];
+  state.stack = stack.filter(function(d) {
+    return d !== "phrasing";
+  });
   subexit = state.enter("reference");
   const reference = state.safe(state.associationId(node), {
     before: value,
@@ -2324,201 +1874,716 @@ var init_list = __esm(() => {
   init_check_bullet_other();
 });
 
-// ../../node_modules/mdast-util-to-markdown/lib/util/check-list-item-indent.js
-function checkListItemIndent(state) {
-  const style = state.options.listItemIndent || "one";
-  if (style !== "tab" && style !== "one" && style !== "mixed") {
-    throw new Error("Cannot serialize items with `" + style + "` for `options.listItemIndent`, expected `tab`, `one`, or `mixed`");
-  }
-  return style;
-}
+// ../../node_modules/mdast-util-to-markdown/lib/util/check-list-item-indent.js
+function checkListItemIndent(state) {
+  const style = state.options.listItemIndent || "one";
+  if (style !== "tab" && style !== "one" && style !== "mixed") {
+    throw new Error("Cannot serialize items with `" + style + "` for `options.listItemIndent`, expected `tab`, `one`, or `mixed`");
+  }
+  return style;
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/handle/list-item.js
+function listItem(node, parent, state, info) {
+  const listItemIndent = checkListItemIndent(state);
+  let bullet = state.bulletCurrent || checkBullet(state);
+  if (parent && parent.type === "list" && parent.ordered) {
+    bullet = (typeof parent.start === "number" && parent.start > -1 ? parent.start : 1) + (state.options.incrementListMarker === false ? 0 : parent.children.indexOf(node)) + bullet;
+  }
+  let size = bullet.length + 1;
+  if (listItemIndent === "tab" || listItemIndent === "mixed" && (parent && parent.type === "list" && parent.spread || node.spread)) {
+    size = Math.ceil(size / 4) * 4;
+  }
+  const tracker = state.createTracker(info);
+  tracker.move(bullet + " ".repeat(size - bullet.length));
+  tracker.shift(size);
+  const exit = state.enter("listItem");
+  const value = state.indentLines(state.containerFlow(node, tracker.current()), map);
+  exit();
+  return value;
+  function map(line, index, blank) {
+    if (index) {
+      return (blank ? "" : " ".repeat(size)) + line;
+    }
+    return (blank ? bullet : bullet + " ".repeat(size - bullet.length)) + line;
+  }
+}
+var init_list_item = () => {};
+
+// ../../node_modules/mdast-util-to-markdown/lib/handle/paragraph.js
+function paragraph(node, _, state, info) {
+  const exit = state.enter("paragraph");
+  const subexit = state.enter("phrasing");
+  const value = state.containerPhrasing(node, info);
+  subexit();
+  exit();
+  return value;
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/handle/root.js
+function root(node, _, state, info) {
+  const hasPhrasing = node.children.some(function(d) {
+    return phrasing(d);
+  });
+  if (!hasPhrasing)
+    return state.containerFlow(node, info);
+  const exit = state.enter("phrasing");
+  const value = state.containerPhrasing(node, info);
+  exit();
+  return value;
+}
+var init_root = __esm(() => {
+  init_mdast_util_phrasing();
+});
+
+// ../../node_modules/mdast-util-to-markdown/lib/util/check-strong.js
+function checkStrong(state) {
+  const marker = state.options.strong || "*";
+  if (marker !== "*" && marker !== "_") {
+    throw new Error("Cannot serialize strong with `" + marker + "` for `options.strong`, expected `*`, or `_`");
+  }
+  return marker;
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/handle/strong.js
+function strong(node, _, state, info) {
+  const exit = state.enter("phrasing");
+  const value = state.containerPhrasing({ type: "root", children: [node] }, info);
+  exit();
+  return value;
+}
+function attention2(_, state) {
+  const marker = checkStrong(state);
+  return {
+    construct: "strong",
+    markers: marker === "*" ? ["*", "_"] : ["_", "*"],
+    sizes: [2]
+  };
+}
+function peek2(_, _1, state) {
+  return state.options.strong || "*";
+}
+var init_strong = __esm(() => {
+  strong.attention = attention2;
+  strong.peek = peek2;
+});
+
+// ../../node_modules/mdast-util-to-markdown/lib/handle/text.js
+function text(node, parent, state, info) {
+  const siblings = parent ? parent.children : [];
+  const index = siblings.indexOf(node);
+  return state.safe(node.value, {
+    ...info,
+    afterNode: siblings[index + 1],
+    beforeNode: siblings[index - 1]
+  });
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/util/check-rule-repetition.js
+function checkRuleRepetition(state) {
+  const repetition = state.options.ruleRepetition || 3;
+  if (repetition < 3) {
+    throw new Error("Cannot serialize rules with repetition `" + repetition + "` for `options.ruleRepetition`, expected `3` or more");
+  }
+  return repetition;
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/handle/thematic-break.js
+function thematicBreak(_, _1, state) {
+  const value = (checkRule(state) + (state.options.ruleSpaces ? " " : "")).repeat(checkRuleRepetition(state));
+  return state.options.ruleSpaces ? value.slice(0, -1) : value;
+}
+var init_thematic_break = () => {};
+
+// ../../node_modules/mdast-util-to-markdown/lib/handle/index.js
+var handle;
+var init_handle = __esm(() => {
+  init_break();
+  init_code();
+  init_definition();
+  init_emphasis();
+  init_heading();
+  init_html();
+  init_image();
+  init_image_reference();
+  init_inline_code();
+  init_link();
+  init_link_reference();
+  init_list();
+  init_list_item();
+  init_root();
+  init_strong();
+  init_thematic_break();
+  handle = {
+    blockquote,
+    break: hardBreak,
+    code,
+    definition,
+    emphasis,
+    hardBreak,
+    heading,
+    html,
+    image,
+    imageReference,
+    inlineCode,
+    link,
+    linkReference,
+    list: list2,
+    listItem,
+    paragraph,
+    root,
+    strong,
+    text,
+    thematicBreak
+  };
+});
+
+// ../../node_modules/micromark-util-symbol/lib/codes.js
+var codes;
+var init_codes = __esm(() => {
+  codes = {
+    carriageReturn: -5,
+    lineFeed: -4,
+    carriageReturnLineFeed: -3,
+    horizontalTab: -2,
+    virtualSpace: -1,
+    eof: null,
+    nul: 0,
+    soh: 1,
+    stx: 2,
+    etx: 3,
+    eot: 4,
+    enq: 5,
+    ack: 6,
+    bel: 7,
+    bs: 8,
+    ht: 9,
+    lf: 10,
+    vt: 11,
+    ff: 12,
+    cr: 13,
+    so: 14,
+    si: 15,
+    dle: 16,
+    dc1: 17,
+    dc2: 18,
+    dc3: 19,
+    dc4: 20,
+    nak: 21,
+    syn: 22,
+    etb: 23,
+    can: 24,
+    em: 25,
+    sub: 26,
+    esc: 27,
+    fs: 28,
+    gs: 29,
+    rs: 30,
+    us: 31,
+    space: 32,
+    exclamationMark: 33,
+    quotationMark: 34,
+    numberSign: 35,
+    dollarSign: 36,
+    percentSign: 37,
+    ampersand: 38,
+    apostrophe: 39,
+    leftParenthesis: 40,
+    rightParenthesis: 41,
+    asterisk: 42,
+    plusSign: 43,
+    comma: 44,
+    dash: 45,
+    dot: 46,
+    slash: 47,
+    digit0: 48,
+    digit1: 49,
+    digit2: 50,
+    digit3: 51,
+    digit4: 52,
+    digit5: 53,
+    digit6: 54,
+    digit7: 55,
+    digit8: 56,
+    digit9: 57,
+    colon: 58,
+    semicolon: 59,
+    lessThan: 60,
+    equalsTo: 61,
+    greaterThan: 62,
+    questionMark: 63,
+    atSign: 64,
+    uppercaseA: 65,
+    uppercaseB: 66,
+    uppercaseC: 67,
+    uppercaseD: 68,
+    uppercaseE: 69,
+    uppercaseF: 70,
+    uppercaseG: 71,
+    uppercaseH: 72,
+    uppercaseI: 73,
+    uppercaseJ: 74,
+    uppercaseK: 75,
+    uppercaseL: 76,
+    uppercaseM: 77,
+    uppercaseN: 78,
+    uppercaseO: 79,
+    uppercaseP: 80,
+    uppercaseQ: 81,
+    uppercaseR: 82,
+    uppercaseS: 83,
+    uppercaseT: 84,
+    uppercaseU: 85,
+    uppercaseV: 86,
+    uppercaseW: 87,
+    uppercaseX: 88,
+    uppercaseY: 89,
+    uppercaseZ: 90,
+    leftSquareBracket: 91,
+    backslash: 92,
+    rightSquareBracket: 93,
+    caret: 94,
+    underscore: 95,
+    graveAccent: 96,
+    lowercaseA: 97,
+    lowercaseB: 98,
+    lowercaseC: 99,
+    lowercaseD: 100,
+    lowercaseE: 101,
+    lowercaseF: 102,
+    lowercaseG: 103,
+    lowercaseH: 104,
+    lowercaseI: 105,
+    lowercaseJ: 106,
+    lowercaseK: 107,
+    lowercaseL: 108,
+    lowercaseM: 109,
+    lowercaseN: 110,
+    lowercaseO: 111,
+    lowercaseP: 112,
+    lowercaseQ: 113,
+    lowercaseR: 114,
+    lowercaseS: 115,
+    lowercaseT: 116,
+    lowercaseU: 117,
+    lowercaseV: 118,
+    lowercaseW: 119,
+    lowercaseX: 120,
+    lowercaseY: 121,
+    lowercaseZ: 122,
+    leftCurlyBrace: 123,
+    verticalBar: 124,
+    rightCurlyBrace: 125,
+    tilde: 126,
+    del: 127,
+    byteOrderMarker: 65279,
+    replacementCharacter: 65533
+  };
+});
+
+// ../../node_modules/micromark-util-symbol/lib/constants.js
+var constants;
+var init_constants = __esm(() => {
+  constants = {
+    attentionSideAfter: 2,
+    attentionSideBefore: 1,
+    atxHeadingOpeningFenceSizeMax: 6,
+    autolinkDomainSizeMax: 63,
+    autolinkSchemeSizeMax: 32,
+    cdataOpeningString: "CDATA[",
+    characterGroupPunctuation: 2,
+    characterGroupWhitespace: 1,
+    characterReferenceDecimalSizeMax: 7,
+    characterReferenceHexadecimalSizeMax: 6,
+    characterReferenceNamedSizeMax: 31,
+    codeFencedSequenceSizeMin: 3,
+    contentTypeContent: "content",
+    contentTypeDocument: "document",
+    contentTypeFlow: "flow",
+    contentTypeString: "string",
+    contentTypeText: "text",
+    hardBreakPrefixSizeMin: 2,
+    htmlBasic: 6,
+    htmlCdata: 5,
+    htmlComment: 2,
+    htmlComplete: 7,
+    htmlDeclaration: 4,
+    htmlInstruction: 3,
+    htmlRawSizeMax: 8,
+    htmlRaw: 1,
+    linkResourceDestinationBalanceMax: 32,
+    linkReferenceSizeMax: 999,
+    listItemValueSizeMax: 10,
+    numericBaseDecimal: 10,
+    numericBaseHexadecimal: 16,
+    tabSize: 4,
+    thematicBreakMarkerCountMin: 3,
+    v8MaxSafeChunkSize: 1e4
+  };
+});
+
+// ../../node_modules/micromark-util-symbol/lib/types.js
+var types;
+var init_types = __esm(() => {
+  types = {
+    data: "data",
+    whitespace: "whitespace",
+    lineEnding: "lineEnding",
+    lineEndingBlank: "lineEndingBlank",
+    linePrefix: "linePrefix",
+    lineSuffix: "lineSuffix",
+    atxHeading: "atxHeading",
+    atxHeadingSequence: "atxHeadingSequence",
+    atxHeadingText: "atxHeadingText",
+    autolink: "autolink",
+    autolinkEmail: "autolinkEmail",
+    autolinkMarker: "autolinkMarker",
+    autolinkProtocol: "autolinkProtocol",
+    characterEscape: "characterEscape",
+    characterEscapeValue: "characterEscapeValue",
+    characterReference: "characterReference",
+    characterReferenceMarker: "characterReferenceMarker",
+    characterReferenceMarkerNumeric: "characterReferenceMarkerNumeric",
+    characterReferenceMarkerHexadecimal: "characterReferenceMarkerHexadecimal",
+    characterReferenceValue: "characterReferenceValue",
+    codeFenced: "codeFenced",
+    codeFencedFence: "codeFencedFence",
+    codeFencedFenceSequence: "codeFencedFenceSequence",
+    codeFencedFenceInfo: "codeFencedFenceInfo",
+    codeFencedFenceMeta: "codeFencedFenceMeta",
+    codeFlowValue: "codeFlowValue",
+    codeIndented: "codeIndented",
+    codeText: "codeText",
+    codeTextData: "codeTextData",
+    codeTextPadding: "codeTextPadding",
+    codeTextSequence: "codeTextSequence",
+    content: "content",
+    definition: "definition",
+    definitionDestination: "definitionDestination",
+    definitionDestinationLiteral: "definitionDestinationLiteral",
+    definitionDestinationLiteralMarker: "definitionDestinationLiteralMarker",
+    definitionDestinationRaw: "definitionDestinationRaw",
+    definitionDestinationString: "definitionDestinationString",
+    definitionLabel: "definitionLabel",
+    definitionLabelMarker: "definitionLabelMarker",
+    definitionLabelString: "definitionLabelString",
+    definitionMarker: "definitionMarker",
+    definitionTitle: "definitionTitle",
+    definitionTitleMarker: "definitionTitleMarker",
+    definitionTitleString: "definitionTitleString",
+    emphasis: "emphasis",
+    emphasisSequence: "emphasisSequence",
+    emphasisText: "emphasisText",
+    escapeMarker: "escapeMarker",
+    hardBreakEscape: "hardBreakEscape",
+    hardBreakTrailing: "hardBreakTrailing",
+    htmlFlow: "htmlFlow",
+    htmlFlowData: "htmlFlowData",
+    htmlText: "htmlText",
+    htmlTextData: "htmlTextData",
+    image: "image",
+    label: "label",
+    labelText: "labelText",
+    labelLink: "labelLink",
+    labelImage: "labelImage",
+    labelMarker: "labelMarker",
+    labelImageMarker: "labelImageMarker",
+    labelEnd: "labelEnd",
+    link: "link",
+    paragraph: "paragraph",
+    reference: "reference",
+    referenceMarker: "referenceMarker",
+    referenceString: "referenceString",
+    resource: "resource",
+    resourceDestination: "resourceDestination",
+    resourceDestinationLiteral: "resourceDestinationLiteral",
+    resourceDestinationLiteralMarker: "resourceDestinationLiteralMarker",
+    resourceDestinationRaw: "resourceDestinationRaw",
+    resourceDestinationString: "resourceDestinationString",
+    resourceMarker: "resourceMarker",
+    resourceTitle: "resourceTitle",
+    resourceTitleMarker: "resourceTitleMarker",
+    resourceTitleString: "resourceTitleString",
+    setextHeading: "setextHeading",
+    setextHeadingText: "setextHeadingText",
+    setextHeadingLine: "setextHeadingLine",
+    setextHeadingLineSequence: "setextHeadingLineSequence",
+    strong: "strong",
+    strongSequence: "strongSequence",
+    strongText: "strongText",
+    thematicBreak: "thematicBreak",
+    thematicBreakSequence: "thematicBreakSequence",
+    blockQuote: "blockQuote",
+    blockQuotePrefix: "blockQuotePrefix",
+    blockQuoteMarker: "blockQuoteMarker",
+    blockQuotePrefixWhitespace: "blockQuotePrefixWhitespace",
+    listOrdered: "listOrdered",
+    listUnordered: "listUnordered",
+    listItemIndent: "listItemIndent",
+    listItemMarker: "listItemMarker",
+    listItemPrefix: "listItemPrefix",
+    listItemPrefixWhitespace: "listItemPrefixWhitespace",
+    listItemValue: "listItemValue",
+    chunkDocument: "chunkDocument",
+    chunkContent: "chunkContent",
+    chunkFlow: "chunkFlow",
+    chunkText: "chunkText",
+    chunkString: "chunkString"
+  };
+});
+
+// ../../node_modules/micromark-util-symbol/lib/values.js
+var values;
+var init_values = __esm(() => {
+  values = {
+    ht: "\t",
+    lf: `
+`,
+    cr: "\r",
+    space: " ",
+    exclamationMark: "!",
+    quotationMark: '"',
+    numberSign: "#",
+    dollarSign: "$",
+    percentSign: "%",
+    ampersand: "&",
+    apostrophe: "'",
+    leftParenthesis: "(",
+    rightParenthesis: ")",
+    asterisk: "*",
+    plusSign: "+",
+    comma: ",",
+    dash: "-",
+    dot: ".",
+    slash: "/",
+    digit0: "0",
+    digit1: "1",
+    digit2: "2",
+    digit3: "3",
+    digit4: "4",
+    digit5: "5",
+    digit6: "6",
+    digit7: "7",
+    digit8: "8",
+    digit9: "9",
+    colon: ":",
+    semicolon: ";",
+    lessThan: "<",
+    equalsTo: "=",
+    greaterThan: ">",
+    questionMark: "?",
+    atSign: "@",
+    uppercaseA: "A",
+    uppercaseB: "B",
+    uppercaseC: "C",
+    uppercaseD: "D",
+    uppercaseE: "E",
+    uppercaseF: "F",
+    uppercaseG: "G",
+    uppercaseH: "H",
+    uppercaseI: "I",
+    uppercaseJ: "J",
+    uppercaseK: "K",
+    uppercaseL: "L",
+    uppercaseM: "M",
+    uppercaseN: "N",
+    uppercaseO: "O",
+    uppercaseP: "P",
+    uppercaseQ: "Q",
+    uppercaseR: "R",
+    uppercaseS: "S",
+    uppercaseT: "T",
+    uppercaseU: "U",
+    uppercaseV: "V",
+    uppercaseW: "W",
+    uppercaseX: "X",
+    uppercaseY: "Y",
+    uppercaseZ: "Z",
+    leftSquareBracket: "[",
+    backslash: "\\",
+    rightSquareBracket: "]",
+    caret: "^",
+    underscore: "_",
+    graveAccent: "`",
+    lowercaseA: "a",
+    lowercaseB: "b",
+    lowercaseC: "c",
+    lowercaseD: "d",
+    lowercaseE: "e",
+    lowercaseF: "f",
+    lowercaseG: "g",
+    lowercaseH: "h",
+    lowercaseI: "i",
+    lowercaseJ: "j",
+    lowercaseK: "k",
+    lowercaseL: "l",
+    lowercaseM: "m",
+    lowercaseN: "n",
+    lowercaseO: "o",
+    lowercaseP: "p",
+    lowercaseQ: "q",
+    lowercaseR: "r",
+    lowercaseS: "s",
+    lowercaseT: "t",
+    lowercaseU: "u",
+    lowercaseV: "v",
+    lowercaseW: "w",
+    lowercaseX: "x",
+    lowercaseY: "y",
+    lowercaseZ: "z",
+    leftCurlyBrace: "{",
+    verticalBar: "|",
+    rightCurlyBrace: "}",
+    tilde: "~",
+    replacementCharacter: "�"
+  };
+});
+
+// ../../node_modules/micromark-util-symbol/lib/default.js
+var init_default = __esm(() => {
+  init_codes();
+  init_constants();
+  init_types();
+  init_values();
+});
 
-// ../../node_modules/mdast-util-to-markdown/lib/handle/list-item.js
-function listItem(node, parent, state, info) {
-  const listItemIndent = checkListItemIndent(state);
-  let bullet = state.bulletCurrent || checkBullet(state);
-  if (parent && parent.type === "list" && parent.ordered) {
-    bullet = (typeof parent.start === "number" && parent.start > -1 ? parent.start : 1) + (state.options.incrementListMarker === false ? 0 : parent.children.indexOf(node)) + bullet;
-  }
-  let size = bullet.length + 1;
-  if (listItemIndent === "tab" || listItemIndent === "mixed" && (parent && parent.type === "list" && parent.spread || node.spread)) {
-    size = Math.ceil(size / 4) * 4;
-  }
-  const tracker = state.createTracker(info);
-  tracker.move(bullet + " ".repeat(size - bullet.length));
-  tracker.shift(size);
-  const exit = state.enter("listItem");
-  const value = state.indentLines(state.containerFlow(node, tracker.current()), map);
-  exit();
-  return value;
-  function map(line, index, blank) {
-    if (index) {
-      return (blank ? "" : " ".repeat(size)) + line;
-    }
-    return (blank ? bullet : bullet + " ".repeat(size - bullet.length)) + line;
-  }
+// ../../node_modules/micromark-util-character/dev/index.js
+function asciiControl(code) {
+  return code !== null && (code < codes.space || code === codes.del);
 }
-var init_list_item = () => {};
-
-// ../../node_modules/mdast-util-to-markdown/lib/handle/paragraph.js
-function paragraph(node, _, state, info) {
-  const exit = state.enter("paragraph");
-  const subexit = state.enter("phrasing");
-  const value = state.containerPhrasing(node, info);
-  subexit();
-  exit();
-  return value;
+function markdownLineEnding(code) {
+  return code !== null && code < codes.horizontalTab;
 }
-
-// ../../node_modules/mdast-util-phrasing/lib/index.js
-var phrasing;
-var init_lib7 = __esm(() => {
-  init_unist_util_is();
-  phrasing = convert([
-    "break",
-    "delete",
-    "emphasis",
-    "footnote",
-    "footnoteReference",
-    "image",
-    "imageReference",
-    "inlineCode",
-    "inlineMath",
-    "link",
-    "linkReference",
-    "mdxJsxTextElement",
-    "mdxTextExpression",
-    "strong",
-    "text",
-    "textDirective"
-  ]);
-});
-
-// ../../node_modules/mdast-util-phrasing/index.js
-var init_mdast_util_phrasing = __esm(() => {
-  init_lib7();
-});
-
-// ../../node_modules/mdast-util-to-markdown/lib/handle/root.js
-function root(node, _, state, info) {
-  const hasPhrasing = node.children.some(function(d) {
-    return phrasing(d);
-  });
-  const container = hasPhrasing ? state.containerPhrasing : state.containerFlow;
-  return container.call(state, node, info);
+function markdownLineEndingOrSpace(code) {
+  return code !== null && (code < codes.nul || code === codes.space);
 }
-var init_root = __esm(() => {
-  init_mdast_util_phrasing();
-});
-
-// ../../node_modules/mdast-util-to-markdown/lib/util/check-strong.js
-function checkStrong(state) {
-  const marker = state.options.strong || "*";
-  if (marker !== "*" && marker !== "_") {
-    throw new Error("Cannot serialize strong with `" + marker + "` for `options.strong`, expected `*`, or `_`");
-  }
-  return marker;
+function markdownSpace(code) {
+  return code === codes.horizontalTab || code === codes.virtualSpace || code === codes.space;
 }
-
-// ../../node_modules/mdast-util-to-markdown/lib/handle/strong.js
-function strong(node, _, state, info) {
-  const marker = checkStrong(state);
-  const exit = state.enter("strong");
-  const tracker = state.createTracker(info);
-  const before = tracker.move(marker + marker);
-  let between = tracker.move(state.containerPhrasing(node, {
-    after: marker,
-    before,
-    ...tracker.current()
-  }));
-  const betweenHead = between.charCodeAt(0);
-  const open = encodeInfo(info.before.charCodeAt(info.before.length - 1), betweenHead, marker);
-  if (open.inside) {
-    between = encodeCharacterReference(betweenHead) + between.slice(1);
-  }
-  const betweenTail = between.charCodeAt(between.length - 1);
-  const close = encodeInfo(info.after.charCodeAt(0), betweenTail, marker);
-  if (close.inside) {
-    between = between.slice(0, -1) + encodeCharacterReference(betweenTail);
+function regexCheck(regex) {
+  return check;
+  function check(code) {
+    return code !== null && code > -1 && regex.test(String.fromCharCode(code));
   }
-  const after = tracker.move(marker + marker);
-  exit();
-  state.attentionEncodeSurroundingInfo = {
-    after: close.outside,
-    before: open.outside
-  };
-  return before + between + after;
-}
-function strongPeek(_, _1, state) {
-  return state.options.strong || "*";
 }
-var init_strong = __esm(() => {
-  init_encode_info();
-  strong.peek = strongPeek;
+var asciiAlpha, asciiAlphanumeric, asciiAtext, asciiDigit, asciiHexDigit, asciiPunctuation, unicodePunctuation, unicodeWhitespace;
+var init_dev = __esm(() => {
+  init_default();
+  asciiAlpha = regexCheck(/[A-Za-z]/);
+  asciiAlphanumeric = regexCheck(/[\dA-Za-z]/);
+  asciiAtext = regexCheck(/[#-'*+\--9=?A-Z^-~]/);
+  asciiDigit = regexCheck(/\d/);
+  asciiHexDigit = regexCheck(/[\dA-Fa-f]/);
+  asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);
+  unicodePunctuation = regexCheck(/\p{P}|\p{S}/u);
+  unicodeWhitespace = regexCheck(/\s/);
 });
 
-// ../../node_modules/mdast-util-to-markdown/lib/handle/text.js
-function text(node, _, state, info) {
-  return state.safe(node.value, info);
-}
+// ../../node_modules/micromark-util-html-tag-name/index.js
+var htmlBlockNames, htmlRawNames;
+var init_micromark_util_html_tag_name = __esm(() => {
+  htmlBlockNames = [
+    "address",
+    "article",
+    "aside",
+    "base",
+    "basefont",
+    "blockquote",
+    "body",
+    "caption",
+    "center",
+    "col",
+    "colgroup",
+    "dd",
+    "details",
+    "dialog",
+    "dir",
+    "div",
+    "dl",
+    "dt",
+    "fieldset",
+    "figcaption",
+    "figure",
+    "footer",
+    "form",
+    "frame",
+    "frameset",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "head",
+    "header",
+    "hr",
+    "html",
+    "iframe",
+    "legend",
+    "li",
+    "link",
+    "main",
+    "menu",
+    "menuitem",
+    "nav",
+    "noframes",
+    "ol",
+    "optgroup",
+    "option",
+    "p",
+    "param",
+    "search",
+    "section",
+    "summary",
+    "table",
+    "tbody",
+    "td",
+    "tfoot",
+    "th",
+    "thead",
+    "title",
+    "tr",
+    "track",
+    "ul"
+  ];
+  htmlRawNames = ["pre", "script", "style", "textarea"];
+});
 
-// ../../node_modules/mdast-util-to-markdown/lib/util/check-rule-repetition.js
-function checkRuleRepetition(state) {
-  const repetition = state.options.ruleRepetition || 3;
-  if (repetition < 3) {
-    throw new Error("Cannot serialize rules with repetition `" + repetition + "` for `options.ruleRepetition`, expected `3` or more");
+// ../../node_modules/mdast-util-to-markdown/lib/util/html-kind.js
+function htmlKind(value) {
+  if (value.charCodeAt(0) !== 60)
+    return;
+  const next = value.charCodeAt(1);
+  if (next === 33) {
+    const code = value.charCodeAt(2);
+    if (code === 45)
+      return 2;
+    if (code === 91)
+      return 5;
+    if (asciiAlpha(code))
+      return 4;
+    return;
   }
-  return repetition;
-}
-
-// ../../node_modules/mdast-util-to-markdown/lib/handle/thematic-break.js
-function thematicBreak(_, _1, state) {
-  const value = (checkRule(state) + (state.options.ruleSpaces ? " " : "")).repeat(checkRuleRepetition(state));
-  return state.options.ruleSpaces ? value.slice(0, -1) : value;
+  if (next === 63)
+    return 3;
+  const closing = next === 47;
+  const start = closing ? 2 : 1;
+  let end = start;
+  let code = value.charCodeAt(end);
+  if (!asciiAlpha(code))
+    return;
+  while (code === 45 || asciiAlphanumeric(code)) {
+    code = value.charCodeAt(++end);
+  }
+  const name = value.slice(start, end).toLowerCase();
+  if (!closing && code !== 47 && htmlRawNames.includes(name)) {
+    return 1;
+  }
+  return htmlBlockNames.includes(name) ? 6 : 7;
 }
-var init_thematic_break = () => {};
-
-// ../../node_modules/mdast-util-to-markdown/lib/handle/index.js
-var handle;
-var init_handle = __esm(() => {
-  init_break();
-  init_code();
-  init_definition();
-  init_emphasis();
-  init_heading();
-  init_html();
-  init_image();
-  init_image_reference();
-  init_inline_code();
-  init_link();
-  init_link_reference();
-  init_list();
-  init_list_item();
-  init_root();
-  init_strong();
-  init_thematic_break();
-  handle = {
-    blockquote,
-    break: hardBreak,
-    code,
-    definition,
-    emphasis,
-    hardBreak,
-    heading,
-    html,
-    image,
-    imageReference,
-    inlineCode,
-    link,
-    linkReference,
-    list: list2,
-    listItem,
-    paragraph,
-    root,
-    strong,
-    text,
-    thematicBreak
-  };
+var init_html_kind = __esm(() => {
+  init_dev();
+  init_micromark_util_html_tag_name();
 });
 
 // ../../node_modules/mdast-util-to-markdown/lib/join.js
@@ -2530,17 +2595,28 @@ function joinDefaults(left, right, parent, state) {
     if (left.type === "paragraph" && (left.type === right.type || right.type === "definition" || right.type === "heading" && formatHeadingAsSetext(right, state))) {
       return;
     }
+    if (left.type === "html") {
+      const kind = htmlKind(left.value);
+      if (kind === undefined || kind === 6 || kind === 7)
+        return 1;
+    }
+    if (left.type === "paragraph" && right.type === "html") {
+      const kind = htmlKind(right.value);
+      if (kind === undefined || kind === 7)
+        return 1;
+    }
     return parent.spread ? 1 : 0;
   }
 }
 var join;
 var init_join = __esm(() => {
   init_format_heading_as_setext();
+  init_html_kind();
   join = [joinDefaults];
 });
 
 // ../../node_modules/mdast-util-to-markdown/lib/unsafe.js
-var fullPhrasingSpans, unsafe;
+var fullPhrasingSpans, unsafe, code2 = -1;
 var init_unsafe = __esm(() => {
   fullPhrasingSpans = [
     "autolink",
@@ -2580,6 +2656,12 @@ var init_unsafe = __esm(() => {
         "headingAtx"
       ]
     },
+    { character: "\r", before: "[\\r\\n]", inConstruct: "phrasing" },
+    { character: "\r", after: "\\r", inConstruct: "phrasing" },
+    { character: `
+`, before: "\\n", inConstruct: "phrasing" },
+    { character: `
+`, after: "[\\r\\n]", inConstruct: "phrasing" },
     { character: " ", after: "[\\r\\n]", inConstruct: "phrasing" },
     { character: " ", before: "[\\r\\n]", inConstruct: "phrasing" },
     {
@@ -2640,8 +2722,14 @@ var init_unsafe = __esm(() => {
       inConstruct: ["codeFencedLangGraveAccent", "codeFencedMetaGraveAccent"]
     },
     { character: "`", inConstruct: "phrasing", notInConstruct: fullPhrasingSpans },
-    { atBreak: true, character: "~" }
+    { atBreak: true, character: "~" },
+    { character: "<", inConstruct: "autolink" },
+    { character: ">", inConstruct: "autolink" },
+    { character: "", inConstruct: "autolink" }
   ];
+  while (++code2 < 33) {
+    unsafe.push({ character: String.fromCharCode(code2), inConstruct: "autolink" });
+  }
 });
 
 // ../../node_modules/character-entities/index.js
@@ -4795,7 +4883,7 @@ function decodeNumericCharacterReference(value, base) {
   }
   return String.fromCodePoint(code);
 }
-var init_dev3 = __esm(() => {
+var init_dev2 = __esm(() => {
   init_default();
 });
 
@@ -4816,9 +4904,9 @@ function decode($0, $1, $2) {
   return decodeNamedCharacterReference($2) || $0;
 }
 var characterEscapeOrReference;
-var init_dev4 = __esm(() => {
+var init_dev3 = __esm(() => {
   init_decode_named_character_reference();
-  init_dev3();
+  init_dev2();
   init_default();
   characterEscapeOrReference = /\\([!-/:-@[-`{-~])|&(#(?:\d{1,7}|x[\da-f]{1,6})|[\da-z]{1,31});/gi;
 });
@@ -4831,26 +4919,222 @@ function association(node) {
   return decodeString(node.identifier);
 }
 var init_association = __esm(() => {
-  init_dev4();
+  init_dev3();
 });
 
 // ../../node_modules/mdast-util-to-markdown/lib/util/compile-pattern.js
 function compilePattern(pattern) {
   if (!pattern._compiled) {
     const before = (pattern.atBreak ? "[\\r\\n][\\t ]*" : "") + (pattern.before ? "(?:" + pattern.before + ")" : "");
-    pattern._compiled = new RegExp((before ? "(" + before + ")" : "") + (/[|\\{}()[\]^$+*?.-]/.test(pattern.character) ? "\\" : "") + pattern.character + (pattern.after ? "(?:" + pattern.after + ")" : ""), "g");
+    pattern._compiled = new RegExp((pattern.beforeNode ? "^" : before ? "(" + before + ")" : "") + (/[$()*+.?[\\\]^{|}]/.test(pattern.character) ? "\\" : "") + pattern.character + (pattern.afterNode ? "$" : pattern.after ? "(?:" + pattern.after + ")" : ""), pattern.unicode ? "gu" : "g");
   }
   return pattern._compiled;
 }
 
+// ../../node_modules/micromark-util-classify-character/dev/index.js
+function classifyCharacter(code) {
+  if (code === codes.eof || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {
+    return constants.characterGroupWhitespace;
+  }
+  if (unicodePunctuation(code)) {
+    return constants.characterGroupPunctuation;
+  }
+}
+var init_dev4 = __esm(() => {
+  init_dev();
+  init_default();
+});
+
+// ../../node_modules/mdast-util-to-markdown/lib/util/character.js
+function firstCharacter(value) {
+  const code = value.codePointAt(0);
+  return code === undefined ? "" : String.fromCodePoint(code);
+}
+function lastCharacter(value) {
+  const code = value.codePointAt(value.length - 2);
+  return code !== undefined && code > 65535 ? value.slice(-2) : value.slice(-1);
+}
+
+// ../../node_modules/mdast-util-to-markdown/lib/util/encode-info.js
+function encodeInfo(outside, inside, marker) {
+  const outsideKind = classifyCharacter(outside);
+  const insideKind = classifyCharacter(inside);
+  if (outsideKind === undefined) {
+    return insideKind === undefined ? marker === "_" ? { inside: true, outside: true } : { inside: false, outside: false } : insideKind === 1 ? { inside: true, outside: true } : { inside: false, outside: true };
+  }
+  if (outsideKind === 1) {
+    return insideKind === undefined ? { inside: false, outside: false } : insideKind === 1 ? { inside: true, outside: true } : { inside: false, outside: false };
+  }
+  return insideKind === undefined ? { inside: false, outside: false } : insideKind === 1 ? { inside: true, outside: false } : { inside: false, outside: false };
+}
+var init_encode_info = __esm(() => {
+  init_dev4();
+});
+
 // ../../node_modules/mdast-util-to-markdown/lib/util/container-phrasing.js
+function candidates(tokens, involved, runOf) {
+  const related = new Set;
+  for (const token of tokens) {
+    const siblings = runOf.get(token);
+    if (siblings && token.attention && involved.some((d) => d.attention === token.attention)) {
+      for (const sibling of siblings.tokens) {
+        related.add(sibling.attention);
+      }
+    }
+  }
+  const ordered = [];
+  for (const token of tokens) {
+    if (token.attention && related.delete(token.attention)) {
+      ordered.push(token.attention);
+    }
+  }
+  ordered.reverse();
+  return ordered;
+}
+function check(tokens, before, after) {
+  const runs = [];
+  const wrong = new Map;
+  const runOf = new Map;
+  let index = 0;
+  while (index < tokens.length) {
+    if (!tokens[index].attention) {
+      index++;
+      continue;
+    }
+    const marker = tokens[index].value.charAt(0);
+    const strict = builtins.get(marker);
+    let end = index + 1;
+    while (end < tokens.length && tokens[end].attention && tokens[end].value.charAt(0) === marker) {
+      end++;
+    }
+    const head = index ? tokens[index - 1].value : before;
+    const previous = classifyCharacter(head.charCodeAt(head.length - 1));
+    const next = classifyCharacter((end < tokens.length ? tokens[end].value : after).charCodeAt(0));
+    const open = !next || next === 2 && Boolean(previous);
+    const close = !previous || previous === 2 && Boolean(next);
+    const run = {
+      tokens: tokens.slice(index, end),
+      markers: [],
+      start: 0,
+      end: 0,
+      open: strict ? open && (Boolean(previous) || !close) : open,
+      close: strict ? close && (Boolean(next) || !open) : close,
+      split: strict !== undefined
+    };
+    for (const token of run.tokens) {
+      wrong.set(token, [...run.tokens]);
+      runOf.set(token, run);
+      let size = token.value.length;
+      while (size--)
+        run.markers.push(token);
+    }
+    run.end = run.markers.length;
+    runs.push(run);
+    index = end;
+  }
+  pair(runs, wrong);
+  index = -1;
+  while (++index < tokens.length) {
+    const involved = wrong.get(tokens[index]);
+    if (involved)
+      return { attention: candidates(tokens, involved, runOf), index };
+  }
+}
 function containerPhrasing(parent, state, info) {
+  return serialize(phrasing2(parent, state, info), info.before, info.after);
+}
+function encode(tokens, start) {
+  const token = tokens[start ? 0 : tokens.length - 1];
+  if (!token || token.attention)
+    return;
+  const character = start ? firstCharacter(token.value) : lastCharacter(token.value);
+  const reference = encodeCharacterReference(character.codePointAt(0));
+  token.value = start ? reference + token.value.slice(character.length) : token.value.slice(0, token.value.length - character.length) + reference;
+}
+function improve(items, chosen, mistake, before, after) {
+  for (const attention of mistake.attention) {
+    const current = chosen.get(attention) || attention.sequences[0];
+    for (const sequence of attention.sequences) {
+      if (sequence === current)
+        continue;
+      const trial = new Map(chosen);
+      trial.set(attention, sequence);
+      const tokens = render(items, trial, before, after);
+      const next = check(tokens, before, after);
+      if (!next || next.index > mistake.index) {
+        return { chosen: trial, mistake: next, tokens };
+      }
+    }
+  }
+}
+function pair(runs, wrong) {
+  let index = 0;
+  while (index < runs.length) {
+    const closer = runs[index];
+    const marker = closer.tokens[0].value.charAt(0);
+    const closerSize = closer.end - closer.start;
+    let open = closer.close && closerSize ? index : 0;
+    while (open--) {
+      const opener = runs[open];
+      const openerSize = opener.end - opener.start;
+      if (opener.tokens[0].value.charAt(0) === marker && opener.open && openerSize && (closer.split ? !((opener.close || closer.open) && closerSize % 3) || (openerSize + closerSize) % 3 : openerSize === opener.markers.length && openerSize === closerSize)) {
+        const size = closer.split ? openerSize > 1 && closerSize > 1 ? 2 : 1 : closerSize;
+        const opening = opener.markers.slice(opener.end - size, opener.end);
+        const closing = closer.markers.slice(closer.start, closer.start + size);
+        const openToken = opening[0];
+        const closeToken = closing[0];
+        if (openToken === opening[size - 1] && openToken.value.length === size && closeToken === closing[size - 1] && closeToken.value.length === size && openToken.attention === closeToken.attention) {
+          wrong.delete(openToken);
+          wrong.delete(closeToken);
+        } else {
+          const involved = [...new Set([...opening, ...closing])];
+          for (const token of involved) {
+            const list = wrong.get(token);
+            if (list)
+              list.push(...involved);
+          }
+        }
+        opener.end -= size;
+        closer.start += size;
+        break;
+      }
+    }
+    if (open === -1 || closer.start === closer.end)
+      index++;
+  }
+}
+function attentionSequences(type, markers, sizes) {
+  if (markers.length === 0) {
+    throw new Error("Cannot serialize `" + type + "` as attention without markers, expected one or more markers");
+  }
+  if (sizes.length === 0) {
+    throw new Error("Cannot serialize `" + type + "` as attention without sizes, expected one or more sizes");
+  }
+  for (const size of sizes) {
+    if (!Number.isSafeInteger(size) || size < 1) {
+      throw new Error("Cannot serialize `" + type + "` as attention with `" + size + "` as size, expected positive integer");
+    }
+  }
+  const sequences = [];
+  for (const marker of markers) {
+    if (marker.length !== 1) {
+      throw new Error("Cannot serialize `" + type + "` as attention with `" + marker + "` as marker, expected a single ascii character");
+    }
+    if (!asciiPunctuation(marker.charCodeAt(0))) {
+      throw new Error("Cannot serialize `" + type + "` as attention with `" + marker + "` as marker, expected ascii punctuation");
+    }
+    for (const size of sizes) {
+      sequences.push(marker.repeat(size));
+    }
+  }
+  return sequences;
+}
+function phrasing2(parent, state, info) {
   const indexStack = state.indexStack;
   const children = parent.children || [];
   const results = [];
   let index = -1;
   let before = info.before;
-  let encodeAfter;
   indexStack.push(-1);
   let tracker = state.createTracker(info);
   while (++index < children.length) {
@@ -4861,47 +5145,132 @@ function containerPhrasing(parent, state, info) {
       let handle = state.handle.handlers[children[index + 1].type];
       if (handle && handle.peek)
         handle = handle.peek;
-      after = handle ? handle(children[index + 1], parent, state, {
+      after = handle ? firstCharacter(handle(children[index + 1], parent, state, {
         before: "",
         after: "",
         ...tracker.current()
-      }).charAt(0) : "";
+      })) : "";
     } else {
       after = info.after;
     }
-    if (results.length > 0 && (before === "\r" || before === `
-`) && child.type === "html") {
-      results[results.length - 1] = results[results.length - 1].replace(/(\r?\n|\r)$/, " ");
+    const previous = results[results.length - 1];
+    if (typeof previous === "string" && (before === "\r" || before === `
+`) && child.type === "html" && htmlKind(child.value) !== 7) {
+      results[results.length - 1] = previous.replace(/(\r?\n|\r)$/, " ");
       before = " ";
       tracker = state.createTracker(info);
-      tracker.move(results.join(""));
+      tracker.move(serialize(results, info.before, info.after));
+    }
+    const handle = state.handle.handlers[child.type];
+    if (handle && handle.attention) {
+      const { construct, markers, sizes } = handle.attention(child, state);
+      const sequences = attentionSequences(child.type, markers, sizes);
+      const sequence = sequences[0];
+      const exit = state.enter(construct);
+      tracker.move(sequence);
+      const inside = phrasing2(child, state, {
+        ...tracker.current(),
+        before: sequence,
+        after: sequence
+      });
+      tracker.move(serialize(inside, sequence, sequence));
+      tracker.move(sequence);
+      exit();
+      results.push({ children: inside, sequences });
+      before = sequence.charAt(sequence.length - 1);
+    } else {
+      const value = state.handle(child, parent, state, {
+        ...tracker.current(),
+        after,
+        before
+      });
+      if (!value)
+        continue;
+      tracker.move(value);
+      results.push(value);
+      before = lastCharacter(value);
     }
-    let value = state.handle(child, parent, state, {
-      ...tracker.current(),
-      after,
-      before
-    });
-    if (encodeAfter && encodeAfter === value.slice(0, 1)) {
-      value = encodeCharacterReference(encodeAfter.charCodeAt(0)) + value.slice(1);
+  }
+  indexStack.pop();
+  return results;
+}
+function render(items, chosen, before, after) {
+  const tokens = [];
+  let encodeAfter;
+  let previous = lastCharacter(before);
+  let index = -1;
+  while (++index < items.length) {
+    const item = items[index];
+    if (typeof item === "string") {
+      const token = { value: item, attention: undefined };
+      if (encodeAfter && encodeAfter === firstCharacter(item)) {
+        encode([token], true);
+      }
+      encodeAfter = undefined;
+      tokens.push(token);
+      if (token.value)
+        previous = lastCharacter(token.value);
+      continue;
     }
-    const encodingInfo = state.attentionEncodeSurroundingInfo;
-    state.attentionEncodeSurroundingInfo = undefined;
-    encodeAfter = undefined;
-    if (encodingInfo) {
-      if (results.length > 0 && encodingInfo.before && before === results[results.length - 1].slice(-1)) {
-        results[results.length - 1] = results[results.length - 1].slice(0, -1) + encodeCharacterReference(before.charCodeAt(0));
-      }
-      if (encodingInfo.after)
-        encodeAfter = after;
+    const sequence = chosen.get(item) || item.sequences[0];
+    const marker = sequence.charAt(0);
+    const next = items[index + 1];
+    const outsideBefore = previous;
+    const outsideAfter = firstCharacter(next === undefined ? after : typeof next === "string" ? next : chosen.get(next) || next.sequences[0]);
+    const inside = render(item.children, chosen, sequence, sequence);
+    const head = inside.length > 0 ? inside[0].value : "";
+    const open = encodeInfo(outsideBefore.charCodeAt(outsideBefore.length - 1), head.charCodeAt(0), marker);
+    if (open.inside)
+      encode(inside, true);
+    const tail = inside.length > 0 ? lastCharacter(inside[inside.length - 1].value) : "";
+    const close = encodeInfo(outsideAfter.charCodeAt(0), tail.charCodeAt(tail.length - 1), marker);
+    if (close.inside)
+      encode(inside, false);
+    if (open.outside && outsideBefore !== `
+` && outsideBefore !== "\r") {
+      encode(tokens, false);
+    }
+    if (close.outside)
+      encodeAfter = outsideAfter;
+    tokens.push({ value: sequence, attention: item }, ...inside, {
+      value: sequence,
+      attention: item
+    });
+    previous = sequence.charAt(sequence.length - 1);
+  }
+  return tokens;
+}
+function serialize(items, before, after) {
+  let chosen = new Map;
+  const initial = render(items, chosen, before, after);
+  let tokens = initial;
+  let mistake = check(tokens, before, after);
+  while (mistake) {
+    const next = improve(items, chosen, mistake, before, after);
+    if (!next) {
+      tokens = initial;
+      break;
     }
-    tracker.move(value);
-    results.push(value);
-    before = value.slice(-1);
+    chosen = next.chosen;
+    tokens = next.tokens;
+    mistake = next.mistake;
   }
-  indexStack.pop();
-  return results.join("");
+  let result = "";
+  for (const token of tokens)
+    result += token.value;
+  return result;
 }
-var init_container_phrasing = () => {};
+var builtins;
+var init_container_phrasing = __esm(() => {
+  init_dev();
+  init_dev4();
+  init_encode_info();
+  init_html_kind();
+  builtins = new Map([
+    ["*", false],
+    ["_", true]
+  ]);
+});
 
 // ../../node_modules/mdast-util-to-markdown/lib/util/container-flow.js
 function containerFlow(parent, state, info) {
@@ -4984,19 +5353,24 @@ function safe(state, input, config) {
   const positions = [];
   const result = [];
   const infos = {};
+  const percentEncode = state.stack.includes("autolink");
+  const offset = config.before ? config.before.length : 0;
+  const end = value.length - (config.after ? config.after.length : 0);
   let index = -1;
   while (++index < state.unsafe.length) {
     const pattern = state.unsafe[index];
-    if (!patternInScope(state.stack, pattern)) {
+    if (!patternInScope(state.stack, pattern) || !nodeInScope(pattern.beforeNode, config.beforeNode) || !nodeInScope(pattern.afterNode, config.afterNode)) {
       continue;
     }
     const expression = state.compilePattern(pattern);
+    const from = pattern.beforeNode ? offset : 0;
+    const subject = value.slice(from, pattern.afterNode ? end : undefined);
     let match;
-    while (match = expression.exec(value)) {
+    while (match = expression.exec(subject)) {
       const before = "before" in pattern || Boolean(pattern.atBreak);
       const after = "after" in pattern;
-      const position = match.index + (before ? match[1].length : 0);
-      if (positions.includes(position)) {
+      const position = from + match.index + (before ? match[1].length : 0);
+      if (own5.call(infos, position)) {
         if (infos[position].before && !before) {
           infos[position].before = false;
         }
@@ -5010,31 +5384,53 @@ function safe(state, input, config) {
     }
   }
   positions.sort(numerical);
-  let start = config.before ? config.before.length : 0;
-  const end = value.length - (config.after ? config.after.length : 0);
+  let start = offset;
   index = -1;
   while (++index < positions.length) {
     const position = positions[index];
     if (position < start || position >= end) {
       continue;
     }
+    if (value.charAt(position) === "_" && position > 0 && classifyCharacter(value.charCodeAt(position - 1)) === undefined && !own5.call(infos, position - 1) && !(position - 1 === offset && /[*_]/.test(value.charAt(offset - 1)))) {
+      let sequenceEnd = position + 1;
+      while (sequenceEnd < end && value.charAt(sequenceEnd) === "_") {
+        sequenceEnd++;
+      }
+      const skip = sequenceEnd - position - 1;
+      if (positions[index + skip] === sequenceEnd - 1 && sequenceEnd < value.length && classifyCharacter(value.charCodeAt(sequenceEnd)) === undefined && !own5.call(infos, sequenceEnd) && !(sequenceEnd === end - 1 && /[*_]/.test(value.charAt(end)))) {
+        index += skip;
+        continue;
+      }
+    }
     if (position + 1 < end && positions[index + 1] === position + 1 && infos[position].after && !infos[position + 1].before && !infos[position + 1].after || positions[index - 1] === position - 1 && infos[position].before && !infos[position - 1].before && !infos[position - 1].after) {
       continue;
     }
     if (start !== position) {
-      result.push(escapeBackslashes(value.slice(start, position), "\\"));
+      const slice = value.slice(start, position);
+      result.push(percentEncode ? slice : escapeBackslashes(slice, "\\"));
     }
     start = position;
-    if (/[!-/:-@[-`{-~]/.test(value.charAt(position)) && (!config.encode || !config.encode.includes(value.charAt(position)))) {
+    if (percentEncode) {
+      result.push("%" + value.charCodeAt(position).toString(16).toUpperCase().padStart(2, "0"));
+      start++;
+    } else if (/[!-/:-@[-`{-~]/.test(value.charAt(position)) && (!config.encode || !config.encode.includes(value.charAt(position)))) {
       result.push("\\");
     } else {
       result.push(encodeCharacterReference(value.charCodeAt(position)));
       start++;
     }
   }
-  result.push(escapeBackslashes(value.slice(start, end), config.after));
+  const rest = value.slice(start, end);
+  result.push(percentEncode ? rest : escapeBackslashes(rest, config.after));
   return result.join("");
 }
+function nodeInScope(types, node) {
+  if (!types)
+    return true;
+  if (!node)
+    return false;
+  return typeof types === "string" ? types === node.type : types.includes(node.type);
+}
 function numerical(a, b) {
   return a - b;
 }
@@ -5059,7 +5455,11 @@ function escapeBackslashes(value, after) {
   results.push(value.slice(start));
   return results.join("");
 }
-var init_safe = () => {};
+var own5;
+var init_safe = __esm(() => {
+  init_dev4();
+  own5 = {}.hasOwnProperty;
+});
 
 // ../../node_modules/mdast-util-to-markdown/lib/util/track.js
 function track(config) {
@@ -5090,6 +5490,8 @@ function toMarkdown(tree, options) {
   const settings = options || {};
   const state = {
     associationId: association,
+    bulletCurrent: undefined,
+    bulletLastUsed: undefined,
     containerPhrasing: containerPhrasingBound,
     containerFlow: containerFlowBound,
     createTracker: track,
@@ -5114,14 +5516,9 @@ function toMarkdown(tree, options) {
     unknown,
     handlers: state.handlers
   });
-  let result = state.handle(tree, undefined, state, {
-    before: `
-`,
-    after: `
-`,
-    now: { line: 1, column: 1 },
-    lineShift: 0
-  });
+  let result = state.handle(phrasing(tree) ? { type: "root", children: [tree] } : tree, undefined, state, { before: `
+`, after: `
+`, now: { line: 1, column: 1 }, lineShift: 0 });
   if (result && result.charCodeAt(result.length - 1) !== 10 && result.charCodeAt(result.length - 1) !== 13) {
     result += `
 `;
@@ -5157,6 +5554,7 @@ function safeBound(value, config) {
   return safe(this, value, config);
 }
 var init_lib8 = __esm(() => {
+  init_mdast_util_phrasing();
   init_zwitch();
   init_configure();
   init_handle();
@@ -5942,7 +6340,7 @@ var init_dangerous = __esm(() => {
 // ../../node_modules/stringify-entities/lib/util/to-named.js
 function toNamed(code, next, omit, attribute) {
   const character = String.fromCharCode(code);
-  if (own5.call(characters, character)) {
+  if (own6.call(characters, character)) {
     const name = characters[character];
     const value = "&" + name;
     if (omit && characterEntitiesLegacy.includes(name) && !dangerous.includes(name) && (!attribute || next && next !== 61 && notAlphanumericRegex.test(String.fromCharCode(next)))) {
@@ -5952,15 +6350,15 @@ function toNamed(code, next, omit, attribute) {
   }
   return "";
 }
-var own5, characters, key, notAlphanumericRegex;
+var own6, characters, key, notAlphanumericRegex;
 var init_to_named = __esm(() => {
   init_character_entities_legacy();
   init_character_entities_html4();
   init_dangerous();
-  own5 = {}.hasOwnProperty;
+  own6 = {}.hasOwnProperty;
   characters = {};
   for (key in characterEntitiesHtml4) {
-    if (own5.call(characterEntitiesHtml4, key)) {
+    if (own6.call(characterEntitiesHtml4, key)) {
       characters[characterEntitiesHtml4[key]] = key;
     }
   }
@@ -6148,12 +6546,14 @@ function directiveToMarkdown(options) {
         inConstruct: ["leafDirectiveLabel", "containerDirectiveLabel"]
       },
       {
+        after: "[^\\s\\p{P}\\p{S}]",
         before: "[^:]",
         character: ":",
-        after: "[A-Za-z]",
-        inConstruct: ["phrasing"]
+        inConstruct: ["phrasing"],
+        unicode: true
       },
-      { atBreak: true, character: ":", after: ":" }
+      { afterNode: "textDirective", character: ":", inConstruct: ["phrasing"] },
+      { atBreak: true, before: ":+", character: ":" }
     ]
   };
   function handleDirective(node, _, state, info) {
@@ -6161,6 +6561,8 @@ function directiveToMarkdown(options) {
     const sequence = fence(node);
     const exit = state.enter(node.type);
     let value = tracker.move(sequence + (node.name || ""));
+    const attributesValue = attributes(node, state);
+    const after = info.after.charCodeAt(0);
     let label;
     if (node.type === "containerDirective") {
       const head = (node.children || [])[0];
@@ -6181,8 +6583,10 @@ function directiveToMarkdown(options) {
       value += tracker.move("]");
       subexit();
       exit();
+    } else if (!attributesValue && (after === 45 || after === 95 || !(unicodePunctuation(after) || unicodeWhitespace(after)))) {
+      value += tracker.move("[]");
     }
-    value += tracker.move(attributes(node, state));
+    value += tracker.move(attributesValue || (after === 123 ? "{}" : ""));
     if (node.type === "containerDirective") {
       const head = (node.children || [])[0];
       let shallow = node;
@@ -6208,12 +6612,12 @@ function directiveToMarkdown(options) {
     let id;
     let key;
     for (key in attributes) {
-      if (own6.call(attributes, key) && attributes[key] !== undefined && attributes[key] !== null) {
+      if (own7.call(attributes, key) && attributes[key] !== undefined && attributes[key] !== null) {
         const value = String(attributes[key]);
         if (key === "id") {
           id = settings.preferShortcut !== false && shortcut.test(value) ? "#" + value : quoted("id", value, node, state);
         } else if (key === "class") {
-          const list = value.split(/[\t\n\r ]+/g);
+          const list = value.split(/[\t\n\r ]+/);
           const classesFullList = [];
           const classesList = [];
           let index = -1;
@@ -6359,13 +6763,14 @@ function fence(node) {
   }
   return ":".repeat(size);
 }
-var own6, emptyOptions2, shortcut, unquoted;
+var own7, emptyOptions2, shortcut, unquoted;
 var init_lib13 = __esm(() => {
   init_development();
+  init_dev();
   init_parse_entities();
   init_stringify_entities();
   init_unist_util_visit_parents2();
-  own6 = {}.hasOwnProperty;
+  own7 = {}.hasOwnProperty;
   emptyOptions2 = {};
   shortcut = /^[^\t\n\r "#'.<=>`}]+$/;
   unquoted = /^[^\t\n\r "'<=>`}]+$/;
@@ -6378,7 +6783,7 @@ var init_mdast_util_directive = __esm(() => {
 
 // ../../node_modules/micromark-factory-space/dev/index.js
 function factorySpace(effects, ok, type, max) {
-  const limit = max ? max - 1 : Number.POSITIVE_INFINITY;
+  const limit = max ? max - 1 : Infinity;
   let size = 0;
   return start;
   function start(code) {
@@ -6397,6 +6802,29 @@ function factorySpace(effects, ok, type, max) {
     return ok(code);
   }
 }
+function factorySpaceMinMax(effects, ok, nok, type, min, max) {
+  let size = 0;
+  return start;
+  function start(code) {
+    if (max > 0 && markdownSpace(code)) {
+      effects.enter(type);
+      return prefix(code);
+    }
+    return after(code);
+  }
+  function prefix(code) {
+    if (markdownSpace(code) && size < max) {
+      effects.consume(code);
+      size++;
+      return prefix;
+    }
+    effects.exit(type);
+    return after(code);
+  }
+  function after(code) {
+    return size >= min ? ok(code) : nok(code);
+  }
+}
 var init_dev5 = __esm(() => {
   init_dev();
 });
@@ -7182,15 +7610,13 @@ function findAndReplace(tree, list, options) {
         find.lastIndex = position + 1;
       } else {
         if (start !== position) {
-          nodes.push({
-            type: "text",
-            value: node.value.slice(start, position)
-          });
+          add({ type: "text", value: node.value.slice(start, position) });
         }
         if (Array.isArray(value)) {
-          nodes.push(...value);
+          for (const child of value)
+            add(child);
         } else if (value) {
-          nodes.push(value);
+          add(value);
         }
         start = position + match[0].length;
         change = true;
@@ -7202,20 +7628,28 @@ function findAndReplace(tree, list, options) {
     }
     if (change) {
       if (start < node.value.length) {
-        nodes.push({ type: "text", value: node.value.slice(start) });
+        add({ type: "text", value: node.value.slice(start) });
       }
       parent.children.splice(index, 1, ...nodes);
     } else {
       nodes = [node];
     }
     return index + nodes.length;
+    function add(child) {
+      const previous = nodes[nodes.length - 1];
+      if (previous && previous.type === "text" && child.type === "text") {
+        previous.value += child.value;
+      } else {
+        nodes.push(child);
+      }
+    }
   }
 }
 function toPairs(tupleOrList) {
-  const result = [];
   if (!Array.isArray(tupleOrList)) {
     throw new TypeError("Expected find and replace tuple or list of tuples");
   }
+  const result = [];
   const list = !tupleOrList[0] || Array.isArray(tupleOrList[0]) ? tupleOrList : [tupleOrList];
   let index = -1;
   while (++index < list.length) {
@@ -7518,35 +7952,39 @@ function gfmStrikethroughFromMarkdown() {
 }
 function gfmStrikethroughToMarkdown() {
   return {
+    handlers: { delete: handleDelete },
     unsafe: [
       {
         character: "~",
         inConstruct: "phrasing",
         notInConstruct: constructsWithoutStrikethrough
       }
-    ],
-    handlers: { delete: handleDelete }
+    ]
   };
 }
 function enterStrikethrough(token) {
-  this.enter({ type: "delete", children: [] }, token);
+  this.enter({ type: "delete", children: [], position: undefined }, token);
 }
 function exitStrikethrough(token) {
   this.exit(token);
 }
 function handleDelete(node, _, state, info) {
   const tracker = state.createTracker(info);
+  const sequence = state.stack.includes("strikethrough") ? "~" : "~~";
   const exit = state.enter("strikethrough");
-  let value = tracker.move("~~");
+  let value = tracker.move(sequence);
   value += state.containerPhrasing(node, {
     ...tracker.current(),
     before: value,
     after: "~"
   });
-  value += tracker.move("~~");
+  value += tracker.move(sequence);
   exit();
   return value;
 }
+function attentionDelete() {
+  return { construct: "strikethrough", markers: ["~"], sizes: [2, 1] };
+}
 function peekDelete() {
   return "~";
 }
@@ -7560,6 +7998,7 @@ var init_lib19 = __esm(() => {
     "titleQuote",
     "titleApostrophe"
   ];
+  handleDelete.attention = attentionDelete;
   handleDelete.peek = peekDelete;
 });
 
@@ -7590,7 +8029,7 @@ function markdownTable(table, options) {
       mostCellsPerRow = table[rowIndex].length;
     }
     while (++columnIndex < table[rowIndex].length) {
-      const cell = serialize(table[rowIndex][columnIndex]);
+      const cell = serialize2(table[rowIndex][columnIndex]);
       if (settings.alignDelimiters !== false) {
         const size = stringLength(cell);
         sizes[columnIndex] = size;
@@ -7695,7 +8134,7 @@ function markdownTable(table, options) {
   return lines.join(`
 `);
 }
-function serialize(value) {
+function serialize2(value) {
   return value === null || value === undefined ? "" : String(value);
 }
 function toAlignment(value) {
@@ -8329,7 +8768,7 @@ function previousUnbalanced(events) {
   }
   return result;
 }
-var wwwPrefix, domain, path, trail, emailDomainDotTrail, wwwAutolink, protocolAutolink, emailAutolink, text2, code2;
+var wwwPrefix, domain, path, trail, emailDomainDotTrail, wwwAutolink, protocolAutolink, emailAutolink, text2, code3;
 var init_syntax2 = __esm(() => {
   init_dev();
   init_default();
@@ -8357,14 +8796,14 @@ var init_syntax2 = __esm(() => {
     previous: previousEmail
   };
   text2 = {};
-  code2 = codes.digit0;
-  while (code2 < codes.leftCurlyBrace) {
-    text2[code2] = emailAutolink;
-    code2++;
-    if (code2 === codes.colon)
-      code2 = codes.uppercaseA;
-    else if (code2 === codes.leftSquareBracket)
-      code2 = codes.lowercaseA;
+  code3 = codes.digit0;
+  while (code3 < codes.leftCurlyBrace) {
+    text2[code3] = emailAutolink;
+    code3++;
+    if (code3 === codes.colon)
+      code3 = codes.uppercaseA;
+    else if (code3 === codes.leftSquareBracket)
+      code3 = codes.lowercaseA;
   }
   text2[codes.plusSign] = emailAutolink;
   text2[codes.dash] = emailAutolink;
@@ -8398,43 +8837,36 @@ function resolveAll(constructs, events, context) {
 // ../../node_modules/micromark-core-commonmark/dev/lib/attention.js
 function resolveAllAttention(events, context) {
   let index = -1;
-  let open;
-  let group;
-  let text;
-  let openingSequence;
-  let closingSequence;
-  let use;
   let nextEvents;
-  let offset;
   while (++index < events.length) {
     if (events[index][0] === "enter" && events[index][1].type === "attentionSequence" && events[index][1]._close) {
-      open = index;
+      let open = index;
       while (open--) {
         if (events[open][0] === "exit" && events[open][1].type === "attentionSequence" && events[open][1]._open && context.sliceSerialize(events[open][1]).charCodeAt(0) === context.sliceSerialize(events[index][1]).charCodeAt(0)) {
           if ((events[open][1]._close || events[index][1]._open) && (events[index][1].end.offset - events[index][1].start.offset) % 3 && !((events[open][1].end.offset - events[open][1].start.offset + events[index][1].end.offset - events[index][1].start.offset) % 3)) {
             continue;
           }
-          use = events[open][1].end.offset - events[open][1].start.offset > 1 && events[index][1].end.offset - events[index][1].start.offset > 1 ? 2 : 1;
+          const use = events[open][1].end.offset - events[open][1].start.offset > 1 && events[index][1].end.offset - events[index][1].start.offset > 1 ? 2 : 1;
           const start = { ...events[open][1].end };
           const end = { ...events[index][1].start };
           movePoint(start, -use);
           movePoint(end, use);
-          openingSequence = {
+          const openingSequence = {
             type: use > 1 ? types.strongSequence : types.emphasisSequence,
             start,
             end: { ...events[open][1].end }
           };
-          closingSequence = {
+          const closingSequence = {
             type: use > 1 ? types.strongSequence : types.emphasisSequence,
             start: { ...events[index][1].start },
             end
           };
-          text = {
+          const text = {
             type: use > 1 ? types.strongText : types.emphasisText,
             start: { ...events[open][1].end },
             end: { ...events[index][1].start }
           };
-          group = {
+          const group = {
             type: use > 1 ? types.strong : types.emphasis,
             start: { ...openingSequence.start },
             end: { ...closingSequence.end }
@@ -8462,14 +8894,13 @@ function resolveAllAttention(events, context) {
             ["exit", closingSequence, context],
             ["exit", group, context]
           ]);
+          let offset = 0;
           if (events[index][1].end.offset - events[index][1].start.offset) {
             offset = 2;
             nextEvents = push(nextEvents, [
               ["enter", events[index][1], context],
               ["exit", events[index][1], context]
             ]);
-          } else {
-            offset = 0;
           }
           splice(events, open - 1, index - open + 3, nextEvents);
           index = open + nextEvents.length - offset - 2;
@@ -8506,8 +8937,8 @@ function tokenizeAttention(effects, ok2) {
     const token = effects.exit("attentionSequence");
     const after = classifyCharacter(code);
     ok(attentionMarkers, "expected `attentionMarkers` to be populated");
-    const open = !after || after === constants.characterGroupPunctuation && before || attentionMarkers.includes(code);
-    const close = !before || before === constants.characterGroupPunctuation && after || attentionMarkers.includes(previous);
+    const open = !after || after === constants.characterGroupPunctuation && before || attentionMarkers.includes(code) && code !== codes.asterisk && code !== codes.underscore;
+    const close = !before || before === constants.characterGroupPunctuation && after || attentionMarkers.includes(previous) && previous !== codes.asterisk && previous !== codes.underscore;
     token._open = Boolean(marker === codes.asterisk ? open : open && (before || !close));
     token._close = Boolean(marker === codes.asterisk ? close : close && (after || !open));
     return ok2(code);
@@ -8518,13 +8949,13 @@ function movePoint(point, offset) {
   point.offset += offset;
   point._bufferIndex += offset;
 }
-var attention;
+var attention3;
 var init_attention = __esm(() => {
   init_development();
   init_dev9();
-  init_dev2();
+  init_dev4();
   init_default();
-  attention = {
+  attention3 = {
     name: "attention",
     resolveAll: resolveAllAttention,
     tokenize: tokenizeAttention
@@ -8823,6 +9254,35 @@ var init_character_reference = __esm(() => {
   };
 });
 
+// ../../node_modules/micromark-core-commonmark/dev/lib/partial-non-lazy-continuation.js
+function tokenizeNonLazyContinuation(effects, ok2, nok) {
+  const self2 = this;
+  return start;
+  function start(code) {
+    if (code === codes.eof) {
+      return nok(code);
+    }
+    ok(markdownLineEnding(code), "expected eol");
+    effects.enter(types.lineEnding);
+    effects.consume(code);
+    effects.exit(types.lineEnding);
+    return after;
+  }
+  function after(code) {
+    return self2.parser.lazy[self2.now().line] ? nok(code) : ok2(code);
+  }
+}
+var nonLazyContinuation;
+var init_partial_non_lazy_continuation = __esm(() => {
+  init_development();
+  init_dev();
+  init_default();
+  nonLazyContinuation = {
+    partial: true,
+    tokenize: tokenizeNonLazyContinuation
+  };
+});
+
 // ../../node_modules/micromark-core-commonmark/dev/lib/code-fenced.js
 function tokenizeCodeFenced(effects, ok2, nok) {
   const self2 = this;
@@ -8978,33 +9438,13 @@ function tokenizeCodeFenced(effects, ok2, nok) {
     }
   }
 }
-function tokenizeNonLazyContinuation(effects, ok2, nok) {
-  const self2 = this;
-  return start;
-  function start(code) {
-    if (code === codes.eof) {
-      return nok(code);
-    }
-    ok(markdownLineEnding(code), "expected eol");
-    effects.enter(types.lineEnding);
-    effects.consume(code);
-    effects.exit(types.lineEnding);
-    return lineStart;
-  }
-  function lineStart(code) {
-    return self2.parser.lazy[self2.now().line] ? nok(code) : ok2(code);
-  }
-}
-var nonLazyContinuation, codeFenced;
+var codeFenced;
 var init_code_fenced = __esm(() => {
   init_development();
   init_dev5();
   init_dev();
   init_default();
-  nonLazyContinuation = {
-    partial: true,
-    tokenize: tokenizeNonLazyContinuation
-  };
+  init_partial_non_lazy_continuation();
   codeFenced = {
     concrete: true,
     name: "codeFenced",
@@ -9014,16 +9454,11 @@ var init_code_fenced = __esm(() => {
 
 // ../../node_modules/micromark-core-commonmark/dev/lib/code-indented.js
 function tokenizeCodeIndented(effects, ok2, nok) {
-  const self2 = this;
   return start;
   function start(code) {
     ok(markdownSpace(code));
     effects.enter(types.codeIndented);
-    return factorySpace(effects, afterPrefix, types.linePrefix, constants.tabSize + 1)(code);
-  }
-  function afterPrefix(code) {
-    const tail = self2.events[self2.events.length - 1];
-    return tail && tail[1].type === types.linePrefix && tail[2].sliceSerialize(tail[1], true).length >= constants.tabSize ? atBreak(code) : nok(code);
+    return factorySpaceMinMax(effects, atBreak, nok, types.linePrefix, constants.tabSize, constants.tabSize)(code);
   }
   function atBreak(code) {
     if (code === codes.eof) {
@@ -9061,11 +9496,10 @@ function tokenizeFurtherStart(effects, ok, nok) {
       effects.exit(types.lineEnding);
       return furtherStart;
     }
-    return factorySpace(effects, afterPrefix, types.linePrefix, constants.tabSize + 1)(code);
+    return factorySpaceMinMax(effects, ok, onNotEnoughPrefix, types.linePrefix, constants.tabSize, constants.tabSize)(code);
   }
-  function afterPrefix(code) {
-    const tail = self2.events[self2.events.length - 1];
-    return tail && tail[1].type === types.linePrefix && tail[2].sliceSerialize(tail[1], true).length >= constants.tabSize ? ok(code) : markdownLineEnding(code) ? furtherStart(code) : nok(code);
+  function onNotEnoughPrefix(code) {
+    return markdownLineEnding(code) ? furtherStart(code) : nok(code);
   }
 }
 var codeIndented, furtherStart;
@@ -9851,8 +10285,6 @@ var init_hard_break_escape = __esm(() => {
 function resolveHeadingAtx(events, context) {
   let contentEnd = events.length - 2;
   let contentStart = 3;
-  let content;
-  let text;
   if (events[contentStart][1].type === types.whitespace) {
     contentStart += 2;
   }
@@ -9863,12 +10295,12 @@ function resolveHeadingAtx(events, context) {
     contentEnd -= contentStart + 1 === contentEnd ? 2 : 4;
   }
   if (contentEnd > contentStart) {
-    content = {
+    const content = {
       type: types.atxHeadingText,
       start: events[contentStart][1].start,
       end: events[contentEnd][1].end
     };
-    text = {
+    const text = {
       type: types.chunkText,
       start: events[contentStart][1].start,
       end: events[contentEnd][1].end,
@@ -9952,76 +10384,6 @@ var init_heading_atx = __esm(() => {
   };
 });
 
-// ../../node_modules/micromark-util-html-tag-name/index.js
-var htmlBlockNames, htmlRawNames;
-var init_micromark_util_html_tag_name = __esm(() => {
-  htmlBlockNames = [
-    "address",
-    "article",
-    "aside",
-    "base",
-    "basefont",
-    "blockquote",
-    "body",
-    "caption",
-    "center",
-    "col",
-    "colgroup",
-    "dd",
-    "details",
-    "dialog",
-    "dir",
-    "div",
-    "dl",
-    "dt",
-    "fieldset",
-    "figcaption",
-    "figure",
-    "footer",
-    "form",
-    "frame",
-    "frameset",
-    "h1",
-    "h2",
-    "h3",
-    "h4",
-    "h5",
-    "h6",
-    "head",
-    "header",
-    "hr",
-    "html",
-    "iframe",
-    "legend",
-    "li",
-    "link",
-    "main",
-    "menu",
-    "menuitem",
-    "nav",
-    "noframes",
-    "ol",
-    "optgroup",
-    "option",
-    "p",
-    "param",
-    "search",
-    "section",
-    "summary",
-    "table",
-    "tbody",
-    "td",
-    "tfoot",
-    "th",
-    "thead",
-    "title",
-    "tr",
-    "track",
-    "ul"
-  ];
-  htmlRawNames = ["pre", "script", "style", "textarea"];
-});
-
 // ../../node_modules/micromark-core-commonmark/dev/lib/html-flow.js
 function resolveToHtmlFlow(events) {
   let index = events.length;
@@ -10287,7 +10649,7 @@ function tokenizeHtmlFlow(effects, ok2, nok) {
     return continuation;
   }
   function continuationStart(code) {
-    return effects.check(nonLazyContinuationStart, continuationStartNonLazy, continuationAfter)(code);
+    return effects.check(nonLazyContinuation, continuationStartNonLazy, continuationAfter)(code);
   }
   function continuationStartNonLazy(code) {
     ok(markdownLineEnding(code));
@@ -10366,22 +10728,6 @@ function tokenizeHtmlFlow(effects, ok2, nok) {
     return ok2(code);
   }
 }
-function tokenizeNonLazyContinuationStart(effects, ok, nok) {
-  const self2 = this;
-  return start;
-  function start(code) {
-    if (markdownLineEnding(code)) {
-      effects.enter(types.lineEnding);
-      effects.consume(code);
-      effects.exit(types.lineEnding);
-      return after;
-    }
-    return nok(code);
-  }
-  function after(code) {
-    return self2.parser.lazy[self2.now().line] ? nok(code) : ok(code);
-  }
-}
 function tokenizeBlankLineBefore(effects, ok2, nok) {
   return start;
   function start(code) {
@@ -10392,13 +10738,14 @@ function tokenizeBlankLineBefore(effects, ok2, nok) {
     return effects.attempt(blankLine, ok2, nok);
   }
 }
-var htmlFlow, blankLineBefore, nonLazyContinuationStart;
+var htmlFlow, blankLineBefore;
 var init_html_flow = __esm(() => {
   init_development();
   init_dev();
   init_micromark_util_html_tag_name();
   init_default();
   init_blank_line();
+  init_partial_non_lazy_continuation();
   htmlFlow = {
     concrete: true,
     name: "htmlFlow",
@@ -10406,10 +10753,6 @@ var init_html_flow = __esm(() => {
     tokenize: tokenizeHtmlFlow
   };
   blankLineBefore = { partial: true, tokenize: tokenizeBlankLineBefore };
-  nonLazyContinuationStart = {
-    partial: true,
-    tokenize: tokenizeNonLazyContinuationStart
-  };
 });
 
 // ../../node_modules/micromark-core-commonmark/dev/lib/html-text.js
@@ -10747,12 +11090,11 @@ function resolveAllLabelEnd(events) {
 function resolveToLabelEnd(events, context) {
   let index = events.length;
   let offset = 0;
-  let token;
   let open;
   let close;
   let media;
   while (index--) {
-    token = events[index][1];
+    const token = events[index][1];
     if (open) {
       if (token.type === types.link || token.type === types.labelLink && token._inactive) {
         break;
@@ -10810,14 +11152,14 @@ function resolveToLabelEnd(events, context) {
 }
 function tokenizeLabelEnd(effects, ok2, nok) {
   const self2 = this;
-  let index = self2.events.length;
+  const labelStarts = self2._labelStarts;
   let labelStart;
   let defined;
-  while (index--) {
-    if ((self2.events[index][1].type === types.labelImage || self2.events[index][1].type === types.labelLink) && !self2.events[index][1]._balanced) {
-      labelStart = self2.events[index][1];
-      break;
+  if (labelStarts) {
+    while (labelStarts.length > 0 && labelStarts[labelStarts.length - 1]._balanced) {
+      labelStarts.pop();
     }
+    labelStart = labelStarts[labelStarts.length - 1];
   }
   return start;
   function start(code) {
@@ -10849,6 +11191,8 @@ function tokenizeLabelEnd(effects, ok2, nok) {
     return effects.attempt(referenceCollapsedConstruct, labelEndOk, labelEndNok)(code);
   }
   function labelEndOk(code) {
+    ok(labelStarts, "expected `labelStarts` to be populated");
+    labelStarts.pop();
     return ok2(code);
   }
   function labelEndNok(code) {
@@ -10961,6 +11305,7 @@ var init_label_end = __esm(() => {
 // ../../node_modules/micromark-core-commonmark/dev/lib/label-start-image.js
 function tokenizeLabelStartImage(effects, ok2, nok) {
   const self2 = this;
+  let labelImage;
   return start;
   function start(code) {
     ok(code === codes.exclamationMark, "expected `!`");
@@ -10975,13 +11320,18 @@ function tokenizeLabelStartImage(effects, ok2, nok) {
       effects.enter(types.labelMarker);
       effects.consume(code);
       effects.exit(types.labelMarker);
-      effects.exit(types.labelImage);
+      labelImage = effects.exit(types.labelImage);
       return after;
     }
     return nok(code);
   }
   function after(code) {
-    return code === codes.caret && "_hiddenFootnoteSupport" in self2.parser.constructs ? nok(code) : ok2(code);
+    if (code === codes.caret && "_hiddenFootnoteSupport" in self2.parser.constructs) {
+      return nok(code);
+    }
+    self2._labelStarts = self2._labelStarts || [];
+    self2._labelStarts.push(labelImage);
+    return ok2(code);
   }
 }
 var labelStartImage;
@@ -10999,6 +11349,7 @@ var init_label_start_image = __esm(() => {
 // ../../node_modules/micromark-core-commonmark/dev/lib/label-start-link.js
 function tokenizeLabelStartLink(effects, ok2, nok) {
   const self2 = this;
+  let labelLink;
   return start;
   function start(code) {
     ok(code === codes.leftSquareBracket, "expected `[`");
@@ -11006,11 +11357,16 @@ function tokenizeLabelStartLink(effects, ok2, nok) {
     effects.enter(types.labelMarker);
     effects.consume(code);
     effects.exit(types.labelMarker);
-    effects.exit(types.labelLink);
+    labelLink = effects.exit(types.labelLink);
     return after;
   }
   function after(code) {
-    return code === codes.caret && "_hiddenFootnoteSupport" in self2.parser.constructs ? nok(code) : ok2(code);
+    if (code === codes.caret && "_hiddenFootnoteSupport" in self2.parser.constructs) {
+      return nok(code);
+    }
+    self2._labelStarts = self2._labelStarts || [];
+    self2._labelStarts.push(labelLink);
+    return ok2(code);
   }
 }
 var labelStartLink;
@@ -11237,8 +11593,68 @@ var init_list2 = __esm(() => {
   indentConstruct = { partial: true, tokenize: tokenizeIndent };
 });
 
+// ../../node_modules/micromark-util-edit-map/dev/index.js
+class EditMap {
+  constructor() {
+    this.index = new Map;
+    this.map = [];
+  }
+  add(index, remove, add) {
+    addImplementation(this, index, remove, add, false);
+  }
+  addBefore(index, remove, add) {
+    addImplementation(this, index, remove, add, true);
+  }
+  consume(events) {
+    this.map.sort(function(a, b) {
+      return a[0] - b[0];
+    });
+    if (this.map.length === 0) {
+      return;
+    }
+    let index = this.map.length;
+    const vecs = [];
+    while (index > 0) {
+      index -= 1;
+      vecs.push(events.slice(this.map[index][0] + this.map[index][1]), this.map[index][2]);
+      events.length = this.map[index][0];
+    }
+    vecs.push(events.slice());
+    events.length = 0;
+    let slice = vecs.pop();
+    while (slice) {
+      for (const element of slice) {
+        events.push(element);
+      }
+      slice = vecs.pop();
+    }
+    this.map.length = 0;
+    this.index.clear();
+  }
+}
+function addImplementation(editMap, at, remove, add, before) {
+  if (remove === 0 && add.length === 0) {
+    return;
+  }
+  const existing = editMap.index.get(at);
+  if (existing) {
+    existing[1] += remove;
+    if (before) {
+      add.push(...existing[2]);
+      existing[2] = add;
+    } else {
+      existing[2].push(...add);
+    }
+    return;
+  }
+  const change = [at, remove, add];
+  editMap.map.push(change);
+  editMap.index.set(at, change);
+}
+
 // ../../node_modules/micromark-core-commonmark/dev/lib/setext-underline.js
 function resolveToSetextUnderline(events, context) {
+  const editMap = new EditMap;
   let index = events.length;
   let content;
   let text;
@@ -11254,7 +11670,7 @@ function resolveToSetextUnderline(events, context) {
       }
     } else {
       if (events[index][1].type === types.content) {
-        events.splice(index, 1);
+        editMap.add(index, 1, []);
       }
       if (!definition && events[index][1].type === types.definition) {
         definition = index;
@@ -11272,13 +11688,14 @@ function resolveToSetextUnderline(events, context) {
   };
   events[text][1].type = types.setextHeadingText;
   if (definition) {
-    events.splice(text, 0, ["enter", heading, context]);
-    events.splice(definition + 1, 0, ["exit", events[content][1], context]);
+    editMap.add(text, 0, [["enter", heading, context]]);
+    editMap.add(definition + 1, 0, [["exit", events[content][1], context]]);
     events[content][1].end = { ...events[definition][1].end };
   } else {
     events[content][1] = heading;
   }
-  events.push(["exit", heading, context]);
+  editMap.add(events.length, 0, [["exit", heading, context]]);
+  editMap.consume(events);
   return events;
 }
 function tokenizeSetextUnderline(effects, ok2, nok) {
@@ -11732,7 +12149,7 @@ function gfmStrikethrough(options) {
 var init_syntax4 = __esm(() => {
   init_development();
   init_dev9();
-  init_dev2();
+  init_dev4();
   init_default();
 });
 
@@ -11742,12 +12159,13 @@ var init_dev17 = __esm(() => {
 });
 
 // ../../node_modules/micromark-extension-gfm-table/dev/lib/edit-map.js
-class EditMap {
+class EditMap2 {
   constructor() {
     this.map = [];
+    this.index = new Map;
   }
   add(index, remove, add) {
-    addImplementation(this, index, remove, add);
+    addImplementation2(this, index, remove, add);
   }
   consume(events) {
     this.map.sort(function(a, b) {
@@ -11773,22 +12191,22 @@ class EditMap {
       slice = vecs.pop();
     }
     this.map.length = 0;
+    this.index.clear();
   }
 }
-function addImplementation(editMap, at, remove, add) {
-  let index = 0;
+function addImplementation2(editMap, at, remove, add) {
   if (remove === 0 && add.length === 0) {
     return;
   }
-  while (index < editMap.map.length) {
-    if (editMap.map[index][0] === at) {
-      editMap.map[index][1] += remove;
-      editMap.map[index][2].push(...add);
-      return;
-    }
-    index += 1;
+  const existing = editMap.index.get(at);
+  if (existing) {
+    existing[1] += remove;
+    existing[2].push(...add);
+    return;
   }
-  editMap.map.push([at, remove, add]);
+  const change = [at, remove, add];
+  editMap.map.push(change);
+  editMap.index.set(at, change);
 }
 
 // ../../node_modules/micromark-extension-gfm-table/dev/lib/infer.js
@@ -11839,11 +12257,12 @@ function tokenizeTable(effects, ok2, nok) {
   function start(code) {
     let index = self2.events.length - 1;
     while (index > -1) {
-      const type = self2.events[index][1].type;
-      if (type === types.lineEnding || type === types.linePrefix)
+      const { type } = self2.events[index][1];
+      if (type === types.lineEnding || type === types.linePrefix) {
         index--;
-      else
+      } else {
         break;
+      }
     }
     const tail = index > -1 ? self2.events[index][1].type : null;
     const next = tail === "tableHead" || tail === "tableRow" ? bodyRowStart : headRowBefore;
@@ -12058,7 +12477,7 @@ function resolveTable(events, context) {
   let currentTable;
   let currentBody;
   let currentCell;
-  const map = new EditMap;
+  const map = new EditMap2;
   while (++index < events.length) {
     const event = events[index];
     const token = event[1];
@@ -20952,7 +21371,7 @@ function element(state, node) {
   while (++index < node.attrs.length) {
     const attribute = node.attrs[index];
     const name = (attribute.prefix ? attribute.prefix + ":" : "") + attribute.name;
-    if (!own7.call(proto, name)) {
+    if (!own8.call(proto, name)) {
       properties[name] = attribute.value;
     }
   }
@@ -20994,7 +21413,7 @@ function createLocation(state, node, location) {
       let key;
       if (location.attrs) {
         for (key in location.attrs) {
-          if (own7.call(location.attrs, key)) {
+          if (own8.call(location.attrs, key)) {
             properties[find(state.schema, key).property] = position2(location.attrs[key]);
           }
         }
@@ -21027,14 +21446,14 @@ function position2(loc) {
 function point2(point) {
   return point.line && point.column ? point : undefined;
 }
-var own7, proto;
+var own8, proto;
 var init_lib26 = __esm(() => {
   init_development();
   init_hastscript();
   init_property_information();
   init_vfile_location();
   init_web_namespaces();
-  own7 = {}.hasOwnProperty;
+  own8 = {}.hasOwnProperty;
   proto = Object.prototype;
 });
 
@@ -29153,8 +29572,10 @@ function initializeDocument(effects) {
         self2.events[index][1].end = { ...point };
         index++;
       }
-      splice(self2.events, indexBeforeFlow + 1, 0, self2.events.slice(indexBeforeExits));
-      self2.events.length = index;
+      const editMap = new EditMap;
+      editMap.add(indexBeforeFlow + 1, 0, self2.events.slice(indexBeforeExits));
+      editMap.add(indexBeforeExits, index - indexBeforeExits, []);
+      editMap.consume(self2.events);
       return checkNewContainers(code);
     }
     return start(code);
@@ -29173,8 +29594,9 @@ function initializeDocument(effects) {
     return effects.check(containerConstruct, thereIsANewContainer, thereIsNoNewContainer)(code);
   }
   function thereIsANewContainer(code) {
-    if (childFlow)
+    if (childFlow) {
       closeFlow();
+    }
     exitContainers(continued);
     return documentContinued(code);
   }
@@ -29196,8 +29618,9 @@ function initializeDocument(effects) {
   }
   function flowStart(code) {
     if (code === codes.eof) {
-      if (childFlow)
+      if (childFlow) {
         closeFlow();
+      }
       exitContainers(0);
       effects.consume(code);
       return;
@@ -29230,11 +29653,13 @@ function initializeDocument(effects) {
   function writeToChild(token, endOfFile) {
     ok(childFlow, "expected `childFlow` to be defined when continuing");
     const stream = self2.sliceStream(token);
-    if (endOfFile)
+    if (endOfFile) {
       stream.push(null);
+    }
     token.previous = childToken;
-    if (childToken)
+    if (childToken) {
       childToken.next = token;
+    }
     childToken = token;
     childFlow.defineSkip(token.start);
     childFlow.write(stream);
@@ -29265,8 +29690,10 @@ function initializeDocument(effects) {
         self2.events[index][1].end = { ...point };
         index++;
       }
-      splice(self2.events, indexBeforeFlow + 1, 0, self2.events.slice(indexBeforeExits));
-      self2.events.length = index;
+      const editMap = new EditMap;
+      editMap.add(indexBeforeFlow + 1, 0, self2.events.slice(indexBeforeExits));
+      editMap.add(indexBeforeExits, index - indexBeforeExits, []);
+      editMap.consume(self2.events);
     }
   }
   function exitContainers(size) {
@@ -29297,7 +29724,6 @@ var init_document = __esm(() => {
   init_development();
   init_dev5();
   init_dev();
-  init_dev9();
   init_default();
   document2 = { tokenize: initializeDocument };
   containerConstruct = { tokenize: tokenizeContainer };
@@ -29417,6 +29843,7 @@ function createResolver(extraResolver) {
   }
 }
 function resolveAllLineSuffixes(events, context) {
+  const editMap = new EditMap;
   let eventIndex = 0;
   while (++eventIndex <= events.length) {
     if ((eventIndex === events.length || events[eventIndex][1].type === types.lineEnding) && events[eventIndex - 1][1].type === types.data) {
@@ -29434,8 +29861,9 @@ function resolveAllLineSuffixes(events, context) {
             size++;
             bufferIndex--;
           }
-          if (bufferIndex)
+          if (bufferIndex) {
             break;
+          }
           bufferIndex = -1;
         } else if (chunk === codes.horizontalTab) {
           tabs = true;
@@ -29464,13 +29892,16 @@ function resolveAllLineSuffixes(events, context) {
         if (data.start.offset === data.end.offset) {
           Object.assign(data, token);
         } else {
-          events.splice(eventIndex, 0, ["enter", token, context], ["exit", token, context]);
-          eventIndex += 2;
+          editMap.add(eventIndex, 0, [
+            ["enter", token, context],
+            ["exit", token, context]
+          ]);
         }
       }
       eventIndex++;
     }
   }
+  editMap.consume(events);
   return events;
 }
 var resolver, string, text3;
@@ -29544,15 +29975,15 @@ var init_constructs = __esm(() => {
     [codes.carriageReturnLineFeed]: lineEnding,
     [codes.exclamationMark]: labelStartImage,
     [codes.ampersand]: characterReference,
-    [codes.asterisk]: attention,
+    [codes.asterisk]: attention3,
     [codes.lessThan]: [autolink, htmlText],
     [codes.leftSquareBracket]: labelStartLink,
     [codes.backslash]: [hardBreakEscape, characterEscape],
     [codes.rightSquareBracket]: labelEnd,
-    [codes.underscore]: attention,
+    [codes.underscore]: attention3,
     [codes.graveAccent]: codeText
   };
-  insideSpan = { null: [attention, resolver] };
+  insideSpan = { null: [attention3, resolver] };
   attentionMarkers = { null: [codes.asterisk, codes.underscore] };
   disable = { null: [] };
 });
@@ -30357,11 +30788,10 @@ function createTokenizer(parser, initialize, from) {
     debug("position: define skip: `%j`", point);
   }
   function main() {
-    let chunkIndex;
     while (point._index < chunks.length) {
       const chunk = chunks[point._index];
       if (typeof chunk === "string") {
-        chunkIndex = point._index;
+        const chunkIndex = point._index;
         if (point._bufferIndex < 0) {
           point._bufferIndex = 0;
         }
@@ -30570,7 +31000,7 @@ function serializeChunks(chunks, expandTabs) {
     let value;
     if (typeof chunk === "string") {
       value = chunk;
-    } else
+    } else {
       switch (chunk) {
         case codes.carriageReturn: {
           value = values.cr;
@@ -30589,8 +31019,9 @@ function serializeChunks(chunks, expandTabs) {
           break;
         }
         case codes.virtualSpace: {
-          if (!expandTabs && atTab)
+          if (!expandTabs && atTab) {
             continue;
+          }
           value = values.space;
           break;
         }
@@ -30599,6 +31030,7 @@ function serializeChunks(chunks, expandTabs) {
           value = String.fromCharCode(chunk);
         }
       }
+    }
     atTab = chunk === codes.horizontalTab;
     result.push(value);
   }
@@ -30663,14 +31095,9 @@ function preprocess() {
   let atCarriageReturn;
   return preprocessor;
   function preprocessor(value, encoding, end) {
-    const chunks = [];
-    let match;
-    let next;
-    let startPosition;
-    let endPosition;
-    let code;
     value = buffer + (typeof value === "string" ? value.toString() : new TextDecoder(encoding || undefined).decode(value));
-    startPosition = 0;
+    const chunks = [];
+    let startPosition = 0;
     buffer = "";
     if (start) {
       if (value.charCodeAt(0) === codes.byteOrderMarker) {
@@ -30680,9 +31107,9 @@ function preprocess() {
     }
     while (startPosition < value.length) {
       search2.lastIndex = startPosition;
-      match = search2.exec(value);
-      endPosition = match && match.index !== undefined ? match.index : value.length;
-      code = value.charCodeAt(endPosition);
+      const match = search2.exec(value);
+      const endPosition = match && match.index !== undefined ? match.index : value.length;
+      const code = value.charCodeAt(endPosition);
       if (!match) {
         buffer = value.slice(startPosition);
         break;
@@ -30706,10 +31133,11 @@ function preprocess() {
             break;
           }
           case codes.ht: {
-            next = Math.ceil(column / constants.tabSize) * constants.tabSize;
+            const next = Math.ceil(column / constants.tabSize) * constants.tabSize;
             chunks.push(codes.horizontalTab);
-            while (column++ < next)
+            while (column++ < next) {
               chunks.push(codes.virtualSpace);
+            }
             break;
           }
           case codes.lf: {
@@ -30726,10 +31154,12 @@ function preprocess() {
       startPosition = endPosition + 1;
     }
     if (end) {
-      if (atCarriageReturn)
+      if (atCarriageReturn) {
         chunks.push(codes.carriageReturn);
-      if (buffer)
+      }
+      if (buffer) {
         chunks.push(buffer);
+      }
       chunks.push(codes.eof);
     }
     return chunks;
@@ -30758,6 +31188,8 @@ function fromMarkdown(value, encoding, options) {
 }
 function compiler(options) {
   const config = {
+    afterExit: [],
+    beforeEnter: [],
     transforms: [],
     canContainEols: ["emphasis", "fragment", "heading", "paragraph", "strong"],
     enter: {
@@ -30859,7 +31291,7 @@ function compiler(options) {
   const data = {};
   return compile;
   function compile(events) {
-    let tree = { type: "root", children: [] };
+    let tree = { type: "root", children: [], position: undefined };
     const context = {
       stack: [tree],
       tokenStack: [],
@@ -30871,23 +31303,32 @@ function compiler(options) {
       data
     };
     const listStack = [];
+    const prepared = [];
     let index = -1;
     while (++index < events.length) {
+      prepared.push(events[index]);
       if (events[index][1].type === types.listOrdered || events[index][1].type === types.listUnordered) {
         if (events[index][0] === "enter") {
-          listStack.push(index);
+          listStack.push(prepared.length - 1);
         } else {
           const tail = listStack.pop();
           ok(typeof tail === "number", "expected list to be open");
-          index = prepareList(events, tail, index);
+          prepareList(prepared, tail);
         }
       }
     }
+    events = prepared;
     index = -1;
     while (++index < events.length) {
       const handler = config[events[index][0]];
-      if (own8.call(handler, events[index][1].type)) {
-        handler[events[index][1].type].call(Object.assign({ sliceSerialize: events[index][2].sliceSerialize }, context), events[index][1]);
+      if (events[index][0] === "enter" && config.beforeEnter.length > 0) {
+        callListeners(config.beforeEnter, { ...context, sliceSerialize: events[index][2].sliceSerialize }, events[index][1]);
+      }
+      if (own9.call(handler, events[index][1].type)) {
+        handler[events[index][1].type].call({ ...context, sliceSerialize: events[index][2].sliceSerialize }, events[index][1]);
+      }
+      if (events[index][0] === "exit" && config.afterExit.length > 0) {
+        callListeners(config.afterExit, { ...context, sliceSerialize: events[index][2].sliceSerialize }, events[index][1]);
       }
     }
     if (context.tokenStack.length > 0) {
@@ -30905,7 +31346,14 @@ function compiler(options) {
     }
     return tree;
   }
-  function prepareList(events, start, length) {
+  function callListeners(listeners, context, token) {
+    let index = -1;
+    while (++index < listeners.length) {
+      listeners[index].call(context, token);
+    }
+  }
+  function prepareList(events, start) {
+    const end = events.length - 1;
     let index = start - 1;
     let containerBalance = -1;
     let listSpread = false;
@@ -30913,7 +31361,8 @@ function compiler(options) {
     let lineIndex;
     let firstBlankLineIndex;
     let atMarker;
-    while (++index <= length) {
+    const insertions = [];
+    while (++index <= end) {
       const event = events[index];
       switch (event[1].type) {
         case types.listUnordered:
@@ -30970,9 +31419,10 @@ function compiler(options) {
             listItem._spread = true;
           }
           listItem.end = Object.assign({}, lineIndex ? events[lineIndex][1].start : event[1].end);
-          events.splice(lineIndex || index, 0, ["exit", listItem, event[2]]);
-          index++;
-          length++;
+          insertions.push({
+            at: lineIndex || index,
+            event: ["exit", listItem, event[2]]
+          });
         }
         if (event[1].type === types.listItemPrefix) {
           const item = {
@@ -30982,16 +31432,23 @@ function compiler(options) {
             end: undefined
           };
           listItem = item;
-          events.splice(index, 0, ["enter", item, event[2]]);
-          index++;
-          length++;
+          insertions.push({ at: index, event: ["enter", item, event[2]] });
           firstBlankLineIndex = undefined;
           atMarker = true;
         }
       }
     }
+    const listEvents = events.splice(start);
+    let insertion = 0;
+    index = -1;
+    while (++index < listEvents.length) {
+      while (insertion < insertions.length && insertions[insertion].at === start + index) {
+        events.push(insertions[insertion++].event);
+      }
+      events.push(listEvents[index]);
+    }
+    ok(insertion === insertions.length, "expected insertions to be merged");
     events[start][1]._spread = listSpread;
-    return length;
   }
   function opener(create, and) {
     return open;
@@ -31031,7 +31488,8 @@ function compiler(options) {
     const open = this.tokenStack.pop();
     if (!open) {
       throw new Error("Cannot close `" + token.type + "` (" + stringifyPosition({ start: token.start, end: token.end }) + "): it’s not open");
-    } else if (open[0].type !== token.type) {
+    }
+    if (open[0].type !== token.type) {
       if (onExitError) {
         onExitError.call(this, token, open[0]);
       } else {
@@ -31328,13 +31786,19 @@ function compiler(options) {
     node.url = "mailto:" + this.sliceSerialize(token);
   }
   function blockQuote() {
-    return { type: "blockquote", children: [] };
+    return { type: "blockquote", children: [], position: undefined };
   }
   function codeFlow() {
-    return { type: "code", lang: null, meta: null, value: "" };
+    return {
+      type: "code",
+      lang: null,
+      meta: null,
+      value: "",
+      position: undefined
+    };
   }
   function codeText() {
-    return { type: "inlineCode", value: "" };
+    return { type: "inlineCode", value: "", position: undefined };
   }
   function definition() {
     return {
@@ -31342,30 +31806,44 @@ function compiler(options) {
       identifier: "",
       label: null,
       title: null,
-      url: ""
+      url: "",
+      position: undefined
     };
   }
   function emphasis() {
-    return { type: "emphasis", children: [] };
+    return { type: "emphasis", children: [], position: undefined };
   }
   function heading() {
     return {
       type: "heading",
       depth: 0,
-      children: []
+      children: [],
+      position: undefined
     };
   }
   function hardBreak() {
-    return { type: "break" };
+    return { type: "break", position: undefined };
   }
   function html() {
-    return { type: "html", value: "" };
+    return { type: "html", value: "", position: undefined };
   }
   function image() {
-    return { type: "image", title: null, url: "", alt: null };
+    return {
+      type: "image",
+      title: null,
+      url: "",
+      alt: null,
+      position: undefined
+    };
   }
   function link() {
-    return { type: "link", title: null, url: "", children: [] };
+    return {
+      type: "link",
+      title: null,
+      url: "",
+      children: [],
+      position: undefined
+    };
   }
   function list(token) {
     return {
@@ -31373,7 +31851,8 @@ function compiler(options) {
       ordered: token.type === "listOrdered",
       start: null,
       spread: token._spread,
-      children: []
+      children: [],
+      position: undefined
     };
   }
   function listItem(token) {
@@ -31381,20 +31860,21 @@ function compiler(options) {
       type: "listItem",
       spread: token._spread,
       checked: null,
-      children: []
+      children: [],
+      position: undefined
     };
   }
   function paragraph() {
-    return { type: "paragraph", children: [] };
+    return { type: "paragraph", children: [], position: undefined };
   }
   function strong() {
-    return { type: "strong", children: [] };
+    return { type: "strong", children: [], position: undefined };
   }
   function text() {
-    return { type: "text", value: "" };
+    return { type: "text", value: "", position: undefined };
   }
   function thematicBreak() {
-    return { type: "thematicBreak" };
+    return { type: "thematicBreak", position: undefined };
   }
 }
 function point3(d) {
@@ -31414,7 +31894,7 @@ function configure2(combined, extensions) {
 function extension(combined, extension) {
   let key;
   for (key in extension) {
-    if (own8.call(extension, key)) {
+    if (own9.call(extension, key)) {
       switch (key) {
         case "canContainEols": {
           const right = extension[key];
@@ -31430,6 +31910,14 @@ function extension(combined, extension) {
           }
           break;
         }
+        case "afterExit":
+        case "beforeEnter": {
+          const right = extension[key];
+          if (right) {
+            combined[key].push(right);
+          }
+          break;
+        }
         case "enter":
         case "exit": {
           const right = extension[key];
@@ -31445,22 +31933,21 @@ function extension(combined, extension) {
 function defaultOnError(left, right) {
   if (left) {
     throw new Error("Cannot close `" + left.type + "` (" + stringifyPosition({ start: left.start, end: left.end }) + "): a different token (`" + right.type + "`, " + stringifyPosition({ start: right.start, end: right.end }) + ") is open");
-  } else {
-    throw new Error("Cannot close document, a token (`" + right.type + "`, " + stringifyPosition({ start: right.start, end: right.end }) + ") is still open");
   }
+  throw new Error("Cannot close document, a token (`" + right.type + "`, " + stringifyPosition({ start: right.start, end: right.end }) + ") is still open");
 }
-var own8;
+var own9;
 var init_lib29 = __esm(() => {
   init_development();
   init_mdast_util_to_string();
   init_dev20();
+  init_dev2();
   init_dev3();
-  init_dev4();
   init_dev8();
   init_default();
   init_decode_named_character_reference();
   init_unist_util_stringify_position();
-  own8 = {}.hasOwnProperty;
+  own9 = {}.hasOwnProperty;
 });
 
 // ../../node_modules/mdast-util-from-markdown/dev/index.js
@@ -31621,25 +32108,25 @@ function toMatters(options) {
 function matter(option) {
   let result = option;
   if (typeof result === "string") {
-    if (!own9.call(markers, result)) {
+    if (!own10.call(markers, result)) {
       throw fault("Missing matter definition for `%s`", result);
     }
     result = { type: result, marker: markers[result] };
   } else if (typeof result !== "object") {
     throw fault("Expected matter to be an object, not `%j`", result);
   }
-  if (!own9.call(result, "type")) {
+  if (!own10.call(result, "type")) {
     throw fault("Missing `type` in matter `%j`", result);
   }
-  if (!own9.call(result, "fence") && !own9.call(result, "marker")) {
+  if (!own10.call(result, "fence") && !own10.call(result, "marker")) {
     throw fault("Missing `marker` or `fence` in matter `%j`", result);
   }
   return result;
 }
-var own9, markers;
+var own10, markers;
 var init_to_matters = __esm(() => {
   init_fault();
-  own9 = {}.hasOwnProperty;
+  own10 = {}.hasOwnProperty;
   markers = { yaml: "-", toml: "+" };
 });
 
@@ -39288,6 +39775,148 @@ var require_dist2 = __commonJS(function(exports, module) {
   module.exports = plugin;
 });
 
+// src/alerts.ts
+function normalizeAlerts(config, where = "alerts") {
+  if (config === false) {
+    return null;
+  }
+  const types = new Map(Object.keys(DEFAULT_ALERT_TITLES).map((type) => [type, null]));
+  const disabled = new Set;
+  if (config === undefined || config === true) {
+    return { disabled, types };
+  }
+  if (typeof config !== "object" || config === null || Array.isArray(config)) {
+    throw new TypeError(`${where}: expected an object mapping alert types to element names, or false`);
+  }
+  for (const [type, element] of Object.entries(config)) {
+    const key = type.toLowerCase();
+    if (!/^[a-z][\w-]*$/.test(key)) {
+      throw new TypeError(`${where}: "${type}" is not a valid alert type name`);
+    }
+    if (element === false || element === null) {
+      types.delete(key);
+      disabled.add(key);
+    } else if (element === true) {
+      types.set(key, null);
+    } else if (typeof element === "string" && TAG_NAME.test(element)) {
+      types.set(key, element);
+    } else {
+      throw new TypeError(`${where}.${type}: expected an element name such as "doc-note", true or false, got ${JSON.stringify(element)}`);
+    }
+  }
+  return { disabled, types };
+}
+function inlineText(nodes) {
+  let out = "";
+  for (const node of nodes) {
+    if (typeof node.value === "string") {
+      out += node.value;
+    } else if (node.children) {
+      out += inlineText(node.children);
+    }
+  }
+  return out;
+}
+function textNode(value) {
+  return { type: "text", value };
+}
+function markerOf(paragraph) {
+  const [first] = paragraph.children ?? [];
+  if (first?.type !== "text" || typeof first.value !== "string") {
+    return null;
+  }
+  const match = MARKER2.exec(first.value);
+  if (!match) {
+    return null;
+  }
+  const rest = first.value.slice(match[0].length);
+  if (rest !== "" && !/^[ \t\r\n]/.test(rest)) {
+    return null;
+  }
+  return { rest, type: match[1].toLowerCase() };
+}
+function splitMarker(paragraph, settings) {
+  const marker = markerOf(paragraph);
+  if (!marker || !settings.types.has(marker.type)) {
+    return null;
+  }
+  const { type, rest } = marker;
+  const [, ...siblings] = paragraph.children ?? [];
+  const title = [];
+  const body = [];
+  let inTitle = true;
+  const take = (node) => {
+    if (inTitle && node.type === "break") {
+      inTitle = false;
+    } else if (inTitle && node.type === "text" && typeof node.value === "string") {
+      const lineEnd = LINE_END.exec(node.value);
+      if (lineEnd === null) {
+        title.push(node);
+      } else {
+        title.push(textNode(node.value.slice(0, lineEnd.index)));
+        inTitle = false;
+        body.push(textNode(node.value.slice(lineEnd.index + lineEnd[0].length)));
+      }
+    } else {
+      (inTitle ? title : body).push(node);
+    }
+  };
+  take(textNode(rest.replace(/^[ \t]+/, "")));
+  for (const node of siblings) {
+    take(node);
+  }
+  const trimmed = title.filter((node) => !(node.type === "text" && node.value === ""));
+  const text = inlineText(trimmed);
+  return {
+    body: body.filter((node) => !(node.type === "text" && node.value === "")),
+    title: text.trim() === "" ? [] : trimmed,
+    type
+  };
+}
+function transformAlerts(tree, settings, onUnknown) {
+  const { children } = tree;
+  if (!children) {
+    return;
+  }
+  for (const [i, child] of children.entries()) {
+    if (child.type === "blockquote") {
+      const [paragraph, ...rest] = child.children ?? [];
+      const split = paragraph?.type === "paragraph" ? splitMarker(paragraph, settings) : null;
+      if (split) {
+        const bodyParagraph = split.body.length > 0 && inlineText(split.body).trim() !== "" ? [{ children: split.body, type: "paragraph" }] : [];
+        const alert = {
+          alert: split.type,
+          children: [...bodyParagraph, ...rest],
+          element: settings.types.get(split.type) ?? null,
+          titleNodes: split.title.length > 0 ? split.title : null,
+          type: ALERT_NODE
+        };
+        children[i] = alert;
+        transformAlerts(alert, settings, onUnknown);
+        continue;
+      }
+      const unknown = paragraph?.type === "paragraph" ? markerOf(paragraph) : null;
+      if (unknown && !settings.disabled.has(unknown.type)) {
+        onUnknown?.(unknown.type);
+      }
+    }
+    transformAlerts(child, settings, onUnknown);
+  }
+}
+var DEFAULT_ALERT_TITLES, ALERT_NODE = "jxAlert", TAG_NAME, MARKER2, LINE_END;
+var init_alerts = __esm(() => {
+  DEFAULT_ALERT_TITLES = {
+    caution: "Caution",
+    important: "Important",
+    note: "Note",
+    tip: "Tip",
+    warning: "Warning"
+  };
+  TAG_NAME = /^[A-Za-z][\w.-]*$/;
+  MARKER2 = /^\[!([A-Za-z][\w-]*)\][+-]?/;
+  LINE_END = /\r?\n/;
+});
+
 // src/transpile.ts
 function jxKey(key) {
   if (JX_DOLLAR_KEYS.has(key)) {
@@ -39360,6 +39989,9 @@ function mdastNodeToJx(node) {
   if (node.type === "containerDirective" || node.type === "leafDirective" || node.type === "textDirective") {
     return directiveToJx(node);
   }
+  if (node.type === ALERT_NODE) {
+    return alertToJx(node);
+  }
   if (node.type === "text") {
     return node.value ?? null;
   }
@@ -39472,6 +40104,37 @@ function mdastNodeToJx(node) {
   }
   return el;
 }
+function alertToJx(node) {
+  const body = convertChildren(node.children ?? []);
+  if (node.element) {
+    const attributes = { "data-alert": node.alert };
+    if (node.titleNodes) {
+      attributes["data-title"] = inlineText(node.titleNodes).trim();
+    }
+    const el = { attributes, tagName: node.element };
+    if (body.length > 0) {
+      el.children = body;
+    }
+    return el;
+  }
+  const title = { className: "jx-alert-title", tagName: "p" };
+  if (node.titleNodes) {
+    const inline = convertChildren(node.titleNodes);
+    if (inline.length === 1 && typeof inline[0] === "string") {
+      [title.textContent] = inline;
+    } else {
+      title.children = inline;
+    }
+  } else {
+    title.textContent = DEFAULT_ALERT_TITLES[node.alert] ?? `${node.alert.charAt(0).toUpperCase()}${node.alert.slice(1)}`;
+  }
+  return {
+    attributes: { "data-alert": node.alert, role: "note" },
+    children: [title, ...body],
+    className: `jx-alert jx-alert-${node.alert}`,
+    tagName: "div"
+  };
+}
 function directiveToJx(node) {
   if (PROTOTYPE_DIRECTIVE_NAMES.has(node.name)) {
     return prototypeDirectiveToJx(node);
@@ -39665,6 +40328,7 @@ var init_transpile = __esm(() => {
   init_remark_gfm();
   init_remark_directive();
   init_html_to_jx();
+  init_alerts();
   init_html_to_jx();
   import_remark_parse_frontmatter = __toESM(require_dist2(), 1);
   JX_DOLLAR_KEYS = new Set(["prototype", "ref", "component", "props", "switch", "elements"]);