@jxsuite/parser 4.1.2 → 4.3.0

package/dist/serialize.js

@@ -892,6 +892,9 @@ function isRef(value) {
 function isNodeObject(value) {
   return isJsonObject(value);
 }
+function isTemplateString(value) {
+  return typeof value === "string" && value.includes("${");
+}
 function isPlainTagName(tagName) {
   return typeof tagName === "string";
 }
@@ -9682,10 +9685,402 @@ function checkEmphasis(state) {
   return marker;
 }
 
+// ../../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-character-reference.js
+function encodeCharacterReference(code) {
+  return "&#x" + code.toString(16).toUpperCase() + ";";
+}
+
+// ../../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_dev6();
+});
+
+// ../../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;
+  }
+  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_html_kind = __esm(() => {
+  init_dev4();
+  init_micromark_util_html_tag_name();
+});
+
+// ../../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));
+  if (start) {
+    token.value = reference + token.value.slice(character.length);
+  } else {
+    let value = token.value.slice(0, token.value.length - character.length);
+    let escapes = 0;
+    while (value.charCodeAt(value.length - 1 - escapes) === 92) {
+      escapes++;
+    }
+    if (escapes % 2)
+      value += "\\";
+    token.value = value + 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) {
+  const openersByMarker = new Map;
+  for (const closer of runs) {
+    const marker = closer.tokens[0].value.charAt(0);
+    let openers = openersByMarker.get(marker);
+    if (!openers) {
+      openers = [];
+      openersByMarker.set(marker, openers);
+    }
+    let open = closer.close ? openers.length : 0;
+    while (open-- && closer.start < closer.end) {
+      const opener = openers[open];
+      const openerSize = opener.end - opener.start;
+      const closerSize = closer.end - closer.start;
+      if (closer.split ? (opener.close || closer.open) && closerSize % 3 && !((openerSize + closerSize) % 3) : openerSize !== opener.markers.length || openerSize !== closerSize) {
+        continue;
+      }
+      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;
+      if (opener.start === opener.end)
+        openers.splice(open, 1);
+      open = openers.length;
+    }
+    if (closer.open && closer.start < closer.end)
+      openers.push(closer);
+  }
+}
+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;
+  indexStack.push(-1);
+  let tracker = state.createTracker(info);
+  while (++index < children.length) {
+    const child = children[index];
+    let after;
+    indexStack[indexStack.length - 1] = index;
+    if (index + 1 < children.length) {
+      let handle = state.handle.handlers[children[index + 1].type];
+      if (handle && handle.peek)
+        handle = handle.peek;
+      after = handle ? firstCharacter(handle(children[index + 1], parent, state, {
+        before: "",
+        after: "",
+        ...tracker.current()
+      })) : "";
+    } else {
+      after = info.after;
+    }
+    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(serialize(results, info.before, info.after));
+    }
+    const handle = state.handle.handlers[child.type];
+    if (handle && handle.attention) {
+      const item = attentionItem(child, handle.attention, state, tracker);
+      results.push(item);
+      before = lastCharacter(item.sequences[0]);
+    } else {
+      const value = state.handle(child, parent, state, {
+        ...tracker.current(),
+        after,
+        before
+      });
+      if (!value)
+        continue;
+      tracker.move(value);
+      results.push(value);
+      before = lastCharacter(value);
+    }
+  }
+  indexStack.pop();
+  return results;
+}
+function attentionItem(node, attention, state, tracker) {
+  const { construct, markers, sizes } = attention(node, state);
+  const sequences = attentionSequences(node.type, markers, sizes);
+  const sequence = sequences[0];
+  const exit = state.enter(construct);
+  tracker.move(sequence);
+  const children = phrasing2(node, state, {
+    ...tracker.current(),
+    before: sequence,
+    after: sequence
+  });
+  tracker.move(serialize(children, sequence, sequence));
+  tracker.move(sequence);
+  exit();
+  return { children, sequences };
+}
+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 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;
+    }
+    chosen = next.chosen;
+    tokens = next.tokens;
+    mistake = next.mistake;
+  }
+  let result = "";
+  for (const token of tokens)
+    result += token.value;
+  return result;
+}
+var builtins;
+var init_container_phrasing = __esm(() => {
+  init_dev4();
+  init_dev6();
+  init_encode_info();
+  init_html_kind();
+  builtins = new Map([
+    ["*", false],
+    ["_", true]
+  ]);
+});
+
 // ../../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);
+  const item = attentionItem(node, attention2, state, state.createTracker(info));
+  const value = serialize([item], info.before, info.after);
   exit();
   return value;
 }
