@aurodesignsystem-dev/auro-formkit 0.0.0-pr1625.1 → 0.0.0-pr1627.0

package/components/input/demo/demo-support.min.js

@@ -5749,7 +5749,7 @@ function normalizeUri(value) {
  */
 
 
-// To do: implement `spaceOrTab`, `spaceOrTabMinMax`, `spaceOrTabWithOptions`.
+// To do: implement `spaceOrTabWithOptions` (`connect`, `content`).
 
 /**
  * Parse spaces and tabs.
@@ -5777,14 +5777,14 @@ function normalizeUri(value) {
  * @param {State} ok
  *   State switched to when successful.
  * @param {TokenType} type
- *   Type (`' \t'`).
+ *   Type of the whole whitespace.
  * @param {number | undefined} [max=Infinity]
  *   Max (exclusive).
  * @returns {State}
  *   Start state.
  */
 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;
 
@@ -5808,6 +5808,58 @@ function factorySpace(effects, ok, type, max) {
   }
 }
 
+/**
+ * Parse spaces and tabs, with a required minimum and maximum, matching
+ * `markdown-rs`’s `space_or_tab_min_max`.
+ *
+ * Unlike `factorySpace`, this can fail: `nok` is used when fewer than
+ * `min` spaces or tabs are found.
+ *
+ * @param {Effects} effects
+ *   Context.
+ * @param {State} ok
+ *   State switched to when successful.
+ * @param {State} nok
+ *   State switched to when unsuccessful.
+ * @param {TokenType} type
+ *   Type of the whole whitespace.
+ * @param {number} min
+ *   Minimum allowed characters (inclusive).
+ * @param {number} max
+ *   Maximum allowed characters (inclusive).
+ * @returns {State}
+ *   Start state.
+ */
+function factorySpaceMinMax(effects, ok, nok, type, min, max) {
+  let size = 0;
+  return start;
+
+  /** @type {State} */
+  function start(code) {
+    if (markdownSpace(code)) {
+      effects.enter(type);
+      return prefix(code);
+    }
+    return after(code);
+  }
+
+  /** @type {State} */
+  function prefix(code) {
+    if (markdownSpace(code) && size < max) {
+      effects.consume(code);
+      size++;
+      return prefix;
+    }
+    effects.exit(type);
+    return after(code);
+  }
+
+  /** @type {State} */
+  function after(code) {
+    return size >= min ? ok(code) : nok(code);
+  }
+}
+
 /**
  * @import {
  *   InitialConstruct,
@@ -5886,6 +5938,232 @@ function initializeContent(effects) {
   }
 }
 
+/**
+ * @import {Event} from 'micromark-util-types'
+ */
+
+/**
+ * @typedef {[number, number, Array<Event>]} Change
+ * @typedef {[number, number, number]} Jump
+ */
+
+/**
+ * Tracks a bunch of edits.
+ *
+ * Port of `edit_map.rs` from `markdown-rs`:
+ * <https://github.com/wooorm/markdown-rs/blob/1506572f/src/util/edit_map.rs>.
+ *
+ * Deal with several changes in events, batching them together.
+ *
+ * Preferably, changes should be kept to a minimum.
+ * Sometimes, it’s needed to change the list of events, because parsing can be
+ * messy, and it helps to expose a cleaner interface of events to the compiler
+ * and other users.
+ * It can also help to merge many adjacent similar events.
+ * And, in other cases, it’s needed to parse subcontent: pass some events
+ * through another tokenizer and inject the result.
+ */
+let EditMap$1 = class EditMap {
+  /**
+   * Create a new edit map.
+   *
+   * @returns
+   *   New instance.
+   */
+  constructor() {
+    /**
+     * Changes by index, so `add` does not need to scan `map` (which is
+     * quadratic for documents with many edits at different places).
+     *
+     * @type {Map<number, Change>}
+     */
+    this.index = new Map();
+
+    /**
+     * Record of changes.
+     *
+     * @type {Array<Change>}
+     */
+    this.map = [];
+  }
+
+  /**
+   * Create an edit: a remove and/or add at a certain place.
+   *
+   * @param {number} index
+   *   Index at which to apply the edit.
+   * @param {number} remove
+   *   Count of items to remove at the index.
+   * @param {Array<Event>} add
+   *   Items to add at the index.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  add(index, remove, add) {
+    addImplementation$1(this, index, remove, add, false);
+  }
+
+  /**
+   * Create an edit: but insert `add` before existing additions, instead of
+   * after them.
+   *
+   * @param {number} index
+   *   Index at which to apply the edit.
+   * @param {number} remove
+   *   Count of items to remove at the index.
+   * @param {Array<Event>} add
+   *   Items to add at the index.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  addBefore(index, remove, add) {
+    addImplementation$1(this, index, remove, add, true);
+  }
+
+  /**
+   * Done, change the events.
+   *
+   * @param {Array<Event>} events
+   *   List of events to apply the edits to.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  consume(events) {
+    this.map.sort(function (a, b) {
+      return a[0] - b[0];
+    });
+    if (this.map.length === 0) {
+      return;
+    }
+
+    // To do: if links are added in events, like they are in `markdown-rs`,
+    // this is needed.
+    // // Calculate jumps: where items in the current list move to.
+    // /** @type {Array<Jump>} */
+    // const jumps = []
+    // let index = 0
+    // let addAcc = 0
+    // let removeAcc = 0
+    // while (index < this.map.length) {
+    //   const [at, remove, add] = this.map[index]
+    //   removeAcc += remove
+    //   addAcc += add.length
+    //   jumps.push([at, removeAcc, addAcc])
+    //   index += 1
+    // }
+    //
+    // shiftLinks(events, jumps)
+
+    let index = this.map.length;
+    /** @type {Array<Array<Event>>} */
+    const vecs = [];
+    while (index > 0) {
+      index -= 1;
+      vecs.push(events.slice(this.map[index][0] + this.map[index][1]), this.map[index][2]);
+
+      // Truncate rest.
+      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();
+    }
+
+    // Truncate everything.
+    this.map.length = 0;
+    this.index.clear();
+  }
+};
+
+/**
+ * Create an edit.
+ *
+ * @param {EditMap} editMap
+ *   Edit map to apply to.
+ * @param {number} at
+ *   Index at which to apply the edit.
+ * @param {number} remove
+ *   Count of items to remove at the index.
+ * @param {Array<Event>} add
+ *   Items to add at the index.
+ * @param {boolean} before
+ *   Insert `add` before existing additions at `at`, instead of after them.
+ * @returns {undefined}
+ *   Nothing.
+ */
+function addImplementation$1(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;
+  }
+
+  /** @type {Change} */
+  const change = [at, remove, add];
+  editMap.map.push(change);
+  editMap.index.set(at, change);
+}
+
+// /**
+//  * Shift `previous` and `next` links according to `jumps`.
+//  *
+//  * This fixes links in case there are events removed or added between them.
+//  *
+//  * @param {Array<Event>} events
+//  * @param {Array<Jump>} jumps
+//  */
+// function shiftLinks(events, jumps) {
+//   let jumpIndex = 0
+//   let index = 0
+//   let add = 0
+//   let rm = 0
+
+//   while (index < events.length) {
+//     const rmCurr = rm
+
+//     while (jumpIndex < jumps.length && jumps[jumpIndex][0] <= index) {
+//       add = jumps[jumpIndex][2]
+//       rm = jumps[jumpIndex][1]
+//       jumpIndex += 1
+//     }
+
+//     // Ignore items that will be removed.
+//     if (rm > rmCurr) {
+//       index += rm - rmCurr
+//     } else {
+//       // ?
+//       // if let Some(link) = &events[index].link {
+//       //     if let Some(next) = link.next {
+//       //         events[next].link.as_mut().unwrap().previous = Some(index + add - rm);
+//       //         while jumpIndex < jumps.len() && jumps[jumpIndex].0 <= next {
+//       //             add = jumps[jumpIndex].2;
+//       //             rm = jumps[jumpIndex].1;
+//       //             jumpIndex += 1;
+//       //         }
+//       //         events[index].link.as_mut().unwrap().next = Some(next + add - rm);
+//       //         index = next;
+//       //         continue;
+//       //     }
+//       // }
+//       index += 1
+//     }
+//   }
+// }
+
 /**
  * @import {
  *   Construct,
@@ -5988,12 +6266,12 @@ function initializeDocument(effects) {
         };
         index++;
       }
-
+      const editMap = new EditMap$1();
       // Inject the exits earlier (they’re still also at the end).
-      splice(self.events, indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits));
-
+      editMap.add(indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits));
       // Discard the duplicate exits.
-      self.events.length = index;
+      editMap.add(indexBeforeExits, index - indexBeforeExits, []);
+      editMap.consume(self.events);
       return checkNewContainers(code);
     }
     return start(code);
@@ -6036,7 +6314,9 @@ function initializeDocument(effects) {
 
   /** @type {State} */
   function thereIsANewContainer(code) {
-    if (childFlow) closeFlow();
+    if (childFlow) {
+      closeFlow();
+    }
     exitContainers(continued);
     return documentContinued(code);
   }
@@ -6066,7 +6346,9 @@ function initializeDocument(effects) {
   /** @type {State} */
   function flowStart(code) {
     if (code === null) {
-      if (childFlow) closeFlow();
+      if (childFlow) {
+        closeFlow();
+      }
       exitContainers(0);
       effects.consume(code);
       return;
@@ -6110,9 +6392,13 @@ function initializeDocument(effects) {
    */
   function writeToChild(token, endOfFile) {
     const stream = self.sliceStream(token);
-    if (endOfFile) stream.push(null);
+    if (endOfFile) {
+      stream.push(null);
+    }
     token.previous = childToken;
-    if (childToken) childToken.next = token;
+    if (childToken) {
+      childToken.next = token;
+    }
     childToken = token;
     childFlow.defineSkip(token.start);
     childFlow.write(stream);
@@ -6195,12 +6481,12 @@ function initializeDocument(effects) {
         };
         index++;
       }
-
+      const editMap = new EditMap$1();
       // Inject the exits earlier (they’re still also at the end).
-      splice(self.events, indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits));
-
+      editMap.add(indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits));
       // Discard the duplicate exits.
-      self.events.length = index;
+      editMap.add(indexBeforeExits, index - indexBeforeExits, []);
+      editMap.consume(self.events);
     }
   }
 
