@limetech/lime-elements 40.5.2 → 40.6.0

package/dist/esm/{markdown-parser-DrxxGLF5.js → markdown-parser-DCf-3dKZ.js}

@@ -1,5 +1,5 @@
 import { g as getDefaultExportFromCjs } from './_commonjsHelpers-B85MJLTf.js';
-import { s as structuredClone, v as visit, f as convert, g as visitParents, h as ccount, E as EXIT, z as zwitch, i as determineBranch, j as htmlDecodeTree, B as BinTrieFlags, u as unified, a as rehypeSanitize, b as rehypeStringify, r as rehypeParse, d as defaultSchema } from './index-CbciMfiU.js';
+import { s as stringifyPosition, p as pointStart, f as pointEnd, g as structuredClone, v as visit, h as position$1, i as convert, j as visitParents, k as ccount, E as EXIT, l as parseSelector, m as parse$1, n as parse$2, w as webNamespaces, z as zwitch, o as stringify, q as stringify$1, t as determineBranch, x as htmlDecodeTree, B as BinTrieFlags, u as unified, a as rehypeSanitize, b as rehypeStringify, r as rehypeParse, d as defaultSchema } from './index-BN64nlbO.js';
 
 /**
  *
@@ -3461,7 +3461,7 @@ function resolveAll(constructs, events, context) {
  */
 
 /** @type {Construct} */
-const attention = {
+const attention$2 = {
   name: 'attention',
   tokenize: tokenizeAttention,
   resolveAll: resolveAllAttention
@@ -10690,18 +10690,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']} */
@@ -10740,7 +10740,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} */
@@ -10802,7 +10802,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}
@@ -10846,8 +10846,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);
@@ -10942,91 +10942,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
@@ -11094,7 +11009,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))
     )
   )
 }
@@ -11277,7 +11192,7 @@ function compiler(options) {
 
     // Figure out `root` position.
     tree.position = {
-      start: point$3(
+      start: point$1(
         events.length > 0
           ? events[0][1].start
           : {
@@ -11286,7 +11201,7 @@ function compiler(options) {
               offset: 0
             }
       ),
-      end: point$3(
+      end: point$1(
         events.length > 0
           ? events[events.length - 2][1].end
           : {
@@ -11494,7 +11409,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
     };
@@ -11554,7 +11469,7 @@ function compiler(options) {
         handler.call(this, token, open[0]);
       }
     }
-    node.position.end = point$3(token.end);
+    node.position.end = point$1(token.end);
   }
 
   /**
@@ -11725,7 +11640,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
       };
@@ -11742,7 +11657,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);
   }
 
   /**
@@ -11755,7 +11670,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
     }
@@ -11989,7 +11904,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);
   }
 
   /**
@@ -12173,7 +12088,7 @@ function compiler(options) {
  * @returns {Point}
  *   unist point.
  */
-function point$3(d) {
+function point$1(d) {
   return {
     line: d.line,
     column: d.column,
@@ -13080,102 +12995,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'
@@ -13220,8 +13039,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 = pointStart(node.children[1]);
+    const end = pointEnd(node.children[node.children.length - 1]);
     if (start && end) body.position = {start, end};
     tableContent.push(body);
   }
@@ -15446,17 +15265,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} */
+  (
+    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');
@@ -15471,7 +15332,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
 }
@@ -15481,9 +15346,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 (
@@ -15493,10 +15363,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') {
@@ -15525,23 +15401,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) ? '' : ' '
     }
   }
 
@@ -15591,20 +15478,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)
   )
 }
 
@@ -15613,8 +15505,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 || '`';
@@ -15637,16 +15533,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');
@@ -15658,6 +15560,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) {
@@ -15698,7 +15601,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
 }
@@ -15708,8 +15615,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 || '"';
@@ -15732,11 +15643,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);
@@ -15806,8 +15724,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 || '*';
@@ -15824,166 +15746,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'
@@ -15991,9 +15831,14 @@ 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;
@@ -16012,8 +15857,8 @@ function formatHeadingAsSetext(node, state) {
 
   return Boolean(
     (!node.depth || node.depth < 3) &&
-      toString(node) &&
-      (state.options.setext || literalWithBreak)
+    toString(node) &&
+    (state.options.setext || literalWithBreak)
   )
 }
 
