{"version":3,"file":"main/static/js/826.eb54bc92.js","mappings":"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","sources":["../../../node_modules/ahooks/es/utils/index.js","../../../node_modules/ahooks/es/utils/isBrowser.js","../../../node_modules/ahooks/es/utils/domTarget.js","../../../node_modules/ahooks/es/useLatest/index.js","../../../node_modules/ahooks/es/useUnmount/index.js","../../../node_modules/ahooks/es/utils/depsAreSame.js","../../../node_modules/ahooks/es/utils/createEffectWithTarget.js","../../../node_modules/ahooks/es/utils/useEffectWithTarget.js","../../../node_modules/ahooks/es/useInViewport/index.js","../../../node_modules/ahooks/node_modules/intersection-observer/intersection-observer.js","../../../node_modules/extend/index.js","../../../node_modules/inline-style-parser/index.js","../../../node_modules/querystring/decode.js","../../../node_modules/querystring/encode.js","../../../node_modules/querystring/index.js","../../../node_modules/scroll-into-view-if-needed/es/index.js","../../../node_modules/style-to-object/cjs/index.js","../../../node_modules/estree-util-is-identifier-name/lib/index.js","../../../node_modules/hast-util-whitespace/lib/index.js","../../../node_modules/property-information/lib/util/schema.js","../../../node_modules/property-information/lib/util/merge.js","../../../node_modules/property-information/lib/normalize.js","../../../node_modules/property-information/lib/util/info.js","../../../node_modules/property-information/lib/util/types.js","../../../node_modules/property-information/lib/util/defined-info.js","../../../node_modules/property-information/lib/util/create.js","../../../node_modules/property-information/lib/xlink.js","../../../node_modules/property-information/lib/xml.js","../../../node_modules/property-information/lib/util/case-sensitive-transform.js","../../../node_modules/property-information/lib/util/case-insensitive-transform.js","../../../node_modules/property-information/lib/xmlns.js","../../../node_modules/property-information/lib/aria.js","../../../node_modules/property-information/lib/html.js","../../../node_modules/property-information/lib/svg.js","../../../node_modules/property-information/index.js","../../../node_modules/property-information/lib/find.js","../../../node_modules/property-information/lib/hast-to-react.js","../../../node_modules/style-to-object/esm/index.mjs","../../../node_modules/unist-util-position/lib/index.js","../../../node_modules/unist-util-stringify-position/lib/index.js","../../../node_modules/vfile-message/lib/index.js","../../../node_modules/hast-util-to-jsx-runtime/lib/index.js","../../../node_modules/comma-separated-tokens/index.js","../../../node_modules/space-separated-tokens/index.js","../../../node_modules/html-url-attributes/lib/index.js","../../../node_modules/mdast-util-to-string/lib/index.js","../../../node_modules/micromark-util-chunked/index.js","../../../node_modules/micromark-util-subtokenize/lib/splice-buffer.js","../../../node_modules/micromark-util-subtokenize/index.js","../../../node_modules/micromark-util-combine-extensions/index.js","../../../node_modules/micromark-util-character/index.js","../../../node_modules/micromark-factory-space/index.js","../../../node_modules/micromark/lib/initialize/content.js","../../../node_modules/micromark/lib/initialize/document.js","../../../node_modules/micromark-core-commonmark/lib/blank-line.js","../../../node_modules/micromark-core-commonmark/lib/content.js","../../../node_modules/micromark/lib/initialize/flow.js","../../../node_modules/micromark/lib/initialize/text.js","../../../node_modules/micromark-core-commonmark/lib/thematic-break.js","../../../node_modules/micromark-core-commonmark/lib/list.js","../../../node_modules/micromark-core-commonmark/lib/block-quote.js","../../../node_modules/micromark-factory-destination/index.js","../../../node_modules/micromark-factory-label/index.js","../../../node_modules/micromark-factory-title/index.js","../../../node_modules/micromark-factory-whitespace/index.js","../../../node_modules/micromark-util-normalize-identifier/index.js","../../../node_modules/micromark-core-commonmark/lib/definition.js","../../../node_modules/micromark-core-commonmark/lib/code-indented.js","../../../node_modules/micromark-core-commonmark/lib/heading-atx.js","../../../node_modules/micromark-core-commonmark/lib/setext-underline.js","../../../node_modules/micromark-util-html-tag-name/index.js","../../../node_modules/micromark-core-commonmark/lib/html-flow.js","../../../node_modules/micromark-core-commonmark/lib/code-fenced.js","../../../node_modules/decode-named-character-reference/index.dom.js","../../../node_modules/micromark-core-commonmark/lib/character-reference.js","../../../node_modules/micromark-core-commonmark/lib/character-escape.js","../../../node_modules/micromark-core-commonmark/lib/line-ending.js","../../../node_modules/micromark-util-resolve-all/index.js","../../../node_modules/micromark-core-commonmark/lib/label-end.js","../../../node_modules/micromark-core-commonmark/lib/label-start-image.js","../../../node_modules/micromark-util-classify-character/index.js","../../../node_modules/micromark-core-commonmark/lib/attention.js","../../../node_modules/micromark-core-commonmark/lib/autolink.js","../../../node_modules/micromark-core-commonmark/lib/html-text.js","../../../node_modules/micromark-core-commonmark/lib/label-start-link.js","../../../node_modules/micromark-core-commonmark/lib/hard-break-escape.js","../../../node_modules/micromark-core-commonmark/lib/code-text.js","../../../node_modules/micromark/lib/constructs.js","../../../node_modules/micromark/lib/create-tokenizer.js","../../../node_modules/micromark/lib/parse.js","../../../node_modules/micromark/lib/preprocess.js","../../../node_modules/micromark-util-decode-numeric-character-reference/index.js","../../../node_modules/micromark-util-decode-string/index.js","../../../node_modules/mdast-util-from-markdown/lib/index.js","../../../node_modules/micromark/lib/postprocess.js","../../../node_modules/remark-parse/lib/index.js","../../../node_modules/@ungap/structured-clone/esm/types.js","../../../node_modules/@ungap/structured-clone/esm/deserialize.js","../../../node_modules/@ungap/structured-clone/esm/serialize.js","../../../node_modules/@ungap/structured-clone/esm/index.js","../../../node_modules/micromark-util-sanitize-uri/index.js","../../../node_modules/mdast-util-to-hast/lib/footer.js","../../../node_modules/unist-util-is/lib/index.js","../../../node_modules/unist-util-visit-parents/lib/index.js","../../../node_modules/unist-util-visit/lib/index.js","../../../node_modules/mdast-util-to-hast/lib/revert.js","../../../node_modules/mdast-util-to-hast/lib/handlers/list-item.js","../../../node_modules/trim-lines/index.js","../../../node_modules/mdast-util-to-hast/lib/handlers/index.js","../../../node_modules/mdast-util-to-hast/lib/handlers/blockquote.js","../../../node_modules/mdast-util-to-hast/lib/handlers/break.js","../../../node_modules/mdast-util-to-hast/lib/handlers/code.js","../../../node_modules/mdast-util-to-hast/lib/handlers/delete.js","../../../node_modules/mdast-util-to-hast/lib/handlers/emphasis.js","../../../node_modules/mdast-util-to-hast/lib/handlers/footnote-reference.js","../../../node_modules/mdast-util-to-hast/lib/handlers/heading.js","../../../node_modules/mdast-util-to-hast/lib/handlers/html.js","../../../node_modules/mdast-util-to-hast/lib/handlers/image-reference.js","../../../node_modules/mdast-util-to-hast/lib/handlers/image.js","../../../node_modules/mdast-util-to-hast/lib/handlers/inline-code.js","../../../node_modules/mdast-util-to-hast/lib/handlers/link-reference.js","../../../node_modules/mdast-util-to-hast/lib/handlers/link.js","../../../node_modules/mdast-util-to-hast/lib/handlers/list.js","../../../node_modules/mdast-util-to-hast/lib/handlers/paragraph.js","../../../node_modules/mdast-util-to-hast/lib/handlers/root.js","../../../node_modules/mdast-util-to-hast/lib/handlers/strong.js","../../../node_modules/mdast-util-to-hast/lib/handlers/table.js","../../../node_modules/mdast-util-to-hast/lib/handlers/table-cell.js","../../../node_modules/mdast-util-to-hast/lib/handlers/table-row.js","../../../node_modules/mdast-util-to-hast/lib/handlers/text.js","../../../node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js","../../../node_modules/mdast-util-to-hast/lib/state.js","../../../node_modules/mdast-util-to-hast/lib/index.js","../../../node_modules/remark-rehype/lib/index.js","../../../node_modules/bail/index.js","../../../node_modules/unified/node_modules/is-plain-obj/index.js","../../../node_modules/trough/lib/index.js","../../../node_modules/vfile/lib/minpath.browser.js","../../../node_modules/vfile/lib/minproc.browser.js","../../../node_modules/vfile/lib/minurl.shared.js","../../../node_modules/vfile/lib/minurl.browser.js","../../../node_modules/vfile/lib/index.js","../../../node_modules/unified/lib/callable-instance.js","../../../node_modules/unified/lib/index.js","../../../node_modules/react-markdown/lib/index.js"],"sourcesContent":["export var isObject = function (value) {\n  return value !== null && typeof value === 'object';\n};\nexport var isFunction = function (value) {\n  return typeof value === 'function';\n};\nexport var isString = function (value) {\n  return typeof value === 'string';\n};\nexport var isBoolean = function (value) {\n  return typeof value === 'boolean';\n};\nexport var isNumber = function (value) {\n  return typeof value === 'number';\n};\nexport var isUndef = function (value) {\n  return typeof value === 'undefined';\n};","var isBrowser = !!(typeof window !== 'undefined' && window.document && window.document.createElement);\nexport default isBrowser;","import { isFunction } from './index';\nimport isBrowser from './isBrowser';\nexport function getTargetElement(target, defaultElement) {\n  if (!isBrowser) {\n    return undefined;\n  }\n  if (!target) {\n    return defaultElement;\n  }\n  var targetElement;\n  if (isFunction(target)) {\n    targetElement = target();\n  } else if ('current' in target) {\n    targetElement = target.current;\n  } else {\n    targetElement = target;\n  }\n  return targetElement;\n}","import { useRef } from 'react';\nfunction useLatest(value) {\n  var ref = useRef(value);\n  ref.current = value;\n  return ref;\n}\nexport default useLatest;","import { useEffect } from 'react';\nimport useLatest from '../useLatest';\nimport { isFunction } from '../utils';\nimport isDev from '../utils/isDev';\nvar useUnmount = function (fn) {\n  if (isDev) {\n    if (!isFunction(fn)) {\n      console.error(\"useUnmount expected parameter is a function, got \".concat(typeof fn));\n    }\n  }\n  var fnRef = useLatest(fn);\n  useEffect(function () {\n    return function () {\n      fnRef.current();\n    };\n  }, []);\n};\nexport default useUnmount;","export default function depsAreSame(oldDeps, deps) {\n  if (oldDeps === deps) return true;\n  for (var i = 0; i < oldDeps.length; i++) {\n    if (!Object.is(oldDeps[i], deps[i])) return false;\n  }\n  return true;\n}","import { useRef } from 'react';\nimport useUnmount from '../useUnmount';\nimport depsAreSame from './depsAreSame';\nimport { getTargetElement } from './domTarget';\nvar createEffectWithTarget = function (useEffectType) {\n  /**\n   *\n   * @param effect\n   * @param deps\n   * @param target target should compare ref.current vs ref.current, dom vs dom, ()=>dom vs ()=>dom\n   */\n  var useEffectWithTarget = function (effect, deps, target) {\n    var hasInitRef = useRef(false);\n    var lastElementRef = useRef([]);\n    var lastDepsRef = useRef([]);\n    var unLoadRef = useRef();\n    useEffectType(function () {\n      var _a;\n      var targets = Array.isArray(target) ? target : [target];\n      var els = targets.map(function (item) {\n        return getTargetElement(item);\n      });\n      // init run\n      if (!hasInitRef.current) {\n        hasInitRef.current = true;\n        lastElementRef.current = els;\n        lastDepsRef.current = deps;\n        unLoadRef.current = effect();\n        return;\n      }\n      if (els.length !== lastElementRef.current.length || !depsAreSame(els, lastElementRef.current) || !depsAreSame(deps, lastDepsRef.current)) {\n        (_a = unLoadRef.current) === null || _a === void 0 ? void 0 : _a.call(unLoadRef);\n        lastElementRef.current = els;\n        lastDepsRef.current = deps;\n        unLoadRef.current = effect();\n      }\n    });\n    useUnmount(function () {\n      var _a;\n      (_a = unLoadRef.current) === null || _a === void 0 ? void 0 : _a.call(unLoadRef);\n      // for react-refresh\n      hasInitRef.current = false;\n    });\n  };\n  return useEffectWithTarget;\n};\nexport default createEffectWithTarget;","import { useEffect } from 'react';\nimport createEffectWithTarget from './createEffectWithTarget';\nvar useEffectWithTarget = createEffectWithTarget(useEffect);\nexport default useEffectWithTarget;","import { __assign, __read, __rest, __values } from \"tslib\";\nimport 'intersection-observer';\nimport { useState } from 'react';\nimport { getTargetElement } from '../utils/domTarget';\nimport useEffectWithTarget from '../utils/useEffectWithTarget';\nfunction useInViewport(target, options) {\n  var _a = options || {},\n    callback = _a.callback,\n    option = __rest(_a, [\"callback\"]);\n  var _b = __read(useState(), 2),\n    state = _b[0],\n    setState = _b[1];\n  var _c = __read(useState(), 2),\n    ratio = _c[0],\n    setRatio = _c[1];\n  useEffectWithTarget(function () {\n    var targets = Array.isArray(target) ? target : [target];\n    var els = targets.map(function (element) {\n      return getTargetElement(element);\n    }).filter(Boolean);\n    if (!els.length) {\n      return;\n    }\n    var observer = new IntersectionObserver(function (entries) {\n      var e_1, _a;\n      try {\n        for (var entries_1 = __values(entries), entries_1_1 = entries_1.next(); !entries_1_1.done; entries_1_1 = entries_1.next()) {\n          var entry = entries_1_1.value;\n          setRatio(entry.intersectionRatio);\n          setState(entry.isIntersecting);\n          callback === null || callback === void 0 ? void 0 : callback(entry);\n        }\n      } catch (e_1_1) {\n        e_1 = {\n          error: e_1_1\n        };\n      } finally {\n        try {\n          if (entries_1_1 && !entries_1_1.done && (_a = entries_1.return)) _a.call(entries_1);\n        } finally {\n          if (e_1) throw e_1.error;\n        }\n      }\n    }, __assign(__assign({}, option), {\n      root: getTargetElement(options === null || options === void 0 ? void 0 : options.root)\n    }));\n    els.forEach(function (el) {\n      if (el) {\n        observer.observe(el);\n      }\n    });\n    return function () {\n      observer.disconnect();\n    };\n  }, [options === null || options === void 0 ? void 0 : options.rootMargin, options === null || options === void 0 ? void 0 : options.threshold, callback], target);\n  return [state, ratio];\n}\nexport default useInViewport;","/**\n * Copyright 2016 Google Inc. All Rights Reserved.\n *\n * Licensed under the W3C SOFTWARE AND DOCUMENT NOTICE AND LICENSE.\n *\n *  https://www.w3.org/Consortium/Legal/2015/copyright-software-and-document\n *\n */\n(function() {\n'use strict';\n\n// Exit early if we're not running in a browser.\nif (typeof window !== 'object') {\n  return;\n}\n\n// Exit early if all IntersectionObserver and IntersectionObserverEntry\n// features are natively supported.\nif ('IntersectionObserver' in window &&\n    'IntersectionObserverEntry' in window &&\n    'intersectionRatio' in window.IntersectionObserverEntry.prototype) {\n\n  // Minimal polyfill for Edge 15's lack of `isIntersecting`\n  // See: https://github.com/w3c/IntersectionObserver/issues/211\n  if (!('isIntersecting' in window.IntersectionObserverEntry.prototype)) {\n    Object.defineProperty(window.IntersectionObserverEntry.prototype,\n      'isIntersecting', {\n      get: function () {\n        return this.intersectionRatio > 0;\n      }\n    });\n  }\n  return;\n}\n\n/**\n * Returns the embedding frame element, if any.\n * @param {!Document} doc\n * @return {!Element}\n */\nfunction getFrameElement(doc) {\n  try {\n    return doc.defaultView && doc.defaultView.frameElement || null;\n  } catch (e) {\n    // Ignore the error.\n    return null;\n  }\n}\n\n/**\n * A local reference to the root document.\n */\nvar document = (function(startDoc) {\n  var doc = startDoc;\n  var frame = getFrameElement(doc);\n  while (frame) {\n    doc = frame.ownerDocument;\n    frame = getFrameElement(doc);\n  }\n  return doc;\n})(window.document);\n\n/**\n * An IntersectionObserver registry. This registry exists to hold a strong\n * reference to IntersectionObserver instances currently observing a target\n * element. Without this registry, instances without another reference may be\n * garbage collected.\n */\nvar registry = [];\n\n/**\n * The signal updater for cross-origin intersection. When not null, it means\n * that the polyfill is configured to work in a cross-origin mode.\n * @type {function(DOMRect|ClientRect, DOMRect|ClientRect)}\n */\nvar crossOriginUpdater = null;\n\n/**\n * The current cross-origin intersection. Only used in the cross-origin mode.\n * @type {DOMRect|ClientRect}\n */\nvar crossOriginRect = null;\n\n\n/**\n * Creates the global IntersectionObserverEntry constructor.\n * https://w3c.github.io/IntersectionObserver/#intersection-observer-entry\n * @param {Object} entry A dictionary of instance properties.\n * @constructor\n */\nfunction IntersectionObserverEntry(entry) {\n  this.time = entry.time;\n  this.target = entry.target;\n  this.rootBounds = ensureDOMRect(entry.rootBounds);\n  this.boundingClientRect = ensureDOMRect(entry.boundingClientRect);\n  this.intersectionRect = ensureDOMRect(entry.intersectionRect || getEmptyRect());\n  this.isIntersecting = !!entry.intersectionRect;\n\n  // Calculates the intersection ratio.\n  var targetRect = this.boundingClientRect;\n  var targetArea = targetRect.width * targetRect.height;\n  var intersectionRect = this.intersectionRect;\n  var intersectionArea = intersectionRect.width * intersectionRect.height;\n\n  // Sets intersection ratio.\n  if (targetArea) {\n    // Round the intersection ratio to avoid floating point math issues:\n    // https://github.com/w3c/IntersectionObserver/issues/324\n    this.intersectionRatio = Number((intersectionArea / targetArea).toFixed(4));\n  } else {\n    // If area is zero and is intersecting, sets to 1, otherwise to 0\n    this.intersectionRatio = this.isIntersecting ? 1 : 0;\n  }\n}\n\n\n/**\n * Creates the global IntersectionObserver constructor.\n * https://w3c.github.io/IntersectionObserver/#intersection-observer-interface\n * @param {Function} callback The function to be invoked after intersection\n *     changes have queued. The function is not invoked if the queue has\n *     been emptied by calling the `takeRecords` method.\n * @param {Object=} opt_options Optional configuration options.\n * @constructor\n */\nfunction IntersectionObserver(callback, opt_options) {\n\n  var options = opt_options || {};\n\n  if (typeof callback != 'function') {\n    throw new Error('callback must be a function');\n  }\n\n  if (\n    options.root &&\n    options.root.nodeType != 1 &&\n    options.root.nodeType != 9\n  ) {\n    throw new Error('root must be a Document or Element');\n  }\n\n  // Binds and throttles `this._checkForIntersections`.\n  this._checkForIntersections = throttle(\n      this._checkForIntersections.bind(this), this.THROTTLE_TIMEOUT);\n\n  // Private properties.\n  this._callback = callback;\n  this._observationTargets = [];\n  this._queuedEntries = [];\n  this._rootMarginValues = this._parseRootMargin(options.rootMargin);\n\n  // Public properties.\n  this.thresholds = this._initThresholds(options.threshold);\n  this.root = options.root || null;\n  this.rootMargin = this._rootMarginValues.map(function(margin) {\n    return margin.value + margin.unit;\n  }).join(' ');\n\n  /** @private @const {!Array<!Document>} */\n  this._monitoringDocuments = [];\n  /** @private @const {!Array<function()>} */\n  this._monitoringUnsubscribes = [];\n}\n\n\n/**\n * The minimum interval within which the document will be checked for\n * intersection changes.\n */\nIntersectionObserver.prototype.THROTTLE_TIMEOUT = 100;\n\n\n/**\n * The frequency in which the polyfill polls for intersection changes.\n * this can be updated on a per instance basis and must be set prior to\n * calling `observe` on the first target.\n */\nIntersectionObserver.prototype.POLL_INTERVAL = null;\n\n/**\n * Use a mutation observer on the root element\n * to detect intersection changes.\n */\nIntersectionObserver.prototype.USE_MUTATION_OBSERVER = true;\n\n\n/**\n * Sets up the polyfill in the cross-origin mode. The result is the\n * updater function that accepts two arguments: `boundingClientRect` and\n * `intersectionRect` - just as these fields would be available to the\n * parent via `IntersectionObserverEntry`. This function should be called\n * each time the iframe receives intersection information from the parent\n * window, e.g. via messaging.\n * @return {function(DOMRect|ClientRect, DOMRect|ClientRect)}\n */\nIntersectionObserver._setupCrossOriginUpdater = function() {\n  if (!crossOriginUpdater) {\n    /**\n     * @param {DOMRect|ClientRect} boundingClientRect\n     * @param {DOMRect|ClientRect} intersectionRect\n     */\n    crossOriginUpdater = function(boundingClientRect, intersectionRect) {\n      if (!boundingClientRect || !intersectionRect) {\n        crossOriginRect = getEmptyRect();\n      } else {\n        crossOriginRect = convertFromParentRect(boundingClientRect, intersectionRect);\n      }\n      registry.forEach(function(observer) {\n        observer._checkForIntersections();\n      });\n    };\n  }\n  return crossOriginUpdater;\n};\n\n\n/**\n * Resets the cross-origin mode.\n */\nIntersectionObserver._resetCrossOriginUpdater = function() {\n  crossOriginUpdater = null;\n  crossOriginRect = null;\n};\n\n\n/**\n * Starts observing a target element for intersection changes based on\n * the thresholds values.\n * @param {Element} target The DOM element to observe.\n */\nIntersectionObserver.prototype.observe = function(target) {\n  var isTargetAlreadyObserved = this._observationTargets.some(function(item) {\n    return item.element == target;\n  });\n\n  if (isTargetAlreadyObserved) {\n    return;\n  }\n\n  if (!(target && target.nodeType == 1)) {\n    throw new Error('target must be an Element');\n  }\n\n  this._registerInstance();\n  this._observationTargets.push({element: target, entry: null});\n  this._monitorIntersections(target.ownerDocument);\n  this._checkForIntersections();\n};\n\n\n/**\n * Stops observing a target element for intersection changes.\n * @param {Element} target The DOM element to observe.\n */\nIntersectionObserver.prototype.unobserve = function(target) {\n  this._observationTargets =\n      this._observationTargets.filter(function(item) {\n        return item.element != target;\n      });\n  this._unmonitorIntersections(target.ownerDocument);\n  if (this._observationTargets.length == 0) {\n    this._unregisterInstance();\n  }\n};\n\n\n/**\n * Stops observing all target elements for intersection changes.\n */\nIntersectionObserver.prototype.disconnect = function() {\n  this._observationTargets = [];\n  this._unmonitorAllIntersections();\n  this._unregisterInstance();\n};\n\n\n/**\n * Returns any queue entries that have not yet been reported to the\n * callback and clears the queue. This can be used in conjunction with the\n * callback to obtain the absolute most up-to-date intersection information.\n * @return {Array} The currently queued entries.\n */\nIntersectionObserver.prototype.takeRecords = function() {\n  var records = this._queuedEntries.slice();\n  this._queuedEntries = [];\n  return records;\n};\n\n\n/**\n * Accepts the threshold value from the user configuration object and\n * returns a sorted array of unique threshold values. If a value is not\n * between 0 and 1 and error is thrown.\n * @private\n * @param {Array|number=} opt_threshold An optional threshold value or\n *     a list of threshold values, defaulting to [0].\n * @return {Array} A sorted list of unique and valid threshold values.\n */\nIntersectionObserver.prototype._initThresholds = function(opt_threshold) {\n  var threshold = opt_threshold || [0];\n  if (!Array.isArray(threshold)) threshold = [threshold];\n\n  return threshold.sort().filter(function(t, i, a) {\n    if (typeof t != 'number' || isNaN(t) || t < 0 || t > 1) {\n      throw new Error('threshold must be a number between 0 and 1 inclusively');\n    }\n    return t !== a[i - 1];\n  });\n};\n\n\n/**\n * Accepts the rootMargin value from the user configuration object\n * and returns an array of the four margin values as an object containing\n * the value and unit properties. If any of the values are not properly\n * formatted or use a unit other than px or %, and error is thrown.\n * @private\n * @param {string=} opt_rootMargin An optional rootMargin value,\n *     defaulting to '0px'.\n * @return {Array<Object>} An array of margin objects with the keys\n *     value and unit.\n */\nIntersectionObserver.prototype._parseRootMargin = function(opt_rootMargin) {\n  var marginString = opt_rootMargin || '0px';\n  var margins = marginString.split(/\\s+/).map(function(margin) {\n    var parts = /^(-?\\d*\\.?\\d+)(px|%)$/.exec(margin);\n    if (!parts) {\n      throw new Error('rootMargin must be specified in pixels or percent');\n    }\n    return {value: parseFloat(parts[1]), unit: parts[2]};\n  });\n\n  // Handles shorthand.\n  margins[1] = margins[1] || margins[0];\n  margins[2] = margins[2] || margins[0];\n  margins[3] = margins[3] || margins[1];\n\n  return margins;\n};\n\n\n/**\n * Starts polling for intersection changes if the polling is not already\n * happening, and if the page's visibility state is visible.\n * @param {!Document} doc\n * @private\n */\nIntersectionObserver.prototype._monitorIntersections = function(doc) {\n  var win = doc.defaultView;\n  if (!win) {\n    // Already destroyed.\n    return;\n  }\n  if (this._monitoringDocuments.indexOf(doc) != -1) {\n    // Already monitoring.\n    return;\n  }\n\n  // Private state for monitoring.\n  var callback = this._checkForIntersections;\n  var monitoringInterval = null;\n  var domObserver = null;\n\n  // If a poll interval is set, use polling instead of listening to\n  // resize and scroll events or DOM mutations.\n  if (this.POLL_INTERVAL) {\n    monitoringInterval = win.setInterval(callback, this.POLL_INTERVAL);\n  } else {\n    addEvent(win, 'resize', callback, true);\n    addEvent(doc, 'scroll', callback, true);\n    if (this.USE_MUTATION_OBSERVER && 'MutationObserver' in win) {\n      domObserver = new win.MutationObserver(callback);\n      domObserver.observe(doc, {\n        attributes: true,\n        childList: true,\n        characterData: true,\n        subtree: true\n      });\n    }\n  }\n\n  this._monitoringDocuments.push(doc);\n  this._monitoringUnsubscribes.push(function() {\n    // Get the window object again. When a friendly iframe is destroyed, it\n    // will be null.\n    var win = doc.defaultView;\n\n    if (win) {\n      if (monitoringInterval) {\n        win.clearInterval(monitoringInterval);\n      }\n      removeEvent(win, 'resize', callback, true);\n    }\n\n    removeEvent(doc, 'scroll', callback, true);\n    if (domObserver) {\n      domObserver.disconnect();\n    }\n  });\n\n  // Also monitor the parent.\n  var rootDoc =\n    (this.root && (this.root.ownerDocument || this.root)) || document;\n  if (doc != rootDoc) {\n    var frame = getFrameElement(doc);\n    if (frame) {\n      this._monitorIntersections(frame.ownerDocument);\n    }\n  }\n};\n\n\n/**\n * Stops polling for intersection changes.\n * @param {!Document} doc\n * @private\n */\nIntersectionObserver.prototype._unmonitorIntersections = function(doc) {\n  var index = this._monitoringDocuments.indexOf(doc);\n  if (index == -1) {\n    return;\n  }\n\n  var rootDoc =\n    (this.root && (this.root.ownerDocument || this.root)) || document;\n\n  // Check if any dependent targets are still remaining.\n  var hasDependentTargets =\n      this._observationTargets.some(function(item) {\n        var itemDoc = item.element.ownerDocument;\n        // Target is in this context.\n        if (itemDoc == doc) {\n          return true;\n        }\n        // Target is nested in this context.\n        while (itemDoc && itemDoc != rootDoc) {\n          var frame = getFrameElement(itemDoc);\n          itemDoc = frame && frame.ownerDocument;\n          if (itemDoc == doc) {\n            return true;\n          }\n        }\n        return false;\n      });\n  if (hasDependentTargets) {\n    return;\n  }\n\n  // Unsubscribe.\n  var unsubscribe = this._monitoringUnsubscribes[index];\n  this._monitoringDocuments.splice(index, 1);\n  this._monitoringUnsubscribes.splice(index, 1);\n  unsubscribe();\n\n  // Also unmonitor the parent.\n  if (doc != rootDoc) {\n    var frame = getFrameElement(doc);\n    if (frame) {\n      this._unmonitorIntersections(frame.ownerDocument);\n    }\n  }\n};\n\n\n/**\n * Stops polling for intersection changes.\n * @param {!Document} doc\n * @private\n */\nIntersectionObserver.prototype._unmonitorAllIntersections = function() {\n  var unsubscribes = this._monitoringUnsubscribes.slice(0);\n  this._monitoringDocuments.length = 0;\n  this._monitoringUnsubscribes.length = 0;\n  for (var i = 0; i < unsubscribes.length; i++) {\n    unsubscribes[i]();\n  }\n};\n\n\n/**\n * Scans each observation target for intersection changes and adds them\n * to the internal entries queue. If new entries are found, it\n * schedules the callback to be invoked.\n * @private\n */\nIntersectionObserver.prototype._checkForIntersections = function() {\n  if (!this.root && crossOriginUpdater && !crossOriginRect) {\n    // Cross origin monitoring, but no initial data available yet.\n    return;\n  }\n\n  var rootIsInDom = this._rootIsInDom();\n  var rootRect = rootIsInDom ? this._getRootRect() : getEmptyRect();\n\n  this._observationTargets.forEach(function(item) {\n    var target = item.element;\n    var targetRect = getBoundingClientRect(target);\n    var rootContainsTarget = this._rootContainsTarget(target);\n    var oldEntry = item.entry;\n    var intersectionRect = rootIsInDom && rootContainsTarget &&\n        this._computeTargetAndRootIntersection(target, targetRect, rootRect);\n\n    var rootBounds = null;\n    if (!this._rootContainsTarget(target)) {\n      rootBounds = getEmptyRect();\n    } else if (!crossOriginUpdater || this.root) {\n      rootBounds = rootRect;\n    }\n\n    var newEntry = item.entry = new IntersectionObserverEntry({\n      time: now(),\n      target: target,\n      boundingClientRect: targetRect,\n      rootBounds: rootBounds,\n      intersectionRect: intersectionRect\n    });\n\n    if (!oldEntry) {\n      this._queuedEntries.push(newEntry);\n    } else if (rootIsInDom && rootContainsTarget) {\n      // If the new entry intersection ratio has crossed any of the\n      // thresholds, add a new entry.\n      if (this._hasCrossedThreshold(oldEntry, newEntry)) {\n        this._queuedEntries.push(newEntry);\n      }\n    } else {\n      // If the root is not in the DOM or target is not contained within\n      // root but the previous entry for this target had an intersection,\n      // add a new record indicating removal.\n      if (oldEntry && oldEntry.isIntersecting) {\n        this._queuedEntries.push(newEntry);\n      }\n    }\n  }, this);\n\n  if (this._queuedEntries.length) {\n    this._callback(this.takeRecords(), this);\n  }\n};\n\n\n/**\n * Accepts a target and root rect computes the intersection between then\n * following the algorithm in the spec.\n * TODO(philipwalton): at this time clip-path is not considered.\n * https://w3c.github.io/IntersectionObserver/#calculate-intersection-rect-algo\n * @param {Element} target The target DOM element\n * @param {Object} targetRect The bounding rect of the target.\n * @param {Object} rootRect The bounding rect of the root after being\n *     expanded by the rootMargin value.\n * @return {?Object} The final intersection rect object or undefined if no\n *     intersection is found.\n * @private\n */\nIntersectionObserver.prototype._computeTargetAndRootIntersection =\n    function(target, targetRect, rootRect) {\n  // If the element isn't displayed, an intersection can't happen.\n  if (window.getComputedStyle(target).display == 'none') return;\n\n  var intersectionRect = targetRect;\n  var parent = getParentNode(target);\n  var atRoot = false;\n\n  while (!atRoot && parent) {\n    var parentRect = null;\n    var parentComputedStyle = parent.nodeType == 1 ?\n        window.getComputedStyle(parent) : {};\n\n    // If the parent isn't displayed, an intersection can't happen.\n    if (parentComputedStyle.display == 'none') return null;\n\n    if (parent == this.root || parent.nodeType == /* DOCUMENT */ 9) {\n      atRoot = true;\n      if (parent == this.root || parent == document) {\n        if (crossOriginUpdater && !this.root) {\n          if (!crossOriginRect ||\n              crossOriginRect.width == 0 && crossOriginRect.height == 0) {\n            // A 0-size cross-origin intersection means no-intersection.\n            parent = null;\n            parentRect = null;\n            intersectionRect = null;\n          } else {\n            parentRect = crossOriginRect;\n          }\n        } else {\n          parentRect = rootRect;\n        }\n      } else {\n        // Check if there's a frame that can be navigated to.\n        var frame = getParentNode(parent);\n        var frameRect = frame && getBoundingClientRect(frame);\n        var frameIntersect =\n            frame &&\n            this._computeTargetAndRootIntersection(frame, frameRect, rootRect);\n        if (frameRect && frameIntersect) {\n          parent = frame;\n          parentRect = convertFromParentRect(frameRect, frameIntersect);\n        } else {\n          parent = null;\n          intersectionRect = null;\n        }\n      }\n    } else {\n      // If the element has a non-visible overflow, and it's not the <body>\n      // or <html> element, update the intersection rect.\n      // Note: <body> and <html> cannot be clipped to a rect that's not also\n      // the document rect, so no need to compute a new intersection.\n      var doc = parent.ownerDocument;\n      if (parent != doc.body &&\n          parent != doc.documentElement &&\n          parentComputedStyle.overflow != 'visible') {\n        parentRect = getBoundingClientRect(parent);\n      }\n    }\n\n    // If either of the above conditionals set a new parentRect,\n    // calculate new intersection data.\n    if (parentRect) {\n      intersectionRect = computeRectIntersection(parentRect, intersectionRect);\n    }\n    if (!intersectionRect) break;\n    parent = parent && getParentNode(parent);\n  }\n  return intersectionRect;\n};\n\n\n/**\n * Returns the root rect after being expanded by the rootMargin value.\n * @return {ClientRect} The expanded root rect.\n * @private\n */\nIntersectionObserver.prototype._getRootRect = function() {\n  var rootRect;\n  if (this.root && !isDoc(this.root)) {\n    rootRect = getBoundingClientRect(this.root);\n  } else {\n    // Use <html>/<body> instead of window since scroll bars affect size.\n    var doc = isDoc(this.root) ? this.root : document;\n    var html = doc.documentElement;\n    var body = doc.body;\n    rootRect = {\n      top: 0,\n      left: 0,\n      right: html.clientWidth || body.clientWidth,\n      width: html.clientWidth || body.clientWidth,\n      bottom: html.clientHeight || body.clientHeight,\n      height: html.clientHeight || body.clientHeight\n    };\n  }\n  return this._expandRectByRootMargin(rootRect);\n};\n\n\n/**\n * Accepts a rect and expands it by the rootMargin value.\n * @param {DOMRect|ClientRect} rect The rect object to expand.\n * @return {ClientRect} The expanded rect.\n * @private\n */\nIntersectionObserver.prototype._expandRectByRootMargin = function(rect) {\n  var margins = this._rootMarginValues.map(function(margin, i) {\n    return margin.unit == 'px' ? margin.value :\n        margin.value * (i % 2 ? rect.width : rect.height) / 100;\n  });\n  var newRect = {\n    top: rect.top - margins[0],\n    right: rect.right + margins[1],\n    bottom: rect.bottom + margins[2],\n    left: rect.left - margins[3]\n  };\n  newRect.width = newRect.right - newRect.left;\n  newRect.height = newRect.bottom - newRect.top;\n\n  return newRect;\n};\n\n\n/**\n * Accepts an old and new entry and returns true if at least one of the\n * threshold values has been crossed.\n * @param {?IntersectionObserverEntry} oldEntry The previous entry for a\n *    particular target element or null if no previous entry exists.\n * @param {IntersectionObserverEntry} newEntry The current entry for a\n *    particular target element.\n * @return {boolean} Returns true if a any threshold has been crossed.\n * @private\n */\nIntersectionObserver.prototype._hasCrossedThreshold =\n    function(oldEntry, newEntry) {\n\n  // To make comparing easier, an entry that has a ratio of 0\n  // but does not actually intersect is given a value of -1\n  var oldRatio = oldEntry && oldEntry.isIntersecting ?\n      oldEntry.intersectionRatio || 0 : -1;\n  var newRatio = newEntry.isIntersecting ?\n      newEntry.intersectionRatio || 0 : -1;\n\n  // Ignore unchanged ratios\n  if (oldRatio === newRatio) return;\n\n  for (var i = 0; i < this.thresholds.length; i++) {\n    var threshold = this.thresholds[i];\n\n    // Return true if an entry matches a threshold or if the new ratio\n    // and the old ratio are on the opposite sides of a threshold.\n    if (threshold == oldRatio || threshold == newRatio ||\n        threshold < oldRatio !== threshold < newRatio) {\n      return true;\n    }\n  }\n};\n\n\n/**\n * Returns whether or not the root element is an element and is in the DOM.\n * @return {boolean} True if the root element is an element and is in the DOM.\n * @private\n */\nIntersectionObserver.prototype._rootIsInDom = function() {\n  return !this.root || containsDeep(document, this.root);\n};\n\n\n/**\n * Returns whether or not the target element is a child of root.\n * @param {Element} target The target element to check.\n * @return {boolean} True if the target element is a child of root.\n * @private\n */\nIntersectionObserver.prototype._rootContainsTarget = function(target) {\n  var rootDoc =\n    (this.root && (this.root.ownerDocument || this.root)) || document;\n  return (\n    containsDeep(rootDoc, target) &&\n    (!this.root || rootDoc == target.ownerDocument)\n  );\n};\n\n\n/**\n * Adds the instance to the global IntersectionObserver registry if it isn't\n * already present.\n * @private\n */\nIntersectionObserver.prototype._registerInstance = function() {\n  if (registry.indexOf(this) < 0) {\n    registry.push(this);\n  }\n};\n\n\n/**\n * Removes the instance from the global IntersectionObserver registry.\n * @private\n */\nIntersectionObserver.prototype._unregisterInstance = function() {\n  var index = registry.indexOf(this);\n  if (index != -1) registry.splice(index, 1);\n};\n\n\n/**\n * Returns the result of the performance.now() method or null in browsers\n * that don't support the API.\n * @return {number} The elapsed time since the page was requested.\n */\nfunction now() {\n  return window.performance && performance.now && performance.now();\n}\n\n\n/**\n * Throttles a function and delays its execution, so it's only called at most\n * once within a given time period.\n * @param {Function} fn The function to throttle.\n * @param {number} timeout The amount of time that must pass before the\n *     function can be called again.\n * @return {Function} The throttled function.\n */\nfunction throttle(fn, timeout) {\n  var timer = null;\n  return function () {\n    if (!timer) {\n      timer = setTimeout(function() {\n        fn();\n        timer = null;\n      }, timeout);\n    }\n  };\n}\n\n\n/**\n * Adds an event handler to a DOM node ensuring cross-browser compatibility.\n * @param {Node} node The DOM node to add the event handler to.\n * @param {string} event The event name.\n * @param {Function} fn The event handler to add.\n * @param {boolean} opt_useCapture Optionally adds the even to the capture\n *     phase. Note: this only works in modern browsers.\n */\nfunction addEvent(node, event, fn, opt_useCapture) {\n  if (typeof node.addEventListener == 'function') {\n    node.addEventListener(event, fn, opt_useCapture || false);\n  }\n  else if (typeof node.attachEvent == 'function') {\n    node.attachEvent('on' + event, fn);\n  }\n}\n\n\n/**\n * Removes a previously added event handler from a DOM node.\n * @param {Node} node The DOM node to remove the event handler from.\n * @param {string} event The event name.\n * @param {Function} fn The event handler to remove.\n * @param {boolean} opt_useCapture If the event handler was added with this\n *     flag set to true, it should be set to true here in order to remove it.\n */\nfunction removeEvent(node, event, fn, opt_useCapture) {\n  if (typeof node.removeEventListener == 'function') {\n    node.removeEventListener(event, fn, opt_useCapture || false);\n  }\n  else if (typeof node.detachEvent == 'function') {\n    node.detachEvent('on' + event, fn);\n  }\n}\n\n\n/**\n * Returns the intersection between two rect objects.\n * @param {Object} rect1 The first rect.\n * @param {Object} rect2 The second rect.\n * @return {?Object|?ClientRect} The intersection rect or undefined if no\n *     intersection is found.\n */\nfunction computeRectIntersection(rect1, rect2) {\n  var top = Math.max(rect1.top, rect2.top);\n  var bottom = Math.min(rect1.bottom, rect2.bottom);\n  var left = Math.max(rect1.left, rect2.left);\n  var right = Math.min(rect1.right, rect2.right);\n  var width = right - left;\n  var height = bottom - top;\n\n  return (width >= 0 && height >= 0) && {\n    top: top,\n    bottom: bottom,\n    left: left,\n    right: right,\n    width: width,\n    height: height\n  } || null;\n}\n\n\n/**\n * Shims the native getBoundingClientRect for compatibility with older IE.\n * @param {Element} el The element whose bounding rect to get.\n * @return {DOMRect|ClientRect} The (possibly shimmed) rect of the element.\n */\nfunction getBoundingClientRect(el) {\n  var rect;\n\n  try {\n    rect = el.getBoundingClientRect();\n  } catch (err) {\n    // Ignore Windows 7 IE11 \"Unspecified error\"\n    // https://github.com/w3c/IntersectionObserver/pull/205\n  }\n\n  if (!rect) return getEmptyRect();\n\n  // Older IE\n  if (!(rect.width && rect.height)) {\n    rect = {\n      top: rect.top,\n      right: rect.right,\n      bottom: rect.bottom,\n      left: rect.left,\n      width: rect.right - rect.left,\n      height: rect.bottom - rect.top\n    };\n  }\n  return rect;\n}\n\n\n/**\n * Returns an empty rect object. An empty rect is returned when an element\n * is not in the DOM.\n * @return {ClientRect} The empty rect.\n */\nfunction getEmptyRect() {\n  return {\n    top: 0,\n    bottom: 0,\n    left: 0,\n    right: 0,\n    width: 0,\n    height: 0\n  };\n}\n\n\n/**\n * Ensure that the result has all of the necessary fields of the DOMRect.\n * Specifically this ensures that `x` and `y` fields are set.\n *\n * @param {?DOMRect|?ClientRect} rect\n * @return {?DOMRect}\n */\nfunction ensureDOMRect(rect) {\n  // A `DOMRect` object has `x` and `y` fields.\n  if (!rect || 'x' in rect) {\n    return rect;\n  }\n  // A IE's `ClientRect` type does not have `x` and `y`. The same is the case\n  // for internally calculated Rect objects. For the purposes of\n  // `IntersectionObserver`, it's sufficient to simply mirror `left` and `top`\n  // for these fields.\n  return {\n    top: rect.top,\n    y: rect.top,\n    bottom: rect.bottom,\n    left: rect.left,\n    x: rect.left,\n    right: rect.right,\n    width: rect.width,\n    height: rect.height\n  };\n}\n\n\n/**\n * Inverts the intersection and bounding rect from the parent (frame) BCR to\n * the local BCR space.\n * @param {DOMRect|ClientRect} parentBoundingRect The parent's bound client rect.\n * @param {DOMRect|ClientRect} parentIntersectionRect The parent's own intersection rect.\n * @return {ClientRect} The local root bounding rect for the parent's children.\n */\nfunction convertFromParentRect(parentBoundingRect, parentIntersectionRect) {\n  var top = parentIntersectionRect.top - parentBoundingRect.top;\n  var left = parentIntersectionRect.left - parentBoundingRect.left;\n  return {\n    top: top,\n    left: left,\n    height: parentIntersectionRect.height,\n    width: parentIntersectionRect.width,\n    bottom: top + parentIntersectionRect.height,\n    right: left + parentIntersectionRect.width\n  };\n}\n\n\n/**\n * Checks to see if a parent element contains a child element (including inside\n * shadow DOM).\n * @param {Node} parent The parent element.\n * @param {Node} child The child element.\n * @return {boolean} True if the parent node contains the child node.\n */\nfunction containsDeep(parent, child) {\n  var node = child;\n  while (node) {\n    if (node == parent) return true;\n\n    node = getParentNode(node);\n  }\n  return false;\n}\n\n\n/**\n * Gets the parent node of an element or its host element if the parent node\n * is a shadow root.\n * @param {Node} node The node whose parent to get.\n * @return {Node|null} The parent node or null if no parent exists.\n */\nfunction getParentNode(node) {\n  var parent = node.parentNode;\n\n  if (node.nodeType == /* DOCUMENT */ 9 && node != document) {\n    // If this node is a document node, look for the embedding frame.\n    return getFrameElement(node);\n  }\n\n  // If the parent has element that is assigned through shadow root slot\n  if (parent && parent.assignedSlot) {\n    parent = parent.assignedSlot.parentNode\n  }\n\n  if (parent && parent.nodeType == 11 && parent.host) {\n    // If the parent is a shadow root, return the host element.\n    return parent.host;\n  }\n\n  return parent;\n}\n\n/**\n * Returns true if `node` is a Document.\n * @param {!Node} node\n * @returns {boolean}\n */\nfunction isDoc(node) {\n  return node && node.nodeType === 9;\n}\n\n\n// Exposes the constructors globally.\nwindow.IntersectionObserver = IntersectionObserver;\nwindow.IntersectionObserverEntry = IntersectionObserverEntry;\n\n}());\n","'use strict';\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar defineProperty = Object.defineProperty;\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nvar isArray = function isArray(arr) {\n\tif (typeof Array.isArray === 'function') {\n\t\treturn Array.isArray(arr);\n\t}\n\n\treturn toStr.call(arr) === '[object Array]';\n};\n\nvar isPlainObject = function isPlainObject(obj) {\n\tif (!obj || toStr.call(obj) !== '[object Object]') {\n\t\treturn false;\n\t}\n\n\tvar hasOwnConstructor = hasOwn.call(obj, 'constructor');\n\tvar hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');\n\t// Not own constructor property must be Object\n\tif (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n\t\treturn false;\n\t}\n\n\t// Own properties are enumerated firstly, so to speed up,\n\t// if last one is own, then all properties are own.\n\tvar key;\n\tfor (key in obj) { /**/ }\n\n\treturn typeof key === 'undefined' || hasOwn.call(obj, key);\n};\n\n// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target\nvar setProperty = function setProperty(target, options) {\n\tif (defineProperty && options.name === '__proto__') {\n\t\tdefineProperty(target, options.name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\t\t\tvalue: options.newValue,\n\t\t\twritable: true\n\t\t});\n\t} else {\n\t\ttarget[options.name] = options.newValue;\n\t}\n};\n\n// Return undefined instead of __proto__ if '__proto__' is not an own property\nvar getProperty = function getProperty(obj, name) {\n\tif (name === '__proto__') {\n\t\tif (!hasOwn.call(obj, name)) {\n\t\t\treturn void 0;\n\t\t} else if (gOPD) {\n\t\t\t// In early versions of node, obj['__proto__'] is buggy when obj has\n\t\t\t// __proto__ as an own property. Object.getOwnPropertyDescriptor() works.\n\t\t\treturn gOPD(obj, name).value;\n\t\t}\n\t}\n\n\treturn obj[name];\n};\n\nmodule.exports = function extend() {\n\tvar options, name, src, copy, copyIsArray, clone;\n\tvar target = arguments[0];\n\tvar i = 1;\n\tvar length = arguments.length;\n\tvar deep = false;\n\n\t// Handle a deep copy situation\n\tif (typeof target === 'boolean') {\n\t\tdeep = target;\n\t\ttarget = arguments[1] || {};\n\t\t// skip the boolean and the target\n\t\ti = 2;\n\t}\n\tif (target == null || (typeof target !== 'object' && typeof target !== 'function')) {\n\t\ttarget = {};\n\t}\n\n\tfor (; i < length; ++i) {\n\t\toptions = arguments[i];\n\t\t// Only deal with non-null/undefined values\n\t\tif (options != null) {\n\t\t\t// Extend the base object\n\t\t\tfor (name in options) {\n\t\t\t\tsrc = getProperty(target, name);\n\t\t\t\tcopy = getProperty(options, name);\n\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif (target !== copy) {\n\t\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\t\tif (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n\t\t\t\t\t\tif (copyIsArray) {\n\t\t\t\t\t\t\tcopyIsArray = false;\n\t\t\t\t\t\t\tclone = src && isArray(src) ? src : [];\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tclone = src && isPlainObject(src) ? src : {};\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: extend(deep, clone, copy) });\n\n\t\t\t\t\t// Don't bring in undefined values\n\t\t\t\t\t} else if (typeof copy !== 'undefined') {\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: copy });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n","// http://www.w3.org/TR/CSS21/grammar.html\n// https://github.com/visionmedia/css-parse/pull/49#issuecomment-30088027\nvar COMMENT_REGEX = /\\/\\*[^*]*\\*+([^/*][^*]*\\*+)*\\//g;\n\nvar NEWLINE_REGEX = /\\n/g;\nvar WHITESPACE_REGEX = /^\\s*/;\n\n// declaration\nvar PROPERTY_REGEX = /^(\\*?[-#/*\\\\\\w]+(\\[[0-9a-z_-]+\\])?)\\s*/;\nvar COLON_REGEX = /^:\\s*/;\nvar VALUE_REGEX = /^((?:'(?:\\\\'|.)*?'|\"(?:\\\\\"|.)*?\"|\\([^)]*?\\)|[^};])+)/;\nvar SEMICOLON_REGEX = /^[;\\s]*/;\n\n// https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String/Trim#Polyfill\nvar TRIM_REGEX = /^\\s+|\\s+$/g;\n\n// strings\nvar NEWLINE = '\\n';\nvar FORWARD_SLASH = '/';\nvar ASTERISK = '*';\nvar EMPTY_STRING = '';\n\n// types\nvar TYPE_COMMENT = 'comment';\nvar TYPE_DECLARATION = 'declaration';\n\n/**\n * @param {String} style\n * @param {Object} [options]\n * @return {Object[]}\n * @throws {TypeError}\n * @throws {Error}\n */\nmodule.exports = function (style, options) {\n  if (typeof style !== 'string') {\n    throw new TypeError('First argument must be a string');\n  }\n\n  if (!style) return [];\n\n  options = options || {};\n\n  /**\n   * Positional.\n   */\n  var lineno = 1;\n  var column = 1;\n\n  /**\n   * Update lineno and column based on `str`.\n   *\n   * @param {String} str\n   */\n  function updatePosition(str) {\n    var lines = str.match(NEWLINE_REGEX);\n    if (lines) lineno += lines.length;\n    var i = str.lastIndexOf(NEWLINE);\n    column = ~i ? str.length - i : column + str.length;\n  }\n\n  /**\n   * Mark position and patch `node.position`.\n   *\n   * @return {Function}\n   */\n  function position() {\n    var start = { line: lineno, column: column };\n    return function (node) {\n      node.position = new Position(start);\n      whitespace();\n      return node;\n    };\n  }\n\n  /**\n   * Store position information for a node.\n   *\n   * @constructor\n   * @property {Object} start\n   * @property {Object} end\n   * @property {undefined|String} source\n   */\n  function Position(start) {\n    this.start = start;\n    this.end = { line: lineno, column: column };\n    this.source = options.source;\n  }\n\n  /**\n   * Non-enumerable source string.\n   */\n  Position.prototype.content = style;\n\n  var errorsList = [];\n\n  /**\n   * Error `msg`.\n   *\n   * @param {String} msg\n   * @throws {Error}\n   */\n  function error(msg) {\n    var err = new Error(\n      options.source + ':' + lineno + ':' + column + ': ' + msg\n    );\n    err.reason = msg;\n    err.filename = options.source;\n    err.line = lineno;\n    err.column = column;\n    err.source = style;\n\n    if (options.silent) {\n      errorsList.push(err);\n    } else {\n      throw err;\n    }\n  }\n\n  /**\n   * Match `re` and return captures.\n   *\n   * @param {RegExp} re\n   * @return {undefined|Array}\n   */\n  function match(re) {\n    var m = re.exec(style);\n    if (!m) return;\n    var str = m[0];\n    updatePosition(str);\n    style = style.slice(str.length);\n    return m;\n  }\n\n  /**\n   * Parse whitespace.\n   */\n  function whitespace() {\n    match(WHITESPACE_REGEX);\n  }\n\n  /**\n   * Parse comments.\n   *\n   * @param {Object[]} [rules]\n   * @return {Object[]}\n   */\n  function comments(rules) {\n    var c;\n    rules = rules || [];\n    while ((c = comment())) {\n      if (c !== false) {\n        rules.push(c);\n      }\n    }\n    return rules;\n  }\n\n  /**\n   * Parse comment.\n   *\n   * @return {Object}\n   * @throws {Error}\n   */\n  function comment() {\n    var pos = position();\n    if (FORWARD_SLASH != style.charAt(0) || ASTERISK != style.charAt(1)) return;\n\n    var i = 2;\n    while (\n      EMPTY_STRING != style.charAt(i) &&\n      (ASTERISK != style.charAt(i) || FORWARD_SLASH != style.charAt(i + 1))\n    ) {\n      ++i;\n    }\n    i += 2;\n\n    if (EMPTY_STRING === style.charAt(i - 1)) {\n      return error('End of comment missing');\n    }\n\n    var str = style.slice(2, i - 2);\n    column += 2;\n    updatePosition(str);\n    style = style.slice(i);\n    column += 2;\n\n    return pos({\n      type: TYPE_COMMENT,\n      comment: str\n    });\n  }\n\n  /**\n   * Parse declaration.\n   *\n   * @return {Object}\n   * @throws {Error}\n   */\n  function declaration() {\n    var pos = position();\n\n    // prop\n    var prop = match(PROPERTY_REGEX);\n    if (!prop) return;\n    comment();\n\n    // :\n    if (!match(COLON_REGEX)) return error(\"property missing ':'\");\n\n    // val\n    var val = match(VALUE_REGEX);\n\n    var ret = pos({\n      type: TYPE_DECLARATION,\n      property: trim(prop[0].replace(COMMENT_REGEX, EMPTY_STRING)),\n      value: val\n        ? trim(val[0].replace(COMMENT_REGEX, EMPTY_STRING))\n        : EMPTY_STRING\n    });\n\n    // ;\n    match(SEMICOLON_REGEX);\n\n    return ret;\n  }\n\n  /**\n   * Parse declarations.\n   *\n   * @return {Object[]}\n   */\n  function declarations() {\n    var decls = [];\n\n    comments(decls);\n\n    // declarations\n    var decl;\n    while ((decl = declaration())) {\n      if (decl !== false) {\n        decls.push(decl);\n        comments(decls);\n      }\n    }\n\n    return decls;\n  }\n\n  whitespace();\n  return declarations();\n};\n\n/**\n * Trim `str`.\n *\n * @param {String} str\n * @return {String}\n */\nfunction trim(str) {\n  return str ? str.replace(TRIM_REGEX, EMPTY_STRING) : EMPTY_STRING;\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n// If obj.hasOwnProperty has been overridden, then calling\n// obj.hasOwnProperty(prop) will break.\n// See: https://github.com/joyent/node/issues/1707\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\nmodule.exports = function(qs, sep, eq, options) {\n  sep = sep || '&';\n  eq = eq || '=';\n  var obj = {};\n\n  if (typeof qs !== 'string' || qs.length === 0) {\n    return obj;\n  }\n\n  var regexp = /\\+/g;\n  qs = qs.split(sep);\n\n  var maxKeys = 1000;\n  if (options && typeof options.maxKeys === 'number') {\n    maxKeys = options.maxKeys;\n  }\n\n  var len = qs.length;\n  // maxKeys <= 0 means that we should not limit keys count\n  if (maxKeys > 0 && len > maxKeys) {\n    len = maxKeys;\n  }\n\n  for (var i = 0; i < len; ++i) {\n    var x = qs[i].replace(regexp, '%20'),\n        idx = x.indexOf(eq),\n        kstr, vstr, k, v;\n\n    if (idx >= 0) {\n      kstr = x.substr(0, idx);\n      vstr = x.substr(idx + 1);\n    } else {\n      kstr = x;\n      vstr = '';\n    }\n\n    k = decodeURIComponent(kstr);\n    v = decodeURIComponent(vstr);\n\n    if (!hasOwnProperty(obj, k)) {\n      obj[k] = v;\n    } else if (Array.isArray(obj[k])) {\n      obj[k].push(v);\n    } else {\n      obj[k] = [obj[k], v];\n    }\n  }\n\n  return obj;\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar stringifyPrimitive = function(v) {\n  switch (typeof v) {\n    case 'string':\n      return v;\n\n    case 'boolean':\n      return v ? 'true' : 'false';\n\n    case 'number':\n      return isFinite(v) ? v : '';\n\n    default:\n      return '';\n  }\n};\n\nmodule.exports = function(obj, sep, eq, name) {\n  sep = sep || '&';\n  eq = eq || '=';\n  if (obj === null) {\n    obj = undefined;\n  }\n\n  if (typeof obj === 'object') {\n    return Object.keys(obj).map(function(k) {\n      var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;\n      if (Array.isArray(obj[k])) {\n        return obj[k].map(function(v) {\n          return ks + encodeURIComponent(stringifyPrimitive(v));\n        }).join(sep);\n      } else {\n        return ks + encodeURIComponent(stringifyPrimitive(obj[k]));\n      }\n    }).filter(Boolean).join(sep);\n\n  }\n\n  if (!name) return '';\n  return encodeURIComponent(stringifyPrimitive(name)) + eq +\n         encodeURIComponent(stringifyPrimitive(obj));\n};\n","'use strict';\n\nexports.decode = exports.parse = require('./decode');\nexports.encode = exports.stringify = require('./encode');\n","import compute from 'compute-scroll-into-view';\nfunction isOptionsObject(options) {\n  return options === Object(options) && Object.keys(options).length !== 0;\n}\nfunction defaultBehavior(actions, behavior) {\n  if (behavior === void 0) {\n    behavior = 'auto';\n  }\n  var canSmoothScroll = ('scrollBehavior' in document.body.style);\n  actions.forEach(function (_ref) {\n    var el = _ref.el,\n      top = _ref.top,\n      left = _ref.left;\n    if (el.scroll && canSmoothScroll) {\n      el.scroll({\n        top: top,\n        left: left,\n        behavior: behavior\n      });\n    } else {\n      el.scrollTop = top;\n      el.scrollLeft = left;\n    }\n  });\n}\nfunction getOptions(options) {\n  if (options === false) {\n    return {\n      block: 'end',\n      inline: 'nearest'\n    };\n  }\n  if (isOptionsObject(options)) {\n    return options;\n  }\n  return {\n    block: 'start',\n    inline: 'nearest'\n  };\n}\nfunction scrollIntoView(target, options) {\n  var isTargetAttached = target.isConnected || target.ownerDocument.documentElement.contains(target);\n  if (isOptionsObject(options) && typeof options.behavior === 'function') {\n    return options.behavior(isTargetAttached ? compute(target, options) : []);\n  }\n  if (!isTargetAttached) {\n    return;\n  }\n  var computeOptions = getOptions(options);\n  return defaultBehavior(compute(target, computeOptions), computeOptions.behavior);\n}\nexport default scrollIntoView;","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = StyleToObject;\nvar inline_style_parser_1 = __importDefault(require(\"inline-style-parser\"));\n/**\n * Parses inline style to object.\n *\n * @param style - Inline style.\n * @param iterator - Iterator.\n * @returns - Style object or null.\n *\n * @example Parsing inline style to object:\n *\n * ```js\n * import parse from 'style-to-object';\n * parse('line-height: 42;'); // { 'line-height': '42' }\n * ```\n */\nfunction StyleToObject(style, iterator) {\n    var styleObject = null;\n    if (!style || typeof style !== 'string') {\n        return styleObject;\n    }\n    var declarations = (0, inline_style_parser_1.default)(style);\n    var hasIterator = typeof iterator === 'function';\n    declarations.forEach(function (declaration) {\n        if (declaration.type !== 'declaration') {\n            return;\n        }\n        var property = declaration.property, value = declaration.value;\n        if (hasIterator) {\n            iterator(property, value, declaration);\n        }\n        else if (value) {\n            styleObject = styleObject || {};\n            styleObject[property] = value;\n        }\n    });\n    return styleObject;\n}\n//# sourceMappingURL=index.js.map","/**\n * @typedef Options\n *   Configuration.\n * @property {boolean | null | undefined} [jsx=false]\n *   Support JSX identifiers (default: `false`).\n */\n\nconst startRe = /[$_\\p{ID_Start}]/u\nconst contRe = /[$_\\u{200C}\\u{200D}\\p{ID_Continue}]/u\nconst contReJsx = /[-$_\\u{200C}\\u{200D}\\p{ID_Continue}]/u\nconst nameRe = /^[$_\\p{ID_Start}][$_\\u{200C}\\u{200D}\\p{ID_Continue}]*$/u\nconst nameReJsx = /^[$_\\p{ID_Start}][-$_\\u{200C}\\u{200D}\\p{ID_Continue}]*$/u\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Checks if the given code point can start an identifier.\n *\n * @param {number | undefined} code\n *   Code point to check.\n * @returns {boolean}\n *   Whether `code` can start an identifier.\n */\n// Note: `undefined` is supported so you can pass the result from `''.codePointAt`.\nexport function start(code) {\n  return code ? startRe.test(String.fromCodePoint(code)) : false\n}\n\n/**\n * Checks if the given code point can continue an identifier.\n *\n * @param {number | undefined} code\n *   Code point to check.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {boolean}\n *   Whether `code` can continue an identifier.\n */\n// Note: `undefined` is supported so you can pass the result from `''.codePointAt`.\nexport function cont(code, options) {\n  const settings = options || emptyOptions\n  const re = settings.jsx ? contReJsx : contRe\n  return code ? re.test(String.fromCodePoint(code)) : false\n}\n\n/**\n * Checks if the given value is a valid identifier name.\n *\n * @param {string} name\n *   Identifier to check.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {boolean}\n *   Whether `name` can be an identifier.\n */\nexport function name(name, options) {\n  const settings = options || emptyOptions\n  const re = settings.jsx ? nameReJsx : nameRe\n  return re.test(name)\n}\n","/**\n * @typedef {import('hast').Nodes} Nodes\n */\n\n// HTML whitespace expression.\n// See <https://infra.spec.whatwg.org/#ascii-whitespace>.\nconst re = /[ \\t\\n\\f\\r]/g\n\n/**\n * Check if the given value is *inter-element whitespace*.\n *\n * @param {Nodes | string} thing\n *   Thing to check (`Node` or `string`).\n * @returns {boolean}\n *   Whether the `value` is inter-element whitespace (`boolean`): consisting of\n *   zero or more of space, tab (`\\t`), line feed (`\\n`), carriage return\n *   (`\\r`), or form feed (`\\f`); if a node is passed it must be a `Text` node,\n *   whose `value` field is checked.\n */\nexport function whitespace(thing) {\n  return typeof thing === 'object'\n    ? thing.type === 'text'\n      ? empty(thing.value)\n      : false\n    : empty(thing)\n}\n\n/**\n * @param {string} value\n * @returns {boolean}\n */\nfunction empty(value) {\n  return value.replace(re, '') === ''\n}\n","/**\n * @typedef {import('./info.js').Info} Info\n * @typedef {Record<string, Info>} Properties\n * @typedef {Record<string, string>} Normal\n */\n\nexport class Schema {\n  /**\n   * @constructor\n   * @param {Properties} property\n   * @param {Normal} normal\n   * @param {string} [space]\n   */\n  constructor(property, normal, space) {\n    this.property = property\n    this.normal = normal\n    if (space) {\n      this.space = space\n    }\n  }\n}\n\n/** @type {Properties} */\nSchema.prototype.property = {}\n/** @type {Normal} */\nSchema.prototype.normal = {}\n/** @type {string|null} */\nSchema.prototype.space = null\n","/**\n * @typedef {import('./schema.js').Properties} Properties\n * @typedef {import('./schema.js').Normal} Normal\n */\n\nimport {Schema} from './schema.js'\n\n/**\n * @param {Schema[]} definitions\n * @param {string} [space]\n * @returns {Schema}\n */\nexport function merge(definitions, space) {\n  /** @type {Properties} */\n  const property = {}\n  /** @type {Normal} */\n  const normal = {}\n  let index = -1\n\n  while (++index < definitions.length) {\n    Object.assign(property, definitions[index].property)\n    Object.assign(normal, definitions[index].normal)\n  }\n\n  return new Schema(property, normal, space)\n}\n","/**\n * @param {string} value\n * @returns {string}\n */\nexport function normalize(value) {\n  return value.toLowerCase()\n}\n","export class Info {\n  /**\n   * @constructor\n   * @param {string} property\n   * @param {string} attribute\n   */\n  constructor(property, attribute) {\n    /** @type {string} */\n    this.property = property\n    /** @type {string} */\n    this.attribute = attribute\n  }\n}\n\n/** @type {string|null} */\nInfo.prototype.space = null\nInfo.prototype.boolean = false\nInfo.prototype.booleanish = false\nInfo.prototype.overloadedBoolean = false\nInfo.prototype.number = false\nInfo.prototype.commaSeparated = false\nInfo.prototype.spaceSeparated = false\nInfo.prototype.commaOrSpaceSeparated = false\nInfo.prototype.mustUseProperty = false\nInfo.prototype.defined = false\n","let powers = 0\n\nexport const boolean = increment()\nexport const booleanish = increment()\nexport const overloadedBoolean = increment()\nexport const number = increment()\nexport const spaceSeparated = increment()\nexport const commaSeparated = increment()\nexport const commaOrSpaceSeparated = increment()\n\nfunction increment() {\n  return 2 ** ++powers\n}\n","import {Info} from './info.js'\nimport * as types from './types.js'\n\n/** @type {Array<keyof types>} */\n// @ts-expect-error: hush.\nconst checks = Object.keys(types)\n\nexport class DefinedInfo extends Info {\n  /**\n   * @constructor\n   * @param {string} property\n   * @param {string} attribute\n   * @param {number|null} [mask]\n   * @param {string} [space]\n   */\n  constructor(property, attribute, mask, space) {\n    let index = -1\n\n    super(property, attribute)\n\n    mark(this, 'space', space)\n\n    if (typeof mask === 'number') {\n      while (++index < checks.length) {\n        const check = checks[index]\n        mark(this, checks[index], (mask & types[check]) === types[check])\n      }\n    }\n  }\n}\n\nDefinedInfo.prototype.defined = true\n\n/**\n * @param {DefinedInfo} values\n * @param {string} key\n * @param {unknown} value\n */\nfunction mark(values, key, value) {\n  if (value) {\n    // @ts-expect-error: assume `value` matches the expected value of `key`.\n    values[key] = value\n  }\n}\n","/**\n * @typedef {import('./schema.js').Properties} Properties\n * @typedef {import('./schema.js').Normal} Normal\n *\n * @typedef {Record<string, string>} Attributes\n *\n * @typedef {Object} Definition\n * @property {Record<string, number|null>} properties\n * @property {(attributes: Attributes, property: string) => string} transform\n * @property {string} [space]\n * @property {Attributes} [attributes]\n * @property {Array<string>} [mustUseProperty]\n */\n\nimport {normalize} from '../normalize.js'\nimport {Schema} from './schema.js'\nimport {DefinedInfo} from './defined-info.js'\n\nconst own = {}.hasOwnProperty\n\n/**\n * @param {Definition} definition\n * @returns {Schema}\n */\nexport function create(definition) {\n  /** @type {Properties} */\n  const property = {}\n  /** @type {Normal} */\n  const normal = {}\n  /** @type {string} */\n  let prop\n\n  for (prop in definition.properties) {\n    if (own.call(definition.properties, prop)) {\n      const value = definition.properties[prop]\n      const info = new DefinedInfo(\n        prop,\n        definition.transform(definition.attributes || {}, prop),\n        value,\n        definition.space\n      )\n\n      if (\n        definition.mustUseProperty &&\n        definition.mustUseProperty.includes(prop)\n      ) {\n        info.mustUseProperty = true\n      }\n\n      property[prop] = info\n\n      normal[normalize(prop)] = prop\n      normal[normalize(info.attribute)] = prop\n    }\n  }\n\n  return new Schema(property, normal, definition.space)\n}\n","import {create} from './util/create.js'\n\nexport const xlink = create({\n  space: 'xlink',\n  transform(_, prop) {\n    return 'xlink:' + prop.slice(5).toLowerCase()\n  },\n  properties: {\n    xLinkActuate: null,\n    xLinkArcRole: null,\n    xLinkHref: null,\n    xLinkRole: null,\n    xLinkShow: null,\n    xLinkTitle: null,\n    xLinkType: null\n  }\n})\n","import {create} from './util/create.js'\n\nexport const xml = create({\n  space: 'xml',\n  transform(_, prop) {\n    return 'xml:' + prop.slice(3).toLowerCase()\n  },\n  properties: {xmlLang: null, xmlBase: null, xmlSpace: null}\n})\n","/**\n * @param {Record<string, string>} attributes\n * @param {string} attribute\n * @returns {string}\n */\nexport function caseSensitiveTransform(attributes, attribute) {\n  return attribute in attributes ? attributes[attribute] : attribute\n}\n","import {caseSensitiveTransform} from './case-sensitive-transform.js'\n\n/**\n * @param {Record<string, string>} attributes\n * @param {string} property\n * @returns {string}\n */\nexport function caseInsensitiveTransform(attributes, property) {\n  return caseSensitiveTransform(attributes, property.toLowerCase())\n}\n","import {create} from './util/create.js'\nimport {caseInsensitiveTransform} from './util/case-insensitive-transform.js'\n\nexport const xmlns = create({\n  space: 'xmlns',\n  attributes: {xmlnsxlink: 'xmlns:xlink'},\n  transform: caseInsensitiveTransform,\n  properties: {xmlns: null, xmlnsXLink: null}\n})\n","import {booleanish, number, spaceSeparated} from './util/types.js'\nimport {create} from './util/create.js'\n\nexport const aria = create({\n  transform(_, prop) {\n    return prop === 'role' ? prop : 'aria-' + prop.slice(4).toLowerCase()\n  },\n  properties: {\n    ariaActiveDescendant: null,\n    ariaAtomic: booleanish,\n    ariaAutoComplete: null,\n    ariaBusy: booleanish,\n    ariaChecked: booleanish,\n    ariaColCount: number,\n    ariaColIndex: number,\n    ariaColSpan: number,\n    ariaControls: spaceSeparated,\n    ariaCurrent: null,\n    ariaDescribedBy: spaceSeparated,\n    ariaDetails: null,\n    ariaDisabled: booleanish,\n    ariaDropEffect: spaceSeparated,\n    ariaErrorMessage: null,\n    ariaExpanded: booleanish,\n    ariaFlowTo: spaceSeparated,\n    ariaGrabbed: booleanish,\n    ariaHasPopup: null,\n    ariaHidden: booleanish,\n    ariaInvalid: null,\n    ariaKeyShortcuts: null,\n    ariaLabel: null,\n    ariaLabelledBy: spaceSeparated,\n    ariaLevel: number,\n    ariaLive: null,\n    ariaModal: booleanish,\n    ariaMultiLine: booleanish,\n    ariaMultiSelectable: booleanish,\n    ariaOrientation: null,\n    ariaOwns: spaceSeparated,\n    ariaPlaceholder: null,\n    ariaPosInSet: number,\n    ariaPressed: booleanish,\n    ariaReadOnly: booleanish,\n    ariaRelevant: null,\n    ariaRequired: booleanish,\n    ariaRoleDescription: spaceSeparated,\n    ariaRowCount: number,\n    ariaRowIndex: number,\n    ariaRowSpan: number,\n    ariaSelected: booleanish,\n    ariaSetSize: number,\n    ariaSort: null,\n    ariaValueMax: number,\n    ariaValueMin: number,\n    ariaValueNow: number,\n    ariaValueText: null,\n    role: null\n  }\n})\n","import {\n  boolean,\n  overloadedBoolean,\n  booleanish,\n  number,\n  spaceSeparated,\n  commaSeparated\n} from './util/types.js'\nimport {create} from './util/create.js'\nimport {caseInsensitiveTransform} from './util/case-insensitive-transform.js'\n\nexport const html = create({\n  space: 'html',\n  attributes: {\n    acceptcharset: 'accept-charset',\n    classname: 'class',\n    htmlfor: 'for',\n    httpequiv: 'http-equiv'\n  },\n  transform: caseInsensitiveTransform,\n  mustUseProperty: ['checked', 'multiple', 'muted', 'selected'],\n  properties: {\n    // Standard Properties.\n    abbr: null,\n    accept: commaSeparated,\n    acceptCharset: spaceSeparated,\n    accessKey: spaceSeparated,\n    action: null,\n    allow: null,\n    allowFullScreen: boolean,\n    allowPaymentRequest: boolean,\n    allowUserMedia: boolean,\n    alt: null,\n    as: null,\n    async: boolean,\n    autoCapitalize: null,\n    autoComplete: spaceSeparated,\n    autoFocus: boolean,\n    autoPlay: boolean,\n    blocking: spaceSeparated,\n    capture: null,\n    charSet: null,\n    checked: boolean,\n    cite: null,\n    className: spaceSeparated,\n    cols: number,\n    colSpan: null,\n    content: null,\n    contentEditable: booleanish,\n    controls: boolean,\n    controlsList: spaceSeparated,\n    coords: number | commaSeparated,\n    crossOrigin: null,\n    data: null,\n    dateTime: null,\n    decoding: null,\n    default: boolean,\n    defer: boolean,\n    dir: null,\n    dirName: null,\n    disabled: boolean,\n    download: overloadedBoolean,\n    draggable: booleanish,\n    encType: null,\n    enterKeyHint: null,\n    fetchPriority: null,\n    form: null,\n    formAction: null,\n    formEncType: null,\n    formMethod: null,\n    formNoValidate: boolean,\n    formTarget: null,\n    headers: spaceSeparated,\n    height: number,\n    hidden: boolean,\n    high: number,\n    href: null,\n    hrefLang: null,\n    htmlFor: spaceSeparated,\n    httpEquiv: spaceSeparated,\n    id: null,\n    imageSizes: null,\n    imageSrcSet: null,\n    inert: boolean,\n    inputMode: null,\n    integrity: null,\n    is: null,\n    isMap: boolean,\n    itemId: null,\n    itemProp: spaceSeparated,\n    itemRef: spaceSeparated,\n    itemScope: boolean,\n    itemType: spaceSeparated,\n    kind: null,\n    label: null,\n    lang: null,\n    language: null,\n    list: null,\n    loading: null,\n    loop: boolean,\n    low: number,\n    manifest: null,\n    max: null,\n    maxLength: number,\n    media: null,\n    method: null,\n    min: null,\n    minLength: number,\n    multiple: boolean,\n    muted: boolean,\n    name: null,\n    nonce: null,\n    noModule: boolean,\n    noValidate: boolean,\n    onAbort: null,\n    onAfterPrint: null,\n    onAuxClick: null,\n    onBeforeMatch: null,\n    onBeforePrint: null,\n    onBeforeToggle: null,\n    onBeforeUnload: null,\n    onBlur: null,\n    onCancel: null,\n    onCanPlay: null,\n    onCanPlayThrough: null,\n    onChange: null,\n    onClick: null,\n    onClose: null,\n    onContextLost: null,\n    onContextMenu: null,\n    onContextRestored: null,\n    onCopy: null,\n    onCueChange: null,\n    onCut: null,\n    onDblClick: null,\n    onDrag: null,\n    onDragEnd: null,\n    onDragEnter: null,\n    onDragExit: null,\n    onDragLeave: null,\n    onDragOver: null,\n    onDragStart: null,\n    onDrop: null,\n    onDurationChange: null,\n    onEmptied: null,\n    onEnded: null,\n    onError: null,\n    onFocus: null,\n    onFormData: null,\n    onHashChange: null,\n    onInput: null,\n    onInvalid: null,\n    onKeyDown: null,\n    onKeyPress: null,\n    onKeyUp: null,\n    onLanguageChange: null,\n    onLoad: null,\n    onLoadedData: null,\n    onLoadedMetadata: null,\n    onLoadEnd: null,\n    onLoadStart: null,\n    onMessage: null,\n    onMessageError: null,\n    onMouseDown: null,\n    onMouseEnter: null,\n    onMouseLeave: null,\n    onMouseMove: null,\n    onMouseOut: null,\n    onMouseOver: null,\n    onMouseUp: null,\n    onOffline: null,\n    onOnline: null,\n    onPageHide: null,\n    onPageShow: null,\n    onPaste: null,\n    onPause: null,\n    onPlay: null,\n    onPlaying: null,\n    onPopState: null,\n    onProgress: null,\n    onRateChange: null,\n    onRejectionHandled: null,\n    onReset: null,\n    onResize: null,\n    onScroll: null,\n    onScrollEnd: null,\n    onSecurityPolicyViolation: null,\n    onSeeked: null,\n    onSeeking: null,\n    onSelect: null,\n    onSlotChange: null,\n    onStalled: null,\n    onStorage: null,\n    onSubmit: null,\n    onSuspend: null,\n    onTimeUpdate: null,\n    onToggle: null,\n    onUnhandledRejection: null,\n    onUnload: null,\n    onVolumeChange: null,\n    onWaiting: null,\n    onWheel: null,\n    open: boolean,\n    optimum: number,\n    pattern: null,\n    ping: spaceSeparated,\n    placeholder: null,\n    playsInline: boolean,\n    popover: null,\n    popoverTarget: null,\n    popoverTargetAction: null,\n    poster: null,\n    preload: null,\n    readOnly: boolean,\n    referrerPolicy: null,\n    rel: spaceSeparated,\n    required: boolean,\n    reversed: boolean,\n    rows: number,\n    rowSpan: number,\n    sandbox: spaceSeparated,\n    scope: null,\n    scoped: boolean,\n    seamless: boolean,\n    selected: boolean,\n    shadowRootClonable: boolean,\n    shadowRootDelegatesFocus: boolean,\n    shadowRootMode: null,\n    shape: null,\n    size: number,\n    sizes: null,\n    slot: null,\n    span: number,\n    spellCheck: booleanish,\n    src: null,\n    srcDoc: null,\n    srcLang: null,\n    srcSet: null,\n    start: number,\n    step: null,\n    style: null,\n    tabIndex: number,\n    target: null,\n    title: null,\n    translate: null,\n    type: null,\n    typeMustMatch: boolean,\n    useMap: null,\n    value: booleanish,\n    width: number,\n    wrap: null,\n    writingSuggestions: null,\n\n    // Legacy.\n    // See: https://html.spec.whatwg.org/#other-elements,-attributes-and-apis\n    align: null, // Several. Use CSS `text-align` instead,\n    aLink: null, // `<body>`. Use CSS `a:active {color}` instead\n    archive: spaceSeparated, // `<object>`. List of URIs to archives\n    axis: null, // `<td>` and `<th>`. Use `scope` on `<th>`\n    background: null, // `<body>`. Use CSS `background-image` instead\n    bgColor: null, // `<body>` and table elements. Use CSS `background-color` instead\n    border: number, // `<table>`. Use CSS `border-width` instead,\n    borderColor: null, // `<table>`. Use CSS `border-color` instead,\n    bottomMargin: number, // `<body>`\n    cellPadding: null, // `<table>`\n    cellSpacing: null, // `<table>`\n    char: null, // Several table elements. When `align=char`, sets the character to align on\n    charOff: null, // Several table elements. When `char`, offsets the alignment\n    classId: null, // `<object>`\n    clear: null, // `<br>`. Use CSS `clear` instead\n    code: null, // `<object>`\n    codeBase: null, // `<object>`\n    codeType: null, // `<object>`\n    color: null, // `<font>` and `<hr>`. Use CSS instead\n    compact: boolean, // Lists. Use CSS to reduce space between items instead\n    declare: boolean, // `<object>`\n    event: null, // `<script>`\n    face: null, // `<font>`. Use CSS instead\n    frame: null, // `<table>`\n    frameBorder: null, // `<iframe>`. Use CSS `border` instead\n    hSpace: number, // `<img>` and `<object>`\n    leftMargin: number, // `<body>`\n    link: null, // `<body>`. Use CSS `a:link {color: *}` instead\n    longDesc: null, // `<frame>`, `<iframe>`, and `<img>`. Use an `<a>`\n    lowSrc: null, // `<img>`. Use a `<picture>`\n    marginHeight: number, // `<body>`\n    marginWidth: number, // `<body>`\n    noResize: boolean, // `<frame>`\n    noHref: boolean, // `<area>`. Use no href instead of an explicit `nohref`\n    noShade: boolean, // `<hr>`. Use background-color and height instead of borders\n    noWrap: boolean, // `<td>` and `<th>`\n    object: null, // `<applet>`\n    profile: null, // `<head>`\n    prompt: null, // `<isindex>`\n    rev: null, // `<link>`\n    rightMargin: number, // `<body>`\n    rules: null, // `<table>`\n    scheme: null, // `<meta>`\n    scrolling: booleanish, // `<frame>`. Use overflow in the child context\n    standby: null, // `<object>`\n    summary: null, // `<table>`\n    text: null, // `<body>`. Use CSS `color` instead\n    topMargin: number, // `<body>`\n    valueType: null, // `<param>`\n    version: null, // `<html>`. Use a doctype.\n    vAlign: null, // Several. Use CSS `vertical-align` instead\n    vLink: null, // `<body>`. Use CSS `a:visited {color}` instead\n    vSpace: number, // `<img>` and `<object>`\n\n    // Non-standard Properties.\n    allowTransparency: null,\n    autoCorrect: null,\n    autoSave: null,\n    disablePictureInPicture: boolean,\n    disableRemotePlayback: boolean,\n    prefix: null,\n    property: null,\n    results: number,\n    security: null,\n    unselectable: null\n  }\n})\n","import {\n  boolean,\n  number,\n  spaceSeparated,\n  commaSeparated,\n  commaOrSpaceSeparated\n} from './util/types.js'\nimport {create} from './util/create.js'\nimport {caseSensitiveTransform} from './util/case-sensitive-transform.js'\n\nexport const svg = create({\n  space: 'svg',\n  attributes: {\n    accentHeight: 'accent-height',\n    alignmentBaseline: 'alignment-baseline',\n    arabicForm: 'arabic-form',\n    baselineShift: 'baseline-shift',\n    capHeight: 'cap-height',\n    className: 'class',\n    clipPath: 'clip-path',\n    clipRule: 'clip-rule',\n    colorInterpolation: 'color-interpolation',\n    colorInterpolationFilters: 'color-interpolation-filters',\n    colorProfile: 'color-profile',\n    colorRendering: 'color-rendering',\n    crossOrigin: 'crossorigin',\n    dataType: 'datatype',\n    dominantBaseline: 'dominant-baseline',\n    enableBackground: 'enable-background',\n    fillOpacity: 'fill-opacity',\n    fillRule: 'fill-rule',\n    floodColor: 'flood-color',\n    floodOpacity: 'flood-opacity',\n    fontFamily: 'font-family',\n    fontSize: 'font-size',\n    fontSizeAdjust: 'font-size-adjust',\n    fontStretch: 'font-stretch',\n    fontStyle: 'font-style',\n    fontVariant: 'font-variant',\n    fontWeight: 'font-weight',\n    glyphName: 'glyph-name',\n    glyphOrientationHorizontal: 'glyph-orientation-horizontal',\n    glyphOrientationVertical: 'glyph-orientation-vertical',\n    hrefLang: 'hreflang',\n    horizAdvX: 'horiz-adv-x',\n    horizOriginX: 'horiz-origin-x',\n    horizOriginY: 'horiz-origin-y',\n    imageRendering: 'image-rendering',\n    letterSpacing: 'letter-spacing',\n    lightingColor: 'lighting-color',\n    markerEnd: 'marker-end',\n    markerMid: 'marker-mid',\n    markerStart: 'marker-start',\n    navDown: 'nav-down',\n    navDownLeft: 'nav-down-left',\n    navDownRight: 'nav-down-right',\n    navLeft: 'nav-left',\n    navNext: 'nav-next',\n    navPrev: 'nav-prev',\n    navRight: 'nav-right',\n    navUp: 'nav-up',\n    navUpLeft: 'nav-up-left',\n    navUpRight: 'nav-up-right',\n    onAbort: 'onabort',\n    onActivate: 'onactivate',\n    onAfterPrint: 'onafterprint',\n    onBeforePrint: 'onbeforeprint',\n    onBegin: 'onbegin',\n    onCancel: 'oncancel',\n    onCanPlay: 'oncanplay',\n    onCanPlayThrough: 'oncanplaythrough',\n    onChange: 'onchange',\n    onClick: 'onclick',\n    onClose: 'onclose',\n    onCopy: 'oncopy',\n    onCueChange: 'oncuechange',\n    onCut: 'oncut',\n    onDblClick: 'ondblclick',\n    onDrag: 'ondrag',\n    onDragEnd: 'ondragend',\n    onDragEnter: 'ondragenter',\n    onDragExit: 'ondragexit',\n    onDragLeave: 'ondragleave',\n    onDragOver: 'ondragover',\n    onDragStart: 'ondragstart',\n    onDrop: 'ondrop',\n    onDurationChange: 'ondurationchange',\n    onEmptied: 'onemptied',\n    onEnd: 'onend',\n    onEnded: 'onended',\n    onError: 'onerror',\n    onFocus: 'onfocus',\n    onFocusIn: 'onfocusin',\n    onFocusOut: 'onfocusout',\n    onHashChange: 'onhashchange',\n    onInput: 'oninput',\n    onInvalid: 'oninvalid',\n    onKeyDown: 'onkeydown',\n    onKeyPress: 'onkeypress',\n    onKeyUp: 'onkeyup',\n    onLoad: 'onload',\n    onLoadedData: 'onloadeddata',\n    onLoadedMetadata: 'onloadedmetadata',\n    onLoadStart: 'onloadstart',\n    onMessage: 'onmessage',\n    onMouseDown: 'onmousedown',\n    onMouseEnter: 'onmouseenter',\n    onMouseLeave: 'onmouseleave',\n    onMouseMove: 'onmousemove',\n    onMouseOut: 'onmouseout',\n    onMouseOver: 'onmouseover',\n    onMouseUp: 'onmouseup',\n    onMouseWheel: 'onmousewheel',\n    onOffline: 'onoffline',\n    onOnline: 'ononline',\n    onPageHide: 'onpagehide',\n    onPageShow: 'onpageshow',\n    onPaste: 'onpaste',\n    onPause: 'onpause',\n    onPlay: 'onplay',\n    onPlaying: 'onplaying',\n    onPopState: 'onpopstate',\n    onProgress: 'onprogress',\n    onRateChange: 'onratechange',\n    onRepeat: 'onrepeat',\n    onReset: 'onreset',\n    onResize: 'onresize',\n    onScroll: 'onscroll',\n    onSeeked: 'onseeked',\n    onSeeking: 'onseeking',\n    onSelect: 'onselect',\n    onShow: 'onshow',\n    onStalled: 'onstalled',\n    onStorage: 'onstorage',\n    onSubmit: 'onsubmit',\n    onSuspend: 'onsuspend',\n    onTimeUpdate: 'ontimeupdate',\n    onToggle: 'ontoggle',\n    onUnload: 'onunload',\n    onVolumeChange: 'onvolumechange',\n    onWaiting: 'onwaiting',\n    onZoom: 'onzoom',\n    overlinePosition: 'overline-position',\n    overlineThickness: 'overline-thickness',\n    paintOrder: 'paint-order',\n    panose1: 'panose-1',\n    pointerEvents: 'pointer-events',\n    referrerPolicy: 'referrerpolicy',\n    renderingIntent: 'rendering-intent',\n    shapeRendering: 'shape-rendering',\n    stopColor: 'stop-color',\n    stopOpacity: 'stop-opacity',\n    strikethroughPosition: 'strikethrough-position',\n    strikethroughThickness: 'strikethrough-thickness',\n    strokeDashArray: 'stroke-dasharray',\n    strokeDashOffset: 'stroke-dashoffset',\n    strokeLineCap: 'stroke-linecap',\n    strokeLineJoin: 'stroke-linejoin',\n    strokeMiterLimit: 'stroke-miterlimit',\n    strokeOpacity: 'stroke-opacity',\n    strokeWidth: 'stroke-width',\n    tabIndex: 'tabindex',\n    textAnchor: 'text-anchor',\n    textDecoration: 'text-decoration',\n    textRendering: 'text-rendering',\n    transformOrigin: 'transform-origin',\n    typeOf: 'typeof',\n    underlinePosition: 'underline-position',\n    underlineThickness: 'underline-thickness',\n    unicodeBidi: 'unicode-bidi',\n    unicodeRange: 'unicode-range',\n    unitsPerEm: 'units-per-em',\n    vAlphabetic: 'v-alphabetic',\n    vHanging: 'v-hanging',\n    vIdeographic: 'v-ideographic',\n    vMathematical: 'v-mathematical',\n    vectorEffect: 'vector-effect',\n    vertAdvY: 'vert-adv-y',\n    vertOriginX: 'vert-origin-x',\n    vertOriginY: 'vert-origin-y',\n    wordSpacing: 'word-spacing',\n    writingMode: 'writing-mode',\n    xHeight: 'x-height',\n    // These were camelcased in Tiny. Now lowercased in SVG 2\n    playbackOrder: 'playbackorder',\n    timelineBegin: 'timelinebegin'\n  },\n  transform: caseSensitiveTransform,\n  properties: {\n    about: commaOrSpaceSeparated,\n    accentHeight: number,\n    accumulate: null,\n    additive: null,\n    alignmentBaseline: null,\n    alphabetic: number,\n    amplitude: number,\n    arabicForm: null,\n    ascent: number,\n    attributeName: null,\n    attributeType: null,\n    azimuth: number,\n    bandwidth: null,\n    baselineShift: null,\n    baseFrequency: null,\n    baseProfile: null,\n    bbox: null,\n    begin: null,\n    bias: number,\n    by: null,\n    calcMode: null,\n    capHeight: number,\n    className: spaceSeparated,\n    clip: null,\n    clipPath: null,\n    clipPathUnits: null,\n    clipRule: null,\n    color: null,\n    colorInterpolation: null,\n    colorInterpolationFilters: null,\n    colorProfile: null,\n    colorRendering: null,\n    content: null,\n    contentScriptType: null,\n    contentStyleType: null,\n    crossOrigin: null,\n    cursor: null,\n    cx: null,\n    cy: null,\n    d: null,\n    dataType: null,\n    defaultAction: null,\n    descent: number,\n    diffuseConstant: number,\n    direction: null,\n    display: null,\n    dur: null,\n    divisor: number,\n    dominantBaseline: null,\n    download: boolean,\n    dx: null,\n    dy: null,\n    edgeMode: null,\n    editable: null,\n    elevation: number,\n    enableBackground: null,\n    end: null,\n    event: null,\n    exponent: number,\n    externalResourcesRequired: null,\n    fill: null,\n    fillOpacity: number,\n    fillRule: null,\n    filter: null,\n    filterRes: null,\n    filterUnits: null,\n    floodColor: null,\n    floodOpacity: null,\n    focusable: null,\n    focusHighlight: null,\n    fontFamily: null,\n    fontSize: null,\n    fontSizeAdjust: null,\n    fontStretch: null,\n    fontStyle: null,\n    fontVariant: null,\n    fontWeight: null,\n    format: null,\n    fr: null,\n    from: null,\n    fx: null,\n    fy: null,\n    g1: commaSeparated,\n    g2: commaSeparated,\n    glyphName: commaSeparated,\n    glyphOrientationHorizontal: null,\n    glyphOrientationVertical: null,\n    glyphRef: null,\n    gradientTransform: null,\n    gradientUnits: null,\n    handler: null,\n    hanging: number,\n    hatchContentUnits: null,\n    hatchUnits: null,\n    height: null,\n    href: null,\n    hrefLang: null,\n    horizAdvX: number,\n    horizOriginX: number,\n    horizOriginY: number,\n    id: null,\n    ideographic: number,\n    imageRendering: null,\n    initialVisibility: null,\n    in: null,\n    in2: null,\n    intercept: number,\n    k: number,\n    k1: number,\n    k2: number,\n    k3: number,\n    k4: number,\n    kernelMatrix: commaOrSpaceSeparated,\n    kernelUnitLength: null,\n    keyPoints: null, // SEMI_COLON_SEPARATED\n    keySplines: null, // SEMI_COLON_SEPARATED\n    keyTimes: null, // SEMI_COLON_SEPARATED\n    kerning: null,\n    lang: null,\n    lengthAdjust: null,\n    letterSpacing: null,\n    lightingColor: null,\n    limitingConeAngle: number,\n    local: null,\n    markerEnd: null,\n    markerMid: null,\n    markerStart: null,\n    markerHeight: null,\n    markerUnits: null,\n    markerWidth: null,\n    mask: null,\n    maskContentUnits: null,\n    maskUnits: null,\n    mathematical: null,\n    max: null,\n    media: null,\n    mediaCharacterEncoding: null,\n    mediaContentEncodings: null,\n    mediaSize: number,\n    mediaTime: null,\n    method: null,\n    min: null,\n    mode: null,\n    name: null,\n    navDown: null,\n    navDownLeft: null,\n    navDownRight: null,\n    navLeft: null,\n    navNext: null,\n    navPrev: null,\n    navRight: null,\n    navUp: null,\n    navUpLeft: null,\n    navUpRight: null,\n    numOctaves: null,\n    observer: null,\n    offset: null,\n    onAbort: null,\n    onActivate: null,\n    onAfterPrint: null,\n    onBeforePrint: null,\n    onBegin: null,\n    onCancel: null,\n    onCanPlay: null,\n    onCanPlayThrough: null,\n    onChange: null,\n    onClick: null,\n    onClose: null,\n    onCopy: null,\n    onCueChange: null,\n    onCut: null,\n    onDblClick: null,\n    onDrag: null,\n    onDragEnd: null,\n    onDragEnter: null,\n    onDragExit: null,\n    onDragLeave: null,\n    onDragOver: null,\n    onDragStart: null,\n    onDrop: null,\n    onDurationChange: null,\n    onEmptied: null,\n    onEnd: null,\n    onEnded: null,\n    onError: null,\n    onFocus: null,\n    onFocusIn: null,\n    onFocusOut: null,\n    onHashChange: null,\n    onInput: null,\n    onInvalid: null,\n    onKeyDown: null,\n    onKeyPress: null,\n    onKeyUp: null,\n    onLoad: null,\n    onLoadedData: null,\n    onLoadedMetadata: null,\n    onLoadStart: null,\n    onMessage: null,\n    onMouseDown: null,\n    onMouseEnter: null,\n    onMouseLeave: null,\n    onMouseMove: null,\n    onMouseOut: null,\n    onMouseOver: null,\n    onMouseUp: null,\n    onMouseWheel: null,\n    onOffline: null,\n    onOnline: null,\n    onPageHide: null,\n    onPageShow: null,\n    onPaste: null,\n    onPause: null,\n    onPlay: null,\n    onPlaying: null,\n    onPopState: null,\n    onProgress: null,\n    onRateChange: null,\n    onRepeat: null,\n    onReset: null,\n    onResize: null,\n    onScroll: null,\n    onSeeked: null,\n    onSeeking: null,\n    onSelect: null,\n    onShow: null,\n    onStalled: null,\n    onStorage: null,\n    onSubmit: null,\n    onSuspend: null,\n    onTimeUpdate: null,\n    onToggle: null,\n    onUnload: null,\n    onVolumeChange: null,\n    onWaiting: null,\n    onZoom: null,\n    opacity: null,\n    operator: null,\n    order: null,\n    orient: null,\n    orientation: null,\n    origin: null,\n    overflow: null,\n    overlay: null,\n    overlinePosition: number,\n    overlineThickness: number,\n    paintOrder: null,\n    panose1: null,\n    path: null,\n    pathLength: number,\n    patternContentUnits: null,\n    patternTransform: null,\n    patternUnits: null,\n    phase: null,\n    ping: spaceSeparated,\n    pitch: null,\n    playbackOrder: null,\n    pointerEvents: null,\n    points: null,\n    pointsAtX: number,\n    pointsAtY: number,\n    pointsAtZ: number,\n    preserveAlpha: null,\n    preserveAspectRatio: null,\n    primitiveUnits: null,\n    propagate: null,\n    property: commaOrSpaceSeparated,\n    r: null,\n    radius: null,\n    referrerPolicy: null,\n    refX: null,\n    refY: null,\n    rel: commaOrSpaceSeparated,\n    rev: commaOrSpaceSeparated,\n    renderingIntent: null,\n    repeatCount: null,\n    repeatDur: null,\n    requiredExtensions: commaOrSpaceSeparated,\n    requiredFeatures: commaOrSpaceSeparated,\n    requiredFonts: commaOrSpaceSeparated,\n    requiredFormats: commaOrSpaceSeparated,\n    resource: null,\n    restart: null,\n    result: null,\n    rotate: null,\n    rx: null,\n    ry: null,\n    scale: null,\n    seed: null,\n    shapeRendering: null,\n    side: null,\n    slope: null,\n    snapshotTime: null,\n    specularConstant: number,\n    specularExponent: number,\n    spreadMethod: null,\n    spacing: null,\n    startOffset: null,\n    stdDeviation: null,\n    stemh: null,\n    stemv: null,\n    stitchTiles: null,\n    stopColor: null,\n    stopOpacity: null,\n    strikethroughPosition: number,\n    strikethroughThickness: number,\n    string: null,\n    stroke: null,\n    strokeDashArray: commaOrSpaceSeparated,\n    strokeDashOffset: null,\n    strokeLineCap: null,\n    strokeLineJoin: null,\n    strokeMiterLimit: number,\n    strokeOpacity: number,\n    strokeWidth: null,\n    style: null,\n    surfaceScale: number,\n    syncBehavior: null,\n    syncBehaviorDefault: null,\n    syncMaster: null,\n    syncTolerance: null,\n    syncToleranceDefault: null,\n    systemLanguage: commaOrSpaceSeparated,\n    tabIndex: number,\n    tableValues: null,\n    target: null,\n    targetX: number,\n    targetY: number,\n    textAnchor: null,\n    textDecoration: null,\n    textRendering: null,\n    textLength: null,\n    timelineBegin: null,\n    title: null,\n    transformBehavior: null,\n    type: null,\n    typeOf: commaOrSpaceSeparated,\n    to: null,\n    transform: null,\n    transformOrigin: null,\n    u1: null,\n    u2: null,\n    underlinePosition: number,\n    underlineThickness: number,\n    unicode: null,\n    unicodeBidi: null,\n    unicodeRange: null,\n    unitsPerEm: number,\n    values: null,\n    vAlphabetic: number,\n    vMathematical: number,\n    vectorEffect: null,\n    vHanging: number,\n    vIdeographic: number,\n    version: null,\n    vertAdvY: number,\n    vertOriginX: number,\n    vertOriginY: number,\n    viewBox: null,\n    viewTarget: null,\n    visibility: null,\n    width: null,\n    widths: null,\n    wordSpacing: null,\n    writingMode: null,\n    x: null,\n    x1: null,\n    x2: null,\n    xChannelSelector: null,\n    xHeight: number,\n    y: null,\n    y1: null,\n    y2: null,\n    yChannelSelector: null,\n    z: null,\n    zoomAndPan: null\n  }\n})\n","/**\n * @typedef {import('./lib/util/info.js').Info} Info\n * @typedef {import('./lib/util/schema.js').Schema} Schema\n */\n\nimport {merge} from './lib/util/merge.js'\nimport {xlink} from './lib/xlink.js'\nimport {xml} from './lib/xml.js'\nimport {xmlns} from './lib/xmlns.js'\nimport {aria} from './lib/aria.js'\nimport {html as htmlBase} from './lib/html.js'\nimport {svg as svgBase} from './lib/svg.js'\n\nexport {find} from './lib/find.js'\nexport {hastToReact} from './lib/hast-to-react.js'\nexport {normalize} from './lib/normalize.js'\nexport const html = merge([xml, xlink, xmlns, aria, htmlBase], 'html')\nexport const svg = merge([xml, xlink, xmlns, aria, svgBase], 'svg')\n","/**\n * @typedef {import('./util/schema.js').Schema} Schema\n */\n\nimport {normalize} from './normalize.js'\nimport {DefinedInfo} from './util/defined-info.js'\nimport {Info} from './util/info.js'\n\nconst valid = /^data[-\\w.:]+$/i\nconst dash = /-[a-z]/g\nconst cap = /[A-Z]/g\n\n/**\n * @param {Schema} schema\n * @param {string} value\n * @returns {Info}\n */\nexport function find(schema, value) {\n  const normal = normalize(value)\n  let prop = value\n  let Type = Info\n\n  if (normal in schema.normal) {\n    return schema.property[schema.normal[normal]]\n  }\n\n  if (normal.length > 4 && normal.slice(0, 4) === 'data' && valid.test(value)) {\n    // Attribute or property.\n    if (value.charAt(4) === '-') {\n      // Turn it into a property.\n      const rest = value.slice(5).replace(dash, camelcase)\n      prop = 'data' + rest.charAt(0).toUpperCase() + rest.slice(1)\n    } else {\n      // Turn it into an attribute.\n      const rest = value.slice(4)\n\n      if (!dash.test(rest)) {\n        let dashes = rest.replace(cap, kebab)\n\n        if (dashes.charAt(0) !== '-') {\n          dashes = '-' + dashes\n        }\n\n        value = 'data' + dashes\n      }\n    }\n\n    Type = DefinedInfo\n  }\n\n  return new Type(prop, value)\n}\n\n/**\n * @param {string} $0\n * @returns {string}\n */\nfunction kebab($0) {\n  return '-' + $0.toLowerCase()\n}\n\n/**\n * @param {string} $0\n * @returns {string}\n */\nfunction camelcase($0) {\n  return $0.charAt(1).toUpperCase()\n}\n","/**\n * `hast` is close to `React`, but differs in a couple of cases.\n *\n * To get a React property from a hast property, check if it is in\n * `hastToReact`, if it is, then use the corresponding value,\n * otherwise, use the hast property.\n *\n * @type {Record<string, string>}\n */\nexport const hastToReact = {\n  classId: 'classID',\n  dataType: 'datatype',\n  itemId: 'itemID',\n  strokeDashArray: 'strokeDasharray',\n  strokeDashOffset: 'strokeDashoffset',\n  strokeLineCap: 'strokeLinecap',\n  strokeLineJoin: 'strokeLinejoin',\n  strokeMiterLimit: 'strokeMiterlimit',\n  typeOf: 'typeof',\n  xLinkActuate: 'xlinkActuate',\n  xLinkArcRole: 'xlinkArcrole',\n  xLinkHref: 'xlinkHref',\n  xLinkRole: 'xlinkRole',\n  xLinkShow: 'xlinkShow',\n  xLinkTitle: 'xlinkTitle',\n  xLinkType: 'xlinkType',\n  xmlnsXLink: 'xmlnsXlink'\n}\n","import StyleToObject from '../cjs/index.js';\n\n// ensure compatibility with rollup umd build\nexport default StyleToObject.default || StyleToObject;\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Position} Position\n */\n\n/**\n * @typedef NodeLike\n * @property {string} type\n * @property {PositionLike | null | undefined} [position]\n *\n * @typedef PositionLike\n * @property {PointLike | null | undefined} [start]\n * @property {PointLike | null | undefined} [end]\n *\n * @typedef PointLike\n * @property {number | null | undefined} [line]\n * @property {number | null | undefined} [column]\n * @property {number | null | undefined} [offset]\n */\n\n/**\n * Get the ending point of `node`.\n *\n * @param node\n *   Node.\n * @returns\n *   Point.\n */\nexport const pointEnd = point('end')\n\n/**\n * Get the starting point of `node`.\n *\n * @param node\n *   Node.\n * @returns\n *   Point.\n */\nexport const pointStart = point('start')\n\n/**\n * Get the positional info of `node`.\n *\n * @param {'end' | 'start'} type\n *   Side.\n * @returns\n *   Getter.\n */\nfunction point(type) {\n  return point\n\n  /**\n   * Get the point info of `node` at a bound side.\n   *\n   * @param {Node | NodeLike | null | undefined} [node]\n   * @returns {Point | undefined}\n   */\n  function point(node) {\n    const point = (node && node.position && node.position[type]) || {}\n\n    if (\n      typeof point.line === 'number' &&\n      point.line > 0 &&\n      typeof point.column === 'number' &&\n      point.column > 0\n    ) {\n      return {\n        line: point.line,\n        column: point.column,\n        offset:\n          typeof point.offset === 'number' && point.offset > -1\n            ? point.offset\n            : undefined\n      }\n    }\n  }\n}\n\n/**\n * Get the positional info of `node`.\n *\n * @param {Node | NodeLike | null | undefined} [node]\n *   Node.\n * @returns {Position | undefined}\n *   Position.\n */\nexport function position(node) {\n  const start = pointStart(node)\n  const end = pointEnd(node)\n\n  if (start && end) {\n    return {start, end}\n  }\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Position} Position\n */\n\n/**\n * @typedef NodeLike\n * @property {string} type\n * @property {PositionLike | null | undefined} [position]\n *\n * @typedef PointLike\n * @property {number | null | undefined} [line]\n * @property {number | null | undefined} [column]\n * @property {number | null | undefined} [offset]\n *\n * @typedef PositionLike\n * @property {PointLike | null | undefined} [start]\n * @property {PointLike | null | undefined} [end]\n */\n\n/**\n * Serialize the positional info of a point, position (start and end points),\n * or node.\n *\n * @param {Node | NodeLike | Point | PointLike | Position | PositionLike | null | undefined} [value]\n *   Node, position, or point.\n * @returns {string}\n *   Pretty printed positional info of a node (`string`).\n *\n *   In the format of a range `ls:cs-le:ce` (when given `node` or `position`)\n *   or a point `l:c` (when given `point`), where `l` stands for line, `c` for\n *   column, `s` for `start`, and `e` for end.\n *   An empty string (`''`) is returned if the given value is neither `node`,\n *   `position`, nor `point`.\n */\nexport function stringifyPosition(value) {\n  // Nothing.\n  if (!value || typeof value !== 'object') {\n    return ''\n  }\n\n  // Node.\n  if ('position' in value || 'type' in value) {\n    return position(value.position)\n  }\n\n  // Position.\n  if ('start' in value || 'end' in value) {\n    return position(value)\n  }\n\n  // Point.\n  if ('line' in value || 'column' in value) {\n    return point(value)\n  }\n\n  // ?\n  return ''\n}\n\n/**\n * @param {Point | PointLike | null | undefined} point\n * @returns {string}\n */\nfunction point(point) {\n  return index(point && point.line) + ':' + index(point && point.column)\n}\n\n/**\n * @param {Position | PositionLike | null | undefined} pos\n * @returns {string}\n */\nfunction position(pos) {\n  return point(pos && pos.start) + '-' + point(pos && pos.end)\n}\n\n/**\n * @param {number | null | undefined} value\n * @returns {number}\n */\nfunction index(value) {\n  return value && typeof value === 'number' ? value : 1\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Position} Position\n */\n\n/**\n * @typedef {object & {type: string, position?: Position | undefined}} NodeLike\n *\n * @typedef Options\n *   Configuration.\n * @property {Array<Node> | null | undefined} [ancestors]\n *   Stack of (inclusive) ancestor nodes surrounding the message (optional).\n * @property {Error | null | undefined} [cause]\n *   Original error cause of the message (optional).\n * @property {Point | Position | null | undefined} [place]\n *   Place of message (optional).\n * @property {string | null | undefined} [ruleId]\n *   Category of message (optional, example: `'my-rule'`).\n * @property {string | null | undefined} [source]\n *   Namespace of who sent the message (optional, example: `'my-package'`).\n */\n\nimport {stringifyPosition} from 'unist-util-stringify-position'\n\n/**\n * Message.\n */\nexport class VFileMessage extends Error {\n  /**\n   * Create a message for `reason`.\n   *\n   * > 🪦 **Note**: also has obsolete signatures.\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Options | null | undefined} [options]\n   * @returns\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {string} reason\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @param {Error | VFileMessage | string} causeOrReason\n   *   Reason for message, should use markdown.\n   * @param {Node | NodeLike | Options | Point | Position | string | null | undefined} [optionsOrParentOrPlace]\n   *   Configuration (optional).\n   * @param {string | null | undefined} [origin]\n   *   Place in code where the message originates (example:\n   *   `'my-package:my-rule'` or `'my-rule'`).\n   * @returns\n   *   Instance of `VFileMessage`.\n   */\n  // eslint-disable-next-line complexity\n  constructor(causeOrReason, optionsOrParentOrPlace, origin) {\n    super()\n\n    if (typeof optionsOrParentOrPlace === 'string') {\n      origin = optionsOrParentOrPlace\n      optionsOrParentOrPlace = undefined\n    }\n\n    /** @type {string} */\n    let reason = ''\n    /** @type {Options} */\n    let options = {}\n    let legacyCause = false\n\n    if (optionsOrParentOrPlace) {\n      // Point.\n      if (\n        'line' in optionsOrParentOrPlace &&\n        'column' in optionsOrParentOrPlace\n      ) {\n        options = {place: optionsOrParentOrPlace}\n      }\n      // Position.\n      else if (\n        'start' in optionsOrParentOrPlace &&\n        'end' in optionsOrParentOrPlace\n      ) {\n        options = {place: optionsOrParentOrPlace}\n      }\n      // Node.\n      else if ('type' in optionsOrParentOrPlace) {\n        options = {\n          ancestors: [optionsOrParentOrPlace],\n          place: optionsOrParentOrPlace.position\n        }\n      }\n      // Options.\n      else {\n        options = {...optionsOrParentOrPlace}\n      }\n    }\n\n    if (typeof causeOrReason === 'string') {\n      reason = causeOrReason\n    }\n    // Error.\n    else if (!options.cause && causeOrReason) {\n      legacyCause = true\n      reason = causeOrReason.message\n      options.cause = causeOrReason\n    }\n\n    if (!options.ruleId && !options.source && typeof origin === 'string') {\n      const index = origin.indexOf(':')\n\n      if (index === -1) {\n        options.ruleId = origin\n      } else {\n        options.source = origin.slice(0, index)\n        options.ruleId = origin.slice(index + 1)\n      }\n    }\n\n    if (!options.place && options.ancestors && options.ancestors) {\n      const parent = options.ancestors[options.ancestors.length - 1]\n\n      if (parent) {\n        options.place = parent.position\n      }\n    }\n\n    const start =\n      options.place && 'start' in options.place\n        ? options.place.start\n        : options.place\n\n    /* eslint-disable no-unused-expressions */\n    /**\n     * Stack of ancestor nodes surrounding the message.\n     *\n     * @type {Array<Node> | undefined}\n     */\n    this.ancestors = options.ancestors || undefined\n\n    /**\n     * Original error cause of the message.\n     *\n     * @type {Error | undefined}\n     */\n    this.cause = options.cause || undefined\n\n    /**\n     * Starting column of message.\n     *\n     * @type {number | undefined}\n     */\n    this.column = start ? start.column : undefined\n\n    /**\n     * State of problem.\n     *\n     * * `true` — error, file not usable\n     * * `false` — warning, change may be needed\n     * * `undefined` — change likely not needed\n     *\n     * @type {boolean | null | undefined}\n     */\n    this.fatal = undefined\n\n    /**\n     * Path of a file (used throughout the `VFile` ecosystem).\n     *\n     * @type {string | undefined}\n     */\n    this.file\n\n    // Field from `Error`.\n    /**\n     * Reason for message.\n     *\n     * @type {string}\n     */\n    this.message = reason\n\n    /**\n     * Starting line of error.\n     *\n     * @type {number | undefined}\n     */\n    this.line = start ? start.line : undefined\n\n    // Field from `Error`.\n    /**\n     * Serialized positional info of message.\n     *\n     * On normal errors, this would be something like `ParseError`, buit in\n     * `VFile` messages we use this space to show where an error happened.\n     */\n    this.name = stringifyPosition(options.place) || '1:1'\n\n    /**\n     * Place of message.\n     *\n     * @type {Point | Position | undefined}\n     */\n    this.place = options.place || undefined\n\n    /**\n     * Reason for message, should use markdown.\n     *\n     * @type {string}\n     */\n    this.reason = this.message\n\n    /**\n     * Category of message (example: `'my-rule'`).\n     *\n     * @type {string | undefined}\n     */\n    this.ruleId = options.ruleId || undefined\n\n    /**\n     * Namespace of message (example: `'my-package'`).\n     *\n     * @type {string | undefined}\n     */\n    this.source = options.source || undefined\n\n    // Field from `Error`.\n    /**\n     * Stack of message.\n     *\n     * This is used by normal errors to show where something happened in\n     * programming code, irrelevant for `VFile` messages,\n     *\n     * @type {string}\n     */\n    this.stack =\n      legacyCause && options.cause && typeof options.cause.stack === 'string'\n        ? options.cause.stack\n        : ''\n\n    // The following fields are “well known”.\n    // Not standard.\n    // Feel free to add other non-standard fields to your messages.\n\n    /**\n     * Specify the source value that’s being reported, which is deemed\n     * incorrect.\n     *\n     * @type {string | undefined}\n     */\n    this.actual\n\n    /**\n     * Suggest acceptable values that can be used instead of `actual`.\n     *\n     * @type {Array<string> | undefined}\n     */\n    this.expected\n\n    /**\n     * Long form description of the message (you should use markdown).\n     *\n     * @type {string | undefined}\n     */\n    this.note\n\n    /**\n     * Link to docs for the message.\n     *\n     * > 👉 **Note**: this must be an absolute URL that can be passed as `x`\n     * > to `new URL(x)`.\n     *\n     * @type {string | undefined}\n     */\n    this.url\n    /* eslint-enable no-unused-expressions */\n  }\n}\n\nVFileMessage.prototype.file = ''\nVFileMessage.prototype.name = ''\nVFileMessage.prototype.reason = ''\nVFileMessage.prototype.message = ''\nVFileMessage.prototype.stack = ''\nVFileMessage.prototype.column = undefined\nVFileMessage.prototype.line = undefined\nVFileMessage.prototype.ancestors = undefined\nVFileMessage.prototype.cause = undefined\nVFileMessage.prototype.fatal = undefined\nVFileMessage.prototype.place = undefined\nVFileMessage.prototype.ruleId = undefined\nVFileMessage.prototype.source = undefined\n","/**\n * @import {Identifier, Literal, MemberExpression} from 'estree'\n * @import {Jsx, JsxDev, Options, Props} from 'hast-util-to-jsx-runtime'\n * @import {Element, Nodes, Parents, Root, Text} from 'hast'\n * @import {MdxFlowExpressionHast, MdxTextExpressionHast} from 'mdast-util-mdx-expression'\n * @import {MdxJsxFlowElementHast, MdxJsxTextElementHast} from 'mdast-util-mdx-jsx'\n * @import {MdxjsEsmHast} from 'mdast-util-mdxjs-esm'\n * @import {Position} from 'unist'\n * @import {Child, Create, Field, State, Style} from './types.js'\n */\n\nimport {stringify as commas} from 'comma-separated-tokens'\nimport {ok as assert} from 'devlop'\nimport {name as isIdentifierName} from 'estree-util-is-identifier-name'\nimport {whitespace} from 'hast-util-whitespace'\nimport {find, hastToReact, html, svg} from 'property-information'\nimport {stringify as spaces} from 'space-separated-tokens'\nimport styleToObject from 'style-to-object'\nimport {pointStart} from 'unist-util-position'\nimport {VFileMessage} from 'vfile-message'\n\n// To do: next major: `Object.hasOwn`.\nconst own = {}.hasOwnProperty\n\n/** @type {Map<string, number>} */\nconst emptyMap = new Map()\n\nconst cap = /[A-Z]/g\nconst dashSomething = /-([a-z])/g\n\n// `react-dom` triggers a warning for *any* white space in tables.\n// To follow GFM, `mdast-util-to-hast` injects line endings between elements.\n// Other tools might do so too, but they don’t do here, so we remove all of\n// that.\n\n// See: <https://github.com/facebook/react/pull/7081>.\n// See: <https://github.com/facebook/react/pull/7515>.\n// See: <https://github.com/remarkjs/remark-react/issues/64>.\n// See: <https://github.com/rehypejs/rehype-react/pull/29>.\n// See: <https://github.com/rehypejs/rehype-react/pull/32>.\n// See: <https://github.com/rehypejs/rehype-react/pull/45>.\nconst tableElements = new Set(['table', 'tbody', 'thead', 'tfoot', 'tr'])\n\nconst tableCellElement = new Set(['td', 'th'])\n\nconst docs = 'https://github.com/syntax-tree/hast-util-to-jsx-runtime'\n\n/**\n * Transform a hast tree to preact, react, solid, svelte, vue, etc.,\n * with an automatic JSX runtime.\n *\n * @param {Nodes} tree\n *   Tree to transform.\n * @param {Options} options\n *   Configuration (required).\n * @returns {JSX.Element}\n *   JSX element.\n */\n\nexport function toJsxRuntime(tree, options) {\n  if (!options || options.Fragment === undefined) {\n    throw new TypeError('Expected `Fragment` in options')\n  }\n\n  const filePath = options.filePath || undefined\n  /** @type {Create} */\n  let create\n\n  if (options.development) {\n    if (typeof options.jsxDEV !== 'function') {\n      throw new TypeError(\n        'Expected `jsxDEV` in options when `development: true`'\n      )\n    }\n\n    create = developmentCreate(filePath, options.jsxDEV)\n  } else {\n    if (typeof options.jsx !== 'function') {\n      throw new TypeError('Expected `jsx` in production options')\n    }\n\n    if (typeof options.jsxs !== 'function') {\n      throw new TypeError('Expected `jsxs` in production options')\n    }\n\n    create = productionCreate(filePath, options.jsx, options.jsxs)\n  }\n\n  /** @type {State} */\n  const state = {\n    Fragment: options.Fragment,\n    ancestors: [],\n    components: options.components || {},\n    create,\n    elementAttributeNameCase: options.elementAttributeNameCase || 'react',\n    evaluater: options.createEvaluater ? options.createEvaluater() : undefined,\n    filePath,\n    ignoreInvalidStyle: options.ignoreInvalidStyle || false,\n    passKeys: options.passKeys !== false,\n    passNode: options.passNode || false,\n    schema: options.space === 'svg' ? svg : html,\n    stylePropertyNameCase: options.stylePropertyNameCase || 'dom',\n    tableCellAlignToStyle: options.tableCellAlignToStyle !== false\n  }\n\n  const result = one(state, tree, undefined)\n\n  // JSX element.\n  if (result && typeof result !== 'string') {\n    return result\n  }\n\n  // Text node or something that turned into nothing.\n  return state.create(\n    tree,\n    state.Fragment,\n    {children: result || undefined},\n    undefined\n  )\n}\n\n/**\n * Transform a node.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Nodes} node\n *   Current node.\n * @param {string | undefined} key\n *   Key.\n * @returns {Child | undefined}\n *   Child, optional.\n */\nfunction one(state, node, key) {\n  if (node.type === 'element') {\n    return element(state, node, key)\n  }\n\n  if (node.type === 'mdxFlowExpression' || node.type === 'mdxTextExpression') {\n    return mdxExpression(state, node)\n  }\n\n  if (node.type === 'mdxJsxFlowElement' || node.type === 'mdxJsxTextElement') {\n    return mdxJsxElement(state, node, key)\n  }\n\n  if (node.type === 'mdxjsEsm') {\n    return mdxEsm(state, node)\n  }\n\n  if (node.type === 'root') {\n    return root(state, node, key)\n  }\n\n  if (node.type === 'text') {\n    return text(state, node)\n  }\n}\n\n/**\n * Handle element.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Element} node\n *   Current node.\n * @param {string | undefined} key\n *   Key.\n * @returns {Child | undefined}\n *   Child, optional.\n */\nfunction element(state, node, key) {\n  const parentSchema = state.schema\n  let schema = parentSchema\n\n  if (node.tagName.toLowerCase() === 'svg' && parentSchema.space === 'html') {\n    schema = svg\n    state.schema = schema\n  }\n\n  state.ancestors.push(node)\n\n  const type = findComponentFromName(state, node.tagName, false)\n  const props = createElementProps(state, node)\n  let children = createChildren(state, node)\n\n  if (tableElements.has(node.tagName)) {\n    children = children.filter(function (child) {\n      return typeof child === 'string' ? !whitespace(child) : true\n    })\n  }\n\n  addNode(state, props, type, node)\n  addChildren(props, children)\n\n  // Restore.\n  state.ancestors.pop()\n  state.schema = parentSchema\n\n  return state.create(node, type, props, key)\n}\n\n/**\n * Handle MDX expression.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdxFlowExpressionHast | MdxTextExpressionHast} node\n *   Current node.\n * @returns {Child | undefined}\n *   Child, optional.\n */\nfunction mdxExpression(state, node) {\n  if (node.data && node.data.estree && state.evaluater) {\n    const program = node.data.estree\n    const expression = program.body[0]\n    assert(expression.type === 'ExpressionStatement')\n\n    // Assume result is a child.\n    return /** @type {Child | undefined} */ (\n      state.evaluater.evaluateExpression(expression.expression)\n    )\n  }\n\n  crashEstree(state, node.position)\n}\n\n/**\n * Handle MDX ESM.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdxjsEsmHast} node\n *   Current node.\n * @returns {Child | undefined}\n *   Child, optional.\n */\nfunction mdxEsm(state, node) {\n  if (node.data && node.data.estree && state.evaluater) {\n    // Assume result is a child.\n    return /** @type {Child | undefined} */ (\n      state.evaluater.evaluateProgram(node.data.estree)\n    )\n  }\n\n  crashEstree(state, node.position)\n}\n\n/**\n * Handle MDX JSX.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdxJsxFlowElementHast | MdxJsxTextElementHast} node\n *   Current node.\n * @param {string | undefined} key\n *   Key.\n * @returns {Child | undefined}\n *   Child, optional.\n */\nfunction mdxJsxElement(state, node, key) {\n  const parentSchema = state.schema\n  let schema = parentSchema\n\n  if (node.name === 'svg' && parentSchema.space === 'html') {\n    schema = svg\n    state.schema = schema\n  }\n\n  state.ancestors.push(node)\n\n  const type =\n    node.name === null\n      ? state.Fragment\n      : findComponentFromName(state, node.name, true)\n  const props = createJsxElementProps(state, node)\n  const children = createChildren(state, node)\n\n  addNode(state, props, type, node)\n  addChildren(props, children)\n\n  // Restore.\n  state.ancestors.pop()\n  state.schema = parentSchema\n\n  return state.create(node, type, props, key)\n}\n\n/**\n * Handle root.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Root} node\n *   Current node.\n * @param {string | undefined} key\n *   Key.\n * @returns {Child | undefined}\n *   Child, optional.\n */\nfunction root(state, node, key) {\n  /** @type {Props} */\n  const props = {}\n\n  addChildren(props, createChildren(state, node))\n\n  return state.create(node, state.Fragment, props, key)\n}\n\n/**\n * Handle text.\n *\n * @param {State} _\n *   Info passed around.\n * @param {Text} node\n *   Current node.\n * @returns {Child | undefined}\n *   Child, optional.\n */\nfunction text(_, node) {\n  return node.value\n}\n\n/**\n * Add `node` to props.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Props} props\n *   Props.\n * @param {unknown} type\n *   Type.\n * @param {Element | MdxJsxFlowElementHast | MdxJsxTextElementHast} node\n *   Node.\n * @returns {undefined}\n *   Nothing.\n */\nfunction addNode(state, props, type, node) {\n  // If this is swapped out for a component:\n  if (typeof type !== 'string' && type !== state.Fragment && state.passNode) {\n    props.node = node\n  }\n}\n\n/**\n * Add children to props.\n *\n * @param {Props} props\n *   Props.\n * @param {Array<Child>} children\n *   Children.\n * @returns {undefined}\n *   Nothing.\n */\nfunction addChildren(props, children) {\n  if (children.length > 0) {\n    const value = children.length > 1 ? children : children[0]\n\n    if (value) {\n      props.children = value\n    }\n  }\n}\n\n/**\n * @param {string | undefined} _\n *   Path to file.\n * @param {Jsx} jsx\n *   Dynamic.\n * @param {Jsx} jsxs\n *   Static.\n * @returns {Create}\n *   Create a production element.\n */\nfunction productionCreate(_, jsx, jsxs) {\n  return create\n  /** @type {Create} */\n  function create(_, type, props, key) {\n    // Only an array when there are 2 or more children.\n    const isStaticChildren = Array.isArray(props.children)\n    const fn = isStaticChildren ? jsxs : jsx\n    return key ? fn(type, props, key) : fn(type, props)\n  }\n}\n\n/**\n * @param {string | undefined} filePath\n *   Path to file.\n * @param {JsxDev} jsxDEV\n *   Development.\n * @returns {Create}\n *   Create a development element.\n */\nfunction developmentCreate(filePath, jsxDEV) {\n  return create\n  /** @type {Create} */\n  function create(node, type, props, key) {\n    // Only an array when there are 2 or more children.\n    const isStaticChildren = Array.isArray(props.children)\n    const point = pointStart(node)\n    return jsxDEV(\n      type,\n      props,\n      key,\n      isStaticChildren,\n      {\n        columnNumber: point ? point.column - 1 : undefined,\n        fileName: filePath,\n        lineNumber: point ? point.line : undefined\n      },\n      undefined\n    )\n  }\n}\n\n/**\n * Create props from an element.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Element} node\n *   Current element.\n * @returns {Props}\n *   Props.\n */\nfunction createElementProps(state, node) {\n  /** @type {Props} */\n  const props = {}\n  /** @type {string | undefined} */\n  let alignValue\n  /** @type {string} */\n  let prop\n\n  for (prop in node.properties) {\n    if (prop !== 'children' && own.call(node.properties, prop)) {\n      const result = createProperty(state, prop, node.properties[prop])\n\n      if (result) {\n        const [key, value] = result\n\n        if (\n          state.tableCellAlignToStyle &&\n          key === 'align' &&\n          typeof value === 'string' &&\n          tableCellElement.has(node.tagName)\n        ) {\n          alignValue = value\n        } else {\n          props[key] = value\n        }\n      }\n    }\n  }\n\n  if (alignValue) {\n    // Assume style is an object.\n    const style = /** @type {Style} */ (props.style || (props.style = {}))\n    style[state.stylePropertyNameCase === 'css' ? 'text-align' : 'textAlign'] =\n      alignValue\n  }\n\n  return props\n}\n\n/**\n * Create props from a JSX element.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdxJsxFlowElementHast | MdxJsxTextElementHast} node\n *   Current JSX element.\n * @returns {Props}\n *   Props.\n */\nfunction createJsxElementProps(state, node) {\n  /** @type {Props} */\n  const props = {}\n\n  for (const attribute of node.attributes) {\n    if (attribute.type === 'mdxJsxExpressionAttribute') {\n      if (attribute.data && attribute.data.estree && state.evaluater) {\n        const program = attribute.data.estree\n        const expression = program.body[0]\n        assert(expression.type === 'ExpressionStatement')\n        const objectExpression = expression.expression\n        assert(objectExpression.type === 'ObjectExpression')\n        const property = objectExpression.properties[0]\n        assert(property.type === 'SpreadElement')\n\n        Object.assign(\n          props,\n          state.evaluater.evaluateExpression(property.argument)\n        )\n      } else {\n        crashEstree(state, node.position)\n      }\n    } else {\n      // For JSX, the author is responsible of passing in the correct values.\n      const name = attribute.name\n      /** @type {unknown} */\n      let value\n\n      if (attribute.value && typeof attribute.value === 'object') {\n        if (\n          attribute.value.data &&\n          attribute.value.data.estree &&\n          state.evaluater\n        ) {\n          const program = attribute.value.data.estree\n          const expression = program.body[0]\n          assert(expression.type === 'ExpressionStatement')\n          value = state.evaluater.evaluateExpression(expression.expression)\n        } else {\n          crashEstree(state, node.position)\n        }\n      } else {\n        value = attribute.value === null ? true : attribute.value\n      }\n\n      // Assume a prop.\n      props[name] = /** @type {Props[keyof Props]} */ (value)\n    }\n  }\n\n  return props\n}\n\n/**\n * Create children.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Parents} node\n *   Current element.\n * @returns {Array<Child>}\n *   Children.\n */\nfunction createChildren(state, node) {\n  /** @type {Array<Child>} */\n  const children = []\n  let index = -1\n  /** @type {Map<string, number>} */\n  // Note: test this when Solid doesn’t want to merge my upcoming PR.\n  /* c8 ignore next */\n  const countsByName = state.passKeys ? new Map() : emptyMap\n\n  while (++index < node.children.length) {\n    const child = node.children[index]\n    /** @type {string | undefined} */\n    let key\n\n    if (state.passKeys) {\n      const name =\n        child.type === 'element'\n          ? child.tagName\n          : child.type === 'mdxJsxFlowElement' ||\n              child.type === 'mdxJsxTextElement'\n            ? child.name\n            : undefined\n\n      if (name) {\n        const count = countsByName.get(name) || 0\n        key = name + '-' + count\n        countsByName.set(name, count + 1)\n      }\n    }\n\n    const result = one(state, child, key)\n    if (result !== undefined) children.push(result)\n  }\n\n  return children\n}\n\n/**\n * Handle a property.\n *\n * @param {State} state\n *   Info passed around.\n * @param {string} prop\n *   Key.\n * @param {Array<number | string> | boolean | number | string | null | undefined} value\n *   hast property value.\n * @returns {Field | undefined}\n *   Field for runtime, optional.\n */\nfunction createProperty(state, prop, value) {\n  const info = find(state.schema, prop)\n\n  // Ignore nullish and `NaN` values.\n  if (\n    value === null ||\n    value === undefined ||\n    (typeof value === 'number' && Number.isNaN(value))\n  ) {\n    return\n  }\n\n  if (Array.isArray(value)) {\n    // Accept `array`.\n    // Most props are space-separated.\n    value = info.commaSeparated ? commas(value) : spaces(value)\n  }\n\n  // React only accepts `style` as object.\n  if (info.property === 'style') {\n    let styleObject =\n      typeof value === 'object' ? value : parseStyle(state, String(value))\n\n    if (state.stylePropertyNameCase === 'css') {\n      styleObject = transformStylesToCssCasing(styleObject)\n    }\n\n    return ['style', styleObject]\n  }\n\n  return [\n    state.elementAttributeNameCase === 'react' && info.space\n      ? hastToReact[info.property] || info.property\n      : info.attribute,\n    value\n  ]\n}\n\n/**\n * Parse a CSS declaration to an object.\n *\n * @param {State} state\n *   Info passed around.\n * @param {string} value\n *   CSS declarations.\n * @returns {Style}\n *   Properties.\n * @throws\n *   Throws `VFileMessage` when CSS cannot be parsed.\n */\nfunction parseStyle(state, value) {\n  /** @type {Style} */\n  const result = {}\n\n  try {\n    styleToObject(value, replacer)\n  } catch (error) {\n    if (!state.ignoreInvalidStyle) {\n      const cause = /** @type {Error} */ (error)\n      const message = new VFileMessage('Cannot parse `style` attribute', {\n        ancestors: state.ancestors,\n        cause,\n        ruleId: 'style',\n        source: 'hast-util-to-jsx-runtime'\n      })\n      message.file = state.filePath || undefined\n      message.url = docs + '#cannot-parse-style-attribute'\n\n      throw message\n    }\n  }\n\n  return result\n\n  /**\n   * Add a CSS property (normal, so with dashes) to `result` as a DOM CSS\n   * property.\n   *\n   * @param {string} name\n   *   Key.\n   * @param {string} value\n   *   Value\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function replacer(name, value) {\n    let key = name\n\n    if (key.slice(0, 2) !== '--') {\n      if (key.slice(0, 4) === '-ms-') key = 'ms-' + key.slice(4)\n      key = key.replace(dashSomething, toCamel)\n    }\n\n    result[key] = value\n  }\n}\n\n/**\n * Create a JSX name from a string.\n *\n * @param {State} state\n *   To do.\n * @param {string} name\n *   Name.\n * @param {boolean} allowExpression\n *   Allow member expressions and identifiers.\n * @returns {unknown}\n *   To do.\n */\nfunction findComponentFromName(state, name, allowExpression) {\n  /** @type {Identifier | Literal | MemberExpression} */\n  let result\n\n  if (!allowExpression) {\n    result = {type: 'Literal', value: name}\n  } else if (name.includes('.')) {\n    const identifiers = name.split('.')\n    let index = -1\n    /** @type {Identifier | Literal | MemberExpression | undefined} */\n    let node\n\n    while (++index < identifiers.length) {\n      /** @type {Identifier | Literal} */\n      const prop = isIdentifierName(identifiers[index])\n        ? {type: 'Identifier', name: identifiers[index]}\n        : {type: 'Literal', value: identifiers[index]}\n      node = node\n        ? {\n            type: 'MemberExpression',\n            object: node,\n            property: prop,\n            computed: Boolean(index && prop.type === 'Literal'),\n            optional: false\n          }\n        : prop\n    }\n\n    assert(node, 'always a result')\n    result = node\n  } else {\n    result =\n      isIdentifierName(name) && !/^[a-z]/.test(name)\n        ? {type: 'Identifier', name}\n        : {type: 'Literal', value: name}\n  }\n\n  // Only literals can be passed in `components` currently.\n  // No identifiers / member expressions.\n  if (result.type === 'Literal') {\n    const name = /** @type {keyof JSX.IntrinsicElements} */ (result.value)\n\n    return own.call(state.components, name) ? state.components[name] : name\n  }\n\n  // Assume component.\n  if (state.evaluater) {\n    return state.evaluater.evaluateExpression(result)\n  }\n\n  crashEstree(state)\n}\n\n/**\n * @param {State} state\n * @param {Position | undefined} [place]\n * @returns {never}\n */\nfunction crashEstree(state, place) {\n  const message = new VFileMessage(\n    'Cannot handle MDX estrees without `createEvaluater`',\n    {\n      ancestors: state.ancestors,\n      place,\n      ruleId: 'mdx-estree',\n      source: 'hast-util-to-jsx-runtime'\n    }\n  )\n  message.file = state.filePath || undefined\n  message.url = docs + '#cannot-handle-mdx-estrees-without-createevaluater'\n\n  throw message\n}\n\n/**\n * Transform a DOM casing style object to a CSS casing style object.\n *\n * @param {Style} domCasing\n * @returns {Style}\n */\nfunction transformStylesToCssCasing(domCasing) {\n  /** @type {Style} */\n  const cssCasing = {}\n  /** @type {string} */\n  let from\n\n  for (from in domCasing) {\n    if (own.call(domCasing, from)) {\n      cssCasing[transformStyleToCssCasing(from)] = domCasing[from]\n    }\n  }\n\n  return cssCasing\n}\n\n/**\n * Transform a DOM casing style field to a CSS casing style field.\n *\n * @param {string} from\n * @returns {string}\n */\nfunction transformStyleToCssCasing(from) {\n  let to = from.replace(cap, toDash)\n  // Handle `ms-xxx` -> `-ms-xxx`.\n  if (to.slice(0, 3) === 'ms-') to = '-' + to\n  return to\n}\n\n/**\n * Make `$1` capitalized.\n *\n * @param {string} _\n *   Whatever.\n * @param {string} $1\n *   Single ASCII alphabetical.\n * @returns {string}\n *   Capitalized `$1`.\n */\nfunction toCamel(_, $1) {\n  return $1.toUpperCase()\n}\n\n/**\n * Make `$0` dash cased.\n *\n * @param {string} $0\n *   Capitalized ASCII leter.\n * @returns {string}\n *   Dash and lower letter.\n */\nfunction toDash($0) {\n  return '-' + $0.toLowerCase()\n}\n","/**\n * @typedef Options\n *   Configuration for `stringify`.\n * @property {boolean} [padLeft=true]\n *   Whether to pad a space before a token.\n * @property {boolean} [padRight=false]\n *   Whether to pad a space after a token.\n */\n\n/**\n * @typedef {Options} StringifyOptions\n *   Please use `StringifyOptions` instead.\n */\n\n/**\n * Parse comma-separated tokens to an array.\n *\n * @param {string} value\n *   Comma-separated tokens.\n * @returns {Array<string>}\n *   List of tokens.\n */\nexport function parse(value) {\n  /** @type {Array<string>} */\n  const tokens = []\n  const input = String(value || '')\n  let index = input.indexOf(',')\n  let start = 0\n  /** @type {boolean} */\n  let end = false\n\n  while (!end) {\n    if (index === -1) {\n      index = input.length\n      end = true\n    }\n\n    const token = input.slice(start, index).trim()\n\n    if (token || !end) {\n      tokens.push(token)\n    }\n\n    start = index + 1\n    index = input.indexOf(',', start)\n  }\n\n  return tokens\n}\n\n/**\n * Serialize an array of strings or numbers to comma-separated tokens.\n *\n * @param {Array<string|number>} values\n *   List of tokens.\n * @param {Options} [options]\n *   Configuration for `stringify` (optional).\n * @returns {string}\n *   Comma-separated tokens.\n */\nexport function stringify(values, options) {\n  const settings = options || {}\n\n  // Ensure the last empty entry is seen.\n  const input = values[values.length - 1] === '' ? [...values, ''] : values\n\n  return input\n    .join(\n      (settings.padRight ? ' ' : '') +\n        ',' +\n        (settings.padLeft === false ? '' : ' ')\n    )\n    .trim()\n}\n","/**\n * Parse space-separated tokens to an array of strings.\n *\n * @param {string} value\n *   Space-separated tokens.\n * @returns {Array<string>}\n *   List of tokens.\n */\nexport function parse(value) {\n  const input = String(value || '').trim()\n  return input ? input.split(/[ \\t\\n\\r\\f]+/g) : []\n}\n\n/**\n * Serialize an array of strings as space separated-tokens.\n *\n * @param {Array<string|number>} values\n *   List of tokens.\n * @returns {string}\n *   Space-separated tokens.\n */\nexport function stringify(values) {\n  return values.join(' ').trim()\n}\n","/**\n * HTML URL properties.\n *\n * Each key is a property name and each value is a list of tag names it applies\n * to or `null` if it applies to all elements.\n *\n * @type {Record<string, Array<string> | null>}\n */\nexport const urlAttributes = {\n  action: ['form'],\n  cite: ['blockquote', 'del', 'ins', 'q'],\n  data: ['object'],\n  formAction: ['button', 'input'],\n  href: ['a', 'area', 'base', 'link'],\n  icon: ['menuitem'],\n  itemId: null,\n  manifest: ['html'],\n  ping: ['a', 'area'],\n  poster: ['video'],\n  src: [\n    'audio',\n    'embed',\n    'iframe',\n    'img',\n    'input',\n    'script',\n    'source',\n    'track',\n    'video'\n  ]\n}\n","/**\n * @typedef {import('mdast').Nodes} Nodes\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean | null | undefined} [includeImageAlt=true]\n *   Whether to use `alt` for `image`s (default: `true`).\n * @property {boolean | null | undefined} [includeHtml=true]\n *   Whether to use `value` of HTML (default: `true`).\n */\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Get the text content of a node or list of nodes.\n *\n * Prefers the node’s plain-text fields, otherwise serializes its children,\n * and if the given value is an array, serialize the nodes in it.\n *\n * @param {unknown} [value]\n *   Thing to serialize, typically `Node`.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {string}\n *   Serialized `value`.\n */\nexport function toString(value, options) {\n  const settings = options || emptyOptions\n  const includeImageAlt =\n    typeof settings.includeImageAlt === 'boolean'\n      ? settings.includeImageAlt\n      : true\n  const includeHtml =\n    typeof settings.includeHtml === 'boolean' ? settings.includeHtml : true\n\n  return one(value, includeImageAlt, includeHtml)\n}\n\n/**\n * One node or several nodes.\n *\n * @param {unknown} value\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @param {boolean} includeHtml\n *   Include HTML.\n * @returns {string}\n *   Serialized node.\n */\nfunction one(value, includeImageAlt, includeHtml) {\n  if (node(value)) {\n    if ('value' in value) {\n      return value.type === 'html' && !includeHtml ? '' : value.value\n    }\n\n    if (includeImageAlt && 'alt' in value && value.alt) {\n      return value.alt\n    }\n\n    if ('children' in value) {\n      return all(value.children, includeImageAlt, includeHtml)\n    }\n  }\n\n  if (Array.isArray(value)) {\n    return all(value, includeImageAlt, includeHtml)\n  }\n\n  return ''\n}\n\n/**\n * Serialize a list of nodes.\n *\n * @param {Array<unknown>} values\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @param {boolean} includeHtml\n *   Include HTML.\n * @returns {string}\n *   Serialized nodes.\n */\nfunction all(values, includeImageAlt, includeHtml) {\n  /** @type {Array<string>} */\n  const result = []\n  let index = -1\n\n  while (++index < values.length) {\n    result[index] = one(values[index], includeImageAlt, includeHtml)\n  }\n\n  return result.join('')\n}\n\n/**\n * Check if `value` looks like a node.\n *\n * @param {unknown} value\n *   Thing.\n * @returns {value is Nodes}\n *   Whether `value` is a node.\n */\nfunction node(value) {\n  return Boolean(value && typeof value === 'object')\n}\n","/**\n * Like `Array#splice`, but smarter for giant arrays.\n *\n * `Array#splice` takes all items to be inserted as individual argument which\n * causes a stack overflow in V8 when trying to insert 100k items for instance.\n *\n * Otherwise, this does not return the removed items, and takes `items` as an\n * array instead of rest parameters.\n *\n * @template {unknown} T\n *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {number} start\n *   Index to remove/insert at (can be negative).\n * @param {number} remove\n *   Number of items to remove.\n * @param {Array<T>} items\n *   Items to inject into `list`.\n * @returns {undefined}\n *   Nothing.\n */\nexport function splice(list, start, remove, items) {\n  const end = list.length;\n  let chunkStart = 0;\n  /** @type {Array<unknown>} */\n  let parameters;\n\n  // Make start between zero and `end` (included).\n  if (start < 0) {\n    start = -start > end ? 0 : end + start;\n  } else {\n    start = start > end ? end : start;\n  }\n  remove = remove > 0 ? remove : 0;\n\n  // No need to chunk the items if there’s only a couple (10k) items.\n  if (items.length < 10000) {\n    parameters = Array.from(items);\n    parameters.unshift(start, remove);\n    // @ts-expect-error Hush, it’s fine.\n    list.splice(...parameters);\n  } else {\n    // Delete `remove` items starting from `start`\n    if (remove) list.splice(start, remove);\n\n    // Insert the items in chunks to not cause stack overflows.\n    while (chunkStart < items.length) {\n      parameters = items.slice(chunkStart, chunkStart + 10000);\n      parameters.unshift(start, 0);\n      // @ts-expect-error Hush, it’s fine.\n      list.splice(...parameters);\n      chunkStart += 10000;\n      start += 10000;\n    }\n  }\n}\n\n/**\n * Append `items` (an array) at the end of `list` (another array).\n * When `list` was empty, returns `items` instead.\n *\n * This prevents a potentially expensive operation when `list` is empty,\n * and adds items in batches to prevent V8 from hanging.\n *\n * @template {unknown} T\n *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {Array<T>} items\n *   Items to add to `list`.\n * @returns {Array<T>}\n *   Either `list` or `items`.\n */\nexport function push(list, items) {\n  if (list.length > 0) {\n    splice(list, list.length, 0, items);\n    return list;\n  }\n  return items;\n}","/**\n * Some of the internal operations of micromark do lots of editing\n * operations on very large arrays. This runs into problems with two\n * properties of most circa-2020 JavaScript interpreters:\n *\n *  - Array-length modifications at the high end of an array (push/pop) are\n *    expected to be common and are implemented in (amortized) time\n *    proportional to the number of elements added or removed, whereas\n *    other operations (shift/unshift and splice) are much less efficient.\n *  - Function arguments are passed on the stack, so adding tens of thousands\n *    of elements to an array with `arr.push(...newElements)` will frequently\n *    cause stack overflows. (see <https://stackoverflow.com/questions/22123769/rangeerror-maximum-call-stack-size-exceeded-why>)\n *\n * SpliceBuffers are an implementation of gap buffers, which are a\n * generalization of the \"queue made of two stacks\" idea. The splice buffer\n * maintains a cursor, and moving the cursor has cost proportional to the\n * distance the cursor moves, but inserting, deleting, or splicing in\n * new information at the cursor is as efficient as the push/pop operation.\n * This allows for an efficient sequence of splices (or pushes, pops, shifts,\n * or unshifts) as long such edits happen at the same part of the array or\n * generally sweep through the array from the beginning to the end.\n *\n * The interface for splice buffers also supports large numbers of inputs by\n * passing a single array argument rather passing multiple arguments on the\n * function call stack.\n *\n * @template T\n *   Item type.\n */\nexport class SpliceBuffer {\n  /**\n   * @param {ReadonlyArray<T> | null | undefined} [initial]\n   *   Initial items (optional).\n   * @returns\n   *   Splice buffer.\n   */\n  constructor(initial) {\n    /** @type {Array<T>} */\n    this.left = initial ? [...initial] : [];\n    /** @type {Array<T>} */\n    this.right = [];\n  }\n\n  /**\n   * Array access;\n   * does not move the cursor.\n   *\n   * @param {number} index\n   *   Index.\n   * @return {T}\n   *   Item.\n   */\n  get(index) {\n    if (index < 0 || index >= this.left.length + this.right.length) {\n      throw new RangeError('Cannot access index `' + index + '` in a splice buffer of size `' + (this.left.length + this.right.length) + '`');\n    }\n    if (index < this.left.length) return this.left[index];\n    return this.right[this.right.length - index + this.left.length - 1];\n  }\n\n  /**\n   * The length of the splice buffer, one greater than the largest index in the\n   * array.\n   */\n  get length() {\n    return this.left.length + this.right.length;\n  }\n\n  /**\n   * Remove and return `list[0]`;\n   * moves the cursor to `0`.\n   *\n   * @returns {T | undefined}\n   *   Item, optional.\n   */\n  shift() {\n    this.setCursor(0);\n    return this.right.pop();\n  }\n\n  /**\n   * Slice the buffer to get an array;\n   * does not move the cursor.\n   *\n   * @param {number} start\n   *   Start.\n   * @param {number | null | undefined} [end]\n   *   End (optional).\n   * @returns {Array<T>}\n   *   Array of items.\n   */\n  slice(start, end) {\n    /** @type {number} */\n    const stop = end === null || end === undefined ? Number.POSITIVE_INFINITY : end;\n    if (stop < this.left.length) {\n      return this.left.slice(start, stop);\n    }\n    if (start > this.left.length) {\n      return this.right.slice(this.right.length - stop + this.left.length, this.right.length - start + this.left.length).reverse();\n    }\n    return this.left.slice(start).concat(this.right.slice(this.right.length - stop + this.left.length).reverse());\n  }\n\n  /**\n   * Mimics the behavior of Array.prototype.splice() except for the change of\n   * interface necessary to avoid segfaults when patching in very large arrays.\n   *\n   * This operation moves cursor is moved to `start` and results in the cursor\n   * placed after any inserted items.\n   *\n   * @param {number} start\n   *   Start;\n   *   zero-based index at which to start changing the array;\n   *   negative numbers count backwards from the end of the array and values\n   *   that are out-of bounds are clamped to the appropriate end of the array.\n   * @param {number | null | undefined} [deleteCount=0]\n   *   Delete count (default: `0`);\n   *   maximum number of elements to delete, starting from start.\n   * @param {Array<T> | null | undefined} [items=[]]\n   *   Items to include in place of the deleted items (default: `[]`).\n   * @return {Array<T>}\n   *   Any removed items.\n   */\n  splice(start, deleteCount, items) {\n    /** @type {number} */\n    const count = deleteCount || 0;\n    this.setCursor(Math.trunc(start));\n    const removed = this.right.splice(this.right.length - count, Number.POSITIVE_INFINITY);\n    if (items) chunkedPush(this.left, items);\n    return removed.reverse();\n  }\n\n  /**\n   * Remove and return the highest-numbered item in the array, so\n   * `list[list.length - 1]`;\n   * Moves the cursor to `length`.\n   *\n   * @returns {T | undefined}\n   *   Item, optional.\n   */\n  pop() {\n    this.setCursor(Number.POSITIVE_INFINITY);\n    return this.left.pop();\n  }\n\n  /**\n   * Inserts a single item to the high-numbered side of the array;\n   * moves the cursor to `length`.\n   *\n   * @param {T} item\n   *   Item.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  push(item) {\n    this.setCursor(Number.POSITIVE_INFINITY);\n    this.left.push(item);\n  }\n\n  /**\n   * Inserts many items to the high-numbered side of the array.\n   * Moves the cursor to `length`.\n   *\n   * @param {Array<T>} items\n   *   Items.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  pushMany(items) {\n    this.setCursor(Number.POSITIVE_INFINITY);\n    chunkedPush(this.left, items);\n  }\n\n  /**\n   * Inserts a single item to the low-numbered side of the array;\n   * Moves the cursor to `0`.\n   *\n   * @param {T} item\n   *   Item.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  unshift(item) {\n    this.setCursor(0);\n    this.right.push(item);\n  }\n\n  /**\n   * Inserts many items to the low-numbered side of the array;\n   * moves the cursor to `0`.\n   *\n   * @param {Array<T>} items\n   *   Items.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  unshiftMany(items) {\n    this.setCursor(0);\n    chunkedPush(this.right, items.reverse());\n  }\n\n  /**\n   * Move the cursor to a specific position in the array. Requires\n   * time proportional to the distance moved.\n   *\n   * If `n < 0`, the cursor will end up at the beginning.\n   * If `n > length`, the cursor will end up at the end.\n   *\n   * @param {number} n\n   *   Position.\n   * @return {undefined}\n   *   Nothing.\n   */\n  setCursor(n) {\n    if (n === this.left.length || n > this.left.length && this.right.length === 0 || n < 0 && this.left.length === 0) return;\n    if (n < this.left.length) {\n      // Move cursor to the this.left\n      const removed = this.left.splice(n, Number.POSITIVE_INFINITY);\n      chunkedPush(this.right, removed.reverse());\n    } else {\n      // Move cursor to the this.right\n      const removed = this.right.splice(this.left.length + this.right.length - n, Number.POSITIVE_INFINITY);\n      chunkedPush(this.left, removed.reverse());\n    }\n  }\n}\n\n/**\n * Avoid stack overflow by pushing items onto the stack in segments\n *\n * @template T\n *   Item type.\n * @param {Array<T>} list\n *   List to inject into.\n * @param {ReadonlyArray<T>} right\n *   Items to inject.\n * @return {undefined}\n *   Nothing.\n */\nfunction chunkedPush(list, right) {\n  /** @type {number} */\n  let chunkStart = 0;\n  if (right.length < 10000) {\n    list.push(...right);\n  } else {\n    while (chunkStart < right.length) {\n      list.push(...right.slice(chunkStart, chunkStart + 10000));\n      chunkStart += 10000;\n    }\n  }\n}","/**\n * @import {Chunk, Event, Token} from 'micromark-util-types'\n */\n\nimport { splice } from 'micromark-util-chunked';\nimport { SpliceBuffer } from './lib/splice-buffer.js';\n\n// Hidden API exposed for testing.\nexport { SpliceBuffer } from './lib/splice-buffer.js';\n\n/**\n * Tokenize subcontent.\n *\n * @param {Array<Event>} eventsArray\n *   List of events.\n * @returns {boolean}\n *   Whether subtokens were found.\n */\n// eslint-disable-next-line complexity\nexport function subtokenize(eventsArray) {\n  /** @type {Record<string, number>} */\n  const jumps = {};\n  let index = -1;\n  /** @type {Event} */\n  let event;\n  /** @type {number | undefined} */\n  let lineIndex;\n  /** @type {number} */\n  let otherIndex;\n  /** @type {Event} */\n  let otherEvent;\n  /** @type {Array<Event>} */\n  let parameters;\n  /** @type {Array<Event>} */\n  let subevents;\n  /** @type {boolean | undefined} */\n  let more;\n  const events = new SpliceBuffer(eventsArray);\n  while (++index < events.length) {\n    while (index in jumps) {\n      index = jumps[index];\n    }\n    event = events.get(index);\n\n    // Add a hook for the GFM tasklist extension, which needs to know if text\n    // is in the first content of a list item.\n    if (index && event[1].type === \"chunkFlow\" && events.get(index - 1)[1].type === \"listItemPrefix\") {\n      subevents = event[1]._tokenizer.events;\n      otherIndex = 0;\n      if (otherIndex < subevents.length && subevents[otherIndex][1].type === \"lineEndingBlank\") {\n        otherIndex += 2;\n      }\n      if (otherIndex < subevents.length && subevents[otherIndex][1].type === \"content\") {\n        while (++otherIndex < subevents.length) {\n          if (subevents[otherIndex][1].type === \"content\") {\n            break;\n          }\n          if (subevents[otherIndex][1].type === \"chunkText\") {\n            subevents[otherIndex][1]._isInFirstContentOfListItem = true;\n            otherIndex++;\n          }\n        }\n      }\n    }\n\n    // Enter.\n    if (event[0] === 'enter') {\n      if (event[1].contentType) {\n        Object.assign(jumps, subcontent(events, index));\n        index = jumps[index];\n        more = true;\n      }\n    }\n    // Exit.\n    else if (event[1]._container) {\n      otherIndex = index;\n      lineIndex = undefined;\n      while (otherIndex--) {\n        otherEvent = events.get(otherIndex);\n        if (otherEvent[1].type === \"lineEnding\" || otherEvent[1].type === \"lineEndingBlank\") {\n          if (otherEvent[0] === 'enter') {\n            if (lineIndex) {\n              events.get(lineIndex)[1].type = \"lineEndingBlank\";\n            }\n            otherEvent[1].type = \"lineEnding\";\n            lineIndex = otherIndex;\n          }\n        } else {\n          break;\n        }\n      }\n      if (lineIndex) {\n        // Fix position.\n        event[1].end = {\n          ...events.get(lineIndex)[1].start\n        };\n\n        // Switch container exit w/ line endings.\n        parameters = events.slice(lineIndex, index);\n        parameters.unshift(event);\n        events.splice(lineIndex, index - lineIndex + 1, parameters);\n      }\n    }\n  }\n\n  // The changes to the `events` buffer must be copied back into the eventsArray\n  splice(eventsArray, 0, Number.POSITIVE_INFINITY, events.slice(0));\n  return !more;\n}\n\n/**\n * Tokenize embedded tokens.\n *\n * @param {SpliceBuffer<Event>} events\n *   Events.\n * @param {number} eventIndex\n *   Index.\n * @returns {Record<string, number>}\n *   Gaps.\n */\nfunction subcontent(events, eventIndex) {\n  const token = events.get(eventIndex)[1];\n  const context = events.get(eventIndex)[2];\n  let startPosition = eventIndex - 1;\n  /** @type {Array<number>} */\n  const startPositions = [];\n  const tokenizer = token._tokenizer || context.parser[token.contentType](token.start);\n  const childEvents = tokenizer.events;\n  /** @type {Array<[number, number]>} */\n  const jumps = [];\n  /** @type {Record<string, number>} */\n  const gaps = {};\n  /** @type {Array<Chunk>} */\n  let stream;\n  /** @type {Token | undefined} */\n  let previous;\n  let index = -1;\n  /** @type {Token | undefined} */\n  let current = token;\n  let adjust = 0;\n  let start = 0;\n  const breaks = [start];\n\n  // Loop forward through the linked tokens to pass them in order to the\n  // subtokenizer.\n  while (current) {\n    // Find the position of the event for this token.\n    while (events.get(++startPosition)[1] !== current) {\n      // Empty.\n    }\n    startPositions.push(startPosition);\n    if (!current._tokenizer) {\n      stream = context.sliceStream(current);\n      if (!current.next) {\n        stream.push(null);\n      }\n      if (previous) {\n        tokenizer.defineSkip(current.start);\n      }\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = true;\n      }\n      tokenizer.write(stream);\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = undefined;\n      }\n    }\n\n    // Unravel the next token.\n    previous = current;\n    current = current.next;\n  }\n\n  // Now, loop back through all events (and linked tokens), to figure out which\n  // parts belong where.\n  current = token;\n  while (++index < childEvents.length) {\n    if (\n    // Find a void token that includes a break.\n    childEvents[index][0] === 'exit' && childEvents[index - 1][0] === 'enter' && childEvents[index][1].type === childEvents[index - 1][1].type && childEvents[index][1].start.line !== childEvents[index][1].end.line) {\n      start = index + 1;\n      breaks.push(start);\n      // Help GC.\n      current._tokenizer = undefined;\n      current.previous = undefined;\n      current = current.next;\n    }\n  }\n\n  // Help GC.\n  tokenizer.events = [];\n\n  // If there’s one more token (which is the cases for lines that end in an\n  // EOF), that’s perfect: the last point we found starts it.\n  // If there isn’t then make sure any remaining content is added to it.\n  if (current) {\n    // Help GC.\n    current._tokenizer = undefined;\n    current.previous = undefined;\n  } else {\n    breaks.pop();\n  }\n\n  // Now splice the events from the subtokenizer into the current events,\n  // moving back to front so that splice indices aren’t affected.\n  index = breaks.length;\n  while (index--) {\n    const slice = childEvents.slice(breaks[index], breaks[index + 1]);\n    const start = startPositions.pop();\n    jumps.push([start, start + slice.length - 1]);\n    events.splice(start, 2, slice);\n  }\n  jumps.reverse();\n  index = -1;\n  while (++index < jumps.length) {\n    gaps[adjust + jumps[index][0]] = adjust + jumps[index][1];\n    adjust += jumps[index][1] - jumps[index][0] - 1;\n  }\n  return gaps;\n}","/**\n * @import {\n *   Extension,\n *   Handles,\n *   HtmlExtension,\n *   NormalizedExtension\n * } from 'micromark-util-types'\n */\n\nimport {splice} from 'micromark-util-chunked'\n\nconst hasOwnProperty = {}.hasOwnProperty\n\n/**\n * Combine multiple syntax extensions into one.\n *\n * @param {ReadonlyArray<Extension>} extensions\n *   List of syntax extensions.\n * @returns {NormalizedExtension}\n *   A single combined extension.\n */\nexport function combineExtensions(extensions) {\n  /** @type {NormalizedExtension} */\n  const all = {}\n  let index = -1\n\n  while (++index < extensions.length) {\n    syntaxExtension(all, extensions[index])\n  }\n\n  return all\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {NormalizedExtension} all\n *   Extension to merge into.\n * @param {Extension} extension\n *   Extension to merge.\n * @returns {undefined}\n *   Nothing.\n */\nfunction syntaxExtension(all, extension) {\n  /** @type {keyof Extension} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    /** @type {Record<string, unknown>} */\n    const left = maybe || (all[hook] = {})\n    /** @type {Record<string, unknown> | undefined} */\n    const right = extension[hook]\n    /** @type {string} */\n    let code\n\n    if (right) {\n      for (code in right) {\n        if (!hasOwnProperty.call(left, code)) left[code] = []\n        const value = right[code]\n        constructs(\n          // @ts-expect-error Looks like a list.\n          left[code],\n          Array.isArray(value) ? value : value ? [value] : []\n        )\n      }\n    }\n  }\n}\n\n/**\n * Merge `list` into `existing` (both lists of constructs).\n * Mutates `existing`.\n *\n * @param {Array<unknown>} existing\n *   List of constructs to merge into.\n * @param {Array<unknown>} list\n *   List of constructs to merge.\n * @returns {undefined}\n *   Nothing.\n */\nfunction constructs(existing, list) {\n  let index = -1\n  /** @type {Array<unknown>} */\n  const before = []\n\n  while (++index < list.length) {\n    // @ts-expect-error Looks like an object.\n    ;(list[index].add === 'after' ? existing : before).push(list[index])\n  }\n\n  splice(existing, 0, 0, before)\n}\n\n/**\n * Combine multiple HTML extensions into one.\n *\n * @param {ReadonlyArray<HtmlExtension>} htmlExtensions\n *   List of HTML extensions.\n * @returns {HtmlExtension}\n *   Single combined HTML extension.\n */\nexport function combineHtmlExtensions(htmlExtensions) {\n  /** @type {HtmlExtension} */\n  const handlers = {}\n  let index = -1\n\n  while (++index < htmlExtensions.length) {\n    htmlExtension(handlers, htmlExtensions[index])\n  }\n\n  return handlers\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {HtmlExtension} all\n *   Extension to merge into.\n * @param {HtmlExtension} extension\n *   Extension to merge.\n * @returns {undefined}\n *   Nothing.\n */\nfunction htmlExtension(all, extension) {\n  /** @type {keyof HtmlExtension} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    const left = maybe || (all[hook] = {})\n    const right = extension[hook]\n    /** @type {keyof Handles} */\n    let type\n\n    if (right) {\n      for (type in right) {\n        // @ts-expect-error assume document vs regular handler are managed correctly.\n        left[type] = right[type]\n      }\n    }\n  }\n}\n","/**\n * @import {Code} from 'micromark-util-types'\n */\n\n/**\n * Check whether the character code represents an ASCII alpha (`a` through `z`,\n * case insensitive).\n *\n * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.\n *\n * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)\n * to U+005A (`Z`).\n *\n * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)\n * to U+007A (`z`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAlpha = regexCheck(/[A-Za-z]/);\n\n/**\n * Check whether the character code represents an ASCII alphanumeric (`a`\n * through `z`, case insensitive, or `0` through `9`).\n *\n * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha\n * (see `asciiAlpha`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/);\n\n/**\n * Check whether the character code represents an ASCII atext.\n *\n * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in\n * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),\n * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F\n * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E\n * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE\n * (`{`) to U+007E TILDE (`~`).\n *\n * See:\n * **\\[RFC5322]**:\n * [Internet Message Format](https://tools.ietf.org/html/rfc5322).\n * P. Resnick.\n * IETF.\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/);\n\n/**\n * Check whether a character code is an ASCII control character.\n *\n * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)\n * to U+001F (US), or U+007F (DEL).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function asciiControl(code) {\n  return (\n    // Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code !== null && (code < 32 || code === 127)\n  );\n}\n\n/**\n * Check whether the character code represents an ASCII digit (`0` through `9`).\n *\n * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to\n * U+0039 (`9`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiDigit = regexCheck(/\\d/);\n\n/**\n * Check whether the character code represents an ASCII hex digit (`a` through\n * `f`, case insensitive, or `0` through `9`).\n *\n * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex\n * digit, or an ASCII lower hex digit.\n *\n * An **ASCII upper hex digit** is a character in the inclusive range U+0041\n * (`A`) to U+0046 (`F`).\n *\n * An **ASCII lower hex digit** is a character in the inclusive range U+0061\n * (`a`) to U+0066 (`f`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiHexDigit = regexCheck(/[\\dA-Fa-f]/);\n\n/**\n * Check whether the character code represents ASCII punctuation.\n *\n * An **ASCII punctuation** is a character in the inclusive ranges U+0021\n * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT\n * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT\n * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);\n\n/**\n * Check whether a character code is a markdown line ending.\n *\n * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN\n * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).\n *\n * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE\n * RETURN (CR) are replaced by these virtual characters depending on whether\n * they occurred together.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEnding(code) {\n  return code !== null && code < -2;\n}\n\n/**\n * Check whether a character code is a markdown line ending (see\n * `markdownLineEnding`) or markdown space (see `markdownSpace`).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEndingOrSpace(code) {\n  return code !== null && (code < 0 || code === 32);\n}\n\n/**\n * Check whether a character code is a markdown space.\n *\n * A **markdown space** is the concrete character U+0020 SPACE (SP) and the\n * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).\n *\n * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is\n * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL\n * SPACE (VS) characters, depending on the column at which the tab occurred.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32;\n}\n\n// Size note: removing ASCII from the regex and using `asciiPunctuation` here\n// In fact adds to the bundle size.\n/**\n * Check whether the character code represents Unicode punctuation.\n *\n * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,\n * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`\n * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`\n * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII\n * punctuation (see `asciiPunctuation`).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodePunctuation = regexCheck(/\\p{P}|\\p{S}/u);\n\n/**\n * Check whether the character code represents Unicode whitespace.\n *\n * Note that this does handle micromark specific markdown whitespace characters.\n * See `markdownLineEndingOrSpace` to check that.\n *\n * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,\n * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),\n * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\\[UNICODE]**).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodeWhitespace = regexCheck(/\\s/);\n\n/**\n * Create a code check from a regex.\n *\n * @param {RegExp} regex\n *   Expression.\n * @returns {(code: Code) => boolean}\n *   Check.\n */\nfunction regexCheck(regex) {\n  return check;\n\n  /**\n   * Check whether a code matches the bound regex.\n   *\n   * @param {Code} code\n   *   Character code.\n   * @returns {boolean}\n   *   Whether the character code matches the bound regex.\n   */\n  function check(code) {\n    return code !== null && code > -1 && regex.test(String.fromCharCode(code));\n  }\n}","/**\n * @import {Effects, State, TokenType} from 'micromark-util-types'\n */\n\nimport { markdownSpace } from 'micromark-util-character';\n\n// To do: implement `spaceOrTab`, `spaceOrTabMinMax`, `spaceOrTabWithOptions`.\n\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   spaces in markdown are often optional, in which case this factory can be\n *     used and `ok` will be switched to whether spaces were found or not\n * *   one line ending or space can be detected with `markdownSpace(code)` right\n *     before using `factorySpace`\n *\n * ###### Examples\n *\n * Where `␉` represents a tab (plus how much it expands) and `␠` represents a\n * single space.\n *\n * ```markdown\n * ␉\n * ␠␠␠␠\n * ␉␠\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {TokenType} type\n *   Type (`' \\t'`).\n * @param {number | undefined} [max=Infinity]\n *   Max (exclusive).\n * @returns {State}\n *   Start state.\n */\nexport function factorySpace(effects, ok, type, max) {\n  const limit = max ? max - 1 : Number.POSITIVE_INFINITY;\n  let size = 0;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type);\n      return prefix(code);\n    }\n    return ok(code);\n  }\n\n  /** @type {State} */\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code);\n      return prefix;\n    }\n    effects.exit(type);\n    return ok(code);\n  }\n}","/**\n * @import {\n *   InitialConstruct,\n *   Initializer,\n *   State,\n *   TokenizeContext,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {InitialConstruct} */\nexport const content = {\n  tokenize: initializeContent\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Initializer}\n *   Content.\n */\nfunction initializeContent(effects) {\n  const contentStart = effects.attempt(this.parser.constructs.contentInitial, afterContentStartConstruct, paragraphInitial);\n  /** @type {Token} */\n  let previous;\n  return contentStart;\n\n  /** @type {State} */\n  function afterContentStartConstruct(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return factorySpace(effects, contentStart, \"linePrefix\");\n  }\n\n  /** @type {State} */\n  function paragraphInitial(code) {\n    effects.enter(\"paragraph\");\n    return lineStart(code);\n  }\n\n  /** @type {State} */\n  function lineStart(code) {\n    const token = effects.enter(\"chunkText\", {\n      contentType: \"text\",\n      previous\n    });\n    if (previous) {\n      previous.next = token;\n    }\n    previous = token;\n    return data(code);\n  }\n\n  /** @type {State} */\n  function data(code) {\n    if (code === null) {\n      effects.exit(\"chunkText\");\n      effects.exit(\"paragraph\");\n      effects.consume(code);\n      return;\n    }\n    if (markdownLineEnding(code)) {\n      effects.consume(code);\n      effects.exit(\"chunkText\");\n      return lineStart;\n    }\n\n    // Data.\n    effects.consume(code);\n    return data;\n  }\n}","/**\n * @import {\n *   Construct,\n *   ContainerState,\n *   InitialConstruct,\n *   Initializer,\n *   Point,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\n/**\n * @typedef {[Construct, ContainerState]} StackItem\n *   Construct and its state.\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\nimport { splice } from 'micromark-util-chunked';\n/** @type {InitialConstruct} */\nexport const document = {\n  tokenize: initializeDocument\n};\n\n/** @type {Construct} */\nconst containerConstruct = {\n  tokenize: tokenizeContainer\n};\n\n/**\n * @this {TokenizeContext}\n *   Self.\n * @type {Initializer}\n *   Initializer.\n */\nfunction initializeDocument(effects) {\n  const self = this;\n  /** @type {Array<StackItem>} */\n  const stack = [];\n  let continued = 0;\n  /** @type {TokenizeContext | undefined} */\n  let childFlow;\n  /** @type {Token | undefined} */\n  let childToken;\n  /** @type {number} */\n  let lineStartOffset;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    // First we iterate through the open blocks, starting with the root\n    // document, and descending through last children down to the last open\n    // block.\n    // Each block imposes a condition that the line must satisfy if the block is\n    // to remain open.\n    // For example, a block quote requires a `>` character.\n    // A paragraph requires a non-blank line.\n    // In this phase we may match all or just some of the open blocks.\n    // But we cannot close unmatched blocks yet, because we may have a lazy\n    // continuation line.\n    if (continued < stack.length) {\n      const item = stack[continued];\n      self.containerState = item[1];\n      return effects.attempt(item[0].continuation, documentContinue, checkNewContainers)(code);\n    }\n\n    // Done.\n    return checkNewContainers(code);\n  }\n\n  /** @type {State} */\n  function documentContinue(code) {\n    continued++;\n\n    // Note: this field is called `_closeFlow` but it also closes containers.\n    // Perhaps a good idea to rename it but it’s already used in the wild by\n    // extensions.\n    if (self.containerState._closeFlow) {\n      self.containerState._closeFlow = undefined;\n      if (childFlow) {\n        closeFlow();\n      }\n\n      // Note: this algorithm for moving events around is similar to the\n      // algorithm when dealing with lazy lines in `writeToChild`.\n      const indexBeforeExits = self.events.length;\n      let indexBeforeFlow = indexBeforeExits;\n      /** @type {Point | undefined} */\n      let point;\n\n      // Find the flow chunk.\n      while (indexBeforeFlow--) {\n        if (self.events[indexBeforeFlow][0] === 'exit' && self.events[indexBeforeFlow][1].type === \"chunkFlow\") {\n          point = self.events[indexBeforeFlow][1].end;\n          break;\n        }\n      }\n      exitContainers(continued);\n\n      // Fix positions.\n      let index = indexBeforeExits;\n      while (index < self.events.length) {\n        self.events[index][1].end = {\n          ...point\n        };\n        index++;\n      }\n\n      // Inject the exits earlier (they’re still also at the end).\n      splice(self.events, indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits));\n\n      // Discard the duplicate exits.\n      self.events.length = index;\n      return checkNewContainers(code);\n    }\n    return start(code);\n  }\n\n  /** @type {State} */\n  function checkNewContainers(code) {\n    // Next, after consuming the continuation markers for existing blocks, we\n    // look for new block starts (e.g. `>` for a block quote).\n    // If we encounter a new block start, we close any blocks unmatched in\n    // step 1 before creating the new block as a child of the last matched\n    // block.\n    if (continued === stack.length) {\n      // No need to `check` whether there’s a container, of `exitContainers`\n      // would be moot.\n      // We can instead immediately `attempt` to parse one.\n      if (!childFlow) {\n        return documentContinued(code);\n      }\n\n      // If we have concrete content, such as block HTML or fenced code,\n      // we can’t have containers “pierce” into them, so we can immediately\n      // start.\n      if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {\n        return flowStart(code);\n      }\n\n      // If we do have flow, it could still be a blank line,\n      // but we’d be interrupting it w/ a new container if there’s a current\n      // construct.\n      // To do: next major: remove `_gfmTableDynamicInterruptHack` (no longer\n      // needed in micromark-extension-gfm-table@1.0.6).\n      self.interrupt = Boolean(childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack);\n    }\n\n    // Check if there is a new container.\n    self.containerState = {};\n    return effects.check(containerConstruct, thereIsANewContainer, thereIsNoNewContainer)(code);\n  }\n\n  /** @type {State} */\n  function thereIsANewContainer(code) {\n    if (childFlow) closeFlow();\n    exitContainers(continued);\n    return documentContinued(code);\n  }\n\n  /** @type {State} */\n  function thereIsNoNewContainer(code) {\n    self.parser.lazy[self.now().line] = continued !== stack.length;\n    lineStartOffset = self.now().offset;\n    return flowStart(code);\n  }\n\n  /** @type {State} */\n  function documentContinued(code) {\n    // Try new containers.\n    self.containerState = {};\n    return effects.attempt(containerConstruct, containerContinue, flowStart)(code);\n  }\n\n  /** @type {State} */\n  function containerContinue(code) {\n    continued++;\n    stack.push([self.currentConstruct, self.containerState]);\n    // Try another.\n    return documentContinued(code);\n  }\n\n  /** @type {State} */\n  function flowStart(code) {\n    if (code === null) {\n      if (childFlow) closeFlow();\n      exitContainers(0);\n      effects.consume(code);\n      return;\n    }\n    childFlow = childFlow || self.parser.flow(self.now());\n    effects.enter(\"chunkFlow\", {\n      _tokenizer: childFlow,\n      contentType: \"flow\",\n      previous: childToken\n    });\n    return flowContinue(code);\n  }\n\n  /** @type {State} */\n  function flowContinue(code) {\n    if (code === null) {\n      writeToChild(effects.exit(\"chunkFlow\"), true);\n      exitContainers(0);\n      effects.consume(code);\n      return;\n    }\n    if (markdownLineEnding(code)) {\n      effects.consume(code);\n      writeToChild(effects.exit(\"chunkFlow\"));\n      // Get ready for the next line.\n      continued = 0;\n      self.interrupt = undefined;\n      return start;\n    }\n    effects.consume(code);\n    return flowContinue;\n  }\n\n  /**\n   * @param {Token} token\n   *   Token.\n   * @param {boolean | undefined} [endOfFile]\n   *   Whether the token is at the end of the file (default: `false`).\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function writeToChild(token, endOfFile) {\n    const stream = self.sliceStream(token);\n    if (endOfFile) stream.push(null);\n    token.previous = childToken;\n    if (childToken) childToken.next = token;\n    childToken = token;\n    childFlow.defineSkip(token.start);\n    childFlow.write(stream);\n\n    // Alright, so we just added a lazy line:\n    //\n    // ```markdown\n    // > a\n    // b.\n    //\n    // Or:\n    //\n    // > ~~~c\n    // d\n    //\n    // Or:\n    //\n    // > | e |\n    // f\n    // ```\n    //\n    // The construct in the second example (fenced code) does not accept lazy\n    // lines, so it marked itself as done at the end of its first line, and\n    // then the content construct parses `d`.\n    // Most constructs in markdown match on the first line: if the first line\n    // forms a construct, a non-lazy line can’t “unmake” it.\n    //\n    // The construct in the third example is potentially a GFM table, and\n    // those are *weird*.\n    // It *could* be a table, from the first line, if the following line\n    // matches a condition.\n    // In this case, that second line is lazy, which “unmakes” the first line\n    // and turns the whole into one content block.\n    //\n    // We’ve now parsed the non-lazy and the lazy line, and can figure out\n    // whether the lazy line started a new flow block.\n    // If it did, we exit the current containers between the two flow blocks.\n    if (self.parser.lazy[token.start.line]) {\n      let index = childFlow.events.length;\n      while (index--) {\n        if (\n        // The token starts before the line ending…\n        childFlow.events[index][1].start.offset < lineStartOffset && (\n        // …and either is not ended yet…\n        !childFlow.events[index][1].end ||\n        // …or ends after it.\n        childFlow.events[index][1].end.offset > lineStartOffset)) {\n          // Exit: there’s still something open, which means it’s a lazy line\n          // part of something.\n          return;\n        }\n      }\n\n      // Note: this algorithm for moving events around is similar to the\n      // algorithm when closing flow in `documentContinue`.\n      const indexBeforeExits = self.events.length;\n      let indexBeforeFlow = indexBeforeExits;\n      /** @type {boolean | undefined} */\n      let seen;\n      /** @type {Point | undefined} */\n      let point;\n\n      // Find the previous chunk (the one before the lazy line).\n      while (indexBeforeFlow--) {\n        if (self.events[indexBeforeFlow][0] === 'exit' && self.events[indexBeforeFlow][1].type === \"chunkFlow\") {\n          if (seen) {\n            point = self.events[indexBeforeFlow][1].end;\n            break;\n          }\n          seen = true;\n        }\n      }\n      exitContainers(continued);\n\n      // Fix positions.\n      index = indexBeforeExits;\n      while (index < self.events.length) {\n        self.events[index][1].end = {\n          ...point\n        };\n        index++;\n      }\n\n      // Inject the exits earlier (they’re still also at the end).\n      splice(self.events, indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits));\n\n      // Discard the duplicate exits.\n      self.events.length = index;\n    }\n  }\n\n  /**\n   * @param {number} size\n   *   Size.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function exitContainers(size) {\n    let index = stack.length;\n\n    // Exit open containers.\n    while (index-- > size) {\n      const entry = stack[index];\n      self.containerState = entry[1];\n      entry[0].exit.call(self, effects);\n    }\n    stack.length = size;\n  }\n  function closeFlow() {\n    childFlow.write([null]);\n    childToken = undefined;\n    childFlow = undefined;\n    self.containerState._closeFlow = undefined;\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n *   Tokenizer.\n */\nfunction tokenizeContainer(effects, ok, nok) {\n  // Always populated by defaults.\n\n  return factorySpace(effects, effects.attempt(this.parser.constructs.document, ok, nok), \"linePrefix\", this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4);\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const blankLine = {\n  partial: true,\n  tokenize: tokenizeBlankLine\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlankLine(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of blank line.\n   *\n   * > 👉 **Note**: `␠` represents a space character.\n   *\n   * ```markdown\n   * > | ␠␠␊\n   *     ^\n   * > | ␊\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    return markdownSpace(code) ? factorySpace(effects, after, \"linePrefix\")(code) : after(code);\n  }\n\n  /**\n   * At eof/eol, after optional whitespace.\n   *\n   * > 👉 **Note**: `␠` represents a space character.\n   *\n   * ```markdown\n   * > | ␠␠␊\n   *       ^\n   * > | ␊\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\nimport { subtokenize } from 'micromark-util-subtokenize';\n/**\n * No name because it must not be turned off.\n * @type {Construct}\n */\nexport const content = {\n  resolve: resolveContent,\n  tokenize: tokenizeContent\n};\n\n/** @type {Construct} */\nconst continuationConstruct = {\n  partial: true,\n  tokenize: tokenizeContinuation\n};\n\n/**\n * Content is transparent: it’s parsed right now. That way, definitions are also\n * parsed right now: before text in paragraphs (specifically, media) are parsed.\n *\n * @type {Resolver}\n */\nfunction resolveContent(events) {\n  subtokenize(events);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeContent(effects, ok) {\n  /** @type {Token | undefined} */\n  let previous;\n  return chunkStart;\n\n  /**\n   * Before a content chunk.\n   *\n   * ```markdown\n   * > | abc\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function chunkStart(code) {\n    effects.enter(\"content\");\n    previous = effects.enter(\"chunkContent\", {\n      contentType: \"content\"\n    });\n    return chunkInside(code);\n  }\n\n  /**\n   * In a content chunk.\n   *\n   * ```markdown\n   * > | abc\n   *     ^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function chunkInside(code) {\n    if (code === null) {\n      return contentEnd(code);\n    }\n\n    // To do: in `markdown-rs`, each line is parsed on its own, and everything\n    // is stitched together resolving.\n    if (markdownLineEnding(code)) {\n      return effects.check(continuationConstruct, contentContinue, contentEnd)(code);\n    }\n\n    // Data.\n    effects.consume(code);\n    return chunkInside;\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function contentEnd(code) {\n    effects.exit(\"chunkContent\");\n    effects.exit(\"content\");\n    return ok(code);\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function contentContinue(code) {\n    effects.consume(code);\n    effects.exit(\"chunkContent\");\n    previous.next = effects.enter(\"chunkContent\", {\n      contentType: \"content\",\n      previous\n    });\n    previous = previous.next;\n    return chunkInside;\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeContinuation(effects, ok, nok) {\n  const self = this;\n  return startLookahead;\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function startLookahead(code) {\n    effects.exit(\"chunkContent\");\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return factorySpace(effects, prefixed, \"linePrefix\");\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function prefixed(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    // Always populated by defaults.\n\n    const tail = self.events[self.events.length - 1];\n    if (!self.parser.constructs.disable.null.includes('codeIndented') && tail && tail[1].type === \"linePrefix\" && tail[2].sliceSerialize(tail[1], true).length >= 4) {\n      return ok(code);\n    }\n    return effects.interrupt(self.parser.constructs.flow, nok, ok)(code);\n  }\n}","/**\n * @import {\n *   InitialConstruct,\n *   Initializer,\n *   State,\n *   TokenizeContext\n * } from 'micromark-util-types'\n */\n\nimport { blankLine, content } from 'micromark-core-commonmark';\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {InitialConstruct} */\nexport const flow = {\n  tokenize: initializeFlow\n};\n\n/**\n * @this {TokenizeContext}\n *   Self.\n * @type {Initializer}\n *   Initializer.\n */\nfunction initializeFlow(effects) {\n  const self = this;\n  const initial = effects.attempt(\n  // Try to parse a blank line.\n  blankLine, atBlankEnding,\n  // Try to parse initial flow (essentially, only code).\n  effects.attempt(this.parser.constructs.flowInitial, afterConstruct, factorySpace(effects, effects.attempt(this.parser.constructs.flow, afterConstruct, effects.attempt(content, afterConstruct)), \"linePrefix\")));\n  return initial;\n\n  /** @type {State} */\n  function atBlankEnding(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n    effects.enter(\"lineEndingBlank\");\n    effects.consume(code);\n    effects.exit(\"lineEndingBlank\");\n    self.currentConstruct = undefined;\n    return initial;\n  }\n\n  /** @type {State} */\n  function afterConstruct(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    self.currentConstruct = undefined;\n    return initial;\n  }\n}","/**\n * @import {\n *   Code,\n *   InitialConstruct,\n *   Initializer,\n *   Resolver,\n *   State,\n *   TokenizeContext\n * } from 'micromark-util-types'\n */\n\nexport const resolver = {\n  resolveAll: createResolver()\n};\nexport const string = initializeFactory('string');\nexport const text = initializeFactory('text');\n\n/**\n * @param {'string' | 'text'} field\n *   Field.\n * @returns {InitialConstruct}\n *   Construct.\n */\nfunction initializeFactory(field) {\n  return {\n    resolveAll: createResolver(field === 'text' ? resolveAllLineSuffixes : undefined),\n    tokenize: initializeText\n  };\n\n  /**\n   * @this {TokenizeContext}\n   *   Context.\n   * @type {Initializer}\n   */\n  function initializeText(effects) {\n    const self = this;\n    const constructs = this.parser.constructs[field];\n    const text = effects.attempt(constructs, start, notText);\n    return start;\n\n    /** @type {State} */\n    function start(code) {\n      return atBreak(code) ? text(code) : notText(code);\n    }\n\n    /** @type {State} */\n    function notText(code) {\n      if (code === null) {\n        effects.consume(code);\n        return;\n      }\n      effects.enter(\"data\");\n      effects.consume(code);\n      return data;\n    }\n\n    /** @type {State} */\n    function data(code) {\n      if (atBreak(code)) {\n        effects.exit(\"data\");\n        return text(code);\n      }\n\n      // Data.\n      effects.consume(code);\n      return data;\n    }\n\n    /**\n     * @param {Code} code\n     *   Code.\n     * @returns {boolean}\n     *   Whether the code is a break.\n     */\n    function atBreak(code) {\n      if (code === null) {\n        return true;\n      }\n      const list = constructs[code];\n      let index = -1;\n      if (list) {\n        // Always populated by defaults.\n\n        while (++index < list.length) {\n          const item = list[index];\n          if (!item.previous || item.previous.call(self, self.previous)) {\n            return true;\n          }\n        }\n      }\n      return false;\n    }\n  }\n}\n\n/**\n * @param {Resolver | undefined} [extraResolver]\n *   Resolver.\n * @returns {Resolver}\n *   Resolver.\n */\nfunction createResolver(extraResolver) {\n  return resolveAllText;\n\n  /** @type {Resolver} */\n  function resolveAllText(events, context) {\n    let index = -1;\n    /** @type {number | undefined} */\n    let enter;\n\n    // A rather boring computation (to merge adjacent `data` events) which\n    // improves mm performance by 29%.\n    while (++index <= events.length) {\n      if (enter === undefined) {\n        if (events[index] && events[index][1].type === \"data\") {\n          enter = index;\n          index++;\n        }\n      } else if (!events[index] || events[index][1].type !== \"data\") {\n        // Don’t do anything if there is one data token.\n        if (index !== enter + 2) {\n          events[enter][1].end = events[index - 1][1].end;\n          events.splice(enter + 2, index - enter - 2);\n          index = enter + 2;\n        }\n        enter = undefined;\n      }\n    }\n    return extraResolver ? extraResolver(events, context) : events;\n  }\n}\n\n/**\n * A rather ugly set of instructions which again looks at chunks in the input\n * stream.\n * The reason to do this here is that it is *much* faster to parse in reverse.\n * And that we can’t hook into `null` to split the line suffix before an EOF.\n * To do: figure out if we can make this into a clean utility, or even in core.\n * As it will be useful for GFMs literal autolink extension (and maybe even\n * tables?)\n *\n * @type {Resolver}\n */\nfunction resolveAllLineSuffixes(events, context) {\n  let eventIndex = 0; // Skip first.\n\n  while (++eventIndex <= events.length) {\n    if ((eventIndex === events.length || events[eventIndex][1].type === \"lineEnding\") && events[eventIndex - 1][1].type === \"data\") {\n      const data = events[eventIndex - 1][1];\n      const chunks = context.sliceStream(data);\n      let index = chunks.length;\n      let bufferIndex = -1;\n      let size = 0;\n      /** @type {boolean | undefined} */\n      let tabs;\n      while (index--) {\n        const chunk = chunks[index];\n        if (typeof chunk === 'string') {\n          bufferIndex = chunk.length;\n          while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n            size++;\n            bufferIndex--;\n          }\n          if (bufferIndex) break;\n          bufferIndex = -1;\n        }\n        // Number\n        else if (chunk === -2) {\n          tabs = true;\n          size++;\n        } else if (chunk === -1) {\n          // Empty\n        } else {\n          // Replacement character, exit.\n          index++;\n          break;\n        }\n      }\n      if (size) {\n        const token = {\n          type: eventIndex === events.length || tabs || size < 2 ? \"lineSuffix\" : \"hardBreakTrailing\",\n          start: {\n            _bufferIndex: index ? bufferIndex : data.start._bufferIndex + bufferIndex,\n            _index: data.start._index + index,\n            line: data.end.line,\n            column: data.end.column - size,\n            offset: data.end.offset - size\n          },\n          end: {\n            ...data.end\n          }\n        };\n        data.end = {\n          ...token.start\n        };\n        if (data.start.offset === data.end.offset) {\n          Object.assign(data, token);\n        } else {\n          events.splice(eventIndex, 0, ['enter', token, context], ['exit', token, context]);\n          eventIndex += 2;\n        }\n      }\n      eventIndex++;\n    }\n  }\n  return events;\n}","/**\n * @import {\n *   Code,\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const thematicBreak = {\n  name: 'thematicBreak',\n  tokenize: tokenizeThematicBreak\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeThematicBreak(effects, ok, nok) {\n  let size = 0;\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Start of thematic break.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"thematicBreak\");\n    // To do: parse indent like `markdown-rs`.\n    return before(code);\n  }\n\n  /**\n   * After optional whitespace, at marker.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    marker = code;\n    return atBreak(code);\n  }\n\n  /**\n   * After something, before something else.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === marker) {\n      effects.enter(\"thematicBreakSequence\");\n      return sequence(code);\n    }\n    if (size >= 3 && (code === null || markdownLineEnding(code))) {\n      effects.exit(\"thematicBreak\");\n      return ok(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In sequence.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code);\n      size++;\n      return sequence;\n    }\n    effects.exit(\"thematicBreakSequence\");\n    return markdownSpace(code) ? factorySpace(effects, atBreak, \"whitespace\")(code) : atBreak(code);\n  }\n}","/**\n * @import {\n *   Code,\n *   Construct,\n *   Exiter,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { asciiDigit, markdownSpace } from 'micromark-util-character';\nimport { blankLine } from './blank-line.js';\nimport { thematicBreak } from './thematic-break.js';\n\n/** @type {Construct} */\nexport const list = {\n  continuation: {\n    tokenize: tokenizeListContinuation\n  },\n  exit: tokenizeListEnd,\n  name: 'list',\n  tokenize: tokenizeListStart\n};\n\n/** @type {Construct} */\nconst listItemPrefixWhitespaceConstruct = {\n  partial: true,\n  tokenize: tokenizeListItemPrefixWhitespace\n};\n\n/** @type {Construct} */\nconst indentConstruct = {\n  partial: true,\n  tokenize: tokenizeIndent\n};\n\n// To do: `markdown-rs` parses list items on their own and later stitches them\n// together.\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeListStart(effects, ok, nok) {\n  const self = this;\n  const tail = self.events[self.events.length - 1];\n  let initialSize = tail && tail[1].type === \"linePrefix\" ? tail[2].sliceSerialize(tail[1], true).length : 0;\n  let size = 0;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    const kind = self.containerState.type || (code === 42 || code === 43 || code === 45 ? \"listUnordered\" : \"listOrdered\");\n    if (kind === \"listUnordered\" ? !self.containerState.marker || code === self.containerState.marker : asciiDigit(code)) {\n      if (!self.containerState.type) {\n        self.containerState.type = kind;\n        effects.enter(kind, {\n          _container: true\n        });\n      }\n      if (kind === \"listUnordered\") {\n        effects.enter(\"listItemPrefix\");\n        return code === 42 || code === 45 ? effects.check(thematicBreak, nok, atMarker)(code) : atMarker(code);\n      }\n      if (!self.interrupt || code === 49) {\n        effects.enter(\"listItemPrefix\");\n        effects.enter(\"listItemValue\");\n        return inside(code);\n      }\n    }\n    return nok(code);\n  }\n\n  /** @type {State} */\n  function inside(code) {\n    if (asciiDigit(code) && ++size < 10) {\n      effects.consume(code);\n      return inside;\n    }\n    if ((!self.interrupt || size < 2) && (self.containerState.marker ? code === self.containerState.marker : code === 41 || code === 46)) {\n      effects.exit(\"listItemValue\");\n      return atMarker(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * @type {State}\n   **/\n  function atMarker(code) {\n    effects.enter(\"listItemMarker\");\n    effects.consume(code);\n    effects.exit(\"listItemMarker\");\n    self.containerState.marker = self.containerState.marker || code;\n    return effects.check(blankLine,\n    // Can’t be empty when interrupting.\n    self.interrupt ? nok : onBlank, effects.attempt(listItemPrefixWhitespaceConstruct, endOfPrefix, otherPrefix));\n  }\n\n  /** @type {State} */\n  function onBlank(code) {\n    self.containerState.initialBlankLine = true;\n    initialSize++;\n    return endOfPrefix(code);\n  }\n\n  /** @type {State} */\n  function otherPrefix(code) {\n    if (markdownSpace(code)) {\n      effects.enter(\"listItemPrefixWhitespace\");\n      effects.consume(code);\n      effects.exit(\"listItemPrefixWhitespace\");\n      return endOfPrefix;\n    }\n    return nok(code);\n  }\n\n  /** @type {State} */\n  function endOfPrefix(code) {\n    self.containerState.size = initialSize + self.sliceSerialize(effects.exit(\"listItemPrefix\"), true).length;\n    return ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeListContinuation(effects, ok, nok) {\n  const self = this;\n  self.containerState._closeFlow = undefined;\n  return effects.check(blankLine, onBlank, notBlank);\n\n  /** @type {State} */\n  function onBlank(code) {\n    self.containerState.furtherBlankLines = self.containerState.furtherBlankLines || self.containerState.initialBlankLine;\n\n    // We have a blank line.\n    // Still, try to consume at most the items size.\n    return factorySpace(effects, ok, \"listItemIndent\", self.containerState.size + 1)(code);\n  }\n\n  /** @type {State} */\n  function notBlank(code) {\n    if (self.containerState.furtherBlankLines || !markdownSpace(code)) {\n      self.containerState.furtherBlankLines = undefined;\n      self.containerState.initialBlankLine = undefined;\n      return notInCurrentItem(code);\n    }\n    self.containerState.furtherBlankLines = undefined;\n    self.containerState.initialBlankLine = undefined;\n    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code);\n  }\n\n  /** @type {State} */\n  function notInCurrentItem(code) {\n    // While we do continue, we signal that the flow should be closed.\n    self.containerState._closeFlow = true;\n    // As we’re closing flow, we’re no longer interrupting.\n    self.interrupt = undefined;\n    // Always populated by defaults.\n\n    return factorySpace(effects, effects.attempt(list, ok, nok), \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeIndent(effects, ok, nok) {\n  const self = this;\n  return factorySpace(effects, afterPrefix, \"listItemIndent\", self.containerState.size + 1);\n\n  /** @type {State} */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === \"listItemIndent\" && tail[2].sliceSerialize(tail[1], true).length === self.containerState.size ? ok(code) : nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Exiter}\n */\nfunction tokenizeListEnd(effects) {\n  effects.exit(this.containerState.type);\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeListItemPrefixWhitespace(effects, ok, nok) {\n  const self = this;\n\n  // Always populated by defaults.\n\n  return factorySpace(effects, afterPrefix, \"listItemPrefixWhitespace\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4 + 1);\n\n  /** @type {State} */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return !markdownSpace(code) && tail && tail[1].type === \"listItemPrefixWhitespace\" ? ok(code) : nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   Exiter,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const blockQuote = {\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit,\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlockQuoteStart(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of block quote.\n   *\n   * ```markdown\n   * > | > a\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 62) {\n      const state = self.containerState;\n      if (!state.open) {\n        effects.enter(\"blockQuote\", {\n          _container: true\n        });\n        state.open = true;\n      }\n      effects.enter(\"blockQuotePrefix\");\n      effects.enter(\"blockQuoteMarker\");\n      effects.consume(code);\n      effects.exit(\"blockQuoteMarker\");\n      return after;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `>`, before optional whitespace.\n   *\n   * ```markdown\n   * > | > a\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    if (markdownSpace(code)) {\n      effects.enter(\"blockQuotePrefixWhitespace\");\n      effects.consume(code);\n      effects.exit(\"blockQuotePrefixWhitespace\");\n      effects.exit(\"blockQuotePrefix\");\n      return ok;\n    }\n    effects.exit(\"blockQuotePrefix\");\n    return ok(code);\n  }\n}\n\n/**\n * Start of block quote continuation.\n *\n * ```markdown\n *   | > a\n * > | > b\n *     ^\n * ```\n *\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlockQuoteContinuation(effects, ok, nok) {\n  const self = this;\n  return contStart;\n\n  /**\n   * Start of block quote continuation.\n   *\n   * Also used to parse the first block quote opening.\n   *\n   * ```markdown\n   *   | > a\n   * > | > b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function contStart(code) {\n    if (markdownSpace(code)) {\n      // Always populated by defaults.\n\n      return factorySpace(effects, contBefore, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code);\n    }\n    return contBefore(code);\n  }\n\n  /**\n   * At `>`, after optional whitespace.\n   *\n   * Also used to parse the first block quote opening.\n   *\n   * ```markdown\n   *   | > a\n   * > | > b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function contBefore(code) {\n    return effects.attempt(blockQuote, ok, nok)(code);\n  }\n}\n\n/** @type {Exiter} */\nfunction exit(effects) {\n  effects.exit(\"blockQuote\");\n}","/**\n * @import {Effects, State, TokenType} from 'micromark-util-types'\n */\n\nimport { asciiControl, markdownLineEndingOrSpace, markdownLineEnding } from 'micromark-util-character';\n/**\n * Parse destinations.\n *\n * ###### Examples\n *\n * ```markdown\n * <a>\n * <a\\>b>\n * <a b>\n * <a)>\n * a\n * a\\)b\n * a(b)c\n * a(b)\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type for whole (`<a>` or `b`).\n * @param {TokenType} literalType\n *   Type when enclosed (`<a>`).\n * @param {TokenType} literalMarkerType\n *   Type for enclosing (`<` and `>`).\n * @param {TokenType} rawType\n *   Type when not enclosed (`b`).\n * @param {TokenType} stringType\n *   Type for the value (`a` or `b`).\n * @param {number | undefined} [max=Infinity]\n *   Depth of nested parens (inclusive).\n * @returns {State}\n *   Start state.\n */\nexport function factoryDestination(effects, ok, nok, type, literalType, literalMarkerType, rawType, stringType, max) {\n  const limit = max || Number.POSITIVE_INFINITY;\n  let balance = 0;\n  return start;\n\n  /**\n   * Start of destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *     ^\n   * > | aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 60) {\n      effects.enter(type);\n      effects.enter(literalType);\n      effects.enter(literalMarkerType);\n      effects.consume(code);\n      effects.exit(literalMarkerType);\n      return enclosedBefore;\n    }\n\n    // ASCII control, space, closing paren.\n    if (code === null || code === 32 || code === 41 || asciiControl(code)) {\n      return nok(code);\n    }\n    effects.enter(type);\n    effects.enter(rawType);\n    effects.enter(stringType);\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return raw(code);\n  }\n\n  /**\n   * After `<`, at an enclosed destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosedBefore(code) {\n    if (code === 62) {\n      effects.enter(literalMarkerType);\n      effects.consume(code);\n      effects.exit(literalMarkerType);\n      effects.exit(literalType);\n      effects.exit(type);\n      return ok;\n    }\n    effects.enter(stringType);\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return enclosed(code);\n  }\n\n  /**\n   * In enclosed destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosed(code) {\n    if (code === 62) {\n      effects.exit(\"chunkString\");\n      effects.exit(stringType);\n      return enclosedBefore(code);\n    }\n    if (code === null || code === 60 || markdownLineEnding(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return code === 92 ? enclosedEscape : enclosed;\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | <a\\*a>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosedEscape(code) {\n    if (code === 60 || code === 62 || code === 92) {\n      effects.consume(code);\n      return enclosed;\n    }\n    return enclosed(code);\n  }\n\n  /**\n   * In raw destination.\n   *\n   * ```markdown\n   * > | aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function raw(code) {\n    if (!balance && (code === null || code === 41 || markdownLineEndingOrSpace(code))) {\n      effects.exit(\"chunkString\");\n      effects.exit(stringType);\n      effects.exit(rawType);\n      effects.exit(type);\n      return ok(code);\n    }\n    if (balance < limit && code === 40) {\n      effects.consume(code);\n      balance++;\n      return raw;\n    }\n    if (code === 41) {\n      effects.consume(code);\n      balance--;\n      return raw;\n    }\n\n    // ASCII control (but *not* `\\0`) and space and `(`.\n    // Note: in `markdown-rs`, `\\0` exists in codes, in `micromark-js` it\n    // doesn’t.\n    if (code === null || code === 32 || code === 40 || asciiControl(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return code === 92 ? rawEscape : raw;\n  }\n\n  /**\n   * After `\\`, at special character.\n   *\n   * ```markdown\n   * > | a\\*a\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function rawEscape(code) {\n    if (code === 40 || code === 41 || code === 92) {\n      effects.consume(code);\n      return raw;\n    }\n    return raw(code);\n  }\n}","/**\n * @import {\n *   Effects,\n *   State,\n *   TokenizeContext,\n *   TokenType\n * } from 'micromark-util-types'\n */\n\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/**\n * Parse labels.\n *\n * > 👉 **Note**: labels in markdown are capped at 999 characters in the string.\n *\n * ###### Examples\n *\n * ```markdown\n * [a]\n * [a\n * b]\n * [a\\]b]\n * ```\n *\n * @this {TokenizeContext}\n *   Tokenize context.\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type of the whole label (`[a]`).\n * @param {TokenType} markerType\n *   Type for the markers (`[` and `]`).\n * @param {TokenType} stringType\n *   Type for the identifier (`a`).\n * @returns {State}\n *   Start state.\n */\nexport function factoryLabel(effects, ok, nok, type, markerType, stringType) {\n  const self = this;\n  let size = 0;\n  /** @type {boolean} */\n  let seen;\n  return start;\n\n  /**\n   * Start of label.\n   *\n   * ```markdown\n   * > | [a]\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(type);\n    effects.enter(markerType);\n    effects.consume(code);\n    effects.exit(markerType);\n    effects.enter(stringType);\n    return atBreak;\n  }\n\n  /**\n   * In label, at something, before something else.\n   *\n   * ```markdown\n   * > | [a]\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (size > 999 || code === null || code === 91 || code === 93 && !seen ||\n    // To do: remove in the future once we’ve switched from\n    // `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,\n    // which doesn’t need this.\n    // Hidden footnotes hook.\n    /* c8 ignore next 3 */\n    code === 94 && !size && '_hiddenFootnoteSupport' in self.parser.constructs) {\n      return nok(code);\n    }\n    if (code === 93) {\n      effects.exit(stringType);\n      effects.enter(markerType);\n      effects.consume(code);\n      effects.exit(markerType);\n      effects.exit(type);\n      return ok;\n    }\n\n    // To do: indent? Link chunks and EOLs together?\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return atBreak;\n    }\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return labelInside(code);\n  }\n\n  /**\n   * In label, in text.\n   *\n   * ```markdown\n   * > | [a]\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelInside(code) {\n    if (code === null || code === 91 || code === 93 || markdownLineEnding(code) || size++ > 999) {\n      effects.exit(\"chunkString\");\n      return atBreak(code);\n    }\n    effects.consume(code);\n    if (!seen) seen = !markdownSpace(code);\n    return code === 92 ? labelEscape : labelInside;\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | [a\\*a]\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code);\n      size++;\n      return labelInside;\n    }\n    return labelInside(code);\n  }\n}","/**\n * @import {\n *   Code,\n *   Effects,\n *   State,\n *   TokenType\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/**\n * Parse titles.\n *\n * ###### Examples\n *\n * ```markdown\n * \"a\"\n * 'b'\n * (c)\n * \"a\n * b\"\n * 'a\n *     b'\n * (a\\)b)\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type of the whole title (`\"a\"`, `'b'`, `(c)`).\n * @param {TokenType} markerType\n *   Type for the markers (`\"`, `'`, `(`, and `)`).\n * @param {TokenType} stringType\n *   Type for the value (`a`).\n * @returns {State}\n *   Start state.\n */\nexport function factoryTitle(effects, ok, nok, type, markerType, stringType) {\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Start of title.\n   *\n   * ```markdown\n   * > | \"a\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      effects.enter(type);\n      effects.enter(markerType);\n      effects.consume(code);\n      effects.exit(markerType);\n      marker = code === 40 ? 41 : code;\n      return begin;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After opening marker.\n   *\n   * This is also used at the closing marker.\n   *\n   * ```markdown\n   * > | \"a\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function begin(code) {\n    if (code === marker) {\n      effects.enter(markerType);\n      effects.consume(code);\n      effects.exit(markerType);\n      effects.exit(type);\n      return ok;\n    }\n    effects.enter(stringType);\n    return atBreak(code);\n  }\n\n  /**\n   * At something, before something else.\n   *\n   * ```markdown\n   * > | \"a\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === marker) {\n      effects.exit(stringType);\n      return begin(marker);\n    }\n    if (code === null) {\n      return nok(code);\n    }\n\n    // Note: blank lines can’t exist in content.\n    if (markdownLineEnding(code)) {\n      // To do: use `space_or_tab_eol_with_options`, connect.\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return factorySpace(effects, atBreak, \"linePrefix\");\n    }\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return inside(code);\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker || code === null || markdownLineEnding(code)) {\n      effects.exit(\"chunkString\");\n      return atBreak(code);\n    }\n    effects.consume(code);\n    return code === 92 ? escape : inside;\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | \"a\\*b\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function escape(code) {\n    if (code === marker || code === 92) {\n      effects.consume(code);\n      return inside;\n    }\n    return inside(code);\n  }\n}","/**\n * @import {Effects, State} from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   line endings or spaces in markdown are often optional, in which case this\n *     factory can be used and `ok` will be switched to whether spaces were found\n *     or not\n * *   one line ending or space can be detected with\n *     `markdownLineEndingOrSpace(code)` right before using `factoryWhitespace`\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @returns {State}\n *   Start state.\n */\nexport function factoryWhitespace(effects, ok) {\n  /** @type {boolean} */\n  let seen;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      seen = true;\n      return start;\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(effects, start, seen ? \"linePrefix\" : \"lineSuffix\")(code);\n    }\n    return ok(code);\n  }\n}","/**\n * Normalize an identifier (as found in references, definitions).\n *\n * Collapses markdown whitespace, trim, and then lower- and uppercase.\n *\n * Some characters are considered “uppercase”, such as U+03F4 (`ϴ`), but if their\n * lowercase counterpart (U+03B8 (`θ`)) is uppercased will result in a different\n * uppercase character (U+0398 (`Θ`)).\n * So, to get a canonical form, we perform both lower- and uppercase.\n *\n * Using uppercase last makes sure keys will never interact with default\n * prototypal values (such as `constructor`): nothing in the prototype of\n * `Object` is uppercase.\n *\n * @param {string} value\n *   Identifier to normalize.\n * @returns {string}\n *   Normalized identifier.\n */\nexport function normalizeIdentifier(value) {\n  return value\n  // Collapse markdown whitespace.\n  .replace(/[\\t\\n\\r ]+/g, \" \")\n  // Trim.\n  .replace(/^ | $/g, '')\n  // Some characters are considered “uppercase”, but if their lowercase\n  // counterpart is uppercased will result in a different uppercase\n  // character.\n  // Hence, to get that form, we perform both lower- and uppercase.\n  // Upper case makes sure keys will not interact with default prototypal\n  // methods: no method is uppercase.\n  .toLowerCase().toUpperCase();\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factoryDestination } from 'micromark-factory-destination';\nimport { factoryLabel } from 'micromark-factory-label';\nimport { factorySpace } from 'micromark-factory-space';\nimport { factoryTitle } from 'micromark-factory-title';\nimport { factoryWhitespace } from 'micromark-factory-whitespace';\nimport { markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\n/** @type {Construct} */\nexport const definition = {\n  name: 'definition',\n  tokenize: tokenizeDefinition\n};\n\n/** @type {Construct} */\nconst titleBefore = {\n  partial: true,\n  tokenize: tokenizeTitleBefore\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeDefinition(effects, ok, nok) {\n  const self = this;\n  /** @type {string} */\n  let identifier;\n  return start;\n\n  /**\n   * At start of a definition.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // Do not interrupt paragraphs (but do follow definitions).\n    // To do: do `interrupt` the way `markdown-rs` does.\n    // To do: parse whitespace the way `markdown-rs` does.\n    effects.enter(\"definition\");\n    return before(code);\n  }\n\n  /**\n   * After optional whitespace, at `[`.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    // To do: parse whitespace the way `markdown-rs` does.\n\n    return factoryLabel.call(self, effects, labelAfter,\n    // Note: we don’t need to reset the way `markdown-rs` does.\n    nok, \"definitionLabel\", \"definitionLabelMarker\", \"definitionLabelString\")(code);\n  }\n\n  /**\n   * After label.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelAfter(code) {\n    identifier = normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1));\n    if (code === 58) {\n      effects.enter(\"definitionMarker\");\n      effects.consume(code);\n      effects.exit(\"definitionMarker\");\n      return markerAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After marker.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function markerAfter(code) {\n    // Note: whitespace is optional.\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, destinationBefore)(code) : destinationBefore(code);\n  }\n\n  /**\n   * Before destination.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function destinationBefore(code) {\n    return factoryDestination(effects, destinationAfter,\n    // Note: we don’t need to reset the way `markdown-rs` does.\n    nok, \"definitionDestination\", \"definitionDestinationLiteral\", \"definitionDestinationLiteralMarker\", \"definitionDestinationRaw\", \"definitionDestinationString\")(code);\n  }\n\n  /**\n   * After destination.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function destinationAfter(code) {\n    return effects.attempt(titleBefore, after, after)(code);\n  }\n\n  /**\n   * After definition.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return markdownSpace(code) ? factorySpace(effects, afterWhitespace, \"whitespace\")(code) : afterWhitespace(code);\n  }\n\n  /**\n   * After definition, after optional whitespace.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterWhitespace(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"definition\");\n\n      // Note: we don’t care about uniqueness.\n      // It’s likely that that doesn’t happen very frequently.\n      // It is more likely that it wastes precious time.\n      self.parser.defined.push(identifier);\n\n      // To do: `markdown-rs` interrupt.\n      // // You’d be interrupting.\n      // tokenizer.interrupt = true\n      return ok(code);\n    }\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeTitleBefore(effects, ok, nok) {\n  return titleBefore;\n\n  /**\n   * After destination, at whitespace.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleBefore(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, beforeMarker)(code) : nok(code);\n  }\n\n  /**\n   * At title.\n   *\n   * ```markdown\n   *   | [a]: b\n   * > | \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeMarker(code) {\n    return factoryTitle(effects, titleAfter, nok, \"definitionTitle\", \"definitionTitleMarker\", \"definitionTitleString\")(code);\n  }\n\n  /**\n   * After title.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleAfter(code) {\n    return markdownSpace(code) ? factorySpace(effects, titleAfterOptionalWhitespace, \"whitespace\")(code) : titleAfterOptionalWhitespace(code);\n  }\n\n  /**\n   * After title, after optional whitespace.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleAfterOptionalWhitespace(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const codeIndented = {\n  name: 'codeIndented',\n  tokenize: tokenizeCodeIndented\n};\n\n/** @type {Construct} */\nconst furtherStart = {\n  partial: true,\n  tokenize: tokenizeFurtherStart\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCodeIndented(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of code (indented).\n   *\n   * > **Parsing note**: it is not needed to check if this first line is a\n   * > filled line (that it has a non-whitespace character), because blank lines\n   * > are parsed already, so we never run into that.\n   *\n   * ```markdown\n   * > |     aaa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: manually check if interrupting like `markdown-rs`.\n\n    effects.enter(\"codeIndented\");\n    // To do: use an improved `space_or_tab` function like `markdown-rs`,\n    // so that we can drop the next state.\n    return factorySpace(effects, afterPrefix, \"linePrefix\", 4 + 1)(code);\n  }\n\n  /**\n   * At start, after 1 or 4 spaces.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === \"linePrefix\" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? atBreak(code) : nok(code);\n  }\n\n  /**\n   * At a break.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^  ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === null) {\n      return after(code);\n    }\n    if (markdownLineEnding(code)) {\n      return effects.attempt(furtherStart, atBreak, after)(code);\n    }\n    effects.enter(\"codeFlowValue\");\n    return inside(code);\n  }\n\n  /**\n   * In code content.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"codeFlowValue\");\n      return atBreak(code);\n    }\n    effects.consume(code);\n    return inside;\n  }\n\n  /** @type {State} */\n  function after(code) {\n    effects.exit(\"codeIndented\");\n    // To do: allow interrupting like `markdown-rs`.\n    // Feel free to interrupt.\n    // tokenizer.interrupt = false\n    return ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeFurtherStart(effects, ok, nok) {\n  const self = this;\n  return furtherStart;\n\n  /**\n   * At eol, trying to parse another indent.\n   *\n   * ```markdown\n   * > |     aaa\n   *            ^\n   *   |     bbb\n   * ```\n   *\n   * @type {State}\n   */\n  function furtherStart(code) {\n    // To do: improve `lazy` / `pierce` handling.\n    // If this is a lazy line, it can’t be code.\n    if (self.parser.lazy[self.now().line]) {\n      return nok(code);\n    }\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return furtherStart;\n    }\n\n    // To do: the code here in `micromark-js` is a bit different from\n    // `markdown-rs` because there it can attempt spaces.\n    // We can’t yet.\n    //\n    // To do: use an improved `space_or_tab` function like `markdown-rs`,\n    // so that we can drop the next state.\n    return factorySpace(effects, afterPrefix, \"linePrefix\", 4 + 1)(code);\n  }\n\n  /**\n   * At start, after 1 or 4 spaces.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === \"linePrefix\" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? ok(code) : markdownLineEnding(code) ? furtherStart(code) : nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';\nimport { splice } from 'micromark-util-chunked';\n/** @type {Construct} */\nexport const headingAtx = {\n  name: 'headingAtx',\n  resolve: resolveHeadingAtx,\n  tokenize: tokenizeHeadingAtx\n};\n\n/** @type {Resolver} */\nfunction resolveHeadingAtx(events, context) {\n  let contentEnd = events.length - 2;\n  let contentStart = 3;\n  /** @type {Token} */\n  let content;\n  /** @type {Token} */\n  let text;\n\n  // Prefix whitespace, part of the opening.\n  if (events[contentStart][1].type === \"whitespace\") {\n    contentStart += 2;\n  }\n\n  // Suffix whitespace, part of the closing.\n  if (contentEnd - 2 > contentStart && events[contentEnd][1].type === \"whitespace\") {\n    contentEnd -= 2;\n  }\n  if (events[contentEnd][1].type === \"atxHeadingSequence\" && (contentStart === contentEnd - 1 || contentEnd - 4 > contentStart && events[contentEnd - 2][1].type === \"whitespace\")) {\n    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4;\n  }\n  if (contentEnd > contentStart) {\n    content = {\n      type: \"atxHeadingText\",\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end\n    };\n    text = {\n      type: \"chunkText\",\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end,\n      contentType: \"text\"\n    };\n    splice(events, contentStart, contentEnd - contentStart + 1, [['enter', content, context], ['enter', text, context], ['exit', text, context], ['exit', content, context]]);\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeHeadingAtx(effects, ok, nok) {\n  let size = 0;\n  return start;\n\n  /**\n   * Start of a heading (atx).\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse indent like `markdown-rs`.\n    effects.enter(\"atxHeading\");\n    return before(code);\n  }\n\n  /**\n   * After optional whitespace, at `#`.\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter(\"atxHeadingSequence\");\n    return sequenceOpen(code);\n  }\n\n  /**\n   * In opening sequence.\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === 35 && size++ < 6) {\n      effects.consume(code);\n      return sequenceOpen;\n    }\n\n    // Always at least one `#`.\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit(\"atxHeadingSequence\");\n      return atBreak(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * After something, before something else.\n   *\n   * ```markdown\n   * > | ## aa\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === 35) {\n      effects.enter(\"atxHeadingSequence\");\n      return sequenceFurther(code);\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"atxHeading\");\n      // To do: interrupt like `markdown-rs`.\n      // // Feel free to interrupt.\n      // tokenizer.interrupt = false\n      return ok(code);\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(effects, atBreak, \"whitespace\")(code);\n    }\n\n    // To do: generate `data` tokens, add the `text` token later.\n    // Needs edit map, see: `markdown.rs`.\n    effects.enter(\"atxHeadingText\");\n    return data(code);\n  }\n\n  /**\n   * In further sequence (after whitespace).\n   *\n   * Could be normal “visible” hashes in the heading or a final sequence.\n   *\n   * ```markdown\n   * > | ## aa ##\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceFurther(code) {\n    if (code === 35) {\n      effects.consume(code);\n      return sequenceFurther;\n    }\n    effects.exit(\"atxHeadingSequence\");\n    return atBreak(code);\n  }\n\n  /**\n   * In text.\n   *\n   * ```markdown\n   * > | ## aa\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function data(code) {\n    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {\n      effects.exit(\"atxHeadingText\");\n      return atBreak(code);\n    }\n    effects.consume(code);\n    return data;\n  }\n}","/**\n * @import {\n *   Code,\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const setextUnderline = {\n  name: 'setextUnderline',\n  resolveTo: resolveToSetextUnderline,\n  tokenize: tokenizeSetextUnderline\n};\n\n/** @type {Resolver} */\nfunction resolveToSetextUnderline(events, context) {\n  // To do: resolve like `markdown-rs`.\n  let index = events.length;\n  /** @type {number | undefined} */\n  let content;\n  /** @type {number | undefined} */\n  let text;\n  /** @type {number | undefined} */\n  let definition;\n\n  // Find the opening of the content.\n  // It’ll always exist: we don’t tokenize if it isn’t there.\n  while (index--) {\n    if (events[index][0] === 'enter') {\n      if (events[index][1].type === \"content\") {\n        content = index;\n        break;\n      }\n      if (events[index][1].type === \"paragraph\") {\n        text = index;\n      }\n    }\n    // Exit\n    else {\n      if (events[index][1].type === \"content\") {\n        // Remove the content end (if needed we’ll add it later)\n        events.splice(index, 1);\n      }\n      if (!definition && events[index][1].type === \"definition\") {\n        definition = index;\n      }\n    }\n  }\n  const heading = {\n    type: \"setextHeading\",\n    start: {\n      ...events[text][1].start\n    },\n    end: {\n      ...events[events.length - 1][1].end\n    }\n  };\n\n  // Change the paragraph to setext heading text.\n  events[text][1].type = \"setextHeadingText\";\n\n  // If we have definitions in the content, we’ll keep on having content,\n  // but we need move it.\n  if (definition) {\n    events.splice(text, 0, ['enter', heading, context]);\n    events.splice(definition + 1, 0, ['exit', events[content][1], context]);\n    events[content][1].end = {\n      ...events[definition][1].end\n    };\n  } else {\n    events[content][1] = heading;\n  }\n\n  // Add the heading exit at the end.\n  events.push(['exit', heading, context]);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeSetextUnderline(effects, ok, nok) {\n  const self = this;\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * At start of heading (setext) underline.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    let index = self.events.length;\n    /** @type {boolean | undefined} */\n    let paragraph;\n    // Find an opening.\n    while (index--) {\n      // Skip enter/exit of line ending, line prefix, and content.\n      // We can now either have a definition or a paragraph.\n      if (self.events[index][1].type !== \"lineEnding\" && self.events[index][1].type !== \"linePrefix\" && self.events[index][1].type !== \"content\") {\n        paragraph = self.events[index][1].type === \"paragraph\";\n        break;\n      }\n    }\n\n    // To do: handle lazy/pierce like `markdown-rs`.\n    // To do: parse indent like `markdown-rs`.\n    if (!self.parser.lazy[self.now().line] && (self.interrupt || paragraph)) {\n      effects.enter(\"setextHeadingLine\");\n      marker = code;\n      return before(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * After optional whitespace, at `-` or `=`.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter(\"setextHeadingLineSequence\");\n    return inside(code);\n  }\n\n  /**\n   * In sequence.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return inside;\n    }\n    effects.exit(\"setextHeadingLineSequence\");\n    return markdownSpace(code) ? factorySpace(effects, after, \"lineSuffix\")(code) : after(code);\n  }\n\n  /**\n   * After sequence, after optional whitespace.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"setextHeadingLine\");\n      return ok(code);\n    }\n    return nok(code);\n  }\n}","/**\n * List of lowercase HTML “block” tag names.\n *\n * The list, when parsing HTML (flow), results in more relaxed rules (condition\n * 6).\n * Because they are known blocks, the HTML-like syntax doesn’t have to be\n * strictly parsed.\n * For tag names not in this list, a more strict algorithm (condition 7) is used\n * to detect whether the HTML-like syntax is seen as HTML (flow) or not.\n *\n * This is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n *\n * > 👉 **Note**: `search` was added in `CommonMark@0.31`.\n */\nexport const htmlBlockNames = [\n  'address',\n  'article',\n  'aside',\n  'base',\n  'basefont',\n  'blockquote',\n  'body',\n  'caption',\n  'center',\n  'col',\n  'colgroup',\n  'dd',\n  'details',\n  'dialog',\n  'dir',\n  'div',\n  'dl',\n  'dt',\n  'fieldset',\n  'figcaption',\n  'figure',\n  'footer',\n  'form',\n  'frame',\n  'frameset',\n  'h1',\n  'h2',\n  'h3',\n  'h4',\n  'h5',\n  'h6',\n  'head',\n  'header',\n  'hr',\n  'html',\n  'iframe',\n  'legend',\n  'li',\n  'link',\n  'main',\n  'menu',\n  'menuitem',\n  'nav',\n  'noframes',\n  'ol',\n  'optgroup',\n  'option',\n  'p',\n  'param',\n  'search',\n  'section',\n  'summary',\n  'table',\n  'tbody',\n  'td',\n  'tfoot',\n  'th',\n  'thead',\n  'title',\n  'tr',\n  'track',\n  'ul'\n]\n\n/**\n * List of lowercase HTML “raw” tag names.\n *\n * The list, when parsing HTML (flow), results in HTML that can include lines\n * without exiting, until a closing tag also in this list is found (condition\n * 1).\n *\n * This module is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n *\n * > 👉 **Note**: `textarea` was added in `CommonMark@0.30`.\n */\nexport const htmlRawNames = ['pre', 'script', 'style', 'textarea']\n","/**\n * @import {\n *   Code,\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { asciiAlphanumeric, asciiAlpha, markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';\nimport { htmlBlockNames, htmlRawNames } from 'micromark-util-html-tag-name';\nimport { blankLine } from './blank-line.js';\n\n/** @type {Construct} */\nexport const htmlFlow = {\n  concrete: true,\n  name: 'htmlFlow',\n  resolveTo: resolveToHtmlFlow,\n  tokenize: tokenizeHtmlFlow\n};\n\n/** @type {Construct} */\nconst blankLineBefore = {\n  partial: true,\n  tokenize: tokenizeBlankLineBefore\n};\nconst nonLazyContinuationStart = {\n  partial: true,\n  tokenize: tokenizeNonLazyContinuationStart\n};\n\n/** @type {Resolver} */\nfunction resolveToHtmlFlow(events) {\n  let index = events.length;\n  while (index--) {\n    if (events[index][0] === 'enter' && events[index][1].type === \"htmlFlow\") {\n      break;\n    }\n  }\n  if (index > 1 && events[index - 2][1].type === \"linePrefix\") {\n    // Add the prefix start to the HTML token.\n    events[index][1].start = events[index - 2][1].start;\n    // Add the prefix start to the HTML line token.\n    events[index + 1][1].start = events[index - 2][1].start;\n    // Remove the line prefix.\n    events.splice(index - 2, 2);\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeHtmlFlow(effects, ok, nok) {\n  const self = this;\n  /** @type {number} */\n  let marker;\n  /** @type {boolean} */\n  let closingTag;\n  /** @type {string} */\n  let buffer;\n  /** @type {number} */\n  let index;\n  /** @type {Code} */\n  let markerB;\n  return start;\n\n  /**\n   * Start of HTML (flow).\n   *\n   * ```markdown\n   * > | <x />\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse indent like `markdown-rs`.\n    return before(code);\n  }\n\n  /**\n   * At `<`, after optional whitespace.\n   *\n   * ```markdown\n   * > | <x />\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter(\"htmlFlow\");\n    effects.enter(\"htmlFlowData\");\n    effects.consume(code);\n    return open;\n  }\n\n  /**\n   * After `<`, at tag name or other stuff.\n   *\n   * ```markdown\n   * > | <x />\n   *      ^\n   * > | <!doctype>\n   *      ^\n   * > | <!--xxx-->\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationOpen;\n    }\n    if (code === 47) {\n      effects.consume(code);\n      closingTag = true;\n      return tagCloseStart;\n    }\n    if (code === 63) {\n      effects.consume(code);\n      marker = 3;\n      // To do:\n      // tokenizer.concrete = true\n      // To do: use `markdown-rs` style interrupt.\n      // While we’re in an instruction instead of a declaration, we’re on a `?`\n      // right now, so we do need to search for `>`, similar to declarations.\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      // Always the case.\n      effects.consume(code);\n      buffer = String.fromCharCode(code);\n      return tagName;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<!`, at declaration, comment, or CDATA.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *       ^\n   * > | <!--xxx-->\n   *       ^\n   * > | <![CDATA[>&<]]>\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      marker = 2;\n      return commentOpenInside;\n    }\n    if (code === 91) {\n      effects.consume(code);\n      marker = 5;\n      index = 0;\n      return cdataOpenInside;\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      marker = 4;\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<!-`, inside a comment, at another `-`.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<![`, inside CDATA, expecting `CDATA[`.\n   *\n   * ```markdown\n   * > | <![CDATA[>&<]]>\n   *        ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataOpenInside(code) {\n    const value = \"CDATA[\";\n    if (code === value.charCodeAt(index++)) {\n      effects.consume(code);\n      if (index === value.length) {\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok : continuation;\n      }\n      return cdataOpenInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `</`, in closing tag, at tag name.\n   *\n   * ```markdown\n   * > | </x>\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      // Always the case.\n      effects.consume(code);\n      buffer = String.fromCharCode(code);\n      return tagName;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In tag name.\n   *\n   * ```markdown\n   * > | <ab>\n   *      ^^\n   * > | </ab>\n   *       ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagName(code) {\n    if (code === null || code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      const slash = code === 47;\n      const name = buffer.toLowerCase();\n      if (!slash && !closingTag && htmlRawNames.includes(name)) {\n        marker = 1;\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok(code) : continuation(code);\n      }\n      if (htmlBlockNames.includes(buffer.toLowerCase())) {\n        marker = 6;\n        if (slash) {\n          effects.consume(code);\n          return basicSelfClosing;\n        }\n\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok(code) : continuation(code);\n      }\n      marker = 7;\n      // Do not support complete HTML when interrupting.\n      return self.interrupt && !self.parser.lazy[self.now().line] ? nok(code) : closingTag ? completeClosingTagAfter(code) : completeAttributeNameBefore(code);\n    }\n\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      buffer += String.fromCharCode(code);\n      return tagName;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After closing slash of a basic tag name.\n   *\n   * ```markdown\n   * > | <div/>\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function basicSelfClosing(code) {\n    if (code === 62) {\n      effects.consume(code);\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuation;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After closing slash of a complete tag name.\n   *\n   * ```markdown\n   * > | <x/>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeClosingTagAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeClosingTagAfter;\n    }\n    return completeEnd(code);\n  }\n\n  /**\n   * At an attribute name.\n   *\n   * At first, this state is used after a complete tag name, after whitespace,\n   * where it expects optional attributes or the end of the tag.\n   * It is also reused after attributes, when expecting more optional\n   * attributes.\n   *\n   * ```markdown\n   * > | <a />\n   *        ^\n   * > | <a :b>\n   *        ^\n   * > | <a _b>\n   *        ^\n   * > | <a b>\n   *        ^\n   * > | <a >\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeNameBefore(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return completeEnd;\n    }\n\n    // ASCII alphanumerical and `:` and `_`.\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameBefore;\n    }\n    return completeEnd(code);\n  }\n\n  /**\n   * In attribute name.\n   *\n   * ```markdown\n   * > | <a :b>\n   *         ^\n   * > | <a _b>\n   *         ^\n   * > | <a b>\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeName(code) {\n    // ASCII alphanumerical and `-`, `.`, `:`, and `_`.\n    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n    return completeAttributeNameAfter(code);\n  }\n\n  /**\n   * After attribute name, at an optional initializer, the end of the tag, or\n   * whitespace.\n   *\n   * ```markdown\n   * > | <a b>\n   *         ^\n   * > | <a b=c>\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameAfter;\n    }\n    return completeAttributeNameBefore(code);\n  }\n\n  /**\n   * Before unquoted, double quoted, or single quoted attribute value, allowing\n   * whitespace.\n   *\n   * ```markdown\n   * > | <a b=c>\n   *          ^\n   * > | <a b=\"c\">\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      markerB = code;\n      return completeAttributeValueQuoted;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n    return completeAttributeValueUnquoted(code);\n  }\n\n  /**\n   * In double or single quoted attribute value.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *           ^\n   * > | <a b='c'>\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueQuoted(code) {\n    if (code === markerB) {\n      effects.consume(code);\n      markerB = null;\n      return completeAttributeValueQuotedAfter;\n    }\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return completeAttributeValueQuoted;\n  }\n\n  /**\n   * In unquoted attribute value.\n   *\n   * ```markdown\n   * > | <a b=c>\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueUnquoted(code) {\n    if (code === null || code === 34 || code === 39 || code === 47 || code === 60 || code === 61 || code === 62 || code === 96 || markdownLineEndingOrSpace(code)) {\n      return completeAttributeNameAfter(code);\n    }\n    effects.consume(code);\n    return completeAttributeValueUnquoted;\n  }\n\n  /**\n   * After double or single quoted attribute value, before whitespace or the\n   * end of the tag.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownSpace(code)) {\n      return completeAttributeNameBefore(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In certain circumstances of a complete tag where only an `>` is allowed.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeEnd(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return completeAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `>` in a complete tag.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAfter(code) {\n    if (code === null || markdownLineEnding(code)) {\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return continuation(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In continuation of any HTML kind.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuation(code) {\n    if (code === 45 && marker === 2) {\n      effects.consume(code);\n      return continuationCommentInside;\n    }\n    if (code === 60 && marker === 1) {\n      effects.consume(code);\n      return continuationRawTagOpen;\n    }\n    if (code === 62 && marker === 4) {\n      effects.consume(code);\n      return continuationClose;\n    }\n    if (code === 63 && marker === 3) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    if (code === 93 && marker === 5) {\n      effects.consume(code);\n      return continuationCdataInside;\n    }\n    if (markdownLineEnding(code) && (marker === 6 || marker === 7)) {\n      effects.exit(\"htmlFlowData\");\n      return effects.check(blankLineBefore, continuationAfter, continuationStart)(code);\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"htmlFlowData\");\n      return continuationStart(code);\n    }\n    effects.consume(code);\n    return continuation;\n  }\n\n  /**\n   * In continuation, at eol.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   *   | asd\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationStart(code) {\n    return effects.check(nonLazyContinuationStart, continuationStartNonLazy, continuationAfter)(code);\n  }\n\n  /**\n   * In continuation, at eol, before non-lazy content.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   *   | asd\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationStartNonLazy(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return continuationBefore;\n  }\n\n  /**\n   * In continuation, before non-lazy content.\n   *\n   * ```markdown\n   *   | <x>\n   * > | asd\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return continuationStart(code);\n    }\n    effects.enter(\"htmlFlowData\");\n    return continuation(code);\n  }\n\n  /**\n   * In comment continuation, after one `-`, expecting another.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationCommentInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In raw continuation, after `<`, at `/`.\n   *\n   * ```markdown\n   * > | <script>console.log(1)</script>\n   *                            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationRawTagOpen(code) {\n    if (code === 47) {\n      effects.consume(code);\n      buffer = '';\n      return continuationRawEndTag;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In raw continuation, after `</`, in a raw tag name.\n   *\n   * ```markdown\n   * > | <script>console.log(1)</script>\n   *                             ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationRawEndTag(code) {\n    if (code === 62) {\n      const name = buffer.toLowerCase();\n      if (htmlRawNames.includes(name)) {\n        effects.consume(code);\n        return continuationClose;\n      }\n      return continuation(code);\n    }\n    if (asciiAlpha(code) && buffer.length < 8) {\n      // Always the case.\n      effects.consume(code);\n      buffer += String.fromCharCode(code);\n      return continuationRawEndTag;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In cdata continuation, after `]`, expecting `]>`.\n   *\n   * ```markdown\n   * > | <![CDATA[>&<]]>\n   *                  ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationCdataInside(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In declaration or instruction continuation, at `>`.\n   *\n   * ```markdown\n   * > | <!-->\n   *         ^\n   * > | <?>\n   *       ^\n   * > | <!q>\n   *        ^\n   * > | <!--ab-->\n   *             ^\n   * > | <![CDATA[>&<]]>\n   *                   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationDeclarationInside(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return continuationClose;\n    }\n\n    // More dashes.\n    if (code === 45 && marker === 2) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In closed continuation: everything we get until the eol/eof is part of it.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationClose(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"htmlFlowData\");\n      return continuationAfter(code);\n    }\n    effects.consume(code);\n    return continuationClose;\n  }\n\n  /**\n   * Done.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationAfter(code) {\n    effects.exit(\"htmlFlow\");\n    // // Feel free to interrupt.\n    // tokenizer.interrupt = false\n    // // No longer concrete.\n    // tokenizer.concrete = false\n    return ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeNonLazyContinuationStart(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * At eol, before continuation.\n   *\n   * ```markdown\n   * > | * ```js\n   *            ^\n   *   | b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return after;\n    }\n    return nok(code);\n  }\n\n  /**\n   * A continuation.\n   *\n   * ```markdown\n   *   | * ```js\n   * > | b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return self.parser.lazy[self.now().line] ? nok(code) : ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlankLineBefore(effects, ok, nok) {\n  return start;\n\n  /**\n   * Before eol, expecting blank line.\n   *\n   * ```markdown\n   * > | <div>\n   *          ^\n   *   |\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return effects.attempt(blankLine, ok, nok);\n  }\n}","/**\n * @import {\n *   Code,\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nconst nonLazyContinuation = {\n  partial: true,\n  tokenize: tokenizeNonLazyContinuation\n};\n\n/** @type {Construct} */\nexport const codeFenced = {\n  concrete: true,\n  name: 'codeFenced',\n  tokenize: tokenizeCodeFenced\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCodeFenced(effects, ok, nok) {\n  const self = this;\n  /** @type {Construct} */\n  const closeStart = {\n    partial: true,\n    tokenize: tokenizeCloseStart\n  };\n  let initialPrefix = 0;\n  let sizeOpen = 0;\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Start of code.\n   *\n   * ```markdown\n   * > | ~~~js\n   *     ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse whitespace like `markdown-rs`.\n    return beforeSequenceOpen(code);\n  }\n\n  /**\n   * In opening fence, after prefix, at sequence.\n   *\n   * ```markdown\n   * > | ~~~js\n   *     ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeSequenceOpen(code) {\n    const tail = self.events[self.events.length - 1];\n    initialPrefix = tail && tail[1].type === \"linePrefix\" ? tail[2].sliceSerialize(tail[1], true).length : 0;\n    marker = code;\n    effects.enter(\"codeFenced\");\n    effects.enter(\"codeFencedFence\");\n    effects.enter(\"codeFencedFenceSequence\");\n    return sequenceOpen(code);\n  }\n\n  /**\n   * In opening fence sequence.\n   *\n   * ```markdown\n   * > | ~~~js\n   *      ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === marker) {\n      sizeOpen++;\n      effects.consume(code);\n      return sequenceOpen;\n    }\n    if (sizeOpen < 3) {\n      return nok(code);\n    }\n    effects.exit(\"codeFencedFenceSequence\");\n    return markdownSpace(code) ? factorySpace(effects, infoBefore, \"whitespace\")(code) : infoBefore(code);\n  }\n\n  /**\n   * In opening fence, after the sequence (and optional whitespace), before info.\n   *\n   * ```markdown\n   * > | ~~~js\n   *        ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function infoBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"codeFencedFence\");\n      return self.interrupt ? ok(code) : effects.check(nonLazyContinuation, atNonLazyBreak, after)(code);\n    }\n    effects.enter(\"codeFencedFenceInfo\");\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return info(code);\n  }\n\n  /**\n   * In info.\n   *\n   * ```markdown\n   * > | ~~~js\n   *        ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function info(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"chunkString\");\n      effects.exit(\"codeFencedFenceInfo\");\n      return infoBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.exit(\"chunkString\");\n      effects.exit(\"codeFencedFenceInfo\");\n      return factorySpace(effects, metaBefore, \"whitespace\")(code);\n    }\n    if (code === 96 && code === marker) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return info;\n  }\n\n  /**\n   * In opening fence, after info and whitespace, before meta.\n   *\n   * ```markdown\n   * > | ~~~js eval\n   *           ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function metaBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return infoBefore(code);\n    }\n    effects.enter(\"codeFencedFenceMeta\");\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return meta(code);\n  }\n\n  /**\n   * In meta.\n   *\n   * ```markdown\n   * > | ~~~js eval\n   *           ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function meta(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"chunkString\");\n      effects.exit(\"codeFencedFenceMeta\");\n      return infoBefore(code);\n    }\n    if (code === 96 && code === marker) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return meta;\n  }\n\n  /**\n   * At eol/eof in code, before a non-lazy closing fence or content.\n   *\n   * ```markdown\n   * > | ~~~js\n   *          ^\n   * > | alert(1)\n   *             ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function atNonLazyBreak(code) {\n    return effects.attempt(closeStart, after, contentBefore)(code);\n  }\n\n  /**\n   * Before code content, not a closing fence, at eol.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *             ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentBefore(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return contentStart;\n  }\n\n  /**\n   * Before code content, not a closing fence.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentStart(code) {\n    return initialPrefix > 0 && markdownSpace(code) ? factorySpace(effects, beforeContentChunk, \"linePrefix\", initialPrefix + 1)(code) : beforeContentChunk(code);\n  }\n\n  /**\n   * Before code content, after optional prefix.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeContentChunk(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return effects.check(nonLazyContinuation, atNonLazyBreak, after)(code);\n    }\n    effects.enter(\"codeFlowValue\");\n    return contentChunk(code);\n  }\n\n  /**\n   * In code content.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^^^^^^^^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentChunk(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"codeFlowValue\");\n      return beforeContentChunk(code);\n    }\n    effects.consume(code);\n    return contentChunk;\n  }\n\n  /**\n   * After code.\n   *\n   * ```markdown\n   *   | ~~~js\n   *   | alert(1)\n   * > | ~~~\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    effects.exit(\"codeFenced\");\n    return ok(code);\n  }\n\n  /**\n   * @this {TokenizeContext}\n   *   Context.\n   * @type {Tokenizer}\n   */\n  function tokenizeCloseStart(effects, ok, nok) {\n    let size = 0;\n    return startBefore;\n\n    /**\n     *\n     *\n     * @type {State}\n     */\n    function startBefore(code) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return start;\n    }\n\n    /**\n     * Before closing fence, at optional whitespace.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function start(code) {\n      // Always populated by defaults.\n\n      // To do: `enter` here or in next state?\n      effects.enter(\"codeFencedFence\");\n      return markdownSpace(code) ? factorySpace(effects, beforeSequenceClose, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code) : beforeSequenceClose(code);\n    }\n\n    /**\n     * In closing fence, after optional whitespace, at sequence.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function beforeSequenceClose(code) {\n      if (code === marker) {\n        effects.enter(\"codeFencedFenceSequence\");\n        return sequenceClose(code);\n      }\n      return nok(code);\n    }\n\n    /**\n     * In closing fence sequence.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function sequenceClose(code) {\n      if (code === marker) {\n        size++;\n        effects.consume(code);\n        return sequenceClose;\n      }\n      if (size >= sizeOpen) {\n        effects.exit(\"codeFencedFenceSequence\");\n        return markdownSpace(code) ? factorySpace(effects, sequenceCloseAfter, \"whitespace\")(code) : sequenceCloseAfter(code);\n      }\n      return nok(code);\n    }\n\n    /**\n     * After closing fence sequence, after optional whitespace.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *        ^\n     * ```\n     *\n     * @type {State}\n     */\n    function sequenceCloseAfter(code) {\n      if (code === null || markdownLineEnding(code)) {\n        effects.exit(\"codeFencedFence\");\n        return ok(code);\n      }\n      return nok(code);\n    }\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeNonLazyContinuation(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return lineStart;\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function lineStart(code) {\n    return self.parser.lazy[self.now().line] ? nok(code) : ok(code);\n  }\n}","/// <reference lib=\"dom\" />\n\n/* eslint-env browser */\n\nconst element = document.createElement('i')\n\n/**\n * @param {string} value\n * @returns {string|false}\n */\nexport function decodeNamedCharacterReference(value) {\n  const characterReference = '&' + value + ';'\n  element.innerHTML = characterReference\n  const char = element.textContent\n\n  // Some named character references do not require the closing semicolon\n  // (`&not`, for instance), which leads to situations where parsing the assumed\n  // named reference of `&notit;` will result in the string `¬it;`.\n  // When we encounter a trailing semicolon after parsing, and the character\n  // reference to decode was not a semicolon (`&semi;`), we can assume that the\n  // matching was not complete.\n  // @ts-expect-error: TypeScript is wrong that `textContent` on elements can\n  // yield `null`.\n  if (char.charCodeAt(char.length - 1) === 59 /* `;` */ && value !== 'semi') {\n    return false\n  }\n\n  // If the decoded string is equal to the input, the character reference was\n  // not valid.\n  // @ts-expect-error: TypeScript is wrong that `textContent` on elements can\n  // yield `null`.\n  return char === characterReference ? false : char\n}\n","/**\n * @import {\n *   Code,\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { decodeNamedCharacterReference } from 'decode-named-character-reference';\nimport { asciiAlphanumeric, asciiDigit, asciiHexDigit } from 'micromark-util-character';\n/** @type {Construct} */\nexport const characterReference = {\n  name: 'characterReference',\n  tokenize: tokenizeCharacterReference\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCharacterReference(effects, ok, nok) {\n  const self = this;\n  let size = 0;\n  /** @type {number} */\n  let max;\n  /** @type {(code: Code) => boolean} */\n  let test;\n  return start;\n\n  /**\n   * Start of character reference.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *      ^\n   * > | a&#123;b\n   *      ^\n   * > | a&#x9;b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"characterReference\");\n    effects.enter(\"characterReferenceMarker\");\n    effects.consume(code);\n    effects.exit(\"characterReferenceMarker\");\n    return open;\n  }\n\n  /**\n   * After `&`, at `#` for numeric references or alphanumeric for named\n   * references.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *       ^\n   * > | a&#123;b\n   *       ^\n   * > | a&#x9;b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 35) {\n      effects.enter(\"characterReferenceMarkerNumeric\");\n      effects.consume(code);\n      effects.exit(\"characterReferenceMarkerNumeric\");\n      return numeric;\n    }\n    effects.enter(\"characterReferenceValue\");\n    max = 31;\n    test = asciiAlphanumeric;\n    return value(code);\n  }\n\n  /**\n   * After `#`, at `x` for hexadecimals or digit for decimals.\n   *\n   * ```markdown\n   * > | a&#123;b\n   *        ^\n   * > | a&#x9;b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function numeric(code) {\n    if (code === 88 || code === 120) {\n      effects.enter(\"characterReferenceMarkerHexadecimal\");\n      effects.consume(code);\n      effects.exit(\"characterReferenceMarkerHexadecimal\");\n      effects.enter(\"characterReferenceValue\");\n      max = 6;\n      test = asciiHexDigit;\n      return value;\n    }\n    effects.enter(\"characterReferenceValue\");\n    max = 7;\n    test = asciiDigit;\n    return value(code);\n  }\n\n  /**\n   * After markers (`&#x`, `&#`, or `&`), in value, before `;`.\n   *\n   * The character reference kind defines what and how many characters are\n   * allowed.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *       ^^^\n   * > | a&#123;b\n   *        ^^^\n   * > | a&#x9;b\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function value(code) {\n    if (code === 59 && size) {\n      const token = effects.exit(\"characterReferenceValue\");\n      if (test === asciiAlphanumeric && !decodeNamedCharacterReference(self.sliceSerialize(token))) {\n        return nok(code);\n      }\n\n      // To do: `markdown-rs` uses a different name:\n      // `CharacterReferenceMarkerSemi`.\n      effects.enter(\"characterReferenceMarker\");\n      effects.consume(code);\n      effects.exit(\"characterReferenceMarker\");\n      effects.exit(\"characterReference\");\n      return ok;\n    }\n    if (test(code) && size++ < max) {\n      effects.consume(code);\n      return value;\n    }\n    return nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { asciiPunctuation } from 'micromark-util-character';\n/** @type {Construct} */\nexport const characterEscape = {\n  name: 'characterEscape',\n  tokenize: tokenizeCharacterEscape\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCharacterEscape(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of character escape.\n   *\n   * ```markdown\n   * > | a\\*b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"characterEscape\");\n    effects.enter(\"escapeMarker\");\n    effects.consume(code);\n    effects.exit(\"escapeMarker\");\n    return inside;\n  }\n\n  /**\n   * After `\\`, at punctuation.\n   *\n   * ```markdown\n   * > | a\\*b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    // ASCII punctuation.\n    if (asciiPunctuation(code)) {\n      effects.enter(\"characterEscapeValue\");\n      effects.consume(code);\n      effects.exit(\"characterEscapeValue\");\n      effects.exit(\"characterEscape\");\n      return ok;\n    }\n    return nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const lineEnding = {\n  name: 'lineEnding',\n  tokenize: tokenizeLineEnding\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeLineEnding(effects, ok) {\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return factorySpace(effects, ok, \"linePrefix\");\n  }\n}","/**\n * @import {Event, Resolver, TokenizeContext} from 'micromark-util-types'\n */\n\n/**\n * Call all `resolveAll`s.\n *\n * @param {ReadonlyArray<{resolveAll?: Resolver | undefined}>} constructs\n *   List of constructs, optionally with `resolveAll`s.\n * @param {Array<Event>} events\n *   List of events.\n * @param {TokenizeContext} context\n *   Context used by `tokenize`.\n * @returns {Array<Event>}\n *   Changed events.\n */\nexport function resolveAll(constructs, events, context) {\n  /** @type {Array<Resolver>} */\n  const called = []\n  let index = -1\n\n  while (++index < constructs.length) {\n    const resolve = constructs[index].resolveAll\n\n    if (resolve && !called.includes(resolve)) {\n      events = resolve(events, context)\n      called.push(resolve)\n    }\n  }\n\n  return events\n}\n","/**\n * @import {\n *   Construct,\n *   Event,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { factoryDestination } from 'micromark-factory-destination';\nimport { factoryLabel } from 'micromark-factory-label';\nimport { factoryTitle } from 'micromark-factory-title';\nimport { factoryWhitespace } from 'micromark-factory-whitespace';\nimport { markdownLineEndingOrSpace } from 'micromark-util-character';\nimport { push, splice } from 'micromark-util-chunked';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/** @type {Construct} */\nexport const labelEnd = {\n  name: 'labelEnd',\n  resolveAll: resolveAllLabelEnd,\n  resolveTo: resolveToLabelEnd,\n  tokenize: tokenizeLabelEnd\n};\n\n/** @type {Construct} */\nconst resourceConstruct = {\n  tokenize: tokenizeResource\n};\n/** @type {Construct} */\nconst referenceFullConstruct = {\n  tokenize: tokenizeReferenceFull\n};\n/** @type {Construct} */\nconst referenceCollapsedConstruct = {\n  tokenize: tokenizeReferenceCollapsed\n};\n\n/** @type {Resolver} */\nfunction resolveAllLabelEnd(events) {\n  let index = -1;\n  /** @type {Array<Event>} */\n  const newEvents = [];\n  while (++index < events.length) {\n    const token = events[index][1];\n    newEvents.push(events[index]);\n    if (token.type === \"labelImage\" || token.type === \"labelLink\" || token.type === \"labelEnd\") {\n      // Remove the marker.\n      const offset = token.type === \"labelImage\" ? 4 : 2;\n      token.type = \"data\";\n      index += offset;\n    }\n  }\n\n  // If the events are equal, we don't have to copy newEvents to events\n  if (events.length !== newEvents.length) {\n    splice(events, 0, events.length, newEvents);\n  }\n  return events;\n}\n\n/** @type {Resolver} */\nfunction resolveToLabelEnd(events, context) {\n  let index = events.length;\n  let offset = 0;\n  /** @type {Token} */\n  let token;\n  /** @type {number | undefined} */\n  let open;\n  /** @type {number | undefined} */\n  let close;\n  /** @type {Array<Event>} */\n  let media;\n\n  // Find an opening.\n  while (index--) {\n    token = events[index][1];\n    if (open) {\n      // If we see another link, or inactive link label, we’ve been here before.\n      if (token.type === \"link\" || token.type === \"labelLink\" && token._inactive) {\n        break;\n      }\n\n      // Mark other link openings as inactive, as we can’t have links in\n      // links.\n      if (events[index][0] === 'enter' && token.type === \"labelLink\") {\n        token._inactive = true;\n      }\n    } else if (close) {\n      if (events[index][0] === 'enter' && (token.type === \"labelImage\" || token.type === \"labelLink\") && !token._balanced) {\n        open = index;\n        if (token.type !== \"labelLink\") {\n          offset = 2;\n          break;\n        }\n      }\n    } else if (token.type === \"labelEnd\") {\n      close = index;\n    }\n  }\n  const group = {\n    type: events[open][1].type === \"labelLink\" ? \"link\" : \"image\",\n    start: {\n      ...events[open][1].start\n    },\n    end: {\n      ...events[events.length - 1][1].end\n    }\n  };\n  const label = {\n    type: \"label\",\n    start: {\n      ...events[open][1].start\n    },\n    end: {\n      ...events[close][1].end\n    }\n  };\n  const text = {\n    type: \"labelText\",\n    start: {\n      ...events[open + offset + 2][1].end\n    },\n    end: {\n      ...events[close - 2][1].start\n    }\n  };\n  media = [['enter', group, context], ['enter', label, context]];\n\n  // Opening marker.\n  media = push(media, events.slice(open + 1, open + offset + 3));\n\n  // Text open.\n  media = push(media, [['enter', text, context]]);\n\n  // Always populated by defaults.\n\n  // Between.\n  media = push(media, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + offset + 4, close - 3), context));\n\n  // Text close, marker close, label close.\n  media = push(media, [['exit', text, context], events[close - 2], events[close - 1], ['exit', label, context]]);\n\n  // Reference, resource, or so.\n  media = push(media, events.slice(close + 1));\n\n  // Media close.\n  media = push(media, [['exit', group, context]]);\n  splice(events, open, events.length, media);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeLabelEnd(effects, ok, nok) {\n  const self = this;\n  let index = self.events.length;\n  /** @type {Token} */\n  let labelStart;\n  /** @type {boolean} */\n  let defined;\n\n  // Find an opening.\n  while (index--) {\n    if ((self.events[index][1].type === \"labelImage\" || self.events[index][1].type === \"labelLink\") && !self.events[index][1]._balanced) {\n      labelStart = self.events[index][1];\n      break;\n    }\n  }\n  return start;\n\n  /**\n   * Start of label end.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *       ^\n   * > | [a][b] c\n   *       ^\n   * > | [a][] b\n   *       ^\n   * > | [a] b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // If there is not an okay opening.\n    if (!labelStart) {\n      return nok(code);\n    }\n\n    // If the corresponding label (link) start is marked as inactive,\n    // it means we’d be wrapping a link, like this:\n    //\n    // ```markdown\n    // > | a [b [c](d) e](f) g.\n    //                  ^\n    // ```\n    //\n    // We can’t have that, so it’s just balanced brackets.\n    if (labelStart._inactive) {\n      return labelEndNok(code);\n    }\n    defined = self.parser.defined.includes(normalizeIdentifier(self.sliceSerialize({\n      start: labelStart.end,\n      end: self.now()\n    })));\n    effects.enter(\"labelEnd\");\n    effects.enter(\"labelMarker\");\n    effects.consume(code);\n    effects.exit(\"labelMarker\");\n    effects.exit(\"labelEnd\");\n    return after;\n  }\n\n  /**\n   * After `]`.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *       ^\n   * > | [a][b] c\n   *       ^\n   * > | [a][] b\n   *       ^\n   * > | [a] b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // Note: `markdown-rs` also parses GFM footnotes here, which for us is in\n    // an extension.\n\n    // Resource (`[asd](fgh)`)?\n    if (code === 40) {\n      return effects.attempt(resourceConstruct, labelEndOk, defined ? labelEndOk : labelEndNok)(code);\n    }\n\n    // Full (`[asd][fgh]`) or collapsed (`[asd][]`) reference?\n    if (code === 91) {\n      return effects.attempt(referenceFullConstruct, labelEndOk, defined ? referenceNotFull : labelEndNok)(code);\n    }\n\n    // Shortcut (`[asd]`) reference?\n    return defined ? labelEndOk(code) : labelEndNok(code);\n  }\n\n  /**\n   * After `]`, at `[`, but not at a full reference.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] b\n   *        ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceNotFull(code) {\n    return effects.attempt(referenceCollapsedConstruct, labelEndOk, labelEndNok)(code);\n  }\n\n  /**\n   * Done, we found something.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *           ^\n   * > | [a][b] c\n   *           ^\n   * > | [a][] b\n   *          ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEndOk(code) {\n    // Note: `markdown-rs` does a bunch of stuff here.\n    return ok(code);\n  }\n\n  /**\n   * Done, it’s nothing.\n   *\n   * There was an okay opening, but we didn’t match anything.\n   *\n   * ```markdown\n   * > | [a](b c\n   *        ^\n   * > | [a][b c\n   *        ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEndNok(code) {\n    labelStart._balanced = true;\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeResource(effects, ok, nok) {\n  return resourceStart;\n\n  /**\n   * At a resource.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceStart(code) {\n    effects.enter(\"resource\");\n    effects.enter(\"resourceMarker\");\n    effects.consume(code);\n    effects.exit(\"resourceMarker\");\n    return resourceBefore;\n  }\n\n  /**\n   * In resource, after `(`, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceBefore(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceOpen)(code) : resourceOpen(code);\n  }\n\n  /**\n   * In resource, after optional whitespace, at `)` or a destination.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceOpen(code) {\n    if (code === 41) {\n      return resourceEnd(code);\n    }\n    return factoryDestination(effects, resourceDestinationAfter, resourceDestinationMissing, \"resourceDestination\", \"resourceDestinationLiteral\", \"resourceDestinationLiteralMarker\", \"resourceDestinationRaw\", \"resourceDestinationString\", 32)(code);\n  }\n\n  /**\n   * In resource, after destination, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceDestinationAfter(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceBetween)(code) : resourceEnd(code);\n  }\n\n  /**\n   * At invalid destination.\n   *\n   * ```markdown\n   * > | [a](<<) b\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceDestinationMissing(code) {\n    return nok(code);\n  }\n\n  /**\n   * In resource, after destination and whitespace, at `(` or title.\n   *\n   * ```markdown\n   * > | [a](b ) c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceBetween(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(effects, resourceTitleAfter, nok, \"resourceTitle\", \"resourceTitleMarker\", \"resourceTitleString\")(code);\n    }\n    return resourceEnd(code);\n  }\n\n  /**\n   * In resource, after title, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b \"c\") d\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceTitleAfter(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceEnd)(code) : resourceEnd(code);\n  }\n\n  /**\n   * In resource, at `)`.\n   *\n   * ```markdown\n   * > | [a](b) d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceEnd(code) {\n    if (code === 41) {\n      effects.enter(\"resourceMarker\");\n      effects.consume(code);\n      effects.exit(\"resourceMarker\");\n      effects.exit(\"resource\");\n      return ok;\n    }\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeReferenceFull(effects, ok, nok) {\n  const self = this;\n  return referenceFull;\n\n  /**\n   * In a reference (full), at the `[`.\n   *\n   * ```markdown\n   * > | [a][b] d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFull(code) {\n    return factoryLabel.call(self, effects, referenceFullAfter, referenceFullMissing, \"reference\", \"referenceMarker\", \"referenceString\")(code);\n  }\n\n  /**\n   * In a reference (full), after `]`.\n   *\n   * ```markdown\n   * > | [a][b] d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFullAfter(code) {\n    return self.parser.defined.includes(normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1))) ? ok(code) : nok(code);\n  }\n\n  /**\n   * In reference (full) that was missing.\n   *\n   * ```markdown\n   * > | [a][b d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFullMissing(code) {\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeReferenceCollapsed(effects, ok, nok) {\n  return referenceCollapsedStart;\n\n  /**\n   * In reference (collapsed), at `[`.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceCollapsedStart(code) {\n    // We only attempt a collapsed label if there’s a `[`.\n\n    effects.enter(\"reference\");\n    effects.enter(\"referenceMarker\");\n    effects.consume(code);\n    effects.exit(\"referenceMarker\");\n    return referenceCollapsedOpen;\n  }\n\n  /**\n   * In reference (collapsed), at `]`.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] d\n   *         ^\n   * ```\n   *\n   *  @type {State}\n   */\n  function referenceCollapsedOpen(code) {\n    if (code === 93) {\n      effects.enter(\"referenceMarker\");\n      effects.consume(code);\n      effects.exit(\"referenceMarker\");\n      effects.exit(\"reference\");\n      return ok;\n    }\n    return nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { labelEnd } from './label-end.js';\n\n/** @type {Construct} */\nexport const labelStartImage = {\n  name: 'labelStartImage',\n  resolveAll: labelEnd.resolveAll,\n  tokenize: tokenizeLabelStartImage\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeLabelStartImage(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of label (image) start.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"labelImage\");\n    effects.enter(\"labelImageMarker\");\n    effects.consume(code);\n    effects.exit(\"labelImageMarker\");\n    return open;\n  }\n\n  /**\n   * After `!`, at `[`.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 91) {\n      effects.enter(\"labelMarker\");\n      effects.consume(code);\n      effects.exit(\"labelMarker\");\n      effects.exit(\"labelImage\");\n      return after;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `![`.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *         ^\n   * ```\n   *\n   * This is needed in because, when GFM footnotes are enabled, images never\n   * form when started with a `^`.\n   * Instead, links form:\n   *\n   * ```markdown\n   * ![^a](b)\n   *\n   * ![^a][b]\n   *\n   * [b]: c\n   * ```\n   *\n   * ```html\n   * <p>!<a href=\\\"b\\\">^a</a></p>\n   * <p>!<a href=\\\"c\\\">^a</a></p>\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // To do: use a new field to do this, this is still needed for\n    // `micromark-extension-gfm-footnote`, but the `label-start-link`\n    // behavior isn’t.\n    // Hidden footnotes hook.\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs ? nok(code) : ok(code);\n  }\n}","/**\n * @import {Code} from 'micromark-util-types'\n */\n\nimport { markdownLineEndingOrSpace, unicodePunctuation, unicodeWhitespace } from 'micromark-util-character';\n/**\n * Classify whether a code represents whitespace, punctuation, or something\n * else.\n *\n * Used for attention (emphasis, strong), whose sequences can open or close\n * based on the class of surrounding characters.\n *\n * > 👉 **Note**: eof (`null`) is seen as whitespace.\n *\n * @param {Code} code\n *   Code.\n * @returns {typeof constants.characterGroupWhitespace | typeof constants.characterGroupPunctuation | undefined}\n *   Group.\n */\nexport function classifyCharacter(code) {\n  if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n    return 1;\n  }\n  if (unicodePunctuation(code)) {\n    return 2;\n  }\n}","/**\n * @import {\n *   Code,\n *   Construct,\n *   Event,\n *   Point,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { push, splice } from 'micromark-util-chunked';\nimport { classifyCharacter } from 'micromark-util-classify-character';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/** @type {Construct} */\nexport const attention = {\n  name: 'attention',\n  resolveAll: resolveAllAttention,\n  tokenize: tokenizeAttention\n};\n\n/**\n * Take all events and resolve attention to emphasis or strong.\n *\n * @type {Resolver}\n */\n// eslint-disable-next-line complexity\nfunction resolveAllAttention(events, context) {\n  let index = -1;\n  /** @type {number} */\n  let open;\n  /** @type {Token} */\n  let group;\n  /** @type {Token} */\n  let text;\n  /** @type {Token} */\n  let openingSequence;\n  /** @type {Token} */\n  let closingSequence;\n  /** @type {number} */\n  let use;\n  /** @type {Array<Event>} */\n  let nextEvents;\n  /** @type {number} */\n  let offset;\n\n  // Walk through all events.\n  //\n  // Note: performance of this is fine on an mb of normal markdown, but it’s\n  // a bottleneck for malicious stuff.\n  while (++index < events.length) {\n    // Find a token that can close.\n    if (events[index][0] === 'enter' && events[index][1].type === 'attentionSequence' && events[index][1]._close) {\n      open = index;\n\n      // Now walk back to find an opener.\n      while (open--) {\n        // Find a token that can open the closer.\n        if (events[open][0] === 'exit' && events[open][1].type === 'attentionSequence' && events[open][1]._open &&\n        // If the markers are the same:\n        context.sliceSerialize(events[open][1]).charCodeAt(0) === context.sliceSerialize(events[index][1]).charCodeAt(0)) {\n          // If the opening can close or the closing can open,\n          // and the close size *is not* a multiple of three,\n          // but the sum of the opening and closing size *is* multiple of three,\n          // then don’t match.\n          if ((events[open][1]._close || events[index][1]._open) && (events[index][1].end.offset - events[index][1].start.offset) % 3 && !((events[open][1].end.offset - events[open][1].start.offset + events[index][1].end.offset - events[index][1].start.offset) % 3)) {\n            continue;\n          }\n\n          // Number of markers to use from the sequence.\n          use = events[open][1].end.offset - events[open][1].start.offset > 1 && events[index][1].end.offset - events[index][1].start.offset > 1 ? 2 : 1;\n          const start = {\n            ...events[open][1].end\n          };\n          const end = {\n            ...events[index][1].start\n          };\n          movePoint(start, -use);\n          movePoint(end, use);\n          openingSequence = {\n            type: use > 1 ? \"strongSequence\" : \"emphasisSequence\",\n            start,\n            end: {\n              ...events[open][1].end\n            }\n          };\n          closingSequence = {\n            type: use > 1 ? \"strongSequence\" : \"emphasisSequence\",\n            start: {\n              ...events[index][1].start\n            },\n            end\n          };\n          text = {\n            type: use > 1 ? \"strongText\" : \"emphasisText\",\n            start: {\n              ...events[open][1].end\n            },\n            end: {\n              ...events[index][1].start\n            }\n          };\n          group = {\n            type: use > 1 ? \"strong\" : \"emphasis\",\n            start: {\n              ...openingSequence.start\n            },\n            end: {\n              ...closingSequence.end\n            }\n          };\n          events[open][1].end = {\n            ...openingSequence.start\n          };\n          events[index][1].start = {\n            ...closingSequence.end\n          };\n          nextEvents = [];\n\n          // If there are more markers in the opening, add them before.\n          if (events[open][1].end.offset - events[open][1].start.offset) {\n            nextEvents = push(nextEvents, [['enter', events[open][1], context], ['exit', events[open][1], context]]);\n          }\n\n          // Opening.\n          nextEvents = push(nextEvents, [['enter', group, context], ['enter', openingSequence, context], ['exit', openingSequence, context], ['enter', text, context]]);\n\n          // Always populated by defaults.\n\n          // Between.\n          nextEvents = push(nextEvents, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + 1, index), context));\n\n          // Closing.\n          nextEvents = push(nextEvents, [['exit', text, context], ['enter', closingSequence, context], ['exit', closingSequence, context], ['exit', group, context]]);\n\n          // If there are more markers in the closing, add them after.\n          if (events[index][1].end.offset - events[index][1].start.offset) {\n            offset = 2;\n            nextEvents = push(nextEvents, [['enter', events[index][1], context], ['exit', events[index][1], context]]);\n          } else {\n            offset = 0;\n          }\n          splice(events, open - 1, index - open + 3, nextEvents);\n          index = open + nextEvents.length - offset - 2;\n          break;\n        }\n      }\n    }\n  }\n\n  // Remove remaining sequences.\n  index = -1;\n  while (++index < events.length) {\n    if (events[index][1].type === 'attentionSequence') {\n      events[index][1].type = 'data';\n    }\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeAttention(effects, ok) {\n  const attentionMarkers = this.parser.constructs.attentionMarkers.null;\n  const previous = this.previous;\n  const before = classifyCharacter(previous);\n\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Before a sequence.\n   *\n   * ```markdown\n   * > | **\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    marker = code;\n    effects.enter('attentionSequence');\n    return inside(code);\n  }\n\n  /**\n   * In a sequence.\n   *\n   * ```markdown\n   * > | **\n   *     ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return inside;\n    }\n    const token = effects.exit('attentionSequence');\n\n    // To do: next major: move this to resolver, just like `markdown-rs`.\n    const after = classifyCharacter(code);\n\n    // Always populated by defaults.\n\n    const open = !after || after === 2 && before || attentionMarkers.includes(code);\n    const close = !before || before === 2 && after || attentionMarkers.includes(previous);\n    token._open = Boolean(marker === 42 ? open : open && (before || !close));\n    token._close = Boolean(marker === 42 ? close : close && (after || !open));\n    return ok(code);\n  }\n}\n\n/**\n * Move a point a bit.\n *\n * Note: `move` only works inside lines! It’s not possible to move past other\n * chunks (replacement characters, tabs, or line endings).\n *\n * @param {Point} point\n *   Point.\n * @param {number} offset\n *   Amount to move.\n * @returns {undefined}\n *   Nothing.\n */\nfunction movePoint(point, offset) {\n  point.column += offset;\n  point.offset += offset;\n  point._bufferIndex += offset;\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { asciiAlphanumeric, asciiAlpha, asciiAtext, asciiControl } from 'micromark-util-character';\n/** @type {Construct} */\nexport const autolink = {\n  name: 'autolink',\n  tokenize: tokenizeAutolink\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeAutolink(effects, ok, nok) {\n  let size = 0;\n  return start;\n\n  /**\n   * Start of an autolink.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *      ^\n   * > | a<user@example.com>b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"autolink\");\n    effects.enter(\"autolinkMarker\");\n    effects.consume(code);\n    effects.exit(\"autolinkMarker\");\n    effects.enter(\"autolinkProtocol\");\n    return open;\n  }\n\n  /**\n   * After `<`, at protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *       ^\n   * > | a<user@example.com>b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return schemeOrEmailAtext;\n    }\n    if (code === 64) {\n      return nok(code);\n    }\n    return emailAtext(code);\n  }\n\n  /**\n   * At second byte of protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *        ^\n   * > | a<user@example.com>b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function schemeOrEmailAtext(code) {\n    // ASCII alphanumeric and `+`, `-`, and `.`.\n    if (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) {\n      // Count the previous alphabetical from `open` too.\n      size = 1;\n      return schemeInsideOrEmailAtext(code);\n    }\n    return emailAtext(code);\n  }\n\n  /**\n   * In ambiguous protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *        ^\n   * > | a<user@example.com>b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function schemeInsideOrEmailAtext(code) {\n    if (code === 58) {\n      effects.consume(code);\n      size = 0;\n      return urlInside;\n    }\n\n    // ASCII alphanumeric and `+`, `-`, and `.`.\n    if ((code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) && size++ < 32) {\n      effects.consume(code);\n      return schemeInsideOrEmailAtext;\n    }\n    size = 0;\n    return emailAtext(code);\n  }\n\n  /**\n   * After protocol, in URL.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function urlInside(code) {\n    if (code === 62) {\n      effects.exit(\"autolinkProtocol\");\n      effects.enter(\"autolinkMarker\");\n      effects.consume(code);\n      effects.exit(\"autolinkMarker\");\n      effects.exit(\"autolink\");\n      return ok;\n    }\n\n    // ASCII control, space, or `<`.\n    if (code === null || code === 32 || code === 60 || asciiControl(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return urlInside;\n  }\n\n  /**\n   * In email atext.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailAtext(code) {\n    if (code === 64) {\n      effects.consume(code);\n      return emailAtSignOrDot;\n    }\n    if (asciiAtext(code)) {\n      effects.consume(code);\n      return emailAtext;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In label, after at-sign or dot.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *                 ^       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailAtSignOrDot(code) {\n    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code);\n  }\n\n  /**\n   * In label, where `.` and `>` are allowed.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *                   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailLabel(code) {\n    if (code === 46) {\n      effects.consume(code);\n      size = 0;\n      return emailAtSignOrDot;\n    }\n    if (code === 62) {\n      // Exit, then change the token type.\n      effects.exit(\"autolinkProtocol\").type = \"autolinkEmail\";\n      effects.enter(\"autolinkMarker\");\n      effects.consume(code);\n      effects.exit(\"autolinkMarker\");\n      effects.exit(\"autolink\");\n      return ok;\n    }\n    return emailValue(code);\n  }\n\n  /**\n   * In label, where `.` and `>` are *not* allowed.\n   *\n   * Though, this is also used in `emailLabel` to parse other values.\n   *\n   * ```markdown\n   * > | a<user.name@ex-ample.com>b\n   *                    ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailValue(code) {\n    // ASCII alphanumeric or `-`.\n    if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {\n      const next = code === 45 ? emailValue : emailLabel;\n      effects.consume(code);\n      return next;\n    }\n    return nok(code);\n  }\n}","/**\n * @import {\n *   Code,\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { asciiAlphanumeric, asciiAlpha, markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const htmlText = {\n  name: 'htmlText',\n  tokenize: tokenizeHtmlText\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeHtmlText(effects, ok, nok) {\n  const self = this;\n  /** @type {NonNullable<Code> | undefined} */\n  let marker;\n  /** @type {number} */\n  let index;\n  /** @type {State} */\n  let returnState;\n  return start;\n\n  /**\n   * Start of HTML (text).\n   *\n   * ```markdown\n   * > | a <b> c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"htmlText\");\n    effects.enter(\"htmlTextData\");\n    effects.consume(code);\n    return open;\n  }\n\n  /**\n   * After `<`, at tag name or other stuff.\n   *\n   * ```markdown\n   * > | a <b> c\n   *        ^\n   * > | a <!doctype> c\n   *        ^\n   * > | a <!--b--> c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationOpen;\n    }\n    if (code === 47) {\n      effects.consume(code);\n      return tagCloseStart;\n    }\n    if (code === 63) {\n      effects.consume(code);\n      return instruction;\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<!`, at declaration, comment, or CDATA.\n   *\n   * ```markdown\n   * > | a <!doctype> c\n   *         ^\n   * > | a <!--b--> c\n   *         ^\n   * > | a <![CDATA[>&<]]> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentOpenInside;\n    }\n    if (code === 91) {\n      effects.consume(code);\n      index = 0;\n      return cdataOpenInside;\n    }\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return declaration;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In a comment, after `<!-`, at another `-`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentEnd;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In comment.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function comment(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 45) {\n      effects.consume(code);\n      return commentClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = comment;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return comment;\n  }\n\n  /**\n   * In comment, after `-`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentClose(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentEnd;\n    }\n    return comment(code);\n  }\n\n  /**\n   * In comment, after `--`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentEnd(code) {\n    return code === 62 ? end(code) : code === 45 ? commentClose(code) : comment(code);\n  }\n\n  /**\n   * After `<![`, in CDATA, expecting `CDATA[`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *          ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataOpenInside(code) {\n    const value = \"CDATA[\";\n    if (code === value.charCodeAt(index++)) {\n      effects.consume(code);\n      return index === value.length ? cdata : cdataOpenInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In CDATA.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                ^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdata(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 93) {\n      effects.consume(code);\n      return cdataClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = cdata;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return cdata;\n  }\n\n  /**\n   * In CDATA, after `]`, at another `]`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                    ^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataClose(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n    return cdata(code);\n  }\n\n  /**\n   * In CDATA, after `]]`, at `>`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataEnd(code) {\n    if (code === 62) {\n      return end(code);\n    }\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n    return cdata(code);\n  }\n\n  /**\n   * In declaration.\n   *\n   * ```markdown\n   * > | a <!b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declaration(code) {\n    if (code === null || code === 62) {\n      return end(code);\n    }\n    if (markdownLineEnding(code)) {\n      returnState = declaration;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return declaration;\n  }\n\n  /**\n   * In instruction.\n   *\n   * ```markdown\n   * > | a <?b?> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function instruction(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 63) {\n      effects.consume(code);\n      return instructionClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = instruction;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return instruction;\n  }\n\n  /**\n   * In instruction, after `?`, at `>`.\n   *\n   * ```markdown\n   * > | a <?b?> c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function instructionClose(code) {\n    return code === 62 ? end(code) : instruction(code);\n  }\n\n  /**\n   * After `</`, in closing tag, at tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseStart(code) {\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `</x`, in a tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagClose(code) {\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n    return tagCloseBetween(code);\n  }\n\n  /**\n   * In closing tag, after tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseBetween(code) {\n    if (markdownLineEnding(code)) {\n      returnState = tagCloseBetween;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagCloseBetween;\n    }\n    return end(code);\n  }\n\n  /**\n   * After `<x`, in opening tag name.\n   *\n   * ```markdown\n   * > | a <b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpen(code) {\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In opening tag, after tag name.\n   *\n   * ```markdown\n   * > | a <b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenBetween(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return end;\n    }\n\n    // ASCII alphabetical and `:` and `_`.\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenBetween;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenBetween;\n    }\n    return end(code);\n  }\n\n  /**\n   * In attribute name.\n   *\n   * ```markdown\n   * > | a <b c> d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeName(code) {\n    // ASCII alphabetical and `-`, `.`, `:`, and `_`.\n    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n    return tagOpenAttributeNameAfter(code);\n  }\n\n  /**\n   * After attribute name, before initializer, the end of the tag, or\n   * whitespace.\n   *\n   * ```markdown\n   * > | a <b c> d\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeNameAfter;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeNameAfter;\n    }\n    return tagOpenBetween(code);\n  }\n\n  /**\n   * Before unquoted, double quoted, or single quoted attribute value, allowing\n   * whitespace.\n   *\n   * ```markdown\n   * > | a <b c=d> e\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      marker = code;\n      return tagOpenAttributeValueQuoted;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueBefore;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n    effects.consume(code);\n    return tagOpenAttributeValueUnquoted;\n  }\n\n  /**\n   * In double or single quoted attribute value.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code);\n      marker = undefined;\n      return tagOpenAttributeValueQuotedAfter;\n    }\n    if (code === null) {\n      return nok(code);\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueQuoted;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return tagOpenAttributeValueQuoted;\n  }\n\n  /**\n   * In unquoted attribute value.\n   *\n   * ```markdown\n   * > | a <b c=d> e\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueUnquoted(code) {\n    if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 96) {\n      return nok(code);\n    }\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n    effects.consume(code);\n    return tagOpenAttributeValueUnquoted;\n  }\n\n  /**\n   * After double or single quoted attribute value, before whitespace or the end\n   * of the tag.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In certain circumstances of a tag where only an `>` is allowed.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function end(code) {\n    if (code === 62) {\n      effects.consume(code);\n      effects.exit(\"htmlTextData\");\n      effects.exit(\"htmlText\");\n      return ok;\n    }\n    return nok(code);\n  }\n\n  /**\n   * At eol.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   * > | a <!--a\n   *            ^\n   *   | b-->\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingBefore(code) {\n    effects.exit(\"htmlTextData\");\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return lineEndingAfter;\n  }\n\n  /**\n   * After eol, at optional whitespace.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   *   | a <!--a\n   * > | b-->\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingAfter(code) {\n    // Always populated by defaults.\n\n    return markdownSpace(code) ? factorySpace(effects, lineEndingAfterPrefix, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code) : lineEndingAfterPrefix(code);\n  }\n\n  /**\n   * After eol, after optional whitespace.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   *   | a <!--a\n   * > | b-->\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingAfterPrefix(code) {\n    effects.enter(\"htmlTextData\");\n    return returnState(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { labelEnd } from './label-end.js';\n\n/** @type {Construct} */\nexport const labelStartLink = {\n  name: 'labelStartLink',\n  resolveAll: labelEnd.resolveAll,\n  tokenize: tokenizeLabelStartLink\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeLabelStartLink(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of label (link) start.\n   *\n   * ```markdown\n   * > | a [b] c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"labelLink\");\n    effects.enter(\"labelMarker\");\n    effects.consume(code);\n    effects.exit(\"labelMarker\");\n    effects.exit(\"labelLink\");\n    return after;\n  }\n\n  /** @type {State} */\n  function after(code) {\n    // To do: this isn’t needed in `micromark-extension-gfm-footnote`,\n    // remove.\n    // Hidden footnotes hook.\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs ? nok(code) : ok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of a hard break (escape).\n   *\n   * ```markdown\n   * > | a\\\n   *      ^\n   *   | b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"hardBreakEscape\");\n    effects.consume(code);\n    return after;\n  }\n\n  /**\n   * After `\\`, at eol.\n   *\n   * ```markdown\n   * > | a\\\n   *       ^\n   *   | b\n   * ```\n   *\n   *  @type {State}\n   */\n  function after(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit(\"hardBreakEscape\");\n      return ok(code);\n    }\n    return nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   Previous,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const codeText = {\n  name: 'codeText',\n  previous,\n  resolve: resolveCodeText,\n  tokenize: tokenizeCodeText\n};\n\n// To do: next major: don’t resolve, like `markdown-rs`.\n/** @type {Resolver} */\nfunction resolveCodeText(events) {\n  let tailExitIndex = events.length - 4;\n  let headEnterIndex = 3;\n  /** @type {number} */\n  let index;\n  /** @type {number | undefined} */\n  let enter;\n\n  // If we start and end with an EOL or a space.\n  if ((events[headEnterIndex][1].type === \"lineEnding\" || events[headEnterIndex][1].type === 'space') && (events[tailExitIndex][1].type === \"lineEnding\" || events[tailExitIndex][1].type === 'space')) {\n    index = headEnterIndex;\n\n    // And we have data.\n    while (++index < tailExitIndex) {\n      if (events[index][1].type === \"codeTextData\") {\n        // Then we have padding.\n        events[headEnterIndex][1].type = \"codeTextPadding\";\n        events[tailExitIndex][1].type = \"codeTextPadding\";\n        headEnterIndex += 2;\n        tailExitIndex -= 2;\n        break;\n      }\n    }\n  }\n\n  // Merge adjacent spaces and data.\n  index = headEnterIndex - 1;\n  tailExitIndex++;\n  while (++index <= tailExitIndex) {\n    if (enter === undefined) {\n      if (index !== tailExitIndex && events[index][1].type !== \"lineEnding\") {\n        enter = index;\n      }\n    } else if (index === tailExitIndex || events[index][1].type === \"lineEnding\") {\n      events[enter][1].type = \"codeTextData\";\n      if (index !== enter + 2) {\n        events[enter][1].end = events[index - 1][1].end;\n        events.splice(enter + 2, index - enter - 2);\n        tailExitIndex -= index - enter - 2;\n        index = enter + 2;\n      }\n      enter = undefined;\n    }\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Previous}\n */\nfunction previous(code) {\n  // If there is a previous code, there will always be a tail.\n  return code !== 96 || this.events[this.events.length - 1][1].type === \"characterEscape\";\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCodeText(effects, ok, nok) {\n  const self = this;\n  let sizeOpen = 0;\n  /** @type {number} */\n  let size;\n  /** @type {Token} */\n  let token;\n  return start;\n\n  /**\n   * Start of code (text).\n   *\n   * ```markdown\n   * > | `a`\n   *     ^\n   * > | \\`a`\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"codeText\");\n    effects.enter(\"codeTextSequence\");\n    return sequenceOpen(code);\n  }\n\n  /**\n   * In opening sequence.\n   *\n   * ```markdown\n   * > | `a`\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === 96) {\n      effects.consume(code);\n      sizeOpen++;\n      return sequenceOpen;\n    }\n    effects.exit(\"codeTextSequence\");\n    return between(code);\n  }\n\n  /**\n   * Between something and something else.\n   *\n   * ```markdown\n   * > | `a`\n   *      ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function between(code) {\n    // EOF.\n    if (code === null) {\n      return nok(code);\n    }\n\n    // To do: next major: don’t do spaces in resolve, but when compiling,\n    // like `markdown-rs`.\n    // Tabs don’t work, and virtual spaces don’t make sense.\n    if (code === 32) {\n      effects.enter('space');\n      effects.consume(code);\n      effects.exit('space');\n      return between;\n    }\n\n    // Closing fence? Could also be data.\n    if (code === 96) {\n      token = effects.enter(\"codeTextSequence\");\n      size = 0;\n      return sequenceClose(code);\n    }\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return between;\n    }\n\n    // Data.\n    effects.enter(\"codeTextData\");\n    return data(code);\n  }\n\n  /**\n   * In data.\n   *\n   * ```markdown\n   * > | `a`\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function data(code) {\n    if (code === null || code === 32 || code === 96 || markdownLineEnding(code)) {\n      effects.exit(\"codeTextData\");\n      return between(code);\n    }\n    effects.consume(code);\n    return data;\n  }\n\n  /**\n   * In closing sequence.\n   *\n   * ```markdown\n   * > | `a`\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceClose(code) {\n    // More.\n    if (code === 96) {\n      effects.consume(code);\n      size++;\n      return sequenceClose;\n    }\n\n    // Done!\n    if (size === sizeOpen) {\n      effects.exit(\"codeTextSequence\");\n      effects.exit(\"codeText\");\n      return ok(code);\n    }\n\n    // More or less accents: mark as data.\n    token.type = \"codeTextData\";\n    return data(code);\n  }\n}","/**\n * @import {Extension} from 'micromark-util-types'\n */\n\nimport { attention, autolink, blockQuote, characterEscape, characterReference, codeFenced, codeIndented, codeText, definition, hardBreakEscape, headingAtx, htmlFlow, htmlText, labelEnd, labelStartImage, labelStartLink, lineEnding, list, setextUnderline, thematicBreak } from 'micromark-core-commonmark';\nimport { resolver as resolveText } from './initialize/text.js';\n\n/** @satisfies {Extension['document']} */\nexport const document = {\n  [42]: list,\n  [43]: list,\n  [45]: list,\n  [48]: list,\n  [49]: list,\n  [50]: list,\n  [51]: list,\n  [52]: list,\n  [53]: list,\n  [54]: list,\n  [55]: list,\n  [56]: list,\n  [57]: list,\n  [62]: blockQuote\n};\n\n/** @satisfies {Extension['contentInitial']} */\nexport const contentInitial = {\n  [91]: definition\n};\n\n/** @satisfies {Extension['flowInitial']} */\nexport const flowInitial = {\n  [-2]: codeIndented,\n  [-1]: codeIndented,\n  [32]: codeIndented\n};\n\n/** @satisfies {Extension['flow']} */\nexport const flow = {\n  [35]: headingAtx,\n  [42]: thematicBreak,\n  [45]: [setextUnderline, thematicBreak],\n  [60]: htmlFlow,\n  [61]: setextUnderline,\n  [95]: thematicBreak,\n  [96]: codeFenced,\n  [126]: codeFenced\n};\n\n/** @satisfies {Extension['string']} */\nexport const string = {\n  [38]: characterReference,\n  [92]: characterEscape\n};\n\n/** @satisfies {Extension['text']} */\nexport const text = {\n  [-5]: lineEnding,\n  [-4]: lineEnding,\n  [-3]: lineEnding,\n  [33]: labelStartImage,\n  [38]: characterReference,\n  [42]: attention,\n  [60]: [autolink, htmlText],\n  [91]: labelStartLink,\n  [92]: [hardBreakEscape, characterEscape],\n  [93]: labelEnd,\n  [95]: attention,\n  [96]: codeText\n};\n\n/** @satisfies {Extension['insideSpan']} */\nexport const insideSpan = {\n  null: [attention, resolveText]\n};\n\n/** @satisfies {Extension['attentionMarkers']} */\nexport const attentionMarkers = {\n  null: [42, 95]\n};\n\n/** @satisfies {Extension['disable']} */\nexport const disable = {\n  null: []\n};","/**\n * @import {\n *   Chunk,\n *   Code,\n *   ConstructRecord,\n *   Construct,\n *   Effects,\n *   InitialConstruct,\n *   ParseContext,\n *   Point,\n *   State,\n *   TokenizeContext,\n *   Token\n * } from 'micromark-util-types'\n */\n\n/**\n * @callback Restore\n *   Restore the state.\n * @returns {undefined}\n *   Nothing.\n *\n * @typedef Info\n *   Info.\n * @property {Restore} restore\n *   Restore.\n * @property {number} from\n *   From.\n *\n * @callback ReturnHandle\n *   Handle a successful run.\n * @param {Construct} construct\n *   Construct.\n * @param {Info} info\n *   Info.\n * @returns {undefined}\n *   Nothing.\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\nimport { push, splice } from 'micromark-util-chunked';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/**\n * Create a tokenizer.\n * Tokenizers deal with one type of data (e.g., containers, flow, text).\n * The parser is the object dealing with it all.\n * `initialize` works like other constructs, except that only its `tokenize`\n * function is used, in which case it doesn’t receive an `ok` or `nok`.\n * `from` can be given to set the point before the first character, although\n * when further lines are indented, they must be set with `defineSkip`.\n *\n * @param {ParseContext} parser\n *   Parser.\n * @param {InitialConstruct} initialize\n *   Construct.\n * @param {Omit<Point, '_bufferIndex' | '_index'> | undefined} [from]\n *   Point (optional).\n * @returns {TokenizeContext}\n *   Context.\n */\nexport function createTokenizer(parser, initialize, from) {\n  /** @type {Point} */\n  let point = {\n    _bufferIndex: -1,\n    _index: 0,\n    line: from && from.line || 1,\n    column: from && from.column || 1,\n    offset: from && from.offset || 0\n  };\n  /** @type {Record<string, number>} */\n  const columnStart = {};\n  /** @type {Array<Construct>} */\n  const resolveAllConstructs = [];\n  /** @type {Array<Chunk>} */\n  let chunks = [];\n  /** @type {Array<Token>} */\n  let stack = [];\n  /** @type {boolean | undefined} */\n  let consumed = true;\n\n  /**\n   * Tools used for tokenizing.\n   *\n   * @type {Effects}\n   */\n  const effects = {\n    attempt: constructFactory(onsuccessfulconstruct),\n    check: constructFactory(onsuccessfulcheck),\n    consume,\n    enter,\n    exit,\n    interrupt: constructFactory(onsuccessfulcheck, {\n      interrupt: true\n    })\n  };\n\n  /**\n   * State and tools for resolving and serializing.\n   *\n   * @type {TokenizeContext}\n   */\n  const context = {\n    code: null,\n    containerState: {},\n    defineSkip,\n    events: [],\n    now,\n    parser,\n    previous: null,\n    sliceSerialize,\n    sliceStream,\n    write\n  };\n\n  /**\n   * The state function.\n   *\n   * @type {State | undefined}\n   */\n  let state = initialize.tokenize.call(context, effects);\n\n  /**\n   * Track which character we expect to be consumed, to catch bugs.\n   *\n   * @type {Code}\n   */\n  let expectedCode;\n  if (initialize.resolveAll) {\n    resolveAllConstructs.push(initialize);\n  }\n  return context;\n\n  /** @type {TokenizeContext['write']} */\n  function write(slice) {\n    chunks = push(chunks, slice);\n    main();\n\n    // Exit if we’re not done, resolve might change stuff.\n    if (chunks[chunks.length - 1] !== null) {\n      return [];\n    }\n    addResult(initialize, 0);\n\n    // Otherwise, resolve, and exit.\n    context.events = resolveAll(resolveAllConstructs, context.events, context);\n    return context.events;\n  }\n\n  //\n  // Tools.\n  //\n\n  /** @type {TokenizeContext['sliceSerialize']} */\n  function sliceSerialize(token, expandTabs) {\n    return serializeChunks(sliceStream(token), expandTabs);\n  }\n\n  /** @type {TokenizeContext['sliceStream']} */\n  function sliceStream(token) {\n    return sliceChunks(chunks, token);\n  }\n\n  /** @type {TokenizeContext['now']} */\n  function now() {\n    // This is a hot path, so we clone manually instead of `Object.assign({}, point)`\n    const {\n      _bufferIndex,\n      _index,\n      line,\n      column,\n      offset\n    } = point;\n    return {\n      _bufferIndex,\n      _index,\n      line,\n      column,\n      offset\n    };\n  }\n\n  /** @type {TokenizeContext['defineSkip']} */\n  function defineSkip(value) {\n    columnStart[value.line] = value.column;\n    accountForPotentialSkip();\n  }\n\n  //\n  // State management.\n  //\n\n  /**\n   * Main loop (note that `_index` and `_bufferIndex` in `point` are modified by\n   * `consume`).\n   * Here is where we walk through the chunks, which either include strings of\n   * several characters, or numerical character codes.\n   * The reason to do this in a loop instead of a call is so the stack can\n   * drain.\n   *\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function main() {\n    /** @type {number} */\n    let chunkIndex;\n    while (point._index < chunks.length) {\n      const chunk = chunks[point._index];\n\n      // If we’re in a buffer chunk, loop through it.\n      if (typeof chunk === 'string') {\n        chunkIndex = point._index;\n        if (point._bufferIndex < 0) {\n          point._bufferIndex = 0;\n        }\n        while (point._index === chunkIndex && point._bufferIndex < chunk.length) {\n          go(chunk.charCodeAt(point._bufferIndex));\n        }\n      } else {\n        go(chunk);\n      }\n    }\n  }\n\n  /**\n   * Deal with one code.\n   *\n   * @param {Code} code\n   *   Code.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function go(code) {\n    consumed = undefined;\n    expectedCode = code;\n    state = state(code);\n  }\n\n  /** @type {Effects['consume']} */\n  function consume(code) {\n    if (markdownLineEnding(code)) {\n      point.line++;\n      point.column = 1;\n      point.offset += code === -3 ? 2 : 1;\n      accountForPotentialSkip();\n    } else if (code !== -1) {\n      point.column++;\n      point.offset++;\n    }\n\n    // Not in a string chunk.\n    if (point._bufferIndex < 0) {\n      point._index++;\n    } else {\n      point._bufferIndex++;\n\n      // At end of string chunk.\n      if (point._bufferIndex ===\n      // Points w/ non-negative `_bufferIndex` reference\n      // strings.\n      /** @type {string} */\n      chunks[point._index].length) {\n        point._bufferIndex = -1;\n        point._index++;\n      }\n    }\n\n    // Expose the previous character.\n    context.previous = code;\n\n    // Mark as consumed.\n    consumed = true;\n  }\n\n  /** @type {Effects['enter']} */\n  function enter(type, fields) {\n    /** @type {Token} */\n    // @ts-expect-error Patch instead of assign required fields to help GC.\n    const token = fields || {};\n    token.type = type;\n    token.start = now();\n    context.events.push(['enter', token, context]);\n    stack.push(token);\n    return token;\n  }\n\n  /** @type {Effects['exit']} */\n  function exit(type) {\n    const token = stack.pop();\n    token.end = now();\n    context.events.push(['exit', token, context]);\n    return token;\n  }\n\n  /**\n   * Use results.\n   *\n   * @type {ReturnHandle}\n   */\n  function onsuccessfulconstruct(construct, info) {\n    addResult(construct, info.from);\n  }\n\n  /**\n   * Discard results.\n   *\n   * @type {ReturnHandle}\n   */\n  function onsuccessfulcheck(_, info) {\n    info.restore();\n  }\n\n  /**\n   * Factory to attempt/check/interrupt.\n   *\n   * @param {ReturnHandle} onreturn\n   *   Callback.\n   * @param {{interrupt?: boolean | undefined} | undefined} [fields]\n   *   Fields.\n   */\n  function constructFactory(onreturn, fields) {\n    return hook;\n\n    /**\n     * Handle either an object mapping codes to constructs, a list of\n     * constructs, or a single construct.\n     *\n     * @param {Array<Construct> | ConstructRecord | Construct} constructs\n     *   Constructs.\n     * @param {State} returnState\n     *   State.\n     * @param {State | undefined} [bogusState]\n     *   State.\n     * @returns {State}\n     *   State.\n     */\n    function hook(constructs, returnState, bogusState) {\n      /** @type {ReadonlyArray<Construct>} */\n      let listOfConstructs;\n      /** @type {number} */\n      let constructIndex;\n      /** @type {Construct} */\n      let currentConstruct;\n      /** @type {Info} */\n      let info;\n      return Array.isArray(constructs) ? /* c8 ignore next 1 */\n      handleListOfConstructs(constructs) : 'tokenize' in constructs ?\n      // Looks like a construct.\n      handleListOfConstructs([(/** @type {Construct} */constructs)]) : handleMapOfConstructs(constructs);\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ConstructRecord} map\n       *   Constructs.\n       * @returns {State}\n       *   State.\n       */\n      function handleMapOfConstructs(map) {\n        return start;\n\n        /** @type {State} */\n        function start(code) {\n          const left = code !== null && map[code];\n          const all = code !== null && map.null;\n          const list = [\n          // To do: add more extension tests.\n          /* c8 ignore next 2 */\n          ...(Array.isArray(left) ? left : left ? [left] : []), ...(Array.isArray(all) ? all : all ? [all] : [])];\n          return handleListOfConstructs(list)(code);\n        }\n      }\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ReadonlyArray<Construct>} list\n       *   Constructs.\n       * @returns {State}\n       *   State.\n       */\n      function handleListOfConstructs(list) {\n        listOfConstructs = list;\n        constructIndex = 0;\n        if (list.length === 0) {\n          return bogusState;\n        }\n        return handleConstruct(list[constructIndex]);\n      }\n\n      /**\n       * Handle a single construct.\n       *\n       * @param {Construct} construct\n       *   Construct.\n       * @returns {State}\n       *   State.\n       */\n      function handleConstruct(construct) {\n        return start;\n\n        /** @type {State} */\n        function start(code) {\n          // To do: not needed to store if there is no bogus state, probably?\n          // Currently doesn’t work because `inspect` in document does a check\n          // w/o a bogus, which doesn’t make sense. But it does seem to help perf\n          // by not storing.\n          info = store();\n          currentConstruct = construct;\n          if (!construct.partial) {\n            context.currentConstruct = construct;\n          }\n\n          // Always populated by defaults.\n\n          if (construct.name && context.parser.constructs.disable.null.includes(construct.name)) {\n            return nok(code);\n          }\n          return construct.tokenize.call(\n          // If we do have fields, create an object w/ `context` as its\n          // prototype.\n          // This allows a “live binding”, which is needed for `interrupt`.\n          fields ? Object.assign(Object.create(context), fields) : context, effects, ok, nok)(code);\n        }\n      }\n\n      /** @type {State} */\n      function ok(code) {\n        consumed = true;\n        onreturn(currentConstruct, info);\n        return returnState;\n      }\n\n      /** @type {State} */\n      function nok(code) {\n        consumed = true;\n        info.restore();\n        if (++constructIndex < listOfConstructs.length) {\n          return handleConstruct(listOfConstructs[constructIndex]);\n        }\n        return bogusState;\n      }\n    }\n  }\n\n  /**\n   * @param {Construct} construct\n   *   Construct.\n   * @param {number} from\n   *   From.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function addResult(construct, from) {\n    if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {\n      resolveAllConstructs.push(construct);\n    }\n    if (construct.resolve) {\n      splice(context.events, from, context.events.length - from, construct.resolve(context.events.slice(from), context));\n    }\n    if (construct.resolveTo) {\n      context.events = construct.resolveTo(context.events, context);\n    }\n  }\n\n  /**\n   * Store state.\n   *\n   * @returns {Info}\n   *   Info.\n   */\n  function store() {\n    const startPoint = now();\n    const startPrevious = context.previous;\n    const startCurrentConstruct = context.currentConstruct;\n    const startEventsIndex = context.events.length;\n    const startStack = Array.from(stack);\n    return {\n      from: startEventsIndex,\n      restore\n    };\n\n    /**\n     * Restore state.\n     *\n     * @returns {undefined}\n     *   Nothing.\n     */\n    function restore() {\n      point = startPoint;\n      context.previous = startPrevious;\n      context.currentConstruct = startCurrentConstruct;\n      context.events.length = startEventsIndex;\n      stack = startStack;\n      accountForPotentialSkip();\n    }\n  }\n\n  /**\n   * Move the current point a bit forward in the line when it’s on a column\n   * skip.\n   *\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function accountForPotentialSkip() {\n    if (point.line in columnStart && point.column < 2) {\n      point.column = columnStart[point.line];\n      point.offset += columnStart[point.line] - 1;\n    }\n  }\n}\n\n/**\n * Get the chunks from a slice of chunks in the range of a token.\n *\n * @param {ReadonlyArray<Chunk>} chunks\n *   Chunks.\n * @param {Pick<Token, 'end' | 'start'>} token\n *   Token.\n * @returns {Array<Chunk>}\n *   Chunks.\n */\nfunction sliceChunks(chunks, token) {\n  const startIndex = token.start._index;\n  const startBufferIndex = token.start._bufferIndex;\n  const endIndex = token.end._index;\n  const endBufferIndex = token.end._bufferIndex;\n  /** @type {Array<Chunk>} */\n  let view;\n  if (startIndex === endIndex) {\n    // @ts-expect-error `_bufferIndex` is used on string chunks.\n    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)];\n  } else {\n    view = chunks.slice(startIndex, endIndex);\n    if (startBufferIndex > -1) {\n      const head = view[0];\n      if (typeof head === 'string') {\n        view[0] = head.slice(startBufferIndex);\n      } else {\n        view.shift();\n      }\n    }\n    if (endBufferIndex > 0) {\n      // @ts-expect-error `_bufferIndex` is used on string chunks.\n      view.push(chunks[endIndex].slice(0, endBufferIndex));\n    }\n  }\n  return view;\n}\n\n/**\n * Get the string value of a slice of chunks.\n *\n * @param {ReadonlyArray<Chunk>} chunks\n *   Chunks.\n * @param {boolean | undefined} [expandTabs=false]\n *   Whether to expand tabs (default: `false`).\n * @returns {string}\n *   Result.\n */\nfunction serializeChunks(chunks, expandTabs) {\n  let index = -1;\n  /** @type {Array<string>} */\n  const result = [];\n  /** @type {boolean | undefined} */\n  let atTab;\n  while (++index < chunks.length) {\n    const chunk = chunks[index];\n    /** @type {string} */\n    let value;\n    if (typeof chunk === 'string') {\n      value = chunk;\n    } else switch (chunk) {\n      case -5:\n        {\n          value = \"\\r\";\n          break;\n        }\n      case -4:\n        {\n          value = \"\\n\";\n          break;\n        }\n      case -3:\n        {\n          value = \"\\r\" + \"\\n\";\n          break;\n        }\n      case -2:\n        {\n          value = expandTabs ? \" \" : \"\\t\";\n          break;\n        }\n      case -1:\n        {\n          if (!expandTabs && atTab) continue;\n          value = \" \";\n          break;\n        }\n      default:\n        {\n          // Currently only replacement character.\n          value = String.fromCharCode(chunk);\n        }\n    }\n    atTab = chunk === -2;\n    result.push(value);\n  }\n  return result.join('');\n}","/**\n * @import {\n *   Create,\n *   FullNormalizedExtension,\n *   InitialConstruct,\n *   ParseContext,\n *   ParseOptions\n * } from 'micromark-util-types'\n */\n\nimport { combineExtensions } from 'micromark-util-combine-extensions';\nimport { content } from './initialize/content.js';\nimport { document } from './initialize/document.js';\nimport { flow } from './initialize/flow.js';\nimport { string, text } from './initialize/text.js';\nimport * as defaultConstructs from './constructs.js';\nimport { createTokenizer } from './create-tokenizer.js';\n\n/**\n * @param {ParseOptions | null | undefined} [options]\n *   Configuration (optional).\n * @returns {ParseContext}\n *   Parser.\n */\nexport function parse(options) {\n  const settings = options || {};\n  const constructs = /** @type {FullNormalizedExtension} */\n  combineExtensions([defaultConstructs, ...(settings.extensions || [])]);\n\n  /** @type {ParseContext} */\n  const parser = {\n    constructs,\n    content: create(content),\n    defined: [],\n    document: create(document),\n    flow: create(flow),\n    lazy: {},\n    string: create(string),\n    text: create(text)\n  };\n  return parser;\n\n  /**\n   * @param {InitialConstruct} initial\n   *   Construct to start with.\n   * @returns {Create}\n   *   Create a tokenizer.\n   */\n  function create(initial) {\n    return creator;\n    /** @type {Create} */\n    function creator(from) {\n      return createTokenizer(parser, initial, from);\n    }\n  }\n}","/**\n * @import {Chunk, Code, Encoding, Value} from 'micromark-util-types'\n */\n\n/**\n * @callback Preprocessor\n *   Preprocess a value.\n * @param {Value} value\n *   Value.\n * @param {Encoding | null | undefined} [encoding]\n *   Encoding when `value` is a typed array (optional).\n * @param {boolean | null | undefined} [end=false]\n *   Whether this is the last chunk (default: `false`).\n * @returns {Array<Chunk>}\n *   Chunks.\n */\n\nconst search = /[\\0\\t\\n\\r]/g;\n\n/**\n * @returns {Preprocessor}\n *   Preprocess a value.\n */\nexport function preprocess() {\n  let column = 1;\n  let buffer = '';\n  /** @type {boolean | undefined} */\n  let start = true;\n  /** @type {boolean | undefined} */\n  let atCarriageReturn;\n  return preprocessor;\n\n  /** @type {Preprocessor} */\n  // eslint-disable-next-line complexity\n  function preprocessor(value, encoding, end) {\n    /** @type {Array<Chunk>} */\n    const chunks = [];\n    /** @type {RegExpMatchArray | null} */\n    let match;\n    /** @type {number} */\n    let next;\n    /** @type {number} */\n    let startPosition;\n    /** @type {number} */\n    let endPosition;\n    /** @type {Code} */\n    let code;\n    value = buffer + (typeof value === 'string' ? value.toString() : new TextDecoder(encoding || undefined).decode(value));\n    startPosition = 0;\n    buffer = '';\n    if (start) {\n      // To do: `markdown-rs` actually parses BOMs (byte order mark).\n      if (value.charCodeAt(0) === 65279) {\n        startPosition++;\n      }\n      start = undefined;\n    }\n    while (startPosition < value.length) {\n      search.lastIndex = startPosition;\n      match = search.exec(value);\n      endPosition = match && match.index !== undefined ? match.index : value.length;\n      code = value.charCodeAt(endPosition);\n      if (!match) {\n        buffer = value.slice(startPosition);\n        break;\n      }\n      if (code === 10 && startPosition === endPosition && atCarriageReturn) {\n        chunks.push(-3);\n        atCarriageReturn = undefined;\n      } else {\n        if (atCarriageReturn) {\n          chunks.push(-5);\n          atCarriageReturn = undefined;\n        }\n        if (startPosition < endPosition) {\n          chunks.push(value.slice(startPosition, endPosition));\n          column += endPosition - startPosition;\n        }\n        switch (code) {\n          case 0:\n            {\n              chunks.push(65533);\n              column++;\n              break;\n            }\n          case 9:\n            {\n              next = Math.ceil(column / 4) * 4;\n              chunks.push(-2);\n              while (column++ < next) chunks.push(-1);\n              break;\n            }\n          case 10:\n            {\n              chunks.push(-4);\n              column = 1;\n              break;\n            }\n          default:\n            {\n              atCarriageReturn = true;\n              column = 1;\n            }\n        }\n      }\n      startPosition = endPosition + 1;\n    }\n    if (end) {\n      if (atCarriageReturn) chunks.push(-5);\n      if (buffer) chunks.push(buffer);\n      chunks.push(null);\n    }\n    return chunks;\n  }\n}","/**\n * Turn the number (in string form as either hexa- or plain decimal) coming from\n * a numeric character reference into a character.\n *\n * Sort of like `String.fromCodePoint(Number.parseInt(value, base))`, but makes\n * non-characters and control characters safe.\n *\n * @param {string} value\n *   Value to decode.\n * @param {number} base\n *   Numeric base.\n * @returns {string}\n *   Character.\n */\nexport function decodeNumericCharacterReference(value, base) {\n  const code = Number.parseInt(value, base);\n  if (\n  // C0 except for HT, LF, FF, CR, space.\n  code < 9 || code === 11 || code > 13 && code < 32 ||\n  // Control character (DEL) of C0, and C1 controls.\n  code > 126 && code < 160 ||\n  // Lone high surrogates and low surrogates.\n  code > 55_295 && code < 57_344 ||\n  // Noncharacters.\n  code > 64_975 && code < 65_008 || /* eslint-disable no-bitwise */\n  (code & 65_535) === 65_535 || (code & 65_535) === 65_534 || /* eslint-enable no-bitwise */\n  // Out of range\n  code > 1_114_111) {\n    return \"\\uFFFD\";\n  }\n  return String.fromCodePoint(code);\n}","import { decodeNamedCharacterReference } from 'decode-named-character-reference';\nimport { decodeNumericCharacterReference } from 'micromark-util-decode-numeric-character-reference';\nconst characterEscapeOrReference = /\\\\([!-/:-@[-`{-~])|&(#(?:\\d{1,7}|x[\\da-f]{1,6})|[\\da-z]{1,31});/gi;\n\n/**\n * Decode markdown strings (which occur in places such as fenced code info\n * strings, destinations, labels, and titles).\n *\n * The “string” content type allows character escapes and -references.\n * This decodes those.\n *\n * @param {string} value\n *   Value to decode.\n * @returns {string}\n *   Decoded value.\n */\nexport function decodeString(value) {\n  return value.replace(characterEscapeOrReference, decode);\n}\n\n/**\n * @param {string} $0\n *   Match.\n * @param {string} $1\n *   Character escape.\n * @param {string} $2\n *   Character reference.\n * @returns {string}\n *   Decoded value\n */\nfunction decode($0, $1, $2) {\n  if ($1) {\n    // Escape.\n    return $1;\n  }\n\n  // Reference.\n  const head = $2.charCodeAt(0);\n  if (head === 35) {\n    const head = $2.charCodeAt(1);\n    const hex = head === 120 || head === 88;\n    return decodeNumericCharacterReference($2.slice(hex ? 2 : 1), hex ? 16 : 10);\n  }\n  return decodeNamedCharacterReference($2) || $0;\n}","/**\n * @import {\n *   Break,\n *   Blockquote,\n *   Code,\n *   Definition,\n *   Emphasis,\n *   Heading,\n *   Html,\n *   Image,\n *   InlineCode,\n *   Link,\n *   ListItem,\n *   List,\n *   Nodes,\n *   Paragraph,\n *   PhrasingContent,\n *   ReferenceType,\n *   Root,\n *   Strong,\n *   Text,\n *   ThematicBreak\n * } from 'mdast'\n * @import {\n *   Encoding,\n *   Event,\n *   Token,\n *   Value\n * } from 'micromark-util-types'\n * @import {Point} from 'unist'\n * @import {\n *   CompileContext,\n *   CompileData,\n *   Config,\n *   Extension,\n *   Handle,\n *   OnEnterError,\n *   Options\n * } from './types.js'\n */\n\nimport { toString } from 'mdast-util-to-string';\nimport { parse, postprocess, preprocess } from 'micromark';\nimport { decodeNumericCharacterReference } from 'micromark-util-decode-numeric-character-reference';\nimport { decodeString } from 'micromark-util-decode-string';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\nimport { decodeNamedCharacterReference } from 'decode-named-character-reference';\nimport { stringifyPosition } from 'unist-util-stringify-position';\nconst own = {}.hasOwnProperty;\n\n/**\n * Turn markdown into a syntax tree.\n *\n * @overload\n * @param {Value} value\n * @param {Encoding | null | undefined} [encoding]\n * @param {Options | null | undefined} [options]\n * @returns {Root}\n *\n * @overload\n * @param {Value} value\n * @param {Options | null | undefined} [options]\n * @returns {Root}\n *\n * @param {Value} value\n *   Markdown to parse.\n * @param {Encoding | Options | null | undefined} [encoding]\n *   Character encoding for when `value` is `Buffer`.\n * @param {Options | null | undefined} [options]\n *   Configuration.\n * @returns {Root}\n *   mdast tree.\n */\nexport function fromMarkdown(value, encoding, options) {\n  if (typeof encoding !== 'string') {\n    options = encoding;\n    encoding = undefined;\n  }\n  return compiler(options)(postprocess(parse(options).document().write(preprocess()(value, encoding, true))));\n}\n\n/**\n * Note this compiler only understand complete buffering, not streaming.\n *\n * @param {Options | null | undefined} [options]\n */\nfunction compiler(options) {\n  /** @type {Config} */\n  const config = {\n    transforms: [],\n    canContainEols: ['emphasis', 'fragment', 'heading', 'paragraph', 'strong'],\n    enter: {\n      autolink: opener(link),\n      autolinkProtocol: onenterdata,\n      autolinkEmail: onenterdata,\n      atxHeading: opener(heading),\n      blockQuote: opener(blockQuote),\n      characterEscape: onenterdata,\n      characterReference: onenterdata,\n      codeFenced: opener(codeFlow),\n      codeFencedFenceInfo: buffer,\n      codeFencedFenceMeta: buffer,\n      codeIndented: opener(codeFlow, buffer),\n      codeText: opener(codeText, buffer),\n      codeTextData: onenterdata,\n      data: onenterdata,\n      codeFlowValue: onenterdata,\n      definition: opener(definition),\n      definitionDestinationString: buffer,\n      definitionLabelString: buffer,\n      definitionTitleString: buffer,\n      emphasis: opener(emphasis),\n      hardBreakEscape: opener(hardBreak),\n      hardBreakTrailing: opener(hardBreak),\n      htmlFlow: opener(html, buffer),\n      htmlFlowData: onenterdata,\n      htmlText: opener(html, buffer),\n      htmlTextData: onenterdata,\n      image: opener(image),\n      label: buffer,\n      link: opener(link),\n      listItem: opener(listItem),\n      listItemValue: onenterlistitemvalue,\n      listOrdered: opener(list, onenterlistordered),\n      listUnordered: opener(list),\n      paragraph: opener(paragraph),\n      reference: onenterreference,\n      referenceString: buffer,\n      resourceDestinationString: buffer,\n      resourceTitleString: buffer,\n      setextHeading: opener(heading),\n      strong: opener(strong),\n      thematicBreak: opener(thematicBreak)\n    },\n    exit: {\n      atxHeading: closer(),\n      atxHeadingSequence: onexitatxheadingsequence,\n      autolink: closer(),\n      autolinkEmail: onexitautolinkemail,\n      autolinkProtocol: onexitautolinkprotocol,\n      blockQuote: closer(),\n      characterEscapeValue: onexitdata,\n      characterReferenceMarkerHexadecimal: onexitcharacterreferencemarker,\n      characterReferenceMarkerNumeric: onexitcharacterreferencemarker,\n      characterReferenceValue: onexitcharacterreferencevalue,\n      characterReference: onexitcharacterreference,\n      codeFenced: closer(onexitcodefenced),\n      codeFencedFence: onexitcodefencedfence,\n      codeFencedFenceInfo: onexitcodefencedfenceinfo,\n      codeFencedFenceMeta: onexitcodefencedfencemeta,\n      codeFlowValue: onexitdata,\n      codeIndented: closer(onexitcodeindented),\n      codeText: closer(onexitcodetext),\n      codeTextData: onexitdata,\n      data: onexitdata,\n      definition: closer(),\n      definitionDestinationString: onexitdefinitiondestinationstring,\n      definitionLabelString: onexitdefinitionlabelstring,\n      definitionTitleString: onexitdefinitiontitlestring,\n      emphasis: closer(),\n      hardBreakEscape: closer(onexithardbreak),\n      hardBreakTrailing: closer(onexithardbreak),\n      htmlFlow: closer(onexithtmlflow),\n      htmlFlowData: onexitdata,\n      htmlText: closer(onexithtmltext),\n      htmlTextData: onexitdata,\n      image: closer(onexitimage),\n      label: onexitlabel,\n      labelText: onexitlabeltext,\n      lineEnding: onexitlineending,\n      link: closer(onexitlink),\n      listItem: closer(),\n      listOrdered: closer(),\n      listUnordered: closer(),\n      paragraph: closer(),\n      referenceString: onexitreferencestring,\n      resourceDestinationString: onexitresourcedestinationstring,\n      resourceTitleString: onexitresourcetitlestring,\n      resource: onexitresource,\n      setextHeading: closer(onexitsetextheading),\n      setextHeadingLineSequence: onexitsetextheadinglinesequence,\n      setextHeadingText: onexitsetextheadingtext,\n      strong: closer(),\n      thematicBreak: closer()\n    }\n  };\n  configure(config, (options || {}).mdastExtensions || []);\n\n  /** @type {CompileData} */\n  const data = {};\n  return compile;\n\n  /**\n   * Turn micromark events into an mdast tree.\n   *\n   * @param {Array<Event>} events\n   *   Events.\n   * @returns {Root}\n   *   mdast tree.\n   */\n  function compile(events) {\n    /** @type {Root} */\n    let tree = {\n      type: 'root',\n      children: []\n    };\n    /** @type {Omit<CompileContext, 'sliceSerialize'>} */\n    const context = {\n      stack: [tree],\n      tokenStack: [],\n      config,\n      enter,\n      exit,\n      buffer,\n      resume,\n      data\n    };\n    /** @type {Array<number>} */\n    const listStack = [];\n    let index = -1;\n    while (++index < events.length) {\n      // We preprocess lists to add `listItem` tokens, and to infer whether\n      // items the list itself are spread out.\n      if (events[index][1].type === \"listOrdered\" || events[index][1].type === \"listUnordered\") {\n        if (events[index][0] === 'enter') {\n          listStack.push(index);\n        } else {\n          const tail = listStack.pop();\n          index = prepareList(events, tail, index);\n        }\n      }\n    }\n    index = -1;\n    while (++index < events.length) {\n      const handler = config[events[index][0]];\n      if (own.call(handler, events[index][1].type)) {\n        handler[events[index][1].type].call(Object.assign({\n          sliceSerialize: events[index][2].sliceSerialize\n        }, context), events[index][1]);\n      }\n    }\n\n    // Handle tokens still being open.\n    if (context.tokenStack.length > 0) {\n      const tail = context.tokenStack[context.tokenStack.length - 1];\n      const handler = tail[1] || defaultOnError;\n      handler.call(context, undefined, tail[0]);\n    }\n\n    // Figure out `root` position.\n    tree.position = {\n      start: point(events.length > 0 ? events[0][1].start : {\n        line: 1,\n        column: 1,\n        offset: 0\n      }),\n      end: point(events.length > 0 ? events[events.length - 2][1].end : {\n        line: 1,\n        column: 1,\n        offset: 0\n      })\n    };\n\n    // Call transforms.\n    index = -1;\n    while (++index < config.transforms.length) {\n      tree = config.transforms[index](tree) || tree;\n    }\n    return tree;\n  }\n\n  /**\n   * @param {Array<Event>} events\n   * @param {number} start\n   * @param {number} length\n   * @returns {number}\n   */\n  function prepareList(events, start, length) {\n    let index = start - 1;\n    let containerBalance = -1;\n    let listSpread = false;\n    /** @type {Token | undefined} */\n    let listItem;\n    /** @type {number | undefined} */\n    let lineIndex;\n    /** @type {number | undefined} */\n    let firstBlankLineIndex;\n    /** @type {boolean | undefined} */\n    let atMarker;\n    while (++index <= length) {\n      const event = events[index];\n      switch (event[1].type) {\n        case \"listUnordered\":\n        case \"listOrdered\":\n        case \"blockQuote\":\n          {\n            if (event[0] === 'enter') {\n              containerBalance++;\n            } else {\n              containerBalance--;\n            }\n            atMarker = undefined;\n            break;\n          }\n        case \"lineEndingBlank\":\n          {\n            if (event[0] === 'enter') {\n              if (listItem && !atMarker && !containerBalance && !firstBlankLineIndex) {\n                firstBlankLineIndex = index;\n              }\n              atMarker = undefined;\n            }\n            break;\n          }\n        case \"linePrefix\":\n        case \"listItemValue\":\n        case \"listItemMarker\":\n        case \"listItemPrefix\":\n        case \"listItemPrefixWhitespace\":\n          {\n            // Empty.\n\n            break;\n          }\n        default:\n          {\n            atMarker = undefined;\n          }\n      }\n      if (!containerBalance && event[0] === 'enter' && event[1].type === \"listItemPrefix\" || containerBalance === -1 && event[0] === 'exit' && (event[1].type === \"listUnordered\" || event[1].type === \"listOrdered\")) {\n        if (listItem) {\n          let tailIndex = index;\n          lineIndex = undefined;\n          while (tailIndex--) {\n            const tailEvent = events[tailIndex];\n            if (tailEvent[1].type === \"lineEnding\" || tailEvent[1].type === \"lineEndingBlank\") {\n              if (tailEvent[0] === 'exit') continue;\n              if (lineIndex) {\n                events[lineIndex][1].type = \"lineEndingBlank\";\n                listSpread = true;\n              }\n              tailEvent[1].type = \"lineEnding\";\n              lineIndex = tailIndex;\n            } else if (tailEvent[1].type === \"linePrefix\" || tailEvent[1].type === \"blockQuotePrefix\" || tailEvent[1].type === \"blockQuotePrefixWhitespace\" || tailEvent[1].type === \"blockQuoteMarker\" || tailEvent[1].type === \"listItemIndent\") {\n              // Empty\n            } else {\n              break;\n            }\n          }\n          if (firstBlankLineIndex && (!lineIndex || firstBlankLineIndex < lineIndex)) {\n            listItem._spread = true;\n          }\n\n          // Fix position.\n          listItem.end = Object.assign({}, lineIndex ? events[lineIndex][1].start : event[1].end);\n          events.splice(lineIndex || index, 0, ['exit', listItem, event[2]]);\n          index++;\n          length++;\n        }\n\n        // Create a new list item.\n        if (event[1].type === \"listItemPrefix\") {\n          /** @type {Token} */\n          const item = {\n            type: 'listItem',\n            _spread: false,\n            start: Object.assign({}, event[1].start),\n            // @ts-expect-error: we’ll add `end` in a second.\n            end: undefined\n          };\n          listItem = item;\n          events.splice(index, 0, ['enter', item, event[2]]);\n          index++;\n          length++;\n          firstBlankLineIndex = undefined;\n          atMarker = true;\n        }\n      }\n    }\n    events[start][1]._spread = listSpread;\n    return length;\n  }\n\n  /**\n   * Create an opener handle.\n   *\n   * @param {(token: Token) => Nodes} create\n   *   Create a node.\n   * @param {Handle | undefined} [and]\n   *   Optional function to also run.\n   * @returns {Handle}\n   *   Handle.\n   */\n  function opener(create, and) {\n    return open;\n\n    /**\n     * @this {CompileContext}\n     * @param {Token} token\n     * @returns {undefined}\n     */\n    function open(token) {\n      enter.call(this, create(token), token);\n      if (and) and.call(this, token);\n    }\n  }\n\n  /**\n   * @type {CompileContext['buffer']}\n   */\n  function buffer() {\n    this.stack.push({\n      type: 'fragment',\n      children: []\n    });\n  }\n\n  /**\n   * @type {CompileContext['enter']}\n   */\n  function enter(node, token, errorHandler) {\n    const parent = this.stack[this.stack.length - 1];\n    /** @type {Array<Nodes>} */\n    const siblings = parent.children;\n    siblings.push(node);\n    this.stack.push(node);\n    this.tokenStack.push([token, errorHandler || undefined]);\n    node.position = {\n      start: point(token.start),\n      // @ts-expect-error: `end` will be patched later.\n      end: undefined\n    };\n  }\n\n  /**\n   * Create a closer handle.\n   *\n   * @param {Handle | undefined} [and]\n   *   Optional function to also run.\n   * @returns {Handle}\n   *   Handle.\n   */\n  function closer(and) {\n    return close;\n\n    /**\n     * @this {CompileContext}\n     * @param {Token} token\n     * @returns {undefined}\n     */\n    function close(token) {\n      if (and) and.call(this, token);\n      exit.call(this, token);\n    }\n  }\n\n  /**\n   * @type {CompileContext['exit']}\n   */\n  function exit(token, onExitError) {\n    const node = this.stack.pop();\n    const open = this.tokenStack.pop();\n    if (!open) {\n      throw new Error('Cannot close `' + token.type + '` (' + stringifyPosition({\n        start: token.start,\n        end: token.end\n      }) + '): it’s not open');\n    } else if (open[0].type !== token.type) {\n      if (onExitError) {\n        onExitError.call(this, token, open[0]);\n      } else {\n        const handler = open[1] || defaultOnError;\n        handler.call(this, token, open[0]);\n      }\n    }\n    node.position.end = point(token.end);\n  }\n\n  /**\n   * @type {CompileContext['resume']}\n   */\n  function resume() {\n    return toString(this.stack.pop());\n  }\n\n  //\n  // Handlers.\n  //\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onenterlistordered() {\n    this.data.expectingFirstListItemValue = true;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onenterlistitemvalue(token) {\n    if (this.data.expectingFirstListItemValue) {\n      const ancestor = this.stack[this.stack.length - 2];\n      ancestor.start = Number.parseInt(this.sliceSerialize(token), 10);\n      this.data.expectingFirstListItemValue = undefined;\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfenceinfo() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.lang = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfencemeta() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.meta = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfence() {\n    // Exit if this is the closing fence.\n    if (this.data.flowCodeInside) return;\n    this.buffer();\n    this.data.flowCodeInside = true;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefenced() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data.replace(/^(\\r?\\n|\\r)|(\\r?\\n|\\r)$/g, '');\n    this.data.flowCodeInside = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodeindented() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data.replace(/(\\r?\\n|\\r)$/g, '');\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitionlabelstring(token) {\n    const label = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.label = label;\n    node.identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitiontitlestring() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.title = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitiondestinationstring() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.url = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitatxheadingsequence(token) {\n    const node = this.stack[this.stack.length - 1];\n    if (!node.depth) {\n      const depth = this.sliceSerialize(token).length;\n      node.depth = depth;\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheadingtext() {\n    this.data.setextHeadingSlurpLineEnding = true;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheadinglinesequence(token) {\n    const node = this.stack[this.stack.length - 1];\n    node.depth = this.sliceSerialize(token).codePointAt(0) === 61 ? 1 : 2;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheading() {\n    this.data.setextHeadingSlurpLineEnding = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onenterdata(token) {\n    const node = this.stack[this.stack.length - 1];\n    /** @type {Array<Nodes>} */\n    const siblings = node.children;\n    let tail = siblings[siblings.length - 1];\n    if (!tail || tail.type !== 'text') {\n      // Add a new text node.\n      tail = text();\n      tail.position = {\n        start: point(token.start),\n        // @ts-expect-error: we’ll add `end` later.\n        end: undefined\n      };\n      siblings.push(tail);\n    }\n    this.stack.push(tail);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitdata(token) {\n    const tail = this.stack.pop();\n    tail.value += this.sliceSerialize(token);\n    tail.position.end = point(token.end);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlineending(token) {\n    const context = this.stack[this.stack.length - 1];\n    // If we’re at a hard break, include the line ending in there.\n    if (this.data.atHardBreak) {\n      const tail = context.children[context.children.length - 1];\n      tail.position.end = point(token.end);\n      this.data.atHardBreak = undefined;\n      return;\n    }\n    if (!this.data.setextHeadingSlurpLineEnding && config.canContainEols.includes(context.type)) {\n      onenterdata.call(this, token);\n      onexitdata.call(this, token);\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithardbreak() {\n    this.data.atHardBreak = true;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithtmlflow() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithtmltext() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitcodetext() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlink() {\n    const node = this.stack[this.stack.length - 1];\n    // Note: there are also `identifier` and `label` fields on this link node!\n    // These are used / cleaned here.\n\n    // To do: clean.\n    if (this.data.inReference) {\n      /** @type {ReferenceType} */\n      const referenceType = this.data.referenceType || 'shortcut';\n      node.type += 'Reference';\n      // @ts-expect-error: mutate.\n      node.referenceType = referenceType;\n      // @ts-expect-error: mutate.\n      delete node.url;\n      delete node.title;\n    } else {\n      // @ts-expect-error: mutate.\n      delete node.identifier;\n      // @ts-expect-error: mutate.\n      delete node.label;\n    }\n    this.data.referenceType = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitimage() {\n    const node = this.stack[this.stack.length - 1];\n    // Note: there are also `identifier` and `label` fields on this link node!\n    // These are used / cleaned here.\n\n    // To do: clean.\n    if (this.data.inReference) {\n      /** @type {ReferenceType} */\n      const referenceType = this.data.referenceType || 'shortcut';\n      node.type += 'Reference';\n      // @ts-expect-error: mutate.\n      node.referenceType = referenceType;\n      // @ts-expect-error: mutate.\n      delete node.url;\n      delete node.title;\n    } else {\n      // @ts-expect-error: mutate.\n      delete node.identifier;\n      // @ts-expect-error: mutate.\n      delete node.label;\n    }\n    this.data.referenceType = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlabeltext(token) {\n    const string = this.sliceSerialize(token);\n    const ancestor = this.stack[this.stack.length - 2];\n    // @ts-expect-error: stash this on the node, as it might become a reference\n    // later.\n    ancestor.label = decodeString(string);\n    // @ts-expect-error: same as above.\n    ancestor.identifier = normalizeIdentifier(string).toLowerCase();\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlabel() {\n    const fragment = this.stack[this.stack.length - 1];\n    const value = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    // Assume a reference.\n    this.data.inReference = true;\n    if (node.type === 'link') {\n      /** @type {Array<PhrasingContent>} */\n      const children = fragment.children;\n      node.children = children;\n    } else {\n      node.alt = value;\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresourcedestinationstring() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.url = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresourcetitlestring() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.title = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresource() {\n    this.data.inReference = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onenterreference() {\n    this.data.referenceType = 'collapsed';\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitreferencestring(token) {\n    const label = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    // @ts-expect-error: stash this on the node, as it might become a reference\n    // later.\n    node.label = label;\n    // @ts-expect-error: same as above.\n    node.identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n    this.data.referenceType = 'full';\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitcharacterreferencemarker(token) {\n    this.data.characterReferenceType = token.type;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcharacterreferencevalue(token) {\n    const data = this.sliceSerialize(token);\n    const type = this.data.characterReferenceType;\n    /** @type {string} */\n    let value;\n    if (type) {\n      value = decodeNumericCharacterReference(data, type === \"characterReferenceMarkerNumeric\" ? 10 : 16);\n      this.data.characterReferenceType = undefined;\n    } else {\n      const result = decodeNamedCharacterReference(data);\n      value = result;\n    }\n    const tail = this.stack[this.stack.length - 1];\n    tail.value += value;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcharacterreference(token) {\n    const tail = this.stack.pop();\n    tail.position.end = point(token.end);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitautolinkprotocol(token) {\n    onexitdata.call(this, token);\n    const node = this.stack[this.stack.length - 1];\n    node.url = this.sliceSerialize(token);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitautolinkemail(token) {\n    onexitdata.call(this, token);\n    const node = this.stack[this.stack.length - 1];\n    node.url = 'mailto:' + this.sliceSerialize(token);\n  }\n\n  //\n  // Creaters.\n  //\n\n  /** @returns {Blockquote} */\n  function blockQuote() {\n    return {\n      type: 'blockquote',\n      children: []\n    };\n  }\n\n  /** @returns {Code} */\n  function codeFlow() {\n    return {\n      type: 'code',\n      lang: null,\n      meta: null,\n      value: ''\n    };\n  }\n\n  /** @returns {InlineCode} */\n  function codeText() {\n    return {\n      type: 'inlineCode',\n      value: ''\n    };\n  }\n\n  /** @returns {Definition} */\n  function definition() {\n    return {\n      type: 'definition',\n      identifier: '',\n      label: null,\n      title: null,\n      url: ''\n    };\n  }\n\n  /** @returns {Emphasis} */\n  function emphasis() {\n    return {\n      type: 'emphasis',\n      children: []\n    };\n  }\n\n  /** @returns {Heading} */\n  function heading() {\n    return {\n      type: 'heading',\n      // @ts-expect-error `depth` will be set later.\n      depth: 0,\n      children: []\n    };\n  }\n\n  /** @returns {Break} */\n  function hardBreak() {\n    return {\n      type: 'break'\n    };\n  }\n\n  /** @returns {Html} */\n  function html() {\n    return {\n      type: 'html',\n      value: ''\n    };\n  }\n\n  /** @returns {Image} */\n  function image() {\n    return {\n      type: 'image',\n      title: null,\n      url: '',\n      alt: null\n    };\n  }\n\n  /** @returns {Link} */\n  function link() {\n    return {\n      type: 'link',\n      title: null,\n      url: '',\n      children: []\n    };\n  }\n\n  /**\n   * @param {Token} token\n   * @returns {List}\n   */\n  function list(token) {\n    return {\n      type: 'list',\n      ordered: token.type === 'listOrdered',\n      start: null,\n      spread: token._spread,\n      children: []\n    };\n  }\n\n  /**\n   * @param {Token} token\n   * @returns {ListItem}\n   */\n  function listItem(token) {\n    return {\n      type: 'listItem',\n      spread: token._spread,\n      checked: null,\n      children: []\n    };\n  }\n\n  /** @returns {Paragraph} */\n  function paragraph() {\n    return {\n      type: 'paragraph',\n      children: []\n    };\n  }\n\n  /** @returns {Strong} */\n  function strong() {\n    return {\n      type: 'strong',\n      children: []\n    };\n  }\n\n  /** @returns {Text} */\n  function text() {\n    return {\n      type: 'text',\n      value: ''\n    };\n  }\n\n  /** @returns {ThematicBreak} */\n  function thematicBreak() {\n    return {\n      type: 'thematicBreak'\n    };\n  }\n}\n\n/**\n * Copy a point-like value.\n *\n * @param {Point} d\n *   Point-like value.\n * @returns {Point}\n *   unist point.\n */\nfunction point(d) {\n  return {\n    line: d.line,\n    column: d.column,\n    offset: d.offset\n  };\n}\n\n/**\n * @param {Config} combined\n * @param {Array<Array<Extension> | Extension>} extensions\n * @returns {undefined}\n */\nfunction configure(combined, extensions) {\n  let index = -1;\n  while (++index < extensions.length) {\n    const value = extensions[index];\n    if (Array.isArray(value)) {\n      configure(combined, value);\n    } else {\n      extension(combined, value);\n    }\n  }\n}\n\n/**\n * @param {Config} combined\n * @param {Extension} extension\n * @returns {undefined}\n */\nfunction extension(combined, extension) {\n  /** @type {keyof Extension} */\n  let key;\n  for (key in extension) {\n    if (own.call(extension, key)) {\n      switch (key) {\n        case 'canContainEols':\n          {\n            const right = extension[key];\n            if (right) {\n              combined[key].push(...right);\n            }\n            break;\n          }\n        case 'transforms':\n          {\n            const right = extension[key];\n            if (right) {\n              combined[key].push(...right);\n            }\n            break;\n          }\n        case 'enter':\n        case 'exit':\n          {\n            const right = extension[key];\n            if (right) {\n              Object.assign(combined[key], right);\n            }\n            break;\n          }\n        // No default\n      }\n    }\n  }\n}\n\n/** @type {OnEnterError} */\nfunction defaultOnError(left, right) {\n  if (left) {\n    throw new Error('Cannot close `' + left.type + '` (' + stringifyPosition({\n      start: left.start,\n      end: left.end\n    }) + '): a different token (`' + right.type + '`, ' + stringifyPosition({\n      start: right.start,\n      end: right.end\n    }) + ') is open');\n  } else {\n    throw new Error('Cannot close document, a token (`' + right.type + '`, ' + stringifyPosition({\n      start: right.start,\n      end: right.end\n    }) + ') is still open');\n  }\n}","/**\n * @import {Event} from 'micromark-util-types'\n */\n\nimport { subtokenize } from 'micromark-util-subtokenize';\n\n/**\n * @param {Array<Event>} events\n *   Events.\n * @returns {Array<Event>}\n *   Events.\n */\nexport function postprocess(events) {\n  while (!subtokenize(events)) {\n    // Empty\n  }\n  return events;\n}","/**\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast-util-from-markdown').Options} FromMarkdownOptions\n * @typedef {import('unified').Parser<Root>} Parser\n * @typedef {import('unified').Processor<Root>} Processor\n */\n\n/**\n * @typedef {Omit<FromMarkdownOptions, 'extensions' | 'mdastExtensions'>} Options\n */\n\nimport {fromMarkdown} from 'mdast-util-from-markdown'\n\n/**\n * Aadd support for parsing from markdown.\n *\n * @param {Readonly<Options> | null | undefined} [options]\n *   Configuration (optional).\n * @returns {undefined}\n *   Nothing.\n */\nexport default function remarkParse(options) {\n  /** @type {Processor} */\n  // @ts-expect-error: TS in JSDoc generates wrong types if `this` is typed regularly.\n  const self = this\n\n  self.parser = parser\n\n  /**\n   * @type {Parser}\n   */\n  function parser(doc) {\n    return fromMarkdown(doc, {\n      ...self.data('settings'),\n      ...options,\n      // Note: these options are not in the readme.\n      // The goal is for them to be set by plugins on `data` instead of being\n      // passed by users.\n      extensions: self.data('micromarkExtensions') || [],\n      mdastExtensions: self.data('fromMarkdownExtensions') || []\n    })\n  }\n}\n","export const VOID       = -1;\nexport const PRIMITIVE  = 0;\nexport const ARRAY      = 1;\nexport const OBJECT     = 2;\nexport const DATE       = 3;\nexport const REGEXP     = 4;\nexport const MAP        = 5;\nexport const SET        = 6;\nexport const ERROR      = 7;\nexport const BIGINT     = 8;\n// export const SYMBOL = 9;\n","import {\n  VOID, PRIMITIVE,\n  ARRAY, OBJECT,\n  DATE, REGEXP, MAP, SET,\n  ERROR, BIGINT\n} from './types.js';\n\nconst env = typeof self === 'object' ? self : globalThis;\n\nconst deserializer = ($, _) => {\n  const as = (out, index) => {\n    $.set(index, out);\n    return out;\n  };\n\n  const unpair = index => {\n    if ($.has(index))\n      return $.get(index);\n\n    const [type, value] = _[index];\n    switch (type) {\n      case PRIMITIVE:\n      case VOID:\n        return as(value, index);\n      case ARRAY: {\n        const arr = as([], index);\n        for (const index of value)\n          arr.push(unpair(index));\n        return arr;\n      }\n      case OBJECT: {\n        const object = as({}, index);\n        for (const [key, index] of value)\n          object[unpair(key)] = unpair(index);\n        return object;\n      }\n      case DATE:\n        return as(new Date(value), index);\n      case REGEXP: {\n        const {source, flags} = value;\n        return as(new RegExp(source, flags), index);\n      }\n      case MAP: {\n        const map = as(new Map, index);\n        for (const [key, index] of value)\n          map.set(unpair(key), unpair(index));\n        return map;\n      }\n      case SET: {\n        const set = as(new Set, index);\n        for (const index of value)\n          set.add(unpair(index));\n        return set;\n      }\n      case ERROR: {\n        const {name, message} = value;\n        return as(new env[name](message), index);\n      }\n      case BIGINT:\n        return as(BigInt(value), index);\n      case 'BigInt':\n        return as(Object(BigInt(value)), index);\n    }\n    return as(new env[type](value), index);\n  };\n\n  return unpair;\n};\n\n/**\n * @typedef {Array<string,any>} Record a type representation\n */\n\n/**\n * Returns a deserialized value from a serialized array of Records.\n * @param {Record[]} serialized a previously serialized value.\n * @returns {any}\n */\nexport const deserialize = serialized => deserializer(new Map, serialized)(0);\n","import {\n  VOID, PRIMITIVE,\n  ARRAY, OBJECT,\n  DATE, REGEXP, MAP, SET,\n  ERROR, BIGINT\n} from './types.js';\n\nconst EMPTY = '';\n\nconst {toString} = {};\nconst {keys} = Object;\n\nconst typeOf = value => {\n  const type = typeof value;\n  if (type !== 'object' || !value)\n    return [PRIMITIVE, type];\n\n  const asString = toString.call(value).slice(8, -1);\n  switch (asString) {\n    case 'Array':\n      return [ARRAY, EMPTY];\n    case 'Object':\n      return [OBJECT, EMPTY];\n    case 'Date':\n      return [DATE, EMPTY];\n    case 'RegExp':\n      return [REGEXP, EMPTY];\n    case 'Map':\n      return [MAP, EMPTY];\n    case 'Set':\n      return [SET, EMPTY];\n  }\n\n  if (asString.includes('Array'))\n    return [ARRAY, asString];\n\n  if (asString.includes('Error'))\n    return [ERROR, asString];\n\n  return [OBJECT, asString];\n};\n\nconst shouldSkip = ([TYPE, type]) => (\n  TYPE === PRIMITIVE &&\n  (type === 'function' || type === 'symbol')\n);\n\nconst serializer = (strict, json, $, _) => {\n\n  const as = (out, value) => {\n    const index = _.push(out) - 1;\n    $.set(value, index);\n    return index;\n  };\n\n  const pair = value => {\n    if ($.has(value))\n      return $.get(value);\n\n    let [TYPE, type] = typeOf(value);\n    switch (TYPE) {\n      case PRIMITIVE: {\n        let entry = value;\n        switch (type) {\n          case 'bigint':\n            TYPE = BIGINT;\n            entry = value.toString();\n            break;\n          case 'function':\n          case 'symbol':\n            if (strict)\n              throw new TypeError('unable to serialize ' + type);\n            entry = null;\n            break;\n          case 'undefined':\n            return as([VOID], value);\n        }\n        return as([TYPE, entry], value);\n      }\n      case ARRAY: {\n        if (type)\n          return as([type, [...value]], value);\n  \n        const arr = [];\n        const index = as([TYPE, arr], value);\n        for (const entry of value)\n          arr.push(pair(entry));\n        return index;\n      }\n      case OBJECT: {\n        if (type) {\n          switch (type) {\n            case 'BigInt':\n              return as([type, value.toString()], value);\n            case 'Boolean':\n            case 'Number':\n            case 'String':\n              return as([type, value.valueOf()], value);\n          }\n        }\n\n        if (json && ('toJSON' in value))\n          return pair(value.toJSON());\n\n        const entries = [];\n        const index = as([TYPE, entries], value);\n        for (const key of keys(value)) {\n          if (strict || !shouldSkip(typeOf(value[key])))\n            entries.push([pair(key), pair(value[key])]);\n        }\n        return index;\n      }\n      case DATE:\n        return as([TYPE, value.toISOString()], value);\n      case REGEXP: {\n        const {source, flags} = value;\n        return as([TYPE, {source, flags}], value);\n      }\n      case MAP: {\n        const entries = [];\n        const index = as([TYPE, entries], value);\n        for (const [key, entry] of value) {\n          if (strict || !(shouldSkip(typeOf(key)) || shouldSkip(typeOf(entry))))\n            entries.push([pair(key), pair(entry)]);\n        }\n        return index;\n      }\n      case SET: {\n        const entries = [];\n        const index = as([TYPE, entries], value);\n        for (const entry of value) {\n          if (strict || !shouldSkip(typeOf(entry)))\n            entries.push(pair(entry));\n        }\n        return index;\n      }\n    }\n\n    const {message} = value;\n    return as([TYPE, {name: type, message}], value);\n  };\n\n  return pair;\n};\n\n/**\n * @typedef {Array<string,any>} Record a type representation\n */\n\n/**\n * Returns an array of serialized Records.\n * @param {any} value a serializable value.\n * @param {{json?: boolean, lossy?: boolean}?} options an object with a `lossy` or `json` property that,\n *  if `true`, will not throw errors on incompatible types, and behave more\n *  like JSON stringify would behave. Symbol and Function will be discarded.\n * @returns {Record[]}\n */\n export const serialize = (value, {json, lossy} = {}) => {\n  const _ = [];\n  return serializer(!(json || lossy), !!json, new Map, _)(value), _;\n};\n","import {deserialize} from './deserialize.js';\nimport {serialize} from './serialize.js';\n\n/**\n * @typedef {Array<string,any>} Record a type representation\n */\n\n/**\n * Returns an array of serialized Records.\n * @param {any} any a serializable value.\n * @param {{transfer?: any[], json?: boolean, lossy?: boolean}?} options an object with\n * a transfer option (ignored when polyfilled) and/or non standard fields that\n * fallback to the polyfill if present.\n * @returns {Record[]}\n */\nexport default typeof structuredClone === \"function\" ?\n  /* c8 ignore start */\n  (any, options) => (\n    options && ('json' in options || 'lossy' in options) ?\n      deserialize(serialize(any, options)) : structuredClone(any)\n  ) :\n  (any, options) => deserialize(serialize(any, options));\n  /* c8 ignore stop */\n\nexport {deserialize, serialize};\n","import { asciiAlphanumeric } from 'micromark-util-character';\nimport { encode } from 'micromark-util-encode';\n/**\n * Make a value safe for injection as a URL.\n *\n * This encodes unsafe characters with percent-encoding and skips already\n * encoded sequences (see `normalizeUri`).\n * Further unsafe characters are encoded as character references (see\n * `micromark-util-encode`).\n *\n * A regex of allowed protocols can be given, in which case the URL is\n * sanitized.\n * For example, `/^(https?|ircs?|mailto|xmpp)$/i` can be used for `a[href]`, or\n * `/^https?$/i` for `img[src]` (this is what `github.com` allows).\n * If the URL includes an unknown protocol (one not matched by `protocol`, such\n * as a dangerous example, `javascript:`), the value is ignored.\n *\n * @param {string | null | undefined} url\n *   URI to sanitize.\n * @param {RegExp | null | undefined} [protocol]\n *   Allowed protocols.\n * @returns {string}\n *   Sanitized URI.\n */\nexport function sanitizeUri(url, protocol) {\n  const value = encode(normalizeUri(url || ''));\n  if (!protocol) {\n    return value;\n  }\n  const colon = value.indexOf(':');\n  const questionMark = value.indexOf('?');\n  const numberSign = value.indexOf('#');\n  const slash = value.indexOf('/');\n  if (\n  // If there is no protocol, it’s relative.\n  colon < 0 ||\n  // If the first colon is after a `?`, `#`, or `/`, it’s not a protocol.\n  slash > -1 && colon > slash || questionMark > -1 && colon > questionMark || numberSign > -1 && colon > numberSign ||\n  // It is a protocol, it should be allowed.\n  protocol.test(value.slice(0, colon))) {\n    return value;\n  }\n  return '';\n}\n\n/**\n * Normalize a URL.\n *\n * Encode unsafe characters with percent-encoding, skipping already encoded\n * sequences.\n *\n * @param {string} value\n *   URI to normalize.\n * @returns {string}\n *   Normalized URI.\n */\nexport function normalizeUri(value) {\n  /** @type {Array<string>} */\n  const result = [];\n  let index = -1;\n  let start = 0;\n  let skip = 0;\n  while (++index < value.length) {\n    const code = value.charCodeAt(index);\n    /** @type {string} */\n    let replace = '';\n\n    // A correct percent encoded value.\n    if (code === 37 && asciiAlphanumeric(value.charCodeAt(index + 1)) && asciiAlphanumeric(value.charCodeAt(index + 2))) {\n      skip = 2;\n    }\n    // ASCII.\n    else if (code < 128) {\n      if (!/[!#$&-;=?-Z_a-z~]/.test(String.fromCharCode(code))) {\n        replace = String.fromCharCode(code);\n      }\n    }\n    // Astral.\n    else if (code > 55_295 && code < 57_344) {\n      const next = value.charCodeAt(index + 1);\n\n      // A correct surrogate pair.\n      if (code < 56_320 && next > 56_319 && next < 57_344) {\n        replace = String.fromCharCode(code, next);\n        skip = 1;\n      }\n      // Lone surrogate.\n      else {\n        replace = \"\\uFFFD\";\n      }\n    }\n    // Unicode.\n    else {\n      replace = String.fromCharCode(code);\n    }\n    if (replace) {\n      result.push(value.slice(start, index), encodeURIComponent(replace));\n      start = index + skip + 1;\n      replace = '';\n    }\n    if (skip) {\n      index += skip;\n      skip = 0;\n    }\n  }\n  return result.join('') + value.slice(start);\n}","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n *\n * @typedef {import('./state.js').State} State\n */\n\n/**\n * @callback FootnoteBackContentTemplate\n *   Generate content for the backreference dynamically.\n *\n *   For the following markdown:\n *\n *   ```markdown\n *   Alpha[^micromark], bravo[^micromark], and charlie[^remark].\n *\n *   [^remark]: things about remark\n *   [^micromark]: things about micromark\n *   ```\n *\n *   This function will be called with:\n *\n *   *  `0` and `0` for the backreference from `things about micromark` to\n *      `alpha`, as it is the first used definition, and the first call to it\n *   *  `0` and `1` for the backreference from `things about micromark` to\n *      `bravo`, as it is the first used definition, and the second call to it\n *   *  `1` and `0` for the backreference from `things about remark` to\n *      `charlie`, as it is the second used definition\n * @param {number} referenceIndex\n *   Index of the definition in the order that they are first referenced,\n *   0-indexed.\n * @param {number} rereferenceIndex\n *   Index of calls to the same definition, 0-indexed.\n * @returns {Array<ElementContent> | ElementContent | string}\n *   Content for the backreference when linking back from definitions to their\n *   reference.\n *\n * @callback FootnoteBackLabelTemplate\n *   Generate a back label dynamically.\n *\n *   For the following markdown:\n *\n *   ```markdown\n *   Alpha[^micromark], bravo[^micromark], and charlie[^remark].\n *\n *   [^remark]: things about remark\n *   [^micromark]: things about micromark\n *   ```\n *\n *   This function will be called with:\n *\n *   *  `0` and `0` for the backreference from `things about micromark` to\n *      `alpha`, as it is the first used definition, and the first call to it\n *   *  `0` and `1` for the backreference from `things about micromark` to\n *      `bravo`, as it is the first used definition, and the second call to it\n *   *  `1` and `0` for the backreference from `things about remark` to\n *      `charlie`, as it is the second used definition\n * @param {number} referenceIndex\n *   Index of the definition in the order that they are first referenced,\n *   0-indexed.\n * @param {number} rereferenceIndex\n *   Index of calls to the same definition, 0-indexed.\n * @returns {string}\n *   Back label to use when linking back from definitions to their reference.\n */\n\nimport structuredClone from '@ungap/structured-clone'\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Generate the default content that GitHub uses on backreferences.\n *\n * @param {number} _\n *   Index of the definition in the order that they are first referenced,\n *   0-indexed.\n * @param {number} rereferenceIndex\n *   Index of calls to the same definition, 0-indexed.\n * @returns {Array<ElementContent>}\n *   Content.\n */\nexport function defaultFootnoteBackContent(_, rereferenceIndex) {\n  /** @type {Array<ElementContent>} */\n  const result = [{type: 'text', value: '↩'}]\n\n  if (rereferenceIndex > 1) {\n    result.push({\n      type: 'element',\n      tagName: 'sup',\n      properties: {},\n      children: [{type: 'text', value: String(rereferenceIndex)}]\n    })\n  }\n\n  return result\n}\n\n/**\n * Generate the default label that GitHub uses on backreferences.\n *\n * @param {number} referenceIndex\n *   Index of the definition in the order that they are first referenced,\n *   0-indexed.\n * @param {number} rereferenceIndex\n *   Index of calls to the same definition, 0-indexed.\n * @returns {string}\n *   Label.\n */\nexport function defaultFootnoteBackLabel(referenceIndex, rereferenceIndex) {\n  return (\n    'Back to reference ' +\n    (referenceIndex + 1) +\n    (rereferenceIndex > 1 ? '-' + rereferenceIndex : '')\n  )\n}\n\n/**\n * Generate a hast footer for called footnote definitions.\n *\n * @param {State} state\n *   Info passed around.\n * @returns {Element | undefined}\n *   `section` element or `undefined`.\n */\n// eslint-disable-next-line complexity\nexport function footer(state) {\n  const clobberPrefix =\n    typeof state.options.clobberPrefix === 'string'\n      ? state.options.clobberPrefix\n      : 'user-content-'\n  const footnoteBackContent =\n    state.options.footnoteBackContent || defaultFootnoteBackContent\n  const footnoteBackLabel =\n    state.options.footnoteBackLabel || defaultFootnoteBackLabel\n  const footnoteLabel = state.options.footnoteLabel || 'Footnotes'\n  const footnoteLabelTagName = state.options.footnoteLabelTagName || 'h2'\n  const footnoteLabelProperties = state.options.footnoteLabelProperties || {\n    className: ['sr-only']\n  }\n  /** @type {Array<ElementContent>} */\n  const listItems = []\n  let referenceIndex = -1\n\n  while (++referenceIndex < state.footnoteOrder.length) {\n    const definition = state.footnoteById.get(\n      state.footnoteOrder[referenceIndex]\n    )\n\n    if (!definition) {\n      continue\n    }\n\n    const content = state.all(definition)\n    const id = String(definition.identifier).toUpperCase()\n    const safeId = normalizeUri(id.toLowerCase())\n    let rereferenceIndex = 0\n    /** @type {Array<ElementContent>} */\n    const backReferences = []\n    const counts = state.footnoteCounts.get(id)\n\n    // eslint-disable-next-line no-unmodified-loop-condition\n    while (counts !== undefined && ++rereferenceIndex <= counts) {\n      if (backReferences.length > 0) {\n        backReferences.push({type: 'text', value: ' '})\n      }\n\n      let children =\n        typeof footnoteBackContent === 'string'\n          ? footnoteBackContent\n          : footnoteBackContent(referenceIndex, rereferenceIndex)\n\n      if (typeof children === 'string') {\n        children = {type: 'text', value: children}\n      }\n\n      backReferences.push({\n        type: 'element',\n        tagName: 'a',\n        properties: {\n          href:\n            '#' +\n            clobberPrefix +\n            'fnref-' +\n            safeId +\n            (rereferenceIndex > 1 ? '-' + rereferenceIndex : ''),\n          dataFootnoteBackref: '',\n          ariaLabel:\n            typeof footnoteBackLabel === 'string'\n              ? footnoteBackLabel\n              : footnoteBackLabel(referenceIndex, rereferenceIndex),\n          className: ['data-footnote-backref']\n        },\n        children: Array.isArray(children) ? children : [children]\n      })\n    }\n\n    const tail = content[content.length - 1]\n\n    if (tail && tail.type === 'element' && tail.tagName === 'p') {\n      const tailTail = tail.children[tail.children.length - 1]\n      if (tailTail && tailTail.type === 'text') {\n        tailTail.value += ' '\n      } else {\n        tail.children.push({type: 'text', value: ' '})\n      }\n\n      tail.children.push(...backReferences)\n    } else {\n      content.push(...backReferences)\n    }\n\n    /** @type {Element} */\n    const listItem = {\n      type: 'element',\n      tagName: 'li',\n      properties: {id: clobberPrefix + 'fn-' + safeId},\n      children: state.wrap(content, true)\n    }\n\n    state.patch(definition, listItem)\n\n    listItems.push(listItem)\n  }\n\n  if (listItems.length === 0) {\n    return\n  }\n\n  return {\n    type: 'element',\n    tagName: 'section',\n    properties: {dataFootnotes: true, className: ['footnotes']},\n    children: [\n      {\n        type: 'element',\n        tagName: footnoteLabelTagName,\n        properties: {\n          ...structuredClone(footnoteLabelProperties),\n          id: 'footnote-label'\n        },\n        children: [{type: 'text', value: footnoteLabel}]\n      },\n      {type: 'text', value: '\\n'},\n      {\n        type: 'element',\n        tagName: 'ol',\n        properties: {},\n        children: state.wrap(listItems, true)\n      },\n      {type: 'text', value: '\\n'}\n    ]\n  }\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n */\n\n/**\n * @template Fn\n * @template Fallback\n * @typedef {Fn extends (value: any) => value is infer Thing ? Thing : Fallback} Predicate\n */\n\n/**\n * @callback Check\n *   Check that an arbitrary value is a node.\n * @param {unknown} this\n *   The given context.\n * @param {unknown} [node]\n *   Anything (typically a node).\n * @param {number | null | undefined} [index]\n *   The node’s position in its parent.\n * @param {Parent | null | undefined} [parent]\n *   The node’s parent.\n * @returns {boolean}\n *   Whether this is a node and passes a test.\n *\n * @typedef {Record<string, unknown> | Node} Props\n *   Object to check for equivalence.\n *\n *   Note: `Node` is included as it is common but is not indexable.\n *\n * @typedef {Array<Props | TestFunction | string> | Props | TestFunction | string | null | undefined} Test\n *   Check for an arbitrary node.\n *\n * @callback TestFunction\n *   Check if a node passes a test.\n * @param {unknown} this\n *   The given context.\n * @param {Node} node\n *   A node.\n * @param {number | undefined} [index]\n *   The node’s position in its parent.\n * @param {Parent | undefined} [parent]\n *   The node’s parent.\n * @returns {boolean | undefined | void}\n *   Whether this node passes the test.\n *\n *   Note: `void` is included until TS sees no return as `undefined`.\n */\n\n/**\n * Check if `node` is a `Node` and whether it passes the given test.\n *\n * @param {unknown} node\n *   Thing to check, typically `Node`.\n * @param {Test} test\n *   A check for a specific node.\n * @param {number | null | undefined} index\n *   The node’s position in its parent.\n * @param {Parent | null | undefined} parent\n *   The node’s parent.\n * @param {unknown} context\n *   Context object (`this`) to pass to `test` functions.\n * @returns {boolean}\n *   Whether `node` is a node and passes a test.\n */\nexport const is =\n  // Note: overloads in JSDoc can’t yet use different `@template`s.\n  /**\n   * @type {(\n   *   (<Condition extends string>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &\n   *   (<Condition extends Props>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &\n   *   (<Condition extends TestFunction>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &\n   *   ((node?: null | undefined) => false) &\n   *   ((node: unknown, test?: null | undefined, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &\n   *   ((node: unknown, test?: Test, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => boolean)\n   * )}\n   */\n  (\n    /**\n     * @param {unknown} [node]\n     * @param {Test} [test]\n     * @param {number | null | undefined} [index]\n     * @param {Parent | null | undefined} [parent]\n     * @param {unknown} [context]\n     * @returns {boolean}\n     */\n    // eslint-disable-next-line max-params\n    function (node, test, index, parent, context) {\n      const check = convert(test)\n\n      if (\n        index !== undefined &&\n        index !== null &&\n        (typeof index !== 'number' ||\n          index < 0 ||\n          index === Number.POSITIVE_INFINITY)\n      ) {\n        throw new Error('Expected positive finite index')\n      }\n\n      if (\n        parent !== undefined &&\n        parent !== null &&\n        (!is(parent) || !parent.children)\n      ) {\n        throw new Error('Expected parent node')\n      }\n\n      if (\n        (parent === undefined || parent === null) !==\n        (index === undefined || index === null)\n      ) {\n        throw new Error('Expected both parent and index')\n      }\n\n      return looksLikeANode(node)\n        ? check.call(context, node, index, parent)\n        : false\n    }\n  )\n\n/**\n * Generate an assertion from a test.\n *\n * Useful if you’re going to test many nodes, for example when creating a\n * utility where something else passes a compatible test.\n *\n * The created function is a bit faster because it expects valid input only:\n * a `node`, `index`, and `parent`.\n *\n * @param {Test} test\n *   *   when nullish, checks if `node` is a `Node`.\n *   *   when `string`, works like passing `(node) => node.type === test`.\n *   *   when `function` checks if function passed the node is true.\n *   *   when `object`, checks that all keys in test are in node, and that they have (strictly) equal values.\n *   *   when `array`, checks if any one of the subtests pass.\n * @returns {Check}\n *   An assertion.\n */\nexport const convert =\n  // Note: overloads in JSDoc can’t yet use different `@template`s.\n  /**\n   * @type {(\n   *   (<Condition extends string>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &\n   *   (<Condition extends Props>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &\n   *   (<Condition extends TestFunction>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &\n   *   ((test?: null | undefined) => (node?: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &\n   *   ((test?: Test) => Check)\n   * )}\n   */\n  (\n    /**\n     * @param {Test} [test]\n     * @returns {Check}\n     */\n    function (test) {\n      if (test === null || test === undefined) {\n        return ok\n      }\n\n      if (typeof test === 'function') {\n        return castFactory(test)\n      }\n\n      if (typeof test === 'object') {\n        return Array.isArray(test) ? anyFactory(test) : propsFactory(test)\n      }\n\n      if (typeof test === 'string') {\n        return typeFactory(test)\n      }\n\n      throw new Error('Expected function, string, or object as test')\n    }\n  )\n\n/**\n * @param {Array<Props | TestFunction | string>} tests\n * @returns {Check}\n */\nfunction anyFactory(tests) {\n  /** @type {Array<Check>} */\n  const checks = []\n  let index = -1\n\n  while (++index < tests.length) {\n    checks[index] = convert(tests[index])\n  }\n\n  return castFactory(any)\n\n  /**\n   * @this {unknown}\n   * @type {TestFunction}\n   */\n  function any(...parameters) {\n    let index = -1\n\n    while (++index < checks.length) {\n      if (checks[index].apply(this, parameters)) return true\n    }\n\n    return false\n  }\n}\n\n/**\n * Turn an object into a test for a node with a certain fields.\n *\n * @param {Props} check\n * @returns {Check}\n */\nfunction propsFactory(check) {\n  const checkAsRecord = /** @type {Record<string, unknown>} */ (check)\n\n  return castFactory(all)\n\n  /**\n   * @param {Node} node\n   * @returns {boolean}\n   */\n  function all(node) {\n    const nodeAsRecord = /** @type {Record<string, unknown>} */ (\n      /** @type {unknown} */ (node)\n    )\n\n    /** @type {string} */\n    let key\n\n    for (key in check) {\n      if (nodeAsRecord[key] !== checkAsRecord[key]) return false\n    }\n\n    return true\n  }\n}\n\n/**\n * Turn a string into a test for a node with a certain type.\n *\n * @param {string} check\n * @returns {Check}\n */\nfunction typeFactory(check) {\n  return castFactory(type)\n\n  /**\n   * @param {Node} node\n   */\n  function type(node) {\n    return node && node.type === check\n  }\n}\n\n/**\n * Turn a custom test into a test for a node that passes that test.\n *\n * @param {TestFunction} testFunction\n * @returns {Check}\n */\nfunction castFactory(testFunction) {\n  return check\n\n  /**\n   * @this {unknown}\n   * @type {Check}\n   */\n  function check(value, index, parent) {\n    return Boolean(\n      looksLikeANode(value) &&\n        testFunction.call(\n          this,\n          value,\n          typeof index === 'number' ? index : undefined,\n          parent || undefined\n        )\n    )\n  }\n}\n\nfunction ok() {\n  return true\n}\n\n/**\n * @param {unknown} value\n * @returns {value is Node}\n */\nfunction looksLikeANode(value) {\n  return value !== null && typeof value === 'object' && 'type' in value\n}\n","/**\n * @typedef {import('unist').Node} UnistNode\n * @typedef {import('unist').Parent} UnistParent\n */\n\n/**\n * @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test\n *   Test from `unist-util-is`.\n *\n *   Note: we have remove and add `undefined`, because otherwise when generating\n *   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,\n *   which doesn’t work when publishing on npm.\n */\n\n/**\n * @typedef {(\n *   Fn extends (value: any) => value is infer Thing\n *   ? Thing\n *   : Fallback\n * )} Predicate\n *   Get the value of a type guard `Fn`.\n * @template Fn\n *   Value; typically function that is a type guard (such as `(x): x is Y`).\n * @template Fallback\n *   Value to yield if `Fn` is not a type guard.\n */\n\n/**\n * @typedef {(\n *   Check extends null | undefined // No test.\n *   ? Value\n *   : Value extends {type: Check} // String (type) test.\n *   ? Value\n *   : Value extends Check // Partial test.\n *   ? Value\n *   : Check extends Function // Function test.\n *   ? Predicate<Check, Value> extends Value\n *     ? Predicate<Check, Value>\n *     : never\n *   : never // Some other test?\n * )} MatchesOne\n *   Check whether a node matches a primitive check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test, but not arrays.\n */\n\n/**\n * @typedef {(\n *   Check extends Array<any>\n *   ? MatchesOne<Value, Check[keyof Check]>\n *   : MatchesOne<Value, Check>\n * )} Matches\n *   Check whether a node matches a check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test.\n */\n\n/**\n * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint\n *   Number; capped reasonably.\n */\n\n/**\n * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment\n *   Increment a number in the type system.\n * @template {Uint} [I=0]\n *   Index.\n */\n\n/**\n * @typedef {(\n *   Node extends UnistParent\n *   ? Node extends {children: Array<infer Children>}\n *     ? Child extends Children ? Node : never\n *     : never\n *   : never\n * )} InternalParent\n *   Collect nodes that can be parents of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent\n *   Collect nodes in `Tree` that can be parents of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Depth extends Max\n *   ? never\n *   :\n *     | InternalParent<Node, Child>\n *     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>\n * )} InternalAncestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {InternalAncestor<InclusiveDescendant<Tree>, Child>} Ancestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Tree extends UnistParent\n *     ? Depth extends Max\n *       ? Tree\n *       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>\n *     : Tree\n * )} InclusiveDescendant\n *   Collect all (inclusive) descendants of `Tree`.\n *\n *   > 👉 **Note**: for performance reasons, this seems to be the fastest way to\n *   > recurse without actually running into an infinite loop, which the\n *   > previous version did.\n *   >\n *   > Practically, a max of `2` is typically enough assuming a `Root` is\n *   > passed, but it doesn’t improve performance.\n *   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.\n *   > Using up to `10` doesn’t hurt or help either.\n * @template {UnistNode} Tree\n *   Tree type.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {'skip' | boolean} Action\n *   Union of the action types.\n *\n * @typedef {number} Index\n *   Move to the sibling at `index` next (after node itself is completely\n *   traversed).\n *\n *   Useful if mutating the tree, such as removing the node the visitor is\n *   currently on, or any of its previous siblings.\n *   Results less than 0 or greater than or equal to `children.length` stop\n *   traversing the parent.\n *\n * @typedef {[(Action | null | undefined | void)?, (Index | null | undefined)?]} ActionTuple\n *   List with one or two values, the first an action, the second an index.\n *\n * @typedef {Action | ActionTuple | Index | null | undefined | void} VisitorResult\n *   Any value that can be returned from a visitor.\n */\n\n/**\n * @callback Visitor\n *   Handle a node (matching `test`, if given).\n *\n *   Visitors are free to transform `node`.\n *   They can also transform the parent of node (the last of `ancestors`).\n *\n *   Replacing `node` itself, if `SKIP` is not returned, still causes its\n *   descendants to be walked (which is a bug).\n *\n *   When adding or removing previous siblings of `node` (or next siblings, in\n *   case of reverse), the `Visitor` should return a new `Index` to specify the\n *   sibling to traverse after `node` is traversed.\n *   Adding or removing next siblings of `node` (or previous siblings, in case\n *   of reverse) is handled as expected without needing to return a new `Index`.\n *\n *   Removing the children property of an ancestor still results in them being\n *   traversed.\n * @param {Visited} node\n *   Found node.\n * @param {Array<VisitedParents>} ancestors\n *   Ancestors of `node`.\n * @returns {VisitorResult}\n *   What to do next.\n *\n *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.\n *   An `Action` is treated as a tuple of `[Action]`.\n *\n *   Passing a tuple back only makes sense if the `Action` is `SKIP`.\n *   When the `Action` is `EXIT`, that action can be returned.\n *   When the `Action` is `CONTINUE`, `Index` can be returned.\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [VisitedParents=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @typedef {Visitor<Matches<InclusiveDescendant<Tree>, Check>, Ancestor<Tree, Matches<InclusiveDescendant<Tree>, Check>>>} BuildVisitor\n *   Build a typed `Visitor` function from a tree and a test.\n *\n *   It will infer which values are passed as `node` and which as `parents`.\n * @template {UnistNode} [Tree=UnistNode]\n *   Tree type.\n * @template {Test} [Check=Test]\n *   Test type.\n */\n\nimport {convert} from 'unist-util-is'\nimport {color} from 'unist-util-visit-parents/do-not-use-color'\n\n/** @type {Readonly<ActionTuple>} */\nconst empty = []\n\n/**\n * Continue traversing as normal.\n */\nexport const CONTINUE = true\n\n/**\n * Stop traversing immediately.\n */\nexport const EXIT = false\n\n/**\n * Do not traverse this node’s children.\n */\nexport const SKIP = 'skip'\n\n/**\n * Visit nodes, with ancestral information.\n *\n * This algorithm performs *depth-first* *tree traversal* in *preorder*\n * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).\n *\n * You can choose for which nodes `visitor` is called by passing a `test`.\n * For complex tests, you should test yourself in `visitor`, as it will be\n * faster and will have improved type information.\n *\n * Walking the tree is an intensive task.\n * Make use of the return values of the visitor when possible.\n * Instead of walking a tree multiple times, walk it once, use `unist-util-is`\n * to check if a node matches, and then perform different operations.\n *\n * You can change the tree.\n * See `Visitor` for more info.\n *\n * @overload\n * @param {Tree} tree\n * @param {Check} check\n * @param {BuildVisitor<Tree, Check>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @overload\n * @param {Tree} tree\n * @param {BuildVisitor<Tree>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @param {UnistNode} tree\n *   Tree to traverse.\n * @param {Visitor | Test} test\n *   `unist-util-is`-compatible test\n * @param {Visitor | boolean | null | undefined} [visitor]\n *   Handle each node.\n * @param {boolean | null | undefined} [reverse]\n *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).\n * @returns {undefined}\n *   Nothing.\n *\n * @template {UnistNode} Tree\n *   Node type.\n * @template {Test} Check\n *   `unist-util-is`-compatible test.\n */\nexport function visitParents(tree, test, visitor, reverse) {\n  /** @type {Test} */\n  let check\n\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor\n    // @ts-expect-error no visitor given, so `visitor` is test.\n    visitor = test\n  } else {\n    // @ts-expect-error visitor given, so `test` isn’t a visitor.\n    check = test\n  }\n\n  const is = convert(check)\n  const step = reverse ? -1 : 1\n\n  factory(tree, undefined, [])()\n\n  /**\n   * @param {UnistNode} node\n   * @param {number | undefined} index\n   * @param {Array<UnistParent>} parents\n   */\n  function factory(node, index, parents) {\n    const value = /** @type {Record<string, unknown>} */ (\n      node && typeof node === 'object' ? node : {}\n    )\n\n    if (typeof value.type === 'string') {\n      const name =\n        // `hast`\n        typeof value.tagName === 'string'\n          ? value.tagName\n          : // `xast`\n          typeof value.name === 'string'\n          ? value.name\n          : undefined\n\n      Object.defineProperty(visit, 'name', {\n        value:\n          'node (' + color(node.type + (name ? '<' + name + '>' : '')) + ')'\n      })\n    }\n\n    return visit\n\n    function visit() {\n      /** @type {Readonly<ActionTuple>} */\n      let result = empty\n      /** @type {Readonly<ActionTuple>} */\n      let subresult\n      /** @type {number} */\n      let offset\n      /** @type {Array<UnistParent>} */\n      let grandparents\n\n      if (!test || is(node, index, parents[parents.length - 1] || undefined)) {\n        // @ts-expect-error: `visitor` is now a visitor.\n        result = toResult(visitor(node, parents))\n\n        if (result[0] === EXIT) {\n          return result\n        }\n      }\n\n      if ('children' in node && node.children) {\n        const nodeAsParent = /** @type {UnistParent} */ (node)\n\n        if (nodeAsParent.children && result[0] !== SKIP) {\n          offset = (reverse ? nodeAsParent.children.length : -1) + step\n          grandparents = parents.concat(nodeAsParent)\n\n          while (offset > -1 && offset < nodeAsParent.children.length) {\n            const child = nodeAsParent.children[offset]\n\n            subresult = factory(child, offset, grandparents)()\n\n            if (subresult[0] === EXIT) {\n              return subresult\n            }\n\n            offset =\n              typeof subresult[1] === 'number' ? subresult[1] : offset + step\n          }\n        }\n      }\n\n      return result\n    }\n  }\n}\n\n/**\n * Turn a return value into a clean result.\n *\n * @param {VisitorResult} value\n *   Valid return values from visitors.\n * @returns {Readonly<ActionTuple>}\n *   Clean result.\n */\nfunction toResult(value) {\n  if (Array.isArray(value)) {\n    return value\n  }\n\n  if (typeof value === 'number') {\n    return [CONTINUE, value]\n  }\n\n  return value === null || value === undefined ? empty : [value]\n}\n","/**\n * @typedef {import('unist').Node} UnistNode\n * @typedef {import('unist').Parent} UnistParent\n * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult\n */\n\n/**\n * @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test\n *   Test from `unist-util-is`.\n *\n *   Note: we have remove and add `undefined`, because otherwise when generating\n *   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,\n *   which doesn’t work when publishing on npm.\n */\n\n// To do: use types from `unist-util-visit-parents` when it’s released.\n\n/**\n * @typedef {(\n *   Fn extends (value: any) => value is infer Thing\n *   ? Thing\n *   : Fallback\n * )} Predicate\n *   Get the value of a type guard `Fn`.\n * @template Fn\n *   Value; typically function that is a type guard (such as `(x): x is Y`).\n * @template Fallback\n *   Value to yield if `Fn` is not a type guard.\n */\n\n/**\n * @typedef {(\n *   Check extends null | undefined // No test.\n *   ? Value\n *   : Value extends {type: Check} // String (type) test.\n *   ? Value\n *   : Value extends Check // Partial test.\n *   ? Value\n *   : Check extends Function // Function test.\n *   ? Predicate<Check, Value> extends Value\n *     ? Predicate<Check, Value>\n *     : never\n *   : never // Some other test?\n * )} MatchesOne\n *   Check whether a node matches a primitive check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test, but not arrays.\n */\n\n/**\n * @typedef {(\n *   Check extends Array<any>\n *   ? MatchesOne<Value, Check[keyof Check]>\n *   : MatchesOne<Value, Check>\n * )} Matches\n *   Check whether a node matches a check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test.\n */\n\n/**\n * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint\n *   Number; capped reasonably.\n */\n\n/**\n * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment\n *   Increment a number in the type system.\n * @template {Uint} [I=0]\n *   Index.\n */\n\n/**\n * @typedef {(\n *   Node extends UnistParent\n *   ? Node extends {children: Array<infer Children>}\n *     ? Child extends Children ? Node : never\n *     : never\n *   : never\n * )} InternalParent\n *   Collect nodes that can be parents of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent\n *   Collect nodes in `Tree` that can be parents of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Depth extends Max\n *   ? never\n *   :\n *     | InternalParent<Node, Child>\n *     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>\n * )} InternalAncestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {(\n *   Tree extends UnistParent\n *     ? Depth extends Max\n *       ? Tree\n *       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>\n *     : Tree\n * )} InclusiveDescendant\n *   Collect all (inclusive) descendants of `Tree`.\n *\n *   > 👉 **Note**: for performance reasons, this seems to be the fastest way to\n *   > recurse without actually running into an infinite loop, which the\n *   > previous version did.\n *   >\n *   > Practically, a max of `2` is typically enough assuming a `Root` is\n *   > passed, but it doesn’t improve performance.\n *   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.\n *   > Using up to `10` doesn’t hurt or help either.\n * @template {UnistNode} Tree\n *   Tree type.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @callback Visitor\n *   Handle a node (matching `test`, if given).\n *\n *   Visitors are free to transform `node`.\n *   They can also transform `parent`.\n *\n *   Replacing `node` itself, if `SKIP` is not returned, still causes its\n *   descendants to be walked (which is a bug).\n *\n *   When adding or removing previous siblings of `node` (or next siblings, in\n *   case of reverse), the `Visitor` should return a new `Index` to specify the\n *   sibling to traverse after `node` is traversed.\n *   Adding or removing next siblings of `node` (or previous siblings, in case\n *   of reverse) is handled as expected without needing to return a new `Index`.\n *\n *   Removing the children property of `parent` still results in them being\n *   traversed.\n * @param {Visited} node\n *   Found node.\n * @param {Visited extends UnistNode ? number | undefined : never} index\n *   Index of `node` in `parent`.\n * @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent\n *   Parent of `node`.\n * @returns {VisitorResult}\n *   What to do next.\n *\n *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.\n *   An `Action` is treated as a tuple of `[Action]`.\n *\n *   Passing a tuple back only makes sense if the `Action` is `SKIP`.\n *   When the `Action` is `EXIT`, that action can be returned.\n *   When the `Action` is `CONTINUE`, `Index` can be returned.\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [Ancestor=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @typedef {Visitor<Visited, Parent<Ancestor, Visited>>} BuildVisitorFromMatch\n *   Build a typed `Visitor` function from a node and all possible parents.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} Visited\n *   Node type.\n * @template {UnistParent} Ancestor\n *   Parent type.\n */\n\n/**\n * @typedef {(\n *   BuildVisitorFromMatch<\n *     Matches<Descendant, Check>,\n *     Extract<Descendant, UnistParent>\n *   >\n * )} BuildVisitorFromDescendants\n *   Build a typed `Visitor` function from a list of descendants and a test.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} Descendant\n *   Node type.\n * @template {Test} Check\n *   Test type.\n */\n\n/**\n * @typedef {(\n *   BuildVisitorFromDescendants<\n *     InclusiveDescendant<Tree>,\n *     Check\n *   >\n * )} BuildVisitor\n *   Build a typed `Visitor` function from a tree and a test.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} [Tree=UnistNode]\n *   Node type.\n * @template {Test} [Check=Test]\n *   Test type.\n */\n\nimport {visitParents} from 'unist-util-visit-parents'\n\nexport {CONTINUE, EXIT, SKIP} from 'unist-util-visit-parents'\n\n/**\n * Visit nodes.\n *\n * This algorithm performs *depth-first* *tree traversal* in *preorder*\n * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).\n *\n * You can choose for which nodes `visitor` is called by passing a `test`.\n * For complex tests, you should test yourself in `visitor`, as it will be\n * faster and will have improved type information.\n *\n * Walking the tree is an intensive task.\n * Make use of the return values of the visitor when possible.\n * Instead of walking a tree multiple times, walk it once, use `unist-util-is`\n * to check if a node matches, and then perform different operations.\n *\n * You can change the tree.\n * See `Visitor` for more info.\n *\n * @overload\n * @param {Tree} tree\n * @param {Check} check\n * @param {BuildVisitor<Tree, Check>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @overload\n * @param {Tree} tree\n * @param {BuildVisitor<Tree>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @param {UnistNode} tree\n *   Tree to traverse.\n * @param {Visitor | Test} testOrVisitor\n *   `unist-util-is`-compatible test (optional, omit to pass a visitor).\n * @param {Visitor | boolean | null | undefined} [visitorOrReverse]\n *   Handle each node (when test is omitted, pass `reverse`).\n * @param {boolean | null | undefined} [maybeReverse=false]\n *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).\n * @returns {undefined}\n *   Nothing.\n *\n * @template {UnistNode} Tree\n *   Node type.\n * @template {Test} Check\n *   `unist-util-is`-compatible test.\n */\nexport function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {\n  /** @type {boolean | null | undefined} */\n  let reverse\n  /** @type {Test} */\n  let test\n  /** @type {Visitor} */\n  let visitor\n\n  if (\n    typeof testOrVisitor === 'function' &&\n    typeof visitorOrReverse !== 'function'\n  ) {\n    test = undefined\n    visitor = testOrVisitor\n    reverse = visitorOrReverse\n  } else {\n    // @ts-expect-error: assume the overload with test was given.\n    test = testOrVisitor\n    // @ts-expect-error: assume the overload with test was given.\n    visitor = visitorOrReverse\n    reverse = maybeReverse\n  }\n\n  visitParents(tree, test, overload, reverse)\n\n  /**\n   * @param {UnistNode} node\n   * @param {Array<UnistParent>} parents\n   */\n  function overload(node, parents) {\n    const parent = parents[parents.length - 1]\n    const index = parent ? parent.children.indexOf(node) : undefined\n    return visitor(node, index, parent)\n  }\n}\n","/**\n * @typedef {import('hast').ElementContent} ElementContent\n *\n * @typedef {import('mdast').Nodes} Nodes\n * @typedef {import('mdast').Reference} Reference\n *\n * @typedef {import('./state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Return the content of a reference without definition as plain text.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Extract<Nodes, Reference>} node\n *   Reference node (image, link).\n * @returns {Array<ElementContent>}\n *   hast content.\n */\nexport function revert(state, node) {\n  const subtype = node.referenceType\n  let suffix = ']'\n\n  if (subtype === 'collapsed') {\n    suffix += '[]'\n  } else if (subtype === 'full') {\n    suffix += '[' + (node.label || node.identifier) + ']'\n  }\n\n  if (node.type === 'imageReference') {\n    return [{type: 'text', value: '![' + node.alt + suffix}]\n  }\n\n  const contents = state.all(node)\n  const head = contents[0]\n\n  if (head && head.type === 'text') {\n    head.value = '[' + head.value\n  } else {\n    contents.unshift({type: 'text', value: '['})\n  }\n\n  const tail = contents[contents.length - 1]\n\n  if (tail && tail.type === 'text') {\n    tail.value += suffix\n  } else {\n    contents.push({type: 'text', value: suffix})\n  }\n\n  return contents\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `listItem` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {ListItem} node\n *   mdast node.\n * @param {Parents | undefined} parent\n *   Parent of `node`.\n * @returns {Element}\n *   hast node.\n */\nexport function listItem(state, node, parent) {\n  const results = state.all(node)\n  const loose = parent ? listLoose(parent) : listItemLoose(node)\n  /** @type {Properties} */\n  const properties = {}\n  /** @type {Array<ElementContent>} */\n  const children = []\n\n  if (typeof node.checked === 'boolean') {\n    const head = results[0]\n    /** @type {Element} */\n    let paragraph\n\n    if (head && head.type === 'element' && head.tagName === 'p') {\n      paragraph = head\n    } else {\n      paragraph = {type: 'element', tagName: 'p', properties: {}, children: []}\n      results.unshift(paragraph)\n    }\n\n    if (paragraph.children.length > 0) {\n      paragraph.children.unshift({type: 'text', value: ' '})\n    }\n\n    paragraph.children.unshift({\n      type: 'element',\n      tagName: 'input',\n      properties: {type: 'checkbox', checked: node.checked, disabled: true},\n      children: []\n    })\n\n    // According to github-markdown-css, this class hides bullet.\n    // See: <https://github.com/sindresorhus/github-markdown-css>.\n    properties.className = ['task-list-item']\n  }\n\n  let index = -1\n\n  while (++index < results.length) {\n    const child = results[index]\n\n    // Add eols before nodes, except if this is a loose, first paragraph.\n    if (\n      loose ||\n      index !== 0 ||\n      child.type !== 'element' ||\n      child.tagName !== 'p'\n    ) {\n      children.push({type: 'text', value: '\\n'})\n    }\n\n    if (child.type === 'element' && child.tagName === 'p' && !loose) {\n      children.push(...child.children)\n    } else {\n      children.push(child)\n    }\n  }\n\n  const tail = results[results.length - 1]\n\n  // Add a final eol.\n  if (tail && (loose || tail.type !== 'element' || tail.tagName !== 'p')) {\n    children.push({type: 'text', value: '\\n'})\n  }\n\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'li', properties, children}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n\n/**\n * @param {Parents} node\n * @return {Boolean}\n */\nfunction listLoose(node) {\n  let loose = false\n  if (node.type === 'list') {\n    loose = node.spread || false\n    const children = node.children\n    let index = -1\n\n    while (!loose && ++index < children.length) {\n      loose = listItemLoose(children[index])\n    }\n  }\n\n  return loose\n}\n\n/**\n * @param {ListItem} node\n * @return {Boolean}\n */\nfunction listItemLoose(node) {\n  const spread = node.spread\n\n  return spread === null || spread === undefined\n    ? node.children.length > 1\n    : spread\n}\n","const tab = 9 /* `\\t` */\nconst space = 32 /* ` ` */\n\n/**\n * Remove initial and final spaces and tabs at the line breaks in `value`.\n * Does not trim initial and final spaces and tabs of the value itself.\n *\n * @param {string} value\n *   Value to trim.\n * @returns {string}\n *   Trimmed value.\n */\nexport function trimLines(value) {\n  const source = String(value)\n  const search = /\\r?\\n|\\r/g\n  let match = search.exec(source)\n  let last = 0\n  /** @type {Array<string>} */\n  const lines = []\n\n  while (match) {\n    lines.push(\n      trimLine(source.slice(last, match.index), last > 0, true),\n      match[0]\n    )\n\n    last = match.index + match[0].length\n    match = search.exec(source)\n  }\n\n  lines.push(trimLine(source.slice(last), last > 0, false))\n\n  return lines.join('')\n}\n\n/**\n * @param {string} value\n *   Line to trim.\n * @param {boolean} start\n *   Whether to trim the start of the line.\n * @param {boolean} end\n *   Whether to trim the end of the line.\n * @returns {string}\n *   Trimmed line.\n */\nfunction trimLine(value, start, end) {\n  let startIndex = 0\n  let endIndex = value.length\n\n  if (start) {\n    let code = value.codePointAt(startIndex)\n\n    while (code === tab || code === space) {\n      startIndex++\n      code = value.codePointAt(startIndex)\n    }\n  }\n\n  if (end) {\n    let code = value.codePointAt(endIndex - 1)\n\n    while (code === tab || code === space) {\n      endIndex--\n      code = value.codePointAt(endIndex - 1)\n    }\n  }\n\n  return endIndex > startIndex ? value.slice(startIndex, endIndex) : ''\n}\n","import {blockquote} from './blockquote.js'\nimport {hardBreak} from './break.js'\nimport {code} from './code.js'\nimport {strikethrough} from './delete.js'\nimport {emphasis} from './emphasis.js'\nimport {footnoteReference} from './footnote-reference.js'\nimport {heading} from './heading.js'\nimport {html} from './html.js'\nimport {imageReference} from './image-reference.js'\nimport {image} from './image.js'\nimport {inlineCode} from './inline-code.js'\nimport {linkReference} from './link-reference.js'\nimport {link} from './link.js'\nimport {listItem} from './list-item.js'\nimport {list} from './list.js'\nimport {paragraph} from './paragraph.js'\nimport {root} from './root.js'\nimport {strong} from './strong.js'\nimport {table} from './table.js'\nimport {tableRow} from './table-row.js'\nimport {tableCell} from './table-cell.js'\nimport {text} from './text.js'\nimport {thematicBreak} from './thematic-break.js'\n\n/**\n * Default handlers for nodes.\n *\n * @satisfies {import('../state.js').Handlers}\n */\nexport const handlers = {\n  blockquote,\n  break: hardBreak,\n  code,\n  delete: strikethrough,\n  emphasis,\n  footnoteReference,\n  heading,\n  html,\n  imageReference,\n  image,\n  inlineCode,\n  linkReference,\n  link,\n  listItem,\n  list,\n  paragraph,\n  // @ts-expect-error: root is different, but hard to type.\n  root,\n  strong,\n  table,\n  tableCell,\n  tableRow,\n  text,\n  thematicBreak,\n  toml: ignore,\n  yaml: ignore,\n  definition: ignore,\n  footnoteDefinition: ignore\n}\n\n// Return nothing for nodes that are ignored.\nfunction ignore() {\n  return undefined\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Blockquote} Blockquote\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `blockquote` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Blockquote} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function blockquote(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'blockquote',\n    properties: {},\n    children: state.wrap(state.all(node), true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Text} Text\n * @typedef {import('mdast').Break} Break\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `break` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Break} node\n *   mdast node.\n * @returns {Array<Element | Text>}\n *   hast element content.\n */\nexport function hardBreak(state, node) {\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'br', properties: {}, children: []}\n  state.patch(node, result)\n  return [state.applyData(node, result), {type: 'text', value: '\\n'}]\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Code} Code\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `code` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Code} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function code(state, node) {\n  const value = node.value ? node.value + '\\n' : ''\n  /** @type {Properties} */\n  const properties = {}\n\n  if (node.lang) {\n    properties.className = ['language-' + node.lang]\n  }\n\n  // Create `<code>`.\n  /** @type {Element} */\n  let result = {\n    type: 'element',\n    tagName: 'code',\n    properties,\n    children: [{type: 'text', value}]\n  }\n\n  if (node.meta) {\n    result.data = {meta: node.meta}\n  }\n\n  state.patch(node, result)\n  result = state.applyData(node, result)\n\n  // Create `<pre>`.\n  result = {type: 'element', tagName: 'pre', properties: {}, children: [result]}\n  state.patch(node, result)\n  return result\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Delete} Delete\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `delete` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Delete} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function strikethrough(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'del',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Emphasis} Emphasis\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `emphasis` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Emphasis} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function emphasis(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'em',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').FootnoteReference} FootnoteReference\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Turn an mdast `footnoteReference` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {FootnoteReference} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function footnoteReference(state, node) {\n  const clobberPrefix =\n    typeof state.options.clobberPrefix === 'string'\n      ? state.options.clobberPrefix\n      : 'user-content-'\n  const id = String(node.identifier).toUpperCase()\n  const safeId = normalizeUri(id.toLowerCase())\n  const index = state.footnoteOrder.indexOf(id)\n  /** @type {number} */\n  let counter\n\n  let reuseCounter = state.footnoteCounts.get(id)\n\n  if (reuseCounter === undefined) {\n    reuseCounter = 0\n    state.footnoteOrder.push(id)\n    counter = state.footnoteOrder.length\n  } else {\n    counter = index + 1\n  }\n\n  reuseCounter += 1\n  state.footnoteCounts.set(id, reuseCounter)\n\n  /** @type {Element} */\n  const link = {\n    type: 'element',\n    tagName: 'a',\n    properties: {\n      href: '#' + clobberPrefix + 'fn-' + safeId,\n      id:\n        clobberPrefix +\n        'fnref-' +\n        safeId +\n        (reuseCounter > 1 ? '-' + reuseCounter : ''),\n      dataFootnoteRef: true,\n      ariaDescribedBy: ['footnote-label']\n    },\n    children: [{type: 'text', value: String(counter)}]\n  }\n  state.patch(node, link)\n\n  /** @type {Element} */\n  const sup = {\n    type: 'element',\n    tagName: 'sup',\n    properties: {},\n    children: [link]\n  }\n  state.patch(node, sup)\n  return state.applyData(node, sup)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Heading} Heading\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `heading` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Heading} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function heading(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'h' + node.depth,\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Html} Html\n * @typedef {import('../state.js').State} State\n * @typedef {import('../../index.js').Raw} Raw\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `html` node into hast (`raw` node in dangerous mode, otherwise\n * nothing).\n *\n * @param {State} state\n *   Info passed around.\n * @param {Html} node\n *   mdast node.\n * @returns {Element | Raw | undefined}\n *   hast node.\n */\nexport function html(state, node) {\n  if (state.options.allowDangerousHtml) {\n    /** @type {Raw} */\n    const result = {type: 'raw', value: node.value}\n    state.patch(node, result)\n    return state.applyData(node, result)\n  }\n\n  return undefined\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').ImageReference} ImageReference\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\nimport {revert} from '../revert.js'\n\n/**\n * Turn an mdast `imageReference` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {ImageReference} node\n *   mdast node.\n * @returns {Array<ElementContent> | ElementContent}\n *   hast node.\n */\nexport function imageReference(state, node) {\n  const id = String(node.identifier).toUpperCase()\n  const definition = state.definitionById.get(id)\n\n  if (!definition) {\n    return revert(state, node)\n  }\n\n  /** @type {Properties} */\n  const properties = {src: normalizeUri(definition.url || ''), alt: node.alt}\n\n  if (definition.title !== null && definition.title !== undefined) {\n    properties.title = definition.title\n  }\n\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'img', properties, children: []}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Image} Image\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Turn an mdast `image` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Image} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function image(state, node) {\n  /** @type {Properties} */\n  const properties = {src: normalizeUri(node.url)}\n\n  if (node.alt !== null && node.alt !== undefined) {\n    properties.alt = node.alt\n  }\n\n  if (node.title !== null && node.title !== undefined) {\n    properties.title = node.title\n  }\n\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'img', properties, children: []}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Text} Text\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `inlineCode` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {InlineCode} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function inlineCode(state, node) {\n  /** @type {Text} */\n  const text = {type: 'text', value: node.value.replace(/\\r?\\n|\\r/g, ' ')}\n  state.patch(node, text)\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'code',\n    properties: {},\n    children: [text]\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').LinkReference} LinkReference\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\nimport {revert} from '../revert.js'\n\n/**\n * Turn an mdast `linkReference` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {LinkReference} node\n *   mdast node.\n * @returns {Array<ElementContent> | ElementContent}\n *   hast node.\n */\nexport function linkReference(state, node) {\n  const id = String(node.identifier).toUpperCase()\n  const definition = state.definitionById.get(id)\n\n  if (!definition) {\n    return revert(state, node)\n  }\n\n  /** @type {Properties} */\n  const properties = {href: normalizeUri(definition.url || '')}\n\n  if (definition.title !== null && definition.title !== undefined) {\n    properties.title = definition.title\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'a',\n    properties,\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Link} Link\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Turn an mdast `link` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Link} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function link(state, node) {\n  /** @type {Properties} */\n  const properties = {href: normalizeUri(node.url)}\n\n  if (node.title !== null && node.title !== undefined) {\n    properties.title = node.title\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'a',\n    properties,\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').List} List\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `list` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {List} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function list(state, node) {\n  /** @type {Properties} */\n  const properties = {}\n  const results = state.all(node)\n  let index = -1\n\n  if (typeof node.start === 'number' && node.start !== 1) {\n    properties.start = node.start\n  }\n\n  // Like GitHub, add a class for custom styling.\n  while (++index < results.length) {\n    const child = results[index]\n\n    if (\n      child.type === 'element' &&\n      child.tagName === 'li' &&\n      child.properties &&\n      Array.isArray(child.properties.className) &&\n      child.properties.className.includes('task-list-item')\n    ) {\n      properties.className = ['contains-task-list']\n      break\n    }\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: node.ordered ? 'ol' : 'ul',\n    properties,\n    children: state.wrap(results, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `paragraph` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Paragraph} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function paragraph(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'p',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Parents} HastParents\n * @typedef {import('hast').Root} HastRoot\n * @typedef {import('mdast').Root} MdastRoot\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `root` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastRoot} node\n *   mdast node.\n * @returns {HastParents}\n *   hast node.\n */\nexport function root(state, node) {\n  /** @type {HastRoot} */\n  const result = {type: 'root', children: state.wrap(state.all(node))}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Strong} Strong\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `strong` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Strong} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function strong(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'strong',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Table} Table\n * @typedef {import('../state.js').State} State\n */\n\nimport {pointEnd, pointStart} from 'unist-util-position'\n\n/**\n * Turn an mdast `table` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Table} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function table(state, node) {\n  const rows = state.all(node)\n  const firstRow = rows.shift()\n  /** @type {Array<Element>} */\n  const tableContent = []\n\n  if (firstRow) {\n    /** @type {Element} */\n    const head = {\n      type: 'element',\n      tagName: 'thead',\n      properties: {},\n      children: state.wrap([firstRow], true)\n    }\n    state.patch(node.children[0], head)\n    tableContent.push(head)\n  }\n\n  if (rows.length > 0) {\n    /** @type {Element} */\n    const body = {\n      type: 'element',\n      tagName: 'tbody',\n      properties: {},\n      children: state.wrap(rows, true)\n    }\n\n    const start = pointStart(node.children[1])\n    const end = pointEnd(node.children[node.children.length - 1])\n    if (start && end) body.position = {start, end}\n    tableContent.push(body)\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'table',\n    properties: {},\n    children: state.wrap(tableContent, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').TableCell} TableCell\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `tableCell` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {TableCell} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function tableCell(state, node) {\n  // Note: this function is normally not called: see `table-row` for how rows\n  // and their cells are compiled.\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'td', // Assume body cell.\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('mdast').TableRow} TableRow\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `tableRow` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {TableRow} node\n *   mdast node.\n * @param {Parents | undefined} parent\n *   Parent of `node`.\n * @returns {Element}\n *   hast node.\n */\nexport function tableRow(state, node, parent) {\n  const siblings = parent ? parent.children : undefined\n  // Generate a body row when without parent.\n  const rowIndex = siblings ? siblings.indexOf(node) : 1\n  const tagName = rowIndex === 0 ? 'th' : 'td'\n  // To do: option to use `style`?\n  const align = parent && parent.type === 'table' ? parent.align : undefined\n  const length = align ? align.length : node.children.length\n  let cellIndex = -1\n  /** @type {Array<ElementContent>} */\n  const cells = []\n\n  while (++cellIndex < length) {\n    // Note: can also be undefined.\n    const cell = node.children[cellIndex]\n    /** @type {Properties} */\n    const properties = {}\n    const alignValue = align ? align[cellIndex] : undefined\n\n    if (alignValue) {\n      properties.align = alignValue\n    }\n\n    /** @type {Element} */\n    let result = {type: 'element', tagName, properties, children: []}\n\n    if (cell) {\n      result.children = state.all(cell)\n      state.patch(cell, result)\n      result = state.applyData(cell, result)\n    }\n\n    cells.push(result)\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'tr',\n    properties: {},\n    children: state.wrap(cells, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} HastElement\n * @typedef {import('hast').Text} HastText\n * @typedef {import('mdast').Text} MdastText\n * @typedef {import('../state.js').State} State\n */\n\nimport {trimLines} from 'trim-lines'\n\n/**\n * Turn an mdast `text` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastText} node\n *   mdast node.\n * @returns {HastElement | HastText}\n *   hast node.\n */\nexport function text(state, node) {\n  /** @type {HastText} */\n  const result = {type: 'text', value: trimLines(String(node.value))}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').ThematicBreak} ThematicBreak\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `thematicBreak` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {ThematicBreak} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function thematicBreak(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'hr',\n    properties: {},\n    children: []\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} HastElement\n * @typedef {import('hast').ElementContent} HastElementContent\n * @typedef {import('hast').Nodes} HastNodes\n * @typedef {import('hast').Properties} HastProperties\n * @typedef {import('hast').RootContent} HastRootContent\n * @typedef {import('hast').Text} HastText\n *\n * @typedef {import('mdast').Definition} MdastDefinition\n * @typedef {import('mdast').FootnoteDefinition} MdastFootnoteDefinition\n * @typedef {import('mdast').Nodes} MdastNodes\n * @typedef {import('mdast').Parents} MdastParents\n *\n * @typedef {import('vfile').VFile} VFile\n *\n * @typedef {import('./footer.js').FootnoteBackContentTemplate} FootnoteBackContentTemplate\n * @typedef {import('./footer.js').FootnoteBackLabelTemplate} FootnoteBackLabelTemplate\n */\n\n/**\n * @callback Handler\n *   Handle a node.\n * @param {State} state\n *   Info passed around.\n * @param {any} node\n *   mdast node to handle.\n * @param {MdastParents | undefined} parent\n *   Parent of `node`.\n * @returns {Array<HastElementContent> | HastElementContent | undefined}\n *   hast node.\n *\n * @typedef {Partial<Record<MdastNodes['type'], Handler>>} Handlers\n *   Handle nodes.\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean | null | undefined} [allowDangerousHtml=false]\n *   Whether to persist raw HTML in markdown in the hast tree (default:\n *   `false`).\n * @property {string | null | undefined} [clobberPrefix='user-content-']\n *   Prefix to use before the `id` property on footnotes to prevent them from\n *   *clobbering* (default: `'user-content-'`).\n *\n *   Pass `''` for trusted markdown and when you are careful with\n *   polyfilling.\n *   You could pass a different prefix.\n *\n *   DOM clobbering is this:\n *\n *   ```html\n *   <p id=\"x\"></p>\n *   <script>alert(x) // `x` now refers to the `p#x` DOM element</script>\n *   ```\n *\n *   The above example shows that elements are made available by browsers, by\n *   their ID, on the `window` object.\n *   This is a security risk because you might be expecting some other variable\n *   at that place.\n *   It can also break polyfills.\n *   Using a prefix solves these problems.\n * @property {VFile | null | undefined} [file]\n *   Corresponding virtual file representing the input document (optional).\n * @property {FootnoteBackContentTemplate | string | null | undefined} [footnoteBackContent]\n *   Content of the backreference back to references (default: `defaultFootnoteBackContent`).\n *\n *   The default value is:\n *\n *   ```js\n *   function defaultFootnoteBackContent(_, rereferenceIndex) {\n *     const result = [{type: 'text', value: '↩'}]\n *\n *     if (rereferenceIndex > 1) {\n *       result.push({\n *         type: 'element',\n *         tagName: 'sup',\n *         properties: {},\n *         children: [{type: 'text', value: String(rereferenceIndex)}]\n *       })\n *     }\n *\n *     return result\n *   }\n *   ```\n *\n *   This content is used in the `a` element of each backreference (the `↩`\n *   links).\n * @property {FootnoteBackLabelTemplate | string | null | undefined} [footnoteBackLabel]\n *   Label to describe the backreference back to references (default:\n *   `defaultFootnoteBackLabel`).\n *\n *   The default value is:\n *\n *   ```js\n *   function defaultFootnoteBackLabel(referenceIndex, rereferenceIndex) {\n *    return (\n *      'Back to reference ' +\n *      (referenceIndex + 1) +\n *      (rereferenceIndex > 1 ? '-' + rereferenceIndex : '')\n *    )\n *   }\n *   ```\n *\n *   Change it when the markdown is not in English.\n *\n *   This label is used in the `ariaLabel` property on each backreference\n *   (the `↩` links).\n *   It affects users of assistive technology.\n * @property {string | null | undefined} [footnoteLabel='Footnotes']\n *   Textual label to use for the footnotes section (default: `'Footnotes'`).\n *\n *   Change it when the markdown is not in English.\n *\n *   This label is typically hidden visually (assuming a `sr-only` CSS class\n *   is defined that does that) and so affects screen readers only.\n *   If you do have such a class, but want to show this section to everyone,\n *   pass different properties with the `footnoteLabelProperties` option.\n * @property {HastProperties | null | undefined} [footnoteLabelProperties={className: ['sr-only']}]\n *   Properties to use on the footnote label (default: `{className:\n *   ['sr-only']}`).\n *\n *   Change it to show the label and add other properties.\n *\n *   This label is typically hidden visually (assuming an `sr-only` CSS class\n *   is defined that does that) and so affects screen readers only.\n *   If you do have such a class, but want to show this section to everyone,\n *   pass an empty string.\n *   You can also add different properties.\n *\n *   > **Note**: `id: 'footnote-label'` is always added, because footnote\n *   > calls use it with `aria-describedby` to provide an accessible label.\n * @property {string | null | undefined} [footnoteLabelTagName='h2']\n *   HTML tag name to use for the footnote label element (default: `'h2'`).\n *\n *   Change it to match your document structure.\n *\n *   This label is typically hidden visually (assuming a `sr-only` CSS class\n *   is defined that does that) and so affects screen readers only.\n *   If you do have such a class, but want to show this section to everyone,\n *   pass different properties with the `footnoteLabelProperties` option.\n * @property {Handlers | null | undefined} [handlers]\n *   Extra handlers for nodes (optional).\n * @property {Array<MdastNodes['type']> | null | undefined} [passThrough]\n *   List of custom mdast node types to pass through (keep) in hast (note that\n *   the node itself is passed, but eventual children are transformed)\n *   (optional).\n * @property {Handler | null | undefined} [unknownHandler]\n *   Handler for all unknown nodes (optional).\n *\n * @typedef State\n *   Info passed around.\n * @property {(node: MdastNodes) => Array<HastElementContent>} all\n *   Transform the children of an mdast parent to hast.\n * @property {<Type extends HastNodes>(from: MdastNodes, to: Type) => HastElement | Type} applyData\n *   Honor the `data` of `from`, and generate an element instead of `node`.\n * @property {Map<string, MdastDefinition>} definitionById\n *   Definitions by their identifier.\n * @property {Map<string, MdastFootnoteDefinition>} footnoteById\n *   Footnote definitions by their identifier.\n * @property {Map<string, number>} footnoteCounts\n *   Counts for how often the same footnote was called.\n * @property {Array<string>} footnoteOrder\n *   Identifiers of order when footnote calls first appear in tree order.\n * @property {Handlers} handlers\n *   Applied handlers.\n * @property {(node: MdastNodes, parent: MdastParents | undefined) => Array<HastElementContent> | HastElementContent | undefined} one\n *   Transform an mdast node to hast.\n * @property {Options} options\n *   Configuration.\n * @property {(from: MdastNodes, node: HastNodes) => undefined} patch\n *   Copy a node’s positional info.\n * @property {<Type extends HastRootContent>(nodes: Array<Type>, loose?: boolean | undefined) => Array<HastText | Type>} wrap\n *   Wrap `nodes` with line endings between each node, adds initial/final line endings when `loose`.\n */\n\nimport structuredClone from '@ungap/structured-clone'\nimport {visit} from 'unist-util-visit'\nimport {position} from 'unist-util-position'\nimport {handlers as defaultHandlers} from './handlers/index.js'\n\nconst own = {}.hasOwnProperty\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Create `state` from an mdast tree.\n *\n * @param {MdastNodes} tree\n *   mdast node to transform.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {State}\n *   `state` function.\n */\nexport function createState(tree, options) {\n  const settings = options || emptyOptions\n  /** @type {Map<string, MdastDefinition>} */\n  const definitionById = new Map()\n  /** @type {Map<string, MdastFootnoteDefinition>} */\n  const footnoteById = new Map()\n  /** @type {Map<string, number>} */\n  const footnoteCounts = new Map()\n  /** @type {Handlers} */\n  // @ts-expect-error: the root handler returns a root.\n  // Hard to type.\n  const handlers = {...defaultHandlers, ...settings.handlers}\n\n  /** @type {State} */\n  const state = {\n    all,\n    applyData,\n    definitionById,\n    footnoteById,\n    footnoteCounts,\n    footnoteOrder: [],\n    handlers,\n    one,\n    options: settings,\n    patch,\n    wrap\n  }\n\n  visit(tree, function (node) {\n    if (node.type === 'definition' || node.type === 'footnoteDefinition') {\n      const map = node.type === 'definition' ? definitionById : footnoteById\n      const id = String(node.identifier).toUpperCase()\n\n      // Mimick CM behavior of link definitions.\n      // See: <https://github.com/syntax-tree/mdast-util-definitions/blob/9032189/lib/index.js#L20-L21>.\n      if (!map.has(id)) {\n        // @ts-expect-error: node type matches map.\n        map.set(id, node)\n      }\n    }\n  })\n\n  return state\n\n  /**\n   * Transform an mdast node into a hast node.\n   *\n   * @param {MdastNodes} node\n   *   mdast node.\n   * @param {MdastParents | undefined} [parent]\n   *   Parent of `node`.\n   * @returns {Array<HastElementContent> | HastElementContent | undefined}\n   *   Resulting hast node.\n   */\n  function one(node, parent) {\n    const type = node.type\n    const handle = state.handlers[type]\n\n    if (own.call(state.handlers, type) && handle) {\n      return handle(state, node, parent)\n    }\n\n    if (state.options.passThrough && state.options.passThrough.includes(type)) {\n      if ('children' in node) {\n        const {children, ...shallow} = node\n        const result = structuredClone(shallow)\n        // @ts-expect-error: TS doesn’t understand…\n        result.children = state.all(node)\n        // @ts-expect-error: TS doesn’t understand…\n        return result\n      }\n\n      // @ts-expect-error: it’s custom.\n      return structuredClone(node)\n    }\n\n    const unknown = state.options.unknownHandler || defaultUnknownHandler\n\n    return unknown(state, node, parent)\n  }\n\n  /**\n   * Transform the children of an mdast node into hast nodes.\n   *\n   * @param {MdastNodes} parent\n   *   mdast node to compile\n   * @returns {Array<HastElementContent>}\n   *   Resulting hast nodes.\n   */\n  function all(parent) {\n    /** @type {Array<HastElementContent>} */\n    const values = []\n\n    if ('children' in parent) {\n      const nodes = parent.children\n      let index = -1\n      while (++index < nodes.length) {\n        const result = state.one(nodes[index], parent)\n\n        // To do: see if we van clean this? Can we merge texts?\n        if (result) {\n          if (index && nodes[index - 1].type === 'break') {\n            if (!Array.isArray(result) && result.type === 'text') {\n              result.value = trimMarkdownSpaceStart(result.value)\n            }\n\n            if (!Array.isArray(result) && result.type === 'element') {\n              const head = result.children[0]\n\n              if (head && head.type === 'text') {\n                head.value = trimMarkdownSpaceStart(head.value)\n              }\n            }\n          }\n\n          if (Array.isArray(result)) {\n            values.push(...result)\n          } else {\n            values.push(result)\n          }\n        }\n      }\n    }\n\n    return values\n  }\n}\n\n/**\n * Copy a node’s positional info.\n *\n * @param {MdastNodes} from\n *   mdast node to copy from.\n * @param {HastNodes} to\n *   hast node to copy into.\n * @returns {undefined}\n *   Nothing.\n */\nfunction patch(from, to) {\n  if (from.position) to.position = position(from)\n}\n\n/**\n * Honor the `data` of `from` and maybe generate an element instead of `to`.\n *\n * @template {HastNodes} Type\n *   Node type.\n * @param {MdastNodes} from\n *   mdast node to use data from.\n * @param {Type} to\n *   hast node to change.\n * @returns {HastElement | Type}\n *   Nothing.\n */\nfunction applyData(from, to) {\n  /** @type {HastElement | Type} */\n  let result = to\n\n  // Handle `data.hName`, `data.hProperties, `data.hChildren`.\n  if (from && from.data) {\n    const hName = from.data.hName\n    const hChildren = from.data.hChildren\n    const hProperties = from.data.hProperties\n\n    if (typeof hName === 'string') {\n      // Transforming the node resulted in an element with a different name\n      // than wanted:\n      if (result.type === 'element') {\n        result.tagName = hName\n      }\n      // Transforming the node resulted in a non-element, which happens for\n      // raw, text, and root nodes (unless custom handlers are passed).\n      // The intent of `hName` is to create an element, but likely also to keep\n      // the content around (otherwise: pass `hChildren`).\n      else {\n        /** @type {Array<HastElementContent>} */\n        // @ts-expect-error: assume no doctypes in `root`.\n        const children = 'children' in result ? result.children : [result]\n        result = {type: 'element', tagName: hName, properties: {}, children}\n      }\n    }\n\n    if (result.type === 'element' && hProperties) {\n      Object.assign(result.properties, structuredClone(hProperties))\n    }\n\n    if (\n      'children' in result &&\n      result.children &&\n      hChildren !== null &&\n      hChildren !== undefined\n    ) {\n      result.children = hChildren\n    }\n  }\n\n  return result\n}\n\n/**\n * Transform an unknown node.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastNodes} node\n *   Unknown mdast node.\n * @returns {HastElement | HastText}\n *   Resulting hast node.\n */\nfunction defaultUnknownHandler(state, node) {\n  const data = node.data || {}\n  /** @type {HastElement | HastText} */\n  const result =\n    'value' in node &&\n    !(own.call(data, 'hProperties') || own.call(data, 'hChildren'))\n      ? {type: 'text', value: node.value}\n      : {\n          type: 'element',\n          tagName: 'div',\n          properties: {},\n          children: state.all(node)\n        }\n\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n\n/**\n * Wrap `nodes` with line endings between each node.\n *\n * @template {HastRootContent} Type\n *   Node type.\n * @param {Array<Type>} nodes\n *   List of nodes to wrap.\n * @param {boolean | undefined} [loose=false]\n *   Whether to add line endings at start and end (default: `false`).\n * @returns {Array<HastText | Type>}\n *   Wrapped nodes.\n */\nexport function wrap(nodes, loose) {\n  /** @type {Array<HastText | Type>} */\n  const result = []\n  let index = -1\n\n  if (loose) {\n    result.push({type: 'text', value: '\\n'})\n  }\n\n  while (++index < nodes.length) {\n    if (index) result.push({type: 'text', value: '\\n'})\n    result.push(nodes[index])\n  }\n\n  if (loose && nodes.length > 0) {\n    result.push({type: 'text', value: '\\n'})\n  }\n\n  return result\n}\n\n/**\n * Trim spaces and tabs at the start of `value`.\n *\n * @param {string} value\n *   Value to trim.\n * @returns {string}\n *   Result.\n */\nfunction trimMarkdownSpaceStart(value) {\n  let index = 0\n  let code = value.charCodeAt(index)\n\n  while (code === 9 || code === 32) {\n    index++\n    code = value.charCodeAt(index)\n  }\n\n  return value.slice(index)\n}\n","/**\n * @typedef {import('hast').Nodes} HastNodes\n * @typedef {import('mdast').Nodes} MdastNodes\n * @typedef {import('./state.js').Options} Options\n */\n\nimport {ok as assert} from 'devlop'\nimport {footer} from './footer.js'\nimport {createState} from './state.js'\n\n/**\n * Transform mdast to hast.\n *\n * ##### Notes\n *\n * ###### HTML\n *\n * Raw HTML is available in mdast as `html` nodes and can be embedded in hast\n * as semistandard `raw` nodes.\n * Most utilities ignore `raw` nodes but two notable ones don’t:\n *\n * *   `hast-util-to-html` also has an option `allowDangerousHtml` which will\n *     output the raw HTML.\n *     This is typically discouraged as noted by the option name but is useful\n *     if you completely trust authors\n * *   `hast-util-raw` can handle the raw embedded HTML strings by parsing them\n *     into standard hast nodes (`element`, `text`, etc).\n *     This is a heavy task as it needs a full HTML parser, but it is the only\n *     way to support untrusted content\n *\n * ###### Footnotes\n *\n * Many options supported here relate to footnotes.\n * Footnotes are not specified by CommonMark, which we follow by default.\n * They are supported by GitHub, so footnotes can be enabled in markdown with\n * `mdast-util-gfm`.\n *\n * The options `footnoteBackLabel` and `footnoteLabel` define natural language\n * that explains footnotes, which is hidden for sighted users but shown to\n * assistive technology.\n * When your page is not in English, you must define translated values.\n *\n * Back references use ARIA attributes, but the section label itself uses a\n * heading that is hidden with an `sr-only` class.\n * To show it to sighted users, define different attributes in\n * `footnoteLabelProperties`.\n *\n * ###### Clobbering\n *\n * Footnotes introduces a problem, as it links footnote calls to footnote\n * definitions on the page through `id` attributes generated from user content,\n * which results in DOM clobbering.\n *\n * DOM clobbering is this:\n *\n * ```html\n * <p id=x></p>\n * <script>alert(x) // `x` now refers to the DOM `p#x` element</script>\n * ```\n *\n * Elements by their ID are made available by browsers on the `window` object,\n * which is a security risk.\n * Using a prefix solves this problem.\n *\n * More information on how to handle clobbering and the prefix is explained in\n * Example: headings (DOM clobbering) in `rehype-sanitize`.\n *\n * ###### Unknown nodes\n *\n * Unknown nodes are nodes with a type that isn’t in `handlers` or `passThrough`.\n * The default behavior for unknown nodes is:\n *\n * *   when the node has a `value` (and doesn’t have `data.hName`,\n *     `data.hProperties`, or `data.hChildren`, see later), create a hast `text`\n *     node\n * *   otherwise, create a `<div>` element (which could be changed with\n *     `data.hName`), with its children mapped from mdast to hast as well\n *\n * This behavior can be changed by passing an `unknownHandler`.\n *\n * @param {MdastNodes} tree\n *   mdast tree.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {HastNodes}\n *   hast tree.\n */\nexport function toHast(tree, options) {\n  const state = createState(tree, options)\n  const node = state.one(tree, undefined)\n  const foot = footer(state)\n  /** @type {HastNodes} */\n  const result = Array.isArray(node)\n    ? {type: 'root', children: node}\n    : node || {type: 'root', children: []}\n\n  if (foot) {\n    // If there’s a footer, there were definitions, meaning block\n    // content.\n    // So `result` is a parent node.\n    assert('children' in result)\n    result.children.push({type: 'text', value: '\\n'}, foot)\n  }\n\n  return result\n}\n","// Include `data` fields in mdast and `raw` nodes in hast.\n/// <reference types=\"mdast-util-to-hast\" />\n\n/**\n * @import {Root as HastRoot} from 'hast'\n * @import {Root as MdastRoot} from 'mdast'\n * @import {Options as ToHastOptions} from 'mdast-util-to-hast'\n * @import {Processor} from 'unified'\n * @import {VFile} from 'vfile'\n */\n\n/**\n * @typedef {Omit<ToHastOptions, 'file'>} Options\n *\n * @callback TransformBridge\n *   Bridge-mode.\n *\n *   Runs the destination with the new hast tree.\n *   Discards result.\n * @param {MdastRoot} tree\n *   Tree.\n * @param {VFile} file\n *   File.\n * @returns {Promise<undefined>}\n *   Nothing.\n *\n * @callback TransformMutate\n *  Mutate-mode.\n *\n *  Further transformers run on the hast tree.\n * @param {MdastRoot} tree\n *   Tree.\n * @param {VFile} file\n *   File.\n * @returns {HastRoot}\n *   Tree (hast).\n */\n\nimport {toHast} from 'mdast-util-to-hast'\n\n/**\n * Turn markdown into HTML.\n *\n * ##### Notes\n *\n * ###### Signature\n *\n * *   if a processor is given, runs the (rehype) plugins used on it with a\n *     hast tree, then discards the result (*bridge mode*)\n * *   otherwise, returns a hast tree, the plugins used after `remarkRehype`\n *     are rehype plugins (*mutate mode*)\n *\n * > 👉 **Note**: It’s highly unlikely that you want to pass a `processor`.\n *\n * ###### HTML\n *\n * Raw HTML is available in mdast as `html` nodes and can be embedded in hast\n * as semistandard `raw` nodes.\n * Most plugins ignore `raw` nodes but two notable ones don’t:\n *\n * *   `rehype-stringify` also has an option `allowDangerousHtml` which will\n *     output the raw HTML.\n *     This is typically discouraged as noted by the option name but is useful if\n *     you completely trust authors\n * *   `rehype-raw` can handle the raw embedded HTML strings by parsing them\n *     into standard hast nodes (`element`, `text`, etc).\n *     This is a heavy task as it needs a full HTML parser, but it is the only way\n *     to support untrusted content\n *\n * ###### Footnotes\n *\n * Many options supported here relate to footnotes.\n * Footnotes are not specified by CommonMark, which we follow by default.\n * They are supported by GitHub, so footnotes can be enabled in markdown with\n * `remark-gfm`.\n *\n * The options `footnoteBackLabel` and `footnoteLabel` define natural language\n * that explains footnotes, which is hidden for sighted users but shown to\n * assistive technology.\n * When your page is not in English, you must define translated values.\n *\n * Back references use ARIA attributes, but the section label itself uses a\n * heading that is hidden with an `sr-only` class.\n * To show it to sighted users, define different attributes in\n * `footnoteLabelProperties`.\n *\n * ###### Clobbering\n *\n * Footnotes introduces a problem, as it links footnote calls to footnote\n * definitions on the page through `id` attributes generated from user content,\n * which results in DOM clobbering.\n *\n * DOM clobbering is this:\n *\n * ```html\n * <p id=x></p>\n * <script>alert(x) // `x` now refers to the DOM `p#x` element</script>\n * ```\n *\n * Elements by their ID are made available by browsers on the `window` object,\n * which is a security risk.\n * Using a prefix solves this problem.\n *\n * More information on how to handle clobbering and the prefix is explained in\n * *Example: headings (DOM clobbering)* in `rehype-sanitize`.\n *\n * ###### Unknown nodes\n *\n * Unknown nodes are nodes with a type that isn’t in `handlers` or `passThrough`.\n * The default behavior for unknown nodes is:\n *\n * *   when the node has a `value` (and doesn’t have `data.hName`,\n *     `data.hProperties`, or `data.hChildren`, see later), create a hast `text`\n *     node\n * *   otherwise, create a `<div>` element (which could be changed with\n *     `data.hName`), with its children mapped from mdast to hast as well\n *\n * This behavior can be changed by passing an `unknownHandler`.\n *\n * @overload\n * @param {Processor} processor\n * @param {Readonly<Options> | null | undefined} [options]\n * @returns {TransformBridge}\n *\n * @overload\n * @param {Readonly<Options> | null | undefined} [options]\n * @returns {TransformMutate}\n *\n * @param {Readonly<Options> | Processor | null | undefined} [destination]\n *   Processor or configuration (optional).\n * @param {Readonly<Options> | null | undefined} [options]\n *   When a processor was given, configuration (optional).\n * @returns {TransformBridge | TransformMutate}\n *   Transform.\n */\nexport default function remarkRehype(destination, options) {\n  if (destination && 'run' in destination) {\n    /**\n     * @type {TransformBridge}\n     */\n    return async function (tree, file) {\n      // Cast because root in -> root out.\n      const hastTree = /** @type {HastRoot} */ (\n        toHast(tree, {file, ...options})\n      )\n      await destination.run(hastTree, file)\n    }\n  }\n\n  /**\n   * @type {TransformMutate}\n   */\n  return function (tree, file) {\n    // Cast because root in -> root out.\n    // To do: in the future, disallow ` || options` fallback.\n    // With `unified-engine`, `destination` can be `undefined` but\n    // `options` will be the file set.\n    // We should not pass that as `options`.\n    return /** @type {HastRoot} */ (\n      toHast(tree, {file, ...(destination || options)})\n    )\n  }\n}\n","/**\n * Throw a given error.\n *\n * @param {Error|null|undefined} [error]\n *   Maybe error.\n * @returns {asserts error is null|undefined}\n */\nexport function bail(error) {\n  if (error) {\n    throw error\n  }\n}\n","export default function isPlainObject(value) {\n\tif (typeof value !== 'object' || value === null) {\n\t\treturn false;\n\t}\n\n\tconst prototype = Object.getPrototypeOf(value);\n\treturn (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);\n}\n","// To do: remove `void`s\n// To do: remove `null` from output of our APIs, allow it as user APIs.\n\n/**\n * @typedef {(error?: Error | null | undefined, ...output: Array<any>) => void} Callback\n *   Callback.\n *\n * @typedef {(...input: Array<any>) => any} Middleware\n *   Ware.\n *\n * @typedef Pipeline\n *   Pipeline.\n * @property {Run} run\n *   Run the pipeline.\n * @property {Use} use\n *   Add middleware.\n *\n * @typedef {(...input: Array<any>) => void} Run\n *   Call all middleware.\n *\n *   Calls `done` on completion with either an error or the output of the\n *   last middleware.\n *\n *   > 👉 **Note**: as the length of input defines whether async functions get a\n *   > `next` function,\n *   > it’s recommended to keep `input` at one value normally.\n\n *\n * @typedef {(fn: Middleware) => Pipeline} Use\n *   Add middleware.\n */\n\n/**\n * Create new middleware.\n *\n * @returns {Pipeline}\n *   Pipeline.\n */\nexport function trough() {\n  /** @type {Array<Middleware>} */\n  const fns = []\n  /** @type {Pipeline} */\n  const pipeline = {run, use}\n\n  return pipeline\n\n  /** @type {Run} */\n  function run(...values) {\n    let middlewareIndex = -1\n    /** @type {Callback} */\n    const callback = values.pop()\n\n    if (typeof callback !== 'function') {\n      throw new TypeError('Expected function as last argument, not ' + callback)\n    }\n\n    next(null, ...values)\n\n    /**\n     * Run the next `fn`, or we’re done.\n     *\n     * @param {Error | null | undefined} error\n     * @param {Array<any>} output\n     */\n    function next(error, ...output) {\n      const fn = fns[++middlewareIndex]\n      let index = -1\n\n      if (error) {\n        callback(error)\n        return\n      }\n\n      // Copy non-nullish input into values.\n      while (++index < values.length) {\n        if (output[index] === null || output[index] === undefined) {\n          output[index] = values[index]\n        }\n      }\n\n      // Save the newly created `output` for the next call.\n      values = output\n\n      // Next or done.\n      if (fn) {\n        wrap(fn, next)(...output)\n      } else {\n        callback(null, ...output)\n      }\n    }\n  }\n\n  /** @type {Use} */\n  function use(middelware) {\n    if (typeof middelware !== 'function') {\n      throw new TypeError(\n        'Expected `middelware` to be a function, not ' + middelware\n      )\n    }\n\n    fns.push(middelware)\n    return pipeline\n  }\n}\n\n/**\n * Wrap `middleware` into a uniform interface.\n *\n * You can pass all input to the resulting function.\n * `callback` is then called with the output of `middleware`.\n *\n * If `middleware` accepts more arguments than the later given in input,\n * an extra `done` function is passed to it after that input,\n * which must be called by `middleware`.\n *\n * The first value in `input` is the main input value.\n * All other input values are the rest input values.\n * The values given to `callback` are the input values,\n * merged with every non-nullish output value.\n *\n * * if `middleware` throws an error,\n *   returns a promise that is rejected,\n *   or calls the given `done` function with an error,\n *   `callback` is called with that error\n * * if `middleware` returns a value or returns a promise that is resolved,\n *   that value is the main output value\n * * if `middleware` calls `done`,\n *   all non-nullish values except for the first one (the error) overwrite the\n *   output values\n *\n * @param {Middleware} middleware\n *   Function to wrap.\n * @param {Callback} callback\n *   Callback called with the output of `middleware`.\n * @returns {Run}\n *   Wrapped middleware.\n */\nexport function wrap(middleware, callback) {\n  /** @type {boolean} */\n  let called\n\n  return wrapped\n\n  /**\n   * Call `middleware`.\n   * @this {any}\n   * @param {Array<any>} parameters\n   * @returns {void}\n   */\n  function wrapped(...parameters) {\n    const fnExpectsCallback = middleware.length > parameters.length\n    /** @type {any} */\n    let result\n\n    if (fnExpectsCallback) {\n      parameters.push(done)\n    }\n\n    try {\n      result = middleware.apply(this, parameters)\n    } catch (error) {\n      const exception = /** @type {Error} */ (error)\n\n      // Well, this is quite the pickle.\n      // `middleware` received a callback and called it synchronously, but that\n      // threw an error.\n      // The only thing left to do is to throw the thing instead.\n      if (fnExpectsCallback && called) {\n        throw exception\n      }\n\n      return done(exception)\n    }\n\n    if (!fnExpectsCallback) {\n      if (result && result.then && typeof result.then === 'function') {\n        result.then(then, done)\n      } else if (result instanceof Error) {\n        done(result)\n      } else {\n        then(result)\n      }\n    }\n  }\n\n  /**\n   * Call `callback`, only once.\n   *\n   * @type {Callback}\n   */\n  function done(error, ...output) {\n    if (!called) {\n      called = true\n      callback(error, ...output)\n    }\n  }\n\n  /**\n   * Call `done` with one value.\n   *\n   * @param {any} [value]\n   */\n  function then(value) {\n    done(null, value)\n  }\n}\n","// A derivative work based on:\n// <https://github.com/browserify/path-browserify>.\n// Which is licensed:\n//\n// MIT License\n//\n// Copyright (c) 2013 James Halliday\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy of\n// this software and associated documentation files (the \"Software\"), to deal in\n// the Software without restriction, including without limitation the rights to\n// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\n// the Software, and to permit persons to whom the Software is furnished to do so,\n// subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\n// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\n// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\n// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n// A derivative work based on:\n//\n// Parts of that are extracted from Node’s internal `path` module:\n// <https://github.com/nodejs/node/blob/master/lib/path.js>.\n// Which is licensed:\n//\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nexport const minpath = {basename, dirname, extname, join, sep: '/'}\n\n/* eslint-disable max-depth, complexity */\n\n/**\n * Get the basename from a path.\n *\n * @param {string} path\n *   File path.\n * @param {string | null | undefined} [extname]\n *   Extension to strip.\n * @returns {string}\n *   Stem or basename.\n */\nfunction basename(path, extname) {\n  if (extname !== undefined && typeof extname !== 'string') {\n    throw new TypeError('\"ext\" argument must be a string')\n  }\n\n  assertPath(path)\n  let start = 0\n  let end = -1\n  let index = path.length\n  /** @type {boolean | undefined} */\n  let seenNonSlash\n\n  if (\n    extname === undefined ||\n    extname.length === 0 ||\n    extname.length > path.length\n  ) {\n    while (index--) {\n      if (path.codePointAt(index) === 47 /* `/` */) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now.\n        if (seenNonSlash) {\n          start = index + 1\n          break\n        }\n      } else if (end < 0) {\n        // We saw the first non-path separator, mark this as the end of our\n        // path component.\n        seenNonSlash = true\n        end = index + 1\n      }\n    }\n\n    return end < 0 ? '' : path.slice(start, end)\n  }\n\n  if (extname === path) {\n    return ''\n  }\n\n  let firstNonSlashEnd = -1\n  let extnameIndex = extname.length - 1\n\n  while (index--) {\n    if (path.codePointAt(index) === 47 /* `/` */) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now.\n      if (seenNonSlash) {\n        start = index + 1\n        break\n      }\n    } else {\n      if (firstNonSlashEnd < 0) {\n        // We saw the first non-path separator, remember this index in case\n        // we need it if the extension ends up not matching.\n        seenNonSlash = true\n        firstNonSlashEnd = index + 1\n      }\n\n      if (extnameIndex > -1) {\n        // Try to match the explicit extension.\n        if (path.codePointAt(index) === extname.codePointAt(extnameIndex--)) {\n          if (extnameIndex < 0) {\n            // We matched the extension, so mark this as the end of our path\n            // component\n            end = index\n          }\n        } else {\n          // Extension does not match, so our result is the entire path\n          // component\n          extnameIndex = -1\n          end = firstNonSlashEnd\n        }\n      }\n    }\n  }\n\n  if (start === end) {\n    end = firstNonSlashEnd\n  } else if (end < 0) {\n    end = path.length\n  }\n\n  return path.slice(start, end)\n}\n\n/**\n * Get the dirname from a path.\n *\n * @param {string} path\n *   File path.\n * @returns {string}\n *   File path.\n */\nfunction dirname(path) {\n  assertPath(path)\n\n  if (path.length === 0) {\n    return '.'\n  }\n\n  let end = -1\n  let index = path.length\n  /** @type {boolean | undefined} */\n  let unmatchedSlash\n\n  // Prefix `--` is important to not run on `0`.\n  while (--index) {\n    if (path.codePointAt(index) === 47 /* `/` */) {\n      if (unmatchedSlash) {\n        end = index\n        break\n      }\n    } else if (!unmatchedSlash) {\n      // We saw the first non-path separator\n      unmatchedSlash = true\n    }\n  }\n\n  return end < 0\n    ? path.codePointAt(0) === 47 /* `/` */\n      ? '/'\n      : '.'\n    : end === 1 && path.codePointAt(0) === 47 /* `/` */\n      ? '//'\n      : path.slice(0, end)\n}\n\n/**\n * Get an extname from a path.\n *\n * @param {string} path\n *   File path.\n * @returns {string}\n *   Extname.\n */\nfunction extname(path) {\n  assertPath(path)\n\n  let index = path.length\n\n  let end = -1\n  let startPart = 0\n  let startDot = -1\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find.\n  let preDotState = 0\n  /** @type {boolean | undefined} */\n  let unmatchedSlash\n\n  while (index--) {\n    const code = path.codePointAt(index)\n\n    if (code === 47 /* `/` */) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now.\n      if (unmatchedSlash) {\n        startPart = index + 1\n        break\n      }\n\n      continue\n    }\n\n    if (end < 0) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension.\n      unmatchedSlash = true\n      end = index + 1\n    }\n\n    if (code === 46 /* `.` */) {\n      // If this is our first dot, mark it as the start of our extension.\n      if (startDot < 0) {\n        startDot = index\n      } else if (preDotState !== 1) {\n        preDotState = 1\n      }\n    } else if (startDot > -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension.\n      preDotState = -1\n    }\n  }\n\n  if (\n    startDot < 0 ||\n    end < 0 ||\n    // We saw a non-dot character immediately before the dot.\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly `..`.\n    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n  ) {\n    return ''\n  }\n\n  return path.slice(startDot, end)\n}\n\n/**\n * Join segments from a path.\n *\n * @param {Array<string>} segments\n *   Path segments.\n * @returns {string}\n *   File path.\n */\nfunction join(...segments) {\n  let index = -1\n  /** @type {string | undefined} */\n  let joined\n\n  while (++index < segments.length) {\n    assertPath(segments[index])\n\n    if (segments[index]) {\n      joined =\n        joined === undefined ? segments[index] : joined + '/' + segments[index]\n    }\n  }\n\n  return joined === undefined ? '.' : normalize(joined)\n}\n\n/**\n * Normalize a basic file path.\n *\n * @param {string} path\n *   File path.\n * @returns {string}\n *   File path.\n */\n// Note: `normalize` is not exposed as `path.normalize`, so some code is\n// manually removed from it.\nfunction normalize(path) {\n  assertPath(path)\n\n  const absolute = path.codePointAt(0) === 47 /* `/` */\n\n  // Normalize the path according to POSIX rules.\n  let value = normalizeString(path, !absolute)\n\n  if (value.length === 0 && !absolute) {\n    value = '.'\n  }\n\n  if (value.length > 0 && path.codePointAt(path.length - 1) === 47 /* / */) {\n    value += '/'\n  }\n\n  return absolute ? '/' + value : value\n}\n\n/**\n * Resolve `.` and `..` elements in a path with directory names.\n *\n * @param {string} path\n *   File path.\n * @param {boolean} allowAboveRoot\n *   Whether `..` can move above root.\n * @returns {string}\n *   File path.\n */\nfunction normalizeString(path, allowAboveRoot) {\n  let result = ''\n  let lastSegmentLength = 0\n  let lastSlash = -1\n  let dots = 0\n  let index = -1\n  /** @type {number | undefined} */\n  let code\n  /** @type {number} */\n  let lastSlashIndex\n\n  while (++index <= path.length) {\n    if (index < path.length) {\n      code = path.codePointAt(index)\n    } else if (code === 47 /* `/` */) {\n      break\n    } else {\n      code = 47 /* `/` */\n    }\n\n    if (code === 47 /* `/` */) {\n      if (lastSlash === index - 1 || dots === 1) {\n        // Empty.\n      } else if (lastSlash !== index - 1 && dots === 2) {\n        if (\n          result.length < 2 ||\n          lastSegmentLength !== 2 ||\n          result.codePointAt(result.length - 1) !== 46 /* `.` */ ||\n          result.codePointAt(result.length - 2) !== 46 /* `.` */\n        ) {\n          if (result.length > 2) {\n            lastSlashIndex = result.lastIndexOf('/')\n\n            if (lastSlashIndex !== result.length - 1) {\n              if (lastSlashIndex < 0) {\n                result = ''\n                lastSegmentLength = 0\n              } else {\n                result = result.slice(0, lastSlashIndex)\n                lastSegmentLength = result.length - 1 - result.lastIndexOf('/')\n              }\n\n              lastSlash = index\n              dots = 0\n              continue\n            }\n          } else if (result.length > 0) {\n            result = ''\n            lastSegmentLength = 0\n            lastSlash = index\n            dots = 0\n            continue\n          }\n        }\n\n        if (allowAboveRoot) {\n          result = result.length > 0 ? result + '/..' : '..'\n          lastSegmentLength = 2\n        }\n      } else {\n        if (result.length > 0) {\n          result += '/' + path.slice(lastSlash + 1, index)\n        } else {\n          result = path.slice(lastSlash + 1, index)\n        }\n\n        lastSegmentLength = index - lastSlash - 1\n      }\n\n      lastSlash = index\n      dots = 0\n    } else if (code === 46 /* `.` */ && dots > -1) {\n      dots++\n    } else {\n      dots = -1\n    }\n  }\n\n  return result\n}\n\n/**\n * Make sure `path` is a string.\n *\n * @param {string} path\n *   File path.\n * @returns {asserts path is string}\n *   Nothing.\n */\nfunction assertPath(path) {\n  if (typeof path !== 'string') {\n    throw new TypeError(\n      'Path must be a string. Received ' + JSON.stringify(path)\n    )\n  }\n}\n\n/* eslint-enable max-depth, complexity */\n","// Somewhat based on:\n// <https://github.com/defunctzombie/node-process/blob/master/browser.js>.\n// But I don’t think one tiny line of code can be copyrighted. 😅\nexport const minproc = {cwd}\n\nfunction cwd() {\n  return '/'\n}\n","/**\n * Checks if a value has the shape of a WHATWG URL object.\n *\n * Using a symbol or instanceof would not be able to recognize URL objects\n * coming from other implementations (e.g. in Electron), so instead we are\n * checking some well known properties for a lack of a better test.\n *\n * We use `href` and `protocol` as they are the only properties that are\n * easy to retrieve and calculate due to the lazy nature of the getters.\n *\n * We check for auth attribute to distinguish legacy url instance with\n * WHATWG URL instance.\n *\n * @param {unknown} fileUrlOrPath\n *   File path or URL.\n * @returns {fileUrlOrPath is URL}\n *   Whether it’s a URL.\n */\n// From: <https://github.com/nodejs/node/blob/6a3403c/lib/internal/url.js#L720>\nexport function isUrl(fileUrlOrPath) {\n  return Boolean(\n    fileUrlOrPath !== null &&\n      typeof fileUrlOrPath === 'object' &&\n      'href' in fileUrlOrPath &&\n      fileUrlOrPath.href &&\n      'protocol' in fileUrlOrPath &&\n      fileUrlOrPath.protocol &&\n      // @ts-expect-error: indexing is fine.\n      fileUrlOrPath.auth === undefined\n  )\n}\n","import {isUrl} from './minurl.shared.js'\n\nexport {isUrl} from './minurl.shared.js'\n\n// See: <https://github.com/nodejs/node/blob/6a3403c/lib/internal/url.js>\n\n/**\n * @param {URL | string} path\n *   File URL.\n * @returns {string}\n *   File URL.\n */\nexport function urlToPath(path) {\n  if (typeof path === 'string') {\n    path = new URL(path)\n  } else if (!isUrl(path)) {\n    /** @type {NodeJS.ErrnoException} */\n    const error = new TypeError(\n      'The \"path\" argument must be of type string or an instance of URL. Received `' +\n        path +\n        '`'\n    )\n    error.code = 'ERR_INVALID_ARG_TYPE'\n    throw error\n  }\n\n  if (path.protocol !== 'file:') {\n    /** @type {NodeJS.ErrnoException} */\n    const error = new TypeError('The URL must be of scheme file')\n    error.code = 'ERR_INVALID_URL_SCHEME'\n    throw error\n  }\n\n  return getPathFromURLPosix(path)\n}\n\n/**\n * Get a path from a POSIX URL.\n *\n * @param {URL} url\n *   URL.\n * @returns {string}\n *   File path.\n */\nfunction getPathFromURLPosix(url) {\n  if (url.hostname !== '') {\n    /** @type {NodeJS.ErrnoException} */\n    const error = new TypeError(\n      'File URL host must be \"localhost\" or empty on darwin'\n    )\n    error.code = 'ERR_INVALID_FILE_URL_HOST'\n    throw error\n  }\n\n  const pathname = url.pathname\n  let index = -1\n\n  while (++index < pathname.length) {\n    if (\n      pathname.codePointAt(index) === 37 /* `%` */ &&\n      pathname.codePointAt(index + 1) === 50 /* `2` */\n    ) {\n      const third = pathname.codePointAt(index + 2)\n      if (third === 70 /* `F` */ || third === 102 /* `f` */) {\n        /** @type {NodeJS.ErrnoException} */\n        const error = new TypeError(\n          'File URL path must not include encoded / characters'\n        )\n        error.code = 'ERR_INVALID_FILE_URL_PATH'\n        throw error\n      }\n    }\n  }\n\n  return decodeURIComponent(pathname)\n}\n","/**\n * @import {Node, Point, Position} from 'unist'\n * @import {Options as MessageOptions} from 'vfile-message'\n * @import {Compatible, Data, Map, Options, Value} from 'vfile'\n */\n\n/**\n * @typedef {object & {type: string, position?: Position | undefined}} NodeLike\n */\n\nimport {VFileMessage} from 'vfile-message'\nimport {minpath} from '#minpath'\nimport {minproc} from '#minproc'\nimport {urlToPath, isUrl} from '#minurl'\n\n/**\n * Order of setting (least specific to most), we need this because otherwise\n * `{stem: 'a', path: '~/b.js'}` would throw, as a path is needed before a\n * stem can be set.\n */\nconst order = /** @type {const} */ ([\n  'history',\n  'path',\n  'basename',\n  'stem',\n  'extname',\n  'dirname'\n])\n\nexport class VFile {\n  /**\n   * Create a new virtual file.\n   *\n   * `options` is treated as:\n   *\n   * *   `string` or `Uint8Array` — `{value: options}`\n   * *   `URL` — `{path: options}`\n   * *   `VFile` — shallow copies its data over to the new file\n   * *   `object` — all fields are shallow copied over to the new file\n   *\n   * Path related fields are set in the following order (least specific to\n   * most specific): `history`, `path`, `basename`, `stem`, `extname`,\n   * `dirname`.\n   *\n   * You cannot set `dirname` or `extname` without setting either `history`,\n   * `path`, `basename`, or `stem` too.\n   *\n   * @param {Compatible | null | undefined} [value]\n   *   File value.\n   * @returns\n   *   New instance.\n   */\n  constructor(value) {\n    /** @type {Options | VFile} */\n    let options\n\n    if (!value) {\n      options = {}\n    } else if (isUrl(value)) {\n      options = {path: value}\n    } else if (typeof value === 'string' || isUint8Array(value)) {\n      options = {value}\n    } else {\n      options = value\n    }\n\n    /* eslint-disable no-unused-expressions */\n\n    /**\n     * Base of `path` (default: `process.cwd()` or `'/'` in browsers).\n     *\n     * @type {string}\n     */\n    // Prevent calling `cwd` (which could be expensive) if it’s not needed;\n    // the empty string will be overridden in the next block.\n    this.cwd = 'cwd' in options ? '' : minproc.cwd()\n\n    /**\n     * Place to store custom info (default: `{}`).\n     *\n     * It’s OK to store custom data directly on the file but moving it to\n     * `data` is recommended.\n     *\n     * @type {Data}\n     */\n    this.data = {}\n\n    /**\n     * List of file paths the file moved between.\n     *\n     * The first is the original path and the last is the current path.\n     *\n     * @type {Array<string>}\n     */\n    this.history = []\n\n    /**\n     * List of messages associated with the file.\n     *\n     * @type {Array<VFileMessage>}\n     */\n    this.messages = []\n\n    /**\n     * Raw value.\n     *\n     * @type {Value}\n     */\n    this.value\n\n    // The below are non-standard, they are “well-known”.\n    // As in, used in several tools.\n    /**\n     * Source map.\n     *\n     * This type is equivalent to the `RawSourceMap` type from the `source-map`\n     * module.\n     *\n     * @type {Map | null | undefined}\n     */\n    this.map\n\n    /**\n     * Custom, non-string, compiled, representation.\n     *\n     * This is used by unified to store non-string results.\n     * One example is when turning markdown into React nodes.\n     *\n     * @type {unknown}\n     */\n    this.result\n\n    /**\n     * Whether a file was saved to disk.\n     *\n     * This is used by vfile reporters.\n     *\n     * @type {boolean}\n     */\n    this.stored\n    /* eslint-enable no-unused-expressions */\n\n    // Set path related properties in the correct order.\n    let index = -1\n\n    while (++index < order.length) {\n      const field = order[index]\n\n      // Note: we specifically use `in` instead of `hasOwnProperty` to accept\n      // `vfile`s too.\n      if (\n        field in options &&\n        options[field] !== undefined &&\n        options[field] !== null\n      ) {\n        // @ts-expect-error: TS doesn’t understand basic reality.\n        this[field] = field === 'history' ? [...options[field]] : options[field]\n      }\n    }\n\n    /** @type {string} */\n    let field\n\n    // Set non-path related properties.\n    for (field in options) {\n      // @ts-expect-error: fine to set other things.\n      if (!order.includes(field)) {\n        // @ts-expect-error: fine to set other things.\n        this[field] = options[field]\n      }\n    }\n  }\n\n  /**\n   * Get the basename (including extname) (example: `'index.min.js'`).\n   *\n   * @returns {string | undefined}\n   *   Basename.\n   */\n  get basename() {\n    return typeof this.path === 'string'\n      ? minpath.basename(this.path)\n      : undefined\n  }\n\n  /**\n   * Set basename (including extname) (`'index.min.js'`).\n   *\n   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n   * on windows).\n   * Cannot be nullified (use `file.path = file.dirname` instead).\n   *\n   * @param {string} basename\n   *   Basename.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set basename(basename) {\n    assertNonEmpty(basename, 'basename')\n    assertPart(basename, 'basename')\n    this.path = minpath.join(this.dirname || '', basename)\n  }\n\n  /**\n   * Get the parent path (example: `'~'`).\n   *\n   * @returns {string | undefined}\n   *   Dirname.\n   */\n  get dirname() {\n    return typeof this.path === 'string'\n      ? minpath.dirname(this.path)\n      : undefined\n  }\n\n  /**\n   * Set the parent path (example: `'~'`).\n   *\n   * Cannot be set if there’s no `path` yet.\n   *\n   * @param {string | undefined} dirname\n   *   Dirname.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set dirname(dirname) {\n    assertPath(this.basename, 'dirname')\n    this.path = minpath.join(dirname || '', this.basename)\n  }\n\n  /**\n   * Get the extname (including dot) (example: `'.js'`).\n   *\n   * @returns {string | undefined}\n   *   Extname.\n   */\n  get extname() {\n    return typeof this.path === 'string'\n      ? minpath.extname(this.path)\n      : undefined\n  }\n\n  /**\n   * Set the extname (including dot) (example: `'.js'`).\n   *\n   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n   * on windows).\n   * Cannot be set if there’s no `path` yet.\n   *\n   * @param {string | undefined} extname\n   *   Extname.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set extname(extname) {\n    assertPart(extname, 'extname')\n    assertPath(this.dirname, 'extname')\n\n    if (extname) {\n      if (extname.codePointAt(0) !== 46 /* `.` */) {\n        throw new Error('`extname` must start with `.`')\n      }\n\n      if (extname.includes('.', 1)) {\n        throw new Error('`extname` cannot contain multiple dots')\n      }\n    }\n\n    this.path = minpath.join(this.dirname, this.stem + (extname || ''))\n  }\n\n  /**\n   * Get the full path (example: `'~/index.min.js'`).\n   *\n   * @returns {string}\n   *   Path.\n   */\n  get path() {\n    return this.history[this.history.length - 1]\n  }\n\n  /**\n   * Set the full path (example: `'~/index.min.js'`).\n   *\n   * Cannot be nullified.\n   * You can set a file URL (a `URL` object with a `file:` protocol) which will\n   * be turned into a path with `url.fileURLToPath`.\n   *\n   * @param {URL | string} path\n   *   Path.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set path(path) {\n    if (isUrl(path)) {\n      path = urlToPath(path)\n    }\n\n    assertNonEmpty(path, 'path')\n\n    if (this.path !== path) {\n      this.history.push(path)\n    }\n  }\n\n  /**\n   * Get the stem (basename w/o extname) (example: `'index.min'`).\n   *\n   * @returns {string | undefined}\n   *   Stem.\n   */\n  get stem() {\n    return typeof this.path === 'string'\n      ? minpath.basename(this.path, this.extname)\n      : undefined\n  }\n\n  /**\n   * Set the stem (basename w/o extname) (example: `'index.min'`).\n   *\n   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n   * on windows).\n   * Cannot be nullified (use `file.path = file.dirname` instead).\n   *\n   * @param {string} stem\n   *   Stem.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set stem(stem) {\n    assertNonEmpty(stem, 'stem')\n    assertPart(stem, 'stem')\n    this.path = minpath.join(this.dirname || '', stem + (this.extname || ''))\n  }\n\n  // Normal prototypal methods.\n  /**\n   * Create a fatal message for `reason` associated with the file.\n   *\n   * The `fatal` field of the message is set to `true` (error; file not usable)\n   * and the `file` field is set to the current file path.\n   * The message is added to the `messages` field on `file`.\n   *\n   * > 🪦 **Note**: also has obsolete signatures.\n   *\n   * @overload\n   * @param {string} reason\n   * @param {MessageOptions | null | undefined} [options]\n   * @returns {never}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @param {Error | VFileMessage | string} causeOrReason\n   *   Reason for message, should use markdown.\n   * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]\n   *   Configuration (optional).\n   * @param {string | null | undefined} [origin]\n   *   Place in code where the message originates (example:\n   *   `'my-package:my-rule'` or `'my-rule'`).\n   * @returns {never}\n   *   Never.\n   * @throws {VFileMessage}\n   *   Message.\n   */\n  fail(causeOrReason, optionsOrParentOrPlace, origin) {\n    // @ts-expect-error: the overloads are fine.\n    const message = this.message(causeOrReason, optionsOrParentOrPlace, origin)\n\n    message.fatal = true\n\n    throw message\n  }\n\n  /**\n   * Create an info message for `reason` associated with the file.\n   *\n   * The `fatal` field of the message is set to `undefined` (info; change\n   * likely not needed) and the `file` field is set to the current file path.\n   * The message is added to the `messages` field on `file`.\n   *\n   * > 🪦 **Note**: also has obsolete signatures.\n   *\n   * @overload\n   * @param {string} reason\n   * @param {MessageOptions | null | undefined} [options]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @param {Error | VFileMessage | string} causeOrReason\n   *   Reason for message, should use markdown.\n   * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]\n   *   Configuration (optional).\n   * @param {string | null | undefined} [origin]\n   *   Place in code where the message originates (example:\n   *   `'my-package:my-rule'` or `'my-rule'`).\n   * @returns {VFileMessage}\n   *   Message.\n   */\n  info(causeOrReason, optionsOrParentOrPlace, origin) {\n    // @ts-expect-error: the overloads are fine.\n    const message = this.message(causeOrReason, optionsOrParentOrPlace, origin)\n\n    message.fatal = undefined\n\n    return message\n  }\n\n  /**\n   * Create a message for `reason` associated with the file.\n   *\n   * The `fatal` field of the message is set to `false` (warning; change may be\n   * needed) and the `file` field is set to the current file path.\n   * The message is added to the `messages` field on `file`.\n   *\n   * > 🪦 **Note**: also has obsolete signatures.\n   *\n   * @overload\n   * @param {string} reason\n   * @param {MessageOptions | null | undefined} [options]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @param {Error | VFileMessage | string} causeOrReason\n   *   Reason for message, should use markdown.\n   * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]\n   *   Configuration (optional).\n   * @param {string | null | undefined} [origin]\n   *   Place in code where the message originates (example:\n   *   `'my-package:my-rule'` or `'my-rule'`).\n   * @returns {VFileMessage}\n   *   Message.\n   */\n  message(causeOrReason, optionsOrParentOrPlace, origin) {\n    const message = new VFileMessage(\n      // @ts-expect-error: the overloads are fine.\n      causeOrReason,\n      optionsOrParentOrPlace,\n      origin\n    )\n\n    if (this.path) {\n      message.name = this.path + ':' + message.name\n      message.file = this.path\n    }\n\n    message.fatal = false\n\n    this.messages.push(message)\n\n    return message\n  }\n\n  /**\n   * Serialize the file.\n   *\n   * > **Note**: which encodings are supported depends on the engine.\n   * > For info on Node.js, see:\n   * > <https://nodejs.org/api/util.html#whatwg-supported-encodings>.\n   *\n   * @param {string | null | undefined} [encoding='utf8']\n   *   Character encoding to understand `value` as when it’s a `Uint8Array`\n   *   (default: `'utf-8'`).\n   * @returns {string}\n   *   Serialized file.\n   */\n  toString(encoding) {\n    if (this.value === undefined) {\n      return ''\n    }\n\n    if (typeof this.value === 'string') {\n      return this.value\n    }\n\n    const decoder = new TextDecoder(encoding || undefined)\n    return decoder.decode(this.value)\n  }\n}\n\n/**\n * Assert that `part` is not a path (as in, does not contain `path.sep`).\n *\n * @param {string | null | undefined} part\n *   File path part.\n * @param {string} name\n *   Part name.\n * @returns {undefined}\n *   Nothing.\n */\nfunction assertPart(part, name) {\n  if (part && part.includes(minpath.sep)) {\n    throw new Error(\n      '`' + name + '` cannot be a path: did not expect `' + minpath.sep + '`'\n    )\n  }\n}\n\n/**\n * Assert that `part` is not empty.\n *\n * @param {string | undefined} part\n *   Thing.\n * @param {string} name\n *   Part name.\n * @returns {asserts part is string}\n *   Nothing.\n */\nfunction assertNonEmpty(part, name) {\n  if (!part) {\n    throw new Error('`' + name + '` cannot be empty')\n  }\n}\n\n/**\n * Assert `path` exists.\n *\n * @param {string | undefined} path\n *   Path.\n * @param {string} name\n *   Dependency name.\n * @returns {asserts path is string}\n *   Nothing.\n */\nfunction assertPath(path, name) {\n  if (!path) {\n    throw new Error('Setting `' + name + '` requires `path` to be set too')\n  }\n}\n\n/**\n * Assert `value` is an `Uint8Array`.\n *\n * @param {unknown} value\n *   thing.\n * @returns {value is Uint8Array}\n *   Whether `value` is an `Uint8Array`.\n */\nfunction isUint8Array(value) {\n  return Boolean(\n    value &&\n      typeof value === 'object' &&\n      'byteLength' in value &&\n      'byteOffset' in value\n  )\n}\n","export const CallableInstance =\n  /**\n   * @type {new <Parameters extends Array<unknown>, Result>(property: string | symbol) => (...parameters: Parameters) => Result}\n   */\n  (\n    /** @type {unknown} */\n    (\n      /**\n       * @this {Function}\n       * @param {string | symbol} property\n       * @returns {(...parameters: Array<unknown>) => unknown}\n       */\n      function (property) {\n        const self = this\n        const constr = self.constructor\n        const proto = /** @type {Record<string | symbol, Function>} */ (\n          // Prototypes do exist.\n          // type-coverage:ignore-next-line\n          constr.prototype\n        )\n        const value = proto[property]\n        /** @type {(...parameters: Array<unknown>) => unknown} */\n        const apply = function () {\n          return value.apply(apply, arguments)\n        }\n\n        Object.setPrototypeOf(apply, proto)\n\n        // Not needed for us in `unified`: we only call this on the `copy`\n        // function,\n        // and we don't need to add its fields (`length`, `name`)\n        // over.\n        // See also: GH-246.\n        // const names = Object.getOwnPropertyNames(value)\n        //\n        // for (const p of names) {\n        //   const descriptor = Object.getOwnPropertyDescriptor(value, p)\n        //   if (descriptor) Object.defineProperty(apply, p, descriptor)\n        // }\n\n        return apply\n      }\n    )\n  )\n","/**\n * @typedef {import('trough').Pipeline} Pipeline\n *\n * @typedef {import('unist').Node} Node\n *\n * @typedef {import('vfile').Compatible} Compatible\n * @typedef {import('vfile').Value} Value\n *\n * @typedef {import('../index.js').CompileResultMap} CompileResultMap\n * @typedef {import('../index.js').Data} Data\n * @typedef {import('../index.js').Settings} Settings\n */\n\n/**\n * @typedef {CompileResultMap[keyof CompileResultMap]} CompileResults\n *   Acceptable results from compilers.\n *\n *   To register custom results, add them to\n *   {@linkcode CompileResultMap}.\n */\n\n/**\n * @template {Node} [Tree=Node]\n *   The node that the compiler receives (default: `Node`).\n * @template {CompileResults} [Result=CompileResults]\n *   The thing that the compiler yields (default: `CompileResults`).\n * @callback Compiler\n *   A **compiler** handles the compiling of a syntax tree to something else\n *   (in most cases, text) (TypeScript type).\n *\n *   It is used in the stringify phase and called with a {@linkcode Node}\n *   and {@linkcode VFile} representation of the document to compile.\n *   It should return the textual representation of the given tree (typically\n *   `string`).\n *\n *   > **Note**: unified typically compiles by serializing: most compilers\n *   > return `string` (or `Uint8Array`).\n *   > Some compilers, such as the one configured with\n *   > [`rehype-react`][rehype-react], return other values (in this case, a\n *   > React tree).\n *   > If you’re using a compiler that doesn’t serialize, expect different\n *   > result values.\n *   >\n *   > To register custom results in TypeScript, add them to\n *   > {@linkcode CompileResultMap}.\n *\n *   [rehype-react]: https://github.com/rehypejs/rehype-react\n * @param {Tree} tree\n *   Tree to compile.\n * @param {VFile} file\n *   File associated with `tree`.\n * @returns {Result}\n *   New content: compiled text (`string` or `Uint8Array`, for `file.value`) or\n *   something else (for `file.result`).\n */\n\n/**\n * @template {Node} [Tree=Node]\n *   The node that the parser yields (default: `Node`)\n * @callback Parser\n *   A **parser** handles the parsing of text to a syntax tree.\n *\n *   It is used in the parse phase and is called with a `string` and\n *   {@linkcode VFile} of the document to parse.\n *   It must return the syntax tree representation of the given file\n *   ({@linkcode Node}).\n * @param {string} document\n *   Document to parse.\n * @param {VFile} file\n *   File associated with `document`.\n * @returns {Tree}\n *   Node representing the given file.\n */\n\n/**\n * @typedef {(\n *   Plugin<Array<any>, any, any> |\n *   PluginTuple<Array<any>, any, any> |\n *   Preset\n * )} Pluggable\n *   Union of the different ways to add plugins and settings.\n */\n\n/**\n * @typedef {Array<Pluggable>} PluggableList\n *   List of plugins and presets.\n */\n\n// Note: we can’t use `callback` yet as it messes up `this`:\n//  <https://github.com/microsoft/TypeScript/issues/55197>.\n/**\n * @template {Array<unknown>} [PluginParameters=[]]\n *   Arguments passed to the plugin (default: `[]`, the empty tuple).\n * @template {Node | string | undefined} [Input=Node]\n *   Value that is expected as input (default: `Node`).\n *\n *   *   If the plugin returns a {@linkcode Transformer}, this\n *       should be the node it expects.\n *   *   If the plugin sets a {@linkcode Parser}, this should be\n *       `string`.\n *   *   If the plugin sets a {@linkcode Compiler}, this should be the\n *       node it expects.\n * @template [Output=Input]\n *   Value that is yielded as output (default: `Input`).\n *\n *   *   If the plugin returns a {@linkcode Transformer}, this\n *       should be the node that that yields.\n *   *   If the plugin sets a {@linkcode Parser}, this should be the\n *       node that it yields.\n *   *   If the plugin sets a {@linkcode Compiler}, this should be\n *       result it yields.\n * @typedef {(\n *   (this: Processor, ...parameters: PluginParameters) =>\n *     Input extends string ? // Parser.\n *        Output extends Node | undefined ? undefined | void : never :\n *     Output extends CompileResults ? // Compiler.\n *        Input extends Node | undefined ? undefined | void : never :\n *     Transformer<\n *       Input extends Node ? Input : Node,\n *       Output extends Node ? Output : Node\n *     > | undefined | void\n * )} Plugin\n *   Single plugin.\n *\n *   Plugins configure the processors they are applied on in the following\n *   ways:\n *\n *   *   they change the processor, such as the parser, the compiler, or by\n *       configuring data\n *   *   they specify how to handle trees and files\n *\n *   In practice, they are functions that can receive options and configure the\n *   processor (`this`).\n *\n *   > **Note**: plugins are called when the processor is *frozen*, not when\n *   > they are applied.\n */\n\n/**\n * Tuple of a plugin and its configuration.\n *\n * The first item is a plugin, the rest are its parameters.\n *\n * @template {Array<unknown>} [TupleParameters=[]]\n *   Arguments passed to the plugin (default: `[]`, the empty tuple).\n * @template {Node | string | undefined} [Input=undefined]\n *   Value that is expected as input (optional).\n *\n *   *   If the plugin returns a {@linkcode Transformer}, this\n *       should be the node it expects.\n *   *   If the plugin sets a {@linkcode Parser}, this should be\n *       `string`.\n *   *   If the plugin sets a {@linkcode Compiler}, this should be the\n *       node it expects.\n * @template [Output=undefined] (optional).\n *   Value that is yielded as output.\n *\n *   *   If the plugin returns a {@linkcode Transformer}, this\n *       should be the node that that yields.\n *   *   If the plugin sets a {@linkcode Parser}, this should be the\n *       node that it yields.\n *   *   If the plugin sets a {@linkcode Compiler}, this should be\n *       result it yields.\n * @typedef {(\n *   [\n *     plugin: Plugin<TupleParameters, Input, Output>,\n *     ...parameters: TupleParameters\n *   ]\n * )} PluginTuple\n */\n\n/**\n * @typedef Preset\n *   Sharable configuration.\n *\n *   They can contain plugins and settings.\n * @property {PluggableList | undefined} [plugins]\n *   List of plugins and presets (optional).\n * @property {Settings | undefined} [settings]\n *   Shared settings for parsers and compilers (optional).\n */\n\n/**\n * @template {VFile} [File=VFile]\n *   The file that the callback receives (default: `VFile`).\n * @callback ProcessCallback\n *   Callback called when the process is done.\n *\n *   Called with either an error or a result.\n * @param {Error | undefined} [error]\n *   Fatal error (optional).\n * @param {File | undefined} [file]\n *   Processed file (optional).\n * @returns {undefined}\n *   Nothing.\n */\n\n/**\n * @template {Node} [Tree=Node]\n *   The tree that the callback receives (default: `Node`).\n * @callback RunCallback\n *   Callback called when transformers are done.\n *\n *   Called with either an error or results.\n * @param {Error | undefined} [error]\n *   Fatal error (optional).\n * @param {Tree | undefined} [tree]\n *   Transformed tree (optional).\n * @param {VFile | undefined} [file]\n *   File (optional).\n * @returns {undefined}\n *   Nothing.\n */\n\n/**\n * @template {Node} [Output=Node]\n *   Node type that the transformer yields (default: `Node`).\n * @callback TransformCallback\n *   Callback passed to transforms.\n *\n *   If the signature of a `transformer` accepts a third argument, the\n *   transformer may perform asynchronous operations, and must call it.\n * @param {Error | undefined} [error]\n *   Fatal error to stop the process (optional).\n * @param {Output | undefined} [tree]\n *   New, changed, tree (optional).\n * @param {VFile | undefined} [file]\n *   New, changed, file (optional).\n * @returns {undefined}\n *   Nothing.\n */\n\n/**\n * @template {Node} [Input=Node]\n *   Node type that the transformer expects (default: `Node`).\n * @template {Node} [Output=Input]\n *   Node type that the transformer yields (default: `Input`).\n * @callback Transformer\n *   Transformers handle syntax trees and files.\n *\n *   They are functions that are called each time a syntax tree and file are\n *   passed through the run phase.\n *   When an error occurs in them (either because it’s thrown, returned,\n *   rejected, or passed to `next`), the process stops.\n *\n *   The run phase is handled by [`trough`][trough], see its documentation for\n *   the exact semantics of these functions.\n *\n *   > **Note**: you should likely ignore `next`: don’t accept it.\n *   > it supports callback-style async work.\n *   > But promises are likely easier to reason about.\n *\n *   [trough]: https://github.com/wooorm/trough#function-fninput-next\n * @param {Input} tree\n *   Tree to handle.\n * @param {VFile} file\n *   File to handle.\n * @param {TransformCallback<Output>} next\n *   Callback.\n * @returns {(\n *   Promise<Output | undefined | void> |\n *   Promise<never> | // For some reason this is needed separately.\n *   Output |\n *   Error |\n *   undefined |\n *   void\n * )}\n *   If you accept `next`, nothing.\n *   Otherwise:\n *\n *   *   `Error` — fatal error to stop the process\n *   *   `Promise<undefined>` or `undefined` — the next transformer keeps using\n *       same tree\n *   *   `Promise<Node>` or `Node` — new, changed, tree\n */\n\n/**\n * @template {Node | undefined} ParseTree\n *   Output of `parse`.\n * @template {Node | undefined} HeadTree\n *   Input for `run`.\n * @template {Node | undefined} TailTree\n *   Output for `run`.\n * @template {Node | undefined} CompileTree\n *   Input of `stringify`.\n * @template {CompileResults | undefined} CompileResult\n *   Output of `stringify`.\n * @template {Node | string | undefined} Input\n *   Input of plugin.\n * @template Output\n *   Output of plugin (optional).\n * @typedef {(\n *   Input extends string\n *     ? Output extends Node | undefined\n *       ? // Parser.\n *         Processor<\n *           Output extends undefined ? ParseTree : Output,\n *           HeadTree,\n *           TailTree,\n *           CompileTree,\n *           CompileResult\n *         >\n *       : // Unknown.\n *         Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>\n *     : Output extends CompileResults\n *     ? Input extends Node | undefined\n *       ? // Compiler.\n *         Processor<\n *           ParseTree,\n *           HeadTree,\n *           TailTree,\n *           Input extends undefined ? CompileTree : Input,\n *           Output extends undefined ? CompileResult : Output\n *         >\n *       : // Unknown.\n *         Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>\n *     : Input extends Node | undefined\n *     ? Output extends Node | undefined\n *       ? // Transform.\n *         Processor<\n *           ParseTree,\n *           HeadTree extends undefined ? Input : HeadTree,\n *           Output extends undefined ? TailTree : Output,\n *           CompileTree,\n *           CompileResult\n *         >\n *       : // Unknown.\n *         Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>\n *     : // Unknown.\n *       Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>\n * )} UsePlugin\n *   Create a processor based on the input/output of a {@link Plugin plugin}.\n */\n\n/**\n * @template {CompileResults | undefined} Result\n *   Node type that the transformer yields.\n * @typedef {(\n *   Result extends Value | undefined ?\n *     VFile :\n *     VFile & {result: Result}\n *   )} VFileWithOutput\n *   Type to generate a {@linkcode VFile} corresponding to a compiler result.\n *\n *   If a result that is not acceptable on a `VFile` is used, that will\n *   be stored on the `result` field of {@linkcode VFile}.\n */\n\nimport {bail} from 'bail'\nimport extend from 'extend'\nimport {ok as assert} from 'devlop'\nimport isPlainObj from 'is-plain-obj'\nimport {trough} from 'trough'\nimport {VFile} from 'vfile'\nimport {CallableInstance} from './callable-instance.js'\n\n// To do: next major: drop `Compiler`, `Parser`: prefer lowercase.\n\n// To do: we could start yielding `never` in TS when a parser is missing and\n// `parse` is called.\n// Currently, we allow directly setting `processor.parser`, which is untyped.\n\nconst own = {}.hasOwnProperty\n\n/**\n * @template {Node | undefined} [ParseTree=undefined]\n *   Output of `parse` (optional).\n * @template {Node | undefined} [HeadTree=undefined]\n *   Input for `run` (optional).\n * @template {Node | undefined} [TailTree=undefined]\n *   Output for `run` (optional).\n * @template {Node | undefined} [CompileTree=undefined]\n *   Input of `stringify` (optional).\n * @template {CompileResults | undefined} [CompileResult=undefined]\n *   Output of `stringify` (optional).\n * @extends {CallableInstance<[], Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>>}\n */\nexport class Processor extends CallableInstance {\n  /**\n   * Create a processor.\n   */\n  constructor() {\n    // If `Processor()` is called (w/o new), `copy` is called instead.\n    super('copy')\n\n    /**\n     * Compiler to use (deprecated).\n     *\n     * @deprecated\n     *   Use `compiler` instead.\n     * @type {(\n     *   Compiler<\n     *     CompileTree extends undefined ? Node : CompileTree,\n     *     CompileResult extends undefined ? CompileResults : CompileResult\n     *   > |\n     *   undefined\n     * )}\n     */\n    this.Compiler = undefined\n\n    /**\n     * Parser to use (deprecated).\n     *\n     * @deprecated\n     *   Use `parser` instead.\n     * @type {(\n     *   Parser<ParseTree extends undefined ? Node : ParseTree> |\n     *   undefined\n     * )}\n     */\n    this.Parser = undefined\n\n    // Note: the following fields are considered private.\n    // However, they are needed for tests, and TSC generates an untyped\n    // `private freezeIndex` field for, which trips `type-coverage` up.\n    // Instead, we use `@deprecated` to visualize that they shouldn’t be used.\n    /**\n     * Internal list of configured plugins.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {Array<PluginTuple<Array<unknown>>>}\n     */\n    this.attachers = []\n\n    /**\n     * Compiler to use.\n     *\n     * @type {(\n     *   Compiler<\n     *     CompileTree extends undefined ? Node : CompileTree,\n     *     CompileResult extends undefined ? CompileResults : CompileResult\n     *   > |\n     *   undefined\n     * )}\n     */\n    this.compiler = undefined\n\n    /**\n     * Internal state to track where we are while freezing.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {number}\n     */\n    this.freezeIndex = -1\n\n    /**\n     * Internal state to track whether we’re frozen.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {boolean | undefined}\n     */\n    this.frozen = undefined\n\n    /**\n     * Internal state.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {Data}\n     */\n    this.namespace = {}\n\n    /**\n     * Parser to use.\n     *\n     * @type {(\n     *   Parser<ParseTree extends undefined ? Node : ParseTree> |\n     *   undefined\n     * )}\n     */\n    this.parser = undefined\n\n    /**\n     * Internal list of configured transformers.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {Pipeline}\n     */\n    this.transformers = trough()\n  }\n\n  /**\n   * Copy a processor.\n   *\n   * @deprecated\n   *   This is a private internal method and should not be used.\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *   New *unfrozen* processor ({@linkcode Processor}) that is\n   *   configured to work the same as its ancestor.\n   *   When the descendant processor is configured in the future it does not\n   *   affect the ancestral processor.\n   */\n  copy() {\n    // Cast as the type parameters will be the same after attaching.\n    const destination =\n      /** @type {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>} */ (\n        new Processor()\n      )\n    let index = -1\n\n    while (++index < this.attachers.length) {\n      const attacher = this.attachers[index]\n      destination.use(...attacher)\n    }\n\n    destination.data(extend(true, {}, this.namespace))\n\n    return destination\n  }\n\n  /**\n   * Configure the processor with info available to all plugins.\n   * Information is stored in an object.\n   *\n   * Typically, options can be given to a specific plugin, but sometimes it\n   * makes sense to have information shared with several plugins.\n   * For example, a list of HTML elements that are self-closing, which is\n   * needed during all phases.\n   *\n   * > **Note**: setting information cannot occur on *frozen* processors.\n   * > Call the processor first to create a new unfrozen processor.\n   *\n   * > **Note**: to register custom data in TypeScript, augment the\n   * > {@linkcode Data} interface.\n   *\n   * @example\n   *   This example show how to get and set info:\n   *\n   *   ```js\n   *   import {unified} from 'unified'\n   *\n   *   const processor = unified().data('alpha', 'bravo')\n   *\n   *   processor.data('alpha') // => 'bravo'\n   *\n   *   processor.data() // => {alpha: 'bravo'}\n   *\n   *   processor.data({charlie: 'delta'})\n   *\n   *   processor.data() // => {charlie: 'delta'}\n   *   ```\n   *\n   * @template {keyof Data} Key\n   *\n   * @overload\n   * @returns {Data}\n   *\n   * @overload\n   * @param {Data} dataset\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *\n   * @overload\n   * @param {Key} key\n   * @returns {Data[Key]}\n   *\n   * @overload\n   * @param {Key} key\n   * @param {Data[Key]} value\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *\n   * @param {Data | Key} [key]\n   *   Key to get or set, or entire dataset to set, or nothing to get the\n   *   entire dataset (optional).\n   * @param {Data[Key]} [value]\n   *   Value to set (optional).\n   * @returns {unknown}\n   *   The current processor when setting, the value at `key` when getting, or\n   *   the entire dataset when getting without key.\n   */\n  data(key, value) {\n    if (typeof key === 'string') {\n      // Set `key`.\n      if (arguments.length === 2) {\n        assertUnfrozen('data', this.frozen)\n        this.namespace[key] = value\n        return this\n      }\n\n      // Get `key`.\n      return (own.call(this.namespace, key) && this.namespace[key]) || undefined\n    }\n\n    // Set space.\n    if (key) {\n      assertUnfrozen('data', this.frozen)\n      this.namespace = key\n      return this\n    }\n\n    // Get space.\n    return this.namespace\n  }\n\n  /**\n   * Freeze a processor.\n   *\n   * Frozen processors are meant to be extended and not to be configured\n   * directly.\n   *\n   * When a processor is frozen it cannot be unfrozen.\n   * New processors working the same way can be created by calling the\n   * processor.\n   *\n   * It’s possible to freeze processors explicitly by calling `.freeze()`.\n   * Processors freeze automatically when `.parse()`, `.run()`, `.runSync()`,\n   * `.stringify()`, `.process()`, or `.processSync()` are called.\n   *\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *   The current processor.\n   */\n  freeze() {\n    if (this.frozen) {\n      return this\n    }\n\n    // Cast so that we can type plugins easier.\n    // Plugins are supposed to be usable on different processors, not just on\n    // this exact processor.\n    const self = /** @type {Processor} */ (/** @type {unknown} */ (this))\n\n    while (++this.freezeIndex < this.attachers.length) {\n      const [attacher, ...options] = this.attachers[this.freezeIndex]\n\n      if (options[0] === false) {\n        continue\n      }\n\n      if (options[0] === true) {\n        options[0] = undefined\n      }\n\n      const transformer = attacher.call(self, ...options)\n\n      if (typeof transformer === 'function') {\n        this.transformers.use(transformer)\n      }\n    }\n\n    this.frozen = true\n    this.freezeIndex = Number.POSITIVE_INFINITY\n\n    return this\n  }\n\n  /**\n   * Parse text to a syntax tree.\n   *\n   * > **Note**: `parse` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `parse` performs the parse phase, not the run phase or other\n   * > phases.\n   *\n   * @param {Compatible | undefined} [file]\n   *   file to parse (optional); typically `string` or `VFile`; any value\n   *   accepted as `x` in `new VFile(x)`.\n   * @returns {ParseTree extends undefined ? Node : ParseTree}\n   *   Syntax tree representing `file`.\n   */\n  parse(file) {\n    this.freeze()\n    const realFile = vfile(file)\n    const parser = this.parser || this.Parser\n    assertParser('parse', parser)\n    return parser(String(realFile), realFile)\n  }\n\n  /**\n   * Process the given file as configured on the processor.\n   *\n   * > **Note**: `process` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `process` performs the parse, run, and stringify phases.\n   *\n   * @overload\n   * @param {Compatible | undefined} file\n   * @param {ProcessCallback<VFileWithOutput<CompileResult>>} done\n   * @returns {undefined}\n   *\n   * @overload\n   * @param {Compatible | undefined} [file]\n   * @returns {Promise<VFileWithOutput<CompileResult>>}\n   *\n   * @param {Compatible | undefined} [file]\n   *   File (optional); typically `string` or `VFile`]; any value accepted as\n   *   `x` in `new VFile(x)`.\n   * @param {ProcessCallback<VFileWithOutput<CompileResult>> | undefined} [done]\n   *   Callback (optional).\n   * @returns {Promise<VFile> | undefined}\n   *   Nothing if `done` is given.\n   *   Otherwise a promise, rejected with a fatal error or resolved with the\n   *   processed file.\n   *\n   *   The parsed, transformed, and compiled value is available at\n   *   `file.value` (see note).\n   *\n   *   > **Note**: unified typically compiles by serializing: most\n   *   > compilers return `string` (or `Uint8Array`).\n   *   > Some compilers, such as the one configured with\n   *   > [`rehype-react`][rehype-react], return other values (in this case, a\n   *   > React tree).\n   *   > If you’re using a compiler that doesn’t serialize, expect different\n   *   > result values.\n   *   >\n   *   > To register custom results in TypeScript, add them to\n   *   > {@linkcode CompileResultMap}.\n   *\n   *   [rehype-react]: https://github.com/rehypejs/rehype-react\n   */\n  process(file, done) {\n    const self = this\n\n    this.freeze()\n    assertParser('process', this.parser || this.Parser)\n    assertCompiler('process', this.compiler || this.Compiler)\n\n    return done ? executor(undefined, done) : new Promise(executor)\n\n    // Note: `void`s needed for TS.\n    /**\n     * @param {((file: VFileWithOutput<CompileResult>) => undefined | void) | undefined} resolve\n     * @param {(error: Error | undefined) => undefined | void} reject\n     * @returns {undefined}\n     */\n    function executor(resolve, reject) {\n      const realFile = vfile(file)\n      // Assume `ParseTree` (the result of the parser) matches `HeadTree` (the\n      // input of the first transform).\n      const parseTree =\n        /** @type {HeadTree extends undefined ? Node : HeadTree} */ (\n          /** @type {unknown} */ (self.parse(realFile))\n        )\n\n      self.run(parseTree, realFile, function (error, tree, file) {\n        if (error || !tree || !file) {\n          return realDone(error)\n        }\n\n        // Assume `TailTree` (the output of the last transform) matches\n        // `CompileTree` (the input of the compiler).\n        const compileTree =\n          /** @type {CompileTree extends undefined ? Node : CompileTree} */ (\n            /** @type {unknown} */ (tree)\n          )\n\n        const compileResult = self.stringify(compileTree, file)\n\n        if (looksLikeAValue(compileResult)) {\n          file.value = compileResult\n        } else {\n          file.result = compileResult\n        }\n\n        realDone(error, /** @type {VFileWithOutput<CompileResult>} */ (file))\n      })\n\n      /**\n       * @param {Error | undefined} error\n       * @param {VFileWithOutput<CompileResult> | undefined} [file]\n       * @returns {undefined}\n       */\n      function realDone(error, file) {\n        if (error || !file) {\n          reject(error)\n        } else if (resolve) {\n          resolve(file)\n        } else {\n          assert(done, '`done` is defined if `resolve` is not')\n          done(undefined, file)\n        }\n      }\n    }\n  }\n\n  /**\n   * Process the given file as configured on the processor.\n   *\n   * An error is thrown if asynchronous transforms are configured.\n   *\n   * > **Note**: `processSync` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `processSync` performs the parse, run, and stringify phases.\n   *\n   * @param {Compatible | undefined} [file]\n   *   File (optional); typically `string` or `VFile`; any value accepted as\n   *   `x` in `new VFile(x)`.\n   * @returns {VFileWithOutput<CompileResult>}\n   *   The processed file.\n   *\n   *   The parsed, transformed, and compiled value is available at\n   *   `file.value` (see note).\n   *\n   *   > **Note**: unified typically compiles by serializing: most\n   *   > compilers return `string` (or `Uint8Array`).\n   *   > Some compilers, such as the one configured with\n   *   > [`rehype-react`][rehype-react], return other values (in this case, a\n   *   > React tree).\n   *   > If you’re using a compiler that doesn’t serialize, expect different\n   *   > result values.\n   *   >\n   *   > To register custom results in TypeScript, add them to\n   *   > {@linkcode CompileResultMap}.\n   *\n   *   [rehype-react]: https://github.com/rehypejs/rehype-react\n   */\n  processSync(file) {\n    /** @type {boolean} */\n    let complete = false\n    /** @type {VFileWithOutput<CompileResult> | undefined} */\n    let result\n\n    this.freeze()\n    assertParser('processSync', this.parser || this.Parser)\n    assertCompiler('processSync', this.compiler || this.Compiler)\n\n    this.process(file, realDone)\n    assertDone('processSync', 'process', complete)\n    assert(result, 'we either bailed on an error or have a tree')\n\n    return result\n\n    /**\n     * @type {ProcessCallback<VFileWithOutput<CompileResult>>}\n     */\n    function realDone(error, file) {\n      complete = true\n      bail(error)\n      result = file\n    }\n  }\n\n  /**\n   * Run *transformers* on a syntax tree.\n   *\n   * > **Note**: `run` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `run` performs the run phase, not other phases.\n   *\n   * @overload\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} done\n   * @returns {undefined}\n   *\n   * @overload\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   * @param {Compatible | undefined} file\n   * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} done\n   * @returns {undefined}\n   *\n   * @overload\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   * @param {Compatible | undefined} [file]\n   * @returns {Promise<TailTree extends undefined ? Node : TailTree>}\n   *\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   *   Tree to transform and inspect.\n   * @param {(\n   *   RunCallback<TailTree extends undefined ? Node : TailTree> |\n   *   Compatible\n   * )} [file]\n   *   File associated with `node` (optional); any value accepted as `x` in\n   *   `new VFile(x)`.\n   * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} [done]\n   *   Callback (optional).\n   * @returns {Promise<TailTree extends undefined ? Node : TailTree> | undefined}\n   *   Nothing if `done` is given.\n   *   Otherwise, a promise rejected with a fatal error or resolved with the\n   *   transformed tree.\n   */\n  run(tree, file, done) {\n    assertNode(tree)\n    this.freeze()\n\n    const transformers = this.transformers\n\n    if (!done && typeof file === 'function') {\n      done = file\n      file = undefined\n    }\n\n    return done ? executor(undefined, done) : new Promise(executor)\n\n    // Note: `void`s needed for TS.\n    /**\n     * @param {(\n     *   ((tree: TailTree extends undefined ? Node : TailTree) => undefined | void) |\n     *   undefined\n     * )} resolve\n     * @param {(error: Error) => undefined | void} reject\n     * @returns {undefined}\n     */\n    function executor(resolve, reject) {\n      assert(\n        typeof file !== 'function',\n        '`file` can’t be a `done` anymore, we checked'\n      )\n      const realFile = vfile(file)\n      transformers.run(tree, realFile, realDone)\n\n      /**\n       * @param {Error | undefined} error\n       * @param {Node} outputTree\n       * @param {VFile} file\n       * @returns {undefined}\n       */\n      function realDone(error, outputTree, file) {\n        const resultingTree =\n          /** @type {TailTree extends undefined ? Node : TailTree} */ (\n            outputTree || tree\n          )\n\n        if (error) {\n          reject(error)\n        } else if (resolve) {\n          resolve(resultingTree)\n        } else {\n          assert(done, '`done` is defined if `resolve` is not')\n          done(undefined, resultingTree, file)\n        }\n      }\n    }\n  }\n\n  /**\n   * Run *transformers* on a syntax tree.\n   *\n   * An error is thrown if asynchronous transforms are configured.\n   *\n   * > **Note**: `runSync` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `runSync` performs the run phase, not other phases.\n   *\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   *   Tree to transform and inspect.\n   * @param {Compatible | undefined} [file]\n   *   File associated with `node` (optional); any value accepted as `x` in\n   *   `new VFile(x)`.\n   * @returns {TailTree extends undefined ? Node : TailTree}\n   *   Transformed tree.\n   */\n  runSync(tree, file) {\n    /** @type {boolean} */\n    let complete = false\n    /** @type {(TailTree extends undefined ? Node : TailTree) | undefined} */\n    let result\n\n    this.run(tree, file, realDone)\n\n    assertDone('runSync', 'run', complete)\n    assert(result, 'we either bailed on an error or have a tree')\n    return result\n\n    /**\n     * @type {RunCallback<TailTree extends undefined ? Node : TailTree>}\n     */\n    function realDone(error, tree) {\n      bail(error)\n      result = tree\n      complete = true\n    }\n  }\n\n  /**\n   * Compile a syntax tree.\n   *\n   * > **Note**: `stringify` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `stringify` performs the stringify phase, not the run phase\n   * > or other phases.\n   *\n   * @param {CompileTree extends undefined ? Node : CompileTree} tree\n   *   Tree to compile.\n   * @param {Compatible | undefined} [file]\n   *   File associated with `node` (optional); any value accepted as `x` in\n   *   `new VFile(x)`.\n   * @returns {CompileResult extends undefined ? Value : CompileResult}\n   *   Textual representation of the tree (see note).\n   *\n   *   > **Note**: unified typically compiles by serializing: most compilers\n   *   > return `string` (or `Uint8Array`).\n   *   > Some compilers, such as the one configured with\n   *   > [`rehype-react`][rehype-react], return other values (in this case, a\n   *   > React tree).\n   *   > If you’re using a compiler that doesn’t serialize, expect different\n   *   > result values.\n   *   >\n   *   > To register custom results in TypeScript, add them to\n   *   > {@linkcode CompileResultMap}.\n   *\n   *   [rehype-react]: https://github.com/rehypejs/rehype-react\n   */\n  stringify(tree, file) {\n    this.freeze()\n    const realFile = vfile(file)\n    const compiler = this.compiler || this.Compiler\n    assertCompiler('stringify', compiler)\n    assertNode(tree)\n\n    return compiler(tree, realFile)\n  }\n\n  /**\n   * Configure the processor to use a plugin, a list of usable values, or a\n   * preset.\n   *\n   * If the processor is already using a plugin, the previous plugin\n   * configuration is changed based on the options that are passed in.\n   * In other words, the plugin is not added a second time.\n   *\n   * > **Note**: `use` cannot be called on *frozen* processors.\n   * > Call the processor first to create a new unfrozen processor.\n   *\n   * @example\n   *   There are many ways to pass plugins to `.use()`.\n   *   This example gives an overview:\n   *\n   *   ```js\n   *   import {unified} from 'unified'\n   *\n   *   unified()\n   *     // Plugin with options:\n   *     .use(pluginA, {x: true, y: true})\n   *     // Passing the same plugin again merges configuration (to `{x: true, y: false, z: true}`):\n   *     .use(pluginA, {y: false, z: true})\n   *     // Plugins:\n   *     .use([pluginB, pluginC])\n   *     // Two plugins, the second with options:\n   *     .use([pluginD, [pluginE, {}]])\n   *     // Preset with plugins and settings:\n   *     .use({plugins: [pluginF, [pluginG, {}]], settings: {position: false}})\n   *     // Settings only:\n   *     .use({settings: {position: false}})\n   *   ```\n   *\n   * @template {Array<unknown>} [Parameters=[]]\n   * @template {Node | string | undefined} [Input=undefined]\n   * @template [Output=Input]\n   *\n   * @overload\n   * @param {Preset | null | undefined} [preset]\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *\n   * @overload\n   * @param {PluggableList} list\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *\n   * @overload\n   * @param {Plugin<Parameters, Input, Output>} plugin\n   * @param {...(Parameters | [boolean])} parameters\n   * @returns {UsePlugin<ParseTree, HeadTree, TailTree, CompileTree, CompileResult, Input, Output>}\n   *\n   * @param {PluggableList | Plugin | Preset | null | undefined} value\n   *   Usable value.\n   * @param {...unknown} parameters\n   *   Parameters, when a plugin is given as a usable value.\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *   Current processor.\n   */\n  use(value, ...parameters) {\n    const attachers = this.attachers\n    const namespace = this.namespace\n\n    assertUnfrozen('use', this.frozen)\n\n    if (value === null || value === undefined) {\n      // Empty.\n    } else if (typeof value === 'function') {\n      addPlugin(value, parameters)\n    } else if (typeof value === 'object') {\n      if (Array.isArray(value)) {\n        addList(value)\n      } else {\n        addPreset(value)\n      }\n    } else {\n      throw new TypeError('Expected usable value, not `' + value + '`')\n    }\n\n    return this\n\n    /**\n     * @param {Pluggable} value\n     * @returns {undefined}\n     */\n    function add(value) {\n      if (typeof value === 'function') {\n        addPlugin(value, [])\n      } else if (typeof value === 'object') {\n        if (Array.isArray(value)) {\n          const [plugin, ...parameters] =\n            /** @type {PluginTuple<Array<unknown>>} */ (value)\n          addPlugin(plugin, parameters)\n        } else {\n          addPreset(value)\n        }\n      } else {\n        throw new TypeError('Expected usable value, not `' + value + '`')\n      }\n    }\n\n    /**\n     * @param {Preset} result\n     * @returns {undefined}\n     */\n    function addPreset(result) {\n      if (!('plugins' in result) && !('settings' in result)) {\n        throw new Error(\n          'Expected usable value but received an empty preset, which is probably a mistake: presets typically come with `plugins` and sometimes with `settings`, but this has neither'\n        )\n      }\n\n      addList(result.plugins)\n\n      if (result.settings) {\n        namespace.settings = extend(true, namespace.settings, result.settings)\n      }\n    }\n\n    /**\n     * @param {PluggableList | null | undefined} plugins\n     * @returns {undefined}\n     */\n    function addList(plugins) {\n      let index = -1\n\n      if (plugins === null || plugins === undefined) {\n        // Empty.\n      } else if (Array.isArray(plugins)) {\n        while (++index < plugins.length) {\n          const thing = plugins[index]\n          add(thing)\n        }\n      } else {\n        throw new TypeError('Expected a list of plugins, not `' + plugins + '`')\n      }\n    }\n\n    /**\n     * @param {Plugin} plugin\n     * @param {Array<unknown>} parameters\n     * @returns {undefined}\n     */\n    function addPlugin(plugin, parameters) {\n      let index = -1\n      let entryIndex = -1\n\n      while (++index < attachers.length) {\n        if (attachers[index][0] === plugin) {\n          entryIndex = index\n          break\n        }\n      }\n\n      if (entryIndex === -1) {\n        attachers.push([plugin, ...parameters])\n      }\n      // Only set if there was at least a `primary` value, otherwise we’d change\n      // `arguments.length`.\n      else if (parameters.length > 0) {\n        let [primary, ...rest] = parameters\n        const currentPrimary = attachers[entryIndex][1]\n        if (isPlainObj(currentPrimary) && isPlainObj(primary)) {\n          primary = extend(true, currentPrimary, primary)\n        }\n\n        attachers[entryIndex] = [plugin, primary, ...rest]\n      }\n    }\n  }\n}\n\n// Note: this returns a *callable* instance.\n// That’s why it’s documented as a function.\n/**\n * Create a new processor.\n *\n * @example\n *   This example shows how a new processor can be created (from `remark`) and linked\n *   to **stdin**(4) and **stdout**(4).\n *\n *   ```js\n *   import process from 'node:process'\n *   import concatStream from 'concat-stream'\n *   import {remark} from 'remark'\n *\n *   process.stdin.pipe(\n *     concatStream(function (buf) {\n *       process.stdout.write(String(remark().processSync(buf)))\n *     })\n *   )\n *   ```\n *\n * @returns\n *   New *unfrozen* processor (`processor`).\n *\n *   This processor is configured to work the same as its ancestor.\n *   When the descendant processor is configured in the future it does not\n *   affect the ancestral processor.\n */\nexport const unified = new Processor().freeze()\n\n/**\n * Assert a parser is available.\n *\n * @param {string} name\n * @param {unknown} value\n * @returns {asserts value is Parser}\n */\nfunction assertParser(name, value) {\n  if (typeof value !== 'function') {\n    throw new TypeError('Cannot `' + name + '` without `parser`')\n  }\n}\n\n/**\n * Assert a compiler is available.\n *\n * @param {string} name\n * @param {unknown} value\n * @returns {asserts value is Compiler}\n */\nfunction assertCompiler(name, value) {\n  if (typeof value !== 'function') {\n    throw new TypeError('Cannot `' + name + '` without `compiler`')\n  }\n}\n\n/**\n * Assert the processor is not frozen.\n *\n * @param {string} name\n * @param {unknown} frozen\n * @returns {asserts frozen is false}\n */\nfunction assertUnfrozen(name, frozen) {\n  if (frozen) {\n    throw new Error(\n      'Cannot call `' +\n        name +\n        '` on a frozen processor.\\nCreate a new processor first, by calling it: use `processor()` instead of `processor`.'\n    )\n  }\n}\n\n/**\n * Assert `node` is a unist node.\n *\n * @param {unknown} node\n * @returns {asserts node is Node}\n */\nfunction assertNode(node) {\n  // `isPlainObj` unfortunately uses `any` instead of `unknown`.\n  // type-coverage:ignore-next-line\n  if (!isPlainObj(node) || typeof node.type !== 'string') {\n    throw new TypeError('Expected node, got `' + node + '`')\n    // Fine.\n  }\n}\n\n/**\n * Assert that `complete` is `true`.\n *\n * @param {string} name\n * @param {string} asyncName\n * @param {unknown} complete\n * @returns {asserts complete is true}\n */\nfunction assertDone(name, asyncName, complete) {\n  if (!complete) {\n    throw new Error(\n      '`' + name + '` finished async. Use `' + asyncName + '` instead'\n    )\n  }\n}\n\n/**\n * @param {Compatible | undefined} [value]\n * @returns {VFile}\n */\nfunction vfile(value) {\n  return looksLikeAVFile(value) ? value : new VFile(value)\n}\n\n/**\n * @param {Compatible | undefined} [value]\n * @returns {value is VFile}\n */\nfunction looksLikeAVFile(value) {\n  return Boolean(\n    value &&\n      typeof value === 'object' &&\n      'message' in value &&\n      'messages' in value\n  )\n}\n\n/**\n * @param {unknown} [value]\n * @returns {value is Value}\n */\nfunction looksLikeAValue(value) {\n  return typeof value === 'string' || isUint8Array(value)\n}\n\n/**\n * Assert `value` is an `Uint8Array`.\n *\n * @param {unknown} value\n *   thing.\n * @returns {value is Uint8Array}\n *   Whether `value` is an `Uint8Array`.\n */\nfunction isUint8Array(value) {\n  return Boolean(\n    value &&\n      typeof value === 'object' &&\n      'byteLength' in value &&\n      'byteOffset' in value\n  )\n}\n","// Register `Raw` in tree:\n/// <reference types=\"mdast-util-to-hast\" />\n\n/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Nodes} Nodes\n * @typedef {import('hast').Parents} Parents\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast-util-to-jsx-runtime').Components} JsxRuntimeComponents\n * @typedef {import('remark-rehype').Options} RemarkRehypeOptions\n * @typedef {import('unist-util-visit').BuildVisitor<Root>} Visitor\n * @typedef {import('unified').PluggableList} PluggableList\n */\n\n/**\n * @callback AllowElement\n *   Filter elements.\n * @param {Readonly<Element>} element\n *   Element to check.\n * @param {number} index\n *   Index of `element` in `parent`.\n * @param {Readonly<Parents> | undefined} parent\n *   Parent of `element`.\n * @returns {boolean | null | undefined}\n *   Whether to allow `element` (default: `false`).\n *\n * @typedef {Partial<JsxRuntimeComponents>} Components\n *   Map tag names to components.\n *\n * @typedef Deprecation\n *   Deprecation.\n * @property {string} from\n *   Old field.\n * @property {string} id\n *   ID in readme.\n * @property {keyof Options} [to]\n *   New field.\n *\n * @typedef Options\n *   Configuration.\n * @property {AllowElement | null | undefined} [allowElement]\n *   Filter elements (optional);\n *   `allowedElements` / `disallowedElements` is used first.\n * @property {ReadonlyArray<string> | null | undefined} [allowedElements]\n *   Tag names to allow (default: all tag names);\n *   cannot combine w/ `disallowedElements`.\n * @property {string | null | undefined} [children]\n *   Markdown.\n * @property {string | null | undefined} [className]\n *   Wrap in a `div` with this class name.\n * @property {Components | null | undefined} [components]\n *   Map tag names to components.\n * @property {ReadonlyArray<string> | null | undefined} [disallowedElements]\n *   Tag names to disallow (default: `[]`);\n *   cannot combine w/ `allowedElements`.\n * @property {PluggableList | null | undefined} [rehypePlugins]\n *   List of rehype plugins to use.\n * @property {PluggableList | null | undefined} [remarkPlugins]\n *   List of remark plugins to use.\n * @property {Readonly<RemarkRehypeOptions> | null | undefined} [remarkRehypeOptions]\n *   Options to pass through to `remark-rehype`.\n * @property {boolean | null | undefined} [skipHtml=false]\n *   Ignore HTML in markdown completely (default: `false`).\n * @property {boolean | null | undefined} [unwrapDisallowed=false]\n *   Extract (unwrap) what’s in disallowed elements (default: `false`);\n *   normally when say `strong` is not allowed, it and it’s children are dropped,\n *   with `unwrapDisallowed` the element itself is replaced by its children.\n * @property {UrlTransform | null | undefined} [urlTransform]\n *   Change URLs (default: `defaultUrlTransform`)\n *\n * @callback UrlTransform\n *   Transform all URLs.\n * @param {string} url\n *   URL.\n * @param {string} key\n *   Property name (example: `'href'`).\n * @param {Readonly<Element>} node\n *   Node.\n * @returns {string | null | undefined}\n *   Transformed URL (optional).\n */\n\nimport {unreachable} from 'devlop'\nimport {toJsxRuntime} from 'hast-util-to-jsx-runtime'\nimport {urlAttributes} from 'html-url-attributes'\n// @ts-expect-error: untyped.\nimport {Fragment, jsx, jsxs} from 'react/jsx-runtime'\nimport remarkParse from 'remark-parse'\nimport remarkRehype from 'remark-rehype'\nimport {unified} from 'unified'\nimport {visit} from 'unist-util-visit'\nimport {VFile} from 'vfile'\n\nconst changelog =\n  'https://github.com/remarkjs/react-markdown/blob/main/changelog.md'\n\n/** @type {PluggableList} */\nconst emptyPlugins = []\n/** @type {Readonly<RemarkRehypeOptions>} */\nconst emptyRemarkRehypeOptions = {allowDangerousHtml: true}\nconst safeProtocol = /^(https?|ircs?|mailto|xmpp)$/i\n\n// Mutable because we `delete` any time it’s used and a message is sent.\n/** @type {ReadonlyArray<Readonly<Deprecation>>} */\nconst deprecations = [\n  {from: 'astPlugins', id: 'remove-buggy-html-in-markdown-parser'},\n  {from: 'allowDangerousHtml', id: 'remove-buggy-html-in-markdown-parser'},\n  {\n    from: 'allowNode',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes',\n    to: 'allowElement'\n  },\n  {\n    from: 'allowedTypes',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes',\n    to: 'allowedElements'\n  },\n  {\n    from: 'disallowedTypes',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes',\n    to: 'disallowedElements'\n  },\n  {from: 'escapeHtml', id: 'remove-buggy-html-in-markdown-parser'},\n  {from: 'includeElementIndex', id: '#remove-includeelementindex'},\n  {\n    from: 'includeNodeIndex',\n    id: 'change-includenodeindex-to-includeelementindex'\n  },\n  {from: 'linkTarget', id: 'remove-linktarget'},\n  {from: 'plugins', id: 'change-plugins-to-remarkplugins', to: 'remarkPlugins'},\n  {from: 'rawSourcePos', id: '#remove-rawsourcepos'},\n  {from: 'renderers', id: 'change-renderers-to-components', to: 'components'},\n  {from: 'source', id: 'change-source-to-children', to: 'children'},\n  {from: 'sourcePos', id: '#remove-sourcepos'},\n  {from: 'transformImageUri', id: '#add-urltransform', to: 'urlTransform'},\n  {from: 'transformLinkUri', id: '#add-urltransform', to: 'urlTransform'}\n]\n\n/**\n * Component to render markdown.\n *\n * @param {Readonly<Options>} options\n *   Props.\n * @returns {JSX.Element}\n *   React element.\n */\nexport function Markdown(options) {\n  const allowedElements = options.allowedElements\n  const allowElement = options.allowElement\n  const children = options.children || ''\n  const className = options.className\n  const components = options.components\n  const disallowedElements = options.disallowedElements\n  const rehypePlugins = options.rehypePlugins || emptyPlugins\n  const remarkPlugins = options.remarkPlugins || emptyPlugins\n  const remarkRehypeOptions = options.remarkRehypeOptions\n    ? {...options.remarkRehypeOptions, ...emptyRemarkRehypeOptions}\n    : emptyRemarkRehypeOptions\n  const skipHtml = options.skipHtml\n  const unwrapDisallowed = options.unwrapDisallowed\n  const urlTransform = options.urlTransform || defaultUrlTransform\n\n  const processor = unified()\n    .use(remarkParse)\n    .use(remarkPlugins)\n    .use(remarkRehype, remarkRehypeOptions)\n    .use(rehypePlugins)\n\n  const file = new VFile()\n\n  if (typeof children === 'string') {\n    file.value = children\n  } else {\n    unreachable(\n      'Unexpected value `' +\n        children +\n        '` for `children` prop, expected `string`'\n    )\n  }\n\n  if (allowedElements && disallowedElements) {\n    unreachable(\n      'Unexpected combined `allowedElements` and `disallowedElements`, expected one or the other'\n    )\n  }\n\n  for (const deprecation of deprecations) {\n    if (Object.hasOwn(options, deprecation.from)) {\n      unreachable(\n        'Unexpected `' +\n          deprecation.from +\n          '` prop, ' +\n          (deprecation.to\n            ? 'use `' + deprecation.to + '` instead'\n            : 'remove it') +\n          ' (see <' +\n          changelog +\n          '#' +\n          deprecation.id +\n          '> for more info)'\n      )\n    }\n  }\n\n  const mdastTree = processor.parse(file)\n  /** @type {Nodes} */\n  let hastTree = processor.runSync(mdastTree, file)\n\n  // Wrap in `div` if there’s a class name.\n  if (className) {\n    hastTree = {\n      type: 'element',\n      tagName: 'div',\n      properties: {className},\n      // Assume no doctypes.\n      children: /** @type {Array<ElementContent>} */ (\n        hastTree.type === 'root' ? hastTree.children : [hastTree]\n      )\n    }\n  }\n\n  visit(hastTree, transform)\n\n  return toJsxRuntime(hastTree, {\n    Fragment,\n    components,\n    ignoreInvalidStyle: true,\n    jsx,\n    jsxs,\n    passKeys: true,\n    passNode: true\n  })\n\n  /** @type {Visitor} */\n  function transform(node, index, parent) {\n    if (node.type === 'raw' && parent && typeof index === 'number') {\n      if (skipHtml) {\n        parent.children.splice(index, 1)\n      } else {\n        parent.children[index] = {type: 'text', value: node.value}\n      }\n\n      return index\n    }\n\n    if (node.type === 'element') {\n      /** @type {string} */\n      let key\n\n      for (key in urlAttributes) {\n        if (\n          Object.hasOwn(urlAttributes, key) &&\n          Object.hasOwn(node.properties, key)\n        ) {\n          const value = node.properties[key]\n          const test = urlAttributes[key]\n          if (test === null || test.includes(node.tagName)) {\n            node.properties[key] = urlTransform(String(value || ''), key, node)\n          }\n        }\n      }\n    }\n\n    if (node.type === 'element') {\n      let remove = allowedElements\n        ? !allowedElements.includes(node.tagName)\n        : disallowedElements\n        ? disallowedElements.includes(node.tagName)\n        : false\n\n      if (!remove && allowElement && typeof index === 'number') {\n        remove = !allowElement(node, index, parent)\n      }\n\n      if (remove && parent && typeof index === 'number') {\n        if (unwrapDisallowed && node.children) {\n          parent.children.splice(index, 1, ...node.children)\n        } else {\n          parent.children.splice(index, 1)\n        }\n\n        return index\n      }\n    }\n  }\n}\n\n/**\n * Make a URL safe.\n *\n * @satisfies {UrlTransform}\n * @param {string} value\n *   URL.\n * @returns {string}\n *   Safe URL.\n */\nexport function defaultUrlTransform(value) {\n  // Same as:\n  // <https://github.com/micromark/micromark/blob/929275e/packages/micromark-util-sanitize-uri/dev/index.js#L34>\n  // But without the `encode` part.\n  const colon = value.indexOf(':')\n  const questionMark = value.indexOf('?')\n  const numberSign = value.indexOf('#')\n  const slash = value.indexOf('/')\n\n  if (\n    // If there is no protocol, it’s relative.\n    colon < 0 ||\n    // If the first colon is after a `?`, `#`, or `/`, it’s not a protocol.\n    (slash > -1 && colon > slash) ||\n    (questionMark > -1 && colon > questionMark) ||\n    (numberSign > -1 && colon > numberSign) ||\n    // It is a protocol, it should be allowed.\n    safeProtocol.test(value.slice(0, colon))\n  ) {\n    return value\n  }\n\n  return ''\n}\n"],"names":["isFunction","value","window","document","createElement","getTargetElement","target","defaultElement","current","ref","useRef","fn","fnRef","useEffect","depsAreSame","oldDeps","deps","i","length","Object","is","useEffectType","effect","hasInitRef","lastElementRef","lastDepsRef","unLoadRef","_a","els","Array","isArray","map","item","call","options","callback","option","_b","useState","state","setState","_c","ratio","setRatio","element","filter","Boolean","observer","IntersectionObserver","entries","e_1","entries_1","entries_1_1","next","done","entry","intersectionRatio","isIntersecting","e_1_1","error","return","root","forEach","el","observe","disconnect","rootMargin","threshold","IntersectionObserverEntry","prototype","defineProperty","get","this","startDoc","doc","frame","getFrameElement","ownerDocument","registry","crossOriginUpdater","crossOriginRect","THROTTLE_TIMEOUT","POLL_INTERVAL","USE_MUTATION_OBSERVER","_setupCrossOriginUpdater","boundingClientRect","intersectionRect","convertFromParentRect","top","bottom","left","right","width","height","_checkForIntersections","_resetCrossOriginUpdater","_observationTargets","some","nodeType","Error","_registerInstance","push","_monitorIntersections","unobserve","_unmonitorIntersections","_unregisterInstance","_unmonitorAllIntersections","takeRecords","records","_queuedEntries","slice","_initThresholds","opt_threshold","sort","t","a","isNaN","_parseRootMargin","opt_rootMargin","margins","split","margin","parts","exec","parseFloat","unit","win","defaultView","_monitoringDocuments","indexOf","monitoringInterval","domObserver","setInterval","addEvent","MutationObserver","attributes","childList","characterData","subtree","_monitoringUnsubscribes","clearInterval","removeEvent","rootDoc","index","hasDependentTargets","itemDoc","unsubscribe","splice","unsubscribes","rootIsInDom","_rootIsInDom","rootRect","_getRootRect","targetRect","getBoundingClientRect","rootContainsTarget","_rootContainsTarget","oldEntry","_computeTargetAndRootIntersection","rootBounds","newEntry","time","performance","now","_hasCrossedThreshold","_callback","getComputedStyle","display","parent","getParentNode","atRoot","parentRect","parentComputedStyle","frameRect","frameIntersect","body","documentElement","overflow","computeRectIntersection","isDoc","html","clientWidth","clientHeight","_expandRectByRootMargin","rect","_rootMarginValues","newRect","oldRatio","newRatio","thresholds","containsDeep","frameElement","e","ensureDOMRect","targetArea","intersectionArea","Number","toFixed","opt_options","timeout","timer","setTimeout","throttle","bind","join","node","event","opt_useCapture","addEventListener","attachEvent","removeEventListener","detachEvent","rect1","rect2","Math","max","min","err","y","x","parentBoundingRect","parentIntersectionRect","child","parentNode","assignedSlot","host","hasOwn","hasOwnProperty","toStr","toString","gOPD","getOwnPropertyDescriptor","arr","isPlainObject","obj","key","hasOwnConstructor","hasIsPrototypeOf","constructor","setProperty","name","enumerable","configurable","newValue","writable","getProperty","module","exports","extend","src","copy","copyIsArray","clone","arguments","deep","COMMENT_REGEX","NEWLINE_REGEX","WHITESPACE_REGEX","PROPERTY_REGEX","COLON_REGEX","VALUE_REGEX","SEMICOLON_REGEX","TRIM_REGEX","EMPTY_STRING","trim","str","replace","style","TypeError","lineno","column","updatePosition","lines","match","lastIndexOf","position","start","line","Position","whitespace","end","source","content","errorsList","msg","reason","filename","silent","re","m","comments","rules","c","comment","pos","charAt","type","declaration","prop","val","ret","property","decl","decls","declarations","qs","sep","eq","regexp","maxKeys","len","kstr","vstr","k","v","idx","substr","decodeURIComponent","stringifyPrimitive","isFinite","undefined","keys","ks","encodeURIComponent","decode","parse","encode","stringify","isOptionsObject","isTargetAttached","isConnected","contains","behavior","computeOptions","block","inline","getOptions","actions","canSmoothScroll","_ref","scroll","scrollTop","scrollLeft","defaultBehavior","__importDefault","mod","__esModule","iterator","styleObject","inline_style_parser_1","default","hasIterator","nameRe","nameReJsx","emptyOptions","jsx","test","empty","Schema","normal","space","merge","definitions","assign","normalize","toLowerCase","Info","attribute","boolean","booleanish","overloadedBoolean","number","commaSeparated","spaceSeparated","commaOrSpaceSeparated","mustUseProperty","defined","powers","increment","checks","DefinedInfo","mask","super","mark","check","values","own","create","definition","properties","info","transform","includes","xlink","_","xLinkActuate","xLinkArcRole","xLinkHref","xLinkRole","xLinkShow","xLinkTitle","xLinkType","xml","xmlLang","xmlBase","xmlSpace","caseSensitiveTransform","caseInsensitiveTransform","xmlns","xmlnsxlink","xmlnsXLink","aria","ariaActiveDescendant","ariaAtomic","ariaAutoComplete","ariaBusy","ariaChecked","ariaColCount","ariaColIndex","ariaColSpan","ariaControls","ariaCurrent","ariaDescribedBy","ariaDetails","ariaDisabled","ariaDropEffect","ariaErrorMessage","ariaExpanded","ariaFlowTo","ariaGrabbed","ariaHasPopup","ariaHidden","ariaInvalid","ariaKeyShortcuts","ariaLabel","ariaLabelledBy","ariaLevel","ariaLive","ariaModal","ariaMultiLine","ariaMultiSelectable","ariaOrientation","ariaOwns","ariaPlaceholder","ariaPosInSet","ariaPressed","ariaReadOnly","ariaRelevant","ariaRequired","ariaRoleDescription","ariaRowCount","ariaRowIndex","ariaRowSpan","ariaSelected","ariaSetSize","ariaSort","ariaValueMax","ariaValueMin","ariaValueNow","ariaValueText","role","acceptcharset","classname","htmlfor","httpequiv","abbr","accept","acceptCharset","accessKey","action","allow","allowFullScreen","allowPaymentRequest","allowUserMedia","alt","as","async","autoCapitalize","autoComplete","autoFocus","autoPlay","blocking","capture","charSet","checked","cite","className","cols","colSpan","contentEditable","controls","controlsList","coords","crossOrigin","data","dateTime","decoding","defer","dir","dirName","disabled","download","draggable","encType","enterKeyHint","fetchPriority","form","formAction","formEncType","formMethod","formNoValidate","formTarget","headers","hidden","high","href","hrefLang","htmlFor","httpEquiv","id","imageSizes","imageSrcSet","inert","inputMode","integrity","isMap","itemId","itemProp","itemRef","itemScope","itemType","kind","label","lang","language","list","loading","loop","low","manifest","maxLength","media","method","minLength","multiple","muted","nonce","noModule","noValidate","onAbort","onAfterPrint","onAuxClick","onBeforeMatch","onBeforePrint","onBeforeToggle","onBeforeUnload","onBlur","onCancel","onCanPlay","onCanPlayThrough","onChange","onClick","onClose","onContextLost","onContextMenu","onContextRestored","onCopy","onCueChange","onCut","onDblClick","onDrag","onDragEnd","onDragEnter","onDragExit","onDragLeave","onDragOver","onDragStart","onDrop","onDurationChange","onEmptied","onEnded","onError","onFocus","onFormData","onHashChange","onInput","onInvalid","onKeyDown","onKeyPress","onKeyUp","onLanguageChange","onLoad","onLoadedData","onLoadedMetadata","onLoadEnd","onLoadStart","onMessage","onMessageError","onMouseDown","onMouseEnter","onMouseLeave","onMouseMove","onMouseOut","onMouseOver","onMouseUp","onOffline","onOnline","onPageHide","onPageShow","onPaste","onPause","onPlay","onPlaying","onPopState","onProgress","onRateChange","onRejectionHandled","onReset","onResize","onScroll","onScrollEnd","onSecurityPolicyViolation","onSeeked","onSeeking","onSelect","onSlotChange","onStalled","onStorage","onSubmit","onSuspend","onTimeUpdate","onToggle","onUnhandledRejection","onUnload","onVolumeChange","onWaiting","onWheel","open","optimum","pattern","ping","placeholder","playsInline","popover","popoverTarget","popoverTargetAction","poster","preload","readOnly","referrerPolicy","rel","required","reversed","rows","rowSpan","sandbox","scope","scoped","seamless","selected","shadowRootClonable","shadowRootDelegatesFocus","shadowRootMode","shape","size","sizes","slot","span","spellCheck","srcDoc","srcLang","srcSet","step","tabIndex","title","translate","typeMustMatch","useMap","wrap","writingSuggestions","align","aLink","archive","axis","background","bgColor","border","borderColor","bottomMargin","cellPadding","cellSpacing","char","charOff","classId","clear","code","codeBase","codeType","color","compact","declare","face","frameBorder","hSpace","leftMargin","link","longDesc","lowSrc","marginHeight","marginWidth","noResize","noHref","noShade","noWrap","object","profile","prompt","rev","rightMargin","scheme","scrolling","standby","summary","text","topMargin","valueType","version","vAlign","vLink","vSpace","allowTransparency","autoCorrect","autoSave","disablePictureInPicture","disableRemotePlayback","prefix","results","security","unselectable","svg","accentHeight","alignmentBaseline","arabicForm","baselineShift","capHeight","clipPath","clipRule","colorInterpolation","colorInterpolationFilters","colorProfile","colorRendering","dataType","dominantBaseline","enableBackground","fillOpacity","fillRule","floodColor","floodOpacity","fontFamily","fontSize","fontSizeAdjust","fontStretch","fontStyle","fontVariant","fontWeight","glyphName","glyphOrientationHorizontal","glyphOrientationVertical","horizAdvX","horizOriginX","horizOriginY","imageRendering","letterSpacing","lightingColor","markerEnd","markerMid","markerStart","navDown","navDownLeft","navDownRight","navLeft","navNext","navPrev","navRight","navUp","navUpLeft","navUpRight","onActivate","onBegin","onEnd","onFocusIn","onFocusOut","onMouseWheel","onRepeat","onShow","onZoom","overlinePosition","overlineThickness","paintOrder","panose1","pointerEvents","renderingIntent","shapeRendering","stopColor","stopOpacity","strikethroughPosition","strikethroughThickness","strokeDashArray","strokeDashOffset","strokeLineCap","strokeLineJoin","strokeMiterLimit","strokeOpacity","strokeWidth","textAnchor","textDecoration","textRendering","transformOrigin","typeOf","underlinePosition","underlineThickness","unicodeBidi","unicodeRange","unitsPerEm","vAlphabetic","vHanging","vIdeographic","vMathematical","vectorEffect","vertAdvY","vertOriginX","vertOriginY","wordSpacing","writingMode","xHeight","playbackOrder","timelineBegin","about","accumulate","additive","alphabetic","amplitude","ascent","attributeName","attributeType","azimuth","bandwidth","baseFrequency","baseProfile","bbox","begin","bias","by","calcMode","clip","clipPathUnits","contentScriptType","contentStyleType","cursor","cx","cy","d","defaultAction","descent","diffuseConstant","direction","dur","divisor","dx","dy","edgeMode","editable","elevation","exponent","externalResourcesRequired","fill","filterRes","filterUnits","focusable","focusHighlight","format","fr","from","fx","fy","g1","g2","glyphRef","gradientTransform","gradientUnits","handler","hanging","hatchContentUnits","hatchUnits","ideographic","initialVisibility","in","in2","intercept","k1","k2","k3","k4","kernelMatrix","kernelUnitLength","keyPoints","keySplines","keyTimes","kerning","lengthAdjust","limitingConeAngle","local","markerHeight","markerUnits","markerWidth","maskContentUnits","maskUnits","mathematical","mediaCharacterEncoding","mediaContentEncodings","mediaSize","mediaTime","mode","numOctaves","offset","opacity","operator","order","orient","orientation","origin","overlay","path","pathLength","patternContentUnits","patternTransform","patternUnits","phase","pitch","points","pointsAtX","pointsAtY","pointsAtZ","preserveAlpha","preserveAspectRatio","primitiveUnits","propagate","r","radius","refX","refY","repeatCount","repeatDur","requiredExtensions","requiredFeatures","requiredFonts","requiredFormats","resource","restart","result","rotate","rx","ry","scale","seed","side","slope","snapshotTime","specularConstant","specularExponent","spreadMethod","spacing","startOffset","stdDeviation","stemh","stemv","stitchTiles","string","stroke","surfaceScale","syncBehavior","syncBehaviorDefault","syncMaster","syncTolerance","syncToleranceDefault","systemLanguage","tableValues","targetX","targetY","textLength","transformBehavior","to","u1","u2","unicode","viewBox","viewTarget","visibility","widths","x1","x2","xChannelSelector","y1","y2","yChannelSelector","z","zoomAndPan","valid","dash","cap","kebab","$0","camelcase","toUpperCase","hastToReact","pointEnd","point","pointStart","stringifyPosition","VFileMessage","causeOrReason","optionsOrParentOrPlace","legacyCause","place","ancestors","cause","message","ruleId","fatal","file","stack","actual","expected","note","url","emptyMap","Map","dashSomething","tableElements","Set","tableCellElement","docs","toJsxRuntime","tree","Fragment","filePath","development","jsxDEV","props","isStaticChildren","children","columnNumber","fileName","lineNumber","developmentCreate","jsxs","productionCreate","components","elementAttributeNameCase","evaluater","createEvaluater","ignoreInvalidStyle","passKeys","passNode","schema","stylePropertyNameCase","tableCellAlignToStyle","one","parentSchema","tagName","findComponentFromName","alignValue","createProperty","has","createElementProps","createChildren","thing","addNode","addChildren","pop","estree","expression","evaluateExpression","crashEstree","mdxExpression","objectExpression","argument","createJsxElementProps","mdxJsxElement","evaluateProgram","mdxEsm","countsByName","count","set","Type","rest","dashes","find","settings","padRight","padLeft","replacer","toCamel","parseStyle","String","domCasing","cssCasing","transformStyleToCssCasing","transformStylesToCssCasing","allowExpression","identifiers","computed","optional","toDash","$1","urlAttributes","icon","includeImageAlt","includeHtml","remove","items","parameters","chunkStart","unshift","SpliceBuffer","initial","RangeError","shift","setCursor","stop","POSITIVE_INFINITY","reverse","concat","deleteCount","trunc","removed","chunkedPush","pushMany","unshiftMany","n","subtokenize","eventsArray","jumps","lineIndex","otherIndex","otherEvent","subevents","more","events","_tokenizer","_isInFirstContentOfListItem","contentType","subcontent","_container","eventIndex","token","context","startPosition","startPositions","tokenizer","parser","childEvents","gaps","stream","previous","adjust","breaks","sliceStream","defineSkip","_gfmTasklistFirstContentOfListItem","write","syntaxExtension","all","extension","hook","constructs","existing","before","add","asciiAlpha","regexCheck","asciiAlphanumeric","asciiAtext","asciiControl","asciiDigit","asciiHexDigit","asciiPunctuation","markdownLineEnding","markdownLineEndingOrSpace","markdownSpace","unicodePunctuation","unicodeWhitespace","regex","fromCharCode","factorySpace","effects","ok","limit","enter","consume","exit","tokenize","contentStart","attempt","contentInitial","lineStart","self","childFlow","childToken","lineStartOffset","continued","containerState","continuation","documentContinue","checkNewContainers","_closeFlow","closeFlow","indexBeforeExits","indexBeforeFlow","exitContainers","documentContinued","currentConstruct","concrete","flowStart","interrupt","_gfmTableDynamicInterruptHack","containerConstruct","thereIsANewContainer","thereIsNoNewContainer","lazy","containerContinue","flow","flowContinue","writeToChild","endOfFile","seen","nok","disable","null","blankLine","partial","after","resolve","chunkInside","contentEnd","continuationConstruct","contentContinue","prefixed","tail","sliceSerialize","flowInitial","afterConstruct","resolver","resolveAll","createResolver","initializeFactory","field","resolveAllLineSuffixes","notText","atBreak","extraResolver","chunks","tabs","bufferIndex","chunk","charCodeAt","_bufferIndex","_index","thematicBreak","marker","sequence","onBlank","notBlank","furtherBlankLines","initialBlankLine","notInCurrentItem","indentConstruct","initialSize","atMarker","inside","listItemPrefixWhitespaceConstruct","endOfPrefix","otherPrefix","blockQuote","contBefore","factoryDestination","literalType","literalMarkerType","rawType","stringType","balance","enclosedBefore","raw","enclosed","enclosedEscape","rawEscape","factoryLabel","markerType","labelInside","labelEscape","factoryTitle","escape","factoryWhitespace","normalizeIdentifier","identifier","labelAfter","markerAfter","destinationBefore","destinationAfter","titleBefore","afterWhitespace","beforeMarker","titleAfter","titleAfterOptionalWhitespace","codeIndented","afterPrefix","furtherStart","headingAtx","sequenceOpen","sequenceFurther","setextUnderline","resolveTo","heading","paragraph","htmlBlockNames","htmlRawNames","htmlFlow","closingTag","buffer","markerB","declarationOpen","tagCloseStart","continuationDeclarationInside","commentOpenInside","cdataOpenInside","slash","basicSelfClosing","completeClosingTagAfter","completeAttributeNameBefore","completeEnd","completeAttributeName","completeAttributeNameAfter","completeAttributeValueBefore","completeAttributeValueQuoted","completeAttributeValueUnquoted","completeAttributeValueQuotedAfter","completeAfter","continuationCommentInside","continuationRawTagOpen","continuationClose","continuationCdataInside","continuationStart","blankLineBefore","continuationAfter","nonLazyContinuationStart","continuationStartNonLazy","continuationBefore","continuationRawEndTag","nonLazyContinuation","codeFenced","closeStart","startBefore","beforeSequenceClose","sequenceClose","sizeOpen","sequenceCloseAfter","initialPrefix","beforeSequenceOpen","infoBefore","atNonLazyBreak","metaBefore","meta","contentBefore","beforeContentChunk","contentChunk","decodeNamedCharacterReference","characterReference","innerHTML","textContent","numeric","characterEscape","lineEnding","called","labelEnd","newEvents","close","_inactive","_balanced","group","insideSpan","labelStart","labelEndNok","resourceConstruct","labelEndOk","referenceFullConstruct","referenceNotFull","referenceCollapsedConstruct","resourceBefore","resourceOpen","resourceEnd","resourceDestinationAfter","resourceDestinationMissing","resourceBetween","resourceTitleAfter","referenceFullAfter","referenceFullMissing","referenceCollapsedOpen","labelStartImage","classifyCharacter","attention","openingSequence","closingSequence","use","nextEvents","_close","_open","movePoint","attentionMarkers","autolink","schemeOrEmailAtext","emailAtext","schemeInsideOrEmailAtext","urlInside","emailAtSignOrDot","emailLabel","emailValue","htmlText","returnState","instruction","tagOpen","commentEnd","commentClose","lineEndingBefore","cdata","cdataClose","cdataEnd","instructionClose","tagClose","tagCloseBetween","tagOpenBetween","tagOpenAttributeName","tagOpenAttributeNameAfter","tagOpenAttributeValueBefore","tagOpenAttributeValueQuoted","tagOpenAttributeValueUnquoted","tagOpenAttributeValueQuotedAfter","lineEndingAfter","lineEndingAfterPrefix","labelStartLink","hardBreakEscape","codeText","tailExitIndex","headEnterIndex","between","createTokenizer","initialize","columnStart","resolveAllConstructs","consumed","constructFactory","construct","addResult","onsuccessfulcheck","accountForPotentialSkip","fields","expandTabs","atTab","serializeChunks","main","expectedCode","startIndex","startBufferIndex","endIndex","endBufferIndex","view","head","sliceChunks","chunkIndex","go","restore","onreturn","bogusState","listOfConstructs","constructIndex","handleListOfConstructs","handleMapOfConstructs","handleConstruct","startPoint","startPrevious","startCurrentConstruct","startEventsIndex","startStack","store","extensions","combineExtensions","search","decodeNumericCharacterReference","base","parseInt","fromCodePoint","characterEscapeOrReference","$2","hex","fromMarkdown","encoding","config","transforms","canContainEols","opener","autolinkProtocol","onenterdata","autolinkEmail","atxHeading","codeFlow","codeFencedFenceInfo","codeFencedFenceMeta","codeTextData","codeFlowValue","definitionDestinationString","definitionLabelString","definitionTitleString","emphasis","hardBreak","hardBreakTrailing","htmlFlowData","htmlTextData","image","listItem","listItemValue","onenterlistitemvalue","listOrdered","onenterlistordered","listUnordered","reference","onenterreference","referenceString","resourceDestinationString","resourceTitleString","setextHeading","strong","closer","atxHeadingSequence","onexitatxheadingsequence","onexitautolinkemail","onexitautolinkprotocol","characterEscapeValue","onexitdata","characterReferenceMarkerHexadecimal","onexitcharacterreferencemarker","characterReferenceMarkerNumeric","characterReferenceValue","onexitcharacterreferencevalue","onexitcharacterreference","onexitcodefenced","codeFencedFence","onexitcodefencedfence","onexitcodefencedfenceinfo","onexitcodefencedfencemeta","onexitcodeindented","onexitcodetext","onexitdefinitiondestinationstring","onexitdefinitionlabelstring","onexitdefinitiontitlestring","onexithardbreak","onexithtmlflow","onexithtmltext","onexitimage","onexitlabel","labelText","onexitlabeltext","onexitlineending","onexitlink","onexitreferencestring","onexitresourcedestinationstring","onexitresourcetitlestring","onexitresource","onexitsetextheading","setextHeadingLineSequence","onexitsetextheadinglinesequence","setextHeadingText","onexitsetextheadingtext","configure","mdastExtensions","compile","tokenStack","resume","listStack","prepareList","defaultOnError","firstBlankLineIndex","containerBalance","listSpread","tailIndex","tailEvent","_spread","and","errorHandler","onExitError","expectingFirstListItemValue","flowCodeInside","depth","setextHeadingSlurpLineEnding","codePointAt","siblings","atHardBreak","inReference","referenceType","ancestor","decodeString","fragment","characterReferenceType","ordered","spread","compiler","postprocess","atCarriageReturn","endPosition","TextDecoder","lastIndex","ceil","preprocess","combined","remarkParse","env","globalThis","deserialize","serialized","$","out","unpair","Date","flags","RegExp","BigInt","deserializer","EMPTY","asString","shouldSkip","TYPE","serialize","json","lossy","strict","pair","valueOf","toJSON","toISOString","serializer","structuredClone","any","normalizeUri","skip","defaultFootnoteBackContent","rereferenceIndex","defaultFootnoteBackLabel","referenceIndex","convert","castFactory","tests","apply","anyFactory","checkAsRecord","nodeAsRecord","propsFactory","typeFactory","testFunction","looksLikeANode","CONTINUE","EXIT","SKIP","visitParents","visitor","factory","parents","visit","subresult","grandparents","toResult","nodeAsParent","testOrVisitor","visitorOrReverse","maybeReverse","revert","subtype","suffix","contents","listItemLoose","tab","trimLines","last","trimLine","blockquote","patch","applyData","break","delete","footnoteReference","clobberPrefix","safeId","footnoteOrder","counter","reuseCounter","footnoteCounts","dataFootnoteRef","sup","allowDangerousHtml","imageReference","definitionById","inlineCode","linkReference","loose","listLoose","table","firstRow","tableContent","tableCell","tableRow","cellIndex","cells","cell","toml","ignore","yaml","footnoteDefinition","hName","hChildren","hProperties","defaultUnknownHandler","nodes","trimMarkdownSpaceStart","toHast","footnoteById","handlers","handle","passThrough","shallow","unknownHandler","createState","foot","footnoteBackContent","footnoteBackLabel","footnoteLabel","footnoteLabelTagName","footnoteLabelProperties","listItems","backReferences","counts","dataFootnoteBackref","tailTail","dataFootnotes","footer","remarkRehype","destination","hastTree","run","bail","getPrototypeOf","Symbol","toStringTag","trough","fns","pipeline","middlewareIndex","output","middleware","wrapped","fnExpectsCallback","then","middelware","minpath","basename","extname","assertPath","seenNonSlash","firstNonSlashEnd","extnameIndex","dirname","unmatchedSlash","startPart","startDot","preDotState","segments","joined","absolute","allowAboveRoot","lastSlashIndex","lastSegmentLength","lastSlash","dots","normalizeString","JSON","minproc","cwd","isUrl","fileUrlOrPath","protocol","auth","urlToPath","URL","hostname","pathname","third","getPathFromURLPosix","VFile","isUint8Array","history","messages","stored","assertNonEmpty","assertPart","stem","fail","part","CallableInstance","proto","setPrototypeOf","Processor","Compiler","Parser","attachers","freezeIndex","frozen","namespace","transformers","attacher","assertUnfrozen","freeze","transformer","realFile","vfile","assertParser","process","assertCompiler","executor","Promise","reject","parseTree","realDone","compileTree","compileResult","processSync","complete","assertDone","assertNode","outputTree","resultingTree","runSync","addPlugin","addList","addPreset","plugin","plugins","entryIndex","primary","currentPrimary","unified","asyncName","looksLikeAVFile","emptyPlugins","emptyRemarkRehypeOptions","safeProtocol","deprecations","Markdown","allowedElements","allowElement","disallowedElements","rehypePlugins","remarkPlugins","remarkRehypeOptions","skipHtml","unwrapDisallowed","urlTransform","defaultUrlTransform","processor","deprecation","mdastTree","colon","questionMark","numberSign"],"sourceRoot":""}