ember-repl 6.0.0 → 7.0.0

package/dist/index-C8S2G0FH.js

@@ -0,0 +1,1953 @@
+import { p as pointStart, a as pointEnd, s as structuredClone, b as position } from './index-DP_Su7Zc.js';
+import { b as asciiAlphanumeric } from './index-ZyJlPFQY.js';
+import { v as visit } from './index-CCcIVEUK.js';
+
+/**
+ * Normalize a URL.
+ *
+ * Encode unsafe characters with percent-encoding, skipping already encoded
+ * sequences.
+ *
+ * @param {string} value
+ *   URI to normalize.
+ * @returns {string}
+ *   Normalized URI.
+ */
+function normalizeUri(value) {
+  /** @type {Array<string>} */
+  const result = [];
+  let index = -1;
+  let start = 0;
+  let skip = 0;
+  while (++index < value.length) {
+    const code = value.charCodeAt(index);
+    /** @type {string} */
+    let replace = '';
+
+    // A correct percent encoded value.
+    if (code === 37 && asciiAlphanumeric(value.charCodeAt(index + 1)) && asciiAlphanumeric(value.charCodeAt(index + 2))) {
+      skip = 2;
+    }
+    // ASCII.
+    else if (code < 128) {
+      if (!/[!#$&-;=?-Z_a-z~]/.test(String.fromCharCode(code))) {
+        replace = String.fromCharCode(code);
+      }
+    }
+    // Astral.
+    else if (code > 55_295 && code < 57_344) {
+      const next = value.charCodeAt(index + 1);
+
+      // A correct surrogate pair.
+      if (code < 56_320 && next > 56_319 && next < 57_344) {
+        replace = String.fromCharCode(code, next);
+        skip = 1;
+      }
+      // Lone surrogate.
+      else {
+        replace = "\uFFFD";
+      }
+    }
+    // Unicode.
+    else {
+      replace = String.fromCharCode(code);
+    }
+    if (replace) {
+      result.push(value.slice(start, index), encodeURIComponent(replace));
+      start = index + skip + 1;
+      replace = '';
+    }
+    if (skip) {
+      index += skip;
+      skip = 0;
+    }
+  }
+  return result.join('') + value.slice(start);
+}
+
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').Blockquote} Blockquote
+ * @typedef {import('../state.js').State} State
+ */
+
+
+/**
+ * Turn an mdast `blockquote` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Blockquote} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+function blockquote(state, node) {
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'blockquote',
+    properties: {},
+    children: state.wrap(state.all(node), true)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').Text} Text
+ * @typedef {import('mdast').Break} Break
+ * @typedef {import('../state.js').State} State
+ */
+
+
+/**
+ * Turn an mdast `break` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Break} node
+ *   mdast node.
+ * @returns {Array<Element | Text>}
+ *   hast element content.
+ */
+function hardBreak(state, node) {
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'br',
+    properties: {},
+    children: []
+  };
+  state.patch(node, result);
+  return [state.applyData(node, result), {
+    type: 'text',
+    value: '\n'
+  }];
+}
+
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').Properties} Properties
+ * @typedef {import('mdast').Code} Code
+ * @typedef {import('../state.js').State} State
+ */
+
+
+/**
+ * Turn an mdast `code` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Code} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+function code(state, node) {
+  const value = node.value ? node.value + '\n' : '';
+  /** @type {Properties} */
+  const properties = {};
+  if (node.lang) {
+    properties.className = ['language-' + node.lang];
+  }
+
+  // Create `<code>`.
+  /** @type {Element} */
+  let result = {
+    type: 'element',
+    tagName: 'code',
+    properties,
+    children: [{
+      type: 'text',
+      value
+    }]
+  };
+  if (node.meta) {
+    result.data = {
+      meta: node.meta
+    };
+  }
+  state.patch(node, result);
+  result = state.applyData(node, result);
+
+  // Create `<pre>`.
+  result = {
+    type: 'element',
+    tagName: 'pre',
+    properties: {},
+    children: [result]
+  };
+  state.patch(node, result);
+  return result;
+}
+
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').Delete} Delete
+ * @typedef {import('../state.js').State} State
+ */
+
+
+/**
+ * Turn an mdast `delete` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Delete} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+function strikethrough(state, node) {
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'del',
+    properties: {},
+    children: state.all(node)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').Emphasis} Emphasis
+ * @typedef {import('../state.js').State} State
+ */
+
+
+/**
+ * Turn an mdast `emphasis` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Emphasis} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+function emphasis(state, node) {
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'em',
+    properties: {},
+    children: state.all(node)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').FootnoteReference} FootnoteReference
+ * @typedef {import('../state.js').State} State
+ */
+
+
+/**
+ * Turn an mdast `footnoteReference` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {FootnoteReference} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+function footnoteReference(state, node) {
+  const clobberPrefix = typeof state.options.clobberPrefix === 'string' ? state.options.clobberPrefix : 'user-content-';
+  const id = String(node.identifier).toUpperCase();
+  const safeId = normalizeUri(id.toLowerCase());
+  const index = state.footnoteOrder.indexOf(id);
+  /** @type {number} */
+  let counter;
+  let reuseCounter = state.footnoteCounts.get(id);
+  if (reuseCounter === undefined) {
+    reuseCounter = 0;
+    state.footnoteOrder.push(id);
+    counter = state.footnoteOrder.length;
+  } else {
+    counter = index + 1;
+  }
+  reuseCounter += 1;
+  state.footnoteCounts.set(id, reuseCounter);
+
+  /** @type {Element} */
+  const link = {
+    type: 'element',
+    tagName: 'a',
+    properties: {
+      href: '#' + clobberPrefix + 'fn-' + safeId,
+      id: clobberPrefix + 'fnref-' + safeId + (reuseCounter > 1 ? '-' + reuseCounter : ''),
+      dataFootnoteRef: true,
+      ariaDescribedBy: ['footnote-label']
+    },
+    children: [{
+      type: 'text',
+      value: String(counter)
+    }]
+  };
+  state.patch(node, link);
+
+  /** @type {Element} */
+  const sup = {
+    type: 'element',
+    tagName: 'sup',
+    properties: {},
+    children: [link]
+  };
+  state.patch(node, sup);
+  return state.applyData(node, sup);
+}
+
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').Heading} Heading
+ * @typedef {import('../state.js').State} State
+ */
+
+
+/**
+ * Turn an mdast `heading` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Heading} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+function heading(state, node) {
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'h' + node.depth,
+    properties: {},
+    children: state.all(node)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').Html} Html
+ * @typedef {import('../state.js').State} State
+ * @typedef {import('../../index.js').Raw} Raw
+ */
+
+
+/**
+ * Turn an mdast `html` node into hast (`raw` node in dangerous mode, otherwise
+ * nothing).
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Html} node
+ *   mdast node.
+ * @returns {Element | Raw | undefined}
+ *   hast node.
+ */
+function html(state, node) {
+  if (state.options.allowDangerousHtml) {
+    /** @type {Raw} */
+    const result = {
+      type: 'raw',
+      value: node.value
+    };
+    state.patch(node, result);
+    return state.applyData(node, result);
+  }
+  return undefined;
+}
+
+/**
+ * @typedef {import('hast').ElementContent} ElementContent
+ *
+ * @typedef {import('mdast').Nodes} Nodes
+ * @typedef {import('mdast').Reference} Reference
+ *
+ * @typedef {import('./state.js').State} State
+ */
+
+
+/**
+ * Return the content of a reference without definition as plain text.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Extract<Nodes, Reference>} node
+ *   Reference node (image, link).
+ * @returns {Array<ElementContent>}
+ *   hast content.
+ */
+function revert(state, node) {
+  const subtype = node.referenceType;
+  let suffix = ']';
+  if (subtype === 'collapsed') {
+    suffix += '[]';
+  } else if (subtype === 'full') {
+    suffix += '[' + (node.label || node.identifier) + ']';
+  }
+  if (node.type === 'imageReference') {
+    return [{
+      type: 'text',
+      value: '![' + node.alt + suffix
+    }];
+  }
+  const contents = state.all(node);
+  const head = contents[0];
+  if (head && head.type === 'text') {
+    head.value = '[' + head.value;
+  } else {
+    contents.unshift({
+      type: 'text',
+      value: '['
+    });
+  }
+  const tail = contents[contents.length - 1];
+  if (tail && tail.type === 'text') {
+    tail.value += suffix;
+  } else {
+    contents.push({
+      type: 'text',
+      value: suffix
+    });
+  }
+  return contents;
+}
+
+/**
+ * @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
+ */
+
+
+/**
+ * Turn an mdast `imageReference` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {ImageReference} node
+ *   mdast node.
+ * @returns {Array<ElementContent> | ElementContent}
+ *   hast node.
+ */
+function imageReference(state, node) {
+  const id = String(node.identifier).toUpperCase();
+  const definition = state.definitionById.get(id);
+  if (!definition) {
+    return revert(state, node);
+  }
+
+  /** @type {Properties} */
+  const properties = {
+    src: normalizeUri(definition.url || ''),
+    alt: node.alt
+  };
+  if (definition.title !== null && definition.title !== undefined) {
+    properties.title = definition.title;
+  }
+
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'img',
+    properties,
+    children: []
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').Properties} Properties
+ * @typedef {import('mdast').Image} Image
+ * @typedef {import('../state.js').State} State
+ */
+
+
+/**
+ * Turn an mdast `image` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Image} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+function image(state, node) {
+  /** @type {Properties} */
+  const properties = {
+    src: normalizeUri(node.url)
+  };
+  if (node.alt !== null && node.alt !== undefined) {
+    properties.alt = node.alt;
+  }
+  if (node.title !== null && node.title !== undefined) {
+    properties.title = node.title;
+  }
+
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'img',
+    properties,
+    children: []
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').Text} Text
+ * @typedef {import('mdast').InlineCode} InlineCode
+ * @typedef {import('../state.js').State} State
+ */
+
+
+/**
+ * Turn an mdast `inlineCode` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {InlineCode} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+function inlineCode(state, node) {
+  /** @type {Text} */
+  const text = {
+    type: 'text',
+    value: node.value.replace(/\r?\n|\r/g, ' ')
+  };
+  state.patch(node, text);
+
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'code',
+    properties: {},
+    children: [text]
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+
+/**
+ * @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
+ */
+
+
+/**
+ * Turn an mdast `linkReference` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {LinkReference} node
+ *   mdast node.
+ * @returns {Array<ElementContent> | ElementContent}
+ *   hast node.
+ */
+function linkReference(state, node) {
+  const id = String(node.identifier).toUpperCase();
+  const definition = state.definitionById.get(id);
+  if (!definition) {
+    return revert(state, node);
+  }
+
+  /** @type {Properties} */
+  const properties = {
+    href: normalizeUri(definition.url || '')
+  };
+  if (definition.title !== null && definition.title !== undefined) {
+    properties.title = definition.title;
+  }
+
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'a',
+    properties,
+    children: state.all(node)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').Properties} Properties
+ * @typedef {import('mdast').Link} Link
+ * @typedef {import('../state.js').State} State
+ */
+
+
+/**
+ * Turn an mdast `link` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Link} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+function link(state, node) {
+  /** @type {Properties} */
+  const properties = {
+    href: normalizeUri(node.url)
+  };
+  if (node.title !== null && node.title !== undefined) {
+    properties.title = node.title;
+  }
+
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'a',
+    properties,
+    children: state.all(node)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+
+/**
+ * @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
+ */
+
+
+/**
+ * Turn an mdast `listItem` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {ListItem} node
+ *   mdast node.
+ * @param {Parents | undefined} parent
+ *   Parent of `node`.
+ * @returns {Element}
+ *   hast node.
+ */
+function listItem(state, node, parent) {
+  const results = state.all(node);
+  const loose = parent ? listLoose(parent) : listItemLoose(node);
+  /** @type {Properties} */
+  const properties = {};
+  /** @type {Array<ElementContent>} */
+  const children = [];
+  if (typeof node.checked === 'boolean') {
+    const head = results[0];
+    /** @type {Element} */
+    let paragraph;
+    if (head && head.type === 'element' && head.tagName === 'p') {
+      paragraph = head;
+    } else {
+      paragraph = {
+        type: 'element',
+        tagName: 'p',
+        properties: {},
+        children: []
+      };
+      results.unshift(paragraph);
+    }
+    if (paragraph.children.length > 0) {
+      paragraph.children.unshift({
+        type: 'text',
+        value: ' '
+      });
+    }
+    paragraph.children.unshift({
+      type: 'element',
+      tagName: 'input',
+      properties: {
+        type: 'checkbox',
+        checked: node.checked,
+        disabled: true
+      },
+      children: []
+    });
+
+    // According to github-markdown-css, this class hides bullet.
+    // See: <https://github.com/sindresorhus/github-markdown-css>.
+    properties.className = ['task-list-item'];
+  }
+  let index = -1;
+  while (++index < results.length) {
+    const child = results[index];
+
+    // Add eols before nodes, except if this is a loose, first paragraph.
+    if (loose || index !== 0 || child.type !== 'element' || child.tagName !== 'p') {
+      children.push({
+        type: 'text',
+        value: '\n'
+      });
+    }
+    if (child.type === 'element' && child.tagName === 'p' && !loose) {
+      children.push(...child.children);
+    } else {
+      children.push(child);
+    }
+  }
+  const tail = results[results.length - 1];
+
+  // Add a final eol.
+  if (tail && (loose || tail.type !== 'element' || tail.tagName !== 'p')) {
+    children.push({
+      type: 'text',
+      value: '\n'
+    });
+  }
+
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'li',
+    properties,
+    children
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+
+/**
+ * @param {Parents} node
+ * @return {Boolean}
+ */
+function listLoose(node) {
+  let loose = false;
+  if (node.type === 'list') {
+    loose = node.spread || false;
+    const children = node.children;
+    let index = -1;
+    while (!loose && ++index < children.length) {
+      loose = listItemLoose(children[index]);
+    }
+  }
+  return loose;
+}
+
+/**
+ * @param {ListItem} node
+ * @return {Boolean}
+ */
+function listItemLoose(node) {
+  const spread = node.spread;
+  return spread === null || spread === undefined ? node.children.length > 1 : spread;
+}
+
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').Properties} Properties
+ * @typedef {import('mdast').List} List
+ * @typedef {import('../state.js').State} State
+ */
+
+
+/**
+ * Turn an mdast `list` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {List} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+function list(state, node) {
+  /** @type {Properties} */
+  const properties = {};
+  const results = state.all(node);
+  let index = -1;
+  if (typeof node.start === 'number' && node.start !== 1) {
+    properties.start = node.start;
+  }
+
+  // Like GitHub, add a class for custom styling.
+  while (++index < results.length) {
+    const child = results[index];
+    if (child.type === 'element' && child.tagName === 'li' && child.properties && Array.isArray(child.properties.className) && child.properties.className.includes('task-list-item')) {
+      properties.className = ['contains-task-list'];
+      break;
+    }
+  }
+
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: node.ordered ? 'ol' : 'ul',
+    properties,
+    children: state.wrap(results, true)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').Paragraph} Paragraph
+ * @typedef {import('../state.js').State} State
+ */
+
+
+/**
+ * Turn an mdast `paragraph` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Paragraph} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+function paragraph(state, node) {
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'p',
+    properties: {},
+    children: state.all(node)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+
+/**
+ * @typedef {import('hast').Parents} HastParents
+ * @typedef {import('hast').Root} HastRoot
+ * @typedef {import('mdast').Root} MdastRoot
+ * @typedef {import('../state.js').State} State
+ */
+
+
+/**
+ * Turn an mdast `root` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {MdastRoot} node
+ *   mdast node.
+ * @returns {HastParents}
+ *   hast node.
+ */
+function root(state, node) {
+  /** @type {HastRoot} */
+  const result = {
+    type: 'root',
+    children: state.wrap(state.all(node))
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').Strong} Strong
+ * @typedef {import('../state.js').State} State
+ */
+
+
+/**
+ * Turn an mdast `strong` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Strong} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+function strong(state, node) {
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'strong',
+    properties: {},
+    children: state.all(node)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').Table} Table
+ * @typedef {import('../state.js').State} State
+ */
+
+
+/**
+ * Turn an mdast `table` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Table} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+function table(state, node) {
+  const rows = state.all(node);
+  const firstRow = rows.shift();
+  /** @type {Array<Element>} */
+  const tableContent = [];
+  if (firstRow) {
+    /** @type {Element} */
+    const head = {
+      type: 'element',
+      tagName: 'thead',
+      properties: {},
+      children: state.wrap([firstRow], true)
+    };
+    state.patch(node.children[0], head);
+    tableContent.push(head);
+  }
+  if (rows.length > 0) {
+    /** @type {Element} */
+    const body = {
+      type: 'element',
+      tagName: 'tbody',
+      properties: {},
+      children: state.wrap(rows, true)
+    };
+    const start = pointStart(node.children[1]);
+    const end = pointEnd(node.children[node.children.length - 1]);
+    if (start && end) body.position = {
+      start,
+      end
+    };
+    tableContent.push(body);
+  }
+
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'table',
+    properties: {},
+    children: state.wrap(tableContent, true)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+
+/**
+ * @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
+ */
+
+
+/**
+ * Turn an mdast `tableRow` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {TableRow} node
+ *   mdast node.
+ * @param {Parents | undefined} parent
+ *   Parent of `node`.
+ * @returns {Element}
+ *   hast node.
+ */
+function tableRow(state, node, parent) {
+  const siblings = parent ? parent.children : undefined;
+  // Generate a body row when without parent.
+  const rowIndex = siblings ? siblings.indexOf(node) : 1;
+  const tagName = rowIndex === 0 ? 'th' : 'td';
+  // To do: option to use `style`?
+  const align = parent && parent.type === 'table' ? parent.align : undefined;
+  const length = align ? align.length : node.children.length;
+  let cellIndex = -1;
+  /** @type {Array<ElementContent>} */
+  const cells = [];
+  while (++cellIndex < length) {
+    // Note: can also be undefined.
+    const cell = node.children[cellIndex];
+    /** @type {Properties} */
+    const properties = {};
+    const alignValue = align ? align[cellIndex] : undefined;
+    if (alignValue) {
+      properties.align = alignValue;
+    }
+
+    /** @type {Element} */
+    let result = {
+      type: 'element',
+      tagName,
+      properties,
+      children: []
+    };
+    if (cell) {
+      result.children = state.all(cell);
+      state.patch(cell, result);
+      result = state.applyData(cell, result);
+    }
+    cells.push(result);
+  }
+
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'tr',
+    properties: {},
+    children: state.wrap(cells, true)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').TableCell} TableCell
+ * @typedef {import('../state.js').State} State
+ */
+
+
+/**
+ * Turn an mdast `tableCell` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {TableCell} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+function tableCell(state, node) {
+  // Note: this function is normally not called: see `table-row` for how rows
+  // and their cells are compiled.
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'td',
+    // Assume body cell.
+    properties: {},
+    children: state.all(node)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+
+const tab = 9; /* `\t` */
+const space = 32; /* ` ` */
+
+/**
+ * Remove initial and final spaces and tabs at the line breaks in `value`.
+ * Does not trim initial and final spaces and tabs of the value itself.
+ *
+ * @param {string} value
+ *   Value to trim.
+ * @returns {string}
+ *   Trimmed value.
+ */
+function trimLines(value) {
+  const source = String(value);
+  const search = /\r?\n|\r/g;
+  let match = search.exec(source);
+  let last = 0;
+  /** @type {Array<string>} */
+  const lines = [];
+  while (match) {
+    lines.push(trimLine(source.slice(last, match.index), last > 0, true), match[0]);
+    last = match.index + match[0].length;
+    match = search.exec(source);
+  }
+  lines.push(trimLine(source.slice(last), last > 0, false));
+  return lines.join('');
+}
+
+/**
+ * @param {string} value
+ *   Line to trim.
+ * @param {boolean} start
+ *   Whether to trim the start of the line.
+ * @param {boolean} end
+ *   Whether to trim the end of the line.
+ * @returns {string}
+ *   Trimmed line.
+ */
+function trimLine(value, start, end) {
+  let startIndex = 0;
+  let endIndex = value.length;
+  if (start) {
+    let code = value.codePointAt(startIndex);
+    while (code === tab || code === space) {
+      startIndex++;
+      code = value.codePointAt(startIndex);
+    }
+  }
+  if (end) {
+    let code = value.codePointAt(endIndex - 1);
+    while (code === tab || code === space) {
+      endIndex--;
+      code = value.codePointAt(endIndex - 1);
+    }
+  }
+  return endIndex > startIndex ? value.slice(startIndex, endIndex) : '';
+}
+
+/**
+ * @typedef {import('hast').Element} HastElement
+ * @typedef {import('hast').Text} HastText
+ * @typedef {import('mdast').Text} MdastText
+ * @typedef {import('../state.js').State} State
+ */
+
+
+/**
+ * Turn an mdast `text` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {MdastText} node
+ *   mdast node.
+ * @returns {HastElement | HastText}
+ *   hast node.
+ */
+function text(state, node) {
+  /** @type {HastText} */
+  const result = {
+    type: 'text',
+    value: trimLines(String(node.value))
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').ThematicBreak} ThematicBreak
+ * @typedef {import('../state.js').State} State
+ */
+
+
+/**
+ * Turn an mdast `thematicBreak` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {ThematicBreak} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+function thematicBreak(state, node) {
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'hr',
+    properties: {},
+    children: []
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+
+/**
+ * Default handlers for nodes.
+ *
+ * @satisfies {import('../state.js').Handlers}
+ */
+const handlers = {
+  blockquote,
+  break: hardBreak,
+  code,
+  delete: strikethrough,
+  emphasis,
+  footnoteReference,
+  heading,
+  html,
+  imageReference,
+  image,
+  inlineCode,
+  linkReference,
+  link,
+  listItem,
+  list,
+  paragraph,
+  // @ts-expect-error: root is different, but hard to type.
+  root,
+  strong,
+  table,
+  tableCell,
+  tableRow,
+  text,
+  thematicBreak,
+  toml: ignore,
+  yaml: ignore,
+  definition: ignore,
+  footnoteDefinition: ignore
+};
+
+// Return nothing for nodes that are ignored.
+function ignore() {
+  return undefined;
+}
+
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').ElementContent} ElementContent
+ *
+ * @typedef {import('./state.js').State} State
+ */
+
+
+/**
+ * Generate the default content that GitHub uses on backreferences.
+ *
+ * @param {number} _
+ *   Index of the definition in the order that they are first referenced,
+ *   0-indexed.
+ * @param {number} rereferenceIndex
+ *   Index of calls to the same definition, 0-indexed.
+ * @returns {Array<ElementContent>}
+ *   Content.
+ */
+function defaultFootnoteBackContent(_, rereferenceIndex) {
+  /** @type {Array<ElementContent>} */
+  const result = [{
+    type: 'text',
+    value: '↩'
+  }];
+  if (rereferenceIndex > 1) {
+    result.push({
+      type: 'element',
+      tagName: 'sup',
+      properties: {},
+      children: [{
+        type: 'text',
+        value: String(rereferenceIndex)
+      }]
+    });
+  }
+  return result;
+}
+
+/**
+ * Generate the default label that GitHub uses on backreferences.
+ *
+ * @param {number} referenceIndex
+ *   Index of the definition in the order that they are first referenced,
+ *   0-indexed.
+ * @param {number} rereferenceIndex
+ *   Index of calls to the same definition, 0-indexed.
+ * @returns {string}
+ *   Label.
+ */
+function defaultFootnoteBackLabel(referenceIndex, rereferenceIndex) {
+  return 'Back to reference ' + (referenceIndex + 1) + (rereferenceIndex > 1 ? '-' + rereferenceIndex : '');
+}
+
+/**
+ * Generate a hast footer for called footnote definitions.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @returns {Element | undefined}
+ *   `section` element or `undefined`.
+ */
+// eslint-disable-next-line complexity
+function footer(state) {
+  const clobberPrefix = typeof state.options.clobberPrefix === 'string' ? state.options.clobberPrefix : 'user-content-';
+  const footnoteBackContent = state.options.footnoteBackContent || defaultFootnoteBackContent;
+  const footnoteBackLabel = state.options.footnoteBackLabel || defaultFootnoteBackLabel;
+  const footnoteLabel = state.options.footnoteLabel || 'Footnotes';
+  const footnoteLabelTagName = state.options.footnoteLabelTagName || 'h2';
+  const footnoteLabelProperties = state.options.footnoteLabelProperties || {
+    className: ['sr-only']
+  };
+  /** @type {Array<ElementContent>} */
+  const listItems = [];
+  let referenceIndex = -1;
+  while (++referenceIndex < state.footnoteOrder.length) {
+    const definition = state.footnoteById.get(state.footnoteOrder[referenceIndex]);
+    if (!definition) {
+      continue;
+    }
+    const content = state.all(definition);
+    const id = String(definition.identifier).toUpperCase();
+    const safeId = normalizeUri(id.toLowerCase());
+    let rereferenceIndex = 0;
+    /** @type {Array<ElementContent>} */
+    const backReferences = [];
+    const counts = state.footnoteCounts.get(id);
+
+    // eslint-disable-next-line no-unmodified-loop-condition
+    while (counts !== undefined && ++rereferenceIndex <= counts) {
+      if (backReferences.length > 0) {
+        backReferences.push({
+          type: 'text',
+          value: ' '
+        });
+      }
+      let children = typeof footnoteBackContent === 'string' ? footnoteBackContent : footnoteBackContent(referenceIndex, rereferenceIndex);
+      if (typeof children === 'string') {
+        children = {
+          type: 'text',
+          value: children
+        };
+      }
+      backReferences.push({
+        type: 'element',
+        tagName: 'a',
+        properties: {
+          href: '#' + clobberPrefix + 'fnref-' + safeId + (rereferenceIndex > 1 ? '-' + rereferenceIndex : ''),
+          dataFootnoteBackref: '',
+          ariaLabel: typeof footnoteBackLabel === 'string' ? footnoteBackLabel : footnoteBackLabel(referenceIndex, rereferenceIndex),
+          className: ['data-footnote-backref']
+        },
+        children: Array.isArray(children) ? children : [children]
+      });
+    }
+    const tail = content[content.length - 1];
+    if (tail && tail.type === 'element' && tail.tagName === 'p') {
+      const tailTail = tail.children[tail.children.length - 1];
+      if (tailTail && tailTail.type === 'text') {
+        tailTail.value += ' ';
+      } else {
+        tail.children.push({
+          type: 'text',
+          value: ' '
+        });
+      }
+      tail.children.push(...backReferences);
+    } else {
+      content.push(...backReferences);
+    }
+
+    /** @type {Element} */
+    const listItem = {
+      type: 'element',
+      tagName: 'li',
+      properties: {
+        id: clobberPrefix + 'fn-' + safeId
+      },
+      children: state.wrap(content, true)
+    };
+    state.patch(definition, listItem);
+    listItems.push(listItem);
+  }
+  if (listItems.length === 0) {
+    return;
+  }
+  return {
+    type: 'element',
+    tagName: 'section',
+    properties: {
+      dataFootnotes: true,
+      className: ['footnotes']
+    },
+    children: [{
+      type: 'element',
+      tagName: footnoteLabelTagName,
+      properties: {
+        ...structuredClone(footnoteLabelProperties),
+        id: 'footnote-label'
+      },
+      children: [{
+        type: 'text',
+        value: footnoteLabel
+      }]
+    }, {
+      type: 'text',
+      value: '\n'
+    }, {
+      type: 'element',
+      tagName: 'ol',
+      properties: {},
+      children: state.wrap(listItems, true)
+    }, {
+      type: 'text',
+      value: '\n'
+    }]
+  };
+}
+
+/**
+ * @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('vfile').VFile} VFile
+ *
+ * @typedef {import('./footer.js').FootnoteBackContentTemplate} FootnoteBackContentTemplate
+ * @typedef {import('./footer.js').FootnoteBackLabelTemplate} FootnoteBackLabelTemplate
+ */
+
+const own = {}.hasOwnProperty;
+
+/** @type {Options} */
+const emptyOptions = {};
+
+/**
+ * Create `state` from an mdast tree.
+ *
+ * @param {MdastNodes} tree
+ *   mdast node to transform.
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {State}
+ *   `state` function.
+ */
+function createState(tree, options) {
+  const settings = options || emptyOptions;
+  /** @type {Map<string, MdastDefinition>} */
+  const definitionById = new Map();
+  /** @type {Map<string, MdastFootnoteDefinition>} */
+  const footnoteById = new Map();
+  /** @type {Map<string, number>} */
+  const footnoteCounts = new Map();
+  /** @type {Handlers} */
+  // @ts-expect-error: the root handler returns a root.
+  // Hard to type.
+  const handlers$1 = {
+    ...handlers,
+    ...settings.handlers
+  };
+
+  /** @type {State} */
+  const state = {
+    all,
+    applyData,
+    definitionById,
+    footnoteById,
+    footnoteCounts,
+    footnoteOrder: [],
+    handlers: handlers$1,
+    one,
+    options: settings,
+    patch,
+    wrap
+  };
+  visit(tree, function (node) {
+    if (node.type === 'definition' || node.type === 'footnoteDefinition') {
+      const map = node.type === 'definition' ? definitionById : footnoteById;
+      const id = String(node.identifier).toUpperCase();
+
+      // Mimick CM behavior of link definitions.
+      // See: <https://github.com/syntax-tree/mdast-util-definitions/blob/9032189/lib/index.js#L20-L21>.
+      if (!map.has(id)) {
+        // @ts-expect-error: node type matches map.
+        map.set(id, node);
+      }
+    }
+  });
+  return state;
+
+  /**
+   * Transform an mdast node into a hast node.
+   *
+   * @param {MdastNodes} node
+   *   mdast node.
+   * @param {MdastParents | undefined} [parent]
+   *   Parent of `node`.
+   * @returns {Array<HastElementContent> | HastElementContent | undefined}
+   *   Resulting hast node.
+   */
+  function one(node, parent) {
+    const type = node.type;
+    const handle = state.handlers[type];
+    if (own.call(state.handlers, type) && handle) {
+      return handle(state, node, parent);
+    }
+    if (state.options.passThrough && state.options.passThrough.includes(type)) {
+      if ('children' in node) {
+        const {
+          children,
+          ...shallow
+        } = node;
+        const result = structuredClone(shallow);
+        // @ts-expect-error: TS doesn’t understand…
+        result.children = state.all(node);
+        // @ts-expect-error: TS doesn’t understand…
+        return result;
+      }
+
+      // @ts-expect-error: it’s custom.
+      return structuredClone(node);
+    }
+    const unknown = state.options.unknownHandler || defaultUnknownHandler;
+    return unknown(state, node, parent);
+  }
+
+  /**
+   * Transform the children of an mdast node into hast nodes.
+   *
+   * @param {MdastNodes} parent
+   *   mdast node to compile
+   * @returns {Array<HastElementContent>}
+   *   Resulting hast nodes.
+   */
+  function all(parent) {
+    /** @type {Array<HastElementContent>} */
+    const values = [];
+    if ('children' in parent) {
+      const nodes = parent.children;
+      let index = -1;
+      while (++index < nodes.length) {
+        const result = state.one(nodes[index], parent);
+
+        // To do: see if we van clean this? Can we merge texts?
+        if (result) {
+          if (index && nodes[index - 1].type === 'break') {
+            if (!Array.isArray(result) && result.type === 'text') {
+              result.value = trimMarkdownSpaceStart(result.value);
+            }
+            if (!Array.isArray(result) && result.type === 'element') {
+              const head = result.children[0];
+              if (head && head.type === 'text') {
+                head.value = trimMarkdownSpaceStart(head.value);
+              }
+            }
+          }
+          if (Array.isArray(result)) {
+            values.push(...result);
+          } else {
+            values.push(result);
+          }
+        }
+      }
+    }
+    return values;
+  }
+}
+
+/**
+ * Copy a node’s positional info.
+ *
+ * @param {MdastNodes} from
+ *   mdast node to copy from.
+ * @param {HastNodes} to
+ *   hast node to copy into.
+ * @returns {undefined}
+ *   Nothing.
+ */
+function patch(from, to) {
+  if (from.position) to.position = position(from);
+}
+
+/**
+ * Honor the `data` of `from` and maybe generate an element instead of `to`.
+ *
+ * @template {HastNodes} Type
+ *   Node type.
+ * @param {MdastNodes} from
+ *   mdast node to use data from.
+ * @param {Type} to
+ *   hast node to change.
+ * @returns {HastElement | Type}
+ *   Nothing.
+ */
+function applyData(from, to) {
+  /** @type {HastElement | Type} */
+  let result = to;
+
+  // Handle `data.hName`, `data.hProperties, `data.hChildren`.
+  if (from && from.data) {
+    const hName = from.data.hName;
+    const hChildren = from.data.hChildren;
+    const hProperties = from.data.hProperties;
+    if (typeof hName === 'string') {
+      // Transforming the node resulted in an element with a different name
+      // than wanted:
+      if (result.type === 'element') {
+        result.tagName = hName;
+      }
+      // Transforming the node resulted in a non-element, which happens for
+      // raw, text, and root nodes (unless custom handlers are passed).
+      // The intent of `hName` is to create an element, but likely also to keep
+      // the content around (otherwise: pass `hChildren`).
+      else {
+        /** @type {Array<HastElementContent>} */
+        // @ts-expect-error: assume no doctypes in `root`.
+        const children = 'children' in result ? result.children : [result];
+        result = {
+          type: 'element',
+          tagName: hName,
+          properties: {},
+          children
+        };
+      }
+    }
+    if (result.type === 'element' && hProperties) {
+      Object.assign(result.properties, structuredClone(hProperties));
+    }
+    if ('children' in result && result.children && hChildren !== null && hChildren !== undefined) {
+      result.children = hChildren;
+    }
+  }
+  return result;
+}
+
+/**
+ * Transform an unknown node.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {MdastNodes} node
+ *   Unknown mdast node.
+ * @returns {HastElement | HastText}
+ *   Resulting hast node.
+ */
+function defaultUnknownHandler(state, node) {
+  const data = node.data || {};
+  /** @type {HastElement | HastText} */
+  const result = 'value' in node && !(own.call(data, 'hProperties') || own.call(data, 'hChildren')) ? {
+    type: 'text',
+    value: node.value
+  } : {
+    type: 'element',
+    tagName: 'div',
+    properties: {},
+    children: state.all(node)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}
+
+/**
+ * Wrap `nodes` with line endings between each node.
+ *
+ * @template {HastRootContent} Type
+ *   Node type.
+ * @param {Array<Type>} nodes
+ *   List of nodes to wrap.
+ * @param {boolean | undefined} [loose=false]
+ *   Whether to add line endings at start and end (default: `false`).
+ * @returns {Array<HastText | Type>}
+ *   Wrapped nodes.
+ */
+function wrap(nodes, loose) {
+  /** @type {Array<HastText | Type>} */
+  const result = [];
+  let index = -1;
+  if (loose) {
+    result.push({
+      type: 'text',
+      value: '\n'
+    });
+  }
+  while (++index < nodes.length) {
+    if (index) result.push({
+      type: 'text',
+      value: '\n'
+    });
+    result.push(nodes[index]);
+  }
+  if (loose && nodes.length > 0) {
+    result.push({
+      type: 'text',
+      value: '\n'
+    });
+  }
+  return result;
+}
+
+/**
+ * Trim spaces and tabs at the start of `value`.
+ *
+ * @param {string} value
+ *   Value to trim.
+ * @returns {string}
+ *   Result.
+ */
+function trimMarkdownSpaceStart(value) {
+  let index = 0;
+  let code = value.charCodeAt(index);
+  while (code === 9 || code === 32) {
+    index++;
+    code = value.charCodeAt(index);
+  }
+  return value.slice(index);
+}
+
+/**
+ * @typedef {import('hast').Nodes} HastNodes
+ * @typedef {import('mdast').Nodes} MdastNodes
+ * @typedef {import('./state.js').Options} Options
+ */
+
+
+/**
+ * Transform mdast to hast.
+ *
+ * ##### Notes
+ *
+ * ###### HTML
+ *
+ * Raw HTML is available in mdast as `html` nodes and can be embedded in hast
+ * as semistandard `raw` nodes.
+ * Most utilities ignore `raw` nodes but two notable ones don’t:
+ *
+ * *   `hast-util-to-html` 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
+ * *   `hast-util-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
+ * `mdast-util-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.
+ *
+ * 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,
+ * which results in DOM clobbering.
+ *
+ * DOM clobbering is this:
+ *
+ * ```html
+ * <p id=x></p>
+ * <script>alert(x) // `x` now refers to the DOM `p#x` element</script>
+ * ```
+ *
+ * Elements by their ID are made available by browsers on the `window` object,
+ * which is a security risk.
+ * Using a prefix solves this problem.
+ *
+ * More information on how to handle clobbering and the prefix is explained in
+ * Example: headings (DOM clobbering) in `rehype-sanitize`.
+ *
+ * ###### Unknown nodes
+ *
+ * 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
+ *
+ * This behavior can be changed by passing an `unknownHandler`.
+ *
+ * @param {MdastNodes} tree
+ *   mdast tree.
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {HastNodes}
+ *   hast tree.
+ */
+function toHast(tree, options) {
+  const state = createState(tree, options);
+  const node = state.one(tree, undefined);
+  const foot = footer(state);
+  /** @type {HastNodes} */
+  const result = Array.isArray(node) ? {
+    type: 'root',
+    children: node
+  } : node || {
+    type: 'root',
+    children: []
+  };
+  if (foot) {
+    result.children.push({
+      type: 'text',
+      value: '\n'
+    }, foot);
+  }
+  return result;
+}
+
+/**
+ * @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'
+ */
+
+
+/**
+ * Turn markdown into HTML.
+ *
+ * ##### Notes
+ *
+ * ###### 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*)
+ *
+ * > 👉 **Note**:
+ * > It’s highly unlikely that you want to pass a `processor`.
+ *
+ * ###### HTML
+ *
+ * Raw HTML is available in mdast as `html` nodes and can be embedded in hast
+ * 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
+ *
+ * ###### 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`.
+ *
+ * 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.
+ *
+ * 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,
+ * which results in DOM clobbering.
+ *
+ * DOM clobbering is this:
+ *
+ * ```html
+ * <p id=x></p>
+ * <script>alert(x) // `x` now refers to the DOM `p#x` element</script>
+ * ```
+ *
+ * Elements by their ID are made available by browsers on the `window` object,
+ * which is a security risk.
+ * Using a prefix solves this problem.
+ *
+ * More information on how to handle clobbering and the prefix is explained in
+ * *Example: headings (DOM clobbering)* in `rehype-sanitize`.
+ *
+ * ###### Unknown nodes
+ *
+ * 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
+ *
+ * This behavior can be changed by passing an `unknownHandler`.
+ *
+ * @overload
+ * @param {Processor} processor
+ * @param {Readonly<Options> | null | undefined} [options]
+ * @returns {TransformBridge}
+ *
+ * @overload
+ * @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).
+ * @returns {TransformBridge | TransformMutate}
+ *   Transform.
+ */
+function remarkRehype(destination, options) {
+  if (destination && 'run' in destination) {
+    /**
+     * @type {TransformBridge}
+     */
+    return async function (tree, file) {
+      // Cast because root in -> root out.
+      const hastTree = /** @type {HastRoot} */
+      toHast(tree, {
+        file,
+        ...options
+      });
+      await destination.run(hastTree, file);
+    };
+  }
+
+  /**
+   * @type {TransformMutate}
+   */
+  return function (tree, file) {
+    // Cast because root in -> root out.
+    // To do: in the future, disallow ` || options` fallback.
+    // With `unified-engine`, `destination` can be `undefined` but
+    // `options` will be the file set.
+    // We should not pass that as `options`.
+    return /** @type {HastRoot} */toHast(tree, {
+      file,
+      ...(destination || options)
+    });
+  };
+}
+
+export { remarkRehype as default, defaultFootnoteBackContent, defaultFootnoteBackLabel, handlers as defaultHandlers };
+//# sourceMappingURL=index-C8S2G0FH.js.map