@@ -16024,11 +15869,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);
@@ -16074,9 +15926,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;
@@ -16098,15 +15952,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 '<'
@@ -16121,11 +15982,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);
@@ -16188,7 +16056,10 @@ function image(node, _, state, info) {
 }
 
 /**
+ * Peek at this node.
+ *
  * @returns {string}
+ *   Start of the serialized markdown.
  */
 function imagePeek() {
   return '!'
@@ -16202,11 +16073,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;
@@ -16222,9 +16100,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.
@@ -16252,7 +16135,10 @@ function imageReference(node, _, state, info) {
 }
 
 /**
+ * Peek at this node.
+ *
  * @returns {string}
+ *   Start of the serialized markdown.
  */
 function imageReferencePeek() {
   return '!'
@@ -16266,10 +16152,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 || '';
@@ -16286,8 +16178,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 + ' ';
   }
@@ -16302,14 +16194,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;
 
@@ -16329,7 +16222,10 @@ function inlineCode(node, _, state) {
 }
 
 /**
+ * Peek at this node.
+ *
  * @returns {string}
+ *   Start of the serialized markdown.
  */
 function inlineCodePeek() {
   return '`'
@@ -16342,30 +16238,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)
   )
 }
 
@@ -16379,26 +16280,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, {
@@ -16413,8 +16323,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, {
@@ -16473,10 +16383,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) ? '<' : '['
@@ -16490,11 +16406,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;
@@ -16510,9 +16433,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.
@@ -16540,7 +16468,10 @@ function linkReference(node, _, state, info) {
 }
 
 /**
+ * Peek at this node.
+ *
  * @returns {string}
+ *   Start of the serialized markdown.
  */
 function linkReferencePeek() {
   return '['
@@ -16551,8 +16482,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 || '*';
@@ -16574,8 +16509,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);
@@ -16611,8 +16550,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 || '.';
@@ -16633,8 +16576,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 || '*';
@@ -16657,11 +16604,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');
@@ -16752,8 +16706,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';
@@ -16776,11 +16734,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);
@@ -16820,7 +16785,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
@@ -16836,11 +16805,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');
@@ -16851,41 +16827,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} */
-  (
-    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'
@@ -16893,11 +16834,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.
@@ -16905,8 +16853,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
 }
 
 /**
@@ -16914,8 +16866,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 || '*';
@@ -16932,69 +16888,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 || '*'
 }
 
@@ -17004,11 +16960,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)
@@ -17019,8 +16982,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;
@@ -17043,10 +17010,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 = (
@@ -17188,7 +17161,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];
@@ -17201,7 +17174,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
 }
@@ -20563,6 +20536,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
@@ -21820,157 +21846,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
@@ -22145,11 +22020,11 @@ function addProperty(schema, properties, key, value) {
   // Handle list values.
   else if (typeof value === 'string') {
     if (info.spaceSeparated) {
-      result = parse(value);
-    } else if (info.commaSeparated) {
       result = parse$1(value);
+    } else if (info.commaSeparated) {
+      result = parse$2(value);
     } else if (info.commaOrSpaceSeparated) {
-      result = parse(parse$1(value).join(' '));
+      result = parse$1(parse$2(value).join(' '));
     } else {
       result = parsePrimitive(info, info.property, value);
     }
@@ -22466,15 +22341,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
@@ -22631,7 +22497,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 === webNamespaces.svg ? svg$2 : html$2;
 
   // Props.
   let index = -1;
@@ -22765,12 +22631,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
@@ -22789,45 +22655,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
@@ -24085,41 +23916,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
@@ -24352,7 +24148,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 ? stringify(value) : stringify$1(value);
   }
 
   /** @type {Parse5Attribute} */
@@ -32293,85 +32089,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
@@ -32878,16 +32595,16 @@ function startTag(node, state) {
   resetTokenizer(state, 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 : webNamespaces.html;
 
-  if (ns === webNamespaces$1.html && tagName === 'svg') {
-    ns = webNamespaces$1.svg;
+  if (ns === webNamespaces.html && tagName === 'svg') {
+    ns = 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 === webNamespaces.svg ? 'svg' : 'html'}
   );
 
   /** @type {TagToken} */
@@ -34028,12 +33745,10 @@ 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 unified()
         .use(remarkParse)
         .use(remarkGfm)
+        .use((options === null || options === void 0 ? void 0 : options.forceHardLineBreaks) ? [remarkBreaks] : [])
         .use(remarkRehype, { allowDangerousHtml: true })
         .use(rehypeRaw)
         .use(createLinksPlugin())
@@ -34125,4 +33840,4 @@ function getWhiteList(allowedComponents) {
     return whitelist;
 }
 
-export { getLinkAttributes as g, markdownToHTML as m, sanitizeHTML as s };
+export { asciiAlpha as a, asciiAlphanumeric as b, htmlBlockNames as c, formatHeadingAsSetext as d, decodeString as e, formatCodeAsIndented as f, getLinkAttributes as g, htmlRawNames as h, classifyCharacter as i, asciiPunctuation as j, encodeCharacterReference as k, handle as l, markdownToHTML as m, phrasing as n, remarkParse as o, patternInScope as p, remarkGfm as r, sanitizeHTML as s, toString as t };