@limetech/lime-elements 40.5.4 → 40.6.0

package/dist/cjs/{markdown-parser-YH5HSSgF.js → markdown-parser-Cgv5Y9Z4.js}

@@ -1,7 +1,7 @@
 'use strict';
 
 var _commonjsHelpers = require('./_commonjsHelpers-CFO10eej.js');
-var index$2 = require('./index-ETPz91V5.js');
+var index$1 = require('./index-zZvs6xK-.js');
 
 /**
  *
@@ -3463,7 +3463,7 @@ function resolveAll(constructs, events, context) {
  */
 
 /** @type {Construct} */
-const attention = {
+const attention$2 = {
   name: 'attention',
   tokenize: tokenizeAttention,
   resolveAll: resolveAllAttention
@@ -10692,18 +10692,18 @@ const text$5 = {
   [-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']} */
@@ -10742,7 +10742,7 @@ var defaultConstructs = /*#__PURE__*/Object.freeze({
  * @param {ParseOptions | null | undefined} [options]
  * @returns {ParseContext}
  */
-function parse$2(options) {
+function parse(options) {
   const settings = options || {};
   const constructs =
     /** @type {FullNormalizedExtension} */
@@ -10804,7 +10804,7 @@ function postprocess(events) {
  * @returns {Array<Chunk>}
  */
 
-const search$2 = /[\0\t\n\r]/g;
+const search$1 = /[\0\t\n\r]/g;
 
 /**
  * @returns {Preprocessor}
@@ -10848,8 +10848,8 @@ function preprocess() {
       start = undefined;
     }
     while (startPosition < value.length) {
-      search$2.lastIndex = startPosition;
-      match = search$2.exec(value);
+      search$1.lastIndex = startPosition;
+      match = search$1.exec(value);
       endPosition =
         match && match.index !== undefined ? match.index : value.length;
       code = value.charCodeAt(endPosition);
@@ -10944,91 +10944,6 @@ function decode($0, $1, $2) {
   return decodeNamedCharacterReference($2) || $0
 }
 
-/**
- * @typedef {import('unist').Node} Node
- * @typedef {import('unist').Point} Point
- * @typedef {import('unist').Position} Position
- */
-
-/**
- * @typedef NodeLike
- * @property {string} type
- * @property {PositionLike | null | undefined} [position]
- *
- * @typedef PointLike
- * @property {number | null | undefined} [line]
- * @property {number | null | undefined} [column]
- * @property {number | null | undefined} [offset]
- *
- * @typedef PositionLike
- * @property {PointLike | null | undefined} [start]
- * @property {PointLike | null | undefined} [end]
- */
-
-/**
- * Serialize the positional info of a point, position (start and end points),
- * or node.
- *
- * @param {Node | NodeLike | Point | PointLike | Position | PositionLike | null | undefined} [value]
- *   Node, position, or point.
- * @returns {string}
- *   Pretty printed positional info of a node (`string`).
- *
- *   In the format of a range `ls:cs-le:ce` (when given `node` or `position`)
- *   or a point `l:c` (when given `point`), where `l` stands for line, `c` for
- *   column, `s` for `start`, and `e` for end.
- *   An empty string (`''`) is returned if the given value is neither `node`,
- *   `position`, nor `point`.
- */
-function stringifyPosition(value) {
-  // Nothing.
-  if (!value || typeof value !== 'object') {
-    return ''
-  }
-
-  // Node.
-  if ('position' in value || 'type' in value) {
-    return position$2(value.position)
-  }
-
-  // Position.
-  if ('start' in value || 'end' in value) {
-    return position$2(value)
-  }
-
-  // Point.
-  if ('line' in value || 'column' in value) {
-    return point$4(value)
-  }
-
-  // ?
-  return ''
-}
-
-/**
- * @param {Point | PointLike | null | undefined} point
- * @returns {string}
- */
-function point$4(point) {
-  return index$1(point && point.line) + ':' + index$1(point && point.column)
-}
-
-/**
- * @param {Position | PositionLike | null | undefined} pos
- * @returns {string}
- */
-function position$2(pos) {
-  return point$4(pos && pos.start) + '-' + point$4(pos && pos.end)
-}
-
-/**
- * @param {number | null | undefined} value
- * @returns {number}
- */
-function index$1(value) {
-  return value && typeof value === 'number' ? value : 1
-}
-
 /**
  * @typedef {import('mdast').Break} Break
  * @typedef {import('mdast').Blockquote} Blockquote
@@ -11096,7 +11011,7 @@ function fromMarkdown(value, encoding, options) {
   }
   return compiler(options)(
     postprocess(
-      parse$2(options).document().write(preprocess()(value, encoding, true))
+      parse(options).document().write(preprocess()(value, encoding, true))
     )
   )
 }
@@ -11279,7 +11194,7 @@ function compiler(options) {
 
     // Figure out `root` position.
     tree.position = {
-      start: point$3(
+      start: point$1(
         events.length > 0
           ? events[0][1].start
           : {
@@ -11288,7 +11203,7 @@ function compiler(options) {
               offset: 0
             }
       ),
-      end: point$3(
+      end: point$1(
         events.length > 0
           ? events[events.length - 2][1].end
           : {
@@ -11496,7 +11411,7 @@ function compiler(options) {
     this.stack.push(node);
     this.tokenStack.push([token, errorHandler]);
     node.position = {
-      start: point$3(token.start),
+      start: point$1(token.start),
       // @ts-expect-error: `end` will be patched later.
       end: undefined
     };
@@ -11542,7 +11457,7 @@ function compiler(options) {
         'Cannot close `' +
           token.type +
           '` (' +
-          stringifyPosition({
+          index$1.stringifyPosition({
             start: token.start,
             end: token.end
           }) +
@@ -11556,7 +11471,7 @@ function compiler(options) {
         handler.call(this, token, open[0]);
       }
     }
-    node.position.end = point$3(token.end);
+    node.position.end = point$1(token.end);
   }
 
   /**
@@ -11727,7 +11642,7 @@ function compiler(options) {
       // Add a new text node.
       tail = text();
       tail.position = {
-        start: point$3(token.start),
+        start: point$1(token.start),
         // @ts-expect-error: we’ll add `end` later.
         end: undefined
       };
@@ -11744,7 +11659,7 @@ function compiler(options) {
   function onexitdata(token) {
     const tail = this.stack.pop();
     tail.value += this.sliceSerialize(token);
-    tail.position.end = point$3(token.end);
+    tail.position.end = point$1(token.end);
   }
 
   /**
@@ -11757,7 +11672,7 @@ function compiler(options) {
     // If we’re at a hard break, include the line ending in there.
     if (this.data.atHardBreak) {
       const tail = context.children[context.children.length - 1];
-      tail.position.end = point$3(token.end);
+      tail.position.end = point$1(token.end);
       this.data.atHardBreak = undefined;
       return
     }
@@ -11991,7 +11906,7 @@ function compiler(options) {
     }
     const tail = this.stack.pop();
     tail.value += value;
-    tail.position.end = point$3(token.end);
+    tail.position.end = point$1(token.end);
   }
 
   /**
@@ -12175,7 +12090,7 @@ function compiler(options) {
  * @returns {Point}
  *   unist point.
  */
-function point$3(d) {
+function point$1(d) {
   return {
     line: d.line,
     column: d.column,
@@ -12246,14 +12161,14 @@ function defaultOnError(left, right) {
       'Cannot close `' +
         left.type +
         '` (' +
-        stringifyPosition({
+        index$1.stringifyPosition({
           start: left.start,
           end: left.end
         }) +
         '): a different token (`' +
         right.type +
         '`, ' +
-        stringifyPosition({
+        index$1.stringifyPosition({
           start: right.start,
           end: right.end
         }) +
@@ -12264,7 +12179,7 @@ function defaultOnError(left, right) {
       'Cannot close document, a token (`' +
         right.type +
         '`, ' +
-        stringifyPosition({
+        index$1.stringifyPosition({
           start: right.start,
           end: right.end
         }) +
@@ -13082,102 +12997,6 @@ function strong$1(state, node) {
   return state.applyData(node, result)
 }
 
-/**
- * @typedef {import('unist').Node} Node
- * @typedef {import('unist').Point} Point
- * @typedef {import('unist').Position} Position
- */
-
-/**
- * @typedef NodeLike
- * @property {string} type
- * @property {PositionLike | null | undefined} [position]
- *
- * @typedef PositionLike
- * @property {PointLike | null | undefined} [start]
- * @property {PointLike | null | undefined} [end]
- *
- * @typedef PointLike
- * @property {number | null | undefined} [line]
- * @property {number | null | undefined} [column]
- * @property {number | null | undefined} [offset]
- */
-
-/**
- * Get the ending point of `node`.
- *
- * @param node
- *   Node.
- * @returns
- *   Point.
- */
-const pointEnd$1 = point$2('end');
-
-/**
- * Get the starting point of `node`.
- *
- * @param node
- *   Node.
- * @returns
- *   Point.
- */
-const pointStart$1 = point$2('start');
-
-/**
- * Get the positional info of `node`.
- *
- * @param {'end' | 'start'} type
- *   Side.
- * @returns
- *   Getter.
- */
-function point$2(type) {
-  return point
-
-  /**
-   * Get the point info of `node` at a bound side.
-   *
-   * @param {Node | NodeLike | null | undefined} [node]
-   * @returns {Point | undefined}
-   */
-  function point(node) {
-    const point = (node && node.position && node.position[type]) || {};
-
-    if (
-      typeof point.line === 'number' &&
-      point.line > 0 &&
-      typeof point.column === 'number' &&
-      point.column > 0
-    ) {
-      return {
-        line: point.line,
-        column: point.column,
-        offset:
-          typeof point.offset === 'number' && point.offset > -1
-            ? point.offset
-            : undefined
-      }
-    }
-  }
-}
-
-/**
- * Get the positional info of `node`.
- *
- * @param {Node | NodeLike | null | undefined} [node]
- *   Node.
- * @returns {Position | undefined}
- *   Position.
- */
-function position$1(node) {
-  const start = pointStart$1(node);
-  const end = pointEnd$1(node);
-
-  if (start && end) {
-    return {start, end}
-  }
-}
-
 /**
  * @import {Table} from 'mdast'
  * @import {Element} from 'hast'
@@ -13222,8 +13041,8 @@ function table(state, node) {
       children: state.wrap(rows, true)
     };
 
-    const start = pointStart$1(node.children[1]);
-    const end = pointEnd$1(node.children[node.children.length - 1]);
+    const start = index$1.pointStart(node.children[1]);
+    const end = index$1.pointEnd(node.children[node.children.length - 1]);
     if (start && end) body.position = {start, end};
     tableContent.push(body);
   }
@@ -13674,7 +13493,7 @@ function footer(state) {
         type: 'element',
         tagName: footnoteLabelTagName,
         properties: {
-          ...index$2.structuredClone(footnoteLabelProperties),
+          ...index$1.structuredClone(footnoteLabelProperties),
           id: 'footnote-label'
         },
         children: [{type: 'text', value: footnoteLabel}]
@@ -13757,7 +13576,7 @@ function createState(tree, options) {
     wrap
   };
 
-  index$2.visit(tree, function (node) {
+  index$1.visit(tree, function (node) {
     if (node.type === 'definition' || node.type === 'footnoteDefinition') {
       const map = node.type === 'definition' ? definitionById : footnoteById;
       const id = String(node.identifier).toUpperCase();
@@ -13794,7 +13613,7 @@ function createState(tree, options) {
     if (state.options.passThrough && state.options.passThrough.includes(type)) {
       if ('children' in node) {
         const {children, ...shallow} = node;
-        const result = index$2.structuredClone(shallow);
+        const result = index$1.structuredClone(shallow);
         // @ts-expect-error: TS doesn’t understand…
         result.children = state.all(node);
         // @ts-expect-error: TS doesn’t understand…
@@ -13802,7 +13621,7 @@ function createState(tree, options) {
       }
 
       // @ts-expect-error: it’s custom.
-      return index$2.structuredClone(node)
+      return index$1.structuredClone(node)
     }
 
     const unknown = state.options.unknownHandler || defaultUnknownHandler;
@@ -13868,7 +13687,7 @@ function createState(tree, options) {
  *   Nothing.
  */
 function patch$2(from, to) {
-  if (from.position) to.position = position$1(from);
+  if (from.position) to.position = index$1.position(from);
 }
 
 /**
@@ -13912,7 +13731,7 @@ function applyData(from, to) {
     }
 
     if (result.type === 'element' && hProperties) {
-      Object.assign(result.properties, index$2.structuredClone(hProperties));
+      Object.assign(result.properties, index$1.structuredClone(hProperties));
     }
 
     if (
@@ -14298,12 +14117,12 @@ function escapeStringRegexp(string) {
  */
 function findAndReplace(tree, list, options) {
   const settings = options || {};
-  const ignored = index$2.convert(settings.ignore || []);
+  const ignored = index$1.convert(settings.ignore || []);
   const pairs = toPairs(list);
   let pairIndex = -1;
 
   while (++pairIndex < pairs.length) {
-    index$2.visitParents(tree, 'text', visitor);
+    index$1.visitParents(tree, 'text', visitor);
   }
 
   /** @type {import('unist-util-visit-parents').BuildVisitor<Root, 'text'>} */
@@ -14736,8 +14555,8 @@ function splitUrl(url) {
 
   let trail = trailExec[0];
   let closingParenIndex = trail.indexOf(')');
-  const openingParens = index$2.ccount(url, '(');
-  let closingParens = index$2.ccount(url, ')');
+  const openingParens = index$1.ccount(url, '(');
+  let closingParens = index$1.ccount(url, ')');
 
   while (closingParenIndex !== -1 && openingParens > closingParens) {
     url += trail.slice(0, closingParenIndex + 1);
@@ -15448,17 +15267,59 @@ function toAlignment(value) {
     : 0
 }
 
+/**
+ * @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 PhrasingContent} */
+  (
+    index$1.convert([
+      'break',
+      'delete',
+      'emphasis',
+      'footnote',
+      'footnoteReference',
+      'image',
+      'imageReference',
+      'inlineCode',
+      'link',
+      'linkReference',
+      'strong',
+      'text'
+    ])
+  );
+
 /**
  * @import {Blockquote, Parents} from 'mdast'
  * @import {Info, Map, State} from 'mdast-util-to-markdown'
  */
 
 /**
+ * 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(node, _, state, info) {
   const exit = state.enter('blockquote');
@@ -15473,7 +15334,11 @@ function blockquote(node, _, state, info) {
   return value
 }
 
-/** @type {Map} */
+/**
+ * Indent lines w/ blockquote markers.
+ *
+ * @type {Map}
+ */
 function map$1(line, _, blank) {
   return '>' + (blank ? '' : ' ') + line
 }
@@ -15483,9 +15348,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 (
@@ -15495,10 +15365,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') {
@@ -15527,23 +15403,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, 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) ? '' : ' '
     }
   }
 
@@ -15593,20 +15480,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)
   )
 }
 
@@ -15615,8 +15507,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 || '`';
@@ -15639,16 +15535,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$1(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');
@@ -15660,6 +15562,7 @@ function code$1(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) {
@@ -15700,7 +15603,11 @@ function code$1(node, _, state, info) {
   return value
 }
 
-/** @type {Map} */
+/**
+ * Indent lines w/ code indent.
+ *
+ * @type {Map}
+ */
 function map(line, _, blank) {
   return (blank ? '' : '    ') + line
 }
@@ -15710,8 +15617,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 || '"';
@@ -15734,11 +15645,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);
@@ -15808,8 +15726,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 || '*';
@@ -15826,166 +15748,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.attention = attention$1;
+emphasis.peek = peek$1;
 
 /**
- * Check whether to encode (as a character reference) the characters
- * surrounding an attention run.
+ * Serialize an emphasis node.
  *
- * Which characters are around an attention run influence whether it works or
- * not.
- *
- * See <https://github.com/orgs/syntax-tree/discussions/60> for more info.
- * See this markdown in a particular renderer to see what works:
- *
- * ```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*               | *.*                    | * *                   | **                 |
- * ```
+ * Attention is properly handled by `containerPhrasing`.
  *
- * @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.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(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 {State} from 'mdast-util-to-markdown'
  * @import {Heading} from 'mdast'
@@ -15993,29 +15833,34 @@ function emphasisPeek(_, _1, state) {
 
 
 /**
+ * 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;
 
   // Look for literals with a line break.
   // Note that this also
-  index$2.visit(node, function (node) {
+  index$1.visit(node, function (node) {
     if (
       ('value' in node && /\r?\n|\r/.test(node.value)) ||
       node.type === 'break'
     ) {
       literalWithBreak = true;
-      return index$2.EXIT
+      return index$1.EXIT
     }
   });
 
   return Boolean(
     (!node.depth || node.depth < 3) &&
-      toString(node) &&
-      (state.options.setext || literalWithBreak)
+    toString(node) &&
+    (state.options.setext || literalWithBreak)
   )
 }
 
@@ -16026,11 +15871,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(node, _, state, info) {
   const rank = Math.max(Math.min(6, node.depth || 1), 1);
@@ -16076,9 +15928,11 @@ function heading(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;
@@ -16100,15 +15954,22 @@ function heading(node, _, state, info) {
 html$4.peek = htmlPeek;
 
 /**
+ * Serialize an HTML node.
+ *
  * @param {Html} node
+ *   Node to serialize.
  * @returns {string}
+ *   Serialized markdown.
  */
 function html$4(node) {
   return node.value || ''
 }
 
 /**
+ * Peek at this node.
+ *
  * @returns {string}
+ *   Start of the serialized markdown.
  */
 function htmlPeek() {
   return '<'
@@ -16123,11 +15984,18 @@ function htmlPeek() {
 image.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(node, _, state, info) {
   const quote = checkQuote(state);
@@ -16190,7 +16058,10 @@ function image(node, _, state, info) {
 }
 
 /**
+ * Peek at this node.
+ *
  * @returns {string}
+ *   Start of the serialized markdown.
  */
 function imagePeek() {
   return '!'
@@ -16204,11 +16075,18 @@ function imagePeek() {
 imageReference.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(node, _, state, info) {
   const type = node.referenceType;
@@ -16224,9 +16102,14 @@ function imageReference(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.
@@ -16254,7 +16137,10 @@ function imageReference(node, _, state, info) {
 }
 
 /**
+ * Peek at this node.
+ *
  * @returns {string}
+ *   Start of the serialized markdown.
  */
 function imageReferencePeek() {
   return '!'
@@ -16268,10 +16154,16 @@ function imageReferencePeek() {
 inlineCode.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(node, _, state) {
   let value = node.value || '';
@@ -16288,8 +16180,8 @@ function inlineCode(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 + ' ';
   }
@@ -16304,14 +16196,15 @@ function inlineCode(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;
 
@@ -16331,7 +16224,10 @@ function inlineCode(node, _, state) {
 }
 
 /**
+ * Peek at this node.
+ *
  * @returns {string}
+ *   Start of the serialized markdown.
  */
 function inlineCodePeek() {
   return '`'
@@ -16344,30 +16240,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(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)
   )
 }
 
@@ -16381,26 +16282,35 @@ function formatLinkAsAutolink(node, state) {
 link.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(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, {
@@ -16415,8 +16325,8 @@ function link(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, {
@@ -16475,10 +16385,16 @@ function link(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) ? '<' : '['
@@ -16492,11 +16408,18 @@ function linkPeek(node, _, state) {
 linkReference.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(node, _, state, info) {
   const type = node.referenceType;
@@ -16512,9 +16435,14 @@ function linkReference(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.
@@ -16542,7 +16470,10 @@ function linkReference(node, _, state, info) {
 }
 
 /**
+ * Peek at this node.
+ *
  * @returns {string}
+ *   Start of the serialized markdown.
  */
 function linkReferencePeek() {
   return '['
@@ -16553,8 +16484,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 || '*';
@@ -16576,8 +16511,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);
@@ -16613,8 +16552,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 || '.';
@@ -16635,8 +16578,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 || '*';
@@ -16659,11 +16606,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(node, parent, state, info) {
   const exit = state.enter('list');
@@ -16754,8 +16708,12 @@ function list(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';
@@ -16778,11 +16736,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(node, parent, state, info) {
   const listItemIndent = checkListItemIndent(state);
@@ -16822,7 +16787,11 @@ function listItem(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
@@ -16838,11 +16807,18 @@ function listItem(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(node, _, state, info) {
   const exit = state.enter('paragraph');
@@ -16853,41 +16829,6 @@ function paragraph(node, _, state, info) {
   return value
 }
 
-/**
- * @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 PhrasingContent} */
-  (
-    index$2.convert([
-      'break',
-      'delete',
-      'emphasis',
-      'footnote',
-      'footnoteReference',
-      'image',
-      'imageReference',
-      'inlineCode',
-      'link',
-      'linkReference',
-      'strong',
-      'text'
-    ])
-  );
-
 /**
  * @import {Info, State} from 'mdast-util-to-markdown'
  * @import {Parents, Root} from 'mdast'
@@ -16895,11 +16836,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$2(node, _, state, info) {
   // Note: `html` nodes are ambiguous.
@@ -16907,8 +16855,12 @@ function root$2(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
 }
 
 /**
@@ -16916,8 +16868,12 @@ function root$2(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 || '*';
@@ -16934,69 +16890,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.peek = strongPeek;
+strong.attention = attention;
+strong.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(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 || '*'
 }
 
@@ -17006,11 +16962,18 @@ function strongPeek(_, _1, state) {
  */
 
 /**
+ * Serialize a text node.
+ *
  * @param {Text} 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 text$3(node, _, state, info) {
   return state.safe(node.value, info)
@@ -17021,8 +16984,12 @@ function text$3(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;
@@ -17045,10 +17012,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, state) {
   const value = (
@@ -17190,7 +17163,7 @@ function exitCodeText(token) {
   let value = this.resume();
 
   if (this.data.inTable) {
-    value = value.replace(/\\([\\|])/g, replace);
+    value = value.replace(/\\([\\|])/g, replace$1);
   }
 
   const node = this.stack[this.stack.length - 1];
@@ -17203,7 +17176,7 @@ function exitCodeText(token) {
  * @param {string} $1
  * @returns {string}
  */
-function replace($0, $1) {
+function replace$1($0, $1) {
   // Pipes work, backslashes don’t (but can’t escape pipes).
   return $1 === '|' ? $1 : $0
 }
@@ -20565,6 +20538,59 @@ function remarkGfm(options) {
   toMarkdownExtensions.push(gfmToMarkdown(settings));
 }
 
+/**
+ * @typedef {import('mdast').Nodes} Nodes
+ * @typedef {import('mdast-util-find-and-replace').ReplaceFunction} ReplaceFunction
+ */
+
+
+/**
+ * Turn normal line endings into hard breaks.
+ *
+ * @param {Nodes} tree
+ *   Tree to change.
+ * @returns {undefined}
+ *   Nothing.
+ */
+function newlineToBreak(tree) {
+  findAndReplace(tree, [/\r?\n|\r/g, replace]);
+}
+
+/**
+ * Replace line endings.
+ *
+ * @type {ReplaceFunction}
+ */
+function replace() {
+  return {type: 'break'}
+}
+
+/**
+ * @typedef {import('mdast').Root} Root
+ */
+
+
+/**
+ * Support hard breaks without needing spaces or escapes (turns enters into
+ * `<br>`s).
+ *
+ * @returns
+ *   Transform.
+ */
+function remarkBreaks() {
+  /**
+   * Transform.
+   *
+   * @param {Root} tree
+   *   Tree.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  return function (tree) {
+    newlineToBreak(tree);
+  }
+}
+
 /**
  * @typedef {import('./info.js').Info} Info
  * @typedef {Record<string, Info>} Properties
@@ -21822,157 +21848,6 @@ function camelcase$1($0) {
 const html$2 = merge$1([xml$1, xlink$1, xmlns$1, aria$1, html$3], 'html');
 const svg$2 = merge$1([xml$1, xlink$1, xmlns$1, aria$1, svg$3], 'svg');
 
-/**
- * @typedef Options
- *   Configuration for `stringify`.
- * @property {boolean} [padLeft=true]
- *   Whether to pad a space before a token.
- * @property {boolean} [padRight=false]
- *   Whether to pad a space after a token.
- */
-
-/**
- * @typedef {Options} StringifyOptions
- *   Please use `StringifyOptions` instead.
- */
-
-/**
- * Parse comma-separated tokens to an array.
- *
- * @param {string} value
- *   Comma-separated tokens.
- * @returns {Array<string>}
- *   List of tokens.
- */
-function parse$1(value) {
-  /** @type {Array<string>} */
-  const tokens = [];
-  const input = String(value || '');
-  let index = input.indexOf(',');
-  let start = 0;
-  /** @type {boolean} */
-  let end = false;
-
-  while (!end) {
-    if (index === -1) {
-      index = input.length;
-      end = true;
-    }
-
-    const token = input.slice(start, index).trim();
-
-    if (token || !end) {
-      tokens.push(token);
-    }
-
-    start = index + 1;
-    index = input.indexOf(',', start);
-  }
-
-  return tokens
-}
-
-/**
- * @typedef {import('hast').Element} Element
- * @typedef {import('hast').Properties} Properties
- */
-
-/**
- * @template {string} SimpleSelector
- *   Selector type.
- * @template {string} DefaultTagName
- *   Default tag name.
- * @typedef {(
- *   SimpleSelector extends ''
- *     ? DefaultTagName
- *     : SimpleSelector extends `${infer TagName}.${infer Rest}`
- *     ? ExtractTagName<TagName, DefaultTagName>
- *     : SimpleSelector extends `${infer TagName}#${infer Rest}`
- *     ? ExtractTagName<TagName, DefaultTagName>
- *     : SimpleSelector extends string
- *     ? SimpleSelector
- *     : DefaultTagName
- * )} ExtractTagName
- *   Extract tag name from a simple selector.
- */
-
-const search$1 = /[#.]/g;
-
-/**
- * Create a hast element from a simple CSS selector.
- *
- * @template {string} Selector
- *   Type of selector.
- * @template {string} [DefaultTagName='div']
- *   Type of default tag name (default: `'div'`).
- * @param {Selector | null | undefined} [selector]
- *   Simple CSS selector (optional).
- *
- *   Can contain a tag name (`foo`), classes (`.bar`), and an ID (`#baz`).
- *   Multiple classes are allowed.
- *   Uses the last ID if multiple IDs are found.
- * @param {DefaultTagName | null | undefined} [defaultTagName='div']
- *   Tag name to use if `selector` does not specify one (default: `'div'`).
- * @returns {Element & {tagName: ExtractTagName<Selector, DefaultTagName>}}
- *   Built element.
- */
-function parseSelector(selector, defaultTagName) {
-  const value = selector || '';
-  /** @type {Properties} */
-  const props = {};
-  let start = 0;
-  /** @type {string | undefined} */
-  let previous;
-  /** @type {string | undefined} */
-  let tagName;
-
-  while (start < value.length) {
-    search$1.lastIndex = start;
-    const match = search$1.exec(value);
-    const subvalue = value.slice(start, match ? match.index : value.length);
-
-    if (subvalue) {
-      if (!previous) {
-        tagName = subvalue;
-      } else if (previous === '#') {
-        props.id = subvalue;
-      } else if (Array.isArray(props.className)) {
-        props.className.push(subvalue);
-      } else {
-        props.className = [subvalue];
-      }
-
-      start += subvalue.length;
-    }
-
-    if (match) {
-      previous = match[0];
-      start++;
-    }
-  }
-
-  return {
-    type: 'element',
-    // @ts-expect-error: tag name is parsed.
-    tagName: tagName || defaultTagName || 'div',
-    properties: props,
-    children: []
-  }
-}
-
-/**
- * Parse space-separated tokens to an array of strings.
- *
- * @param {string} value
- *   Space-separated tokens.
- * @returns {Array<string>}
- *   List of tokens.
- */
-function parse(value) {
-  const input = String(value || '').trim();
-  return input ? input.split(/[ \t\n\r\f]+/g) : []
-}
-
 /**
  * @typedef {import('hast').Element} Element
  * @typedef {import('hast').Nodes} Nodes
@@ -22040,7 +21915,7 @@ function createH(schema, defaultTagName, caseSensitive) {
       const child = /** @type {Child} */ (properties);
       children.unshift(child);
     } else {
-      node = parseSelector(selector, defaultTagName);
+      node = index$1.parseSelector(selector, defaultTagName);
       // Normalize the name.
       node.tagName = node.tagName.toLowerCase();
       if (adjust && own$3.call(adjust, node.tagName)) {
@@ -22147,11 +22022,11 @@ function addProperty(schema, properties, key, value) {
   // Handle list values.
   else if (typeof value === 'string') {
     if (info.spaceSeparated) {
-      result = parse(value);
+      result = index$1.parse(value);
     } else if (info.commaSeparated) {
-      result = parse$1(value);
+      result = index$1.parse$1(value);
     } else if (info.commaOrSpaceSeparated) {
-      result = parse(parse$1(value).join(' '));
+      result = index$1.parse(index$1.parse$1(value).join(' '));
     } else {
       result = parsePrimitive(info, info.property, value);
     }
@@ -22468,15 +22343,6 @@ function location(file) {
   }
 }
 
-/**
- * Map of web namespaces.
- *
- * @type {Record<string, string>}
- */
-const webNamespaces$1 = {
-  html: 'http://www.w3.org/1999/xhtml',
-  svg: 'http://www.w3.org/2000/svg'};
-
 /**
  * @typedef {import('hast').Element} Element
  * @typedef {import('hast').ElementData} ElementData
@@ -22633,7 +22499,7 @@ function all$2(state, nodes) {
 function element$2(state, node) {
   const schema = state.schema;
 
-  state.schema = node.namespaceURI === webNamespaces$1.svg ? svg$2 : html$2;
+  state.schema = node.namespaceURI === index$1.webNamespaces.svg ? svg$2 : html$2;
 
   // Props.
   let index = -1;
@@ -22767,12 +22633,12 @@ function createLocation(state, node, location) {
  *   Position or nothing.
  */
 function position(loc) {
-  const start = point$1({
+  const start = point({
     line: loc.startLine,
     column: loc.startCol,
     offset: loc.startOffset
   });
-  const end = point$1({
+  const end = point({
     line: loc.endLine,
     column: loc.endCol,
     offset: loc.endOffset
@@ -22791,45 +22657,10 @@ function position(loc) {
  * @returns {Point | undefined}
  *   Point or nothing.
  */
-function point$1(point) {
+function point(point) {
   return point.line && point.column ? point : undefined
 }
 
-/**
- * @typedef Options
- *   Configuration for `stringify`.
- * @property {boolean} [padLeft=true]
- *   Whether to pad a space before a token.
- * @property {boolean} [padRight=false]
- *   Whether to pad a space after a token.
- */
-
-
-/**
- * Serialize an array of strings or numbers to comma-separated tokens.
- *
- * @param {Array<string|number>} values
- *   List of tokens.
- * @param {Options} [options]
- *   Configuration for `stringify` (optional).
- * @returns {string}
- *   Comma-separated tokens.
- */
-function stringify$1(values, options) {
-  const settings = {};
-
-  // Ensure the last empty entry is seen.
-  const input = values[values.length - 1] === '' ? [...values, ''] : values;
-
-  return input
-    .join(
-      (settings.padRight ? ' ' : '') +
-        ',' +
-        (settings.padLeft === false ? '' : ' ')
-    )
-    .trim()
-}
-
 /**
  * @typedef {import('./info.js').Info} Info
  * @typedef {Record<string, Info>} Properties
@@ -24087,41 +23918,6 @@ function camelcase($0) {
 const html = merge([xml, xlink, xmlns, aria, html$1], 'html');
 const svg = merge([xml, xlink, xmlns, aria, svg$1], 'svg');
 
-/**
- * Parse space-separated tokens to an array of strings.
- *
- * @param {string} value
- *   Space-separated tokens.
- * @returns {Array<string>}
- *   List of tokens.
- */
-
-/**
- * Serialize an array of strings as space separated-tokens.
- *
- * @param {Array<string|number>} values
- *   List of tokens.
- * @returns {string}
- *   Space-separated tokens.
- */
-function stringify(values) {
-  return values.join(' ').trim()
-}
-
-/**
- * Map of web namespaces.
- *
- * @type {Record<string, string>}
- */
-const webNamespaces = {
-  html: 'http://www.w3.org/1999/xhtml',
-  mathml: 'http://www.w3.org/1998/Math/MathML',
-  svg: 'http://www.w3.org/2000/svg',
-  xlink: 'http://www.w3.org/1999/xlink',
-  xml: 'http://www.w3.org/XML/1998/namespace',
-  xmlns: 'http://www.w3.org/2000/xmlns/'
-};
-
 /**
  * @typedef {import('hast').Comment} Comment
  * @typedef {import('hast').Doctype} Doctype
@@ -24150,7 +23946,7 @@ const emptyOptions = {};
 
 const own = {}.hasOwnProperty;
 
-const one = index$2.zwitch('type', {handlers: {root: root$1, element: element$1, text: text$1, comment: comment$1, doctype: doctype$1}});
+const one = index$1.zwitch('type', {handlers: {root: root$1, element: element$1, text: text$1, comment: comment$1, doctype: doctype$1}});
 
 /**
  * Transform a hast tree to a `parse5` AST.
@@ -24310,7 +24106,7 @@ function element$1(node, schema) {
     tagName: node.tagName,
     attrs,
     // @ts-expect-error: `parse5` types are wrong.
-    namespaceURI: webNamespaces[space],
+    namespaceURI: index$1.webNamespaces[space],
     childNodes: [],
     parentNode: null
   };
@@ -24354,7 +24150,7 @@ function createProperty(schema, prop, value) {
   if (Array.isArray(value)) {
     // Accept `array`.
     // Most props are space-separated.
-    value = info.commaSeparated ? stringify$1(value) : stringify(value);
+    value = info.commaSeparated ? index$1.stringify(value) : index$1.stringify$1(value);
   }
 
   /** @type {Parse5Attribute} */
@@ -24373,7 +24169,7 @@ function createProperty(schema, prop, value) {
       attribute.prefix = info.attribute.slice(0, index);
     }
 
-    attribute.namespace = webNamespaces[info.space];
+    attribute.namespace = index$1.webNamespaces[info.space];
   }
 
   return attribute
@@ -25804,13 +25600,13 @@ class Tokenizer {
         let result = null;
         let excess = 0;
         let withoutSemicolon = false;
-        for (let i = 0, current = index$2.htmlDecodeTree[0]; i >= 0; cp = this._consume()) {
-            i = index$2.determineBranch(index$2.htmlDecodeTree, current, i + 1, cp);
+        for (let i = 0, current = index$1.htmlDecodeTree[0]; i >= 0; cp = this._consume()) {
+            i = index$1.determineBranch(index$1.htmlDecodeTree, current, i + 1, cp);
             if (i < 0)
                 break;
             excess += 1;
-            current = index$2.htmlDecodeTree[i];
-            const masked = current & index$2.BinTrieFlags.VALUE_LENGTH;
+            current = index$1.htmlDecodeTree[i];
+            const masked = current & index$1.BinTrieFlags.VALUE_LENGTH;
             // If the branch is a value, store it and continue
             if (masked) {
                 // The mask is the number of bytes of the value, including the current byte.
@@ -25830,10 +25626,10 @@ class Tokenizer {
                     // If this is a surrogate pair, consume the next two bytes.
                     result =
                         valueLength === 0
-                            ? [index$2.htmlDecodeTree[i] & ~index$2.BinTrieFlags.VALUE_LENGTH]
+                            ? [index$1.htmlDecodeTree[i] & ~index$1.BinTrieFlags.VALUE_LENGTH]
                             : valueLength === 1
-                                ? [index$2.htmlDecodeTree[++i]]
-                                : [index$2.htmlDecodeTree[++i], index$2.htmlDecodeTree[++i]];
+                                ? [index$1.htmlDecodeTree[++i]]
+                                : [index$1.htmlDecodeTree[++i], index$1.htmlDecodeTree[++i]];
                     excess = 0;
                     withoutSemicolon = cp !== CODE_POINTS.SEMICOLON;
                 }
@@ -32295,85 +32091,6 @@ function endTagInForeignContent(p, token) {
     }
 }
 
-/**
- * @typedef {import('unist').Node} Node
- * @typedef {import('unist').Point} Point
- * @typedef {import('unist').Position} Position
- */
-
-/**
- * @typedef NodeLike
- * @property {string} type
- * @property {PositionLike | null | undefined} [position]
- *
- * @typedef PositionLike
- * @property {PointLike | null | undefined} [start]
- * @property {PointLike | null | undefined} [end]
- *
- * @typedef PointLike
- * @property {number | null | undefined} [line]
- * @property {number | null | undefined} [column]
- * @property {number | null | undefined} [offset]
- */
-
-/**
- * Get the ending point of `node`.
- *
- * @param node
- *   Node.
- * @returns
- *   Point.
- */
-const pointEnd = point('end');
-
-/**
- * Get the starting point of `node`.
- *
- * @param node
- *   Node.
- * @returns
- *   Point.
- */
-const pointStart = point('start');
-
-/**
- * Get the positional info of `node`.
- *
- * @param {'end' | 'start'} type
- *   Side.
- * @returns
- *   Getter.
- */
-function point(type) {
-  return point
-
-  /**
-   * Get the point info of `node` at a bound side.
-   *
-   * @param {Node | NodeLike | null | undefined} [node]
-   * @returns {Point | undefined}
-   */
-  function point(node) {
-    const point = (node && node.position && node.position[type]) || {};
-
-    if (
-      typeof point.line === 'number' &&
-      point.line > 0 &&
-      typeof point.column === 'number' &&
-      point.column > 0
-    ) {
-      return {
-        line: point.line,
-        column: point.column,
-        offset:
-          typeof point.offset === 'number' && point.offset > -1
-            ? point.offset
-            : undefined
-      }
-    }
-  }
-}
-
 /**
  * @typedef {import('hast').Comment} Comment
  * @typedef {import('hast').Doctype} Doctype
@@ -32426,7 +32143,7 @@ const parseOptions = {sourceCodeLocationInfo: true, scriptingEnabled: false};
 function raw(tree, options) {
   const document = documentMode(tree);
   /** @type {(node: Nodes, state: State) => undefined} */
-  const one = index$2.zwitch('type', {
+  const one = index$1.zwitch('type', {
     handlers: {root, element, text, comment, doctype, raw: handleRaw},
     unknown
   });
@@ -32444,7 +32161,7 @@ function raw(tree, options) {
   };
 
   one(tree, state);
-  resetTokenizer(state, pointStart());
+  resetTokenizer(state, index$1.pointStart());
 
   const p5 = document ? state.parser.document : state.parser.getFragment();
   const result = fromParse5(p5, {
@@ -32453,7 +32170,7 @@ function raw(tree, options) {
   });
 
   if (state.stitches) {
-    index$2.visit(result, 'comment', function (node, index, parent) {
+    index$1.visit(result, 'comment', function (node, index, parent) {
       const stitch = /** @type {Stitch} */ (/** @type {unknown} */ (node));
       if (stitch.value.stitch && parent && index !== undefined) {
         /** @type {Array<RootContent>} */
@@ -32557,7 +32274,7 @@ function text(node, state) {
     location: createParse5Location(node)
   };
 
-  resetTokenizer(state, pointStart(node));
+  resetTokenizer(state, index$1.pointStart(node));
   // @ts-expect-error: private.
   // type-coverage:ignore-next-line
   state.parser.currentToken = token;
@@ -32587,7 +32304,7 @@ function doctype(node, state) {
     location: createParse5Location(node)
   };
 
-  resetTokenizer(state, pointStart(node));
+  resetTokenizer(state, index$1.pointStart(node));
   // @ts-expect-error: private.
   // type-coverage:ignore-next-line
   state.parser.currentToken = token;
@@ -32650,7 +32367,7 @@ function comment(node, state) {
     data,
     location: createParse5Location(node)
   };
-  resetTokenizer(state, pointStart(node));
+  resetTokenizer(state, index$1.pointStart(node));
   // @ts-expect-error: private.
   // type-coverage:ignore-next-line
   state.parser.currentToken = token;
@@ -32694,7 +32411,7 @@ function handleRaw(node, state) {
   state.parser.tokenizer.preprocessor.isEol = false;
 
   // Now pass `node.value`.
-  setPoint(state, pointStart(node));
+  setPoint(state, index$1.pointStart(node));
   state.parser.tokenizer.write(node.value, false);
   // @ts-expect-error: private.
   // type-coverage:ignore-next-line
@@ -32877,19 +32594,19 @@ function startTag(node, state) {
   // Ignore tags if we’re in plain text.
   if (state.parser.tokenizer.state === TokenizerMode.PLAINTEXT) return
 
-  resetTokenizer(state, pointStart(node));
+  resetTokenizer(state, index$1.pointStart(node));
 
   const current = state.parser.openElements.current;
-  let ns = 'namespaceURI' in current ? current.namespaceURI : webNamespaces$1.html;
+  let ns = 'namespaceURI' in current ? current.namespaceURI : index$1.webNamespaces.html;
 
-  if (ns === webNamespaces$1.html && tagName === 'svg') {
-    ns = webNamespaces$1.svg;
+  if (ns === index$1.webNamespaces.html && tagName === 'svg') {
+    ns = index$1.webNamespaces.svg;
   }
 
   const result = toParse5(
     // Shallow clone to not delve into `children`: we only need the attributes.
     {...node, children: []},
-    {space: ns === webNamespaces$1.svg ? 'svg' : 'html'}
+    {space: ns === index$1.webNamespaces.svg ? 'svg' : 'html'}
   );
 
   /** @type {TagToken} */
@@ -32950,7 +32667,7 @@ function endTag(node, state) {
   // Ignore tags if we’re in plain text.
   if (state.parser.tokenizer.state === TokenizerMode.PLAINTEXT) return
 
-  resetTokenizer(state, pointEnd(node));
+  resetTokenizer(state, index$1.pointEnd(node));
 
   /** @type {TagToken} */
   const tag = {
@@ -33020,12 +32737,12 @@ function documentMode(node) {
  *   `parse5` location.
  */
 function createParse5Location(node) {
-  const start = pointStart(node) || {
+  const start = index$1.pointStart(node) || {
     line: undefined,
     column: undefined,
     offset: undefined
   };
-  const end = pointEnd(node) || {
+  const end = index$1.pointEnd(node) || {
     line: undefined,
     column: undefined,
     offset: undefined
@@ -33056,8 +32773,8 @@ function createParse5Location(node) {
  */
 function cloneWithoutChildren(node) {
   return 'children' in node
-    ? index$2.structuredClone({...node, children: []})
-    : index$2.structuredClone(node)
+    ? index$1.structuredClone({...node, children: []})
+    : index$1.structuredClone(node)
 }
 
 /**
@@ -33856,7 +33573,7 @@ function createLazyLoadImagesPlugin(lazyLoadImages = false) {
             return (tree) => tree;
         }
         return (tree) => {
-            index$2.visit(tree, 'element', (node) => {
+            index$1.visit(tree, 'element', (node) => {
                 if (node.tagName === 'img') {
                     node.properties = node.properties || {};
                     node.properties.loading = 'lazy';
@@ -33880,7 +33597,7 @@ function createLazyLoadImagesPlugin(lazyLoadImages = false) {
 function createLinksPlugin() {
     return () => {
         return (tree) => {
-            index$2.visit(tree, 'element', (node) => {
+            index$1.visit(tree, 'element', (node) => {
                 var _a, _b;
                 if (node.tagName === 'a') {
                     const href = (_a = node.properties) === null || _a === void 0 ? void 0 : _a.href;
@@ -34030,26 +33747,24 @@ const isWhitespace = (value) => {
  */
 async function markdownToHTML(text, options) {
     var _a;
-    if (options === null || options === void 0 ? void 0 : options.forceHardLineBreaks) {
-        text = text.replaceAll(/(?<!\\)([\n\r])/g, '  $1');
-    }
-    const file = await index$2.unified()
+    const file = await index$1.unified()
         .use(remarkParse)
         .use(remarkGfm)
+        .use((options === null || options === void 0 ? void 0 : options.forceHardLineBreaks) ? [remarkBreaks] : [])
         .use(remarkRehype, { allowDangerousHtml: true })
         .use(rehypeRaw)
         .use(createLinksPlugin())
-        .use(index$2.rehypeSanitize, getWhiteList((_a = options === null || options === void 0 ? void 0 : options.whitelist) !== null && _a !== void 0 ? _a : []))
+        .use(index$1.rehypeSanitize, getWhiteList((_a = options === null || options === void 0 ? void 0 : options.whitelist) !== null && _a !== void 0 ? _a : []))
         .use(() => {
         return (tree) => {
             // Run the sanitizeStyle function on all elements, to sanitize
             // the value of the `style` attribute, if there is one.
-            index$2.visit(tree, 'element', sanitizeStyle);
+            index$1.visit(tree, 'element', sanitizeStyle);
         };
     })
         .use(createRemoveEmptyParagraphsPlugin(options === null || options === void 0 ? void 0 : options.removeEmptyParagraphs))
         .use(createLazyLoadImagesPlugin(options === null || options === void 0 ? void 0 : options.lazyLoadImages))
-        .use(index$2.rehypeStringify)
+        .use(index$1.rehypeStringify)
         .process(text);
     return file.toString();
 }
@@ -34061,28 +33776,28 @@ async function markdownToHTML(text, options) {
  * @returns The sanitized HTML string.
  */
 async function sanitizeHTML(html, whitelist) {
-    const file = await index$2.unified()
-        .use(index$2.rehypeParse)
-        .use(index$2.rehypeSanitize, getWhiteList(whitelist !== null && whitelist !== void 0 ? whitelist : []))
+    const file = await index$1.unified()
+        .use(index$1.rehypeParse)
+        .use(index$1.rehypeSanitize, getWhiteList(whitelist !== null && whitelist !== void 0 ? whitelist : []))
         .use(() => {
         return (tree) => {
             // Run the sanitizeStyle function on all elements, to sanitize
             // the value of the `style` attribute, if there is one.
-            index$2.visit(tree, 'element', sanitizeStyle);
+            index$1.visit(tree, 'element', sanitizeStyle);
         };
     })
-        .use(index$2.rehypeStringify)
+        .use(index$1.rehypeStringify)
         .process(html);
     return file.toString();
 }
 function getWhiteList(allowedComponents) {
     var _a, _b, _c, _d;
-    const defaultSchemaClone = [...((_a = index$2.defaultSchema.attributes['*']) !== null && _a !== void 0 ? _a : [])];
+    const defaultSchemaClone = [...((_a = index$1.defaultSchema.attributes['*']) !== null && _a !== void 0 ? _a : [])];
     const asteriskAttributeWhitelist = defaultSchemaClone.filter((attr) => {
         return attr !== 'height';
     });
     asteriskAttributeWhitelist.push('style');
-    const whitelist = Object.assign(Object.assign({}, index$2.defaultSchema), {
+    const whitelist = Object.assign(Object.assign({}, index$1.defaultSchema), {
         // Disable rehype-sanitize's default `user-content-` prefix, which it
         // otherwise prepends to the DOM-clobber attributes (`id`, `name`,
         // `aria-describedby`, `aria-labelledby`).
@@ -34108,18 +33823,18 @@ function getWhiteList(allowedComponents) {
         // output into the light DOM — or these functions become public exports
         // — reinstate the prefix or scope its removal to whitelisted custom
         // elements only.
-        clobberPrefix: '', strip: [...((_b = index$2.defaultSchema.strip) !== null && _b !== void 0 ? _b : []), 'style'], tagNames: [
-            ...(index$2.defaultSchema.tagNames || []),
+        clobberPrefix: '', strip: [...((_b = index$1.defaultSchema.strip) !== null && _b !== void 0 ? _b : []), 'style'], tagNames: [
+            ...(index$1.defaultSchema.tagNames || []),
             // Table column definitions carry the column widths for tables
             // from sources like Google Sheets, where the table element
             // itself has no usable width.
             'colgroup',
             'col',
             ...allowedComponents.map((component) => component.tagName),
-        ], attributes: Object.assign(Object.assign({}, index$2.defaultSchema.attributes), { p: [
-                ...((_c = index$2.defaultSchema.attributes.p) !== null && _c !== void 0 ? _c : []),
+        ], attributes: Object.assign(Object.assign({}, index$1.defaultSchema.attributes), { p: [
+                ...((_c = index$1.defaultSchema.attributes.p) !== null && _c !== void 0 ? _c : []),
                 ['className', 'MsoNormal'],
-            ], a: [...((_d = index$2.defaultSchema.attributes.a) !== null && _d !== void 0 ? _d : []), 'referrerpolicy'], '*': asteriskAttributeWhitelist })
+            ], a: [...((_d = index$1.defaultSchema.attributes.a) !== null && _d !== void 0 ? _d : []), 'referrerpolicy'], '*': asteriskAttributeWhitelist })
     });
     for (const component of allowedComponents) {
         whitelist.attributes[component.tagName] = component.attributes;
@@ -34127,6 +33842,22 @@ function getWhiteList(allowedComponents) {
     return whitelist;
 }
 
+exports.asciiAlpha = asciiAlpha;
+exports.asciiAlphanumeric = asciiAlphanumeric;
+exports.asciiPunctuation = asciiPunctuation;
+exports.classifyCharacter = classifyCharacter;
+exports.decodeString = decodeString;
+exports.encodeCharacterReference = encodeCharacterReference;
+exports.formatCodeAsIndented = formatCodeAsIndented;
+exports.formatHeadingAsSetext = formatHeadingAsSetext;
 exports.getLinkAttributes = getLinkAttributes;
+exports.handle = handle;
+exports.htmlBlockNames = htmlBlockNames;
+exports.htmlRawNames = htmlRawNames;
 exports.markdownToHTML = markdownToHTML;
+exports.patternInScope = patternInScope;
+exports.phrasing = phrasing;
+exports.remarkGfm = remarkGfm;
+exports.remarkParse = remarkParse;
 exports.sanitizeHTML = sanitizeHTML;
+exports.toString = toString;