ember-repl 7.1.0 → 7.1.2

package/dist/index-CGDqu098.js

@@ -1,1925 +0,0 @@
-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-Bo3xsMqx.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);
-}
-
-/**
- * @import {Element} from 'hast'
- * @import {Blockquote} from 'mdast'
- * @import {State} from '../state.js'
- */
-
-/**
- * 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);
-}
-
-/**
- * @import {Element, Text} from 'hast'
- * @import {Break} from 'mdast'
- * @import {State} from '../state.js'
- */
-
-/**
- * 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'
-  }];
-}
-
-/**
- * @import {Element, Properties} from 'hast'
- * @import {Code} from 'mdast'
- * @import {State} from '../state.js'
- */
-
-/**
- * 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 = {};
-  // Someone can write `js&#x20;python&#x9;ruby`.
-  const language = node.lang ? node.lang.split(/\s+/) : [];
-
-  // GH/CM still drop the non-first languages.
-  if (language.length > 0) {
-    properties.className = ['language-' + language[0]];
-  }
-
-  // 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;
-}
-
-/**
- * @import {Element} from 'hast'
- * @import {Delete} from 'mdast'
- * @import {State} from '../state.js'
- */
-
-/**
- * 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);
-}
-
-/**
- * @import {Element} from 'hast'
- * @import {Emphasis} from 'mdast'
- * @import {State} from '../state.js'
- */
-
-/**
- * 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);
-}
-
-/**
- * @import {Element} from 'hast'
- * @import {FootnoteReference} from 'mdast'
- * @import {State} from '../state.js'
- */
-
-
-/**
- * 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);
-}
-
-/**
- * @import {Element} from 'hast'
- * @import {Heading} from 'mdast'
- * @import {State} from '../state.js'
- */
-
-/**
- * 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);
-}
-
-/**
- * @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).
- *
- * @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;
-}
-
-/**
- * @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.
- *
- * @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;
-}
-
-/**
- * @import {ElementContent, Element, Properties} from 'hast'
- * @import {ImageReference} from 'mdast'
- * @import {State} from '../state.js'
- */
-
-
-/**
- * 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);
-}
-
-/**
- * @import {Element, Properties} from 'hast'
- * @import {Image} from 'mdast'
- * @import {State} from '../state.js'
- */
-
-
-/**
- * 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);
-}
-
-/**
- * @import {Element, Text} from 'hast'
- * @import {InlineCode} from 'mdast'
- * @import {State} from '../state.js'
- */
-
-/**
- * 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);
-}
-
-/**
- * @import {ElementContent, Element, Properties} from 'hast'
- * @import {LinkReference} from 'mdast'
- * @import {State} from '../state.js'
- */
-
-
-/**
- * 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);
-}
-
-/**
- * @import {Element, Properties} from 'hast'
- * @import {Link} from 'mdast'
- * @import {State} from '../state.js'
- */
-
-
-/**
- * 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);
-}
-
-/**
- * @import {ElementContent, Element, Properties} from 'hast'
- * @import {ListItem, Parents} from 'mdast'
- * @import {State} from '../state.js'
- */
-
-/**
- * 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;
-}
-
-/**
- * @import {Element, Properties} from 'hast'
- * @import {List} from 'mdast'
- * @import {State} from '../state.js'
- */
-
-/**
- * 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);
-}
-
-/**
- * @import {Element} from 'hast'
- * @import {Paragraph} from 'mdast'
- * @import {State} from '../state.js'
- */
-
-/**
- * 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);
-}
-
-/**
- * @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.
- *
- * @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);
-}
-
-/**
- * @import {Element} from 'hast'
- * @import {Strong} from 'mdast'
- * @import {State} from '../state.js'
- */
-
-/**
- * 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);
-}
-
-/**
- * @import {Table} from 'mdast'
- * @import {Element} from 'hast'
- * @import {State} from '../state.js'
- */
-
-
-/**
- * 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);
-}
-
-/**
- * @import {Element, ElementContent, Properties} from 'hast'
- * @import {Parents, TableRow} from 'mdast'
- * @import {State} from '../state.js'
- */
-
-/**
- * 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);
-}
-
-/**
- * @import {Element} from 'hast'
- * @import {TableCell} from 'mdast'
- * @import {State} from '../state.js'
- */
-
-/**
- * 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) : '';
-}
-
-/**
- * @import {Element as HastElement, Text as HastText} from 'hast'
- * @import {Text as MdastText} from 'mdast'
- * @import {State} from '../state.js'
- */
-
-
-/**
- * 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);
-}
-
-/**
- * @import {Element} from 'hast'
- * @import {ThematicBreak} from 'mdast'
- * @import {State} from '../state.js'
- */
-
-/**
- * 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);
-}
-
-/**
- * @import {Handlers} from '../state.js'
- */
-
-
-/**
- * Default handlers for nodes.
- *
- * @satisfies {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;
-}
-
-/**
- * @import {ElementContent, Element} from 'hast'
- * @import {State} from './state.js'
- */
-
-
-/**
- * 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'
-    }]
-  };
-}
-
-/**
- * @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 = {}.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);
-}
-
-/**
- * @import {Nodes as HastNodes} from 'hast'
- * @import {Nodes as MdastNodes} from 'mdast'
- * @import {Options} from './state.js'
- */
-
-
-/**
- * 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-CGDqu098.js.map