@@ -6316,7 +6602,7 @@ function resolveAll(constructs, events, context) {
  */
 
 /** @type {Construct} */
-const attention = {
+const attention$2 = {
   name: 'attention',
   resolveAll: resolveAllAttention,
   tokenize: tokenizeAttention
@@ -6330,22 +6616,8 @@ const attention = {
 // eslint-disable-next-line complexity
 function resolveAllAttention(events, context) {
   let index = -1;
-  /** @type {number} */
-  let open;
-  /** @type {Token} */
-  let group;
-  /** @type {Token} */
-  let text;
-  /** @type {Token} */
-  let openingSequence;
-  /** @type {Token} */
-  let closingSequence;
-  /** @type {number} */
-  let use;
   /** @type {Array<Event>} */
   let nextEvents;
-  /** @type {number} */
-  let offset;
 
   // Walk through all events.
   //
@@ -6354,7 +6626,7 @@ function resolveAllAttention(events, context) {
   while (++index < events.length) {
     // Find a token that can close.
     if (events[index][0] === 'enter' && events[index][1].type === 'attentionSequence' && events[index][1]._close) {
-      open = index;
+      let open = index;
 
       // Now walk back to find an opener.
       while (open--) {
@@ -6371,7 +6643,7 @@ function resolveAllAttention(events, context) {
           }
 
           // Number of markers to use from the sequence.
-          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
           };
@@ -6380,21 +6652,21 @@ function resolveAllAttention(events, context) {
           };
           movePoint(start, -use);
           movePoint(end, use);
-          openingSequence = {
+          const openingSequence = {
             type: use > 1 ? "strongSequence" : "emphasisSequence",
             start,
             end: {
               ...events[open][1].end
             }
           };
-          closingSequence = {
+          const closingSequence = {
             type: use > 1 ? "strongSequence" : "emphasisSequence",
             start: {
               ...events[index][1].start
             },
             end
           };
-          text = {
+          const text = {
             type: use > 1 ? "strongText" : "emphasisText",
             start: {
               ...events[open][1].end
@@ -6403,7 +6675,7 @@ function resolveAllAttention(events, context) {
               ...events[index][1].start
             }
           };
-          group = {
+          const group = {
             type: use > 1 ? "strong" : "emphasis",
             start: {
               ...openingSequence.start
@@ -6436,12 +6708,13 @@ function resolveAllAttention(events, context) {
           // Closing.
           nextEvents = push(nextEvents, [['exit', text, context], ['enter', closingSequence, context], ['exit', closingSequence, context], ['exit', group, context]]);
 
+          /** @type {number} */
+          let offset = 0;
+
           // If there are more markers in the closing, add them after.
           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;
@@ -6513,8 +6786,11 @@ function tokenizeAttention(effects, ok) {
 
     // Always populated by defaults.
 
-    const open = !after || after === 2 && before || attentionMarkers.includes(code);
-    const close = !before || before === 2 && after || attentionMarkers.includes(previous);
+    // Note: `*` and `_` are in `attentionMarkers` through core.
+    // They are excluded here as the loosening is meant for markers registered
+    // by *other* constructs (such as GFM strikethrough’s `~`).
+    const open = !after || after === 2 && before || attentionMarkers.includes(code) && code !== 42 && code !== 95;
+    const close = !before || before === 2 && after || attentionMarkers.includes(previous) && previous !== 42 && previous !== 95;
     token._open = Boolean(marker === 42 ? open : open && (before || !close));
     token._close = Boolean(marker === 42 ? close : close && (after || !open));
     return ok(code);
@@ -7189,7 +7465,6 @@ function tokenizeCharacterReference(effects, ok, nok) {
 
 /**
  * @import {
- *   Code,
  *   Construct,
  *   State,
  *   TokenizeContext,
@@ -7203,6 +7478,63 @@ const nonLazyContinuation = {
   tokenize: tokenizeNonLazyContinuation
 };
 
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Tokenizer}
+ */
+function tokenizeNonLazyContinuation(effects, ok, nok) {
+  const self = this;
+  return start;
+
+  /**
+   * At eol, before continuation.
+   *
+   * ```markdown
+   * > | * ```js
+   *            ^
+   *   | b
+   * ```
+   *
+   * @type {State}
+   */
+  function start(code) {
+    if (code === null) {
+      return nok(code);
+    }
+    effects.enter("lineEnding");
+    effects.consume(code);
+    effects.exit("lineEnding");
+    return after;
+  }
+
+  /**
+   * A continuation.
+   *
+   * ```markdown
+   *   | * ```js
+   * > | b
+   *     ^
+   * ```
+   *
+   * @type {State}
+   */
+  function after(code) {
+    return self.parser.lazy[self.now().line] ? nok(code) : ok(code);
+  }
+}
+
+/**
+ * @import {
+ *   Code,
+ *   Construct,
+ *   State,
+ *   TokenizeContext,
+ *   Tokenizer
+ * } from 'micromark-util-types'
+ */
+
+
 /** @type {Construct} */
 const codeFenced = {
   concrete: true,
@@ -7612,40 +7944,6 @@ function tokenizeCodeFenced(effects, ok, nok) {
   }
 }
 
-/**
- * @this {TokenizeContext}
- *   Context.
- * @type {Tokenizer}
- */
-function tokenizeNonLazyContinuation(effects, ok, nok) {
-  const self = this;
-  return start;
-
-  /**
-   *
-   *
-   * @type {State}
-   */
-  function start(code) {
-    if (code === null) {
-      return nok(code);
-    }
-    effects.enter("lineEnding");
-    effects.consume(code);
-    effects.exit("lineEnding");
-    return lineStart;
-  }
-
-  /**
-   *
-   *
-   * @type {State}
-   */
-  function lineStart(code) {
-    return self.parser.lazy[self.now().line] ? nok(code) : ok(code);
-  }
-}
-
 /**
  * @import {
  *   Construct,
@@ -7673,7 +7971,6 @@ const furtherStart = {
  * @type {Tokenizer}
  */
 function tokenizeCodeIndented(effects, ok, nok) {
-  const self = this;
   return start;
 
   /**
@@ -7694,24 +7991,7 @@ function tokenizeCodeIndented(effects, ok, nok) {
     // To do: manually check if interrupting like `markdown-rs`.
 
     effects.enter("codeIndented");
-    // To do: use an improved `space_or_tab` function like `markdown-rs`,
-    // so that we can drop the next state.
-    return factorySpace(effects, afterPrefix, "linePrefix", 4 + 1)(code);
-  }
-
-  /**
-   * At start, after 1 or 4 spaces.
-   *
-   * ```markdown
-   * > |     aaa
-   *         ^
-   * ```
-   *
-   * @type {State}
-   */
-  function afterPrefix(code) {
-    const tail = self.events[self.events.length - 1];
-    return tail && tail[1].type === "linePrefix" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? atBreak(code) : nok(code);
+    return factorySpaceMinMax(effects, atBreak, nok, "linePrefix", 4, 4)(code);
   }
 
   /**
@@ -7800,25 +8080,25 @@ function tokenizeFurtherStart(effects, ok, nok) {
     // To do: the code here in `micromark-js` is a bit different from
     // `markdown-rs` because there it can attempt spaces.
     // We can’t yet.
-    //
-    // To do: use an improved `space_or_tab` function like `markdown-rs`,
-    // so that we can drop the next state.
-    return factorySpace(effects, afterPrefix, "linePrefix", 4 + 1)(code);
+    return factorySpaceMinMax(effects, ok, onNotEnoughPrefix, "linePrefix", 4, 4)(code);
   }
 
   /**
-   * At start, after 1 or 4 spaces.
+   * After not enough of a prefix.
+   *
+   * A following line ending is another (potentially blank) line to try,
+   * anything else means this isn’t a continuation.
    *
    * ```markdown
    * > |     aaa
-   *         ^
+   *
+   *   |     bbb
    * ```
    *
    * @type {State}
    */
-  function afterPrefix(code) {
-    const tail = self.events[self.events.length - 1];
-    return tail && tail[1].type === "linePrefix" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? ok(code) : markdownLineEnding(code) ? furtherStart(code) : nok(code);
+  function onNotEnoughPrefix(code) {
+    return markdownLineEnding(code) ? furtherStart(code) : nok(code);
   }
 }
 
@@ -9565,10 +9845,6 @@ const headingAtx = {
 function resolveHeadingAtx(events, context) {
   let contentEnd = events.length - 2;
   let contentStart = 3;
-  /** @type {Token} */
-  let content;
-  /** @type {Token} */
-  let text;
 
   // Prefix whitespace, part of the opening.
   if (events[contentStart][1].type === "whitespace") {
@@ -9583,12 +9859,12 @@ function resolveHeadingAtx(events, context) {
     contentEnd -= contentStart + 1 === contentEnd ? 2 : 4;
   }
   if (contentEnd > contentStart) {
-    content = {
+    const content = {
       type: "atxHeadingText",
       start: events[contentStart][1].start,
       end: events[contentEnd][1].end
     };
-    text = {
+    const text = {
       type: "chunkText",
       start: events[contentStart][1].start,
       end: events[contentEnd][1].end,
@@ -9855,10 +10131,6 @@ const blankLineBefore = {
   partial: true,
   tokenize: tokenizeBlankLineBefore
 };
-const nonLazyContinuationStart = {
-  partial: true,
-  tokenize: tokenizeNonLazyContinuationStart
-};
 
 /** @type {Resolver} */
 function resolveToHtmlFlow(events) {
@@ -10437,7 +10709,7 @@ function tokenizeHtmlFlow(effects, ok, nok) {
    * @type {State}
    */
   function continuationStart(code) {
-    return effects.check(nonLazyContinuationStart, continuationStartNonLazy, continuationAfter)(code);
+    return effects.check(nonLazyContinuation, continuationStartNonLazy, continuationAfter)(code);
   }
 
   /**
@@ -10631,52 +10903,6 @@ function tokenizeHtmlFlow(effects, ok, nok) {
   }
 }
 
-/**
- * @this {TokenizeContext}
- *   Context.
- * @type {Tokenizer}
- */
-function tokenizeNonLazyContinuationStart(effects, ok, nok) {
-  const self = this;
-  return start;
-
-  /**
-   * At eol, before continuation.
-   *
-   * ```markdown
-   * > | * ```js
-   *            ^
-   *   | b
-   * ```
-   *
-   * @type {State}
-   */
-  function start(code) {
-    if (markdownLineEnding(code)) {
-      effects.enter("lineEnding");
-      effects.consume(code);
-      effects.exit("lineEnding");
-      return after;
-    }
-    return nok(code);
-  }
-
-  /**
-   * A continuation.
-   *
-   * ```markdown
-   *   | * ```js
-   * > | b
-   *     ^
-   * ```
-   *
-   * @type {State}
-   */
-  function after(code) {
-    return self.parser.lazy[self.now().line] ? nok(code) : ok(code);
-  }
-}
-
 /**
  * @this {TokenizeContext}
  *   Context.
@@ -11441,8 +11667,6 @@ function resolveAllLabelEnd(events) {
 function resolveToLabelEnd(events, context) {
   let index = events.length;
   let offset = 0;
-  /** @type {Token} */
-  let token;
   /** @type {number | undefined} */
   let open;
   /** @type {number | undefined} */
@@ -11452,7 +11676,7 @@ function resolveToLabelEnd(events, context) {
 
   // Find an opening.
   while (index--) {
-    token = events[index][1];
+    const token = events[index][1];
     if (open) {
       // If we see another link, or inactive link label, we’ve been here before.
       if (token.type === "link" || token.type === "labelLink" && token._inactive) {
@@ -11535,18 +11759,18 @@ function resolveToLabelEnd(events, context) {
  */
 function tokenizeLabelEnd(effects, ok, nok) {
   const self = this;
-  let index = self.events.length;
+  const labelStarts = self._labelStarts;
   /** @type {Token} */
   let labelStart;
   /** @type {boolean} */
   let defined;
-
-  // Find an opening.
-  while (index--) {
-    if ((self.events[index][1].type === "labelImage" || self.events[index][1].type === "labelLink") && !self.events[index][1]._balanced) {
-      labelStart = self.events[index][1];
-      break;
+  if (labelStarts) {
+    // Discard ones that failed to close,
+    // they’re not needed anymore.
+    while (labelStarts.length > 0 && labelStarts[labelStarts.length - 1]._balanced) {
+      labelStarts.pop();
     }
+    labelStart = labelStarts[labelStarts.length - 1];
   }
   return start;
 
@@ -11665,6 +11889,9 @@ function tokenizeLabelEnd(effects, ok, nok) {
    */
   function labelEndOk(code) {
     // Note: `markdown-rs` does a bunch of stuff here.
+    // This label start is now used up: discard it so it’s never found again.
+
+    labelStarts.pop();
     return ok(code);
   }
 
@@ -11938,6 +12165,7 @@ function tokenizeReferenceCollapsed(effects, ok, nok) {
  * @import {
  *   Construct,
  *   State,
+ *   Token,
  *   TokenizeContext,
  *   Tokenizer
  * } from 'micromark-util-types'
@@ -11958,6 +12186,8 @@ const labelStartImage = {
  */
 function tokenizeLabelStartImage(effects, ok, nok) {
   const self = this;
+  /** @type {Token} */
+  let labelImage;
   return start;
 
   /**
@@ -11993,7 +12223,7 @@ function tokenizeLabelStartImage(effects, ok, nok) {
       effects.enter("labelMarker");
       effects.consume(code);
       effects.exit("labelMarker");
-      effects.exit("labelImage");
+      labelImage = effects.exit("labelImage");
       return after;
     }
     return nok(code);
@@ -12031,8 +12261,13 @@ function tokenizeLabelStartImage(effects, ok, nok) {
     // `micromark-extension-gfm-footnote`, but the `label-start-link`
     // behavior isn’t.
     // Hidden footnotes hook.
-    /* c8 ignore next 3 */
-    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs ? nok(code) : ok(code);
+    /* c8 ignore next 6 */
+    if (code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs) {
+      return nok(code);
+    }
+    self._labelStarts = self._labelStarts || [];
+    self._labelStarts.push(labelImage);
+    return ok(code);
   }
 }
 
@@ -12040,6 +12275,7 @@ function tokenizeLabelStartImage(effects, ok, nok) {
  * @import {
  *   Construct,
  *   State,
+ *   Token,
  *   TokenizeContext,
  *   Tokenizer
  * } from 'micromark-util-types'
@@ -12060,6 +12296,8 @@ const labelStartLink = {
  */
 function tokenizeLabelStartLink(effects, ok, nok) {
   const self = this;
+  /** @type {Token} */
+  let labelLink;
   return start;
 
   /**
@@ -12077,7 +12315,7 @@ function tokenizeLabelStartLink(effects, ok, nok) {
     effects.enter("labelMarker");
     effects.consume(code);
     effects.exit("labelMarker");
-    effects.exit("labelLink");
+    labelLink = effects.exit("labelLink");
     return after;
   }
 
@@ -12086,8 +12324,13 @@ function tokenizeLabelStartLink(effects, ok, nok) {
     // To do: this isn’t needed in `micromark-extension-gfm-footnote`,
     // remove.
     // Hidden footnotes hook.
-    /* c8 ignore next 3 */
-    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs ? nok(code) : ok(code);
+    /* c8 ignore next 6 */
+    if (code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs) {
+      return nok(code);
+    }
+    self._labelStarts = self._labelStarts || [];
+    self._labelStarts.push(labelLink);
+    return ok(code);
   }
 }
 
@@ -12454,7 +12697,7 @@ const setextUnderline = {
 
 /** @type {Resolver} */
 function resolveToSetextUnderline(events, context) {
-  // To do: resolve like `markdown-rs`.
+  const editMap = new EditMap$1();
   let index = events.length;
   /** @type {number | undefined} */
   let content;
@@ -12479,7 +12722,7 @@ function resolveToSetextUnderline(events, context) {
     else {
       if (events[index][1].type === "content") {
         // Remove the content end (if needed we’ll add it later)
-        events.splice(index, 1);
+        editMap.add(index, 1, []);
       }
       if (!definition && events[index][1].type === "definition") {
         definition = index;
@@ -12502,8 +12745,8 @@ function resolveToSetextUnderline(events, context) {
   // If we have definitions in the content, we’ll keep on having content,
   // but we need move it.
   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
     };
@@ -12512,7 +12755,8 @@ function resolveToSetextUnderline(events, context) {
   }
 
   // Add the heading exit at the end.
-  events.push(['exit', heading, context]);
+  editMap.add(events.length, 0, [['exit', heading, context]]);
+  editMap.consume(events);
   return events;
 }
 
@@ -12818,6 +13062,7 @@ function createResolver(extraResolver) {
  * @type {Resolver}
  */
 function resolveAllLineSuffixes(events, context) {
+  const editMap = new EditMap$1();
   let eventIndex = 0; // Skip first.
 
   while (++eventIndex <= events.length) {
@@ -12837,7 +13082,9 @@ function resolveAllLineSuffixes(events, context) {
             size++;
             bufferIndex--;
           }
-          if (bufferIndex) break;
+          if (bufferIndex) {
+            break;
+          }
           bufferIndex = -1;
         }
         // Number
@@ -12875,13 +13122,13 @@ 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;
 }
 
@@ -12945,18 +13192,18 @@ const text$6 = {
   [-3]: lineEnding,
   [33]: labelStartImage,
   [38]: characterReference,
-  [42]: attention,
+  [42]: attention$2,
   [60]: [autolink, htmlText],
   [91]: labelStartLink,
   [92]: [hardBreakEscape, characterEscape],
   [93]: labelEnd,
-  [95]: attention,
+  [95]: attention$2,
   [96]: codeText
 };
 
 /** @satisfies {Extension['insideSpan']} */
 const insideSpan = {
-  null: [attention, resolver]
+  null: [attention$2, resolver]
 };
 
 /** @satisfies {Extension['attentionMarkers']} */
@@ -13150,14 +13397,12 @@ function createTokenizer(parser, initialize, from) {
    *   Nothing.
    */
   function main() {
-    /** @type {number} */
-    let chunkIndex;
     while (point._index < chunks.length) {
       const chunk = chunks[point._index];
 
       // If we’re in a buffer chunk, loop through it.
       if (typeof chunk === 'string') {
-        chunkIndex = point._index;
+        const chunkIndex = point._index;
         if (point._bufferIndex < 0) {
           point._bufferIndex = 0;
         }
@@ -13513,38 +13758,42 @@ function serializeChunks(chunks, expandTabs) {
     let value;
     if (typeof chunk === 'string') {
       value = chunk;
-    } else switch (chunk) {
-      case -5:
-        {
-          value = "\r";
-          break;
-        }
-      case -4:
-        {
-          value = "\n";
-          break;
-        }
-      case -3:
-        {
-          value = "\r" + "\n";
-          break;
-        }
-      case -2:
-        {
-          value = expandTabs ? " " : "\t";
-          break;
-        }
-      case -1:
-        {
-          if (!expandTabs && atTab) continue;
-          value = " ";
-          break;
-        }
-      default:
-        {
-          // Currently only replacement character.
-          value = String.fromCharCode(chunk);
-        }
+    } else {
+      switch (chunk) {
+        case -5:
+          {
+            value = "\r";
+            break;
+          }
+        case -4:
+          {
+            value = "\n";
+            break;
+          }
+        case -3:
+          {
+            value = "\r" + "\n";
+            break;
+          }
+        case -2:
+          {
+            value = expandTabs ? " " : "\t";
+            break;
+          }
+        case -1:
+          {
+            if (!expandTabs && atTab) {
+              continue;
+            }
+            value = " ";
+            break;
+          }
+        default:
+          {
+            // Currently only replacement character.
+            value = String.fromCharCode(chunk);
+          }
+      }
     }
     atTab = chunk === -2;
     result.push(value);
@@ -13655,20 +13904,11 @@ function preprocess() {
   /** @type {Preprocessor} */
   // eslint-disable-next-line complexity
   function preprocessor(value, encoding, end) {
+    value = buffer + (typeof value === 'string' ? value.toString() : new TextDecoder(encoding || undefined).decode(value));
+
     /** @type {Array<Chunk>} */
     const chunks = [];
-    /** @type {RegExpMatchArray | null} */
-    let match;
-    /** @type {number} */
-    let next;
-    /** @type {number} */
-    let startPosition;
-    /** @type {number} */
-    let endPosition;
-    /** @type {Code} */
-    let code;
-    value = buffer + (typeof value === 'string' ? value.toString() : new TextDecoder(encoding || undefined).decode(value));
-    startPosition = 0;
+    let startPosition = 0;
     buffer = '';
     if (start) {
       // To do: `markdown-rs` actually parses BOMs (byte order mark).
@@ -13679,9 +13919,9 @@ function preprocess() {
     }
     while (startPosition < value.length) {
       search$1.lastIndex = startPosition;
-      match = search$1.exec(value);
-      endPosition = match && match.index !== undefined ? match.index : value.length;
-      code = value.charCodeAt(endPosition);
+      const match = search$1.exec(value);
+      const endPosition = match && match.index !== undefined ? match.index : value.length;
+      const code = value.charCodeAt(endPosition);
       if (!match) {
         buffer = value.slice(startPosition);
         break;
@@ -13707,9 +13947,11 @@ function preprocess() {
             }
           case 9:
             {
-              next = Math.ceil(column / 4) * 4;
+              const next = Math.ceil(column / 4) * 4;
               chunks.push(-2);
-              while (column++ < next) chunks.push(-1);
+              while (column++ < next) {
+                chunks.push(-1);
+              }
               break;
             }
           case 10:
@@ -13728,8 +13970,12 @@ function preprocess() {
       startPosition = endPosition + 1;
     }
     if (end) {
-      if (atCarriageReturn) chunks.push(-5);
-      if (buffer) chunks.push(buffer);
+      if (atCarriageReturn) {
+        chunks.push(-5);
+      }
+      if (buffer) {
+        chunks.push(buffer);
+      }
       chunks.push(null);
     }
     return chunks;
@@ -13862,6 +14108,8 @@ function fromMarkdown(value, encoding, options) {
 function compiler(options) {
   /** @type {Config} */
   const config = {
+    afterExit: [],
+    beforeEnter: [],
     transforms: [],
     canContainEols: ['emphasis', 'fragment', 'heading', 'paragraph', 'strong'],
     enter: {
@@ -13977,7 +14225,8 @@ function compiler(options) {
     /** @type {Root} */
     let tree = {
       type: 'root',
-      children: []
+      children: [],
+      position: undefined
     };
     /** @type {Omit<CompileContext, 'sliceSerialize'>} */
     const context = {
@@ -13992,26 +14241,45 @@ function compiler(options) {
     };
     /** @type {Array<number>} */
     const listStack = [];
+    /** @type {Array<Event>} */
+    const prepared = [];
     let index = -1;
+
+    // Add `listItem` tokens and infer spread.
+    // Each list is prepared while it is last in `prepared`, so nothing shifts.
     while (++index < events.length) {
-      // We preprocess lists to add `listItem` tokens, and to infer whether
-      // items the list itself are spread out.
+      prepared.push(events[index]);
       if (events[index][1].type === "listOrdered" || events[index][1].type === "listUnordered") {
         if (events[index][0] === 'enter') {
-          listStack.push(index);
+          listStack.push(prepared.length - 1);
         } else {
           const tail = listStack.pop();
-          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 (own$6.call(handler, events[index][1].type)) {
-        handler[events[index][1].type].call(Object.assign({
+        // Note: spread first, V8 has optimizations for object shape cloning.
+        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
-        }, context), events[index][1]);
+        }, events[index][1]);
       }
     }
 
@@ -14044,13 +14312,32 @@ function compiler(options) {
     return tree;
   }
 
+  /**
+   * @param {Array<Handle>} listeners
+   *   Listeners.
+   * @param {CompileContext} context
+   *   Context.
+   * @param {Token} token
+   *   Token.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  function callListeners(listeners, context, token) {
+    let index = -1;
+    while (++index < listeners.length) {
+      listeners[index].call(context, token);
+    }
+  }
+
   /**
    * @param {Array<Event>} events
+   *   Events, ending with the list to prepare.
    * @param {number} start
-   * @param {number} length
-   * @returns {number}
+   *   Index of the list enter.
+   * @returns {undefined}
    */
-  function prepareList(events, start, length) {
+  function prepareList(events, start) {
+    const end = events.length - 1;
     let index = start - 1;
     let containerBalance = -1;
     let listSpread = false;
@@ -14062,7 +14349,14 @@ function compiler(options) {
     let firstBlankLineIndex;
     /** @type {boolean | undefined} */
     let atMarker;
-    while (++index <= length) {
+    /**
+     * `listItem` events to insert before the event at `at`, in walk order.
+     * Merged in after the walk, as inserting while walking would shift the
+     * rest of the list once per item.
+     * @type {Array<{at: number, event: Event}>}
+     */
+    const insertions = [];
+    while (++index <= end) {
       const event = events[index];
       switch (event[1].type) {
         case "listUnordered":
@@ -14126,9 +14420,10 @@ function compiler(options) {
 
           // Fix position.
           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]]
+          });
         }
 
         // Create a new list item.
@@ -14142,16 +14437,29 @@ 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;
         }
       }
     }
+
+    // The list is at the end of `events`: take it off, then push it back with
+    // the insertions merged in.
+    // Nothing follows the list, so nothing shifts.
+    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]);
+    }
     events[start][1]._spread = listSpread;
-    return length;
   }
 
   /**
@@ -14238,7 +14546,8 @@ function compiler(options) {
         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 {
@@ -14707,11 +15016,18 @@ function compiler(options) {
   // Creaters.
   //
 
+  // Each node factory pre-declares `position` as undefined as the trailing
+  // property. enter() patches it to a real value, but the property already
+  // exists, so V8 sees a single hidden class for each node type from
+  // construction through the rest of the pipeline. Without the pre-declare,
+  // each node took a hidden-class transition when enter() added position.
+
   /** @returns {Blockquote} */
   function blockQuote() {
     return {
       type: 'blockquote',
-      children: []
+      children: [],
+      position: undefined
     };
   }
 
@@ -14721,7 +15037,8 @@ function compiler(options) {
       type: 'code',
       lang: null,
       meta: null,
-      value: ''
+      value: '',
+      position: undefined
     };
   }
 
@@ -14729,7 +15046,8 @@ function compiler(options) {
   function codeText() {
     return {
       type: 'inlineCode',
-      value: ''
+      value: '',
+      position: undefined
     };
   }
 
@@ -14740,7 +15058,8 @@ function compiler(options) {
       identifier: '',
       label: null,
       title: null,
-      url: ''
+      url: '',
+      position: undefined
     };
   }
 
@@ -14748,7 +15067,8 @@ function compiler(options) {
   function emphasis() {
     return {
       type: 'emphasis',
-      children: []
+      children: [],
+      position: undefined
     };
   }
 
@@ -14758,14 +15078,16 @@ function compiler(options) {
       type: 'heading',
       // @ts-expect-error `depth` will be set later.
       depth: 0,
-      children: []
+      children: [],
+      position: undefined
     };
   }
 
   /** @returns {Break} */
   function hardBreak() {
     return {
-      type: 'break'
+      type: 'break',
+      position: undefined
     };
   }
 
@@ -14773,7 +15095,8 @@ function compiler(options) {
   function html() {
     return {
       type: 'html',
-      value: ''
+      value: '',
+      position: undefined
     };
   }
 
@@ -14783,7 +15106,8 @@ function compiler(options) {
       type: 'image',
       title: null,
       url: '',
-      alt: null
+      alt: null,
+      position: undefined
     };
   }
 
@@ -14793,7 +15117,8 @@ function compiler(options) {
       type: 'link',
       title: null,
       url: '',
-      children: []
+      children: [],
+      position: undefined
     };
   }
 
@@ -14807,7 +15132,8 @@ function compiler(options) {
       ordered: token.type === 'listOrdered',
       start: null,
       spread: token._spread,
-      children: []
+      children: [],
+      position: undefined
     };
   }
 
@@ -14820,7 +15146,8 @@ function compiler(options) {
       type: 'listItem',
       spread: token._spread,
       checked: null,
-      children: []
+      children: [],
+      position: undefined
     };
   }
 
@@ -14828,7 +15155,8 @@ function compiler(options) {
   function paragraph() {
     return {
       type: 'paragraph',
-      children: []
+      children: [],
+      position: undefined
     };
   }
 
@@ -14836,7 +15164,8 @@ function compiler(options) {
   function strong() {
     return {
       type: 'strong',
-      children: []
+      children: [],
+      position: undefined
     };
   }
 
@@ -14844,14 +15173,16 @@ function compiler(options) {
   function text() {
     return {
       type: 'text',
-      value: ''
+      value: '',
+      position: undefined
     };
   }
 
   /** @returns {ThematicBreak} */
   function thematicBreak() {
     return {
-      type: 'thematicBreak'
+      type: 'thematicBreak',
+      position: undefined
     };
   }
 }
@@ -14916,6 +15247,15 @@ function extension(combined, extension) {
             }
             break;
           }
+        case 'afterExit':
+        case 'beforeEnter':
+          {
+            const right = extension[key];
+            if (right) {
+              combined[key].push(right);
+            }
+            break;
+          }
         case 'enter':
         case 'exit':
           {
@@ -14941,12 +15281,11 @@ function defaultOnError(left, right) {
       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');
 }
 
 /**
@@ -15430,7 +15769,11 @@ function findAndReplace(tree, list, options) {
     visitParents(tree, 'text', visitor);
   }
 
-  /** @type {BuildVisitor<Root, 'text'>} */
+  /**
+   * Visit a text node, and handle it if it is not in an ignored parent.
+   *
+   * @type {BuildVisitor<Root, 'text'>}
+   */
   function visitor(node, parents) {
     let index = -1;
     /** @type {Parents | undefined} */
@@ -15463,11 +15806,11 @@ function findAndReplace(tree, list, options) {
    * Handle a text node which is not in an ignored parent.
    *
    * @param {Text} node
-   *   Text node.
+   *   Text node to search in.
    * @param {Array<Parents>} parents
-   *   Parents.
+   *   Ancestors of `node`.
    * @returns {VisitorResult}
-   *   Result.
+   *   Where to continue visiting.
    */
   function handler(node, parents) {
     const parent = parents[parents.length - 1];
@@ -15507,16 +15850,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;
@@ -15532,7 +15872,7 @@ 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);
@@ -15541,6 +15881,24 @@ function findAndReplace(tree, list, options) {
     }
 
     return index + nodes.length
+
+    /**
+     * Add a node.
+     *
+     * @param {PhrasingContent} child
+     *   Node to add.
+     * @returns {undefined}
+     *   Nothing.
+     */
+    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);
+      }
+    }
   }
 }
 
@@ -15553,13 +15911,13 @@ function findAndReplace(tree, list, options) {
  *   Clean pairs.
  */
 function toPairs(tupleOrList) {
-  /** @type {Pairs} */
-  const result = [];
-
   if (!Array.isArray(tupleOrList)) {
     throw new TypeError('Expected find and replace tuple or list of tuples')
   }
 
+  /** @type {Pairs} */
+  const result = [];
+
   /** @type {FindAndReplaceList} */
   // @ts-expect-error: correct.
   const list =
@@ -15581,9 +15939,9 @@ function toPairs(tupleOrList) {
  * Turn a find into an expression.
  *
  * @param {Find} find
- *   Find.
+ *   Pattern to find.
  * @returns {RegExp}
- *   Expression.
+ *   Global expression.
  */
 function toExpression(find) {
   return typeof find === 'string' ? new RegExp(escapeStringRegexp(find), 'g') : find
@@ -15593,9 +15951,9 @@ function toExpression(find) {
  * Turn a replace into a function.
  *
  * @param {Replace} replace
- *   Replace.
+ *   Thing to replace with.
  * @returns {ReplaceFunction}
- *   Function.
+ *   Function that returns that thing.
  */
 function toFunction(replace) {
   return typeof replace === 'function'
@@ -16094,15 +16452,18 @@ function mapAll(line, index, blank) {
 }
 
 /**
- * @typedef {import('mdast').Delete} Delete
- *
- * @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext
- * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension
- * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle
- *
- * @typedef {import('mdast-util-to-markdown').ConstructName} ConstructName
- * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle
- * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension
+ * @import {Delete} from 'mdast'
+ * @import {
+ *   CompileContext,
+ *   Extension as FromMarkdownExtension,
+ *   Handle as FromMarkdownHandle
+ * } from 'mdast-util-from-markdown'
+ * @import {
+ *   Attention,
+ *   ConstructName,
+ *   Handle as ToMarkdownHandle,
+ *   Options as ToMarkdownExtension
+ * } from 'mdast-util-to-markdown'
  */
 
 /**
@@ -16124,6 +16485,7 @@ const constructsWithoutStrikethrough = [
   'titleApostrophe'
 ];
 
+handleDelete.attention = attentionDelete;
 handleDelete.peek = peekDelete;
 
 /**
@@ -16150,26 +16512,30 @@ function gfmStrikethroughFromMarkdown() {
  */
 function gfmStrikethroughToMarkdown() {
   return {
+    handlers: {delete: handleDelete},
     unsafe: [
       {
         character: '~',
         inConstruct: 'phrasing',
         notInConstruct: constructsWithoutStrikethrough
       }
-    ],
-    handlers: {delete: handleDelete}
+    ]
   }
 }
 
 /**
+ * Enter strikethrough.
+ *
  * @this {CompileContext}
  * @type {FromMarkdownHandle}
  */
 function enterStrikethrough(token) {
-  this.enter({type: 'delete', children: []}, token);
+  this.enter({type: 'delete', children: [], position: undefined}, token);
 }
 
 /**
+ * Exit strikethrough.
+ *
  * @this {CompileContext}
  * @type {FromMarkdownHandle}
  */
@@ -16178,24 +16544,43 @@ function exitStrikethrough(token) {
 }
 
 /**
+ * Serialize a delete node.
+ *
  * @type {ToMarkdownHandle}
  * @param {Delete} node
+ *   Node to serialize.
  */
 function handleDelete(node, _, state, info) {
+  // To do: next major: empty this function, like emphasis and strong handlers,
+  // this is no longer needed.
   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
 }
 
-/** @type {ToMarkdownHandle} */
+/**
+ * Serialize a delete node as attention.
+ *
+ * @type {Attention}
+ */
+function attentionDelete() {
+  return {construct: 'strikethrough', markers: ['~'], sizes: [2, 1]}
+}
+
+/**
+ * Peek the first character of a delete node.
+ *
+ * @type {ToMarkdownHandle}
+ */
 function peekDelete() {
   return '~'
 }
@@ -16594,6 +16979,51 @@ function toAlignment(value) {
         : 0
 }
 
+/**
+ * @typedef {import('mdast').Html} Html
+ * @typedef {import('mdast').PhrasingContent} PhrasingContent
+ */
+
+
+/**
+ * Check if the given value is *phrasing content*.
+ *
+ * > 👉 **Note**: Excludes `html`, which can be both phrasing or flow.
+ *
+ * @param node
+ *   Thing to check, typically `Node`.
+ * @returns
+ *   Whether `value` is phrasing content.
+ */
+
+const phrasing =
+  /** @type {(node?: unknown) => node is Exclude<PhrasingContent, Html>} */
+  (
+    convert([
+      'break',
+      'delete',
+      'emphasis',
+      // To do: next major: removed since footnotes were added to GFM.
+      'footnote',
+      'footnoteReference',
+      'image',
+      'imageReference',
+      'inlineCode',
+      // Enabled by `mdast-util-math`:
+      'inlineMath',
+      'link',
+      'linkReference',
+      // Enabled by `mdast-util-mdx`:
+      'mdxJsxTextElement',
+      // Enabled by `mdast-util-mdx`:
+      'mdxTextExpression',
+      'strong',
+      'text',
+      // Enabled by `mdast-util-directive`:
+      'textDirective'
+    ])
+  );
+
 /**
  * @callback Handler
  *   Handle a value, with a certain ID field set to a certain value.
@@ -16719,11 +17149,18 @@ function zwitch(key, options) {
  */
 
 /**
+ * Serialize a blockquote node.
+ *
  * @param {Blockquote} node
+ *   Node to serialize.
  * @param {Parents | undefined} _
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @param {Info} info
+ *   Info on surrounding context.
  * @returns {string}
+ *   Serialized markdown.
  */
 function blockquote$1(node, _, state, info) {
   const exit = state.enter('blockquote');
@@ -16738,7 +17175,11 @@ function blockquote$1(node, _, state, info) {
   return value
 }
 
-/** @type {Map} */
+/**
+ * Indent lines w/ blockquote markers.
+ *
+ * @type {Map}
+ */
 function map$1(line, _, blank) {
   return '>' + (blank ? '' : ' ') + line
 }
@@ -16748,9 +17189,14 @@ function map$1(line, _, blank) {
  */
 
 /**
+ * Check if a pattern is in scope based on the current stack of constructs.
+ *
  * @param {Array<ConstructName>} stack
+ *   Current stack of constructs.
  * @param {Unsafe} pattern
+ *   Pattern to check.
  * @returns {boolean}
+ *   Whether the pattern is in scope.
  */
 function patternInScope(stack, pattern) {
   return (
@@ -16760,10 +17206,16 @@ function patternInScope(stack, pattern) {
 }
 
 /**
+ * Check if any of the constructs in the list are present in the stack.
+ *
  * @param {Array<ConstructName>} stack
+ *   Current stack of constructs.
  * @param {Unsafe['inConstruct']} list
+ *   List of constructs to check for in the stack.
  * @param {boolean} none
+ *   Value to return if the list is empty or not provided.
  * @returns {boolean}
+ *   Whether any of the constructs in the list are present in the stack.
  */
 function listInScope(stack, list, none) {
   if (typeof list === 'string') {
@@ -16792,23 +17244,34 @@ function listInScope(stack, list, none) {
 
 
 /**
+ * Serialize a break node.
+ *
  * @param {Break} _
+ *   Node to serialize.
  * @param {Parents | undefined} _1
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @param {Info} info
+ *   Info on surrounding context.
  * @returns {string}
+ *   Serialized markdown.
  */
 function hardBreak$1(_, _1, state, info) {
   let index = -1;
 
   while (++index < state.unsafe.length) {
-    // If we can’t put eols in this construct (setext headings, tables), use a
-    // space instead.
+    const pattern = state.unsafe[index];
+
+    // If we can’t put unconditional eols in this construct (setext headings,
+    // tables), use a space instead.
     if (
-      state.unsafe[index].character === '\n' &&
-      patternInScope(state.stack, state.unsafe[index])
+      pattern.character === '\n' &&
+      !pattern.before &&
+      !pattern.after &&
+      patternInScope(state.stack, pattern)
     ) {
-      return /[ \t]/.test(info.before) ? '' : ' '
+      return /[\t ]/.test(info.before) ? '' : ' '
     }
   }
 
@@ -16858,20 +17321,25 @@ function longestStreak(value, substring) {
  */
 
 /**
+ * Checks if a code block can be formatted as an indented code block.
+ *
  * @param {Code} node
+ *   Node to check.
  * @param {State} state
+ *   Info passed around.
  * @returns {boolean}
+ *   Whether the code can be formatted as an indented code block.
  */
 function formatCodeAsIndented(node, state) {
   return Boolean(
     state.options.fences === false &&
-      node.value &&
-      // If there’s no info…
-      !node.lang &&
-      // And there’s a non-whitespace character…
-      /[^ \r\n]/.test(node.value) &&
-      // And the value doesn’t start or end in a blank…
-      !/^[\t ]*(?:[\r\n]|$)|(?:^|[\r\n])[\t ]*$/.test(node.value)
+    node.value &&
+    // If there’s no info…
+    !node.lang &&
+    // And there’s a non-whitespace character…
+    /[^\n\r ]/.test(node.value) &&
+    // And the value doesn’t start or end in a blank…
+    !/^[\t ]*(?:[\n\r]|$)|(?:^|[\n\r])[\t ]*$/.test(node.value)
   )
 }
 
@@ -16880,8 +17348,12 @@ function formatCodeAsIndented(node, state) {
  */
 
 /**
+ * Checks the preferred fence option.
+ *
  * @param {State} state
+ *   Info passed around.
  * @returns {Exclude<Options['fence'], null | undefined>}
+ *   Preferred fence marker.
  */
 function checkFence(state) {
   const marker = state.options.fence || '`';
@@ -16904,16 +17376,22 @@ function checkFence(state) {
 
 
 /**
+ * Serialize a code node.
+ *
  * @param {Code} node
+ *   Node to serialize.
  * @param {Parents | undefined} _
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @param {Info} info
+ *   Info on surrounding context.
  * @returns {string}
+ *   Serialized markdown.
  */
 function code$2(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');
@@ -16925,6 +17403,7 @@ function code$2(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) {
@@ -16965,7 +17444,11 @@ function code$2(node, _, state, info) {
   return value
 }
 
-/** @type {Map} */
+/**
+ * Indent lines w/ code indent.
+ *
+ * @type {Map}
+ */
 function map(line, _, blank) {
   return (blank ? '' : '    ') + line
 }
@@ -16975,8 +17458,12 @@ function map(line, _, blank) {
  */
 
 /**
+ * Checks the preferred quote option.
+ *
  * @param {State} state
+ *   Info passed around.
  * @returns {Exclude<Options['quote'], null | undefined>}
+ *   Preferred quote.
  */
 function checkQuote(state) {
   const marker = state.options.quote || '"';
@@ -16999,11 +17486,18 @@ function checkQuote(state) {
 
 
 /**
+ * Serialize a definition node.
+ *
  * @param {Definition} node
+ *   Node to serialize.
  * @param {Parents | undefined} _
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @param {Info} info
+ *   Info on surrounding context.
  * @returns {string}
+ *   Serialized markdown.
  */
 function definition(node, _, state, info) {
   const quote = checkQuote(state);
@@ -17073,8 +17567,12 @@ function definition(node, _, state, info) {
  */
 
 /**
+ * Checks the preferred emphasis option.
+ *
  * @param {State} state
+ *   Info passed around.
  * @returns {Exclude<Options['emphasis'], null | undefined>}
+ *   Preferred emphasis marker.
  */
 function checkEmphasis(state) {
   const marker = state.options.emphasis || '*';
@@ -17091,166 +17589,84 @@ function checkEmphasis(state) {
 }
 
 /**
- * Encode a code point as a character reference.
- *
- * @param {number} code
- *   Code point to encode.
- * @returns {string}
- *   Encoded character reference.
+ * @import {AttentionInfo, Info, State} from 'mdast-util-to-markdown'
+ * @import {Emphasis, Parents} from 'mdast'
  */
-function encodeCharacterReference(code) {
-  return '&#x' + code.toString(16).toUpperCase() + ';'
-}
 
-/**
- * @import {EncodeSides} from '../types.js'
- */
 
+emphasis$1.attention = attention$1;
+emphasis$1.peek = peek$1;
 
 /**
- * Check whether to encode (as a character reference) the characters
- * surrounding an attention run.
- *
- * Which characters are around an attention run influence whether it works or
- * not.
+ * Serialize an emphasis node.
  *
- * See <https://github.com/orgs/syntax-tree/discussions/60> for more info.
- * See this markdown in a particular renderer to see what works:
+ * Attention is properly handled by `containerPhrasing`.
  *
- * ```markdown
- * |                         | A (letter inside) | B (punctuation inside) | C (whitespace inside) | D (nothing inside) |
- * | ----------------------- | ----------------- | ---------------------- | --------------------- | ------------------ |
- * | 1 (letter outside)      | x*y*z             | x*.*z                  | x* *z                 | x**z               |
- * | 2 (punctuation outside) | .*y*.             | .*.*.                  | .* *.                 | .**.               |
- * | 3 (whitespace outside)  | x *y* z           | x *.* z                | x * * z               | x ** z             |
- * | 4 (nothing outside)     | *x*               | *.*                    | * *                   | **                 |
- * ```
- *
- * @param {number} outside
- *   Code point on the outer side of the run.
- * @param {number} inside
- *   Code point on the inner side of the run.
- * @param {'*' | '_'} marker
- *   Marker of the run.
- *   Underscores are handled more strictly (they form less often) than
- *   asterisks.
- * @returns {EncodeSides}
- *   Whether to encode characters.
- */
-// Important: punctuation must never be encoded.
-// Punctuation is solely used by markdown constructs.
-// And by encoding itself.
-// Encoding them will break constructs or double encode things.
-function encodeInfo(outside, inside, marker) {
-  const outsideKind = classifyCharacter(outside);
-  const insideKind = classifyCharacter(inside);
-
-  // Letter outside:
-  if (outsideKind === undefined) {
-    return insideKind === undefined
-      ? // Letter inside:
-        // we have to encode *both* letters for `_` as it is looser.
-        // it already forms for `*` (and GFMs `~`).
-        marker === '_'
-        ? {inside: true, outside: true}
-        : {inside: false, outside: false}
-      : insideKind === 1
-        ? // Whitespace inside: encode both (letter, whitespace).
-          {inside: true, outside: true}
-        : // Punctuation inside: encode outer (letter)
-          {inside: false, outside: true}
-  }
-
-  // Whitespace outside:
-  if (outsideKind === 1) {
-    return insideKind === undefined
-      ? // Letter inside: already forms.
-        {inside: false, outside: false}
-      : insideKind === 1
-        ? // Whitespace inside: encode both (whitespace).
-          {inside: true, outside: true}
-        : // Punctuation inside: already forms.
-          {inside: false, outside: false}
-  }
-
-  // Punctuation outside:
-  return insideKind === undefined
-    ? // Letter inside: already forms.
-      {inside: false, outside: false}
-    : insideKind === 1
-      ? // Whitespace inside: encode inner (whitespace).
-        {inside: true, outside: false}
-      : // Punctuation inside: already forms.
-        {inside: false, outside: false}
-}
-
-/**
- * @import {Info, State} from 'mdast-util-to-markdown'
- * @import {Emphasis, Parents} from 'mdast'
- */
-
-
-emphasis$1.peek = emphasisPeek;
-
-/**
  * @param {Emphasis} node
+ *   Node to serialize.
  * @param {Parents | undefined} _
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @param {Info} info
+ *   Info on surrounding context.
  * @returns {string}
+ *   Serialized markdown.
  */
 function emphasis$1(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();
+  return value
+}
 
-  state.attentionEncodeSurroundingInfo = {
-    after: close.outside,
-    before: open.outside
-  };
-  return before + between + after
+/**
+ * Serialize an emphasis node as attention.
+ *
+ * @param {Emphasis} _
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {AttentionInfo}
+ *   Info on how to serialize the node.
+ */
+function attention$1(_, state) {
+  const marker = checkEmphasis(state);
+  return {
+    construct: 'emphasis',
+    markers: marker === '*' ? ['*', '_'] : ['_', '*'],
+    sizes: [1]
+  }
 }
 
 /**
+ * Peek at this node.
+ *
  * @param {Emphasis} _
+ *   Node to serialize.
  * @param {Parents | undefined} _1
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @returns {string}
+ *   Start of the serialized markdown.
  */
-function emphasisPeek(_, _1, state) {
+function peek$1(_, _1, state) {
   return state.options.emphasis || '*'
 }
 
+/**
+ * Encode a code point as a character reference.
+ *
+ * @param {number} code
+ *   Code point to encode.
+ * @returns {string}
+ *   Encoded character reference.
+ */
+function encodeCharacterReference(code) {
+  return '&#x' + code.toString(16).toUpperCase() + ';'
+}
+
 /**
  * @import {Node as UnistNode, Parent as UnistParent} from 'unist'
  * @import {VisitorResult} from 'unist-util-visit-parents'
@@ -17347,9 +17763,14 @@ function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {
 
 
 /**
+ * Checks if a heading can be formatted as a setext heading.
+ *
  * @param {Heading} node
+ *   Node to check.
  * @param {State} state
+ *   Info passed around.
  * @returns {boolean}
+ *   Whether the heading can be formatted as a setext heading.
  */
 function formatHeadingAsSetext(node, state) {
   let literalWithBreak = false;
@@ -17368,8 +17789,8 @@ function formatHeadingAsSetext(node, state) {
 
   return Boolean(
     (!node.depth || node.depth < 3) &&
-      toString$1(node) &&
-      (state.options.setext || literalWithBreak)
+    toString$1(node) &&
+    (state.options.setext || literalWithBreak)
   )
 }
 
@@ -17380,11 +17801,18 @@ function formatHeadingAsSetext(node, state) {
 
 
 /**
+ * Serialize a heading node.
+ *
  * @param {Heading} node
+ *   Node to serialize.
  * @param {Parents | undefined} _
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @param {Info} info
+ *   Info on surrounding context.
  * @returns {string}
+ *   Serialized markdown.
  */
 function heading$1(node, _, state, info) {
   const rank = Math.max(Math.min(6, node.depth || 1), 1);
@@ -17430,9 +17858,11 @@ function heading$1(node, _, state, info) {
     ...tracker.current()
   });
 
-  if (/^[\t ]/.test(value)) {
+  const head = value.charCodeAt(0);
+
+  if (head === 9 /* `\t` */ || head === 32 /* ` ` */) {
     // To do: what effect has the character reference on tracking?
-    value = encodeCharacterReference(value.charCodeAt(0)) + value.slice(1);
+    value = encodeCharacterReference(head) + value.slice(1);
   }
 
   value = value ? sequence + ' ' + value : sequence;
@@ -17454,15 +17884,22 @@ function heading$1(node, _, state, info) {
 html$5.peek = htmlPeek;
 
 /**
+ * Serialize an HTML node.
+ *
  * @param {Html} node
+ *   Node to serialize.
  * @returns {string}
+ *   Serialized markdown.
  */
 function html$5(node) {
   return node.value || ''
 }
 
 /**
+ * Peek at this node.
+ *
  * @returns {string}
+ *   Start of the serialized markdown.
  */
 function htmlPeek() {
   return '<'
@@ -17477,11 +17914,18 @@ function htmlPeek() {
 image$1.peek = imagePeek;
 
 /**
+ * Serialize an image node.
+ *
  * @param {Image} node
+ *   Node to serialize.
  * @param {Parents | undefined} _
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @param {Info} info
+ *   Info on surrounding context.
  * @returns {string}
+ *   Serialized markdown.
  */
 function image$1(node, _, state, info) {
   const quote = checkQuote(state);
@@ -17544,7 +17988,10 @@ function image$1(node, _, state, info) {
 }
 
 /**
+ * Peek at this node.
+ *
  * @returns {string}
+ *   Start of the serialized markdown.
  */
 function imagePeek() {
   return '!'
@@ -17558,11 +18005,18 @@ function imagePeek() {
 imageReference$1.peek = imageReferencePeek;
 
 /**
+ * Serialize an image reference node.
+ *
  * @param {ImageReference} node
+ *   Node to serialize.
  * @param {Parents | undefined} _
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @param {Info} info
+ *   Info on surrounding context.
  * @returns {string}
+ *   Serialized markdown.
  */
 function imageReference$1(node, _, state, info) {
   const type = node.referenceType;
@@ -17578,9 +18032,14 @@ function imageReference$1(node, _, state, info) {
   value += tracker.move(alt + '][');
 
   subexit();
-  // Hide the fact that we’re in phrasing, because escapes don’t work.
+  // Hide that we’re in phrasing as things like attention or code cannot form
+  // in references.
+  // Character escapes and references *do* work.
+  // It is important to know about other constructs, such as table cells.
   const stack = state.stack;
-  state.stack = [];
+  state.stack = stack.filter(function (d) {
+    return d !== 'phrasing'
+  });
   subexit = state.enter('reference');
   // Note: for proper tracking, we should reset the output positions when we end
   // up making a `shortcut` reference, because then there is no brace output.
@@ -17608,7 +18067,10 @@ function imageReference$1(node, _, state, info) {
 }
 
 /**
+ * Peek at this node.
+ *
  * @returns {string}
+ *   Start of the serialized markdown.
  */
 function imageReferencePeek() {
   return '!'
@@ -17622,10 +18084,16 @@ function imageReferencePeek() {
 inlineCode$1.peek = inlineCodePeek;
 
 /**
+ * Serialize an inline code node.
+ *
  * @param {InlineCode} node
+ *   Node to serialize.
  * @param {Parents | undefined} _
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @returns {string}
+ *   Serialized markdown.
  */
 function inlineCode$1(node, _, state) {
   let value = node.value || '';
@@ -17642,8 +18110,8 @@ function inlineCode$1(node, _, state) {
   // If this is not just spaces or eols (tabs don’t count), and either the
   // first or last character are a space, eol, or tick, then pad with spaces.
   if (
-    /[^ \r\n]/.test(value) &&
-    ((/^[ \r\n]/.test(value) && /[ \r\n]$/.test(value)) || /^`|`$/.test(value))
+    /[^\n\r ]/.test(value) &&
+    ((/^[\n\r ]/.test(value) && /[\n\r ]$/.test(value)) || /^`|`$/.test(value))
   ) {
     value = ' ' + value + ' ';
   }
@@ -17658,14 +18126,15 @@ function inlineCode$1(node, _, state) {
   while (++index < state.unsafe.length) {
     const pattern = state.unsafe[index];
     const expression = state.compilePattern(pattern);
-    /** @type {RegExpExecArray | null} */
-    let match;
 
     // Only look for `atBreak`s.
     // Btw: note that `atBreak` patterns will always start the regex at LF or
     // CR.
     if (!pattern.atBreak) continue
 
+    /** @type {RegExpExecArray | null} */
+    let match;
+
     while ((match = expression.exec(value))) {
       let position = match.index;
 
@@ -17685,7 +18154,10 @@ function inlineCode$1(node, _, state) {
 }
 
 /**
+ * Peek at this node.
+ *
  * @returns {string}
+ *   Start of the serialized markdown.
  */
 function inlineCodePeek() {
   return '`'
@@ -17698,30 +18170,35 @@ function inlineCodePeek() {
 
 
 /**
+ * Checks if a link can be formatted as an autolink.
+ *
  * @param {Link} node
+ *   Node to check.
  * @param {State} state
+ *   Info passed around.
  * @returns {boolean}
+ *   Whether the link can be formatted as an autolink.
  */
 function formatLinkAsAutolink(node, state) {
   const raw = toString$1(node);
 
   return Boolean(
     !state.options.resourceLink &&
-      // If there’s a url…
-      node.url &&
-      // And there’s a no title…
-      !node.title &&
-      // And the content of `node` is a single text node…
-      node.children &&
-      node.children.length === 1 &&
-      node.children[0].type === 'text' &&
-      // And if the url is the same as the content…
-      (raw === node.url || 'mailto:' + raw === node.url) &&
-      // And that starts w/ a protocol…
-      /^[a-z][a-z+.-]+:/i.test(node.url) &&
-      // And that doesn’t contain ASCII control codes (character escapes and
-      // references don’t work), space, or angle brackets…
-      !/[\0- <>\u007F]/.test(node.url)
+    // If there’s a url…
+    node.url &&
+    // And there’s no title…
+    !node.title &&
+    // And the content of `node` is a single text node…
+    node.children &&
+    node.children.length === 1 &&
+    node.children[0].type === 'text' &&
+    // And if the url is the same as the content…
+    (raw === node.url || 'mailto:' + raw === node.url) &&
+    // And that starts w/ a protocol…
+    /^[a-z][+\-.a-z]+:/i.test(node.url) &&
+    // And that doesn’t contain ASCII control codes (character escapes and
+    // references don’t work), space, or angle brackets…
+    !/[\0- <>\u007F]/.test(node.url)
   )
 }
 
@@ -17735,26 +18212,35 @@ function formatLinkAsAutolink(node, state) {
 link$1.peek = linkPeek;
 
 /**
+ * Serialize a link node.
+ *
  * @param {Link} node
+ *   Node to serialize.
  * @param {Parents | undefined} _
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @param {Info} info
+ *   Info on surrounding context.
  * @returns {string}
+ *   Serialized markdown.
  */
 function link$1(node, _, state, info) {
   const quote = checkQuote(state);
   const suffix = quote === '"' ? 'Quote' : 'Apostrophe';
   const tracker = state.createTracker(info);
-  /** @type {Exit} */
-  let exit;
-  /** @type {Exit} */
-  let subexit;
 
   if (formatLinkAsAutolink(node, state)) {
-    // Hide the fact that we’re in phrasing, because escapes don’t work.
+    // Hide that we’re in phrasing as things like attention or code cannot form
+    // in autolinks.
+    // Character escapes also don’t work (nor character references),
+    // but that is a different matter, which `safe.js` handles for `autolink`.
+    // It is important to know about other constructs, such as table cells.
     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, {
@@ -17769,8 +18255,8 @@ function link$1(node, _, state, info) {
     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, {
@@ -17829,10 +18315,16 @@ function link$1(node, _, state, info) {
 }
 
 /**
+ * Peek at this node.
+ *
  * @param {Link} node
+ *   Node to peek at.
  * @param {Parents | undefined} _
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @returns {string}
+ *   Start of the serialized markdown.
  */
 function linkPeek(node, _, state) {
   return formatLinkAsAutolink(node, state) ? '<' : '['
@@ -17846,11 +18338,18 @@ function linkPeek(node, _, state) {
 linkReference$1.peek = linkReferencePeek;
 
 /**
+ * Serialize a link reference node.
+ *
  * @param {LinkReference} node
+ *   Node to serialize.
  * @param {Parents | undefined} _
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @param {Info} info
+ *   Info on surrounding context.
  * @returns {string}
+ *   Serialized markdown.
  */
 function linkReference$1(node, _, state, info) {
   const type = node.referenceType;
@@ -17866,9 +18365,14 @@ function linkReference$1(node, _, state, info) {
   value += tracker.move(text + '][');
 
   subexit();
-  // Hide the fact that we’re in phrasing, because escapes don’t work.
+  // Hide that we’re in phrasing as things like attention or code cannot form
+  // in references.
+  // Character escapes and references *do* work.
+  // It is important to know about other constructs, such as table cells.
   const stack = state.stack;
-  state.stack = [];
+  state.stack = stack.filter(function (d) {
+    return d !== 'phrasing'
+  });
   subexit = state.enter('reference');
   // Note: for proper tracking, we should reset the output positions when we end
   // up making a `shortcut` reference, because then there is no brace output.
@@ -17896,7 +18400,10 @@ function linkReference$1(node, _, state, info) {
 }
 
 /**
+ * Peek at this node.
+ *
  * @returns {string}
+ *   Start of the serialized markdown.
  */
 function linkReferencePeek() {
   return '['
@@ -17907,8 +18414,12 @@ function linkReferencePeek() {
  */
 
 /**
+ * Checks the preferred list bullet option.
+ *
  * @param {State} state
+ *   Info passed around.
  * @returns {Exclude<Options['bullet'], null | undefined>}
+ *   Preferred list bullet.
  */
 function checkBullet(state) {
   const marker = state.options.bullet || '*';
@@ -17930,8 +18441,12 @@ function checkBullet(state) {
 
 
 /**
+ * Checks the preferred alternate list bullet option.
+ *
  * @param {State} state
+ *   Info passed around.
  * @returns {Exclude<Options['bullet'], null | undefined>}
+ *   Preferred alternate list bullet.
  */
 function checkBulletOther(state) {
   const bullet = checkBullet(state);
@@ -17967,8 +18482,12 @@ function checkBulletOther(state) {
  */
 
 /**
+ * Checks the preferred ordered list bullet option.
+ *
  * @param {State} state
+ *   Info passed around.
  * @returns {Exclude<Options['bulletOrdered'], null | undefined>}
+ *   Preferred ordered list bullet.
  */
 function checkBulletOrdered(state) {
   const marker = state.options.bulletOrdered || '.';
@@ -17989,8 +18508,12 @@ function checkBulletOrdered(state) {
  */
 
 /**
+ * Checks the preferred rule option.
+ *
  * @param {State} state
+ *   Info passed around.
  * @returns {Exclude<Options['rule'], null | undefined>}
+ *   Preferred rule marker.
  */
 function checkRule(state) {
   const marker = state.options.rule || '*';
@@ -18013,11 +18536,18 @@ function checkRule(state) {
 
 
 /**
+ * Serialize a list node.
+ *
  * @param {List} node
+ *   Node to serialize.
  * @param {Parents | undefined} parent
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @param {Info} info
+ *   Info on surrounding context.
  * @returns {string}
+ *   Serialized markdown.
  */
 function list$1(node, parent, state, info) {
   const exit = state.enter('list');
@@ -18108,8 +18638,12 @@ function list$1(node, parent, state, info) {
  */
 
 /**
+ * Checks the preferred list item indent option.
+ *
  * @param {State} state
+ *   Info passed around.
  * @returns {Exclude<Options['listItemIndent'], null | undefined>}
+ *   Preferred list item indent.
  */
 function checkListItemIndent(state) {
   const style = state.options.listItemIndent || 'one';
@@ -18132,11 +18666,18 @@ function checkListItemIndent(state) {
 
 
 /**
+ * Serialize a list item node.
+ *
  * @param {ListItem} node
+ *   Node to serialize.
  * @param {Parents | undefined} parent
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @param {Info} info
+ *   Info on surrounding context.
  * @returns {string}
+ *   Serialized markdown.
  */
 function listItem$1(node, parent, state, info) {
   const listItemIndent = checkListItemIndent(state);
@@ -18176,7 +18717,11 @@ function listItem$1(node, parent, state, info) {
 
   return value
 
-  /** @type {Map} */
+  /**
+   * Indent lines of the list item.
+   *
+   * @type {Map}
+   */
   function map(line, index, blank) {
     if (index) {
       return (blank ? '' : ' '.repeat(size)) + line
@@ -18192,11 +18737,18 @@ function listItem$1(node, parent, state, info) {
  */
 
 /**
+ * Serialize a paragraph node.
+ *
  * @param {Paragraph} node
+ *   Node to serialize.
  * @param {Parents | undefined} _
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @param {Info} info
+ *   Info on surrounding context.
  * @returns {string}
+ *   Serialized markdown.
  */
 function paragraph$1(node, _, state, info) {
   const exit = state.enter('paragraph');
@@ -18207,51 +18759,6 @@ function paragraph$1(node, _, state, info) {
   return value
 }
 
-/**
- * @typedef {import('mdast').Html} Html
- * @typedef {import('mdast').PhrasingContent} PhrasingContent
- */
-
-
-/**
- * Check if the given value is *phrasing content*.
- *
- * > 👉 **Note**: Excludes `html`, which can be both phrasing or flow.
- *
- * @param node
- *   Thing to check, typically `Node`.
- * @returns
- *   Whether `value` is phrasing content.
- */
-
-const phrasing =
-  /** @type {(node?: unknown) => node is Exclude<PhrasingContent, Html>} */
-  (
-    convert([
-      'break',
-      'delete',
-      'emphasis',
-      // To do: next major: removed since footnotes were added to GFM.
-      'footnote',
-      'footnoteReference',
-      'image',
-      'imageReference',
-      'inlineCode',
-      // Enabled by `mdast-util-math`:
-      'inlineMath',
-      'link',
-      'linkReference',
-      // Enabled by `mdast-util-mdx`:
-      'mdxJsxTextElement',
-      // Enabled by `mdast-util-mdx`:
-      'mdxTextExpression',
-      'strong',
-      'text',
-      // Enabled by `mdast-util-directive`:
-      'textDirective'
-    ])
-  );
-
 /**
  * @import {Info, State} from 'mdast-util-to-markdown'
  * @import {Parents, Root} from 'mdast'
@@ -18259,11 +18766,18 @@ const phrasing =
 
 
 /**
+ * Serialize a root node.
+ *
  * @param {Root} node
+ *   Node to serialize.
  * @param {Parents | undefined} _
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @param {Info} info
+ *   Info on surrounding context.
  * @returns {string}
+ *   Serialized markdown.
  */
 function root$4(node, _, state, info) {
   // Note: `html` nodes are ambiguous.
@@ -18271,8 +18785,12 @@ function root$4(node, _, state, info) {
     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
 }
 
 /**
@@ -18280,8 +18798,12 @@ function root$4(node, _, state, info) {
  */
 
 /**
+ * Checks the preferred strong option.
+ *
  * @param {State} state
+ *   Info passed around.
  * @returns {Exclude<Options['strong'], null | undefined>}
+ *   Preferred strong marker.
  */
 function checkStrong(state) {
   const marker = state.options.strong || '*';
@@ -18298,69 +18820,69 @@ function checkStrong(state) {
 }
 
 /**
- * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {AttentionInfo, Info, State} from 'mdast-util-to-markdown'
  * @import {Parents, Strong} from 'mdast'
  */
 
 
-strong$1.peek = strongPeek;
+strong$1.attention = attention;
+strong$1.peek = peek;
 
 /**
+ * Serialize a strong node.
+ *
+ * Attention is properly handled by `containerPhrasing`.
+ *
  * @param {Strong} node
+ *   Node to serialize.
  * @param {Parents | undefined} _
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @param {Info} info
+ *   Info on surrounding context.
  * @returns {string}
+ *   Serialized markdown.
  */
 function strong$1(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();
+  return value
+}
 
-  state.attentionEncodeSurroundingInfo = {
-    after: close.outside,
-    before: open.outside
-  };
-  return before + between + after
+/**
+ * Serialize a strong node as attention.
+ *
+ * @param {Strong} _
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {AttentionInfo}
+ *   Info on how to serialize the node.
+ */
+function attention(_, state) {
+  const marker = checkStrong(state);
+  return {
+    construct: 'strong',
+    markers: marker === '*' ? ['*', '_'] : ['_', '*'],
+    sizes: [2]
+  }
 }
 
 /**
+ * Peek at this node.
+ *
  * @param {Strong} _
+ *   Node to serialize.
  * @param {Parents | undefined} _1
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @returns {string}
+ *   Start of the serialized markdown.
  */
-function strongPeek(_, _1, state) {
+function peek(_, _1, state) {
   return state.options.strong || '*'
 }
 
@@ -18370,14 +18892,29 @@ function strongPeek(_, _1, state) {
  */
 
 /**
+ * Serialize a text node.
+ *
  * @param {Text} node
- * @param {Parents | undefined} _
+ *   Node to serialize.
+ * @param {Parents | undefined} parent
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @param {Info} info
+ *   Info on surrounding context.
  * @returns {string}
+ *   Serialized markdown.
  */
-function text$5(node, _, state, info) {
-  return state.safe(node.value, info)
+function text$5(node, parent, state, info) {
+  /* c8 ignore next -- parent always passed */
+  const siblings = parent ? parent.children : [];
+  const index = siblings.indexOf(node);
+
+  return state.safe(node.value, {
+    ...info,
+    afterNode: siblings[index + 1],
+    beforeNode: siblings[index - 1]
+  })
 }
 
 /**
@@ -18385,8 +18922,12 @@ function text$5(node, _, state, info) {
  */
 
 /**
+ * Checks the preferred rule repetition option.
+ *
  * @param {State} state
+ *   Info passed around.
  * @returns {Exclude<Options['ruleRepetition'], null | undefined>}
+ *   Preferred rule repetition.
  */
 function checkRuleRepetition(state) {
   const repetition = state.options.ruleRepetition || 3;
@@ -18409,10 +18950,16 @@ function checkRuleRepetition(state) {
 
 
 /**
+ * Serialize a thematic break node.
+ *
  * @param {ThematicBreak} _
+ *   Node to serialize.
  * @param {Parents | undefined} _1
+ *   Parent node.
  * @param {State} state
+ *   Info passed around.
  * @returns {string}
+ *   Serialized markdown.
  */
 function thematicBreak$1(_, _1, state) {
   const value = (
@@ -20429,15 +20976,27 @@ class EditMap {
      * @type {Array<Change>}
      */
     this.map = [];
+
+    /**
+     * Changes by index, so `add` does not scan `map` (quadratic on
+     * table-heavy documents).
+     *
+     * @type {Map<number, Change>}
+     */
+    this.index = new Map();
   }
 
   /**
    * Create an edit: a remove and/or add at a certain place.
    *
    * @param {number} index
+   *   Index at which to apply the edit.
    * @param {number} remove
+   *   Count of items to remove at the index.
    * @param {Array<Event>} add
+   *   Items to add at the index.
    * @returns {undefined}
+   *   Nothing.
    */
   add(index, remove, add) {
     addImplementation(this, index, remove, add);
@@ -20460,7 +21019,9 @@ class EditMap {
    * Done, change the events.
    *
    * @param {Array<Event>} events
+   *   List of events to apply the edits to.
    * @returns {undefined}
+   *   Nothing.
    */
   consume(events) {
     this.map.sort(function (a, b) {
@@ -20512,6 +21073,7 @@ class EditMap {
 
     // Truncate everything.
     this.map.length = 0;
+    this.index.clear();
   }
 }
 
@@ -20519,35 +21081,40 @@ class EditMap {
  * Create an edit.
  *
  * @param {EditMap} editMap
+ *   Edit map to apply to.
  * @param {number} at
+ *   Index at which to apply the edit.
  * @param {number} remove
+ *   Count of items to remove at the index.
  * @param {Array<Event>} add
+ *   Items to add at the index.
  * @returns {undefined}
+ *   Nothing.
  */
 function addImplementation(editMap, at, remove, add) {
-  let index = 0;
-
   /* c8 ignore next 3 -- `resolve` is never called without tables, so without edits. */
   if (remove === 0 && add.length === 0) {
     return;
   }
-  while (index < editMap.map.length) {
-    if (editMap.map[index][0] === at) {
-      editMap.map[index][1] += remove;
+  const existing = editMap.index.get(at);
+  if (existing) {
+    existing[1] += remove;
 
-      // To do: before not used by tables, use when moving to micromark.
-      // if (before) {
-      //   add.push(...editMap.map[index][2])
-      //   editMap.map[index][2] = add
-      // } else {
-      editMap.map[index][2].push(...add);
-      // }
+    // To do: before not used by tables, use when moving to micromark.
+    // if (before) {
+    //   add.push(...existing[2])
+    //   existing[2] = add
+    // } else {
+    existing[2].push(...add);
+    // }
 
-      return;
-    }
-    index += 1;
+    return;
   }
-  editMap.map.push([at, remove, add]);
+
+  /** @type {Change} */
+  const change = [at, remove, add];
+  editMap.map.push(change);
+  editMap.index.set(at, change);
 }
 
 // /**
@@ -20674,6 +21241,8 @@ function gfmTable() {
 }
 
 /**
+ * Tokenizer for GFM tables.
+ *
  * @this {TokenizeContext}
  * @type {Tokenizer}
  */
@@ -20704,10 +21273,16 @@ function tokenizeTable(effects, ok, nok) {
   function start(code) {
     let index = self.events.length - 1;
     while (index > -1) {
-      const type = self.events[index][1].type;
+      const {
+        type
+      } = self.events[index][1];
       if (type === "lineEnding" ||
       // Note: markdown-rs uses `whitespace` instead of `linePrefix`
-      type === "linePrefix") index--;else break;
+      type === "linePrefix") {
+        index--;
+      } else {
+        break;
+      }
     }
     const tail = index > -1 ? self.events[index][1].type : null;
     const next = tail === 'tableHead' || tail === 'tableRow' ? bodyRowStart : headRowBefore;
@@ -21327,12 +21902,19 @@ function resolveTable(events, context) {
  * Generate a cell.
  *
  * @param {EditMap} map
+ *   Edit map to apply to.
  * @param {Readonly<TokenizeContext>} context
+ *   Tokenize context.
  * @param {Readonly<Range>} range
+ *   Range of the cell within events.
  * @param {RowKind} rowKind
+ *   Type of row.
  * @param {number | undefined} rowEnd
+ *   Index of the end of the row, if known.
  * @param {Token | undefined} previousCell
+ *   Previous cell token, if any.
  * @returns {Token | undefined}
+ *   Current cell token after flushing, if any.
  */
 // eslint-disable-next-line max-params
 function flushCell(map, context, range, rowKind, rowEnd, previousCell) {
@@ -21427,10 +22009,17 @@ function flushCell(map, context, range, rowKind, rowEnd, previousCell) {
  * Generate table end (and table body end).
  *
  * @param {Readonly<EditMap>} map
+ *   Edit map to apply to.
  * @param {Readonly<TokenizeContext>} context
+ *   Tokenize context.
  * @param {number} index
+ *   Index within the events where the table end should be inserted.
  * @param {Token} table
+ *   Table token.
  * @param {Token | undefined} tableBody
+ *   Table body token, if any.
+ * @returns {undefined}
+ *   Nothing.
  */
 // eslint-disable-next-line max-params
 function flushTableEnd(map, context, index, table, tableBody) {
@@ -21447,9 +22036,14 @@ function flushTableEnd(map, context, index, table, tableBody) {
 }
 
 /**
+ * Get the point (start or end) for a given event in the list of events.
+ *
  * @param {Readonly<Array<Event>>} events
+ *   List of events.
  * @param {number} index
+ *   Index of the event to get the point for.
  * @returns {Readonly<Point>}
+ *   Start point for enter and end point for exit.
  */
 function getPoint(events, index) {
   const event = events[index];
@@ -22884,6 +23478,7 @@ const ERROR      = 7;
 const BIGINT     = 8;
 // export const SYMBOL = 9;
 
+const { defineProperty } = Object;
 const env = typeof self === 'object' ? self : globalThis;
 
 const guard = (name, init) => {
@@ -22922,8 +23517,16 @@ const deserializer = ($, _) => {
       }
       case OBJECT: {
         const object = as({}, index);
-        for (const [key, index] of value)
-          object[unpair(key)] = unpair(index);
+        for (const [key, index] of value) {
+          const k = unpair(key), value = unpair(index);
+          if (k === '__proto__') defineProperty(object, k, {
+            value,
+            configurable: true,
+            enumerable: true,
+            writable: true
+          });
+          else object[k] = value;
+        }
         return object;
       }
       case DATE:
@@ -22946,7 +23549,12 @@ const deserializer = ($, _) => {
       }
       case ERROR: {
         const {name, message} = value;
-        return as(guard(name, message), index);
+        return as(
+          typeof env[name] === 'function' ?
+            guard(name, message) :
+            new Error(message),
+          index
+        );
       }
       case BIGINT:
         return as(BigInt(value), index);
@@ -22958,6 +23566,7 @@ const deserializer = ($, _) => {
         const { buffer } = new Uint8Array(value);
         return as(new DataView(buffer), value);
       }
+      case '-0': return -0;
     }
     return as(guard(type, value), index);
   };
@@ -22979,7 +23588,7 @@ const deserialize = serialized => deserializer(new Map, serialized)(0);
 const EMPTY = '';
 
 const {toString} = {};
-const {keys} = Object;
+const {keys, is} = Object;
 
 const typeOf = value => {
   const type = typeof value;
@@ -23007,8 +23616,8 @@ const typeOf = value => {
   if (asString.includes('Array'))
     return [ARRAY, asString];
 
-  if (asString.includes('Error'))
-    return [ERROR, asString];
+  if (value instanceof Error)
+    return [ERROR, value.name || 'Error'];
 
   return [OBJECT, asString];
 };
@@ -23039,6 +23648,10 @@ const serializer = (strict, json, $, _) => {
             TYPE = BIGINT;
             entry = value.toString();
             break;
+          case 'number':
+            if (!value && is(value, -0))
+              return _.push(['-0']) - 1;
+            break;
           case 'function':
           case 'symbol':
             if (strict)
@@ -23092,7 +23705,7 @@ const serializer = (strict, json, $, _) => {
         return index;
       }
       case DATE:
-        return as([TYPE, value.toISOString()], value);
+        return as([TYPE, isNaN(value.getTime()) ? EMPTY : value.toISOString()], value);
       case REGEXP: {
         const {source, flags} = value;
         return as([TYPE, {source, flags}], value);
@@ -24247,6 +24860,7 @@ const html$3 = create({
     allowFullScreen: boolean,
     allowPaymentRequest: boolean,
     allowUserMedia: boolean,
+    alpha: boolean,
     alt: null,
     as: null,
     async: boolean,
@@ -24260,8 +24874,12 @@ const html$3 = create({
     checked: boolean,
     cite: null,
     className: spaceSeparated,
+    closedBy: null,
+    colorSpace: null,
     cols: number,
-    colSpan: null,
+    colSpan: number,
+    command: null,
+    commandFor: null,
     content: null,
     contentEditable: booleanish,
     controls: boolean,
@@ -24441,8 +25059,10 @@ const html$3 = create({
     seamless: boolean,
     selected: boolean,
     shadowRootClonable: boolean,
+    shadowRootCustomElementRegistry: boolean,
     shadowRootDelegatesFocus: boolean,
     shadowRootMode: null,
+    shadowRootSerializable: boolean,
     shape: null,
     size: number,
     sizes: null,
@@ -24528,8 +25148,11 @@ const html$3 = create({
     allowTransparency: null,
     autoCorrect: null,
     autoSave: null,
+    credentialless: boolean,
     disablePictureInPicture: boolean,
     disableRemotePlayback: boolean,
+    exportParts: commaSeparated,
+    part: spaceSeparated,
     prefix: null,
     property: null,
     results: number,
@@ -24582,6 +25205,7 @@ const svg$1 = create({
     markerEnd: 'marker-end',
     markerMid: 'marker-mid',
     markerStart: 'marker-start',
+    maskType: 'mask-type',
     navDown: 'nav-down',
     navDownLeft: 'nav-down-left',
     navDownRight: 'nav-down-right',
@@ -24849,6 +25473,7 @@ const svg$1 = create({
     markerWidth: null,
     mask: null,
     maskContentUnits: null,
+    maskType: null,
     maskUnits: null,
     mathematical: null,
     max: null,
@@ -36695,11 +37320,7 @@ function cPlusPlus(hljs) {
       _hint: FUNCTION_HINTS },
     begin: regex.concat(
       /\b/,
-      /(?!decltype)/,
-      /(?!if)/,
-      /(?!for)/,
-      /(?!switch)/,
-      /(?!while)/,
+      `(?!${RESERVED_KEYWORDS.join('|')})`,
       hljs.IDENT_RE,
       regex.lookahead(/(<[^<>]+>|)\s*\(/))
   };
@@ -38442,11 +39063,7 @@ function cpp(hljs) {
       _hint: FUNCTION_HINTS },
     begin: regex.concat(
       /\b/,
-      /(?!decltype)/,
-      /(?!if)/,
-      /(?!for)/,
-      /(?!switch)/,
-      /(?!while)/,
+      `(?!${RESERVED_KEYWORDS.join('|')})`,
       hljs.IDENT_RE,
       regex.lookahead(/(<[^<>]+>|)\s*\(/))
   };
@@ -38787,7 +39404,7 @@ function csharp(hljs) {
     variants: [
       { begin: '\\b(0b[01\']+)' },
       { begin: '(-?)\\b([\\d\']+(\\.[\\d\']*)?|\\.[\\d\']+)(u|U|l|L|ul|UL|f|F|b|B)' },
-      { begin: '(-?)(\\b0[xX][a-fA-F0-9\']+|(\\b[\\d\']+(\\.[\\d\']*)?|\\.[\\d\']+)([eE][-+]?[\\d\']+)?)' }
+      { begin: '(-?)(\\b0[xX][a-fA-F0-9\'_]+|(\\b[\\d\'_]+(\\.[\\d\'_]*)?|\\.[\\d\'_]+)([eE][-+]?[\\d\'_]+)?)' }
     ],
     relevance: 0
   };
@@ -39041,6 +39658,10 @@ const MODES$2 = (hljs) => {
       scope: 'number',
       begin: /#(([0-9a-fA-F]{3,4})|(([0-9a-fA-F]{2}){3,4}))\b/
     },
+    UNICODE_RANGE: {
+      scope: 'number',
+      begin: /\b[Uu]\+[0-9A-Fa-f][0-9A-Fa-f?]{0,4}(-[0-9A-Fa-f][0-9A-Fa-f]{0,4})?/
+    },
     FUNCTION_DISPATCH: {
       className: "built_in",
       begin: /[\w-]+(?=\()/
@@ -39809,6 +40430,7 @@ const ATTRIBUTES$2 = [
   'transition-timing-function',
   'translate',
   'unicode-bidi',
+  'unicode-range',
   'user-modify',
   'user-select',
   'vector-effect',
@@ -39915,9 +40537,10 @@ function css(hljs) {
           modes.HEXCOLOR,
           modes.IMPORTANT,
           modes.CSS_NUMBER_MODE,
+          modes.UNICODE_RANGE,
           ...STRINGS,
           // needed to highlight these as strings and to avoid issues with
-          // illegal characters that might be inside urls that would tigger the
+          // illegal characters that might be inside urls that would trigger the
           // languages illegal stack
           {
             begin: /(url|data-uri)\(/,
@@ -39997,7 +40620,10 @@ function diff(hljs) {
         className: 'meta',
         relevance: 10,
         match: regex.either(
-          /^@@ +-\d+,\d+ +\+\d+,\d+ +@@/,
+          /^@@ +-\d+,\d+ +\+\d+,\d+ +@@/, // @@ -1,2 +1,2 @@
+          /^@@ +-\d+ +\+\d+,\d+ +@@/,     // @@ -1 +1,2 @@
+          /^@@ +-\d+,\d+ +\+\d+ +@@/,     // @@ -1,2 +1 @@
+          /^@@ +-\d+ +\+\d+ +@@/,         // @@ -1 +1 @@
           /^\*\*\* +\d+,\d+ +\*\*\*\*$/,
           /^--- +\d+,\d+ +----$/
         )
@@ -40682,6 +41308,7 @@ function java(hljs) {
 }
 
 const IDENT_RE$1 = '[A-Za-z$_][0-9A-Za-z$_]*';
+
 const KEYWORDS$1 = [
   "as", // for exports
   "in",
@@ -41229,7 +41856,8 @@ function javascript$1(hljs) {
       noneOf([
         ...BUILT_IN_GLOBALS$1,
         "super",
-        "import"
+        "import",
+        "await",
       ].map(x => `${x}\\s*\\(`)),
       IDENT_RE$1$1, regex.lookahead(/\s*\(/)),
     className: "title.function",
@@ -41298,7 +41926,7 @@ function javascript$1(hljs) {
     keywords: KEYWORDS$1$1,
     // this will be extended by TypeScript
     exports: { PARAMS_CONTAINS, CLASS_REFERENCE },
-    illegal: /#(?![$_A-z])/,
+    illegal: /#(?![$_A-Za-z])/,
     contains: [
       hljs.SHEBANG({
         label: "shebang",
@@ -41449,18 +42077,26 @@ function javascript$1(hljs) {
   };
 }
 
+const EXTENDED_NUMBER_RE = '([-+]?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)|NaN|[-+]?Infinity'; // 0x..., 0..., decimal, float
+
+const EXTENDED_NUMBER_MODE = {
+  scope: 'number',
+  match: EXTENDED_NUMBER_RE,
+  relevance: 0
+};
+
 /*
 Language: JSON
 Description: JSON (JavaScript Object Notation) is a lightweight data-interchange format.
-Author: Ivan Sagalaev <maniac@softwaremaniacs.org>
-Website: http://www.json.org
+Websites: http://www.json.org, https://www.json5.org
 Category: common, protocols, web
 */
 
+
 function json(hljs) {
   const ATTRIBUTE = {
     className: 'attr',
-    begin: /"(\\.|[^\\"\r\n])*"(?=\s*:)/,
+    begin: /(("(\\.|[^\\"\r\n])*")|('(\\.|[^\\'\r\n])*'))(?=\s*:)/,
     relevance: 1.01
   };
   const PUNCTUATION = {
@@ -41485,16 +42121,17 @@ function json(hljs) {
 
   return {
     name: 'JSON',
-    aliases: ['jsonc'],
+    aliases: ['jsonc', 'json5'],
     keywords:{
       literal: LITERALS,
     },
     contains: [
       ATTRIBUTE,
       PUNCTUATION,
+      hljs.APOS_STRING_MODE,
       hljs.QUOTE_STRING_MODE,
       LITERALS_MODE,
-      hljs.C_NUMBER_MODE,
+      EXTENDED_NUMBER_MODE,
       hljs.C_LINE_COMMENT_MODE,
       hljs.C_BLOCK_COMMENT_MODE
     ],
@@ -41798,6 +42435,10 @@ const MODES$1 = (hljs) => {
       scope: 'number',
       begin: /#(([0-9a-fA-F]{3,4})|(([0-9a-fA-F]{2}){3,4}))\b/
     },
+    UNICODE_RANGE: {
+      scope: 'number',
+      begin: /\b[Uu]\+[0-9A-Fa-f][0-9A-Fa-f?]{0,4}(-[0-9A-Fa-f][0-9A-Fa-f]{0,4})?/
+    },
     FUNCTION_DISPATCH: {
       className: "built_in",
       begin: /[\w-]+(?=\()/
@@ -42566,6 +43207,7 @@ const ATTRIBUTES$1 = [
   'transition-timing-function',
   'translate',
   'unicode-bidi',
+  'unicode-range',
   'user-modify',
   'user-select',
   'vector-effect',
@@ -42670,6 +43312,7 @@ function less(hljs) {
         excludeEnd: true
       }
     },
+    modes.UNICODE_RANGE,
     modes.HEXCOLOR,
     PARENS_MODE,
     IDENT_MODE('variable', '@@?' + IDENT_RE, 10),
@@ -42780,7 +43423,7 @@ function less(hljs) {
       MIXIN_GUARD_MODE,
       IDENT_MODE('keyword', 'all\\b'),
       IDENT_MODE('variable', '@\\{' + IDENT_RE + '\\}'), // otherwise it’s identified as tag
-      
+
       {
         begin: '\\b(' + TAGS$1.join('|') + ')\\b',
         className: 'selector-tag'
@@ -44422,6 +45065,8 @@ function php(hljs) {
       VARIABLE,
       LEFT_AND_RIGHT_SIDE_OF_DOUBLE_COLON,
       hljs.C_BLOCK_COMMENT_MODE,
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.HASH_COMMENT_MODE,
       STRING,
       NUMBER,
       CONSTRUCTOR_CALL,
@@ -44446,6 +45091,8 @@ function php(hljs) {
     NAMED_ARGUMENT,
     LEFT_AND_RIGHT_SIDE_OF_DOUBLE_COLON,
     hljs.C_BLOCK_COMMENT_MODE,
+    hljs.C_LINE_COMMENT_MODE,
+    hljs.HASH_COMMENT_MODE,
     STRING,
     NUMBER,
     CONSTRUCTOR_CALL,
@@ -44574,6 +45221,8 @@ function php(hljs) {
               VARIABLE,
               LEFT_AND_RIGHT_SIDE_OF_DOUBLE_COLON,
               hljs.C_BLOCK_COMMENT_MODE,
+              hljs.C_LINE_COMMENT_MODE,
+              hljs.HASH_COMMENT_MODE,
               STRING,
               NUMBER
             ]
@@ -46206,6 +46855,10 @@ const MODES = (hljs) => {
       scope: 'number',
       begin: /#(([0-9a-fA-F]{3,4})|(([0-9a-fA-F]{2}){3,4}))\b/
     },
+    UNICODE_RANGE: {
+      scope: 'number',
+      begin: /\b[Uu]\+[0-9A-Fa-f][0-9A-Fa-f?]{0,4}(-[0-9A-Fa-f][0-9A-Fa-f]{0,4})?/
+    },
     FUNCTION_DISPATCH: {
       className: "built_in",
       begin: /[\w-]+(?=\()/
@@ -46974,6 +47627,7 @@ const ATTRIBUTES = [
   'transition-timing-function',
   'translate',
   'unicode-bidi',
+  'unicode-range',
   'user-modify',
   'user-select',
   'vector-effect',
@@ -47087,6 +47741,7 @@ function scss(hljs) {
           VARIABLE,
           modes.HEXCOLOR,
           modes.CSS_NUMBER_MODE,
+          modes.UNICODE_RANGE,
           hljs.QUOTE_STRING_MODE,
           hljs.APOS_STRING_MODE,
           modes.IMPORTANT,
@@ -48829,6 +49484,7 @@ function swift(hljs) {
 }
 
 const IDENT_RE = '[A-Za-z$_][0-9A-Za-z$_]*';
+
 const KEYWORDS = [
   "as", // for exports
   "in",
@@ -49376,7 +50032,8 @@ function javascript(hljs) {
       noneOf([
         ...BUILT_IN_GLOBALS,
         "super",
-        "import"
+        "import",
+        "await",
       ].map(x => `${x}\\s*\\(`)),
       IDENT_RE$1, regex.lookahead(/\s*\(/)),
     className: "title.function",
@@ -49445,7 +50102,7 @@ function javascript(hljs) {
     keywords: KEYWORDS$1,
     // this will be extended by TypeScript
     exports: { PARAMS_CONTAINS, CLASS_REFERENCE },
-    illegal: /#(?![$_A-z])/,
+    illegal: /#(?![$_A-Za-z])/,
     contains: [
       hljs.SHEBANG({
         label: "shebang",
@@ -52094,7 +52751,7 @@ function requireCore () {
 	  return mode;
 	}
 
-	var version = "11.11.1";
+	var version = "11.11.2";
 
 	class HTMLInjectionError extends Error {
 	  constructor(reason, html) {
@@ -52616,12 +53273,15 @@ function requireCore () {
 	        }
 	      }
 
-	      // edge case for when illegal matches $ (end of line) which is technically
+	      // edge case for when illegal matches $ (end of line/text) which is technically
 	      // a 0 width match but not a begin/end match so it's not caught by the
-	      // first handler (when ignoreIllegals is true)
+	      // first handler (when `ignoreIllegals` is true)
 	      if (match.type === "illegal" && lexeme === "") {
-	        // advance so we aren't stuck in an infinite loop
-	        modeBuffer += "\n";
+	        if (match.index === codeToHighlight.length) ; else {
+	          // matched literal `\n` (with `$`) so we must manually add the newline
+	          // itself to the modeBuffer so it is not lost when we advance the cursor
+	          modeBuffer += "\n";
+	        }
 	        return 1;
 	      }