ember-repl 7.1.0 → 7.1.2

package/dist/index-C371bO_b.js

@@ -1,1553 +0,0 @@
-import { s as svg, f as find, b as stringify, c as stringify$1, z as zwitch, h as html$2, d as htmlVoidElements } from './index-Dr5iYoKt.js';
-import { c as ccount } from './index-k6CfLgeq.js';
-
-/**
- * @typedef CoreOptions
- * @property {ReadonlyArray<string>} [subset=[]]
- *   Whether to only escape the given subset of characters.
- * @property {boolean} [escapeOnly=false]
- *   Whether to only escape possibly dangerous characters.
- *   Those characters are `"`, `&`, `'`, `<`, `>`, and `` ` ``.
- *
- * @typedef FormatOptions
- * @property {(code: number, next: number, options: CoreWithFormatOptions) => string} format
- *   Format strategy.
- *
- * @typedef {CoreOptions & FormatOptions & import('./util/format-smart.js').FormatSmartOptions} CoreWithFormatOptions
- */
-
-const defaultSubsetRegex = /["&'<>`]/g;
-const surrogatePairsRegex = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
-const controlCharactersRegex =
-// eslint-disable-next-line no-control-regex, unicorn/no-hex-escape
-/[\x01-\t\v\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g;
-const regexEscapeRegex = /[|\\{}()[\]^$+*?.]/g;
-
-/** @type {WeakMap<ReadonlyArray<string>, RegExp>} */
-const subsetToRegexCache = new WeakMap();
-
-/**
- * Encode certain characters in `value`.
- *
- * @param {string} value
- * @param {CoreWithFormatOptions} options
- * @returns {string}
- */
-function core(value, options) {
-  value = value.replace(options.subset ? charactersToExpressionCached(options.subset) : defaultSubsetRegex, basic);
-  if (options.subset || options.escapeOnly) {
-    return value;
-  }
-  return value
-  // Surrogate pairs.
-  .replace(surrogatePairsRegex, surrogate)
-  // BMP control characters (C0 except for LF, CR, SP; DEL; and some more
-  // non-ASCII ones).
-  .replace(controlCharactersRegex, basic);
-
-  /**
-   * @param {string} pair
-   * @param {number} index
-   * @param {string} all
-   */
-  function surrogate(pair, index, all) {
-    return options.format((pair.charCodeAt(0) - 0xd800) * 0x400 + pair.charCodeAt(1) - 0xdc00 + 0x10000, all.charCodeAt(index + 2), options);
-  }
-
-  /**
-   * @param {string} character
-   * @param {number} index
-   * @param {string} all
-   */
-  function basic(character, index, all) {
-    return options.format(character.charCodeAt(0), all.charCodeAt(index + 1), options);
-  }
-}
-
-/**
- * A wrapper function that caches the result of `charactersToExpression` with a WeakMap.
- * This can improve performance when tooling calls `charactersToExpression` repeatedly
- * with the same subset.
- *
- * @param {ReadonlyArray<string>} subset
- * @returns {RegExp}
- */
-function charactersToExpressionCached(subset) {
-  let cached = subsetToRegexCache.get(subset);
-  if (!cached) {
-    cached = charactersToExpression(subset);
-    subsetToRegexCache.set(subset, cached);
-  }
-  return cached;
-}
-
-/**
- * @param {ReadonlyArray<string>} subset
- * @returns {RegExp}
- */
-function charactersToExpression(subset) {
-  /** @type {Array<string>} */
-  const groups = [];
-  let index = -1;
-  while (++index < subset.length) {
-    groups.push(subset[index].replace(regexEscapeRegex, '\\$&'));
-  }
-  return new RegExp('(?:' + groups.join('|') + ')', 'g');
-}
-
-const hexadecimalRegex = /[\dA-Fa-f]/;
-
-/**
- * Configurable ways to encode characters as hexadecimal references.
- *
- * @param {number} code
- * @param {number} next
- * @param {boolean|undefined} omit
- * @returns {string}
- */
-function toHexadecimal(code, next, omit) {
-  const value = '&#x' + code.toString(16).toUpperCase();
-  return omit && next && !hexadecimalRegex.test(String.fromCharCode(next)) ? value : value + ';';
-}
-
-const decimalRegex = /\d/;
-
-/**
- * Configurable ways to encode characters as decimal references.
- *
- * @param {number} code
- * @param {number} next
- * @param {boolean|undefined} omit
- * @returns {string}
- */
-function toDecimal(code, next, omit) {
-  const value = '&#' + String(code);
-  return omit && next && !decimalRegex.test(String.fromCharCode(next)) ? value : value + ';';
-}
-
-/**
- * List of legacy HTML named character references that don’t need a trailing semicolon.
- *
- * @type {Array<string>}
- */
-const characterEntitiesLegacy = ['AElig', 'AMP', 'Aacute', 'Acirc', 'Agrave', 'Aring', 'Atilde', 'Auml', 'COPY', 'Ccedil', 'ETH', 'Eacute', 'Ecirc', 'Egrave', 'Euml', 'GT', 'Iacute', 'Icirc', 'Igrave', 'Iuml', 'LT', 'Ntilde', 'Oacute', 'Ocirc', 'Ograve', 'Oslash', 'Otilde', 'Ouml', 'QUOT', 'REG', 'THORN', 'Uacute', 'Ucirc', 'Ugrave', 'Uuml', 'Yacute', 'aacute', 'acirc', 'acute', 'aelig', 'agrave', 'amp', 'aring', 'atilde', 'auml', 'brvbar', 'ccedil', 'cedil', 'cent', 'copy', 'curren', 'deg', 'divide', 'eacute', 'ecirc', 'egrave', 'eth', 'euml', 'frac12', 'frac14', 'frac34', 'gt', 'iacute', 'icirc', 'iexcl', 'igrave', 'iquest', 'iuml', 'laquo', 'lt', 'macr', 'micro', 'middot', 'nbsp', 'not', 'ntilde', 'oacute', 'ocirc', 'ograve', 'ordf', 'ordm', 'oslash', 'otilde', 'ouml', 'para', 'plusmn', 'pound', 'quot', 'raquo', 'reg', 'sect', 'shy', 'sup1', 'sup2', 'sup3', 'szlig', 'thorn', 'times', 'uacute', 'ucirc', 'ugrave', 'uml', 'uuml', 'yacute', 'yen', 'yuml'];
-
-/**
- * Map of named character references from HTML 4.
- *
- * @type {Record<string, string>}
- */
-const characterEntitiesHtml4 = {
-  nbsp: ' ',
-  iexcl: '¡',
-  cent: '¢',
-  pound: '£',
-  curren: '¤',
-  yen: '¥',
-  brvbar: '¦',
-  sect: '§',
-  uml: '¨',
-  copy: '©',
-  ordf: 'ª',
-  laquo: '«',
-  not: '¬',
-  shy: '­',
-  reg: '®',
-  macr: '¯',
-  deg: '°',
-  plusmn: '±',
-  sup2: '²',
-  sup3: '³',
-  acute: '´',
-  micro: 'µ',
-  para: '¶',
-  middot: '·',
-  cedil: '¸',
-  sup1: '¹',
-  ordm: 'º',
-  raquo: '»',
-  frac14: '¼',
-  frac12: '½',
-  frac34: '¾',
-  iquest: '¿',
-  Agrave: 'À',
-  Aacute: 'Á',
-  Acirc: 'Â',
-  Atilde: 'Ã',
-  Auml: 'Ä',
-  Aring: 'Å',
-  AElig: 'Æ',
-  Ccedil: 'Ç',
-  Egrave: 'È',
-  Eacute: 'É',
-  Ecirc: 'Ê',
-  Euml: 'Ë',
-  Igrave: 'Ì',
-  Iacute: 'Í',
-  Icirc: 'Î',
-  Iuml: 'Ï',
-  ETH: 'Ð',
-  Ntilde: 'Ñ',
-  Ograve: 'Ò',
-  Oacute: 'Ó',
-  Ocirc: 'Ô',
-  Otilde: 'Õ',
-  Ouml: 'Ö',
-  times: '×',
-  Oslash: 'Ø',
-  Ugrave: 'Ù',
-  Uacute: 'Ú',
-  Ucirc: 'Û',
-  Uuml: 'Ü',
-  Yacute: 'Ý',
-  THORN: 'Þ',
-  szlig: 'ß',
-  agrave: 'à',
-  aacute: 'á',
-  acirc: 'â',
-  atilde: 'ã',
-  auml: 'ä',
-  aring: 'å',
-  aelig: 'æ',
-  ccedil: 'ç',
-  egrave: 'è',
-  eacute: 'é',
-  ecirc: 'ê',
-  euml: 'ë',
-  igrave: 'ì',
-  iacute: 'í',
-  icirc: 'î',
-  iuml: 'ï',
-  eth: 'ð',
-  ntilde: 'ñ',
-  ograve: 'ò',
-  oacute: 'ó',
-  ocirc: 'ô',
-  otilde: 'õ',
-  ouml: 'ö',
-  divide: '÷',
-  oslash: 'ø',
-  ugrave: 'ù',
-  uacute: 'ú',
-  ucirc: 'û',
-  uuml: 'ü',
-  yacute: 'ý',
-  thorn: 'þ',
-  yuml: 'ÿ',
-  fnof: 'ƒ',
-  Alpha: 'Α',
-  Beta: 'Β',
-  Gamma: 'Γ',
-  Delta: 'Δ',
-  Epsilon: 'Ε',
-  Zeta: 'Ζ',
-  Eta: 'Η',
-  Theta: 'Θ',
-  Iota: 'Ι',
-  Kappa: 'Κ',
-  Lambda: 'Λ',
-  Mu: 'Μ',
-  Nu: 'Ν',
-  Xi: 'Ξ',
-  Omicron: 'Ο',
-  Pi: 'Π',
-  Rho: 'Ρ',
-  Sigma: 'Σ',
-  Tau: 'Τ',
-  Upsilon: 'Υ',
-  Phi: 'Φ',
-  Chi: 'Χ',
-  Psi: 'Ψ',
-  Omega: 'Ω',
-  alpha: 'α',
-  beta: 'β',
-  gamma: 'γ',
-  delta: 'δ',
-  epsilon: 'ε',
-  zeta: 'ζ',
-  eta: 'η',
-  theta: 'θ',
-  iota: 'ι',
-  kappa: 'κ',
-  lambda: 'λ',
-  mu: 'μ',
-  nu: 'ν',
-  xi: 'ξ',
-  omicron: 'ο',
-  pi: 'π',
-  rho: 'ρ',
-  sigmaf: 'ς',
-  sigma: 'σ',
-  tau: 'τ',
-  upsilon: 'υ',
-  phi: 'φ',
-  chi: 'χ',
-  psi: 'ψ',
-  omega: 'ω',
-  thetasym: 'ϑ',
-  upsih: 'ϒ',
-  piv: 'ϖ',
-  bull: '•',
-  hellip: '…',
-  prime: '′',
-  Prime: '″',
-  oline: '‾',
-  frasl: '⁄',
-  weierp: '℘',
-  image: 'ℑ',
-  real: 'ℜ',
-  trade: '™',
-  alefsym: 'ℵ',
-  larr: '←',
-  uarr: '↑',
-  rarr: '→',
-  darr: '↓',
-  harr: '↔',
-  crarr: '↵',
-  lArr: '⇐',
-  uArr: '⇑',
-  rArr: '⇒',
-  dArr: '⇓',
-  hArr: '⇔',
-  forall: '∀',
-  part: '∂',
-  exist: '∃',
-  empty: '∅',
-  nabla: '∇',
-  isin: '∈',
-  notin: '∉',
-  ni: '∋',
-  prod: '∏',
-  sum: '∑',
-  minus: '−',
-  lowast: '∗',
-  radic: '√',
-  prop: '∝',
-  infin: '∞',
-  ang: '∠',
-  and: '∧',
-  or: '∨',
-  cap: '∩',
-  cup: '∪',
-  int: '∫',
-  there4: '∴',
-  sim: '∼',
-  cong: '≅',
-  asymp: '≈',
-  ne: '≠',
-  equiv: '≡',
-  le: '≤',
-  ge: '≥',
-  sub: '⊂',
-  sup: '⊃',
-  nsub: '⊄',
-  sube: '⊆',
-  supe: '⊇',
-  oplus: '⊕',
-  otimes: '⊗',
-  perp: '⊥',
-  sdot: '⋅',
-  lceil: '⌈',
-  rceil: '⌉',
-  lfloor: '⌊',
-  rfloor: '⌋',
-  lang: '〈',
-  rang: '〉',
-  loz: '◊',
-  spades: '♠',
-  clubs: '♣',
-  hearts: '♥',
-  diams: '♦',
-  quot: '"',
-  amp: '&',
-  lt: '<',
-  gt: '>',
-  OElig: 'Œ',
-  oelig: 'œ',
-  Scaron: 'Š',
-  scaron: 'š',
-  Yuml: 'Ÿ',
-  circ: 'ˆ',
-  tilde: '˜',
-  ensp: ' ',
-  emsp: ' ',
-  thinsp: ' ',
-  zwnj: '‌',
-  zwj: '‍',
-  lrm: '‎',
-  rlm: '‏',
-  ndash: '–',
-  mdash: '—',
-  lsquo: '‘',
-  rsquo: '’',
-  sbquo: '‚',
-  ldquo: '“',
-  rdquo: '”',
-  bdquo: '„',
-  dagger: '†',
-  Dagger: '‡',
-  permil: '‰',
-  lsaquo: '‹',
-  rsaquo: '›',
-  euro: '€'
-};
-
-/**
- * List of legacy (that don’t need a trailing `;`) named references which could,
- * depending on what follows them, turn into a different meaning
- *
- * @type {Array<string>}
- */
-const dangerous = ['cent', 'copy', 'divide', 'gt', 'lt', 'not', 'para', 'times'];
-
-const own$1 = {}.hasOwnProperty;
-
-/**
- * `characterEntitiesHtml4` but inverted.
- *
- * @type {Record<string, string>}
- */
-const characters = {};
-
-/** @type {string} */
-let key;
-for (key in characterEntitiesHtml4) {
-  if (own$1.call(characterEntitiesHtml4, key)) {
-    characters[characterEntitiesHtml4[key]] = key;
-  }
-}
-const notAlphanumericRegex = /[^\dA-Za-z]/;
-
-/**
- * Configurable ways to encode characters as named references.
- *
- * @param {number} code
- * @param {number} next
- * @param {boolean|undefined} omit
- * @param {boolean|undefined} attribute
- * @returns {string}
- */
-function toNamed(code, next, omit, attribute) {
-  const character = String.fromCharCode(code);
-  if (own$1.call(characters, character)) {
-    const name = characters[character];
-    const value = '&' + name;
-    if (omit && characterEntitiesLegacy.includes(name) && !dangerous.includes(name) && (!attribute || next && next !== 61 /* `=` */ && notAlphanumericRegex.test(String.fromCharCode(next)))) {
-      return value;
-    }
-    return value + ';';
-  }
-  return '';
-}
-
-/**
- * @typedef FormatSmartOptions
- * @property {boolean} [useNamedReferences=false]
- *   Prefer named character references (`&amp;`) where possible.
- * @property {boolean} [useShortestReferences=false]
- *   Prefer the shortest possible reference, if that results in less bytes.
- *   **Note**: `useNamedReferences` can be omitted when using `useShortestReferences`.
- * @property {boolean} [omitOptionalSemicolons=false]
- *   Whether to omit semicolons when possible.
- *   **Note**: This creates what HTML calls “parse errors” but is otherwise still valid HTML — don’t use this except when building a minifier.
- *   Omitting semicolons is possible for certain named and numeric references in some cases.
- * @property {boolean} [attribute=false]
- *   Create character references which don’t fail in attributes.
- *   **Note**: `attribute` only applies when operating dangerously with
- *   `omitOptionalSemicolons: true`.
- */
-
-
-/**
- * Configurable ways to encode a character yielding pretty or small results.
- *
- * @param {number} code
- * @param {number} next
- * @param {FormatSmartOptions} options
- * @returns {string}
- */
-function formatSmart(code, next, options) {
-  let numeric = toHexadecimal(code, next, options.omitOptionalSemicolons);
-  /** @type {string|undefined} */
-  let named;
-  if (options.useNamedReferences || options.useShortestReferences) {
-    named = toNamed(code, next, options.omitOptionalSemicolons, options.attribute);
-  }
-
-  // Use the shortest numeric reference when requested.
-  // A simple algorithm would use decimal for all code points under 100, as
-  // those are shorter than hexadecimal:
-  //
-  // * `&#99;` vs `&#x63;` (decimal shorter)
-  // * `&#100;` vs `&#x64;` (equal)
-  //
-  // However, because we take `next` into consideration when `omit` is used,
-  // And it would be possible that decimals are shorter on bigger values as
-  // well if `next` is hexadecimal but not decimal, we instead compare both.
-  if ((options.useShortestReferences || !named) && options.useShortestReferences) {
-    const decimal = toDecimal(code, next, options.omitOptionalSemicolons);
-    if (decimal.length < numeric.length) {
-      numeric = decimal;
-    }
-  }
-  return named && (!options.useShortestReferences || named.length < numeric.length) ? named : numeric;
-}
-
-/**
- * @typedef {import('./core.js').CoreOptions & import('./util/format-smart.js').FormatSmartOptions} Options
- * @typedef {import('./core.js').CoreOptions} LightOptions
- */
-
-
-/**
- * Encode special characters in `value`.
- *
- * @param {string} value
- *   Value to encode.
- * @param {Options} [options]
- *   Configuration.
- * @returns {string}
- *   Encoded value.
- */
-function stringifyEntities(value, options) {
-  return core(value, Object.assign({
-    format: formatSmart
-  }, options));
-}
-
-/**
- * @import {Comment, Parents} from 'hast'
- * @import {State} from '../index.js'
- */
-
-const htmlCommentRegex = /^>|^->|<!--|-->|--!>|<!-$/g;
-
-// Declare arrays as variables so it can be cached by `stringifyEntities`
-const bogusCommentEntitySubset = ['>'];
-const commentEntitySubset = ['<', '>'];
-
-/**
- * Serialize a comment.
- *
- * @param {Comment} node
- *   Node to handle.
- * @param {number | undefined} _1
- *   Index of `node` in `parent.
- * @param {Parents | undefined} _2
- *   Parent of `node`.
- * @param {State} state
- *   Info passed around about the current state.
- * @returns {string}
- *   Serialized node.
- */
-function comment(node, _1, _2, state) {
-  // See: <https://html.spec.whatwg.org/multipage/syntax.html#comments>
-  return state.settings.bogusComments ? '<?' + stringifyEntities(node.value, Object.assign({}, state.settings.characterReferences, {
-    subset: bogusCommentEntitySubset
-  })) + '>' : '<!--' + node.value.replace(htmlCommentRegex, encode) + '-->';
-
-  /**
-   * @param {string} $0
-   */
-  function encode($0) {
-    return stringifyEntities($0, Object.assign({}, state.settings.characterReferences, {
-      subset: commentEntitySubset
-    }));
-  }
-}
-
-/**
- * @import {Doctype, Parents} from 'hast'
- * @import {State} from '../index.js'
- */
-
-/**
- * Serialize a doctype.
- *
- * @param {Doctype} _1
- *   Node to handle.
- * @param {number | undefined} _2
- *   Index of `node` in `parent.
- * @param {Parents | undefined} _3
- *   Parent of `node`.
- * @param {State} state
- *   Info passed around about the current state.
- * @returns {string}
- *   Serialized node.
- */
-function doctype(_1, _2, _3, state) {
-  return '<!' + (state.settings.upperDoctype ? 'DOCTYPE' : 'doctype') + (state.settings.tightDoctype ? '' : ' ') + 'html>';
-}
-
-/**
- * @typedef {import('hast').Nodes} Nodes
- */
-
-// HTML whitespace expression.
-// See <https://infra.spec.whatwg.org/#ascii-whitespace>.
-const re = /[ \t\n\f\r]/g;
-
-/**
- * Check if the given value is *inter-element whitespace*.
- *
- * @param {Nodes | string} thing
- *   Thing to check (`Node` or `string`).
- * @returns {boolean}
- *   Whether the `value` is inter-element whitespace (`boolean`): consisting of
- *   zero or more of space, tab (`\t`), line feed (`\n`), carriage return
- *   (`\r`), or form feed (`\f`); if a node is passed it must be a `Text` node,
- *   whose `value` field is checked.
- */
-function whitespace(thing) {
-  return typeof thing === 'object' ? thing.type === 'text' ? empty(thing.value) : false : empty(thing);
-}
-
-/**
- * @param {string} value
- * @returns {boolean}
- */
-function empty(value) {
-  return value.replace(re, '') === '';
-}
-
-/**
- * @import {Parents, RootContent} from 'hast'
- */
-
-const siblingAfter = siblings(1);
-const siblingBefore = siblings(-1);
-
-/** @type {Array<RootContent>} */
-const emptyChildren$1 = [];
-
-/**
- * Factory to check siblings in a direction.
- *
- * @param {number} increment
- */
-function siblings(increment) {
-  return sibling;
-
-  /**
-   * Find applicable siblings in a direction.
-   *
-   * @template {Parents} Parent
-   *   Parent type.
-   * @param {Parent | undefined} parent
-   *   Parent.
-   * @param {number | undefined} index
-   *   Index of child in `parent`.
-   * @param {boolean | undefined} [includeWhitespace=false]
-   *   Whether to include whitespace (default: `false`).
-   * @returns {Parent extends {children: Array<infer Child>} ? Child | undefined : never}
-   *   Child of parent.
-   */
-  function sibling(parent, index, includeWhitespace) {
-    const siblings = parent ? parent.children : emptyChildren$1;
-    let offset = (index || 0) + increment;
-    let next = siblings[offset];
-    if (!includeWhitespace) {
-      while (next && whitespace(next)) {
-        offset += increment;
-        next = siblings[offset];
-      }
-    }
-
-    // @ts-expect-error: it’s a correct child.
-    return next;
-  }
-}
-
-/**
- * @import {Element, Parents} from 'hast'
- */
-
-/**
- * @callback OmitHandle
- *   Check if a tag can be omitted.
- * @param {Element} element
- *   Element to check.
- * @param {number | undefined} index
- *   Index of element in parent.
- * @param {Parents | undefined} parent
- *   Parent of element.
- * @returns {boolean}
- *   Whether to omit a tag.
- *
- */
-
-const own = {}.hasOwnProperty;
-
-/**
- * Factory to check if a given node can have a tag omitted.
- *
- * @param {Record<string, OmitHandle>} handlers
- *   Omission handlers, where each key is a tag name, and each value is the
- *   corresponding handler.
- * @returns {OmitHandle}
- *   Whether to omit a tag of an element.
- */
-function omission(handlers) {
-  return omit;
-
-  /**
-   * Check if a given node can have a tag omitted.
-   *
-   * @type {OmitHandle}
-   */
-  function omit(node, index, parent) {
-    return own.call(handlers, node.tagName) && handlers[node.tagName](node, index, parent);
-  }
-}
-
-/**
- * @import {Element, Parents} from 'hast'
- */
-
-const closing = omission({
-  body: body$1,
-  caption: headOrColgroupOrCaption,
-  colgroup: headOrColgroupOrCaption,
-  dd,
-  dt,
-  head: headOrColgroupOrCaption,
-  html: html$1,
-  li,
-  optgroup,
-  option,
-  p,
-  rp: rubyElement,
-  rt: rubyElement,
-  tbody: tbody$1,
-  td: cells,
-  tfoot,
-  th: cells,
-  thead,
-  tr
-});
-
-/**
- * Macro for `</head>`, `</colgroup>`, and `</caption>`.
- *
- * @param {Element} _
- *   Element.
- * @param {number | undefined} index
- *   Index of element in parent.
- * @param {Parents | undefined} parent
- *   Parent of element.
- * @returns {boolean}
- *   Whether the closing tag can be omitted.
- */
-function headOrColgroupOrCaption(_, index, parent) {
-  const next = siblingAfter(parent, index, true);
-  return !next || next.type !== 'comment' && !(next.type === 'text' && whitespace(next.value.charAt(0)));
-}
-
-/**
- * Whether to omit `</html>`.
- *
- * @param {Element} _
- *   Element.
- * @param {number | undefined} index
- *   Index of element in parent.
- * @param {Parents | undefined} parent
- *   Parent of element.
- * @returns {boolean}
- *   Whether the closing tag can be omitted.
- */
-function html$1(_, index, parent) {
-  const next = siblingAfter(parent, index);
-  return !next || next.type !== 'comment';
-}
-
-/**
- * Whether to omit `</body>`.
- *
- * @param {Element} _
- *   Element.
- * @param {number | undefined} index
- *   Index of element in parent.
- * @param {Parents | undefined} parent
- *   Parent of element.
- * @returns {boolean}
- *   Whether the closing tag can be omitted.
- */
-function body$1(_, index, parent) {
-  const next = siblingAfter(parent, index);
-  return !next || next.type !== 'comment';
-}
-
-/**
- * Whether to omit `</p>`.
- *
- * @param {Element} _
- *   Element.
- * @param {number | undefined} index
- *   Index of element in parent.
- * @param {Parents | undefined} parent
- *   Parent of element.
- * @returns {boolean}
- *   Whether the closing tag can be omitted.
- */
-function p(_, index, parent) {
-  const next = siblingAfter(parent, index);
-  return next ? next.type === 'element' && (next.tagName === 'address' || next.tagName === 'article' || next.tagName === 'aside' || next.tagName === 'blockquote' || next.tagName === 'details' || next.tagName === 'div' || next.tagName === 'dl' || next.tagName === 'fieldset' || next.tagName === 'figcaption' || next.tagName === 'figure' || next.tagName === 'footer' || next.tagName === 'form' || next.tagName === 'h1' || next.tagName === 'h2' || next.tagName === 'h3' || next.tagName === 'h4' || next.tagName === 'h5' || next.tagName === 'h6' || next.tagName === 'header' || next.tagName === 'hgroup' || next.tagName === 'hr' || next.tagName === 'main' || next.tagName === 'menu' || next.tagName === 'nav' || next.tagName === 'ol' || next.tagName === 'p' || next.tagName === 'pre' || next.tagName === 'section' || next.tagName === 'table' || next.tagName === 'ul') : !parent ||
-  // Confusing parent.
-  !(parent.type === 'element' && (parent.tagName === 'a' || parent.tagName === 'audio' || parent.tagName === 'del' || parent.tagName === 'ins' || parent.tagName === 'map' || parent.tagName === 'noscript' || parent.tagName === 'video'));
-}
-
-/**
- * Whether to omit `</li>`.
- *
- * @param {Element} _
- *   Element.
- * @param {number | undefined} index
- *   Index of element in parent.
- * @param {Parents | undefined} parent
- *   Parent of element.
- * @returns {boolean}
- *   Whether the closing tag can be omitted.
- */
-function li(_, index, parent) {
-  const next = siblingAfter(parent, index);
-  return !next || next.type === 'element' && next.tagName === 'li';
-}
-
-/**
- * Whether to omit `</dt>`.
- *
- * @param {Element} _
- *   Element.
- * @param {number | undefined} index
- *   Index of element in parent.
- * @param {Parents | undefined} parent
- *   Parent of element.
- * @returns {boolean}
- *   Whether the closing tag can be omitted.
- */
-function dt(_, index, parent) {
-  const next = siblingAfter(parent, index);
-  return Boolean(next && next.type === 'element' && (next.tagName === 'dt' || next.tagName === 'dd'));
-}
-
-/**
- * Whether to omit `</dd>`.
- *
- * @param {Element} _
- *   Element.
- * @param {number | undefined} index
- *   Index of element in parent.
- * @param {Parents | undefined} parent
- *   Parent of element.
- * @returns {boolean}
- *   Whether the closing tag can be omitted.
- */
-function dd(_, index, parent) {
-  const next = siblingAfter(parent, index);
-  return !next || next.type === 'element' && (next.tagName === 'dt' || next.tagName === 'dd');
-}
-
-/**
- * Whether to omit `</rt>` or `</rp>`.
- *
- * @param {Element} _
- *   Element.
- * @param {number | undefined} index
- *   Index of element in parent.
- * @param {Parents | undefined} parent
- *   Parent of element.
- * @returns {boolean}
- *   Whether the closing tag can be omitted.
- */
-function rubyElement(_, index, parent) {
-  const next = siblingAfter(parent, index);
-  return !next || next.type === 'element' && (next.tagName === 'rp' || next.tagName === 'rt');
-}
-
-/**
- * Whether to omit `</optgroup>`.
- *
- * @param {Element} _
- *   Element.
- * @param {number | undefined} index
- *   Index of element in parent.
- * @param {Parents | undefined} parent
- *   Parent of element.
- * @returns {boolean}
- *   Whether the closing tag can be omitted.
- */
-function optgroup(_, index, parent) {
-  const next = siblingAfter(parent, index);
-  return !next || next.type === 'element' && next.tagName === 'optgroup';
-}
-
-/**
- * Whether to omit `</option>`.
- *
- * @param {Element} _
- *   Element.
- * @param {number | undefined} index
- *   Index of element in parent.
- * @param {Parents | undefined} parent
- *   Parent of element.
- * @returns {boolean}
- *   Whether the closing tag can be omitted.
- */
-function option(_, index, parent) {
-  const next = siblingAfter(parent, index);
-  return !next || next.type === 'element' && (next.tagName === 'option' || next.tagName === 'optgroup');
-}
-
-/**
- * Whether to omit `</thead>`.
- *
- * @param {Element} _
- *   Element.
- * @param {number | undefined} index
- *   Index of element in parent.
- * @param {Parents | undefined} parent
- *   Parent of element.
- * @returns {boolean}
- *   Whether the closing tag can be omitted.
- */
-function thead(_, index, parent) {
-  const next = siblingAfter(parent, index);
-  return Boolean(next && next.type === 'element' && (next.tagName === 'tbody' || next.tagName === 'tfoot'));
-}
-
-/**
- * Whether to omit `</tbody>`.
- *
- * @param {Element} _
- *   Element.
- * @param {number | undefined} index
- *   Index of element in parent.
- * @param {Parents | undefined} parent
- *   Parent of element.
- * @returns {boolean}
- *   Whether the closing tag can be omitted.
- */
-function tbody$1(_, index, parent) {
-  const next = siblingAfter(parent, index);
-  return !next || next.type === 'element' && (next.tagName === 'tbody' || next.tagName === 'tfoot');
-}
-
-/**
- * Whether to omit `</tfoot>`.
- *
- * @param {Element} _
- *   Element.
- * @param {number | undefined} index
- *   Index of element in parent.
- * @param {Parents | undefined} parent
- *   Parent of element.
- * @returns {boolean}
- *   Whether the closing tag can be omitted.
- */
-function tfoot(_, index, parent) {
-  return !siblingAfter(parent, index);
-}
-
-/**
- * Whether to omit `</tr>`.
- *
- * @param {Element} _
- *   Element.
- * @param {number | undefined} index
- *   Index of element in parent.
- * @param {Parents | undefined} parent
- *   Parent of element.
- * @returns {boolean}
- *   Whether the closing tag can be omitted.
- */
-function tr(_, index, parent) {
-  const next = siblingAfter(parent, index);
-  return !next || next.type === 'element' && next.tagName === 'tr';
-}
-
-/**
- * Whether to omit `</td>` or `</th>`.
- *
- * @param {Element} _
- *   Element.
- * @param {number | undefined} index
- *   Index of element in parent.
- * @param {Parents | undefined} parent
- *   Parent of element.
- * @returns {boolean}
- *   Whether the closing tag can be omitted.
- */
-function cells(_, index, parent) {
-  const next = siblingAfter(parent, index);
-  return !next || next.type === 'element' && (next.tagName === 'td' || next.tagName === 'th');
-}
-
-/**
- * @import {Element, Parents} from 'hast'
- */
-
-const opening = omission({
-  body,
-  colgroup,
-  head,
-  html,
-  tbody
-});
-
-/**
- * Whether to omit `<html>`.
- *
- * @param {Element} node
- *   Element.
- * @returns {boolean}
- *   Whether the opening tag can be omitted.
- */
-function html(node) {
-  const head = siblingAfter(node, -1);
-  return !head || head.type !== 'comment';
-}
-
-/**
- * Whether to omit `<head>`.
- *
- * @param {Element} node
- *   Element.
- * @returns {boolean}
- *   Whether the opening tag can be omitted.
- */
-function head(node) {
-  /** @type {Set<string>} */
-  const seen = new Set();
-
-  // Whether `srcdoc` or not,
-  // make sure the content model at least doesn’t have too many `base`s/`title`s.
-  for (const child of node.children) {
-    if (child.type === 'element' && (child.tagName === 'base' || child.tagName === 'title')) {
-      if (seen.has(child.tagName)) return false;
-      seen.add(child.tagName);
-    }
-  }
-
-  // “May be omitted if the element is empty,
-  // or if the first thing inside the head element is an element.”
-  const child = node.children[0];
-  return !child || child.type === 'element';
-}
-
-/**
- * Whether to omit `<body>`.
- *
- * @param {Element} node
- *   Element.
- * @returns {boolean}
- *   Whether the opening tag can be omitted.
- */
-function body(node) {
-  const head = siblingAfter(node, -1, true);
-  return !head || head.type !== 'comment' && !(head.type === 'text' && whitespace(head.value.charAt(0))) && !(head.type === 'element' && (head.tagName === 'meta' || head.tagName === 'link' || head.tagName === 'script' || head.tagName === 'style' || head.tagName === 'template'));
-}
-
-/**
- * Whether to omit `<colgroup>`.
- * The spec describes some logic for the opening tag, but it’s easier to
- * implement in the closing tag, to the same effect, so we handle it there
- * instead.
- *
- * @param {Element} node
- *   Element.
- * @param {number | undefined} index
- *   Index of element in parent.
- * @param {Parents | undefined} parent
- *   Parent of element.
- * @returns {boolean}
- *   Whether the opening tag can be omitted.
- */
-function colgroup(node, index, parent) {
-  const previous = siblingBefore(parent, index);
-  const head = siblingAfter(node, -1, true);
-
-  // Previous colgroup was already omitted.
-  if (parent && previous && previous.type === 'element' && previous.tagName === 'colgroup' && closing(previous, parent.children.indexOf(previous), parent)) {
-    return false;
-  }
-  return Boolean(head && head.type === 'element' && head.tagName === 'col');
-}
-
-/**
- * Whether to omit `<tbody>`.
- *
- * @param {Element} node
- *   Element.
- * @param {number | undefined} index
- *   Index of element in parent.
- * @param {Parents | undefined} parent
- *   Parent of element.
- * @returns {boolean}
- *   Whether the opening tag can be omitted.
- */
-function tbody(node, index, parent) {
-  const previous = siblingBefore(parent, index);
-  const head = siblingAfter(node, -1);
-
-  // Previous table section was already omitted.
-  if (parent && previous && previous.type === 'element' && (previous.tagName === 'thead' || previous.tagName === 'tbody') && closing(previous, parent.children.indexOf(previous), parent)) {
-    return false;
-  }
-  return Boolean(head && head.type === 'element' && head.tagName === 'tr');
-}
-
-/**
- * @import {Element, Parents, Properties} from 'hast'
- * @import {State} from '../index.js'
- */
-
-
-/**
- * Maps of subsets.
- *
- * Each value is a matrix of tuples.
- * The value at `0` causes parse errors, the value at `1` is valid.
- * Of both, the value at `0` is unsafe, and the value at `1` is safe.
- *
- * @type {Record<'double' | 'name' | 'single' | 'unquoted', Array<[Array<string>, Array<string>]>>}
- */
-const constants = {
-  // See: <https://html.spec.whatwg.org/#attribute-name-state>.
-  name: [['\t\n\f\r &/=>'.split(''), '\t\n\f\r "&\'/=>`'.split('')], ['\0\t\n\f\r "&\'/<=>'.split(''), '\0\t\n\f\r "&\'/<=>`'.split('')]],
-  // See: <https://html.spec.whatwg.org/#attribute-value-(unquoted)-state>.
-  unquoted: [['\t\n\f\r &>'.split(''), '\0\t\n\f\r "&\'<=>`'.split('')], ['\0\t\n\f\r "&\'<=>`'.split(''), '\0\t\n\f\r "&\'<=>`'.split('')]],
-  // See: <https://html.spec.whatwg.org/#attribute-value-(single-quoted)-state>.
-  single: [["&'".split(''), '"&\'`'.split('')], ["\0&'".split(''), '\0"&\'`'.split('')]],
-  // See: <https://html.spec.whatwg.org/#attribute-value-(double-quoted)-state>.
-  double: [['"&'.split(''), '"&\'`'.split('')], ['\0"&'.split(''), '\0"&\'`'.split('')]]
-};
-
-/**
- * Serialize an element node.
- *
- * @param {Element} node
- *   Node to handle.
- * @param {number | undefined} index
- *   Index of `node` in `parent.
- * @param {Parents | undefined} parent
- *   Parent of `node`.
- * @param {State} state
- *   Info passed around about the current state.
- * @returns {string}
- *   Serialized node.
- */
-function element(node, index, parent, state) {
-  const schema = state.schema;
-  const omit = schema.space === 'svg' ? false : state.settings.omitOptionalTags;
-  let selfClosing = schema.space === 'svg' ? state.settings.closeEmptyElements : state.settings.voids.includes(node.tagName.toLowerCase());
-  /** @type {Array<string>} */
-  const parts = [];
-  /** @type {string} */
-  let last;
-  if (schema.space === 'html' && node.tagName === 'svg') {
-    state.schema = svg;
-  }
-  const attributes = serializeAttributes(state, node.properties);
-  const content = state.all(schema.space === 'html' && node.tagName === 'template' ? node.content : node);
-  state.schema = schema;
-
-  // If the node is categorised as void, but it has children, remove the
-  // categorisation.
-  // This enables for example `menuitem`s, which are void in W3C HTML but not
-  // void in WHATWG HTML, to be stringified properly.
-  // Note: `menuitem` has since been removed from the HTML spec, and so is no
-  // longer void.
-  if (content) selfClosing = false;
-  if (attributes || !omit || !opening(node, index, parent)) {
-    parts.push('<', node.tagName, attributes ? ' ' + attributes : '');
-    if (selfClosing && (schema.space === 'svg' || state.settings.closeSelfClosing)) {
-      last = attributes.charAt(attributes.length - 1);
-      if (!state.settings.tightSelfClosing || last === '/' || last && last !== '"' && last !== "'") {
-        parts.push(' ');
-      }
-      parts.push('/');
-    }
-    parts.push('>');
-  }
-  parts.push(content);
-  if (!selfClosing && (!omit || !closing(node, index, parent))) {
-    parts.push('</' + node.tagName + '>');
-  }
-  return parts.join('');
-}
-
-/**
- * @param {State} state
- * @param {Properties | null | undefined} properties
- * @returns {string}
- */
-function serializeAttributes(state, properties) {
-  /** @type {Array<string>} */
-  const values = [];
-  let index = -1;
-  /** @type {string} */
-  let key;
-  if (properties) {
-    for (key in properties) {
-      if (properties[key] !== null && properties[key] !== undefined) {
-        const value = serializeAttribute(state, key, properties[key]);
-        if (value) values.push(value);
-      }
-    }
-  }
-  while (++index < values.length) {
-    const last = state.settings.tightAttributes ? values[index].charAt(values[index].length - 1) : undefined;
-
-    // In tight mode, don’t add a space after quoted attributes.
-    if (index !== values.length - 1 && last !== '"' && last !== "'") {
-      values[index] += ' ';
-    }
-  }
-  return values.join('');
-}
-
-/**
- * @param {State} state
- * @param {string} key
- * @param {Properties[keyof Properties]} value
- * @returns {string}
- */
-function serializeAttribute(state, key, value) {
-  const info = find(state.schema, key);
-  const x = state.settings.allowParseErrors && state.schema.space === 'html' ? 0 : 1;
-  const y = state.settings.allowDangerousCharacters ? 0 : 1;
-  let quote = state.quote;
-  /** @type {string | undefined} */
-  let result;
-  if (info.overloadedBoolean && (value === info.attribute || value === '')) {
-    value = true;
-  } else if ((info.boolean || info.overloadedBoolean) && (typeof value !== 'string' || value === info.attribute || value === '')) {
-    value = Boolean(value);
-  }
-  if (value === null || value === undefined || value === false || typeof value === 'number' && Number.isNaN(value)) {
-    return '';
-  }
-  const name = stringifyEntities(info.attribute, Object.assign({}, state.settings.characterReferences, {
-    // Always encode without parse errors in non-HTML.
-    subset: constants.name[x][y]
-  }));
-
-  // No value.
-  // There is currently only one boolean property in SVG: `[download]` on
-  // `<a>`.
-  // This property does not seem to work in browsers (Firefox, Safari, Chrome),
-  // so I can’t test if dropping the value works.
-  // But I assume that it should:
-  //
-  // ```html
-  // <!doctype html>
-  // <svg viewBox="0 0 100 100">
-  //   <a href=https://example.com download>
-  //     <circle cx=50 cy=40 r=35 />
-  //   </a>
-  // </svg>
-  // ```
-  //
-  // See: <https://github.com/wooorm/property-information/blob/main/lib/svg.js>
-  if (value === true) return name;
-
-  // `spaces` doesn’t accept a second argument, but it’s given here just to
-  // keep the code cleaner.
-  value = Array.isArray(value) ? (info.commaSeparated ? stringify : stringify$1)(value, {
-    padLeft: !state.settings.tightCommaSeparatedLists
-  }) : String(value);
-  if (state.settings.collapseEmptyAttributes && !value) return name;
-
-  // Check unquoted value.
-  if (state.settings.preferUnquoted) {
-    result = stringifyEntities(value, Object.assign({}, state.settings.characterReferences, {
-      attribute: true,
-      subset: constants.unquoted[x][y]
-    }));
-  }
-
-  // If we don’t want unquoted, or if `value` contains character references when
-  // unquoted…
-  if (result !== value) {
-    // If the alternative is less common than `quote`, switch.
-    if (state.settings.quoteSmart && ccount(value, quote) > ccount(value, state.alternative)) {
-      quote = state.alternative;
-    }
-    result = quote + stringifyEntities(value, Object.assign({}, state.settings.characterReferences, {
-      // Always encode without parse errors in non-HTML.
-      subset: (quote === "'" ? constants.single : constants.double)[x][y],
-      attribute: true
-    })) + quote;
-  }
-
-  // Don’t add a `=` for unquoted empties.
-  return name + (result ? '=' + result : result);
-}
-
-/**
- * @import {Parents, Text} from 'hast'
- * @import {Raw} from 'mdast-util-to-hast'
- * @import {State} from '../index.js'
- */
-
-
-// Declare array as variable so it can be cached by `stringifyEntities`
-const textEntitySubset = ['<', '&'];
-
-/**
- * Serialize a text node.
- *
- * @param {Raw | Text} node
- *   Node to handle.
- * @param {number | undefined} _
- *   Index of `node` in `parent.
- * @param {Parents | undefined} parent
- *   Parent of `node`.
- * @param {State} state
- *   Info passed around about the current state.
- * @returns {string}
- *   Serialized node.
- */
-function text(node, _, parent, state) {
-  // Check if content of `node` should be escaped.
-  return parent && parent.type === 'element' && (parent.tagName === 'script' || parent.tagName === 'style') ? node.value : stringifyEntities(node.value, Object.assign({}, state.settings.characterReferences, {
-    subset: textEntitySubset
-  }));
-}
-
-/**
- * @import {Parents} from 'hast'
- * @import {Raw} from 'mdast-util-to-hast'
- * @import {State} from '../index.js'
- */
-
-
-/**
- * Serialize a raw node.
- *
- * @param {Raw} node
- *   Node to handle.
- * @param {number | undefined} index
- *   Index of `node` in `parent.
- * @param {Parents | undefined} parent
- *   Parent of `node`.
- * @param {State} state
- *   Info passed around about the current state.
- * @returns {string}
- *   Serialized node.
- */
-function raw(node, index, parent, state) {
-  return state.settings.allowDangerousHtml ? node.value : text(node, index, parent, state);
-}
-
-/**
- * @import {Parents, Root} from 'hast'
- * @import {State} from '../index.js'
- */
-
-/**
- * Serialize a root.
- *
- * @param {Root} node
- *   Node to handle.
- * @param {number | undefined} _1
- *   Index of `node` in `parent.
- * @param {Parents | undefined} _2
- *   Parent of `node`.
- * @param {State} state
- *   Info passed around about the current state.
- * @returns {string}
- *   Serialized node.
- */
-function root(node, _1, _2, state) {
-  return state.all(node);
-}
-
-/**
- * @import {Nodes, Parents} from 'hast'
- * @import {State} from '../index.js'
- */
-
-
-/**
- * @type {(node: Nodes, index: number | undefined, parent: Parents | undefined, state: State) => string}
- */
-const handle = zwitch('type', {
-  invalid,
-  unknown,
-  handlers: {
-    comment,
-    doctype,
-    element,
-    raw,
-    root,
-    text
-  }
-});
-
-/**
- * Fail when a non-node is found in the tree.
- *
- * @param {unknown} node
- *   Unknown value.
- * @returns {never}
- *   Never.
- */
-function invalid(node) {
-  throw new Error('Expected node, not `' + node + '`');
-}
-
-/**
- * Fail when a node with an unknown type is found in the tree.
- *
- * @param {unknown} node_
- *  Unknown node.
- * @returns {never}
- *   Never.
- */
-function unknown(node_) {
-  // `type` is guaranteed by runtime JS.
-  const node = /** @type {Nodes} */node_;
-  throw new Error('Cannot compile unknown node `' + node.type + '`');
-}
-
-/**
- * @import {Nodes, Parents, RootContent} from 'hast'
- * @import {Schema} from 'property-information'
- * @import {Options as StringifyEntitiesOptions} from 'stringify-entities'
- */
-
-
-/** @type {Options} */
-const emptyOptions = {};
-
-/** @type {CharacterReferences} */
-const emptyCharacterReferences = {};
-
-/** @type {Array<never>} */
-const emptyChildren = [];
-
-/**
- * Serialize hast as HTML.
- *
- * @param {Array<RootContent> | Nodes} tree
- *   Tree to serialize.
- * @param {Options | null | undefined} [options]
- *   Configuration (optional).
- * @returns {string}
- *   Serialized HTML.
- */
-function toHtml(tree, options) {
-  const options_ = options || emptyOptions;
-  const quote = options_.quote || '"';
-  const alternative = quote === '"' ? "'" : '"';
-  if (quote !== '"' && quote !== "'") {
-    throw new Error('Invalid quote `' + quote + '`, expected `\'` or `"`');
-  }
-
-  /** @type {State} */
-  const state = {
-    one,
-    all,
-    settings: {
-      omitOptionalTags: options_.omitOptionalTags || false,
-      allowParseErrors: options_.allowParseErrors || false,
-      allowDangerousCharacters: options_.allowDangerousCharacters || false,
-      quoteSmart: options_.quoteSmart || false,
-      preferUnquoted: options_.preferUnquoted || false,
-      tightAttributes: options_.tightAttributes || false,
-      upperDoctype: options_.upperDoctype || false,
-      tightDoctype: options_.tightDoctype || false,
-      bogusComments: options_.bogusComments || false,
-      tightCommaSeparatedLists: options_.tightCommaSeparatedLists || false,
-      tightSelfClosing: options_.tightSelfClosing || false,
-      collapseEmptyAttributes: options_.collapseEmptyAttributes || false,
-      allowDangerousHtml: options_.allowDangerousHtml || false,
-      voids: options_.voids || htmlVoidElements,
-      characterReferences: options_.characterReferences || emptyCharacterReferences,
-      closeSelfClosing: options_.closeSelfClosing || false,
-      closeEmptyElements: options_.closeEmptyElements || false
-    },
-    schema: options_.space === 'svg' ? svg : html$2,
-    quote,
-    alternative
-  };
-  return state.one(Array.isArray(tree) ? {
-    type: 'root',
-    children: tree
-  } : tree, undefined, undefined);
-}
-
-/**
- * Serialize a node.
- *
- * @this {State}
- *   Info passed around about the current state.
- * @param {Nodes} node
- *   Node to handle.
- * @param {number | undefined} index
- *   Index of `node` in `parent.
- * @param {Parents | undefined} parent
- *   Parent of `node`.
- * @returns {string}
- *   Serialized node.
- */
-function one(node, index, parent) {
-  return handle(node, index, parent, this);
-}
-
-/**
- * Serialize all children of `parent`.
- *
- * @this {State}
- *   Info passed around about the current state.
- * @param {Parents | undefined} parent
- *   Parent whose children to serialize.
- * @returns {string}
- */
-function all(parent) {
-  /** @type {Array<string>} */
-  const results = [];
-  const children = parent && parent.children || emptyChildren;
-  let index = -1;
-  while (++index < children.length) {
-    results[index] = this.one(children[index], index, parent);
-  }
-  return results.join('');
-}
-
-/**
- * @import {Root} from 'hast'
- * @import {Options} from 'hast-util-to-html'
- * @import {Compiler, Processor} from 'unified'
- */
-
-
-/**
- * Plugin to add support for serializing as HTML.
- *
- * @param {Options | null | undefined} [options]
- *   Configuration (optional).
- * @returns {undefined}
- *   Nothing.
- */
-function rehypeStringify(options) {
-  /** @type {Processor<undefined, undefined, undefined, Root, string>} */
-  // @ts-expect-error: TS in JSDoc generates wrong types if `this` is typed regularly.
-  const self = this;
-  const settings = {
-    ...self.data('settings'),
-    ...options
-  };
-  self.compiler = compiler;
-
-  /**
-   * @type {Compiler<Root, string>}
-   */
-  function compiler(tree) {
-    return toHtml(tree, settings);
-  }
-}
-
-export { rehypeStringify as default };
-//# sourceMappingURL=index-C371bO_b.js.map