@limetech/lime-elements 39.12.5 → 39.13.0

package/dist/esm/{markdown-parser-CeVA0wsI.js → markdown-parser-CXYHPPe2.js}

@@ -1,5 +1,5 @@
 import { g as getDefaultExportFromCjs } from './_commonjsHelpers-BFTU3MAI.js';
-import { s as structuredClone, v as visit, e as convert, f as visitParents, E as EXIT, g as determineBranch, h as htmlDecodeTree, B as BinTrieFlags, u as unified, a as rehypeSanitize, b as rehypeStringify, r as rehypeParse, d as defaultSchema } from './index-CJ0GYrWG.js';
+import { s as structuredClone, v as visit, e as convert, f as visitParents, g as ccount, E as EXIT, z as zwitch, h as determineBranch, i as htmlDecodeTree, B as BinTrieFlags, u as unified, a as rehypeSanitize, b as rehypeStringify, r as rehypeParse, d as defaultSchema } from './index-DJJymEnS.js';
 
 /**
  *
@@ -57,7 +57,7 @@ function isProtocolRelativeUrl(url) {
  */
 
 /** @type {Options} */
-const emptyOptions$5 = {};
+const emptyOptions$3 = {};
 
 /**
  * Get the text content of a node or list of nodes.
@@ -72,8 +72,8 @@ const emptyOptions$5 = {};
  * @returns {string}
  *   Serialized `value`.
  */