@@ -9701,15 +10096,11 @@ function peek(_, _1, state) {
   return state.options.emphasis || "*";
 }
 var init_emphasis = __esm(() => {
+  init_container_phrasing();
   emphasis.attention = attention2;
   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/unist-util-visit/node_modules/unist-util-visit-parents/lib/color.node.js
 function color(d) {
   return "\x1B[33m" + d + "\x1B[39m";
@@ -10094,14 +10485,27 @@ function link(node, _, state, info) {
   const exit = state.enter("link");
   let subexit = state.enter("label");
   let value = tracker.move("[");
-  value += tracker.move(state.containerPhrasing(node, {
+  const text = state.containerPhrasing(node, {
     before: value,
     after: "](",
     ...tracker.current()
-  }));
-  value += tracker.move("](");
+  });
+  value += tracker.move(text);
   subexit();
-  if (!node.url && node.title || /[\0- \u007F]/.test(node.url)) {
+  value += tracker.move("](");
+  const enclose = /[\0- \u007F]/.test(node.url);
+  const last = info.before.charAt(info.before.length - 1);
+  let title = node.title || undefined;
+  if (!title && !enclose && (last === `
+` || last === "\r")) {
+    let index = 0;
+    while (index < text.length && text.charCodeAt(index) !== 93) {
+      index += text.charCodeAt(index) === 92 ? 2 : 1;
+    }
+    if (text.charCodeAt(index + 1) === 58)
+      title = "";
+  }
+  if (!node.url && typeof title === "string" || enclose) {
     subexit = state.enter("destinationLiteral");
     value += tracker.move("<");
     value += tracker.move(state.safe(node.url, { before: value, after: ">", ...tracker.current() }));
@@ -10110,15 +10514,15 @@ function link(node, _, state, info) {
     subexit = state.enter("destinationRaw");
     value += tracker.move(state.safe(node.url, {
       before: value,
-      after: node.title ? " " : ")",
+      after: typeof title === "string" ? " " : ")",
       ...tracker.current()
     }));
   }
   subexit();
-  if (node.title) {
+  if (typeof title === "string") {
     subexit = state.enter(`title${suffix}`);
     value += tracker.move(" " + quote);
-    value += tracker.move(state.safe(node.title, {
+    value += tracker.move(state.safe(title, {
       before: value,
       after: quote,
       ...tracker.current()
@@ -10336,7 +10740,8 @@ function checkStrong(state) {
 // ../../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);
+  const item = attentionItem(node, attention3, state, state.createTracker(info));
+  const value = serialize([item], info.before, info.after);
   exit();
   return value;
 }
@@ -10352,6 +10757,7 @@ function peek2(_, _1, state) {
   return state.options.strong || "*";
 }
 var init_strong = __esm(() => {
+  init_container_phrasing();
   strong.attention = attention3;
   strong.peek = peek2;
 });
@@ -10359,7 +10765,7 @@ var init_strong = __esm(() => {
 // ../../node_modules/mdast-util-to-markdown/lib/handle/text.js
 function text3(node, parent, state, info) {
   const siblings = parent ? parent.children : [];
-  const index = siblings.indexOf(node);
+  const index = state.indexStack[state.indexStack.length - 1];
   return state.safe(node.value, {
     ...info,
     afterNode: siblings[index + 1],
@@ -10426,63 +10832,44 @@ var init_handle = __esm(() => {
   };
 });
 
-// ../../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;
-  }
-  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_html_kind = __esm(() => {
-  init_dev4();
-  init_micromark_util_html_tag_name();
-});
-
 // ../../node_modules/mdast-util-to-markdown/lib/join.js
 function joinDefaults(left, right, parent, state) {
   if (right.type === "code" && formatCodeAsIndented(right, state) && (left.type === "list" || left.type === right.type && formatCodeAsIndented(left, state))) {
     return false;
   }
   if ("spread" in parent && typeof parent.spread === "boolean") {
-    if (left.type === "paragraph" && (left.type === right.type || right.type === "definition" || right.type === "heading" && formatHeadingAsSetext(right, state))) {
-      return;
-    }
+    if (parent.spread)
+      return 1;
     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") {
+    if (left.type === "blockquote" && right.type === "blockquote")
+      return 1;
+    if ((left.type === "definition" || left.type === "paragraph") && right.type === "list" && (right.ordered && typeof right.start === "number" && right.start !== 1 || right.children.length > 0 && right.children[0].children.length === 0)) {
+      return 1;
+    }
+    if (left.type === "paragraph" && right.type === "thematicBreak" && checkRule(state) === "-" && !state.options.ruleSpaces) {
+      return 1;
+    }
+    let tail = left;
+    while ((tail.type === "blockquote" || tail.type === "list" || tail.type === "listItem") && tail.children.length > 0) {
+      tail = tail.children[tail.children.length - 1];
+    }
+    if (tail.type !== "definition" && tail.type !== "paragraph")
+      return 0;
+    if (right.type === "code" && formatCodeAsIndented(right, state))
+      return 1;
+    if (right.type === "html") {
       const kind = htmlKind(right.value);
       if (kind === undefined || kind === 7)
         return 1;
     }
-    return parent.spread ? 1 : 0;
+    if ((left.type === "paragraph" || left !== tail) && (right.type === "definition" || right.type === "heading" && formatHeadingAsSetext(right, state) || right.type === "paragraph")) {
+      return 1;
+    }
+    return 0;
   }
 }
 var join;
@@ -10555,7 +10942,21 @@ var init_unsafe = __esm(() => {
     { atBreak: true, character: "#" },
     { character: "#", inConstruct: "headingAtx", after: `(?:[\r
 ]|$)` },
-    { character: "&", after: "[#A-Za-z]", inConstruct: "phrasing" },
+    {
+      character: "&",
+      after: "[#A-Za-z]",
+      inConstruct: [
+        "codeFencedLangGraveAccent",
+        "codeFencedLangTilde",
+        "codeFencedMetaGraveAccent",
+        "codeFencedMetaTilde",
+        "destinationLiteral",
+        "destinationRaw",
+        "phrasing",
+        "titleApostrophe",
+        "titleQuote"
+      ]
+    },
     { character: "'", inConstruct: "titleApostrophe" },
     { character: "(", inConstruct: "destinationRaw" },
     {
@@ -10629,333 +11030,6 @@ function compilePattern(pattern) {
   return pattern._compiled;
 }
 
-// ../../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_dev6();
-});
-
-// ../../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;
-  indexStack.push(-1);
-  let tracker = state.createTracker(info);
-  while (++index < children.length) {
-    const child = children[index];
-    let after;
-    indexStack[indexStack.length - 1] = index;
-    if (index + 1 < children.length) {
-      let handle = state.handle.handlers[children[index + 1].type];
-      if (handle && handle.peek)
-        handle = handle.peek;
-      after = handle ? firstCharacter(handle(children[index + 1], parent, state, {
-        before: "",
-        after: "",
-        ...tracker.current()
-      })) : "";
-    } else {
-      after = info.after;
-    }
-    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(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);
-    }
-  }
-  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 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;
-    }
-    chosen = next.chosen;
-    tokens = next.tokens;
-    mistake = next.mistake;
-  }
-  let result = "";
-  for (const token of tokens)
-    result += token.value;
-  return result;
-}
-var builtins;
-var init_container_phrasing = __esm(() => {
-  init_dev4();
-  init_dev6();
-  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) {
   const indexStack = state.indexStack;
@@ -11086,22 +11160,20 @@ function safe(state, input, config) {
         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) {
+    if (position + 1 < end && positions[index + 1] === position + 1 && infos[position].after && !infos[position + 1].before && !infos[position + 1].after || position - 1 >= offset && positions[index - 1] === position - 1 && infos[position].before && !infos[position - 1].before && !infos[position - 1].after) {
       continue;
     }
     if (start !== position) {
       const slice = value.slice(start, position);
       result.push(percentEncode ? slice : escapeBackslashes(slice, "\\"));
     }
-    start = position;
+    start = position + 1;
     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("\\");
+      result.push("\\" + value.charAt(position));
     } else {
       result.push(encodeCharacterReference(value.charCodeAt(position)));
-      start++;
     }
   }
   const rest = value.slice(start, end);
@@ -12092,84 +12164,9 @@ var init_stringify_entities = __esm(() => {
   init_lib13();
 });
 
-// ../../node_modules/mdast-util-directive/node_modules/unist-util-visit-parents/lib/color.node.js
-function color2(d) {
-  return "\x1B[33m" + d + "\x1B[39m";
-}
-
-// ../../node_modules/mdast-util-directive/node_modules/unist-util-visit-parents/lib/index.js
-function visitParents2(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 (" + color2(node.type + (name ? "<" + name + ">" : "")) + ")"
-      });
-    }
-    return visit;
-    function visit() {
-      let result = empty2;
-      let subresult;
-      let offset;
-      let grandparents;
-      if (!test || is(node, index, parents[parents.length - 1] || undefined)) {
-        result = toResult2(visitor(node, parents));
-        if (result[0] === EXIT2) {
-          return result;
-        }
-      }
-      if ("children" in node && node.children) {
-        const nodeAsParent = node;
-        if (nodeAsParent.children && result[0] !== SKIP2) {
-          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] === EXIT2) {
-              return subresult;
-            }
-            offset = typeof subresult[1] === "number" ? subresult[1] : offset + step;
-          }
-        }
-      }
-      return result;
-    }
-  }
-}
-function toResult2(value) {
-  if (Array.isArray(value)) {
-    return value;
-  }
-  if (typeof value === "number") {
-    return [CONTINUE2, value];
-  }
-  return value === null || value === undefined ? empty2 : [value];
-}
-var empty2, CONTINUE2 = true, EXIT2 = false, SKIP2 = "skip";
-var init_lib14 = __esm(() => {
-  init_unist_util_is();
-  empty2 = [];
-});
-
-// ../../node_modules/mdast-util-directive/node_modules/unist-util-visit-parents/index.js
-var init_unist_util_visit_parents2 = __esm(() => {
-  init_lib14();
-});
-
 // ../../node_modules/mdast-util-directive/lib/index.js
-function directiveFromMarkdown() {
+function directiveFromMarkdown(options) {
+  const settings = options || emptyFromMarkdownOptions;
   return {
     canContainEols: ["textDirective"],
     enter: {
@@ -12183,29 +12180,57 @@ function directiveFromMarkdown() {
     },
     exit: {
       directiveContainer: exit2,
+      directiveContainerAttributeClass: exitAttributeShortcut,
       directiveContainerAttributeClassValue: exitAttributeClassValue,
+      directiveContainerAttributeId: exitAttributeShortcut,
       directiveContainerAttributeIdValue: exitAttributeIdValue,
       directiveContainerAttributeName: exitAttributeName,
       directiveContainerAttributeValue: exitAttributeValue,
+      directiveContainerAttributeValueLiteral: exitAttributeValueLiteral,
       directiveContainerAttributes: exitAttributes,
       directiveContainerLabel: exitContainerLabel,
       directiveContainerName: exitName,
+      directiveContainerSequence: exitSequence,
       directiveLeaf: exit2,
+      directiveLeafAttributeClass: exitAttributeShortcut,
       directiveLeafAttributeClassValue: exitAttributeClassValue,
+      directiveLeafAttributeId: exitAttributeShortcut,
       directiveLeafAttributeIdValue: exitAttributeIdValue,
       directiveLeafAttributeName: exitAttributeName,
       directiveLeafAttributeValue: exitAttributeValue,
+      directiveLeafAttributeValueLiteral: exitAttributeValueLiteral,
       directiveLeafAttributes: exitAttributes,
+      directiveLeafLabel: exitLabel,
       directiveLeafName: exitName,
+      directiveLeafSequence: exitSequence,
       directiveText: exit2,
+      directiveTextAttributeClass: exitAttributeShortcut,
       directiveTextAttributeClassValue: exitAttributeClassValue,
+      directiveTextAttributeId: exitAttributeShortcut,
       directiveTextAttributeIdValue: exitAttributeIdValue,
       directiveTextAttributeName: exitAttributeName,
       directiveTextAttributeValue: exitAttributeValue,
+      directiveTextAttributeValueLiteral: exitAttributeValueLiteral,
       directiveTextAttributes: exitAttributes,
+      directiveTextLabel: exitLabel,
+      directiveTextMarker: exitSequence,
       directiveTextName: exitName
     }
   };
+  function exitSequence(token) {
+    if (!settings.verbose)
+      return;
+    const node = this.stack[this.stack.length - 1];
+    ok(node, "expected `node`");
+    ok(node.type === "containerDirective" || node.type === "leafDirective" || node.type === "textDirective");
+    const place = { start: point3(token.start), end: point3(token.end) };
+    if (node.data && node.data.position) {
+      ok(node.type === "containerDirective");
+      node.data.position.closing = place;
+    } else {
+      node.data = { position: { opening: place } };
+    }
+  }
 }
 function directiveToMarkdown(options) {
   const settings = options || emptyOptions2;
@@ -12242,8 +12267,20 @@ function directiveToMarkdown(options) {
   };
   function handleDirective(node, _, state, info) {
     const tracker = state.createTracker(info);
-    const sequence = fence(node);
     const exit = state.enter(node.type);
+    let content;
+    if (node.type === "containerDirective") {
+      const head = (node.children || [])[0];
+      const children = inlineDirectiveLabel(head) ? node.children.slice(1) : node.children;
+      if (children && children.length > 0) {
+        const current = tracker.current();
+        content = state.containerFlow({ ...node, children }, {
+          now: { line: current.now.line + 1, column: 1 + current.lineShift },
+          lineShift: current.lineShift
+        });
+      }
+    }
+    const sequence = fence(node, content ? longestColonLine(content) : 0);
     let value = tracker.move(sequence + (node.name || ""));
     const attributesValue = attributes(node, state);
     const after = info.after.charCodeAt(0);
@@ -12272,15 +12309,9 @@ function directiveToMarkdown(options) {
     }
     value += tracker.move(attributesValue || (after === 123 ? "{}" : ""));
     if (node.type === "containerDirective") {
-      const head = (node.children || [])[0];
-      let shallow = node;
-      if (inlineDirectiveLabel(head)) {
-        shallow = Object.assign({}, node, { children: node.children.slice(1) });
-      }
-      if (shallow && shallow.children && shallow.children.length > 0) {
+      if (content) {
         value += tracker.move(`
-`);
-        value += tracker.move(state.containerFlow(shallow, tracker.current()));
+` + content);
       }
       value += tracker.move(`
 ` + sequence);
@@ -12297,16 +12328,15 @@ function directiveToMarkdown(options) {
     let key;
     for (key in attributes) {
       if (own8.call(attributes, key) && attributes[key] !== undefined && attributes[key] !== null) {
-        const value = String(attributes[key]);
+        const value = encode2(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 ]+/);
           const classesFullList = [];
           const classesList = [];
-          let index = -1;
-          while (++index < list.length) {
-            (settings.preferShortcut !== false && shortcut.test(list[index]) ? classesList : classesFullList).push(list[index]);
+          for (const item of list) {
+            (settings.preferShortcut !== false && shortcut.test(item) ? classesList : classesFullList).push(item);
           }
           classesFull = classesFullList.length > 0 ? quoted("class", classesFullList.join(" "), node, state) : "";
           classes = classesList.length > 0 ? "." + classesList.join(".") : "";
@@ -12354,19 +12384,50 @@ function enter(type, token) {
 }
 function exitName(token) {
   const node = this.stack[this.stack.length - 1];
+  ok(node, "expected `node`");
   ok(node.type === "containerDirective" || node.type === "leafDirective" || node.type === "textDirective");
   node.name = this.sliceSerialize(token);
+  openingEnd(node, token);
 }
 function enterContainerLabel(token) {
   this.enter({ type: "paragraph", data: { directiveLabel: true }, children: [] }, token);
 }
 function exitContainerLabel(token) {
   this.exit(token);
+  const node = this.stack[this.stack.length - 1];
+  ok(node, "expected `node`");
+  ok(node.type === "containerDirective");
+  openingEnd(node, token);
+}
+function exitLabel(token) {
+  const node = this.stack[this.stack.length - 1];
+  ok(node, "expected `node`");
+  ok(node.type === "leafDirective" || node.type === "textDirective");
+  openingEnd(node, token);
 }
 function enterAttributes() {
+  const node = this.stack[this.stack.length - 1];
+  ok(node, "expected `node`");
+  ok(node.type === "containerDirective" || node.type === "leafDirective" || node.type === "textDirective");
+  if (node.data && node.data.position) {
+    this.data.directiveAttributePositions = {};
+  }
   this.data.directiveAttributes = [];
   this.buffer();
 }
+function exitAttributeShortcut(token) {
+  const positions = this.data.directiveAttributePositions;
+  if (positions) {
+    const list = this.data.directiveAttributes;
+    ok(list, "expected `directiveAttributes`");
+    const tail = list[list.length - 1];
+    ok(tail, "expected attribute");
+    positions[tail[0]] = { start: point3(token.start), end: point3(token.end) };
+  }
+}
+function exitAttributeValueLiteral(token) {
+  attributeEnd(this, token);
+}
 function exitAttributeIdValue(token) {
   const list = this.data.directiveAttributes;
   ok(list, "expected `directiveAttributes`");
@@ -12386,33 +12447,67 @@ function exitAttributeClassValue(token) {
 function exitAttributeValue(token) {
   const list = this.data.directiveAttributes;
   ok(list, "expected `directiveAttributes`");
-  list[list.length - 1][1] = parseEntities(this.sliceSerialize(token), {
-    attribute: true
-  });
+  const tail = list[list.length - 1];
+  ok(tail, "expected attribute");
+  tail[1] = parseEntities(this.sliceSerialize(token), { attribute: true });
+  attributeEnd(this, token);
 }
 function exitAttributeName(token) {
   const list = this.data.directiveAttributes;
   ok(list, "expected `directiveAttributes`");
-  list.push([this.sliceSerialize(token), ""]);
+  const name = this.sliceSerialize(token);
+  list.push([name, ""]);
+  const positions = this.data.directiveAttributePositions;
+  if (positions) {
+    positions[name] = { start: point3(token.start), end: point3(token.end) };
+  }
 }
-function exitAttributes() {
+function exitAttributes(token) {
   const list = this.data.directiveAttributes;
   ok(list, "expected `directiveAttributes`");
   const cleaned = {};
-  let index = -1;
-  while (++index < list.length) {
-    const attribute = list[index];
+  for (const attribute of list) {
     if (attribute[0] === "class" && cleaned.class) {
       cleaned.class += " " + attribute[1];
     } else {
       cleaned[attribute[0]] = attribute[1];
     }
   }
+  const positions = this.data.directiveAttributePositions;
+  this.data.directiveAttributePositions = undefined;
   this.data.directiveAttributes = undefined;
   this.resume();
   const node = this.stack[this.stack.length - 1];
+  ok(node, "expected `node`");
   ok(node.type === "containerDirective" || node.type === "leafDirective" || node.type === "textDirective");
   node.attributes = cleaned;
+  if (positions) {
+    ok(node.data && node.data.position, "expected `position`");
+    node.data.position.attributes = positions;
+  }
+  openingEnd(node, token);
+}
+function openingEnd(node, token) {
+  if (node.data && node.data.position) {
+    const { opening } = node.data.position;
+    ok(opening, "expected `opening`");
+    opening.end = point3(token.end);
+  }
+}
+function attributeEnd(context, token) {
+  const positions = context.data.directiveAttributePositions;
+  if (positions) {
+    const list = context.data.directiveAttributes;
+    ok(list, "expected `directiveAttributes`");
+    const tail = list[list.length - 1];
+    ok(tail, "expected attribute");
+    const position = positions[tail[0]];
+    ok(position, "expected position");
+    position.end = point3(token.end);
+  }
+}
+function point3(d) {
+  return { line: d.line, column: d.column, offset: d.offset };
 }
 function exit2(token) {
   this.exit(token);
@@ -12420,26 +12515,28 @@ function exit2(token) {
 function peekDirective() {
   return ":";
 }
+function encode2(value) {
+  const result = [];
+  let start = 0;
+  let index = value.indexOf("&");
+  while (index !== -1) {
+    const code = value.charCodeAt(index + 1);
+    if (code === 35 || asciiAlpha(code)) {
+      result.push(value.slice(start, index), "&#x26;");
+      start = index + 1;
+    }
+    index = value.indexOf("&", index + 1);
+  }
+  result.push(value.slice(start));
+  return result.join("");
+}
 function inlineDirectiveLabel(node) {
   return Boolean(node && node.type === "paragraph" && node.data && node.data.directiveLabel);
 }
-function fence(node) {
+function fence(node, longest) {
   let size = 0;
   if (node.type === "containerDirective") {
-    visitParents2(node, function(node, parents) {
-      if (node.type === "containerDirective") {
-        let index = parents.length;
-        let nesting = 0;
-        while (index--) {
-          if (parents[index].type === "containerDirective") {
-            nesting++;
-          }
-        }
-        if (nesting > size)
-          size = nesting;
-      }
-    });
-    size += 3;
+    size = Math.max(3, longest + 1);
   } else if (node.type === "leafDirective") {
     size = 2;
   } else {
@@ -12447,14 +12544,40 @@ function fence(node) {
   }
   return ":".repeat(size);
 }
-var own8, emptyOptions2, shortcut, unquoted;
-var init_lib15 = __esm(() => {
+function longestColonLine(value) {
+  let longest = 0;
+  let index = 0;
+  while (index < value.length) {
+    let size = 0;
+    let code = value.charCodeAt(index);
+    while (code === 9 || code === 32) {
+      code = value.charCodeAt(++index);
+    }
+    while (code === 58) {
+      size++;
+      code = value.charCodeAt(++index);
+    }
+    while (code === 9 || code === 32) {
+      code = value.charCodeAt(++index);
+    }
+    while (!(code === 10 || code === 13 || Number.isNaN(code))) {
+      size = 0;
+      code = value.charCodeAt(++index);
+    }
+    if (size > longest)
+      longest = size;
+    index++;
+  }
+  return longest;
+}
+var own8, emptyFromMarkdownOptions, emptyOptions2, shortcut, unquoted;
+var init_lib14 = __esm(() => {
   init_development();
   init_dev4();
   init_parse_entities();
   init_stringify_entities();
-  init_unist_util_visit_parents2();
   own8 = {}.hasOwnProperty;
+  emptyFromMarkdownOptions = {};
   emptyOptions2 = {};
   shortcut = /^[^\t\n\r "#'.<=>`}]+$/;
   unquoted = /^[^\t\n\r "'<=>`}]+$/;
@@ -12462,7 +12585,7 @@ var init_lib15 = __esm(() => {
 
 // ../../node_modules/mdast-util-directive/index.js
 var init_mdast_util_directive = __esm(() => {
-  init_lib15();
+  init_lib14();
 });
 
 // ../../node_modules/micromark-extension-directive/dev/lib/factory-attributes.js
@@ -13078,14 +13201,14 @@ function remarkDirective() {
   fromMarkdownExtensions.push(directiveFromMarkdown());
   toMarkdownExtensions.push(directiveToMarkdown());
 }
-var init_lib16 = __esm(() => {
+var init_lib15 = __esm(() => {
   init_mdast_util_directive();
   init_dev16();
 });
 
 // ../../node_modules/remark-directive/index.js
 var init_remark_directive = __esm(() => {
-  init_lib16();
+  init_lib15();
 });
 
 // ../../node_modules/mdast-util-find-and-replace/node_modules/escape-string-regexp/index.js
@@ -13097,79 +13220,113 @@ function escapeStringRegexp(string) {
 }
 
 // ../../node_modules/mdast-util-find-and-replace/node_modules/unist-util-visit-parents/lib/color.node.js
-function color3(d) {
+function color2(d) {
   return "\x1B[33m" + d + "\x1B[39m";
 }
 
 // ../../node_modules/mdast-util-find-and-replace/node_modules/unist-util-visit-parents/lib/index.js
-function visitParents3(tree, test, visitor, reverse) {
+function visitParents2(tree, testOrEnterOrVisitors, enterOrVisitorsOrReverse, reverse) {
+  if (!tree || typeof tree !== "object") {
+    throw new Error("Unexpected value `" + tree + "` for `tree`, expected node");
+  }
+  let preorder = true;
   let check;
-  if (typeof test === "function" && typeof visitor !== "function") {
-    reverse = visitor;
-    visitor = test;
+  let visitors;
+  let enter;
+  let exit;
+  if (typeof enterOrVisitorsOrReverse === "function" || enterOrVisitorsOrReverse && typeof enterOrVisitorsOrReverse === "object") {
+    check = testOrEnterOrVisitors;
+    visitors = enterOrVisitorsOrReverse;
+    if (reverse)
+      preorder = false;
   } else {
-    check = test;
+    visitors = testOrEnterOrVisitors;
+    if (enterOrVisitorsOrReverse)
+      preorder = false;
+  }
+  if (typeof visitors === "function") {
+    enter = visitors;
+  } else if (visitors && typeof visitors === "object") {
+    if (visitors.enter === null || visitors.enter === undefined) {} else if (typeof visitors.enter === "function") {
+      enter = visitors.enter;
+    } else {
+      throw new Error("Unexpected value `" + visitors.enter + "` for `visitors.enter`, expected optional visitor");
+    }
+    if (typeof visitors.exit === "function") {
+      exit = visitors.exit;
+    } else {
+      throw new Error("Unexpected value `" + visitors.exit + "` for `visitors.exit`, expected visitor (pass a visitor directly if you only want an enter visitor)");
+    }
+  } else {
+    throw new Error("Unexpected value `" + visitors + "` for `enter` or `visitors`, expected visitor or object with visitors");
   }
   const is = convert(check);
-  const step = reverse ? -1 : 1;
+  const step = preorder ? 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 (" + color3(node.type + (name ? "<" + name + ">" : "")) + ")"
+        value: "node (" + color2(node.type + (name ? "<" + name + ">" : "")) + ")"
       });
     }
     return visit;
     function visit() {
-      let result = empty3;
-      let subresult;
-      let offset;
-      let grandparents;
-      if (!test || is(node, index, parents[parents.length - 1] || undefined)) {
-        result = toResult3(visitor(node, parents));
-        if (result[0] === EXIT3) {
+      const matches = !check || is(node, index, parents[parents.length - 1] || undefined);
+      let result = empty2;
+      if (enter && matches) {
+        result = toResult2(enter(node, parents, index));
+        if (result[0] === EXIT2) {
           return result;
         }
       }
       if ("children" in node && node.children) {
         const nodeAsParent = node;
-        if (nodeAsParent.children && result[0] !== SKIP3) {
-          offset = (reverse ? nodeAsParent.children.length : -1) + step;
-          grandparents = parents.concat(nodeAsParent);
+        if (nodeAsParent.children && result[0] !== SKIP2) {
+          let offset = (preorder ? -1 : nodeAsParent.children.length) + step;
+          const grandparents = [...parents, nodeAsParent];
           while (offset > -1 && offset < nodeAsParent.children.length) {
             const child = nodeAsParent.children[offset];
-            subresult = factory(child, offset, grandparents)();
-            if (subresult[0] === EXIT3) {
+            const subresult = factory(child, offset, grandparents)();
+            if (subresult[0] === EXIT2) {
               return subresult;
             }
             offset = typeof subresult[1] === "number" ? subresult[1] : offset + step;
           }
         }
       }
+      if (exit && matches) {
+        const exitResult = toResult2(exit(node, parents, index));
+        if (exitResult[0] === SKIP2) {
+          throw new Error("Unexpected value `" + exitResult[0] + "` from `exit`, expected `CONTINUE`, `EXIT`, index, or nothing");
+        }
+        if (exitResult[0] === EXIT2 || typeof exitResult[1] === "number") {
+          return exitResult;
+        }
+      }
       return result;
     }
   }
 }
-function toResult3(value) {
+function toResult2(value) {
   if (Array.isArray(value)) {
     return value;
   }
   if (typeof value === "number") {
-    return [CONTINUE3, value];
+    return [CONTINUE2, value];
   }
-  return value === null || value === undefined ? empty3 : [value];
+  return value === null || value === undefined ? empty2 : [value];
 }
-var empty3, CONTINUE3 = true, EXIT3 = false, SKIP3 = "skip";
-var init_lib17 = __esm(() => {
+var empty2, CONTINUE2 = true, EXIT2 = false, SKIP2 = "skip";
+var init_lib16 = __esm(() => {
   init_unist_util_is();
-  empty3 = [];
+  empty2 = [];
 });
 
 // ../../node_modules/mdast-util-find-and-replace/node_modules/unist-util-visit-parents/index.js
-var init_unist_util_visit_parents3 = __esm(() => {
-  init_lib17();
+var init_unist_util_visit_parents2 = __esm(() => {
+  init_lib16();
 });
 
 // ../../node_modules/mdast-util-find-and-replace/lib/index.js
@@ -13179,30 +13336,20 @@ function findAndReplace(tree, list, options) {
   const pairs = toPairs(list);
   let pairIndex = -1;
   while (++pairIndex < pairs.length) {
-    visitParents3(tree, "text", visitor);
+    visitParents2(tree, visitor);
   }
-  function visitor(node, parents) {
-    let index = -1;
-    let grandparent;
-    while (++index < parents.length) {
-      const parent = parents[index];
-      const siblings = grandparent ? grandparent.children : undefined;
-      if (ignored(parent, siblings ? siblings.indexOf(parent) : undefined, grandparent)) {
-        return;
-      }
-      grandparent = parent;
-    }
-    if (grandparent) {
-      return handler(node, parents);
+  function visitor(node, parents, index) {
+    if (node.type === "text" && typeof index === "number") {
+      return handler(node, parents, index);
     }
+    if (ignored(node, index, parents[parents.length - 1]))
+      return SKIP2;
   }
-  function handler(node, parents) {
+  function handler(node, parents, index) {
     const parent = parents[parents.length - 1];
     const find = pairs[pairIndex][0];
     const replace = pairs[pairIndex][1];
     let start = 0;
-    const siblings = parent.children;
-    const index = siblings.indexOf(node);
     let change = false;
     let nodes = [];
     find.lastIndex = 0;
@@ -13278,14 +13425,14 @@ function toFunction(replace) {
     return replace;
   };
 }
-var init_lib18 = __esm(() => {
-  init_unist_util_visit_parents3();
+var init_lib17 = __esm(() => {
+  init_unist_util_visit_parents2();
   init_unist_util_is();
 });
 
 // ../../node_modules/mdast-util-find-and-replace/index.js
 var init_mdast_util_find_and_replace = __esm(() => {
-  init_lib18();
+  init_lib17();
 });
 
 // ../../node_modules/mdast-util-gfm-autolink-literal/lib/index.js
@@ -13428,7 +13575,7 @@ function previous3(match, email) {
   return (match.index === 0 || unicodeWhitespace(code) || unicodePunctuation(code)) && (!email || code !== 47);
 }
 var inConstruct = "phrasing", notInConstruct;
-var init_lib19 = __esm(() => {
+var init_lib18 = __esm(() => {
   init_development();
   init_dev4();
   init_mdast_util_find_and_replace();
@@ -13437,7 +13584,7 @@ var init_lib19 = __esm(() => {
 
 // ../../node_modules/mdast-util-gfm-autolink-literal/index.js
 var init_mdast_util_gfm_autolink_literal = __esm(() => {
-  init_lib19();
+  init_lib18();
 });
 
 // ../../node_modules/mdast-util-gfm-footnote/lib/index.js
@@ -13535,7 +13682,7 @@ function mapExceptFirst(line, index, blank) {
 function mapAll(line, index, blank) {
   return (blank ? "" : "    ") + line;
 }
-var init_lib20 = __esm(() => {
+var init_lib19 = __esm(() => {
   init_development();
   init_dev3();
   footnoteReference.peek = footnoteReferencePeek;
@@ -13543,7 +13690,7 @@ var init_lib20 = __esm(() => {
 
 // ../../node_modules/mdast-util-gfm-footnote/index.js
 var init_mdast_util_gfm_footnote = __esm(() => {
-  init_lib20();
+  init_lib19();
 });
 
 // ../../node_modules/mdast-util-gfm-strikethrough/lib/index.js
@@ -13593,7 +13740,7 @@ function peekDelete() {
   return "~";
 }
 var constructsWithoutStrikethrough;
-var init_lib21 = __esm(() => {
+var init_lib20 = __esm(() => {
   constructsWithoutStrikethrough = [
     "autolink",
     "destinationLiteral",
@@ -13608,7 +13755,7 @@ var init_lib21 = __esm(() => {
 
 // ../../node_modules/mdast-util-gfm-strikethrough/index.js
 var init_mdast_util_gfm_strikethrough = __esm(() => {
-  init_lib21();
+  init_lib20();
 });
 
 // ../../node_modules/markdown-table/index.js
@@ -13884,14 +14031,14 @@ function gfmTableToMarkdown(options) {
     return value;
   }
 }
-var init_lib22 = __esm(() => {
+var init_lib21 = __esm(() => {
   init_development();
   init_mdast_util_to_markdown();
 });
 
 // ../../node_modules/mdast-util-gfm-table/index.js
 var init_mdast_util_gfm_table = __esm(() => {
-  init_lib22();
+  init_lib21();
 });
 
 // ../../node_modules/mdast-util-gfm-task-list-item/lib/index.js
@@ -13966,14 +14113,14 @@ function listItemWithTaskListItem(node, parent, state, info) {
     return $0 + checkbox;
   }
 }
-var init_lib23 = __esm(() => {
+var init_lib22 = __esm(() => {
   init_development();
   init_mdast_util_to_markdown();
 });
 
 // ../../node_modules/mdast-util-gfm-task-list-item/index.js
 var init_mdast_util_gfm_task_list_item = __esm(() => {
-  init_lib23();
+  init_lib22();
 });
 
 // ../../node_modules/mdast-util-gfm/lib/index.js
@@ -13997,7 +14144,7 @@ function gfmToMarkdown(options) {
     ]
   };
 }
-var init_lib24 = __esm(() => {
+var init_lib23 = __esm(() => {
   init_mdast_util_gfm_autolink_literal();
   init_mdast_util_gfm_footnote();
   init_mdast_util_gfm_strikethrough();
@@ -14007,7 +14154,7 @@ var init_lib24 = __esm(() => {
 
 // ../../node_modules/mdast-util-gfm/index.js
 var init_mdast_util_gfm = __esm(() => {
-  init_lib24();
+  init_lib23();
 });
 
 // ../../node_modules/micromark-extension-gfm-autolink-literal/dev/lib/syntax.js
@@ -15313,7 +15460,7 @@ function remarkGfm(options) {
   toMarkdownExtensions.push(gfmToMarkdown(settings));
 }
 var emptyOptions3;
-var init_lib25 = __esm(() => {
+var init_lib24 = __esm(() => {
   init_mdast_util_gfm();
   init_micromark_extension_gfm();
   emptyOptions3 = {};
@@ -15321,7 +15468,7 @@ var init_lib25 = __esm(() => {
 
 // ../../node_modules/remark-gfm/index.js
 var init_remark_gfm = __esm(() => {
-  init_lib25();
+  init_lib24();
 });
 
 // ../../node_modules/yaml/dist/nodes/identity.js
@@ -23572,13 +23719,13 @@ function parseSelector(selector, defaultTagName) {
   };
 }
 var search2;
-var init_lib26 = __esm(() => {
+var init_lib25 = __esm(() => {
   search2 = /[#.]/g;
 });
 
 // ../../node_modules/hast-util-parse-selector/index.js
 var init_hast_util_parse_selector = __esm(() => {
-  init_lib26();
+  init_lib25();
 });
 
 // ../../node_modules/space-separated-tokens/index.js
@@ -23615,7 +23762,7 @@ function createH(schema, defaultTagName, caseSensitive) {
     for (const child of children) {
       addChild(node.children, child);
     }
-    if (node.type === "element" && node.tagName === "template") {
+    if (node.type === "element" && node.tagName === "template" && schema.space === "html") {
       node.content = { type: "root", children: node.children };
       node.children = [];
     }
@@ -23650,10 +23797,10 @@ function isChild(value) {
   return false;
 }
 function addProperty(schema, properties, key, value) {
-  const info = find(schema, key);
-  let result;
   if (value === null || value === undefined)
     return;
+  const info = find(schema, key);
+  let result;
   if (typeof value === "number") {
     if (Number.isNaN(value))
       return;
@@ -23683,7 +23830,8 @@ function addProperty(schema, properties, key, value) {
     result = finalResult;
   }
   if (info.property === "className" && Array.isArray(properties.className)) {
-    result = properties.className.concat(result);
+    const add = result;
+    result = [...properties.className, ...Array.isArray(add) ? add : [add]];
   }
   properties[info.property] = result;
 }
@@ -23782,7 +23930,7 @@ var init_svg_case_sensitive_tag_names = __esm(() => {
 
 // ../../node_modules/hastscript/lib/index.js
 var h, s;
-var init_lib27 = __esm(() => {
+var init_lib26 = __esm(() => {
   init_property_information();
   init_create_h();
   init_svg_case_sensitive_tag_names();
@@ -23792,7 +23940,7 @@ var init_lib27 = __esm(() => {
 
 // ../../node_modules/hastscript/index.js
 var init_hastscript = __esm(() => {
-  init_lib27();
+  init_lib26();
 });
 
 // ../../node_modules/vfile-location/lib/index.js
@@ -23932,7 +24080,7 @@ function all2(state, nodes) {
   return results;
 }
 function element(state, node) {
-  const schema = state.schema;
+  const { schema } = state;
   state.schema = node.namespaceURI === webNamespaces.svg ? svg2 : html3;
   let index = -1;
   const properties = {};
@@ -23947,15 +24095,20 @@ function element(state, node) {
   const result = x(node.tagName, properties, all2(state, node.childNodes));
   patch(state, node, result);
   if (result.tagName === "template") {
-    const reference = node;
-    const pos = reference.sourceCodeLocation;
-    const startTag = pos && pos.startTag && position2(pos.startTag);
-    const endTag = pos && pos.endTag && position2(pos.endTag);
-    const content = one2(state, reference.content);
-    if (startTag && endTag && state.file) {
-      content.position = { start: startTag.end, end: endTag.start };
+    if (node.namespaceURI === webNamespaces.html) {
+      const reference = node;
+      const pos = reference.sourceCodeLocation;
+      const startTag = pos && pos.startTag && position2(pos.startTag);
+      const endTag = pos && pos.endTag && position2(pos.endTag);
+      const content = one2(state, reference.content);
+      if (startTag && endTag && state.file) {
+        content.position = { start: startTag.end, end: endTag.start };
+      }
+      result.content = content;
+    } else if (result.content) {
+      result.children = result.content.children;
+      delete result.content;
     }
-    result.content = content;
   }
   state.schema = schema;
   return result;
@@ -23999,23 +24152,23 @@ function createLocation(state, node, location) {
   return result;
 }
 function position2(loc) {
-  const start = point3({
+  const start = point4({
     line: loc.startLine,
     column: loc.startCol,
     offset: loc.startOffset
   });
-  const end = point3({
+  const end = point4({
     line: loc.endLine,
     column: loc.endCol,
     offset: loc.endOffset
   });
   return start || end ? { start, end } : undefined;
 }
-function point3(point) {
+function point4(point) {
   return point.line && point.column ? point : undefined;
 }
 var own9, proto;
-var init_lib28 = __esm(() => {
+var init_lib27 = __esm(() => {
   init_development();
   init_hastscript();
   init_property_information();
@@ -24027,7 +24180,7 @@ var init_lib28 = __esm(() => {
 
 // ../../node_modules/hast-util-from-parse5/index.js
 var init_hast_util_from_parse5 = __esm(() => {
-  init_lib28();
+  init_lib27();
 });
 
 // ../../node_modules/parse5/dist/common/unicode.js
@@ -31920,7 +32073,7 @@ function visualizeCharacterCode(charCode) {
   return "0x" + charCode.toString(16).toUpperCase();
 }
 var base = "https://html.spec.whatwg.org/multipage/parsing.html#parse-error-", dashToCamelRe, formatCRe, formatXRe, fatalities, emptyOptions4;
-var init_lib29 = __esm(() => {
+var init_lib28 = __esm(() => {
   init_development();
   init_hast_util_from_parse5();
   init_dist3();
@@ -31936,24 +32089,24 @@ var init_lib29 = __esm(() => {
 
 // ../../node_modules/hast-util-from-html/index.js
 var init_hast_util_from_html = __esm(() => {
-  init_lib29();
+  init_lib28();
 });
 
 // ../../node_modules/hast-util-whitespace/lib/index.js
 function whitespace(thing) {
-  return typeof thing === "object" ? thing.type === "text" ? empty4(thing.value) : false : empty4(thing);
+  return typeof thing === "object" ? thing.type === "text" ? empty3(thing.value) : false : empty3(thing);
 }
-function empty4(value) {
+function empty3(value) {
   return value.replace(re, "") === "";
 }
 var re;
-var init_lib30 = __esm(() => {
+var init_lib29 = __esm(() => {
   re = /[ \t\n\f\r]/g;
 });
 
 // ../../node_modules/hast-util-whitespace/index.js
 var init_hast_util_whitespace = __esm(() => {
-  init_lib30();
+  init_lib29();
 });
 
 // ../../packages/markup/src/html-to-jx.ts
@@ -32438,14 +32591,14 @@ function fence3(matter, prop) {
 function pick2(schema, prop) {
   return typeof schema === "string" ? schema : schema[prop];
 }
-var init_lib31 = __esm(() => {
+var init_lib30 = __esm(() => {
   init_development();
   init_dev22();
 });
 
 // ../../node_modules/mdast-util-frontmatter/index.js
 var init_mdast_util_frontmatter = __esm(() => {
-  init_lib31();
+  init_lib30();
 });
 
 // ../../node_modules/remark-frontmatter/lib/index.js
@@ -32461,14 +32614,14 @@ function remarkFrontmatter(options) {
   toMarkdownExtensions.push(frontmatterToMarkdown(settings));
 }
 var emptyOptions5 = "yaml";
-var init_lib32 = __esm(() => {
+var init_lib31 = __esm(() => {
   init_mdast_util_frontmatter();
   init_dev22();
 });
 
 // ../../node_modules/remark-frontmatter/index.js
 var init_remark_frontmatter = __esm(() => {
-  init_lib32();
+  init_lib31();
 });
 
 // ../../node_modules/unist-util-visit-parents/node_modules/unist-util-is/convert.js
@@ -40814,6 +40967,9 @@ function normalizeAllowlist(allowlist) {
   return allowlist instanceof Set ? allowlist : new Set(allowlist);
 }
 function hasJxProps(el) {
+  if (isTemplateString(el.children)) {
+    return true;
+  }
   for (const key of Object.keys(el)) {
     if (key === "tagName" || key === "children" || key === "textContent" || key === "innerHTML" || key === "attributes") {
       continue;
@@ -41027,7 +41183,7 @@ function collectDirectiveAttrs(el) {
       continue;
     }
     if (key === "children") {
-      if (isJsonObject(value)) {
+      if (isJsonObject(value) || isTemplateString(value)) {
         propsObj.children = value;
       }
       continue;