@jxsuite/parser 2.0.0 → 2.0.1

package/dist/markdown.js

@@ -3911,7 +3911,7 @@ var init_dev4 = __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) {
@@ -3930,6 +3930,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_dev4();
 });
@@ -3991,6 +4014,65 @@ var init_content = __esm(() => {
   content = { tokenize: initializeContent };
 });
 
+// ../../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/dev/lib/initialize/document.js
 function initializeDocument(effects) {
   const self2 = this;
@@ -4033,8 +4115,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);
@@ -4053,8 +4137,9 @@ function initializeDocument(effects) {
     return effects.check(containerConstruct, thereIsANewContainer, thereIsNoNewContainer)(code);
   }
   function thereIsANewContainer(code) {
-    if (childFlow)
+    if (childFlow) {
       closeFlow();
+    }
     exitContainers(continued);
     return documentContinued(code);
   }
@@ -4076,8 +4161,9 @@ function initializeDocument(effects) {
   }
   function flowStart(code) {
     if (code === codes.eof) {
-      if (childFlow)
+      if (childFlow) {
         closeFlow();
+      }
       exitContainers(0);
       effects.consume(code);
       return;
@@ -4110,11 +4196,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);
@@ -4145,8 +4233,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) {
@@ -4177,7 +4267,6 @@ var init_document = __esm(() => {
   init_development();
   init_dev5();
   init_dev4();
-  init_dev();
   init_default();
   document2 = { tokenize: initializeDocument };
   containerConstruct = { tokenize: tokenizeContainer };
@@ -4214,43 +4303,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 }
@@ -4278,14 +4360,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;
@@ -4322,8 +4403,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);
@@ -4639,6 +4720,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_dev4();
+  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;
@@ -4794,33 +4904,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_dev4();
   init_default();
-  nonLazyContinuation = {
-    partial: true,
-    tokenize: tokenizeNonLazyContinuation
-  };
+  init_partial_non_lazy_continuation();
   codeFenced = {
     concrete: true,
     name: "codeFenced",
@@ -4830,16 +4920,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) {
@@ -4877,11 +4962,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;
@@ -5691,8 +5775,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;
   }
@@ -5703,12 +5785,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,
@@ -6127,7 +6209,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));
@@ -6206,22 +6288,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) {
@@ -6232,13 +6298,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_dev4();
   init_micromark_util_html_tag_name();
   init_default();
   init_blank_line();
+  init_partial_non_lazy_continuation();
   htmlFlow = {
     concrete: true,
     name: "htmlFlow",
@@ -6246,10 +6313,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
@@ -6587,12 +6650,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;
@@ -6650,14 +6712,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) {
@@ -6689,6 +6751,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) {
@@ -6801,6 +6865,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 `!`");
@@ -6815,13 +6880,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;
@@ -6839,6 +6909,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 `[`");
@@ -6846,11 +6917,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;
@@ -7079,6 +7155,7 @@ var init_list = __esm(() => {
 
 // ../../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;
@@ -7094,7 +7171,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;
@@ -7112,13 +7189,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) {
@@ -7315,6 +7393,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) {
@@ -7332,8 +7411,9 @@ function resolveAllLineSuffixes(events, context) {
             size++;
             bufferIndex--;
           }
-          if (bufferIndex)
+          if (bufferIndex) {
             break;
+          }
           bufferIndex = -1;
         } else if (chunk === codes.horizontalTab) {
           tabs = true;
@@ -7362,13 +7442,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, text;
@@ -8255,11 +8338,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;
         }
@@ -8468,7 +8550,7 @@ function serializeChunks(chunks, expandTabs) {
     let value;
     if (typeof chunk === "string") {
       value = chunk;
-    } else
+    } else {
       switch (chunk) {
         case codes.carriageReturn: {
           value = values.cr;
@@ -8487,8 +8569,9 @@ function serializeChunks(chunks, expandTabs) {
           break;
         }
         case codes.virtualSpace: {
-          if (!expandTabs && atTab)
+          if (!expandTabs && atTab) {
             continue;
+          }
           value = values.space;
           break;
         }
@@ -8497,6 +8580,7 @@ function serializeChunks(chunks, expandTabs) {
           value = String.fromCharCode(chunk);
         }
       }
+    }
     atTab = chunk === codes.horizontalTab;
     result.push(value);
   }
@@ -8561,14 +8645,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) {
@@ -8578,9 +8657,9 @@ function preprocess() {
     }
     while (startPosition < value.length) {
       search.lastIndex = startPosition;
-      match = search.exec(value);
-      endPosition = match && match.index !== undefined ? match.index : value.length;
-      code = value.charCodeAt(endPosition);
+      const match = search.exec(value);
+      const endPosition = match && match.index !== undefined ? match.index : value.length;
+      const code = value.charCodeAt(endPosition);
       if (!match) {
         buffer = value.slice(startPosition);
         break;
@@ -8604,10 +8683,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: {
@@ -8624,10 +8704,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;
@@ -8680,6 +8762,8 @@ function fromMarkdown(value, encoding, options) {
 }
 function compiler(options) {
   const config = {
+    afterExit: [],
+    beforeEnter: [],
     transforms: [],
     canContainEols: ["emphasis", "fragment", "heading", "paragraph", "strong"],
     enter: {
@@ -8781,7 +8865,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: [],
@@ -8793,23 +8877,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 (events[index][0] === "enter" && config.beforeEnter.length > 0) {
+        callListeners(config.beforeEnter, { ...context, sliceSerialize: events[index][2].sliceSerialize }, events[index][1]);
+      }
       if (own3.call(handler, events[index][1].type)) {
-        handler[events[index][1].type].call(Object.assign({ sliceSerialize: events[index][2].sliceSerialize }, context), events[index][1]);
+        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) {
@@ -8827,7 +8920,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;
@@ -8835,7 +8935,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:
@@ -8892,9 +8993,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 = {
@@ -8904,16 +9006,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;
@@ -8953,7 +9062,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 {
@@ -9250,13 +9360,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 {
@@ -9264,30 +9380,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 {
@@ -9295,7 +9425,8 @@ function compiler(options) {
       ordered: token.type === "listOrdered",
       start: null,
       spread: token._spread,
-      children: []
+      children: [],
+      position: undefined
     };
   }
   function listItem(token) {
@@ -9303,20 +9434,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 point2(d) {
@@ -9352,6 +9484,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];
@@ -9367,9 +9507,8 @@ 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 own3;
 var init_lib5 = __esm(() => {
@@ -17426,15 +17565,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;
@@ -17446,20 +17583,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) {
@@ -17754,35 +17899,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 "~";
 }
@@ -17796,6 +17945,7 @@ var init_lib13 = __esm(() => {
     "titleQuote",
     "titleApostrophe"
   ];
+  handleDelete.attention = attentionDelete;
   handleDelete.peek = peekDelete;
 });
 
@@ -17939,6 +18089,35 @@ function toAlignment(value) {
   return code === 67 || code === 99 ? 99 : code === 76 || code === 108 ? 108 : code === 82 || code === 114 ? 114 : 0;
 }
 
+// ../../node_modules/mdast-util-phrasing/lib/index.js
+var phrasing;
+var init_lib14 = __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_lib14();
+});
+
 // ../../node_modules/zwitch/index.js
 function zwitch(key, options) {
   const settings = options || {};
@@ -18051,9 +18230,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";
@@ -18086,7 +18266,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
@@ -18102,7 +18282,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);
@@ -18112,6 +18291,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}`);
@@ -18214,64 +18394,34 @@ function checkEmphasis(state) {
   return marker;
 }
 
-// ../../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/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);
+  const exit = state.enter("phrasing");
+  const value = state.containerPhrasing({ type: "root", children: [node] }, info);
   exit();
-  state.attentionEncodeSurroundingInfo = {
-    after: close.outside,
-    before: open.outside
+  return value;
+}
+function attention2(_, state) {
+  const marker = checkEmphasis(state);
+  return {
+    construct: "emphasis",
+    markers: marker === "*" ? ["*", "_"] : ["_", "*"],
+    sizes: [1]
   };
-  return before + between + after;
 }
-function emphasisPeek(_, _1, state) {
+function peek(_, _1, state) {
   return state.options.emphasis || "*";
 }
 var init_emphasis = __esm(() => {
-  init_encode_info();
-  emphasis.peek = emphasisPeek;
+  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 color2(d) {
   return "\x1B[33m" + d + "\x1B[39m";
@@ -18338,14 +18488,14 @@ function toResult2(value) {
   return value === null || value === undefined ? empty2 : [value];
 }
 var empty2, CONTINUE2 = true, EXIT2 = false, SKIP2 = "skip";
-var init_lib14 = __esm(() => {
+var init_lib15 = __esm(() => {
   init_unist_util_is();
   empty2 = [];
 });
 
 // ../../node_modules/unist-util-visit/node_modules/unist-util-visit-parents/index.js
 var init_unist_util_visit_parents2 = __esm(() => {
-  init_lib14();
+  init_lib15();
 });
 
 // ../../node_modules/unist-util-visit/lib/index.js
@@ -18369,14 +18519,14 @@ function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {
     return visitor(node, index, parent);
   }
 }
-var init_lib15 = __esm(() => {
+var init_lib16 = __esm(() => {
   init_unist_util_visit_parents2();
   init_unist_util_visit_parents2();
 });
 
 // ../../node_modules/unist-util-visit/index.js
 var init_unist_util_visit = __esm(() => {
-  init_lib15();
+  init_lib16();
 });
 
 // ../../node_modules/mdast-util-to-markdown/lib/util/format-heading-as-setext.js
@@ -18425,8 +18575,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) {
@@ -18513,7 +18664,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,
@@ -18547,15 +18700,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) {
@@ -18576,7 +18729,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();
@@ -18587,12 +18740,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,
@@ -18604,8 +18757,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,
@@ -18666,7 +18819,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,
@@ -18819,42 +18974,17 @@ function paragraph(node, _, state, info) {
   return value;
 }
 
-// ../../node_modules/mdast-util-phrasing/lib/index.js
-var phrasing;
-var init_lib16 = __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_lib16();
-});
-
 // ../../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);
+  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();
@@ -18871,44 +19001,36 @@ function checkStrong(state) {
 
 // ../../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);
-  }
-  const after = tracker.move(marker + marker);
+  const exit = state.enter("phrasing");
+  const value = state.containerPhrasing({ type: "root", children: [node] }, info);
   exit();
-  state.attentionEncodeSurroundingInfo = {
-    after: close.outside,
-    before: open.outside
+  return value;
+}
+function attention3(_, state) {
+  const marker = checkStrong(state);
+  return {
+    construct: "strong",
+    markers: marker === "*" ? ["*", "_"] : ["_", "*"],
+    sizes: [2]
   };
-  return before + between + after;
 }
-function strongPeek(_, _1, state) {
+function peek2(_, _1, state) {
   return state.options.strong || "*";
 }
 var init_strong = __esm(() => {
-  init_encode_info();
-  strong.peek = strongPeek;
+  strong.attention = attention3;
+  strong.peek = peek2;
 });
 
 // ../../node_modules/mdast-util-to-markdown/lib/handle/text.js
-function text3(node, _, state, info) {
-  return state.safe(node.value, info);
+function text3(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
@@ -18970,6 +19092,43 @@ 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))) {
@@ -18979,17 +19138,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",
@@ -19029,6 +19199,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" },
     {
@@ -19089,8 +19265,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/mdast-util-to-markdown/lib/util/association.js
@@ -19108,19 +19290,201 @@ var init_association = __esm(() => {
 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/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 serialize2(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) {
@@ -19131,47 +19495,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(serialize2(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(serialize2(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 serialize2(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_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) {
@@ -19254,19 +19703,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 (own7.call(infos, position)) {
         if (infos[position].before && !before) {
           infos[position].before = false;
         }
@@ -19280,31 +19734,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 && !own7.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 && !own7.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;
 }
@@ -19329,7 +19805,11 @@ function escapeBackslashes(value, after) {
   results.push(value.slice(start));
   return results.join("");
 }
-var init_safe = () => {};
+var own7;
+var init_safe = __esm(() => {
+  init_dev6();
+  own7 = {}.hasOwnProperty;
+});
 
 // ../../node_modules/mdast-util-to-markdown/lib/util/track.js
 function track(config) {
@@ -19360,6 +19840,8 @@ function toMarkdown(tree, options) {
   const settings = options || {};
   const state = {
     associationId: association,
+    bulletCurrent: undefined,
+    bulletLastUsed: undefined,
     containerPhrasing: containerPhrasingBound,
     containerFlow: containerFlowBound,
     createTracker: track,
@@ -19384,14 +19866,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 += `
 `;
@@ -19427,6 +19904,7 @@ function safeBound(value, config) {
   return safe(this, value, config);
 }
 var init_lib17 = __esm(() => {
+  init_mdast_util_phrasing();
   init_zwitch();
   init_configure();
   init_handle();
@@ -19992,7 +20470,7 @@ function previousUnbalanced(events) {
   }
   return result;
 }
-var wwwPrefix, domain, path, trail, emailDomainDotTrail, wwwAutolink, protocolAutolink, emailAutolink, text4, code2;
+var wwwPrefix, domain, path, trail, emailDomainDotTrail, wwwAutolink, protocolAutolink, emailAutolink, text4, code3;
 var init_syntax2 = __esm(() => {
   init_dev4();
   init_default();
@@ -20020,14 +20498,14 @@ var init_syntax2 = __esm(() => {
     previous: previousEmail
   };
   text4 = {};
-  code2 = codes.digit0;
-  while (code2 < codes.leftCurlyBrace) {
-    text4[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) {
+    text4[code3] = emailAutolink;
+    code3++;
+    if (code3 === codes.colon)
+      code3 = codes.uppercaseA;
+    else if (code3 === codes.leftSquareBracket)
+      code3 = codes.lowercaseA;
   }
   text4[codes.plusSign] = emailAutolink;
   text4[codes.dash] = emailAutolink;
@@ -20425,12 +20903,13 @@ var init_dev19 = __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) {
@@ -20456,22 +20935,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
@@ -20522,11 +21001,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;
@@ -20741,7 +21221,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];
@@ -21752,7 +22232,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 (own7.call(characters, character)) {
+  if (own8.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)))) {
@@ -21762,15 +22242,15 @@ function toNamed(code, next, omit, attribute) {
   }
   return "";
 }
-var own7, characters, key, notAlphanumericRegex;
+var own8, characters, key, notAlphanumericRegex;
 var init_to_named = __esm(() => {
   init_character_entities_legacy();
   init_character_entities_html4();
   init_dangerous();
-  own7 = {}.hasOwnProperty;
+  own8 = {}.hasOwnProperty;
   characters = {};
   for (key in characterEntitiesHtml4) {
-    if (own7.call(characterEntitiesHtml4, key)) {
+    if (own8.call(characterEntitiesHtml4, key)) {
       characters[characterEntitiesHtml4[key]] = key;
     }
   }
@@ -21958,12 +22438,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) {
@@ -21971,6 +22453,8 @@ function directiveToMarkdown(options) {
     const sequence = fence3(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];
@@ -21991,8 +22475,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;
@@ -22018,12 +22504,12 @@ function directiveToMarkdown(options) {
     let id;
     let key;
     for (key in attributes) {
-      if (own8.call(attributes, key) && attributes[key] !== undefined && attributes[key] !== null) {
+      if (own9.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;
@@ -22169,13 +22655,14 @@ function fence3(node) {
   }
   return ":".repeat(size);
 }
-var own8, emptyOptions4, shortcut, unquoted;
+var own9, emptyOptions4, shortcut, unquoted;
 var init_lib25 = __esm(() => {
   init_development();
+  init_dev4();
   init_parse_entities();
   init_stringify_entities();
   init_unist_util_visit_parents3();
-  own8 = {}.hasOwnProperty;
+  own9 = {}.hasOwnProperty;
   emptyOptions4 = {};
   shortcut = /^[^\t\n\r "#'.<=>`}]+$/;
   unquoted = /^[^\t\n\r "'<=>`}]+$/;
@@ -24433,7 +24920,7 @@ function element(state, node) {
   while (++index < node.attrs.length) {
     const attribute = node.attrs[index];
     const name = (attribute.prefix ? attribute.prefix + ":" : "") + attribute.name;
-    if (!own9.call(proto, name)) {
+    if (!own10.call(proto, name)) {
       properties[name] = attribute.value;
     }
   }
@@ -24475,7 +24962,7 @@ function createLocation(state, node, location) {
       let key;
       if (location.attrs) {
         for (key in location.attrs) {
-          if (own9.call(location.attrs, key)) {
+          if (own10.call(location.attrs, key)) {
             properties[find(state.schema, key).property] = position2(location.attrs[key]);
           }
         }
@@ -24508,14 +24995,14 @@ function position2(loc) {
 function point3(point) {
   return point.line && point.column ? point : undefined;
 }
-var own9, proto;
+var own10, proto;
 var init_lib29 = __esm(() => {
   init_development();
   init_hastscript();
   init_property_information();
   init_vfile_location();
   init_web_namespaces();
-  own9 = {}.hasOwnProperty;
+  own10 = {}.hasOwnProperty;
   proto = Object.prototype;
 });
 
@@ -48310,12 +48797,12 @@ var init_siblings = __esm(() => {
 function omission(handlers) {
   return omit;
   function omit(node, index, parent) {
-    return own10.call(handlers, node.tagName) && handlers[node.tagName](node, index, parent);
+    return own11.call(handlers, node.tagName) && handlers[node.tagName](node, index, parent);
   }
 }
-var own10;
+var own11;
 var init_omission = __esm(() => {
-  own10 = {}.hasOwnProperty;
+  own11 = {}.hasOwnProperty;
 });
 
 // ../../node_modules/hast-util-to-html/lib/omission/closing.js