-function toString$2(value, options) {
-  const settings = emptyOptions$5;
+function toString(value, options) {
+  const settings = emptyOptions$3;
   const includeImageAlt =
     typeof settings.includeImageAlt === 'boolean'
       ? settings.includeImageAlt
@@ -81,7 +81,7 @@ function toString$2(value, options) {
   const includeHtml =
     typeof settings.includeHtml === 'boolean' ? settings.includeHtml : true;
 
-  return one$4(value, includeImageAlt, includeHtml)
+  return one$2(value, includeImageAlt, includeHtml)
 }
 
 /**
@@ -96,8 +96,8 @@ function toString$2(value, options) {
  * @returns {string}
  *   Serialized node.
  */
-function one$4(value, includeImageAlt, includeHtml) {
-  if (node$2(value)) {
+function one$2(value, includeImageAlt, includeHtml) {
+  if (node(value)) {
     if ('value' in value) {
       return value.type === 'html' && !includeHtml ? '' : value.value
     }
@@ -107,12 +107,12 @@ function one$4(value, includeImageAlt, includeHtml) {
     }
 
     if ('children' in value) {
-      return all$5(value.children, includeImageAlt, includeHtml)
+      return all$3(value.children, includeImageAlt, includeHtml)
     }
   }
 
   if (Array.isArray(value)) {
-    return all$5(value, includeImageAlt, includeHtml)
+    return all$3(value, includeImageAlt, includeHtml)
   }
 
   return ''
@@ -130,13 +130,13 @@ function one$4(value, includeImageAlt, includeHtml) {
  * @returns {string}
  *   Serialized nodes.
  */
-function all$5(values, includeImageAlt, includeHtml) {
+function all$3(values, includeImageAlt, includeHtml) {
   /** @type {Array<string>} */
   const result = [];
   let index = -1;
 
   while (++index < values.length) {
-    result[index] = one$4(values[index], includeImageAlt, includeHtml);
+    result[index] = one$2(values[index], includeImageAlt, includeHtml);
   }
 
   return result.join('')
@@ -150,7 +150,7 @@ function all$5(values, includeImageAlt, includeHtml) {
  * @returns {value is Nodes}
  *   Whether `value` is a node.
  */
-function node$2(value) {
+function node(value) {
   return Boolean(value && typeof value === 'object')
 }
 
@@ -2287,7 +2287,7 @@ const characterEntities = {
   zwnj: '‌'
 };
 
-const own$9 = {}.hasOwnProperty;
+const own$7 = {}.hasOwnProperty;
 
 /**
  * Decode a single character reference (without the `&` or `;`).
@@ -2301,7 +2301,7 @@ const own$9 = {}.hasOwnProperty;
  *   Decoded reference.
  */
 function decodeNamedCharacterReference(value) {
-  return own$9.call(characterEntities, value) ? characterEntities[value] : false
+  return own$7.call(characterEntities, value) ? characterEntities[value] : false
 }
 
 /**
@@ -6230,7 +6230,7 @@ function factoryWhitespace(effects, ok) {
  */
 
 /** @type {Construct} */
-const definition$2 = {
+const definition$1 = {
   name: 'definition',
   tokenize: tokenizeDefinition
 };
@@ -9269,7 +9269,7 @@ function tokenizeLineEnding(effects, ok) {
  */
 
 /** @type {Construct} */
-const thematicBreak$3 = {
+const thematicBreak$2 = {
   name: 'thematicBreak',
   tokenize: tokenizeThematicBreak
 };
@@ -9372,7 +9372,7 @@ function tokenizeThematicBreak(effects, ok, nok) {
 
 
 /** @type {Construct} */
-const list$3 = {
+const list$2 = {
   name: 'list',
   tokenize: tokenizeListStart,
   continuation: {
@@ -9431,7 +9431,7 @@ function tokenizeListStart(effects, ok, nok) {
       if (kind === 'listUnordered') {
         effects.enter('listItemPrefix');
         return code === 42 || code === 45
-          ? effects.check(thematicBreak$3, nok, atMarker)(code)
+          ? effects.check(thematicBreak$2, nok, atMarker)(code)
           : atMarker(code)
       }
       if (!self.interrupt || code === 49) {
@@ -9555,7 +9555,7 @@ function tokenizeListContinuation(effects, ok, nok) {
 
     return factorySpace(
       effects,
-      effects.attempt(list$3, ok, nok),
+      effects.attempt(list$2, ok, nok),
       'linePrefix',
       self.parser.constructs.disable.null.includes('codeIndented')
         ? undefined
@@ -9885,7 +9885,7 @@ const resolver = {
   resolveAll: createResolver()
 };
 const string$1 = initializeFactory('string');
-const text$7 = initializeFactory('text');
+const text$6 = initializeFactory('text');
 
 /**
  * @param {'string' | 'text'} field
@@ -10637,25 +10637,25 @@ function serializeChunks(chunks, expandTabs) {
 
 /** @satisfies {Extension['document']} */
 const document = {
-  [42]: list$3,
-  [43]: list$3,
-  [45]: list$3,
-  [48]: list$3,
-  [49]: list$3,
-  [50]: list$3,
-  [51]: list$3,
-  [52]: list$3,
-  [53]: list$3,
-  [54]: list$3,
-  [55]: list$3,
-  [56]: list$3,
-  [57]: list$3,
+  [42]: list$2,
+  [43]: list$2,
+  [45]: list$2,
+  [48]: list$2,
+  [49]: list$2,
+  [50]: list$2,
+  [51]: list$2,
+  [52]: list$2,
+  [53]: list$2,
+  [54]: list$2,
+  [55]: list$2,
+  [56]: list$2,
+  [57]: list$2,
   [62]: blockQuote
 };
 
 /** @satisfies {Extension['contentInitial']} */
 const contentInitial = {
-  [91]: definition$2
+  [91]: definition$1
 };
 
 /** @satisfies {Extension['flowInitial']} */
@@ -10668,11 +10668,11 @@ const flowInitial = {
 /** @satisfies {Extension['flow']} */
 const flow = {
   [35]: headingAtx,
-  [42]: thematicBreak$3,
-  [45]: [setextUnderline, thematicBreak$3],
+  [42]: thematicBreak$2,
+  [45]: [setextUnderline, thematicBreak$2],
   [60]: htmlFlow,
   [61]: setextUnderline,
-  [95]: thematicBreak$3,
+  [95]: thematicBreak$2,
   [96]: codeFenced,
   [126]: codeFenced
 };
@@ -10684,7 +10684,7 @@ const string = {
 };
 
 /** @satisfies {Extension['text']} */
-const text$6 = {
+const text$5 = {
   [-5]: lineEnding,
   [-4]: lineEnding,
   [-3]: lineEnding,
@@ -10724,7 +10724,7 @@ var defaultConstructs = /*#__PURE__*/Object.freeze({
     flowInitial: flowInitial,
     insideSpan: insideSpan,
     string: string,
-    text: text$6
+    text: text$5
 });
 
 /**
@@ -10755,7 +10755,7 @@ function parse$3(options) {
     document: create(document$1),
     flow: create(flow$1),
     string: create(string$1),
-    text: create(text$7)
+    text: create(text$6)
   };
   return parser
 
@@ -11062,7 +11062,7 @@ function index(value) {
  * @typedef {import('../index.js').CompileData} CompileData
  */
 
-const own$8 = {}.hasOwnProperty;
+const own$6 = {}.hasOwnProperty;
 
 /**
  * Turn markdown into a syntax tree.
@@ -11255,7 +11255,7 @@ function compiler(options) {
     index = -1;
     while (++index < events.length) {
       const handler = config[events[index][0]];
-      if (own$8.call(handler, events[index][1].type)) {
+      if (own$6.call(handler, events[index][1].type)) {
         handler[events[index][1].type].call(
           Object.assign(
             {
@@ -11562,7 +11562,7 @@ function compiler(options) {
    * @returns {string}
    */
   function resume() {
-    return toString$2(this.stack.pop())
+    return toString(this.stack.pop())
   }
 
   //
@@ -12207,7 +12207,7 @@ function extension(combined, extension) {
   /** @type {keyof Extension} */
   let key;
   for (key in extension) {
-    if (own$8.call(extension, key)) {
+    if (own$6.call(extension, key)) {
       switch (key) {
         case 'canContainEols': {
           const right = extension[key];
@@ -12311,12 +12311,11 @@ function remarkParse(options) {
 }
 
 /**
- * @typedef {import('hast').Element} Element
- * @typedef {import('mdast').Blockquote} Blockquote
- * @typedef {import('../state.js').State} State
+ * @import {Element} from 'hast'
+ * @import {Blockquote} from 'mdast'
+ * @import {State} from '../state.js'
  */
 
-
 /**
  * Turn an mdast `blockquote` node into hast.
  *
@@ -12327,7 +12326,7 @@ function remarkParse(options) {
  * @returns {Element}
  *   hast node.
  */
-function blockquote$2(state, node) {
+function blockquote$1(state, node) {
   /** @type {Element} */
   const result = {
     type: 'element',
@@ -12340,13 +12339,11 @@ function blockquote$2(state, node) {
 }
 
 /**
- * @typedef {import('hast').Element} Element
- * @typedef {import('hast').Text} Text
- * @typedef {import('mdast').Break} Break
- * @typedef {import('../state.js').State} State
+ * @import {Element, Text} from 'hast'
+ * @import {Break} from 'mdast'
+ * @import {State} from '../state.js'
  */
 
-
 /**
  * Turn an mdast `break` node into hast.
  *
@@ -12357,7 +12354,7 @@ function blockquote$2(state, node) {
  * @returns {Array<Element | Text>}
  *   hast element content.
  */
-function hardBreak$2(state, node) {
+function hardBreak$1(state, node) {
   /** @type {Element} */
   const result = {type: 'element', tagName: 'br', properties: {}, children: []};
   state.patch(node, result);
@@ -12365,13 +12362,11 @@ function hardBreak$2(state, node) {
 }
 
 /**
- * @typedef {import('hast').Element} Element
- * @typedef {import('hast').Properties} Properties
- * @typedef {import('mdast').Code} Code
- * @typedef {import('../state.js').State} State
+ * @import {Element, Properties} from 'hast'
+ * @import {Code} from 'mdast'
+ * @import {State} from '../state.js'
  */
 
-
 /**
  * Turn an mdast `code` node into hast.
  *
@@ -12382,13 +12377,16 @@ function hardBreak$2(state, node) {
  * @returns {Element}
  *   hast node.
  */
-function code$3(state, node) {
+function code$2(state, node) {
   const value = node.value ? node.value + '\n' : '';
   /** @type {Properties} */
   const properties = {};
+  // Someone can write `js&#x20;python&#x9;ruby`.
+  const language = node.lang ? node.lang.split(/\s+/) : [];
 
-  if (node.lang) {
-    properties.className = ['language-' + node.lang];
+  // GH/CM still drop the non-first languages.
+  if (language.length > 0) {
+    properties.className = ['language-' + language[0]];
   }
 
   // Create `<code>`.
@@ -12414,12 +12412,11 @@ function code$3(state, node) {
 }
 
 /**
- * @typedef {import('hast').Element} Element
- * @typedef {import('mdast').Delete} Delete
- * @typedef {import('../state.js').State} State
+ * @import {Element} from 'hast'
+ * @import {Delete} from 'mdast'
+ * @import {State} from '../state.js'
  */
 
-
 /**
  * Turn an mdast `delete` node into hast.
  *
@@ -12443,12 +12440,11 @@ function strikethrough(state, node) {
 }
 
 /**
- * @typedef {import('hast').Element} Element
- * @typedef {import('mdast').Emphasis} Emphasis
- * @typedef {import('../state.js').State} State
+ * @import {Element} from 'hast'
+ * @import {Emphasis} from 'mdast'
+ * @import {State} from '../state.js'
  */
 
-
 /**
  * Turn an mdast `emphasis` node into hast.
  *
@@ -12459,7 +12455,7 @@ function strikethrough(state, node) {
  * @returns {Element}
  *   hast node.
  */
-function emphasis$2(state, node) {
+function emphasis$1(state, node) {
   /** @type {Element} */
   const result = {
     type: 'element',
@@ -12472,9 +12468,9 @@ function emphasis$2(state, node) {
 }
 
 /**
- * @typedef {import('hast').Element} Element
- * @typedef {import('mdast').FootnoteReference} FootnoteReference
- * @typedef {import('../state.js').State} State
+ * @import {Element} from 'hast'
+ * @import {FootnoteReference} from 'mdast'
+ * @import {State} from '../state.js'
  */
 
 
@@ -12542,12 +12538,11 @@ function footnoteReference$1(state, node) {
 }
 
 /**
- * @typedef {import('hast').Element} Element
- * @typedef {import('mdast').Heading} Heading
- * @typedef {import('../state.js').State} State
+ * @import {Element} from 'hast'
+ * @import {Heading} from 'mdast'
+ * @import {State} from '../state.js'
  */
 
-
 /**
  * Turn an mdast `heading` node into hast.
  *
@@ -12558,7 +12553,7 @@ function footnoteReference$1(state, node) {
  * @returns {Element}
  *   hast node.
  */
-function heading$2(state, node) {
+function heading$1(state, node) {
   /** @type {Element} */
   const result = {
     type: 'element',
@@ -12571,13 +12566,12 @@ function heading$2(state, node) {
 }
 
 /**
- * @typedef {import('hast').Element} Element
- * @typedef {import('mdast').Html} Html
- * @typedef {import('../state.js').State} State
- * @typedef {import('../../index.js').Raw} Raw
+ * @import {Element} from 'hast'
+ * @import {Html} from 'mdast'
+ * @import {State} from '../state.js'
+ * @import {Raw} from '../../index.js'
  */
 
-
 /**
  * Turn an mdast `html` node into hast (`raw` node in dangerous mode, otherwise
  * nothing).
@@ -12589,7 +12583,7 @@ function heading$2(state, node) {
  * @returns {Element | Raw | undefined}
  *   hast node.
  */
-function html$6(state, node) {
+function html$5(state, node) {
   if (state.options.allowDangerousHtml) {
     /** @type {Raw} */
     const result = {type: 'raw', value: node.value};
@@ -12601,15 +12595,11 @@ function html$6(state, node) {
 }
 
 /**
- * @typedef {import('hast').ElementContent} ElementContent
- *
- * @typedef {import('mdast').Nodes} Nodes
- * @typedef {import('mdast').Reference} Reference
- *
- * @typedef {import('./state.js').State} State
+ * @import {ElementContent} from 'hast'
+ * @import {Reference, Nodes} from 'mdast'
+ * @import {State} from './state.js'
  */
 
-
 /**
  * Return the content of a reference without definition as plain text.
  *
@@ -12655,11 +12645,9 @@ function revert(state, node) {
 }
 
 /**
- * @typedef {import('hast').Element} Element
- * @typedef {import('hast').ElementContent} ElementContent
- * @typedef {import('hast').Properties} Properties
- * @typedef {import('mdast').ImageReference} ImageReference
- * @typedef {import('../state.js').State} State
+ * @import {ElementContent, Element, Properties} from 'hast'
+ * @import {ImageReference} from 'mdast'
+ * @import {State} from '../state.js'
  */
 
 
@@ -12673,19 +12661,19 @@ function revert(state, node) {
  * @returns {Array<ElementContent> | ElementContent}
  *   hast node.
  */
-function imageReference$2(state, node) {
+function imageReference$1(state, node) {
   const id = String(node.identifier).toUpperCase();
-  const def = state.definitionById.get(id);
+  const definition = state.definitionById.get(id);
 
-  if (!def) {
+  if (!definition) {
     return revert(state, node)
   }
 
   /** @type {Properties} */
-  const properties = {src: normalizeUri(def.url || ''), alt: node.alt};
+  const properties = {src: normalizeUri(definition.url || ''), alt: node.alt};
 
-  if (def.title !== null && def.title !== undefined) {
-    properties.title = def.title;
+  if (definition.title !== null && definition.title !== undefined) {
+    properties.title = definition.title;
   }
 
   /** @type {Element} */
@@ -12695,10 +12683,9 @@ function imageReference$2(state, node) {
 }
 
 /**
- * @typedef {import('hast').Element} Element
- * @typedef {import('hast').Properties} Properties
- * @typedef {import('mdast').Image} Image
- * @typedef {import('../state.js').State} State
+ * @import {Element, Properties} from 'hast'
+ * @import {Image} from 'mdast'
+ * @import {State} from '../state.js'
  */
 
 
@@ -12712,7 +12699,7 @@ function imageReference$2(state, node) {
  * @returns {Element}
  *   hast node.
  */
-function image$2(state, node) {
+function image$1(state, node) {
   /** @type {Properties} */
   const properties = {src: normalizeUri(node.url)};
 
@@ -12731,13 +12718,11 @@ function image$2(state, node) {
 }
 
 /**
- * @typedef {import('hast').Element} Element
- * @typedef {import('hast').Text} Text
- * @typedef {import('mdast').InlineCode} InlineCode
- * @typedef {import('../state.js').State} State
+ * @import {Element, Text} from 'hast'
+ * @import {InlineCode} from 'mdast'
+ * @import {State} from '../state.js'
  */
 
-
 /**
  * Turn an mdast `inlineCode` node into hast.
  *
@@ -12748,7 +12733,7 @@ function image$2(state, node) {
  * @returns {Element}
  *   hast node.
  */
-function inlineCode$2(state, node) {
+function inlineCode$1(state, node) {
   /** @type {Text} */
   const text = {type: 'text', value: node.value.replace(/\r?\n|\r/g, ' ')};
   state.patch(node, text);
@@ -12765,11 +12750,9 @@ function inlineCode$2(state, node) {
 }
 
 /**
- * @typedef {import('hast').Element} Element
- * @typedef {import('hast').ElementContent} ElementContent
- * @typedef {import('hast').Properties} Properties
- * @typedef {import('mdast').LinkReference} LinkReference
- * @typedef {import('../state.js').State} State
+ * @import {ElementContent, Element, Properties} from 'hast'
+ * @import {LinkReference} from 'mdast'
+ * @import {State} from '../state.js'
  */
 
 
@@ -12783,19 +12766,19 @@ function inlineCode$2(state, node) {
  * @returns {Array<ElementContent> | ElementContent}
  *   hast node.
  */
-function linkReference$2(state, node) {
+function linkReference$1(state, node) {
   const id = String(node.identifier).toUpperCase();
-  const def = state.definitionById.get(id);
+  const definition = state.definitionById.get(id);
 
-  if (!def) {
+  if (!definition) {
     return revert(state, node)
   }
 
   /** @type {Properties} */
-  const properties = {href: normalizeUri(def.url || '')};
+  const properties = {href: normalizeUri(definition.url || '')};
 
-  if (def.title !== null && def.title !== undefined) {
-    properties.title = def.title;
+  if (definition.title !== null && definition.title !== undefined) {
+    properties.title = definition.title;
   }
 
   /** @type {Element} */
@@ -12810,10 +12793,9 @@ function linkReference$2(state, node) {
 }
 
 /**
- * @typedef {import('hast').Element} Element
- * @typedef {import('hast').Properties} Properties
- * @typedef {import('mdast').Link} Link
- * @typedef {import('../state.js').State} State
+ * @import {Element, Properties} from 'hast'
+ * @import {Link} from 'mdast'
+ * @import {State} from '../state.js'
  */
 
 
@@ -12827,7 +12809,7 @@ function linkReference$2(state, node) {
  * @returns {Element}
  *   hast node.
  */
-function link$2(state, node) {
+function link$1(state, node) {
   /** @type {Properties} */
   const properties = {href: normalizeUri(node.url)};
 
@@ -12847,15 +12829,11 @@ function link$2(state, node) {
 }
 
 /**
- * @typedef {import('hast').Element} Element
- * @typedef {import('hast').ElementContent} ElementContent
- * @typedef {import('hast').Properties} Properties
- * @typedef {import('mdast').ListItem} ListItem
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../state.js').State} State
+ * @import {ElementContent, Element, Properties} from 'hast'
+ * @import {ListItem, Parents} from 'mdast'
+ * @import {State} from '../state.js'
  */
 
-
 /**
  * Turn an mdast `listItem` node into hast.
  *
@@ -12868,7 +12846,7 @@ function link$2(state, node) {
  * @returns {Element}
  *   hast node.
  */
-function listItem$2(state, node, parent) {
+function listItem$1(state, node, parent) {
   const results = state.all(node);
   const loose = parent ? listLoose(parent) : listItemLoose(node);
   /** @type {Properties} */
@@ -12971,13 +12949,11 @@ function listItemLoose(node) {
 }
 
 /**
- * @typedef {import('hast').Element} Element
- * @typedef {import('hast').Properties} Properties
- * @typedef {import('mdast').List} List
- * @typedef {import('../state.js').State} State
+ * @import {Element, Properties} from 'hast'
+ * @import {List} from 'mdast'
+ * @import {State} from '../state.js'
  */
 
-
 /**
  * Turn an mdast `list` node into hast.
  *
@@ -12988,7 +12964,7 @@ function listItemLoose(node) {
  * @returns {Element}
  *   hast node.
  */
-function list$2(state, node) {
+function list$1(state, node) {
   /** @type {Properties} */
   const properties = {};
   const results = state.all(node);
@@ -13026,12 +13002,11 @@ function list$2(state, node) {
 }
 
 /**
- * @typedef {import('hast').Element} Element
- * @typedef {import('mdast').Paragraph} Paragraph
- * @typedef {import('../state.js').State} State
+ * @import {Element} from 'hast'
+ * @import {Paragraph} from 'mdast'
+ * @import {State} from '../state.js'
  */
 
-
 /**
  * Turn an mdast `paragraph` node into hast.
  *
@@ -13042,7 +13017,7 @@ function list$2(state, node) {
  * @returns {Element}
  *   hast node.
  */
-function paragraph$2(state, node) {
+function paragraph$1(state, node) {
   /** @type {Element} */
   const result = {
     type: 'element',
@@ -13055,13 +13030,11 @@ function paragraph$2(state, node) {
 }
 
 /**
- * @typedef {import('hast').Parents} HastParents
- * @typedef {import('hast').Root} HastRoot
- * @typedef {import('mdast').Root} MdastRoot
- * @typedef {import('../state.js').State} State
+ * @import {Parents as HastParents, Root as HastRoot} from 'hast'
+ * @import {Root as MdastRoot} from 'mdast'
+ * @import {State} from '../state.js'
  */
 
-
 /**
  * Turn an mdast `root` node into hast.
  *
@@ -13072,7 +13045,7 @@ function paragraph$2(state, node) {
  * @returns {HastParents}
  *   hast node.
  */
-function root$4(state, node) {
+function root$3(state, node) {
   /** @type {HastRoot} */
   const result = {type: 'root', children: state.wrap(state.all(node))};
   state.patch(node, result);
@@ -13080,12 +13053,11 @@ function root$4(state, node) {
 }
 
 /**
- * @typedef {import('hast').Element} Element
- * @typedef {import('mdast').Strong} Strong
- * @typedef {import('../state.js').State} State
+ * @import {Element} from 'hast'
+ * @import {Strong} from 'mdast'
+ * @import {State} from '../state.js'
  */
 
-
 /**
  * Turn an mdast `strong` node into hast.
  *
@@ -13096,7 +13068,7 @@ function root$4(state, node) {
  * @returns {Element}
  *   hast node.
  */
-function strong$2(state, node) {
+function strong$1(state, node) {
   /** @type {Element} */
   const result = {
     type: 'element',
@@ -13205,9 +13177,9 @@ function position$1(node) {
 }
 
 /**
- * @typedef {import('hast').Element} Element
- * @typedef {import('mdast').Table} Table
- * @typedef {import('../state.js').State} State
+ * @import {Table} from 'mdast'
+ * @import {Element} from 'hast'
+ * @import {State} from '../state.js'
  */
 
 
@@ -13266,15 +13238,11 @@ function table(state, node) {
 }
 
 /**
- * @typedef {import('hast').Element} Element
- * @typedef {import('hast').ElementContent} ElementContent
- * @typedef {import('hast').Properties} Properties
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('mdast').TableRow} TableRow
- * @typedef {import('../state.js').State} State
+ * @import {Element, ElementContent, Properties} from 'hast'
+ * @import {Parents, TableRow} from 'mdast'
+ * @import {State} from '../state.js'
  */
 
-
 /**
  * Turn an mdast `tableRow` node into hast.
  *
@@ -13334,12 +13302,11 @@ function tableRow(state, node, parent) {
 }
 
 /**
- * @typedef {import('hast').Element} Element
- * @typedef {import('mdast').TableCell} TableCell
- * @typedef {import('../state.js').State} State
+ * @import {Element} from 'hast'
+ * @import {TableCell} from 'mdast'
+ * @import {State} from '../state.js'
  */
 
-
 /**
  * Turn an mdast `tableCell` node into hast.
  *
@@ -13435,10 +13402,9 @@ function trimLine(value, start, end) {
 }
 
 /**
- * @typedef {import('hast').Element} HastElement
- * @typedef {import('hast').Text} HastText
- * @typedef {import('mdast').Text} MdastText
- * @typedef {import('../state.js').State} State
+ * @import {Element as HastElement, Text as HastText} from 'hast'
+ * @import {Text as MdastText} from 'mdast'
+ * @import {State} from '../state.js'
  */
 
 
@@ -13452,7 +13418,7 @@ function trimLine(value, start, end) {
  * @returns {HastElement | HastText}
  *   hast node.
  */
-function text$5(state, node) {
+function text$4(state, node) {
   /** @type {HastText} */
   const result = {type: 'text', value: trimLines(String(node.value))};
   state.patch(node, result);
@@ -13460,12 +13426,11 @@ function text$5(state, node) {
 }
 
 /**
- * @typedef {import('hast').Element} Element
- * @typedef {import('mdast').ThematicBreak} ThematicBreak
- * @typedef {import('../state.js').State} State
+ * @import {Element} from 'hast'
+ * @import {ThematicBreak} from 'mdast'
+ * @import {State} from '../state.js'
  */
 
-
 /**
  * Turn an mdast `thematicBreak` node into hast.
  *
@@ -13476,7 +13441,7 @@ function text$5(state, node) {
  * @returns {Element}
  *   hast node.
  */
-function thematicBreak$2(state, node) {
+function thematicBreak$1(state, node) {
   /** @type {Element} */
   const result = {
     type: 'element',
@@ -13488,36 +13453,41 @@ function thematicBreak$2(state, node) {
   return state.applyData(node, result)
 }
 
+/**
+ * @import {Handlers} from '../state.js'
+ */
+
+
 /**
  * Default handlers for nodes.
  *
- * @satisfies {import('../state.js').Handlers}
+ * @satisfies {Handlers}
  */
 const handlers = {
-  blockquote: blockquote$2,
-  break: hardBreak$2,
-  code: code$3,
+  blockquote: blockquote$1,
+  break: hardBreak$1,
+  code: code$2,
   delete: strikethrough,
-  emphasis: emphasis$2,
+  emphasis: emphasis$1,
   footnoteReference: footnoteReference$1,
-  heading: heading$2,
-  html: html$6,
-  imageReference: imageReference$2,
-  image: image$2,
-  inlineCode: inlineCode$2,
-  linkReference: linkReference$2,
-  link: link$2,
-  listItem: listItem$2,
-  list: list$2,
-  paragraph: paragraph$2,
+  heading: heading$1,
+  html: html$5,
+  imageReference: imageReference$1,
+  image: image$1,
+  inlineCode: inlineCode$1,
+  linkReference: linkReference$1,
+  link: link$1,
+  listItem: listItem$1,
+  list: list$1,
+  paragraph: paragraph$1,
   // @ts-expect-error: root is different, but hard to type.
-  root: root$4,
-  strong: strong$2,
+  root: root$3,
+  strong: strong$1,
   table,
   tableCell,
   tableRow,
-  text: text$5,
-  thematicBreak: thematicBreak$2,
+  text: text$4,
+  thematicBreak: thematicBreak$1,
   toml: ignore,
   yaml: ignore,
   definition: ignore,
@@ -13530,10 +13500,8 @@ function ignore() {
 }
 
 /**
- * @typedef {import('hast').Element} Element
- * @typedef {import('hast').ElementContent} ElementContent
- *
- * @typedef {import('./state.js').State} State
+ * @import {ElementContent, Element} from 'hast'
+ * @import {State} from './state.js'
  */
 
 
@@ -13611,14 +13579,16 @@ function footer(state) {
   let referenceIndex = -1;
 
   while (++referenceIndex < state.footnoteOrder.length) {
-    const def = state.footnoteById.get(state.footnoteOrder[referenceIndex]);
+    const definition = state.footnoteById.get(
+      state.footnoteOrder[referenceIndex]
+    );
 
-    if (!def) {
+    if (!definition) {
       continue
     }
 
-    const content = state.all(def);
-    const id = String(def.identifier).toUpperCase();
+    const content = state.all(definition);
+    const id = String(definition.identifier).toUpperCase();
     const safeId = normalizeUri(id.toLowerCase());
     let rereferenceIndex = 0;
     /** @type {Array<ElementContent>} */
@@ -13684,7 +13654,7 @@ function footer(state) {
       children: state.wrap(content, true)
     };
 
-    state.patch(def, listItem);
+    state.patch(definition, listItem);
 
     listItems.push(listItem);
   }
@@ -13720,27 +13690,32 @@ function footer(state) {
 }
 
 /**
- * @typedef {import('hast').Element} HastElement
- * @typedef {import('hast').ElementContent} HastElementContent
- * @typedef {import('hast').Nodes} HastNodes
- * @typedef {import('hast').Properties} HastProperties
- * @typedef {import('hast').RootContent} HastRootContent
- * @typedef {import('hast').Text} HastText
- *
- * @typedef {import('mdast').Definition} MdastDefinition
- * @typedef {import('mdast').FootnoteDefinition} MdastFootnoteDefinition
- * @typedef {import('mdast').Nodes} MdastNodes
- * @typedef {import('mdast').Parents} MdastParents
- *
- * @typedef {import('./footer.js').FootnoteBackContentTemplate} FootnoteBackContentTemplate
- * @typedef {import('./footer.js').FootnoteBackLabelTemplate} FootnoteBackLabelTemplate
+ * @import {
+ *   ElementContent as HastElementContent,
+ *   Element as HastElement,
+ *   Nodes as HastNodes,
+ *   Properties as HastProperties,
+ *   RootContent as HastRootContent,
+ *   Text as HastText
+ * } from 'hast'
+ * @import {
+ *   Definition as MdastDefinition,
+ *   FootnoteDefinition as MdastFootnoteDefinition,
+ *   Nodes as MdastNodes,
+ *   Parents as MdastParents
+ * } from 'mdast'
+ * @import {VFile} from 'vfile'
+ * @import {
+ *   FootnoteBackContentTemplate,
+ *   FootnoteBackLabelTemplate
+ * } from './footer.js'
  */
 
 
-const own$7 = {}.hasOwnProperty;
+const own$5 = {}.hasOwnProperty;
 
 /** @type {Options} */
-const emptyOptions$4 = {};
+const emptyOptions$2 = {};
 
 /**
  * Create `state` from an mdast tree.
@@ -13753,7 +13728,7 @@ const emptyOptions$4 = {};
  *   `state` function.
  */
 function createState(tree, options) {
-  const settings = options || emptyOptions$4;
+  const settings = options || emptyOptions$2;
   /** @type {Map<string, MdastDefinition>} */
   const definitionById = new Map();
   /** @type {Map<string, MdastFootnoteDefinition>} */
@@ -13810,7 +13785,7 @@ function createState(tree, options) {
     const type = node.type;
     const handle = state.handlers[type];
 
-    if (own$7.call(state.handlers, type) && handle) {
+    if (own$5.call(state.handlers, type) && handle) {
       return handle(state, node, parent)
     }
 
@@ -13966,7 +13941,7 @@ function defaultUnknownHandler(state, node) {
   /** @type {HastElement | HastText} */
   const result =
     'value' in node &&
-    !(own$7.call(data, 'hProperties') || own$7.call(data, 'hChildren'))
+    !(own$5.call(data, 'hProperties') || own$5.call(data, 'hChildren'))
       ? {type: 'text', value: node.value}
       : {
           type: 'element',
@@ -14033,9 +14008,9 @@ function trimMarkdownSpaceStart(value) {
 }
 
 /**
- * @typedef {import('hast').Nodes} HastNodes
- * @typedef {import('mdast').Nodes} MdastNodes
- * @typedef {import('./state.js').Options} Options
+ * @import {Nodes as HastNodes} from 'hast'
+ * @import {Nodes as MdastNodes} from 'mdast'
+ * @import {Options} from './state.js'
  */
 
 
@@ -14132,8 +14107,13 @@ function toHast(tree, options) {
   return result
 }
 
-// Include `data` fields in mdast and `raw` nodes in hast.
-/// <reference types="mdast-util-to-hast" />
+/**
+ * @import {Root as HastRoot} from 'hast'
+ * @import {Root as MdastRoot} from 'mdast'
+ * @import {Options as ToHastOptions} from 'mdast-util-to-hast'
+ * @import {Processor} from 'unified'
+ * @import {VFile} from 'vfile'
+ */
 
 
 /**
@@ -14143,12 +14123,15 @@ function toHast(tree, options) {
  *
  * ###### Signature
  *
- * *   if a processor is given, runs the (rehype) plugins used on it with a
- *     hast tree, then discards the result (*bridge mode*)
- * *   otherwise, returns a hast tree, the plugins used after `remarkRehype`
- *     are rehype plugins (*mutate mode*)
+ * * if a processor is given,
+ *   runs the (rehype) plugins used on it with a hast tree,
+ *   then discards the result (*bridge mode*)
+ * * otherwise,
+ *   returns a hast tree,
+ *   the plugins used after `remarkRehype` are rehype plugins (*mutate mode*)
  *
- * > 👉 **Note**: It’s highly unlikely that you want to pass a `processor`.
+ * > 👉 **Note**:
+ * > It’s highly unlikely that you want to pass a `processor`.
  *
  * ###### HTML
  *
@@ -14156,36 +14139,40 @@ function toHast(tree, options) {
  * as semistandard `raw` nodes.
  * Most plugins ignore `raw` nodes but two notable ones don’t:
  *
- * *   `rehype-stringify` also has an option `allowDangerousHtml` which will
- *     output the raw HTML.
- *     This is typically discouraged as noted by the option name but is useful if
- *     you completely trust authors
- * *   `rehype-raw` can handle the raw embedded HTML strings by parsing them
- *     into standard hast nodes (`element`, `text`, etc).
- *     This is a heavy task as it needs a full HTML parser, but it is the only way
- *     to support untrusted content
+ * * `rehype-stringify` also has an option `allowDangerousHtml` which will
+ *   output the raw HTML.
+ *   This is typically discouraged as noted by the option name but is useful if
+ *   you completely trust authors
+ * * `rehype-raw` can handle the raw embedded HTML strings by parsing them
+ *   into standard hast nodes (`element`, `text`, etc);
+ *   this is a heavy task as it needs a full HTML parser,
+ *   but it is the only way to support untrusted content
  *
  * ###### Footnotes
  *
  * Many options supported here relate to footnotes.
- * Footnotes are not specified by CommonMark, which we follow by default.
- * They are supported by GitHub, so footnotes can be enabled in markdown with
- * `remark-gfm`.
+ * Footnotes are not specified by CommonMark,
+ * which we follow by default.
+ * They are supported by GitHub,
+ * so footnotes can be enabled in markdown with `remark-gfm`.
  *
  * The options `footnoteBackLabel` and `footnoteLabel` define natural language
- * that explains footnotes, which is hidden for sighted users but shown to
- * assistive technology.
- * When your page is not in English, you must define translated values.
+ * that explains footnotes,
+ * which is hidden for sighted users but shown to assistive technology.
+ * When your page is not in English,
+ * you must define translated values.
  *
- * Back references use ARIA attributes, but the section label itself uses a
- * heading that is hidden with an `sr-only` class.
- * To show it to sighted users, define different attributes in
- * `footnoteLabelProperties`.
+ * Back references use ARIA attributes,
+ * but the section label itself uses a heading that is hidden with an
+ * `sr-only` class.
+ * To show it to sighted users,
+ * define different attributes in `footnoteLabelProperties`.
  *
  * ###### Clobbering
  *
- * Footnotes introduces a problem, as it links footnote calls to footnote
- * definitions on the page through `id` attributes generated from user content,
+ * Footnotes introduces a problem,
+ * as it links footnote calls to footnote definitions on the page through `id`
+ * attributes generated from user content,
  * which results in DOM clobbering.
  *
  * DOM clobbering is this:
@@ -14207,11 +14194,13 @@ function toHast(tree, options) {
  * Unknown nodes are nodes with a type that isn’t in `handlers` or `passThrough`.
  * The default behavior for unknown nodes is:
  *
- * *   when the node has a `value` (and doesn’t have `data.hName`,
- *     `data.hProperties`, or `data.hChildren`, see later), create a hast `text`
- *     node
- * *   otherwise, create a `<div>` element (which could be changed with
- *     `data.hName`), with its children mapped from mdast to hast as well
+ * * when the node has a `value`
+ *   (and doesn’t have `data.hName`, `data.hProperties`, or `data.hChildren`,
+ *   see later),
+ *   create a hast `text` node
+ * * otherwise,
+ *   create a `<div>` element (which could be changed with `data.hName`),
+ *   with its children mapped from mdast to hast as well
  *
  * This behavior can be changed by passing an `unknownHandler`.
  *
@@ -14224,10 +14213,16 @@ function toHast(tree, options) {
  * @param {Readonly<Options> | null | undefined} [options]
  * @returns {TransformMutate}
  *
+ * @overload
+ * @param {Readonly<Options> | Processor | null | undefined} [destination]
+ * @param {Readonly<Options> | null | undefined} [options]
+ * @returns {TransformBridge | TransformMutate}
+ *
  * @param {Readonly<Options> | Processor | null | undefined} [destination]
  *   Processor or configuration (optional).
  * @param {Readonly<Options> | null | undefined} [options]
- *   When a processor was given, configuration (optional).
+ *   When a processor was given,
+ *   configuration (optional).
  * @returns {TransformBridge | TransformMutate}
  *   Transform.
  */
@@ -14260,34 +14255,6 @@ function remarkRehype(destination, options) {
   }
 }
 
-/**
- * Count how often a character (or substring) is used in a string.
- *
- * @param {string} value
- *   Value to search in.
- * @param {string} character
- *   Character (or substring) to look for.
- * @return {number}
- *   Number of times `character` occurred in `value`.
- */
-function ccount(value, character) {
-  const source = String(value);
-
-  if (typeof character !== 'string') {
-    throw new TypeError('Expected character')
-  }
-
-  let count = 0;
-  let index = source.indexOf(character);
-
-  while (index !== -1) {
-    count++;
-    index = source.indexOf(character, index + character.length);
-  }
-
-  return count
-}
-
 function escapeStringRegexp(string) {
 	if (typeof string !== 'string') {
 		throw new TypeError('Expected a string');
@@ -14975,7 +14942,7 @@ function footnoteDefinition(node, _, state, info) {
   );
   tracker.shift(4);
   value += tracker.move(
-    state.indentLines(state.containerFlow(node, tracker.current()), map$4)
+    state.indentLines(state.containerFlow(node, tracker.current()), map$2)
   );
   exit();
 
@@ -14983,7 +14950,7 @@ function footnoteDefinition(node, _, state, info) {
 }
 
 /** @type {Map} */
-function map$4(line, index, blank) {
+function map$2(line, index, blank) {
   if (index === 0) {
     return line
   }
@@ -15480,11 +15447,8 @@ function toAlignment(value) {
 }
 
 /**
- * @typedef {import('mdast').Blockquote} Blockquote
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').Map} Map
- * @typedef {import('../types.js').State} State
+ * @import {Blockquote, Parents} from 'mdast'
+ * @import {Info, Map, State} from 'mdast-util-to-markdown'
  */
 
 /**
@@ -15494,27 +15458,26 @@ function toAlignment(value) {
  * @param {Info} info
  * @returns {string}
  */
-function blockquote$1(node, _, state, info) {
+function blockquote(node, _, state, info) {
   const exit = state.enter('blockquote');
   const tracker = state.createTracker(info);
   tracker.move('> ');
   tracker.shift(2);
   const value = state.indentLines(
     state.containerFlow(node, tracker.current()),
-    map$3
+    map$1
   );
   exit();
   return value
 }
 
 /** @type {Map} */
-function map$3(line, _, blank) {
+function map$1(line, _, blank) {
   return '>' + (blank ? '' : ' ') + line
 }
 
 /**
- * @typedef {import('../types.js').ConstructName} ConstructName
- * @typedef {import('../types.js').Unsafe} Unsafe
+ * @import {ConstructName, Unsafe} from 'mdast-util-to-markdown'
  */
 
 /**
@@ -15522,10 +15485,10 @@ function map$3(line, _, blank) {
  * @param {Unsafe} pattern
  * @returns {boolean}
  */
-function patternInScope$1(stack, pattern) {
+function patternInScope(stack, pattern) {
   return (
-    listInScope$1(stack, pattern.inConstruct, true) &&
-    !listInScope$1(stack, pattern.notInConstruct, false)
+    listInScope(stack, pattern.inConstruct, true) &&
+    !listInScope(stack, pattern.notInConstruct, false)
   )
 }
 
@@ -15535,7 +15498,7 @@ function patternInScope$1(stack, pattern) {
  * @param {boolean} none
  * @returns {boolean}
  */
-function listInScope$1(stack, list, none) {
+function listInScope(stack, list, none) {
   if (typeof list === 'string') {
     list = [list];
   }
@@ -15556,10 +15519,8 @@ function listInScope$1(stack, list, none) {
 }
 
 /**
- * @typedef {import('mdast').Break} Break
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').State} State
+ * @import {Break, Parents} from 'mdast'
+ * @import {Info, State} from 'mdast-util-to-markdown'
  */
 
 
@@ -15570,7 +15531,7 @@ function listInScope$1(stack, list, none) {
  * @param {Info} info
  * @returns {string}
  */
-function hardBreak$1(_, _1, state, info) {
+function hardBreak(_, _1, state, info) {
   let index = -1;
 
   while (++index < state.unsafe.length) {
@@ -15578,7 +15539,7 @@ function hardBreak$1(_, _1, state, info) {
     // space instead.
     if (
       state.unsafe[index].character === '\n' &&
-      patternInScope$1(state.stack, state.unsafe[index])
+      patternInScope(state.stack, state.unsafe[index])
     ) {
       return /[ \t]/.test(info.before) ? '' : ' '
     }
@@ -15625,8 +15586,8 @@ function longestStreak(value, substring) {
 }
 
 /**
- * @typedef {import('mdast').Code} Code
- * @typedef {import('../types.js').State} State
+ * @import {State} from 'mdast-util-to-markdown'
+ * @import {Code} from 'mdast'
  */
 
 /**
@@ -15634,7 +15595,7 @@ function longestStreak(value, substring) {
  * @param {State} state
  * @returns {boolean}
  */
-function formatCodeAsIndented$1(node, state) {
+function formatCodeAsIndented(node, state) {
   return Boolean(
     state.options.fences === false &&
       node.value &&
@@ -15648,15 +15609,14 @@ function formatCodeAsIndented$1(node, state) {
 }
 
 /**
- * @typedef {import('../types.js').Options} Options
- * @typedef {import('../types.js').State} State
+ * @import {Options, State} from 'mdast-util-to-markdown'
  */
 
 /**
  * @param {State} state
  * @returns {Exclude<Options['fence'], null | undefined>}
  */
-function checkFence$1(state) {
+function checkFence(state) {
   const marker = state.options.fence || '`';
 
   if (marker !== '`' && marker !== '~') {
@@ -15671,11 +15631,8 @@ function checkFence$1(state) {
 }
 
 /**
- * @typedef {import('mdast').Code} Code
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').Map} Map
- * @typedef {import('../types.js').State} State
+ * @import {Info, Map, State} from 'mdast-util-to-markdown'
+ * @import {Code, Parents} from 'mdast'
  */
 
 
@@ -15686,14 +15643,14 @@ function checkFence$1(state) {
  * @param {Info} info
  * @returns {string}
  */
-function code$2(node, _, state, info) {
-  const marker = checkFence$1(state);
+function code$1(node, _, state, info) {
+  const marker = checkFence(state);
   const raw = node.value || '';
   const suffix = marker === '`' ? 'GraveAccent' : 'Tilde';
 
-  if (formatCodeAsIndented$1(node, state)) {
+  if (formatCodeAsIndented(node, state)) {
     const exit = state.enter('codeIndented');
-    const value = state.indentLines(raw, map$2);
+    const value = state.indentLines(raw, map);
     exit();
     return value
   }
@@ -15742,20 +15699,19 @@ function code$2(node, _, state, info) {
 }
 
 /** @type {Map} */
-function map$2(line, _, blank) {
+function map(line, _, blank) {
   return (blank ? '' : '    ') + line
 }
 
 /**
- * @typedef {import('../types.js').Options} Options
- * @typedef {import('../types.js').State} State
+ * @import {Options, State} from 'mdast-util-to-markdown'
  */
 
 /**
  * @param {State} state
  * @returns {Exclude<Options['quote'], null | undefined>}
  */
-function checkQuote$1(state) {
+function checkQuote(state) {
   const marker = state.options.quote || '"';
 
   if (marker !== '"' && marker !== "'") {
@@ -15770,10 +15726,8 @@ function checkQuote$1(state) {
 }
 
 /**
- * @typedef {import('mdast').Definition} Definition
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').State} State
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {Definition, Parents} from 'mdast'
  */
 
 
@@ -15784,8 +15738,8 @@ function checkQuote$1(state) {
  * @param {Info} info
  * @returns {string}
  */
-function definition$1(node, _, state, info) {
-  const quote = checkQuote$1(state);
+function definition(node, _, state, info) {
+  const quote = checkQuote(state);
   const suffix = quote === '"' ? 'Quote' : 'Apostrophe';
   const exit = state.enter('definition');
   let subexit = state.enter('label');
@@ -15848,15 +15802,14 @@ function definition$1(node, _, state, info) {
 }
 
 /**
- * @typedef {import('../types.js').Options} Options
- * @typedef {import('../types.js').State} State
+ * @import {Options, State} from 'mdast-util-to-markdown'
  */
 
 /**
  * @param {State} state
  * @returns {Exclude<Options['emphasis'], null | undefined>}
  */
-function checkEmphasis$1(state) {
+function checkEmphasis(state) {
   const marker = state.options.emphasis || '*';
 
   if (marker !== '*' && marker !== '_') {
@@ -15871,165 +15824,169 @@ function checkEmphasis$1(state) {
 }
 
 /**
- * @typedef {import('mdast').Emphasis} Emphasis
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').State} State
- */
-
-
-emphasis$1.peek = emphasisPeek$1;
-
-// To do: there are cases where emphasis cannot “form” depending on the
-// previous or next character of sequences.
-// There’s no way around that though, except for injecting zero-width stuff.
-// Do we need to safeguard against that?
-/**
- * @param {Emphasis} node
- * @param {Parents | undefined} _
- * @param {State} state
- * @param {Info} info
- * @returns {string}
- */
-function emphasis$1(node, _, state, info) {
-  const marker = checkEmphasis$1(state);
-  const exit = state.enter('emphasis');
-  const tracker = state.createTracker(info);
-  let value = tracker.move(marker);
-  value += tracker.move(
-    state.containerPhrasing(node, {
-      before: value,
-      after: marker,
-      ...tracker.current()
-    })
-  );
-  value += tracker.move(marker);
-  exit();
-  return value
-}
-
-/**
- * @param {Emphasis} _
- * @param {Parents | undefined} _1
- * @param {State} state
+ * Encode a code point as a character reference.
+ *
+ * @param {number} code
+ *   Code point to encode.
  * @returns {string}
+ *   Encoded character reference.
  */
-function emphasisPeek$1(_, _1, state) {
-  return state.options.emphasis || '*'
+function encodeCharacterReference(code) {
+  return '&#x' + code.toString(16).toUpperCase() + ';'
 }
 
 /**
- * @typedef {import('mdast').Nodes} Nodes
- *
- * @typedef Options
- *   Configuration (optional).
- * @property {boolean | null | undefined} [includeImageAlt=true]
- *   Whether to use `alt` for `image`s (default: `true`).
- * @property {boolean | null | undefined} [includeHtml=true]
- *   Whether to use `value` of HTML (default: `true`).
+ * @import {EncodeSides} from '../types.js'
  */
 
-/** @type {Options} */
-const emptyOptions$3 = {};
 
 /**
- * Get the text content of a node or list of nodes.
+ * Check whether to encode (as a character reference) the characters
+ * surrounding an attention run.
  *
- * Prefers the node’s plain-text fields, otherwise serializes its children,
- * and if the given value is an array, serialize the nodes in it.
+ * Which characters are around an attention run influence whether it works or
+ * not.
  *
- * @param {unknown} [value]
- *   Thing to serialize, typically `Node`.
- * @param {Options | null | undefined} [options]
- *   Configuration (optional).
- * @returns {string}
- *   Serialized `value`.
+ * 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*               | *.*                    | * *                   | **                 |
+ * ```
+ *
+ * @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'
  */
-function toString$1(value, options) {
-  const settings = emptyOptions$3;
-  const includeImageAlt =
-    typeof settings.includeImageAlt === 'boolean'
-      ? settings.includeImageAlt
-      : true;
-  const includeHtml =
-    typeof settings.includeHtml === 'boolean' ? settings.includeHtml : true;
 
-  return one$3(value, includeImageAlt, includeHtml)
-}
+
+emphasis.peek = emphasisPeek;
 
 /**
- * One node or several nodes.
- *
- * @param {unknown} value
- *   Thing to serialize.
- * @param {boolean} includeImageAlt
- *   Include image `alt`s.
- * @param {boolean} includeHtml
- *   Include HTML.
+ * @param {Emphasis} node
+ * @param {Parents | undefined} _
+ * @param {State} state
+ * @param {Info} info
  * @returns {string}
- *   Serialized node.
  */
-function one$3(value, includeImageAlt, includeHtml) {
-  if (node$1(value)) {
-    if ('value' in value) {
-      return value.type === 'html' && !includeHtml ? '' : value.value
-    }
+function emphasis(node, _, state, info) {
+  const marker = checkEmphasis(state);
+  const exit = state.enter('emphasis');
+  const tracker = state.createTracker(info);
+  const before = tracker.move(marker);
 
-    if (includeImageAlt && 'alt' in value && value.alt) {
-      return value.alt
-    }
+  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 ('children' in value) {
-      return all$4(value.children, includeImageAlt, includeHtml)
-    }
+  if (open.inside) {
+    between = encodeCharacterReference(betweenHead) + between.slice(1);
   }
 
-  if (Array.isArray(value)) {
-    return all$4(value, includeImageAlt, includeHtml)
+  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);
   }
 
-  return ''
-}
+  const after = tracker.move(marker);
 
-/**
- * Serialize a list of nodes.
- *
- * @param {Array<unknown>} values
- *   Thing to serialize.
- * @param {boolean} includeImageAlt
- *   Include image `alt`s.
- * @param {boolean} includeHtml
- *   Include HTML.
- * @returns {string}
- *   Serialized nodes.
- */
-function all$4(values, includeImageAlt, includeHtml) {
-  /** @type {Array<string>} */
-  const result = [];
-  let index = -1;
-
-  while (++index < values.length) {
-    result[index] = one$3(values[index], includeImageAlt, includeHtml);
-  }
+  exit();
 
-  return result.join('')
+  state.attentionEncodeSurroundingInfo = {
+    after: close.outside,
+    before: open.outside
+  };
+  return before + between + after
 }
 
 /**
- * Check if `value` looks like a node.
- *
- * @param {unknown} value
- *   Thing.
- * @returns {value is Nodes}
- *   Whether `value` is a node.
+ * @param {Emphasis} _
+ * @param {Parents | undefined} _1
+ * @param {State} state
+ * @returns {string}
  */
-function node$1(value) {
-  return Boolean(value && typeof value === 'object')
+function emphasisPeek(_, _1, state) {
+  return state.options.emphasis || '*'
 }
 
 /**
- * @typedef {import('mdast').Heading} Heading
- * @typedef {import('../types.js').State} State
+ * @import {State} from 'mdast-util-to-markdown'
+ * @import {Heading} from 'mdast'
  */
 
 
@@ -16038,7 +15995,7 @@ function node$1(value) {
  * @param {State} state
  * @returns {boolean}
  */
-function formatHeadingAsSetext$1(node, state) {
+function formatHeadingAsSetext(node, state) {
   let literalWithBreak = false;
 
   // Look for literals with a line break.
@@ -16055,16 +16012,14 @@ function formatHeadingAsSetext$1(node, state) {
 
   return Boolean(
     (!node.depth || node.depth < 3) &&
-      toString$1(node) &&
+      toString(node) &&
       (state.options.setext || literalWithBreak)
   )
 }
 
 /**
- * @typedef {import('mdast').Heading} Heading
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').State} State
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {Heading, Parents} from 'mdast'
  */
 
 
@@ -16075,11 +16030,11 @@ function formatHeadingAsSetext$1(node, state) {
  * @param {Info} info
  * @returns {string}
  */
-function heading$1(node, _, state, info) {
+function heading(node, _, state, info) {
   const rank = Math.max(Math.min(6, node.depth || 1), 1);
   const tracker = state.createTracker(info);
 
-  if (formatHeadingAsSetext$1(node, state)) {
+  if (formatHeadingAsSetext(node, state)) {
     const exit = state.enter('headingSetext');
     const subexit = state.enter('phrasing');
     const value = state.containerPhrasing(node, {
@@ -16121,1917 +16076,7 @@ function heading$1(node, _, state, info) {
 
   if (/^[\t ]/.test(value)) {
     // To do: what effect has the character reference on tracking?
-    value =
-      '&#x' +
-      value.charCodeAt(0).toString(16).toUpperCase() +
-      ';' +
-      value.slice(1);
-  }
-
-  value = value ? sequence + ' ' + value : sequence;
-
-  if (state.options.closeAtx) {
-    value += ' ' + sequence;
-  }
-
-  subexit();
-  exit();
-
-  return value
-}
-
-/**
- * @typedef {import('mdast').Html} Html
- */
-
-html$5.peek = htmlPeek$1;
-
-/**
- * @param {Html} node
- * @returns {string}
- */
-function html$5(node) {
-  return node.value || ''
-}
-
-/**
- * @returns {string}
- */
-function htmlPeek$1() {
-  return '<'
-}
-
-/**
- * @typedef {import('mdast').Image} Image
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').State} State
- */
-
-
-image$1.peek = imagePeek$1;
-
-/**
- * @param {Image} node
- * @param {Parents | undefined} _
- * @param {State} state
- * @param {Info} info
- * @returns {string}
- */
-function image$1(node, _, state, info) {
-  const quote = checkQuote$1(state);
-  const suffix = quote === '"' ? 'Quote' : 'Apostrophe';
-  const exit = state.enter('image');
-  let subexit = state.enter('label');
-  const tracker = state.createTracker(info);
-  let value = tracker.move('![');
-  value += tracker.move(
-    state.safe(node.alt, {before: value, after: ']', ...tracker.current()})
-  );
-  value += tracker.move('](');
-
-  subexit();
-
-  if (
-    // If there’s no url but there is a title…
-    (!node.url && node.title) ||
-    // If there are control characters or whitespace.
-    /[\0- \u007F]/.test(node.url)
-  ) {
-    subexit = state.enter('destinationLiteral');
-    value += tracker.move('<');
-    value += tracker.move(
-      state.safe(node.url, {before: value, after: '>', ...tracker.current()})
-    );
-    value += tracker.move('>');
-  } else {
-    // No whitespace, raw is prettier.
-    subexit = state.enter('destinationRaw');
-    value += tracker.move(
-      state.safe(node.url, {
-        before: value,
-        after: node.title ? ' ' : ')',
-        ...tracker.current()
-      })
-    );
-  }
-
-  subexit();
-
-  if (node.title) {
-    subexit = state.enter(`title${suffix}`);
-    value += tracker.move(' ' + quote);
-    value += tracker.move(
-      state.safe(node.title, {
-        before: value,
-        after: quote,
-        ...tracker.current()
-      })
-    );
-    value += tracker.move(quote);
-    subexit();
-  }
-
-  value += tracker.move(')');
-  exit();
-
-  return value
-}
-
-/**
- * @returns {string}
- */
-function imagePeek$1() {
-  return '!'
-}
-
-/**
- * @typedef {import('mdast').ImageReference} ImageReference
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').State} State
- */
-
-imageReference$1.peek = imageReferencePeek$1;
-
-/**
- * @param {ImageReference} node
- * @param {Parents | undefined} _
- * @param {State} state
- * @param {Info} info
- * @returns {string}
- */
-function imageReference$1(node, _, state, info) {
-  const type = node.referenceType;
-  const exit = state.enter('imageReference');
-  let subexit = state.enter('label');
-  const tracker = state.createTracker(info);
-  let value = tracker.move('![');
-  const alt = state.safe(node.alt, {
-    before: value,
-    after: ']',
-    ...tracker.current()
-  });
-  value += tracker.move(alt + '][');
-
-  subexit();
-  // Hide the fact that we’re in phrasing, because escapes don’t work.
-  const stack = state.stack;
-  state.stack = [];
-  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.
-  // Practically, in that case, there is no content, so it doesn’t matter that
-  // we’ve tracked one too many characters.
-  const reference = state.safe(state.associationId(node), {
-    before: value,
-    after: ']',
-    ...tracker.current()
-  });
-  subexit();
-  state.stack = stack;
-  exit();
-
-  if (type === 'full' || !alt || alt !== reference) {
-    value += tracker.move(reference + ']');
-  } else if (type === 'shortcut') {
-    // Remove the unwanted `[`.
-    value = value.slice(0, -1);
-  } else {
-    value += tracker.move(']');
-  }
-
-  return value
-}
-
-/**
- * @returns {string}
- */
-function imageReferencePeek$1() {
-  return '!'
-}
-
-/**
- * @typedef {import('mdast').InlineCode} InlineCode
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../types.js').State} State
- */
-
-inlineCode$1.peek = inlineCodePeek$1;
-
-/**
- * @param {InlineCode} node
- * @param {Parents | undefined} _
- * @param {State} state
- * @returns {string}
- */
-function inlineCode$1(node, _, state) {
-  let value = node.value || '';
-  let sequence = '`';
-  let index = -1;
-
-  // If there is a single grave accent on its own in the code, use a fence of
-  // two.
-  // If there are two in a row, use one.
-  while (new RegExp('(^|[^`])' + sequence + '([^`]|$)').test(value)) {
-    sequence += '`';
-  }
-
-  // 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))
-  ) {
-    value = ' ' + value + ' ';
-  }
-
-  // We have a potential problem: certain characters after eols could result in
-  // blocks being seen.
-  // For example, if someone injected the string `'\n# b'`, then that would
-  // result in an ATX heading.
-  // We can’t escape characters in `inlineCode`, but because eols are
-  // transformed to spaces when going from markdown to HTML anyway, we can swap
-  // them out.
-  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
-
-    while ((match = expression.exec(value))) {
-      let position = match.index;
-
-      // Support CRLF (patterns only look for one of the characters).
-      if (
-        value.charCodeAt(position) === 10 /* `\n` */ &&
-        value.charCodeAt(position - 1) === 13 /* `\r` */
-      ) {
-        position--;
-      }
-
-      value = value.slice(0, position) + ' ' + value.slice(match.index + 1);
-    }
-  }
-
-  return sequence + value + sequence
-}
-
-/**
- * @returns {string}
- */
-function inlineCodePeek$1() {
-  return '`'
-}
-
-/**
- * @typedef {import('mdast').Link} Link
- * @typedef {import('../types.js').State} State
- */
-
-
-/**
- * @param {Link} node
- * @param {State} state
- * @returns {boolean}
- */
-function formatLinkAsAutolink$1(node, state) {
-  const raw = toString$1(node);
-
-  return Boolean(
-    !state.options.resourceLink &&
-      // If there’s a url…
-      node.url &&
-      // And there’s a no title…
-      !node.title &&
-      // And the content of `node` is a single text node…
-      node.children &&
-      node.children.length === 1 &&
-      node.children[0].type === 'text' &&
-      // And if the url is the same as the content…
-      (raw === node.url || 'mailto:' + raw === node.url) &&
-      // And that starts w/ a protocol…
-      /^[a-z][a-z+.-]+:/i.test(node.url) &&
-      // And that doesn’t contain ASCII control codes (character escapes and
-      // references don’t work), space, or angle brackets…
-      !/[\0- <>\u007F]/.test(node.url)
-  )
-}
-
-/**
- * @typedef {import('mdast').Link} Link
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../types.js').Exit} Exit
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').State} State
- */
-
-
-link$1.peek = linkPeek$1;
-
-/**
- * @param {Link} node
- * @param {Parents | undefined} _
- * @param {State} state
- * @param {Info} info
- * @returns {string}
- */
-function link$1(node, _, state, info) {
-  const quote = checkQuote$1(state);
-  const suffix = quote === '"' ? 'Quote' : 'Apostrophe';
-  const tracker = state.createTracker(info);
-  /** @type {Exit} */
-  let exit;
-  /** @type {Exit} */
-  let subexit;
-
-  if (formatLinkAsAutolink$1(node, state)) {
-    // Hide the fact that we’re in phrasing, because escapes don’t work.
-    const stack = state.stack;
-    state.stack = [];
-    exit = state.enter('autolink');
-    let value = tracker.move('<');
-    value += tracker.move(
-      state.containerPhrasing(node, {
-        before: value,
-        after: '>',
-        ...tracker.current()
-      })
-    );
-    value += tracker.move('>');
-    exit();
-    state.stack = stack;
-    return value
-  }
-
-  exit = state.enter('link');
-  subexit = state.enter('label');
-  let value = tracker.move('[');
-  value += tracker.move(
-    state.containerPhrasing(node, {
-      before: value,
-      after: '](',
-      ...tracker.current()
-    })
-  );
-  value += tracker.move('](');
-  subexit();
-
-  if (
-    // If there’s no url but there is a title…
-    (!node.url && node.title) ||
-    // If there are control characters or whitespace.
-    /[\0- \u007F]/.test(node.url)
-  ) {
-    subexit = state.enter('destinationLiteral');
-    value += tracker.move('<');
-    value += tracker.move(
-      state.safe(node.url, {before: value, after: '>', ...tracker.current()})
-    );
-    value += tracker.move('>');
-  } else {
-    // No whitespace, raw is prettier.
-    subexit = state.enter('destinationRaw');
-    value += tracker.move(
-      state.safe(node.url, {
-        before: value,
-        after: node.title ? ' ' : ')',
-        ...tracker.current()
-      })
-    );
-  }
-
-  subexit();
-
-  if (node.title) {
-    subexit = state.enter(`title${suffix}`);
-    value += tracker.move(' ' + quote);
-    value += tracker.move(
-      state.safe(node.title, {
-        before: value,
-        after: quote,
-        ...tracker.current()
-      })
-    );
-    value += tracker.move(quote);
-    subexit();
-  }
-
-  value += tracker.move(')');
-
-  exit();
-  return value
-}
-
-/**
- * @param {Link} node
- * @param {Parents | undefined} _
- * @param {State} state
- * @returns {string}
- */
-function linkPeek$1(node, _, state) {
-  return formatLinkAsAutolink$1(node, state) ? '<' : '['
-}
-
-/**
- * @typedef {import('mdast').LinkReference} LinkReference
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').State} State
- */
-
-linkReference$1.peek = linkReferencePeek$1;
-
-/**
- * @param {LinkReference} node
- * @param {Parents | undefined} _
- * @param {State} state
- * @param {Info} info
- * @returns {string}
- */
-function linkReference$1(node, _, state, info) {
-  const type = node.referenceType;
-  const exit = state.enter('linkReference');
-  let subexit = state.enter('label');
-  const tracker = state.createTracker(info);
-  let value = tracker.move('[');
-  const text = state.containerPhrasing(node, {
-    before: value,
-    after: ']',
-    ...tracker.current()
-  });
-  value += tracker.move(text + '][');
-
-  subexit();
-  // Hide the fact that we’re in phrasing, because escapes don’t work.
-  const stack = state.stack;
-  state.stack = [];
-  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.
-  // Practically, in that case, there is no content, so it doesn’t matter that
-  // we’ve tracked one too many characters.
-  const reference = state.safe(state.associationId(node), {
-    before: value,
-    after: ']',
-    ...tracker.current()
-  });
-  subexit();
-  state.stack = stack;
-  exit();
-
-  if (type === 'full' || !text || text !== reference) {
-    value += tracker.move(reference + ']');
-  } else if (type === 'shortcut') {
-    // Remove the unwanted `[`.
-    value = value.slice(0, -1);
-  } else {
-    value += tracker.move(']');
-  }
-
-  return value
-}
-
-/**
- * @returns {string}
- */
-function linkReferencePeek$1() {
-  return '['
-}
-
-/**
- * @typedef {import('../types.js').Options} Options
- * @typedef {import('../types.js').State} State
- */
-
-/**
- * @param {State} state
- * @returns {Exclude<Options['bullet'], null | undefined>}
- */
-function checkBullet$1(state) {
-  const marker = state.options.bullet || '*';
-
-  if (marker !== '*' && marker !== '+' && marker !== '-') {
-    throw new Error(
-      'Cannot serialize items with `' +
-        marker +
-        '` for `options.bullet`, expected `*`, `+`, or `-`'
-    )
-  }
-
-  return marker
-}
-
-/**
- * @typedef {import('../types.js').Options} Options
- * @typedef {import('../types.js').State} State
- */
-
-
-/**
- * @param {State} state
- * @returns {Exclude<Options['bullet'], null | undefined>}
- */
-function checkBulletOther$1(state) {
-  const bullet = checkBullet$1(state);
-  const bulletOther = state.options.bulletOther;
-
-  if (!bulletOther) {
-    return bullet === '*' ? '-' : '*'
-  }
-
-  if (bulletOther !== '*' && bulletOther !== '+' && bulletOther !== '-') {
-    throw new Error(
-      'Cannot serialize items with `' +
-        bulletOther +
-        '` for `options.bulletOther`, expected `*`, `+`, or `-`'
-    )
-  }
-
-  if (bulletOther === bullet) {
-    throw new Error(
-      'Expected `bullet` (`' +
-        bullet +
-        '`) and `bulletOther` (`' +
-        bulletOther +
-        '`) to be different'
-    )
-  }
-
-  return bulletOther
-}
-
-/**
- * @typedef {import('../types.js').Options} Options
- * @typedef {import('../types.js').State} State
- */
-
-/**
- * @param {State} state
- * @returns {Exclude<Options['bulletOrdered'], null | undefined>}
- */
-function checkBulletOrdered$1(state) {
-  const marker = state.options.bulletOrdered || '.';
-
-  if (marker !== '.' && marker !== ')') {
-    throw new Error(
-      'Cannot serialize items with `' +
-        marker +
-        '` for `options.bulletOrdered`, expected `.` or `)`'
-    )
-  }
-
-  return marker
-}
-
-/**
- * @typedef {import('../types.js').Options} Options
- * @typedef {import('../types.js').State} State
- */
-
-/**
- * @param {State} state
- * @returns {Exclude<Options['rule'], null | undefined>}
- */
-function checkRule$1(state) {
-  const marker = state.options.rule || '*';
-
-  if (marker !== '*' && marker !== '-' && marker !== '_') {
-    throw new Error(
-      'Cannot serialize rules with `' +
-        marker +
-        '` for `options.rule`, expected `*`, `-`, or `_`'
-    )
-  }
-
-  return marker
-}
-
-/**
- * @typedef {import('mdast').List} List
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').State} State
- */
-
-
-/**
- * @param {List} node
- * @param {Parents | undefined} parent
- * @param {State} state
- * @param {Info} info
- * @returns {string}
- */
-function list$1(node, parent, state, info) {
-  const exit = state.enter('list');
-  const bulletCurrent = state.bulletCurrent;
-  /** @type {string} */
-  let bullet = node.ordered ? checkBulletOrdered$1(state) : checkBullet$1(state);
-  /** @type {string} */
-  const bulletOther = node.ordered
-    ? bullet === '.'
-      ? ')'
-      : '.'
-    : checkBulletOther$1(state);
-  let useDifferentMarker =
-    parent && state.bulletLastUsed ? bullet === state.bulletLastUsed : false;
-
-  if (!node.ordered) {
-    const firstListItem = node.children ? node.children[0] : undefined;
-
-    // If there’s an empty first list item directly in two list items,
-    // we have to use a different bullet:
-    //
-    // ```markdown
-    // * - *
-    // ```
-    //
-    // …because otherwise it would become one big thematic break.
-    if (
-      // Bullet could be used as a thematic break marker:
-      (bullet === '*' || bullet === '-') &&
-      // Empty first list item:
-      firstListItem &&
-      (!firstListItem.children || !firstListItem.children[0]) &&
-      // Directly in two other list items:
-      state.stack[state.stack.length - 1] === 'list' &&
-      state.stack[state.stack.length - 2] === 'listItem' &&
-      state.stack[state.stack.length - 3] === 'list' &&
-      state.stack[state.stack.length - 4] === 'listItem' &&
-      // That are each the first child.
-      state.indexStack[state.indexStack.length - 1] === 0 &&
-      state.indexStack[state.indexStack.length - 2] === 0 &&
-      state.indexStack[state.indexStack.length - 3] === 0
-    ) {
-      useDifferentMarker = true;
-    }
-
-    // If there’s a thematic break at the start of the first list item,
-    // we have to use a different bullet:
-    //
-    // ```markdown
-    // * ---
-    // ```
-    //
-    // …because otherwise it would become one big thematic break.
-    if (checkRule$1(state) === bullet && firstListItem) {
-      let index = -1;
-
-      while (++index < node.children.length) {
-        const item = node.children[index];
-
-        if (
-          item &&
-          item.type === 'listItem' &&
-          item.children &&
-          item.children[0] &&
-          item.children[0].type === 'thematicBreak'
-        ) {
-          useDifferentMarker = true;
-          break
-        }
-      }
-    }
-  }
-
-  if (useDifferentMarker) {
-    bullet = bulletOther;
-  }
-
-  state.bulletCurrent = bullet;
-  const value = state.containerFlow(node, info);
-  state.bulletLastUsed = bullet;
-  state.bulletCurrent = bulletCurrent;
-  exit();
-  return value
-}
-
-/**
- * @typedef {import('../types.js').Options} Options
- * @typedef {import('../types.js').State} State
- */
-
-/**
- * @param {State} state
- * @returns {Exclude<Options['listItemIndent'], null | undefined>}
- */
-function checkListItemIndent$1(state) {
-  const style = state.options.listItemIndent || 'one';
-
-  if (style !== 'tab' && style !== 'one' && style !== 'mixed') {
-    throw new Error(
-      'Cannot serialize items with `' +
-        style +
-        '` for `options.listItemIndent`, expected `tab`, `one`, or `mixed`'
-    )
-  }
-
-  return style
-}
-
-/**
- * @typedef {import('mdast').ListItem} ListItem
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').Map} Map
- * @typedef {import('../types.js').State} State
- */
-
-
-/**
- * @param {ListItem} node
- * @param {Parents | undefined} parent
- * @param {State} state
- * @param {Info} info
- * @returns {string}
- */
-function listItem$1(node, parent, state, info) {
-  const listItemIndent = checkListItemIndent$1(state);
-  let bullet = state.bulletCurrent || checkBullet$1(state);
-
-  // Add the marker value for ordered lists.
-  if (parent && parent.type === 'list' && parent.ordered) {
-    bullet =
-      (typeof parent.start === 'number' && parent.start > -1
-        ? parent.start
-        : 1) +
-      (state.options.incrementListMarker === false
-        ? 0
-        : parent.children.indexOf(node)) +
-      bullet;
-  }
-
-  let size = bullet.length + 1;
-
-  if (
-    listItemIndent === 'tab' ||
-    (listItemIndent === 'mixed' &&
-      ((parent && parent.type === 'list' && parent.spread) || node.spread))
-  ) {
-    size = Math.ceil(size / 4) * 4;
-  }
-
-  const tracker = state.createTracker(info);
-  tracker.move(bullet + ' '.repeat(size - bullet.length));
-  tracker.shift(size);
-  const exit = state.enter('listItem');
-  const value = state.indentLines(
-    state.containerFlow(node, tracker.current()),
-    map
-  );
-  exit();
-
-  return value
-
-  /** @type {Map} */
-  function map(line, index, blank) {
-    if (index) {
-      return (blank ? '' : ' '.repeat(size)) + line
-    }
-
-    return (blank ? bullet : bullet + ' '.repeat(size - bullet.length)) + line
-  }
-}
-
-/**
- * @typedef {import('mdast').Paragraph} Paragraph
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').State} State
- */
-
-/**
- * @param {Paragraph} node
- * @param {Parents | undefined} _
- * @param {State} state
- * @param {Info} info
- * @returns {string}
- */
-function paragraph$1(node, _, state, info) {
-  const exit = state.enter('paragraph');
-  const subexit = state.enter('phrasing');
-  const value = state.containerPhrasing(node, info);
-  subexit();
-  exit();
-  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'
-    ])
-  );
-
-/**
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('mdast').Root} Root
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').State} State
- */
-
-
-/**
- * @param {Root} node
- * @param {Parents | undefined} _
- * @param {State} state
- * @param {Info} info
- * @returns {string}
- */
-function root$3(node, _, state, info) {
-  // Note: `html` nodes are ambiguous.
-  const hasPhrasing = node.children.some(function (d) {
-    return phrasing(d)
-  });
-  const fn = hasPhrasing ? state.containerPhrasing : state.containerFlow;
-  return fn.call(state, node, info)
-}
-
-/**
- * @typedef {import('../types.js').Options} Options
- * @typedef {import('../types.js').State} State
- */
-
-/**
- * @param {State} state
- * @returns {Exclude<Options['strong'], null | undefined>}
- */
-function checkStrong$1(state) {
-  const marker = state.options.strong || '*';
-
-  if (marker !== '*' && marker !== '_') {
-    throw new Error(
-      'Cannot serialize strong with `' +
-        marker +
-        '` for `options.strong`, expected `*`, or `_`'
-    )
-  }
-
-  return marker
-}
-
-/**
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('mdast').Strong} Strong
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').State} State
- */
-
-
-strong$1.peek = strongPeek$1;
-
-// To do: there are cases where emphasis cannot “form” depending on the
-// previous or next character of sequences.
-// There’s no way around that though, except for injecting zero-width stuff.
-// Do we need to safeguard against that?
-/**
- * @param {Strong} node
- * @param {Parents | undefined} _
- * @param {State} state
- * @param {Info} info
- * @returns {string}
- */
-function strong$1(node, _, state, info) {
-  const marker = checkStrong$1(state);
-  const exit = state.enter('strong');
-  const tracker = state.createTracker(info);
-  let value = tracker.move(marker + marker);
-  value += tracker.move(
-    state.containerPhrasing(node, {
-      before: value,
-      after: marker,
-      ...tracker.current()
-    })
-  );
-  value += tracker.move(marker + marker);
-  exit();
-  return value
-}
-
-/**
- * @param {Strong} _
- * @param {Parents | undefined} _1
- * @param {State} state
- * @returns {string}
- */
-function strongPeek$1(_, _1, state) {
-  return state.options.strong || '*'
-}
-
-/**
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('mdast').Text} Text
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').State} State
- */
-
-/**
- * @param {Text} node
- * @param {Parents | undefined} _
- * @param {State} state
- * @param {Info} info
- * @returns {string}
- */
-function text$4(node, _, state, info) {
-  return state.safe(node.value, info)
-}
-
-/**
- * @typedef {import('../types.js').Options} Options
- * @typedef {import('../types.js').State} State
- */
-
-/**
- * @param {State} state
- * @returns {Exclude<Options['ruleRepetition'], null | undefined>}
- */
-function checkRuleRepetition$1(state) {
-  const repetition = state.options.ruleRepetition || 3;
-
-  if (repetition < 3) {
-    throw new Error(
-      'Cannot serialize rules with repetition `' +
-        repetition +
-        '` for `options.ruleRepetition`, expected `3` or more'
-    )
-  }
-
-  return repetition
-}
-
-/**
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('mdast').ThematicBreak} ThematicBreak
- * @typedef {import('../types.js').State} State
- */
-
-
-/**
- * @param {ThematicBreak} _
- * @param {Parents | undefined} _1
- * @param {State} state
- * @returns {string}
- */
-function thematicBreak$1(_, _1, state) {
-  const value = (
-    checkRule$1(state) + (state.options.ruleSpaces ? ' ' : '')
-  ).repeat(checkRuleRepetition$1(state));
-
-  return state.options.ruleSpaces ? value.slice(0, -1) : value
-}
-
-/**
- * Default (CommonMark) handlers.
- */
-const handle$1 = {
-  blockquote: blockquote$1,
-  break: hardBreak$1,
-  code: code$2,
-  definition: definition$1,
-  emphasis: emphasis$1,
-  hardBreak: hardBreak$1,
-  heading: heading$1,
-  html: html$5,
-  image: image$1,
-  imageReference: imageReference$1,
-  inlineCode: inlineCode$1,
-  link: link$1,
-  linkReference: linkReference$1,
-  list: list$1,
-  listItem: listItem$1,
-  paragraph: paragraph$1,
-  root: root$3,
-  strong: strong$1,
-  text: text$4,
-  thematicBreak: thematicBreak$1
-};
-
-/**
- * @typedef {import('mdast').InlineCode} InlineCode
- * @typedef {import('mdast').Table} Table
- * @typedef {import('mdast').TableCell} TableCell
- * @typedef {import('mdast').TableRow} TableRow
- *
- * @typedef {import('markdown-table').Options} MarkdownTableOptions
- *
- * @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext
- * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension
- * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle
- *
- * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension
- * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle
- * @typedef {import('mdast-util-to-markdown').State} State
- * @typedef {import('mdast-util-to-markdown').Info} Info
- */
-
-
-/**
- * Create an extension for `mdast-util-from-markdown` to enable GFM tables in
- * markdown.
- *
- * @returns {FromMarkdownExtension}
- *   Extension for `mdast-util-from-markdown` to enable GFM tables.
- */
-function gfmTableFromMarkdown() {
-  return {
-    enter: {
-      table: enterTable,
-      tableData: enterCell,
-      tableHeader: enterCell,
-      tableRow: enterRow
-    },
-    exit: {
-      codeText: exitCodeText,
-      table: exitTable,
-      tableData: exit,
-      tableHeader: exit,
-      tableRow: exit
-    }
-  }
-}
-
-/**
- * @this {CompileContext}
- * @type {FromMarkdownHandle}
- */
-function enterTable(token) {
-  const align = token._align;
-  this.enter(
-    {
-      type: 'table',
-      align: align.map(function (d) {
-        return d === 'none' ? null : d
-      }),
-      children: []
-    },
-    token
-  );
-  this.data.inTable = true;
-}
-
-/**
- * @this {CompileContext}
- * @type {FromMarkdownHandle}
- */
-function exitTable(token) {
-  this.exit(token);
-  this.data.inTable = undefined;
-}
-
-/**
- * @this {CompileContext}
- * @type {FromMarkdownHandle}
- */
-function enterRow(token) {
-  this.enter({type: 'tableRow', children: []}, token);
-}
-
-/**
- * @this {CompileContext}
- * @type {FromMarkdownHandle}
- */
-function exit(token) {
-  this.exit(token);
-}
-
-/**
- * @this {CompileContext}
- * @type {FromMarkdownHandle}
- */
-function enterCell(token) {
-  this.enter({type: 'tableCell', children: []}, token);
-}
-
-// Overwrite the default code text data handler to unescape escaped pipes when
-// they are in tables.
-/**
- * @this {CompileContext}
- * @type {FromMarkdownHandle}
- */
-function exitCodeText(token) {
-  let value = this.resume();
-
-  if (this.data.inTable) {
-    value = value.replace(/\\([\\|])/g, replace);
-  }
-
-  const node = this.stack[this.stack.length - 1];
-  node.value = value;
-  this.exit(token);
-}
-
-/**
- * @param {string} $0
- * @param {string} $1
- * @returns {string}
- */
-function replace($0, $1) {
-  // Pipes work, backslashes don’t (but can’t escape pipes).
-  return $1 === '|' ? $1 : $0
-}
-
-/**
- * Create an extension for `mdast-util-to-markdown` to enable GFM tables in
- * markdown.
- *
- * @param {Options | null | undefined} [options]
- *   Configuration.
- * @returns {ToMarkdownExtension}
- *   Extension for `mdast-util-to-markdown` to enable GFM tables.
- */
-function gfmTableToMarkdown(options) {
-  const settings = options || {};
-  const padding = settings.tableCellPadding;
-  const alignDelimiters = settings.tablePipeAlign;
-  const stringLength = settings.stringLength;
-  const around = padding ? ' ' : '|';
-
-  return {
-    unsafe: [
-      {character: '\r', inConstruct: 'tableCell'},
-      {character: '\n', inConstruct: 'tableCell'},
-      // A pipe, when followed by a tab or space (padding), or a dash or colon
-      // (unpadded delimiter row), could result in a table.
-      {atBreak: true, character: '|', after: '[\t :-]'},
-      // A pipe in a cell must be encoded.
-      {character: '|', inConstruct: 'tableCell'},
-      // A colon must be followed by a dash, in which case it could start a
-      // delimiter row.
-      {atBreak: true, character: ':', after: '-'},
-      // A delimiter row can also start with a dash, when followed by more
-      // dashes, a colon, or a pipe.
-      // This is a stricter version than the built in check for lists, thematic
-      // breaks, and setex heading underlines though:
-      // <https://github.com/syntax-tree/mdast-util-to-markdown/blob/51a2038/lib/unsafe.js#L57>
-      {atBreak: true, character: '-', after: '[:|-]'}
-    ],
-    handlers: {
-      inlineCode: inlineCodeWithTable,
-      table: handleTable,
-      tableCell: handleTableCell,
-      tableRow: handleTableRow
-    }
-  }
-
-  /**
-   * @type {ToMarkdownHandle}
-   * @param {Table} node
-   */
-  function handleTable(node, _, state, info) {
-    return serializeData(handleTableAsData(node, state, info), node.align)
-  }
-
-  /**
-   * This function isn’t really used normally, because we handle rows at the
-   * table level.
-   * But, if someone passes in a table row, this ensures we make somewhat sense.
-   *
-   * @type {ToMarkdownHandle}
-   * @param {TableRow} node
-   */
-  function handleTableRow(node, _, state, info) {
-    const row = handleTableRowAsData(node, state, info);
-    const value = serializeData([row]);
-    // `markdown-table` will always add an align row
-    return value.slice(0, value.indexOf('\n'))
-  }
-
-  /**
-   * @type {ToMarkdownHandle}
-   * @param {TableCell} node
-   */
-  function handleTableCell(node, _, state, info) {
-    const exit = state.enter('tableCell');
-    const subexit = state.enter('phrasing');
-    const value = state.containerPhrasing(node, {
-      ...info,
-      before: around,
-      after: around
-    });
-    subexit();
-    exit();
-    return value
-  }
-
-  /**
-   * @param {Array<Array<string>>} matrix
-   * @param {Array<string | null | undefined> | null | undefined} [align]
-   */
-  function serializeData(matrix, align) {
-    return markdownTable(matrix, {
-      align,
-      // @ts-expect-error: `markdown-table` types should support `null`.
-      alignDelimiters,
-      // @ts-expect-error: `markdown-table` types should support `null`.
-      padding,
-      // @ts-expect-error: `markdown-table` types should support `null`.
-      stringLength
-    })
-  }
-
-  /**
-   * @param {Table} node
-   * @param {State} state
-   * @param {Info} info
-   */
-  function handleTableAsData(node, state, info) {
-    const children = node.children;
-    let index = -1;
-    /** @type {Array<Array<string>>} */
-    const result = [];
-    const subexit = state.enter('table');
-
-    while (++index < children.length) {
-      result[index] = handleTableRowAsData(children[index], state, info);
-    }
-
-    subexit();
-
-    return result
-  }
-
-  /**
-   * @param {TableRow} node
-   * @param {State} state
-   * @param {Info} info
-   */
-  function handleTableRowAsData(node, state, info) {
-    const children = node.children;
-    let index = -1;
-    /** @type {Array<string>} */
-    const result = [];
-    const subexit = state.enter('tableRow');
-
-    while (++index < children.length) {
-      // Note: the positional info as used here is incorrect.
-      // Making it correct would be impossible due to aligning cells?
-      // And it would need copy/pasting `markdown-table` into this project.
-      result[index] = handleTableCell(children[index], node, state, info);
-    }
-
-    subexit();
-
-    return result
-  }
-
-  /**
-   * @type {ToMarkdownHandle}
-   * @param {InlineCode} node
-   */
-  function inlineCodeWithTable(node, parent, state) {
-    let value = handle$1.inlineCode(node, parent, state);
-
-    if (state.stack.includes('tableCell')) {
-      value = value.replace(/\|/g, '\\$&');
-    }
-
-    return value
-  }
-}
-
-/**
- * @typedef {import('mdast').Blockquote} Blockquote
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').Map} Map
- * @typedef {import('../types.js').State} State
- */
-
-/**
- * @param {Blockquote} node
- * @param {Parents | undefined} _
- * @param {State} state
- * @param {Info} info
- * @returns {string}
- */
-function blockquote(node, _, state, info) {
-  const exit = state.enter('blockquote');
-  const tracker = state.createTracker(info);
-  tracker.move('> ');
-  tracker.shift(2);
-  const value = state.indentLines(
-    state.containerFlow(node, tracker.current()),
-    map$1
-  );
-  exit();
-  return value
-}
-
-/** @type {Map} */
-function map$1(line, _, blank) {
-  return '>' + (blank ? '' : ' ') + line
-}
-
-/**
- * @typedef {import('../types.js').ConstructName} ConstructName
- * @typedef {import('../types.js').Unsafe} Unsafe
- */
-
-/**
- * @param {Array<ConstructName>} stack
- * @param {Unsafe} pattern
- * @returns {boolean}
- */
-function patternInScope(stack, pattern) {
-  return (
-    listInScope(stack, pattern.inConstruct, true) &&
-    !listInScope(stack, pattern.notInConstruct, false)
-  )
-}
-
-/**
- * @param {Array<ConstructName>} stack
- * @param {Unsafe['inConstruct']} list
- * @param {boolean} none
- * @returns {boolean}
- */
-function listInScope(stack, list, none) {
-  if (typeof list === 'string') {
-    list = [list];
-  }
-
-  if (!list || list.length === 0) {
-    return none
-  }
-
-  let index = -1;
-
-  while (++index < list.length) {
-    if (stack.includes(list[index])) {
-      return true
-    }
-  }
-
-  return false
-}
-
-/**
- * @typedef {import('mdast').Break} Break
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').State} State
- */
-
-
-/**
- * @param {Break} _
- * @param {Parents | undefined} _1
- * @param {State} state
- * @param {Info} info
- * @returns {string}
- */
-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.
-    if (
-      state.unsafe[index].character === '\n' &&
-      patternInScope(state.stack, state.unsafe[index])
-    ) {
-      return /[ \t]/.test(info.before) ? '' : ' '
-    }
-  }
-
-  return '\\\n'
-}
-
-/**
- * @typedef {import('mdast').Code} Code
- * @typedef {import('../types.js').State} State
- */
-
-/**
- * @param {Code} node
- * @param {State} state
- * @returns {boolean}
- */
-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)
-  )
-}
-
-/**
- * @typedef {import('../types.js').Options} Options
- * @typedef {import('../types.js').State} State
- */
-
-/**
- * @param {State} state
- * @returns {Exclude<Options['fence'], null | undefined>}
- */
-function checkFence(state) {
-  const marker = state.options.fence || '`';
-
-  if (marker !== '`' && marker !== '~') {
-    throw new Error(
-      'Cannot serialize code with `' +
-        marker +
-        '` for `options.fence`, expected `` ` `` or `~`'
-    )
-  }
-
-  return marker
-}
-
-/**
- * @typedef {import('mdast').Code} Code
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').Map} Map
- * @typedef {import('../types.js').State} State
- */
-
-
-/**
- * @param {Code} node
- * @param {Parents | undefined} _
- * @param {State} state
- * @param {Info} info
- * @returns {string}
- */
-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');
-    const value = state.indentLines(raw, map);
-    exit();
-    return value
-  }
-
-  const tracker = state.createTracker(info);
-  const sequence = marker.repeat(Math.max(longestStreak(raw, marker) + 1, 3));
-  const exit = state.enter('codeFenced');
-  let value = tracker.move(sequence);
-
-  if (node.lang) {
-    const subexit = state.enter(`codeFencedLang${suffix}`);
-    value += tracker.move(
-      state.safe(node.lang, {
-        before: value,
-        after: ' ',
-        encode: ['`'],
-        ...tracker.current()
-      })
-    );
-    subexit();
-  }
-
-  if (node.lang && node.meta) {
-    const subexit = state.enter(`codeFencedMeta${suffix}`);
-    value += tracker.move(' ');
-    value += tracker.move(
-      state.safe(node.meta, {
-        before: value,
-        after: '\n',
-        encode: ['`'],
-        ...tracker.current()
-      })
-    );
-    subexit();
-  }
-
-  value += tracker.move('\n');
-
-  if (raw) {
-    value += tracker.move(raw + '\n');
-  }
-
-  value += tracker.move(sequence);
-  exit();
-  return value
-}
-
-/** @type {Map} */
-function map(line, _, blank) {
-  return (blank ? '' : '    ') + line
-}
-
-/**
- * @typedef {import('../types.js').Options} Options
- * @typedef {import('../types.js').State} State
- */
-
-/**
- * @param {State} state
- * @returns {Exclude<Options['quote'], null | undefined>}
- */
-function checkQuote(state) {
-  const marker = state.options.quote || '"';
-
-  if (marker !== '"' && marker !== "'") {
-    throw new Error(
-      'Cannot serialize title with `' +
-        marker +
-        '` for `options.quote`, expected `"`, or `\'`'
-    )
-  }
-
-  return marker
-}
-
-/**
- * @typedef {import('mdast').Definition} Definition
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').State} State
- */
-
-
-/**
- * @param {Definition} node
- * @param {Parents | undefined} _
- * @param {State} state
- * @param {Info} info
- * @returns {string}
- */
-function definition(node, _, state, info) {
-  const quote = checkQuote(state);
-  const suffix = quote === '"' ? 'Quote' : 'Apostrophe';
-  const exit = state.enter('definition');
-  let subexit = state.enter('label');
-  const tracker = state.createTracker(info);
-  let value = tracker.move('[');
-  value += tracker.move(
-    state.safe(state.associationId(node), {
-      before: value,
-      after: ']',
-      ...tracker.current()
-    })
-  );
-  value += tracker.move(']: ');
-
-  subexit();
-
-  if (
-    // If there’s no url, or…
-    !node.url ||
-    // If there are control characters or whitespace.
-    /[\0- \u007F]/.test(node.url)
-  ) {
-    subexit = state.enter('destinationLiteral');
-    value += tracker.move('<');
-    value += tracker.move(
-      state.safe(node.url, {before: value, after: '>', ...tracker.current()})
-    );
-    value += tracker.move('>');
-  } else {
-    // No whitespace, raw is prettier.
-    subexit = state.enter('destinationRaw');
-    value += tracker.move(
-      state.safe(node.url, {
-        before: value,
-        after: node.title ? ' ' : '\n',
-        ...tracker.current()
-      })
-    );
-  }
-
-  subexit();
-
-  if (node.title) {
-    subexit = state.enter(`title${suffix}`);
-    value += tracker.move(' ' + quote);
-    value += tracker.move(
-      state.safe(node.title, {
-        before: value,
-        after: quote,
-        ...tracker.current()
-      })
-    );
-    value += tracker.move(quote);
-    subexit();
-  }
-
-  exit();
-
-  return value
-}
-
-/**
- * @typedef {import('../types.js').Options} Options
- * @typedef {import('../types.js').State} State
- */
-
-/**
- * @param {State} state
- * @returns {Exclude<Options['emphasis'], null | undefined>}
- */
-function checkEmphasis(state) {
-  const marker = state.options.emphasis || '*';
-
-  if (marker !== '*' && marker !== '_') {
-    throw new Error(
-      'Cannot serialize emphasis with `' +
-        marker +
-        '` for `options.emphasis`, expected `*`, or `_`'
-    )
-  }
-
-  return marker
-}
-
-/**
- * @typedef {import('mdast').Emphasis} Emphasis
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').State} State
- */
-
-
-emphasis.peek = emphasisPeek;
-
-// To do: there are cases where emphasis cannot “form” depending on the
-// previous or next character of sequences.
-// There’s no way around that though, except for injecting zero-width stuff.
-// Do we need to safeguard against that?
-/**
- * @param {Emphasis} node
- * @param {Parents | undefined} _
- * @param {State} state
- * @param {Info} info
- * @returns {string}
- */
-function emphasis(node, _, state, info) {
-  const marker = checkEmphasis(state);
-  const exit = state.enter('emphasis');
-  const tracker = state.createTracker(info);
-  let value = tracker.move(marker);
-  value += tracker.move(
-    state.containerPhrasing(node, {
-      before: value,
-      after: marker,
-      ...tracker.current()
-    })
-  );
-  value += tracker.move(marker);
-  exit();
-  return value
-}
-
-/**
- * @param {Emphasis} _
- * @param {Parents | undefined} _1
- * @param {State} state
- * @returns {string}
- */
-function emphasisPeek(_, _1, state) {
-  return state.options.emphasis || '*'
-}
-
-/**
- * @typedef {import('mdast').Nodes} Nodes
- *
- * @typedef Options
- *   Configuration (optional).
- * @property {boolean | null | undefined} [includeImageAlt=true]
- *   Whether to use `alt` for `image`s (default: `true`).
- * @property {boolean | null | undefined} [includeHtml=true]
- *   Whether to use `value` of HTML (default: `true`).
- */
-
-/** @type {Options} */
-const emptyOptions$2 = {};
-
-/**
- * Get the text content of a node or list of nodes.
- *
- * Prefers the node’s plain-text fields, otherwise serializes its children,
- * and if the given value is an array, serialize the nodes in it.
- *
- * @param {unknown} [value]
- *   Thing to serialize, typically `Node`.
- * @param {Options | null | undefined} [options]
- *   Configuration (optional).
- * @returns {string}
- *   Serialized `value`.
- */
-function toString(value, options) {
-  const settings = emptyOptions$2;
-  const includeImageAlt =
-    typeof settings.includeImageAlt === 'boolean'
-      ? settings.includeImageAlt
-      : true;
-  const includeHtml =
-    typeof settings.includeHtml === 'boolean' ? settings.includeHtml : true;
-
-  return one$2(value, includeImageAlt, includeHtml)
-}
-
-/**
- * One node or several nodes.
- *
- * @param {unknown} value
- *   Thing to serialize.
- * @param {boolean} includeImageAlt
- *   Include image `alt`s.
- * @param {boolean} includeHtml
- *   Include HTML.
- * @returns {string}
- *   Serialized node.
- */
-function one$2(value, includeImageAlt, includeHtml) {
-  if (node(value)) {
-    if ('value' in value) {
-      return value.type === 'html' && !includeHtml ? '' : value.value
-    }
-
-    if (includeImageAlt && 'alt' in value && value.alt) {
-      return value.alt
-    }
-
-    if ('children' in value) {
-      return all$3(value.children, includeImageAlt, includeHtml)
-    }
-  }
-
-  if (Array.isArray(value)) {
-    return all$3(value, includeImageAlt, includeHtml)
-  }
-
-  return ''
-}
-
-/**
- * Serialize a list of nodes.
- *
- * @param {Array<unknown>} values
- *   Thing to serialize.
- * @param {boolean} includeImageAlt
- *   Include image `alt`s.
- * @param {boolean} includeHtml
- *   Include HTML.
- * @returns {string}
- *   Serialized nodes.
- */
-function all$3(values, includeImageAlt, includeHtml) {
-  /** @type {Array<string>} */
-  const result = [];
-  let index = -1;
-
-  while (++index < values.length) {
-    result[index] = one$2(values[index], includeImageAlt, includeHtml);
-  }
-
-  return result.join('')
-}
-
-/**
- * Check if `value` looks like a node.
- *
- * @param {unknown} value
- *   Thing.
- * @returns {value is Nodes}
- *   Whether `value` is a node.
- */
-function node(value) {
-  return Boolean(value && typeof value === 'object')
-}
-
-/**
- * @typedef {import('mdast').Heading} Heading
- * @typedef {import('../types.js').State} State
- */
-
-
-/**
- * @param {Heading} node
- * @param {State} state
- * @returns {boolean}
- */
-function formatHeadingAsSetext(node, state) {
-  let literalWithBreak = false;
-
-  // Look for literals with a line break.
-  // Note that this also
-  visit(node, function (node) {
-    if (
-      ('value' in node && /\r?\n|\r/.test(node.value)) ||
-      node.type === 'break'
-    ) {
-      literalWithBreak = true;
-      return EXIT
-    }
-  });
-
-  return Boolean(
-    (!node.depth || node.depth < 3) &&
-      toString(node) &&
-      (state.options.setext || literalWithBreak)
-  )
-}
-
-/**
- * @typedef {import('mdast').Heading} Heading
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').State} State
- */
-
-
-/**
- * @param {Heading} node
- * @param {Parents | undefined} _
- * @param {State} state
- * @param {Info} info
- * @returns {string}
- */
-function heading(node, _, state, info) {
-  const rank = Math.max(Math.min(6, node.depth || 1), 1);
-  const tracker = state.createTracker(info);
-
-  if (formatHeadingAsSetext(node, state)) {
-    const exit = state.enter('headingSetext');
-    const subexit = state.enter('phrasing');
-    const value = state.containerPhrasing(node, {
-      ...tracker.current(),
-      before: '\n',
-      after: '\n'
-    });
-    subexit();
-    exit();
-
-    return (
-      value +
-      '\n' +
-      (rank === 1 ? '=' : '-').repeat(
-        // The whole size…
-        value.length -
-          // Minus the position of the character after the last EOL (or
-          // 0 if there is none)…
-          (Math.max(value.lastIndexOf('\r'), value.lastIndexOf('\n')) + 1)
-      )
-    )
-  }
-
-  const sequence = '#'.repeat(rank);
-  const exit = state.enter('headingAtx');
-  const subexit = state.enter('phrasing');
-
-  // Note: for proper tracking, we should reset the output positions when there
-  // is no content returned, because then the space is not output.
-  // Practically, in that case, there is no content, so it doesn’t matter that
-  // we’ve tracked one too many characters.
-  tracker.move(sequence + ' ');
-
-  let value = state.containerPhrasing(node, {
-    before: '# ',
-    after: '\n',
-    ...tracker.current()
-  });
-
-  if (/^[\t ]/.test(value)) {
-    // To do: what effect has the character reference on tracking?
-    value =
-      '&#x' +
-      value.charCodeAt(0).toString(16).toUpperCase() +
-      ';' +
-      value.slice(1);
+    value = encodeCharacterReference(value.charCodeAt(0)) + value.slice(1);
   }
 
   value = value ? sequence + ' ' + value : sequence;
@@ -18047,7 +16092,7 @@ function heading(node, _, state, info) {
 }
 
 /**
- * @typedef {import('mdast').Html} Html
+ * @import {Html} from 'mdast'
  */
 
 html$4.peek = htmlPeek;
@@ -18068,10 +16113,8 @@ function htmlPeek() {
 }
 
 /**
- * @typedef {import('mdast').Image} Image
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').State} State
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {Image, Parents} from 'mdast'
  */
 
 
@@ -18152,10 +16195,8 @@ function imagePeek() {
 }
 
 /**
- * @typedef {import('mdast').ImageReference} ImageReference
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').State} State
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {ImageReference, Parents} from 'mdast'
  */
 
 imageReference.peek = imageReferencePeek;
@@ -18218,9 +16259,8 @@ function imageReferencePeek() {
 }
 
 /**
- * @typedef {import('mdast').InlineCode} InlineCode
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../types.js').State} State
+ * @import {State} from 'mdast-util-to-markdown'
+ * @import {InlineCode, Parents} from 'mdast'
  */
 
 inlineCode.peek = inlineCodePeek;
@@ -18296,8 +16336,8 @@ function inlineCodePeek() {
 }
 
 /**
- * @typedef {import('mdast').Link} Link
- * @typedef {import('../types.js').State} State
+ * @import {State} from 'mdast-util-to-markdown'
+ * @import {Link} from 'mdast'
  */
 
 
@@ -18330,11 +16370,9 @@ function formatLinkAsAutolink(node, state) {
 }
 
 /**
- * @typedef {import('mdast').Link} Link
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../types.js').Exit} Exit
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').State} State
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {Link, Parents} from 'mdast'
+ * @import {Exit} from '../types.js'
  */
 
 
@@ -18445,10 +16483,8 @@ function linkPeek(node, _, state) {
 }
 
 /**
- * @typedef {import('mdast').LinkReference} LinkReference
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').State} State
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {LinkReference, Parents} from 'mdast'
  */
 
 linkReference.peek = linkReferencePeek;
@@ -18511,8 +16547,7 @@ function linkReferencePeek() {
 }
 
 /**
- * @typedef {import('../types.js').Options} Options
- * @typedef {import('../types.js').State} State
+ * @import {Options, State} from 'mdast-util-to-markdown'
  */
 
 /**
@@ -18534,8 +16569,7 @@ function checkBullet(state) {
 }
 
 /**
- * @typedef {import('../types.js').Options} Options
- * @typedef {import('../types.js').State} State
+ * @import {Options, State} from 'mdast-util-to-markdown'
  */
 
 
@@ -18573,8 +16607,7 @@ function checkBulletOther(state) {
 }
 
 /**
- * @typedef {import('../types.js').Options} Options
- * @typedef {import('../types.js').State} State
+ * @import {Options, State} from 'mdast-util-to-markdown'
  */
 
 /**
@@ -18596,8 +16629,7 @@ function checkBulletOrdered(state) {
 }
 
 /**
- * @typedef {import('../types.js').Options} Options
- * @typedef {import('../types.js').State} State
+ * @import {Options, State} from 'mdast-util-to-markdown'
  */
 
 /**
@@ -18619,10 +16651,8 @@ function checkRule(state) {
 }
 
 /**
- * @typedef {import('mdast').List} List
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').State} State
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {List, Parents} from 'mdast'
  */
 
 
@@ -18718,8 +16748,7 @@ function list(node, parent, state, info) {
 }
 
 /**
- * @typedef {import('../types.js').Options} Options
- * @typedef {import('../types.js').State} State
+ * @import {Options, State} from 'mdast-util-to-markdown'
  */
 
 /**
@@ -18741,11 +16770,8 @@ function checkListItemIndent(state) {
 }
 
 /**
- * @typedef {import('mdast').ListItem} ListItem
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').Map} Map
- * @typedef {import('../types.js').State} State
+ * @import {Info, Map, State} from 'mdast-util-to-markdown'
+ * @import {ListItem, Parents} from 'mdast'
  */
 
 
@@ -18805,10 +16831,8 @@ function listItem(node, parent, state, info) {
 }
 
 /**
- * @typedef {import('mdast').Paragraph} Paragraph
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').State} State
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {Paragraph, Parents} from 'mdast'
  */
 
 /**
@@ -18828,10 +16852,43 @@ function paragraph(node, _, state, info) {
 }
 
 /**
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('mdast').Root} Root
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').State} State
+ * @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'
  */
 
 
@@ -18847,13 +16904,13 @@ function root$2(node, _, state, info) {
   const hasPhrasing = node.children.some(function (d) {
     return phrasing(d)
   });
-  const fn = hasPhrasing ? state.containerPhrasing : state.containerFlow;
-  return fn.call(state, node, info)
+
+  const container = hasPhrasing ? state.containerPhrasing : state.containerFlow;
+  return container.call(state, node, info)
 }
 
 /**
- * @typedef {import('../types.js').Options} Options
- * @typedef {import('../types.js').State} State
+ * @import {Options, State} from 'mdast-util-to-markdown'
  */
 
 /**
@@ -18875,19 +16932,13 @@ function checkStrong(state) {
 }
 
 /**
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('mdast').Strong} Strong
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').State} State
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {Parents, Strong} from 'mdast'
  */
 
 
 strong.peek = strongPeek;
 
-// To do: there are cases where emphasis cannot “form” depending on the
-// previous or next character of sequences.
-// There’s no way around that though, except for injecting zero-width stuff.
-// Do we need to safeguard against that?
 /**
  * @param {Strong} node
  * @param {Parents | undefined} _
@@ -18899,17 +16950,42 @@ function strong(node, _, state, info) {
   const marker = checkStrong(state);
   const exit = state.enter('strong');
   const tracker = state.createTracker(info);
-  let value = tracker.move(marker + marker);
-  value += tracker.move(
+  const before = tracker.move(marker + marker);
+
+  let between = tracker.move(
     state.containerPhrasing(node, {
-      before: value,
       after: marker,
+      before,
       ...tracker.current()
     })
   );
-  value += tracker.move(marker + marker);
+  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);
+
   exit();
-  return value
+
+  state.attentionEncodeSurroundingInfo = {
+    after: close.outside,
+    before: open.outside
+  };
+  return before + between + after
 }
 
 /**
@@ -18923,10 +16999,8 @@ function strongPeek(_, _1, state) {
 }
 
 /**
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('mdast').Text} Text
- * @typedef {import('../types.js').Info} Info
- * @typedef {import('../types.js').State} State
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {Parents, Text} from 'mdast'
  */
 
 /**
@@ -18941,8 +17015,7 @@ function text$3(node, _, state, info) {
 }
 
 /**
- * @typedef {import('../types.js').Options} Options
- * @typedef {import('../types.js').State} State
+ * @import {Options, State} from 'mdast-util-to-markdown'
  */
 
 /**
@@ -18964,9 +17037,8 @@ function checkRuleRepetition(state) {
 }
 
 /**
- * @typedef {import('mdast').Parents} Parents
- * @typedef {import('mdast').ThematicBreak} ThematicBreak
- * @typedef {import('../types.js').State} State
+ * @import {State} from 'mdast-util-to-markdown'
+ * @import {Parents, ThematicBreak} from 'mdast'
  */
 
 
@@ -19010,6 +17082,289 @@ const handle = {
   thematicBreak
 };
 
+/**
+ * @typedef {import('mdast').InlineCode} InlineCode
+ * @typedef {import('mdast').Table} Table
+ * @typedef {import('mdast').TableCell} TableCell
+ * @typedef {import('mdast').TableRow} TableRow
+ *
+ * @typedef {import('markdown-table').Options} MarkdownTableOptions
+ *
+ * @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext
+ * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension
+ * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle
+ *
+ * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension
+ * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle
+ * @typedef {import('mdast-util-to-markdown').State} State
+ * @typedef {import('mdast-util-to-markdown').Info} Info
+ */
+
+
+/**
+ * Create an extension for `mdast-util-from-markdown` to enable GFM tables in
+ * markdown.
+ *
+ * @returns {FromMarkdownExtension}
+ *   Extension for `mdast-util-from-markdown` to enable GFM tables.
+ */
+function gfmTableFromMarkdown() {
+  return {
+    enter: {
+      table: enterTable,
+      tableData: enterCell,
+      tableHeader: enterCell,
+      tableRow: enterRow
+    },
+    exit: {
+      codeText: exitCodeText,
+      table: exitTable,
+      tableData: exit,
+      tableHeader: exit,
+      tableRow: exit
+    }
+  }
+}
+
+/**
+ * @this {CompileContext}
+ * @type {FromMarkdownHandle}
+ */
+function enterTable(token) {
+  const align = token._align;
+  this.enter(
+    {
+      type: 'table',
+      align: align.map(function (d) {
+        return d === 'none' ? null : d
+      }),
+      children: []
+    },
+    token
+  );
+  this.data.inTable = true;
+}
+
+/**
+ * @this {CompileContext}
+ * @type {FromMarkdownHandle}
+ */
+function exitTable(token) {
+  this.exit(token);
+  this.data.inTable = undefined;
+}
+
+/**
+ * @this {CompileContext}
+ * @type {FromMarkdownHandle}
+ */
+function enterRow(token) {
+  this.enter({type: 'tableRow', children: []}, token);
+}
+
+/**
+ * @this {CompileContext}
+ * @type {FromMarkdownHandle}
+ */
+function exit(token) {
+  this.exit(token);
+}
+
+/**
+ * @this {CompileContext}
+ * @type {FromMarkdownHandle}
+ */
+function enterCell(token) {
+  this.enter({type: 'tableCell', children: []}, token);
+}
+
+// Overwrite the default code text data handler to unescape escaped pipes when
+// they are in tables.
+/**
+ * @this {CompileContext}
+ * @type {FromMarkdownHandle}
+ */
+function exitCodeText(token) {
+  let value = this.resume();
+
+  if (this.data.inTable) {
+    value = value.replace(/\\([\\|])/g, replace);
+  }
+
+  const node = this.stack[this.stack.length - 1];
+  node.value = value;
+  this.exit(token);
+}
+
+/**
+ * @param {string} $0
+ * @param {string} $1
+ * @returns {string}
+ */
+function replace($0, $1) {
+  // Pipes work, backslashes don’t (but can’t escape pipes).
+  return $1 === '|' ? $1 : $0
+}
+
+/**
+ * Create an extension for `mdast-util-to-markdown` to enable GFM tables in
+ * markdown.
+ *
+ * @param {Options | null | undefined} [options]
+ *   Configuration.
+ * @returns {ToMarkdownExtension}
+ *   Extension for `mdast-util-to-markdown` to enable GFM tables.
+ */
+function gfmTableToMarkdown(options) {
+  const settings = options || {};
+  const padding = settings.tableCellPadding;
+  const alignDelimiters = settings.tablePipeAlign;
+  const stringLength = settings.stringLength;
+  const around = padding ? ' ' : '|';
+
+  return {
+    unsafe: [
+      {character: '\r', inConstruct: 'tableCell'},
+      {character: '\n', inConstruct: 'tableCell'},
+      // A pipe, when followed by a tab or space (padding), or a dash or colon
+      // (unpadded delimiter row), could result in a table.
+      {atBreak: true, character: '|', after: '[\t :-]'},
+      // A pipe in a cell must be encoded.
+      {character: '|', inConstruct: 'tableCell'},
+      // A colon must be followed by a dash, in which case it could start a
+      // delimiter row.
+      {atBreak: true, character: ':', after: '-'},
+      // A delimiter row can also start with a dash, when followed by more
+      // dashes, a colon, or a pipe.
+      // This is a stricter version than the built in check for lists, thematic
+      // breaks, and setex heading underlines though:
+      // <https://github.com/syntax-tree/mdast-util-to-markdown/blob/51a2038/lib/unsafe.js#L57>
+      {atBreak: true, character: '-', after: '[:|-]'}
+    ],
+    handlers: {
+      inlineCode: inlineCodeWithTable,
+      table: handleTable,
+      tableCell: handleTableCell,
+      tableRow: handleTableRow
+    }
+  }
+
+  /**
+   * @type {ToMarkdownHandle}
+   * @param {Table} node
+   */
+  function handleTable(node, _, state, info) {
+    return serializeData(handleTableAsData(node, state, info), node.align)
+  }
+
+  /**
+   * This function isn’t really used normally, because we handle rows at the
+   * table level.
+   * But, if someone passes in a table row, this ensures we make somewhat sense.
+   *
+   * @type {ToMarkdownHandle}
+   * @param {TableRow} node
+   */
+  function handleTableRow(node, _, state, info) {
+    const row = handleTableRowAsData(node, state, info);
+    const value = serializeData([row]);
+    // `markdown-table` will always add an align row
+    return value.slice(0, value.indexOf('\n'))
+  }
+
+  /**
+   * @type {ToMarkdownHandle}
+   * @param {TableCell} node
+   */
+  function handleTableCell(node, _, state, info) {
+    const exit = state.enter('tableCell');
+    const subexit = state.enter('phrasing');
+    const value = state.containerPhrasing(node, {
+      ...info,
+      before: around,
+      after: around
+    });
+    subexit();
+    exit();
+    return value
+  }
+
+  /**
+   * @param {Array<Array<string>>} matrix
+   * @param {Array<string | null | undefined> | null | undefined} [align]
+   */
+  function serializeData(matrix, align) {
+    return markdownTable(matrix, {
+      align,
+      // @ts-expect-error: `markdown-table` types should support `null`.
+      alignDelimiters,
+      // @ts-expect-error: `markdown-table` types should support `null`.
+      padding,
+      // @ts-expect-error: `markdown-table` types should support `null`.
+      stringLength
+    })
+  }
+
+  /**
+   * @param {Table} node
+   * @param {State} state
+   * @param {Info} info
+   */
+  function handleTableAsData(node, state, info) {
+    const children = node.children;
+    let index = -1;
+    /** @type {Array<Array<string>>} */
+    const result = [];
+    const subexit = state.enter('table');
+
+    while (++index < children.length) {
+      result[index] = handleTableRowAsData(children[index], state, info);
+    }
+
+    subexit();
+
+    return result
+  }
+
+  /**
+   * @param {TableRow} node
+   * @param {State} state
+   * @param {Info} info
+   */
+  function handleTableRowAsData(node, state, info) {
+    const children = node.children;
+    let index = -1;
+    /** @type {Array<string>} */
+    const result = [];
+    const subexit = state.enter('tableRow');
+
+    while (++index < children.length) {
+      // Note: the positional info as used here is incorrect.
+      // Making it correct would be impossible due to aligning cells?
+      // And it would need copy/pasting `markdown-table` into this project.
+      result[index] = handleTableCell(children[index], node, state, info);
+    }
+
+    subexit();
+
+    return result
+  }
+
+  /**
+   * @type {ToMarkdownHandle}
+   * @param {InlineCode} node
+   */
+  function inlineCodeWithTable(node, parent, state) {
+    let value = handle.inlineCode(node, parent, state);
+
+    if (state.stack.includes('tableCell')) {
+      value = value.replace(/\|/g, '\\$&');
+    }
+
+    return value
+  }
+}
+
 /**
  * @typedef {import('mdast').ListItem} ListItem
  * @typedef {import('mdast').Paragraph} Paragraph
@@ -22379,7 +20734,7 @@ function mark$1(values, key, value) {
  */
 
 
-const own$6 = {}.hasOwnProperty;
+const own$4 = {}.hasOwnProperty;
 
 /**
  * @param {Definition} definition
@@ -22394,7 +20749,7 @@ function create$1(definition) {
   let prop;
 
   for (prop in definition.properties) {
-    if (own$6.call(definition.properties, prop)) {
+    if (own$4.call(definition.properties, prop)) {
       const value = definition.properties[prop];
       const info = new DefinedInfo$1(
         prop,
@@ -23629,7 +21984,7 @@ function parse$1(value) {
 
 const buttonTypes = new Set(['button', 'menu', 'reset', 'submit']);
 
-const own$5 = {}.hasOwnProperty;
+const own$3 = {}.hasOwnProperty;
 
 /**
  * @param {Schema} schema
@@ -23686,7 +22041,7 @@ function createH(schema, defaultTagName, caseSensitive) {
       node = parseSelector(selector, defaultTagName);
       // Normalize the name.
       node.tagName = node.tagName.toLowerCase();
-      if (adjust && own$5.call(adjust, node.tagName)) {
+      if (adjust && own$3.call(adjust, node.tagName)) {
         node.tagName = adjust[node.tagName];
       }
 
@@ -23696,7 +22051,7 @@ function createH(schema, defaultTagName, caseSensitive) {
         let key;
 
         for (key in properties) {
-          if (own$5.call(properties, key)) {
+          if (own$3.call(properties, key)) {
             addProperty(schema, node.properties, key, properties[key]);
           }
         }
@@ -23901,7 +22256,7 @@ function style(value) {
   let key;
 
   for (key in value) {
-    if (own$5.call(value, key)) {
+    if (own$3.call(value, key)) {
       result.push([key, value[key]].join(': '));
     }
   }
@@ -24140,7 +22495,7 @@ const webNamespaces$1 = {
  */
 
 
-const own$4 = {}.hasOwnProperty;
+const own$2 = {}.hasOwnProperty;
 /** @type {unknown} */
 // type-coverage:ignore-next-line
 const proto = Object.prototype;
@@ -24287,7 +22642,7 @@ function element$2(state, node) {
     const attribute = node.attrs[index];
     const name =
       (attribute.prefix ? attribute.prefix + ':' : '') + attribute.name;
-    if (!own$4.call(proto, name)) {
+    if (!own$2.call(proto, name)) {
       props[name] = attribute.value;
     }
   }
@@ -24380,7 +22735,7 @@ function createLocation(state, node, location) {
 
       if (location.attrs) {
         for (key in location.attrs) {
-          if (own$4.call(location.attrs, key)) {
+          if (own$2.call(location.attrs, key)) {
             props[find$1(state.schema, key).property] = position(
               location.attrs[key]
             );
@@ -24644,7 +22999,7 @@ function mark(values, key, value) {
  */
 
 
-const own$3 = {}.hasOwnProperty;
+const own$1 = {}.hasOwnProperty;
 
 /**
  * @param {Definition} definition
@@ -24659,7 +23014,7 @@ function create(definition) {
   let prop;
 
   for (prop in definition.properties) {
-    if (own$3.call(definition.properties, prop)) {
+    if (own$1.call(definition.properties, prop)) {
       const value = definition.properties[prop];
       const info = new DefinedInfo(
         prop,
@@ -25765,125 +24120,6 @@ const webNamespaces = {
   xmlns: 'http://www.w3.org/2000/xmlns/'
 };
 
-/**
- * @callback Handler
- *   Handle a value, with a certain ID field set to a certain value.
- *   The ID field is passed to `zwitch`, and it’s value is this function’s
- *   place on the `handlers` record.
- * @param {...any} parameters
- *   Arbitrary parameters passed to the zwitch.
- *   The first will be an object with a certain ID field set to a certain value.
- * @returns {any}
- *   Anything!
- */
-
-/**
- * @callback UnknownHandler
- *   Handle values that do have a certain ID field, but it’s set to a value
- *   that is not listed in the `handlers` record.
- * @param {unknown} value
- *   An object with a certain ID field set to an unknown value.
- * @param {...any} rest
- *   Arbitrary parameters passed to the zwitch.
- * @returns {any}
- *   Anything!
- */
-
-/**
- * @callback InvalidHandler
- *   Handle values that do not have a certain ID field.
- * @param {unknown} value
- *   Any unknown value.
- * @param {...any} rest
- *   Arbitrary parameters passed to the zwitch.
- * @returns {void|null|undefined|never}
- *   This should crash or return nothing.
- */
-
-/**
- * @template {InvalidHandler} [Invalid=InvalidHandler]
- * @template {UnknownHandler} [Unknown=UnknownHandler]
- * @template {Record<string, Handler>} [Handlers=Record<string, Handler>]
- * @typedef Options
- *   Configuration (required).
- * @property {Invalid} [invalid]
- *   Handler to use for invalid values.
- * @property {Unknown} [unknown]
- *   Handler to use for unknown values.
- * @property {Handlers} [handlers]
- *   Handlers to use.
- */
-
-const own$2 = {}.hasOwnProperty;
-
-/**
- * Handle values based on a field.
- *
- * @template {InvalidHandler} [Invalid=InvalidHandler]
- * @template {UnknownHandler} [Unknown=UnknownHandler]
- * @template {Record<string, Handler>} [Handlers=Record<string, Handler>]
- * @param {string} key
- *   Field to switch on.
- * @param {Options<Invalid, Unknown, Handlers>} [options]
- *   Configuration (required).
- * @returns {{unknown: Unknown, invalid: Invalid, handlers: Handlers, (...parameters: Parameters<Handlers[keyof Handlers]>): ReturnType<Handlers[keyof Handlers]>, (...parameters: Parameters<Unknown>): ReturnType<Unknown>}}
- */
-function zwitch$1(key, options) {
-  const settings = options || {};
-
-  /**
-   * Handle one value.
-   *
-   * Based on the bound `key`, a respective handler will be called.
-   * If `value` is not an object, or doesn’t have a `key` property, the special
-   * “invalid” handler will be called.
-   * If `value` has an unknown `key`, the special “unknown” handler will be
-   * called.
-   *
-   * All arguments, and the context object, are passed through to the handler,
-   * and it’s result is returned.
-   *
-   * @this {unknown}
-   *   Any context object.
-   * @param {unknown} [value]
-   *   Any value.
-   * @param {...unknown} parameters
-   *   Arbitrary parameters passed to the zwitch.
-   * @property {Handler} invalid
-   *   Handle for values that do not have a certain ID field.
-   * @property {Handler} unknown
-   *   Handle values that do have a certain ID field, but it’s set to a value
-   *   that is not listed in the `handlers` record.
-   * @property {Handlers} handlers
-   *   Record of handlers.
-   * @returns {unknown}
-   *   Anything.
-   */
-  function one(value, ...parameters) {
-    /** @type {Handler|undefined} */
-    let fn = one.invalid;
-    const handlers = one.handlers;
-
-    if (value && own$2.call(value, key)) {
-      // @ts-expect-error Indexable.
-      const id = String(value[key]);
-      // @ts-expect-error Indexable.
-      fn = own$2.call(handlers, id) ? handlers[id] : one.unknown;
-    }
-
-    if (fn) {
-      return fn.call(this, value, ...parameters)
-    }
-  }
-
-  one.handlers = settings.handlers || {};
-  one.invalid = settings.invalid;
-  one.unknown = settings.unknown;
-
-  // @ts-expect-error: matches!
-  return one
-}
-
 /**
  * @typedef {import('hast').Comment} Comment
  * @typedef {import('hast').Doctype} Doctype
@@ -25910,9 +24146,9 @@ function zwitch$1(key, options) {
 /** @type {Options} */
 const emptyOptions = {};
 
-const own$1 = {}.hasOwnProperty;
+const own = {}.hasOwnProperty;
 
-const one = zwitch$1('type', {handlers: {root: root$1, element: element$1, text: text$1, comment: comment$1, doctype: doctype$1}});
+const one = 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.
@@ -26050,7 +24286,7 @@ function element$1(node, schema) {
 
   if (node.properties) {
     for (prop in node.properties) {
-      if (prop !== 'children' && own$1.call(node.properties, prop)) {
+      if (prop !== 'children' && own.call(node.properties, prop)) {
         const result = createProperty(
           currentSchema,
           prop,
@@ -34136,125 +32372,6 @@ function point(type) {
   }
 }
 
-/**
- * @callback Handler
- *   Handle a value, with a certain ID field set to a certain value.
- *   The ID field is passed to `zwitch`, and it’s value is this function’s
- *   place on the `handlers` record.
- * @param {...any} parameters
- *   Arbitrary parameters passed to the zwitch.
- *   The first will be an object with a certain ID field set to a certain value.
- * @returns {any}
- *   Anything!
- */
-
-/**
- * @callback UnknownHandler
- *   Handle values that do have a certain ID field, but it’s set to a value
- *   that is not listed in the `handlers` record.
- * @param {unknown} value
- *   An object with a certain ID field set to an unknown value.
- * @param {...any} rest
- *   Arbitrary parameters passed to the zwitch.
- * @returns {any}
- *   Anything!
- */
-
-/**
- * @callback InvalidHandler
- *   Handle values that do not have a certain ID field.
- * @param {unknown} value
- *   Any unknown value.
- * @param {...any} rest
- *   Arbitrary parameters passed to the zwitch.
- * @returns {void|null|undefined|never}
- *   This should crash or return nothing.
- */
-
-/**
- * @template {InvalidHandler} [Invalid=InvalidHandler]
- * @template {UnknownHandler} [Unknown=UnknownHandler]
- * @template {Record<string, Handler>} [Handlers=Record<string, Handler>]
- * @typedef Options
- *   Configuration (required).
- * @property {Invalid} [invalid]
- *   Handler to use for invalid values.
- * @property {Unknown} [unknown]
- *   Handler to use for unknown values.
- * @property {Handlers} [handlers]
- *   Handlers to use.
- */
-
-const own = {}.hasOwnProperty;
-
-/**
- * Handle values based on a field.
- *
- * @template {InvalidHandler} [Invalid=InvalidHandler]
- * @template {UnknownHandler} [Unknown=UnknownHandler]
- * @template {Record<string, Handler>} [Handlers=Record<string, Handler>]
- * @param {string} key
- *   Field to switch on.
- * @param {Options<Invalid, Unknown, Handlers>} [options]
- *   Configuration (required).
- * @returns {{unknown: Unknown, invalid: Invalid, handlers: Handlers, (...parameters: Parameters<Handlers[keyof Handlers]>): ReturnType<Handlers[keyof Handlers]>, (...parameters: Parameters<Unknown>): ReturnType<Unknown>}}
- */
-function zwitch(key, options) {
-  const settings = options || {};
-
-  /**
-   * Handle one value.
-   *
-   * Based on the bound `key`, a respective handler will be called.
-   * If `value` is not an object, or doesn’t have a `key` property, the special
-   * “invalid” handler will be called.
-   * If `value` has an unknown `key`, the special “unknown” handler will be
-   * called.
-   *
-   * All arguments, and the context object, are passed through to the handler,
-   * and it’s result is returned.
-   *
-   * @this {unknown}
-   *   Any context object.
-   * @param {unknown} [value]
-   *   Any value.
-   * @param {...unknown} parameters
-   *   Arbitrary parameters passed to the zwitch.
-   * @property {Handler} invalid
-   *   Handle for values that do not have a certain ID field.
-   * @property {Handler} unknown
-   *   Handle values that do have a certain ID field, but it’s set to a value
-   *   that is not listed in the `handlers` record.
-   * @property {Handlers} handlers
-   *   Record of handlers.
-   * @returns {unknown}
-   *   Anything.
-   */
-  function one(value, ...parameters) {
-    /** @type {Handler|undefined} */
-    let fn = one.invalid;
-    const handlers = one.handlers;
-
-    if (value && own.call(value, key)) {
-      // @ts-expect-error Indexable.
-      const id = String(value[key]);
-      // @ts-expect-error Indexable.
-      fn = own.call(handlers, id) ? handlers[id] : one.unknown;
-    }
-
-    if (fn) {
-      return fn.call(this, value, ...parameters)
-    }
-  }
-
-  one.handlers = settings.handlers || {};
-  one.invalid = settings.invalid;
-  one.unknown = settings.unknown;
-
-  // @ts-expect-error: matches!
-  return one
-}
-
 /**
  * @typedef {import('hast').Comment} Comment
  * @typedef {import('hast').Doctype} Doctype