{"version":3,"file":"react/js/266.22fb689ed0b987bfe3f0.js","mappings":"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","sources":["webpack:///./node_modules/@uiw/color-convert/esm/index.js","webpack:///./node_modules/use-sync-external-store/cjs/use-sync-external-store-with-selector.production.min.js","webpack:///./node_modules/use-sync-external-store/with-selector.js","webpack:///./node_modules/uuid/dist/esm-browser/native.js","webpack:///./node_modules/uuid/dist/esm-browser/rng.js","webpack:///./node_modules/uuid/dist/esm-browser/stringify.js","webpack:///./node_modules/uuid/dist/esm-browser/v4.js","webpack:///./node_modules/@ungap/structured-clone/esm/types.js","webpack:///./node_modules/@ungap/structured-clone/esm/deserialize.js","webpack:///./node_modules/@ungap/structured-clone/esm/serialize.js","webpack:///./node_modules/@ungap/structured-clone/esm/index.js","webpack:///./node_modules/unified/node_modules/is-plain-obj/index.js","webpack:///./node_modules/unified/lib/callable-instance.js","webpack:///./node_modules/unified/lib/index.js","webpack:///./node_modules/unist-util-is/lib/index.js","webpack:///./node_modules/unist-util-position/lib/index.js","webpack:///./node_modules/unist-util-stringify-position/lib/index.js","webpack:///./node_modules/unist-util-visit-parents/lib/index.js","webpack:///./node_modules/unist-util-visit/lib/index.js","webpack:///./node_modules/universal-cookie/esm/index.mjs","webpack:///./node_modules/vfile-message/lib/index.js"],"sourcesContent":["import _extends from \"@babel/runtime/helpers/extends\";\nvar RGB_MAX = 255;\nvar HUE_MAX = 360;\nvar SV_MAX = 100;\n/**\n * ```js\n * rgbaToHsva({ r: 255, g: 255, b: 255, a: 1 }) //=> { h: 0, s: 0, v: 100, a: 1 }\n * ```\n */\nexport var rgbaToHsva = _ref => {\n  var {\n    r,\n    g,\n    b,\n    a\n  } = _ref;\n  var max = Math.max(r, g, b);\n  var delta = max - Math.min(r, g, b);\n\n  // prettier-ignore\n  var hh = delta ? max === r ? (g - b) / delta : max === g ? 2 + (b - r) / delta : 4 + (r - g) / delta : 0;\n  return {\n    h: 60 * (hh < 0 ? hh + 6 : hh),\n    s: max ? delta / max * SV_MAX : 0,\n    v: max / RGB_MAX * SV_MAX,\n    a\n  };\n};\nexport var hsvaToHslString = hsva => {\n  var {\n    h,\n    s,\n    l\n  } = hsvaToHsla(hsva);\n  // return `hsl(${h}, ${s}%, ${l}%)`;\n  return \"hsl(\" + h + \", \" + Math.round(s) + \"%, \" + Math.round(l) + \"%)\";\n};\nexport var hsvaToHsvString = _ref2 => {\n  var {\n    h,\n    s,\n    v\n  } = _ref2;\n  return \"hsv(\" + h + \", \" + s + \"%, \" + v + \"%)\";\n};\nexport var hsvaToHsvaString = _ref3 => {\n  var {\n    h,\n    s,\n    v,\n    a\n  } = _ref3;\n  return \"hsva(\" + h + \", \" + s + \"%, \" + v + \"%, \" + a + \")\";\n};\nexport var hsvaToHslaString = hsva => {\n  var {\n    h,\n    s,\n    l,\n    a\n  } = hsvaToHsla(hsva);\n  return \"hsla(\" + h + \", \" + s + \"%, \" + l + \"%, \" + a + \")\";\n};\nexport var hslStringToHsla = str => {\n  var [h, s, l, a] = (str.match(/\\d+/g) || []).map(Number);\n  return {\n    h,\n    s,\n    l,\n    a\n  };\n};\nexport var hslaStringToHsva = hslString => {\n  var matcher = /hsla?\\(?\\s*(-?\\d*\\.?\\d+)(deg|rad|grad|turn)?[,\\s]+(-?\\d*\\.?\\d+)%?[,\\s]+(-?\\d*\\.?\\d+)%?,?\\s*[/\\s]*(-?\\d*\\.?\\d+)?(%)?\\s*\\)?/i;\n  var match = matcher.exec(hslString);\n  if (!match) return {\n    h: 0,\n    s: 0,\n    v: 0,\n    a: 1\n  };\n  return hslaToHsva({\n    h: parseHue(match[1], match[2]),\n    s: Number(match[3]),\n    l: Number(match[4]),\n    a: match[5] === undefined ? 1 : Number(match[5]) / (match[6] ? 100 : 1)\n  });\n};\nexport var hslStringToHsva = hslaStringToHsva;\nexport var hslaToHsva = _ref4 => {\n  var {\n    h,\n    s,\n    l,\n    a\n  } = _ref4;\n  s *= (l < 50 ? l : SV_MAX - l) / SV_MAX;\n  return {\n    h: h,\n    s: s > 0 ? 2 * s / (l + s) * SV_MAX : 0,\n    v: l + s,\n    a\n  };\n};\nexport var hsvaToHsla = _ref5 => {\n  var {\n    h,\n    s,\n    v,\n    a\n  } = _ref5;\n  var hh = (200 - s) * v / SV_MAX;\n  return {\n    h,\n    s: hh > 0 && hh < 200 ? s * v / SV_MAX / (hh <= SV_MAX ? hh : 200 - hh) * SV_MAX : 0,\n    l: hh / 2,\n    a\n  };\n};\nexport var hsvaStringToHsva = hsvString => {\n  var matcher = /hsva?\\(?\\s*(-?\\d*\\.?\\d+)(deg|rad|grad|turn)?[,\\s]+(-?\\d*\\.?\\d+)%?[,\\s]+(-?\\d*\\.?\\d+)%?,?\\s*[/\\s]*(-?\\d*\\.?\\d+)?(%)?\\s*\\)?/i;\n  var match = matcher.exec(hsvString);\n  if (!match) return {\n    h: 0,\n    s: 0,\n    v: 0,\n    a: 1\n  };\n  return {\n    h: parseHue(match[1], match[2]),\n    s: Number(match[3]),\n    v: Number(match[4]),\n    a: match[5] === undefined ? 1 : Number(match[5]) / (match[6] ? SV_MAX : 1)\n  };\n};\n\n/**\n * Valid CSS <angle> units.\n * https://developer.mozilla.org/en-US/docs/Web/CSS/angle\n */\nvar angleUnits = {\n  grad: HUE_MAX / 400,\n  turn: HUE_MAX,\n  rad: HUE_MAX / (Math.PI * 2)\n};\nexport var parseHue = function parseHue(value, unit) {\n  if (unit === void 0) {\n    unit = 'deg';\n  }\n  return Number(value) * (angleUnits[unit] || 1);\n};\nexport var hsvStringToHsva = hsvaStringToHsva;\nexport var rgbaStringToHsva = rgbaString => {\n  var matcher = /rgba?\\(?\\s*(-?\\d*\\.?\\d+)(%)?[,\\s]+(-?\\d*\\.?\\d+)(%)?[,\\s]+(-?\\d*\\.?\\d+)(%)?,?\\s*[/\\s]*(-?\\d*\\.?\\d+)?(%)?\\s*\\)?/i;\n  var match = matcher.exec(rgbaString);\n  if (!match) return {\n    h: 0,\n    s: 0,\n    v: 0,\n    a: 1\n  };\n  return rgbaToHsva({\n    r: Number(match[1]) / (match[2] ? SV_MAX / RGB_MAX : 1),\n    g: Number(match[3]) / (match[4] ? SV_MAX / RGB_MAX : 1),\n    b: Number(match[5]) / (match[6] ? SV_MAX / RGB_MAX : 1),\n    a: match[7] === undefined ? 1 : Number(match[7]) / (match[8] ? SV_MAX : 1)\n  });\n};\nexport var rgbStringToHsva = rgbaStringToHsva;\n\n/** Converts an RGBA color plus alpha transparency to hex */\nexport var rgbaToHex = _ref6 => {\n  var {\n    r,\n    g,\n    b\n  } = _ref6;\n  var bin = r << 16 | g << 8 | b;\n  return \"#\" + (h => new Array(7 - h.length).join('0') + h)(bin.toString(16));\n};\nexport var rgbaToHexa = _ref7 => {\n  var {\n    r,\n    g,\n    b,\n    a\n  } = _ref7;\n  var alpha = typeof a === 'number' && (a * 255 | 1 << 8).toString(16).slice(1);\n  return \"\" + rgbaToHex({\n    r,\n    g,\n    b,\n    a\n  }) + (alpha ? alpha : '');\n};\nexport var hexToHsva = hex => rgbaToHsva(hexToRgba(hex));\nexport var hexToRgba = hex => {\n  var htemp = hex.replace('#', '');\n  if (/^#?/.test(hex) && htemp.length === 3) {\n    hex = \"#\" + htemp.charAt(0) + htemp.charAt(0) + htemp.charAt(1) + htemp.charAt(1) + htemp.charAt(2) + htemp.charAt(2);\n  }\n  var reg = new RegExp(\"[A-Za-z0-9]{2}\", 'g');\n  var [r, g, b = 0, a] = hex.match(reg).map(v => parseInt(v, 16));\n  return {\n    r,\n    g,\n    b,\n    a: (a != null ? a : 255) / RGB_MAX\n  };\n};\n\n/**\n * Converts HSVA to RGBA. Based on formula from https://en.wikipedia.org/wiki/HSL_and_HSV\n * @param color HSVA color as an array [0-360, 0-1, 0-1, 0-1]\n */\nexport var hsvaToRgba = _ref8 => {\n  var {\n    h,\n    s,\n    v,\n    a\n  } = _ref8;\n  var _h = h / 60,\n    _s = s / SV_MAX,\n    _v = v / SV_MAX,\n    hi = Math.floor(_h) % 6;\n  var f = _h - Math.floor(_h),\n    _p = RGB_MAX * _v * (1 - _s),\n    _q = RGB_MAX * _v * (1 - _s * f),\n    _t = RGB_MAX * _v * (1 - _s * (1 - f));\n  _v *= RGB_MAX;\n  var rgba = {};\n  switch (hi) {\n    case 0:\n      rgba.r = _v;\n      rgba.g = _t;\n      rgba.b = _p;\n      break;\n    case 1:\n      rgba.r = _q;\n      rgba.g = _v;\n      rgba.b = _p;\n      break;\n    case 2:\n      rgba.r = _p;\n      rgba.g = _v;\n      rgba.b = _t;\n      break;\n    case 3:\n      rgba.r = _p;\n      rgba.g = _q;\n      rgba.b = _v;\n      break;\n    case 4:\n      rgba.r = _t;\n      rgba.g = _p;\n      rgba.b = _v;\n      break;\n    case 5:\n      rgba.r = _v;\n      rgba.g = _p;\n      rgba.b = _q;\n      break;\n  }\n  rgba.r = Math.round(rgba.r);\n  rgba.g = Math.round(rgba.g);\n  rgba.b = Math.round(rgba.b);\n  return _extends({}, rgba, {\n    a\n  });\n};\nexport var hsvaToRgbString = hsva => {\n  var {\n    r,\n    g,\n    b\n  } = hsvaToRgba(hsva);\n  return \"rgb(\" + r + \", \" + g + \", \" + b + \")\";\n};\nexport var hsvaToRgbaString = hsva => {\n  var {\n    r,\n    g,\n    b,\n    a\n  } = hsvaToRgba(hsva);\n  return \"rgba(\" + r + \", \" + g + \", \" + b + \", \" + a + \")\";\n};\nexport var rgbaToRgb = _ref9 => {\n  var {\n    r,\n    g,\n    b\n  } = _ref9;\n  return {\n    r,\n    g,\n    b\n  };\n};\nexport var hslaToHsl = _ref10 => {\n  var {\n    h,\n    s,\n    l\n  } = _ref10;\n  return {\n    h,\n    s,\n    l\n  };\n};\nexport var hsvaToHex = hsva => rgbaToHex(hsvaToRgba(hsva));\nexport var hsvaToHexa = hsva => rgbaToHexa(hsvaToRgba(hsva));\nexport var hsvaToHsv = _ref11 => {\n  var {\n    h,\n    s,\n    v\n  } = _ref11;\n  return {\n    h,\n    s,\n    v\n  };\n};\nexport var color = str => {\n  var rgb;\n  var hsl;\n  var hsv;\n  var rgba;\n  var hsla;\n  var hsva;\n  var hex;\n  var hexa;\n  if (typeof str === 'string' && validHex(str)) {\n    hsva = hexToHsva(str);\n    hex = str;\n  } else if (typeof str !== 'string') {\n    hsva = str;\n  }\n  if (hsva) {\n    hsv = hsvaToHsv(hsva);\n    hsla = hsvaToHsla(hsva);\n    rgba = hsvaToRgba(hsva);\n    hexa = rgbaToHexa(rgba);\n    hex = hsvaToHex(hsva);\n    hsl = hslaToHsl(hsla);\n    rgb = rgbaToRgb(rgba);\n  }\n  return {\n    rgb,\n    hsl,\n    hsv,\n    rgba,\n    hsla,\n    hsva,\n    hex,\n    hexa\n  };\n};\nexport var getContrastingColor = str => {\n  if (!str) {\n    return '#ffffff';\n  }\n  var col = color(str);\n  var yiq = (col.rgb.r * 299 + col.rgb.g * 587 + col.rgb.b * 114) / 1000;\n  return yiq >= 128 ? '#000000' : '#ffffff';\n};\nexport var equalColorObjects = (first, second) => {\n  if (first === second) return true;\n  for (var prop in first) {\n    // The following allows for a type-safe calling of this function (first & second have to be HSL, HSV, or RGB)\n    // with type-unsafe iterating over object keys. TS does not allow this without an index (`[key: string]: number`)\n    // on an object to define how iteration is normally done. To ensure extra keys are not allowed on our types,\n    // we must cast our object to unknown (as RGB demands `r` be a key, while `Record<string, x>` does not care if\n    // there is or not), and then as a type TS can iterate over.\n    if (first[prop] !== second[prop]) return false;\n  }\n  return true;\n};\nexport var equalColorString = (first, second) => {\n  return first.replace(/\\s/g, '') === second.replace(/\\s/g, '');\n};\nexport var equalHex = (first, second) => {\n  if (first.toLowerCase() === second.toLowerCase()) return true;\n\n  // To compare colors like `#FFF` and `ffffff` we convert them into RGB objects\n  return equalColorObjects(hexToRgba(first), hexToRgba(second));\n};\nexport var validHex = hex => /^#?([A-Fa-f0-9]{3,4}){1,2}$/.test(hex);","/**\n * @license React\n * use-sync-external-store-with-selector.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var g=require(\"react\");function n(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var p=\"function\"===typeof Object.is?Object.is:n,q=g.useSyncExternalStore,r=g.useRef,t=g.useEffect,u=g.useMemo,v=g.useDebugValue;\nexports.useSyncExternalStoreWithSelector=function(a,b,e,l,h){var c=r(null);if(null===c.current){var f={hasValue:!1,value:null};c.current=f}else f=c.current;c=u(function(){function a(a){if(!c){c=!0;d=a;a=l(a);if(void 0!==h&&f.hasValue){var b=f.value;if(h(b,a))return k=b}return k=a}b=k;if(p(d,a))return b;var e=l(a);if(void 0!==h&&h(b,e))return b;d=a;return k=e}var c=!1,d,k,m=void 0===e?null:e;return[function(){return a(b())},null===m?void 0:function(){return a(m())}]},[b,e,l,h]);var d=q(a,c[0],c[1]);\nt(function(){f.hasValue=!0;f.value=d},[d]);v(d);return d};\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/use-sync-external-store-with-selector.production.min.js');\n} else {\n  module.exports = require('./cjs/use-sync-external-store-with-selector.development.js');\n}\n","const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);\nexport default {\n  randomUUID\n};","// Unique ID creation requires a high quality random # generator. In the browser we therefore\n// require the crypto API and do not support built-in fallback to lower quality random number\n// generators (like Math.random()).\nlet getRandomValues;\nconst rnds8 = new Uint8Array(16);\nexport default function rng() {\n  // lazy load so that environments that need to polyfill have a chance to do so\n  if (!getRandomValues) {\n    // getRandomValues needs to be invoked in a context where \"this\" is a Crypto implementation.\n    getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);\n\n    if (!getRandomValues) {\n      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');\n    }\n  }\n\n  return getRandomValues(rnds8);\n}","import validate from './validate.js';\n/**\n * Convert array of 16 byte values to UUID string format of the form:\n * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX\n */\n\nconst byteToHex = [];\n\nfor (let i = 0; i < 256; ++i) {\n  byteToHex.push((i + 0x100).toString(16).slice(1));\n}\n\nexport function unsafeStringify(arr, offset = 0) {\n  // Note: Be careful editing this code!  It's been tuned for performance\n  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434\n  return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];\n}\n\nfunction stringify(arr, offset = 0) {\n  const uuid = unsafeStringify(arr, offset); // Consistency check for valid UUID.  If this throws, it's likely due to one\n  // of the following:\n  // - One or more input array values don't map to a hex octet (leading to\n  // \"undefined\" in the uuid)\n  // - Invalid input values for the RFC `version` or `variant` fields\n\n  if (!validate(uuid)) {\n    throw TypeError('Stringified UUID is invalid');\n  }\n\n  return uuid;\n}\n\nexport default stringify;","import native from './native.js';\nimport rng from './rng.js';\nimport { unsafeStringify } from './stringify.js';\n\nfunction v4(options, buf, offset) {\n  if (native.randomUUID && !buf && !options) {\n    return native.randomUUID();\n  }\n\n  options = options || {};\n  const rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`\n\n  rnds[6] = rnds[6] & 0x0f | 0x40;\n  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided\n\n  if (buf) {\n    offset = offset || 0;\n\n    for (let i = 0; i < 16; ++i) {\n      buf[offset + i] = rnds[i];\n    }\n\n    return buf;\n  }\n\n  return unsafeStringify(rnds);\n}\n\nexport default v4;","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","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","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 func = proto[property]\n        /** @type {(...parameters: Array<unknown>) => unknown} */\n        const apply = function () {\n          return func.apply(apply, arguments)\n        }\n\n        Object.setPrototypeOf(apply, proto)\n\n        const names = Object.getOwnPropertyNames(func)\n\n        for (const p of names) {\n          const descriptor = Object.getOwnPropertyDescriptor(func, 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 *   {@link CompileResultMap `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 {@link Node `Node`}\n *   and {@link VFile `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 *   > {@link CompileResultMap `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 *   {@link VFile `VFile`} of the document to parse.\n *   It must return the syntax tree representation of the given file\n *   ({@link Node `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 {@link Transformer `Transformer`}, this\n *       should be the node it expects.\n *   *   If the plugin sets a {@link Parser `Parser`}, this should be\n *       `string`.\n *   *   If the plugin sets a {@link Compiler `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 {@link Transformer `Transformer`}, this\n *       should be the node that that yields.\n *   *   If the plugin sets a {@link Parser `Parser`}, this should be the\n *       node that it yields.\n *   *   If the plugin sets a {@link Compiler `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 {@link Transformer `Transformer`}, this\n *       should be the node it expects.\n *   *   If the plugin sets a {@link Parser `Parser`}, this should be\n *       `string`.\n *   *   If the plugin sets a {@link Compiler `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 {@link Transformer `Transformer`}, this\n *       should be the node that that yields.\n *   *   If the plugin sets a {@link Parser `Parser`}, this should be the\n *       node that it yields.\n *   *   If the plugin sets a {@link Compiler `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 {@link VFile `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 {@link VFile `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 ({@link Processor `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   * > {@link Data `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   *   > {@link CompileResultMap `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   *   > {@link CompileResultMap `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   *   > {@link CompileResultMap `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","/**\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} 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} 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 * cookie\n * Copyright(c) 2012-2014 Roman Shtylman\n * Copyright(c) 2015 Douglas Christopher Wilson\n * MIT Licensed\n */\n\n/**\n * Module exports.\n * @public\n */\n\nvar parse_1 = parse;\nvar serialize_1 = serialize;\n\n/**\n * Module variables.\n * @private\n */\n\nvar __toString = Object.prototype.toString;\n\n/**\n * RegExp to match field-content in RFC 7230 sec 3.2\n *\n * field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ]\n * field-vchar   = VCHAR / obs-text\n * obs-text      = %x80-FF\n */\n\nvar fieldContentRegExp = /^[\\u0009\\u0020-\\u007e\\u0080-\\u00ff]+$/;\n\n/**\n * Parse a cookie header.\n *\n * Parse the given cookie header string into an object\n * The object has the various cookies as keys(names) => values\n *\n * @param {string} str\n * @param {object} [options]\n * @return {object}\n * @public\n */\n\nfunction parse(str, options) {\n  if (typeof str !== 'string') {\n    throw new TypeError('argument str must be a string');\n  }\n\n  var obj = {};\n  var opt = options || {};\n  var dec = opt.decode || decode;\n\n  var index = 0;\n  while (index < str.length) {\n    var eqIdx = str.indexOf('=', index);\n\n    // no more cookie pairs\n    if (eqIdx === -1) {\n      break\n    }\n\n    var endIdx = str.indexOf(';', index);\n\n    if (endIdx === -1) {\n      endIdx = str.length;\n    } else if (endIdx < eqIdx) {\n      // backtrack on prior semicolon\n      index = str.lastIndexOf(';', eqIdx - 1) + 1;\n      continue\n    }\n\n    var key = str.slice(index, eqIdx).trim();\n\n    // only assign once\n    if (undefined === obj[key]) {\n      var val = str.slice(eqIdx + 1, endIdx).trim();\n\n      // quoted values\n      if (val.charCodeAt(0) === 0x22) {\n        val = val.slice(1, -1);\n      }\n\n      obj[key] = tryDecode(val, dec);\n    }\n\n    index = endIdx + 1;\n  }\n\n  return obj;\n}\n\n/**\n * Serialize data into a cookie header.\n *\n * Serialize the a name value pair into a cookie string suitable for\n * http headers. An optional options object specified cookie parameters.\n *\n * serialize('foo', 'bar', { httpOnly: true })\n *   => \"foo=bar; httpOnly\"\n *\n * @param {string} name\n * @param {string} val\n * @param {object} [options]\n * @return {string}\n * @public\n */\n\nfunction serialize(name, val, options) {\n  var opt = options || {};\n  var enc = opt.encode || encode;\n\n  if (typeof enc !== 'function') {\n    throw new TypeError('option encode is invalid');\n  }\n\n  if (!fieldContentRegExp.test(name)) {\n    throw new TypeError('argument name is invalid');\n  }\n\n  var value = enc(val);\n\n  if (value && !fieldContentRegExp.test(value)) {\n    throw new TypeError('argument val is invalid');\n  }\n\n  var str = name + '=' + value;\n\n  if (null != opt.maxAge) {\n    var maxAge = opt.maxAge - 0;\n\n    if (isNaN(maxAge) || !isFinite(maxAge)) {\n      throw new TypeError('option maxAge is invalid')\n    }\n\n    str += '; Max-Age=' + Math.floor(maxAge);\n  }\n\n  if (opt.domain) {\n    if (!fieldContentRegExp.test(opt.domain)) {\n      throw new TypeError('option domain is invalid');\n    }\n\n    str += '; Domain=' + opt.domain;\n  }\n\n  if (opt.path) {\n    if (!fieldContentRegExp.test(opt.path)) {\n      throw new TypeError('option path is invalid');\n    }\n\n    str += '; Path=' + opt.path;\n  }\n\n  if (opt.expires) {\n    var expires = opt.expires;\n\n    if (!isDate(expires) || isNaN(expires.valueOf())) {\n      throw new TypeError('option expires is invalid');\n    }\n\n    str += '; Expires=' + expires.toUTCString();\n  }\n\n  if (opt.httpOnly) {\n    str += '; HttpOnly';\n  }\n\n  if (opt.secure) {\n    str += '; Secure';\n  }\n\n  if (opt.partitioned) {\n    str += '; Partitioned';\n  }\n\n  if (opt.priority) {\n    var priority = typeof opt.priority === 'string'\n      ? opt.priority.toLowerCase()\n      : opt.priority;\n\n    switch (priority) {\n      case 'low':\n        str += '; Priority=Low';\n        break\n      case 'medium':\n        str += '; Priority=Medium';\n        break\n      case 'high':\n        str += '; Priority=High';\n        break\n      default:\n        throw new TypeError('option priority is invalid')\n    }\n  }\n\n  if (opt.sameSite) {\n    var sameSite = typeof opt.sameSite === 'string'\n      ? opt.sameSite.toLowerCase() : opt.sameSite;\n\n    switch (sameSite) {\n      case true:\n        str += '; SameSite=Strict';\n        break;\n      case 'lax':\n        str += '; SameSite=Lax';\n        break;\n      case 'strict':\n        str += '; SameSite=Strict';\n        break;\n      case 'none':\n        str += '; SameSite=None';\n        break;\n      default:\n        throw new TypeError('option sameSite is invalid');\n    }\n  }\n\n  return str;\n}\n\n/**\n * URL-decode string value. Optimized to skip native call when no %.\n *\n * @param {string} str\n * @returns {string}\n */\n\nfunction decode (str) {\n  return str.indexOf('%') !== -1\n    ? decodeURIComponent(str)\n    : str\n}\n\n/**\n * URL-encode value.\n *\n * @param {string} val\n * @returns {string}\n */\n\nfunction encode (val) {\n  return encodeURIComponent(val)\n}\n\n/**\n * Determine if value is a Date.\n *\n * @param {*} val\n * @private\n */\n\nfunction isDate (val) {\n  return __toString.call(val) === '[object Date]' ||\n    val instanceof Date\n}\n\n/**\n * Try decoding a string using a decoding function.\n *\n * @param {string} str\n * @param {function} decode\n * @private\n */\n\nfunction tryDecode(str, decode) {\n  try {\n    return decode(str);\n  } catch (e) {\n    return str;\n  }\n}\n\nfunction hasDocumentCookie() {\n    const testingValue = typeof global === 'undefined'\n        ? undefined\n        : global.TEST_HAS_DOCUMENT_COOKIE;\n    if (typeof testingValue === 'boolean') {\n        return testingValue;\n    }\n    // Can we get/set cookies on document.cookie?\n    return typeof document === 'object' && typeof document.cookie === 'string';\n}\nfunction parseCookies(cookies) {\n    if (typeof cookies === 'string') {\n        return parse_1(cookies);\n    }\n    else if (typeof cookies === 'object' && cookies !== null) {\n        return cookies;\n    }\n    else {\n        return {};\n    }\n}\nfunction readCookie(value, options = {}) {\n    const cleanValue = cleanupCookieValue(value);\n    if (!options.doNotParse) {\n        try {\n            return JSON.parse(cleanValue);\n        }\n        catch (e) {\n            // At least we tried\n        }\n    }\n    // Ignore clean value if we failed the deserialization\n    // It is not relevant anymore to trim those values\n    return value;\n}\nfunction cleanupCookieValue(value) {\n    // express prepend j: before serializing a cookie\n    if (value && value[0] === 'j' && value[1] === ':') {\n        return value.substr(2);\n    }\n    return value;\n}\n\nclass Cookies {\n    constructor(cookies, defaultSetOptions = {}) {\n        this.changeListeners = [];\n        this.HAS_DOCUMENT_COOKIE = false;\n        this.update = () => {\n            if (!this.HAS_DOCUMENT_COOKIE) {\n                return;\n            }\n            const previousCookies = this.cookies;\n            this.cookies = parse_1(document.cookie);\n            this._checkChanges(previousCookies);\n        };\n        const domCookies = typeof document === 'undefined' ? '' : document.cookie;\n        this.cookies = parseCookies(cookies || domCookies);\n        this.defaultSetOptions = defaultSetOptions;\n        this.HAS_DOCUMENT_COOKIE = hasDocumentCookie();\n    }\n    _emitChange(params) {\n        for (let i = 0; i < this.changeListeners.length; ++i) {\n            this.changeListeners[i](params);\n        }\n    }\n    _checkChanges(previousCookies) {\n        const names = new Set(Object.keys(previousCookies).concat(Object.keys(this.cookies)));\n        names.forEach((name) => {\n            if (previousCookies[name] !== this.cookies[name]) {\n                this._emitChange({\n                    name,\n                    value: readCookie(this.cookies[name]),\n                });\n            }\n        });\n    }\n    _startPolling() {\n        this.pollingInterval = setInterval(this.update, 300);\n    }\n    _stopPolling() {\n        if (this.pollingInterval) {\n            clearInterval(this.pollingInterval);\n        }\n    }\n    get(name, options = {}) {\n        if (!options.doNotUpdate) {\n            this.update();\n        }\n        return readCookie(this.cookies[name], options);\n    }\n    getAll(options = {}) {\n        if (!options.doNotUpdate) {\n            this.update();\n        }\n        const result = {};\n        for (let name in this.cookies) {\n            result[name] = readCookie(this.cookies[name], options);\n        }\n        return result;\n    }\n    set(name, value, options) {\n        if (options) {\n            options = Object.assign(Object.assign({}, this.defaultSetOptions), options);\n        }\n        else {\n            options = this.defaultSetOptions;\n        }\n        const stringValue = typeof value === 'string' ? value : JSON.stringify(value);\n        this.cookies = Object.assign(Object.assign({}, this.cookies), { [name]: stringValue });\n        if (this.HAS_DOCUMENT_COOKIE) {\n            document.cookie = serialize_1(name, stringValue, options);\n        }\n        this._emitChange({ name, value, options });\n    }\n    remove(name, options) {\n        const finalOptions = (options = Object.assign(Object.assign(Object.assign({}, this.defaultSetOptions), options), { expires: new Date(1970, 1, 1, 0, 0, 1), maxAge: 0 }));\n        this.cookies = Object.assign({}, this.cookies);\n        delete this.cookies[name];\n        if (this.HAS_DOCUMENT_COOKIE) {\n            document.cookie = serialize_1(name, '', finalOptions);\n        }\n        this._emitChange({ name, value: undefined, options });\n    }\n    addChangeListener(callback) {\n        this.changeListeners.push(callback);\n        if (this.HAS_DOCUMENT_COOKIE && this.changeListeners.length === 1) {\n            if (typeof window === 'object' && 'cookieStore' in window) {\n                window.cookieStore.addEventListener('change', this.update);\n            }\n            else {\n                this._startPolling();\n            }\n        }\n    }\n    removeChangeListener(callback) {\n        const idx = this.changeListeners.indexOf(callback);\n        if (idx >= 0) {\n            this.changeListeners.splice(idx, 1);\n        }\n        if (this.HAS_DOCUMENT_COOKIE && this.changeListeners.length === 0) {\n            if (typeof window === 'object' && 'cookieStore' in window) {\n                window.cookieStore.removeEventListener('change', this.update);\n            }\n            else {\n                this._stopPolling();\n            }\n        }\n    }\n}\n\nexport { Cookies as default };\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"],"names":["RGB_MAX","SV_MAX","rgbaToHsva","_ref","r","g","b","a","max","Math","delta","min","hh","h","s","v","hsvaToHsla","_ref5","l","rgbaToHex","PI","_ref6","toString","Array","length","join","rgbaToHexa","_ref7","alpha","slice","hexToRgba","hex","htemp","replace","test","charAt","reg","RegExp","match","map","parseInt","hsvaToRgba","_ref8","_h","_s","_v","hi","floor","f","_p","_q","_t","rgba","round","color","str","rgb","hsl","hsv","hsla","hsva","hexa","validHex","hexToHsva","_ref11","hsvaToHsv","hsvaToHex","_ref10","hslaToHsl","_ref9","rgbaToRgb","getContrastingColor","col","p","Object","is","q","useSyncExternalStore","useRef","t","useEffect","u","useMemo","useDebugValue","exports","useSyncExternalStoreWithSelector","e","c","current","hasValue","value","d","k","m","module","randomUUID","crypto","bind","getRandomValues","rnds8","Uint8Array","rng","Error","byteToHex","i","push","unsafeStringify","arr","offset","options","buf","rnds","random","env","self","globalThis","deserialize","serialized","$","_","as","out","index","set","unpair","has","get","type","object","key","Date","source","flags","Map","Set","add","name","message","BigInt","deserializer","EMPTY","keys","typeOf","asString","call","includes","shouldSkip","TYPE","serialize","json","lossy","strict","pair","entry","TypeError","valueOf","toJSON","entries","toISOString","serializer","structuredClone","any","isPlainObject","prototype","getPrototypeOf","Symbol","toStringTag","iterator","CallableInstance","property","proto","this","constructor","func","apply","arguments","setPrototypeOf","names","getOwnPropertyNames","descriptor","getOwnPropertyDescriptor","defineProperty","own","hasOwnProperty","Processor","super","Compiler","undefined","Parser","attachers","compiler","freezeIndex","frozen","namespace","parser","transformers","copy","destination","attacher","use","data","extend","assertUnfrozen","freeze","transformer","Number","POSITIVE_INFINITY","parse","file","realFile","vfile","assertParser","String","process","done","assertCompiler","executor","Promise","resolve","reject","parseTree","realDone","error","run","tree","compileTree","compileResult","stringify","Boolean","isUint8Array","result","processSync","complete","bail","assertDone","assertNode","outputTree","resultingTree","runSync","parameters","addPlugin","isArray","addList","addPreset","plugin","plugins","settings","entryIndex","primary","rest","currentPrimary","unified","node","asyncName","looksLikeAVFile","convert","ok","castFactory","tests","checks","anyFactory","check","checkAsRecord","all","nodeAsRecord","propsFactory","typeFactory","testFunction","parent","looksLikeANode","pointEnd","point","pointStart","position","line","column","start","end","stringifyPosition","pos","empty","CONTINUE","EXIT","SKIP","visitParents","visitor","reverse","step","factory","parents","tagName","visit","subresult","grandparents","toResult","children","nodeAsParent","concat","child","testOrVisitor","visitorOrReverse","maybeReverse","indexOf","parse_1","obj","dec","decode","eqIdx","endIdx","lastIndexOf","trim","val","charCodeAt","tryDecode","serialize_1","opt","enc","encode","fieldContentRegExp","maxAge","isNaN","isFinite","domain","path","expires","__toString","isDate","toUTCString","httpOnly","secure","partitioned","priority","toLowerCase","sameSite","decodeURIComponent","encodeURIComponent","readCookie","cleanValue","substr","cleanupCookieValue","doNotParse","JSON","Cookies","cookies","defaultSetOptions","changeListeners","HAS_DOCUMENT_COOKIE","update","previousCookies","document","cookie","_checkChanges","domCookies","parseCookies","testingValue","global","TEST_HAS_DOCUMENT_COOKIE","hasDocumentCookie","_emitChange","params","forEach","_startPolling","pollingInterval","setInterval","_stopPolling","clearInterval","doNotUpdate","getAll","assign","stringValue","remove","finalOptions","addChangeListener","callback","window","cookieStore","addEventListener","removeChangeListener","idx","splice","removeEventListener","VFileMessage","causeOrReason","optionsOrParentOrPlace","origin","reason","legacyCause","place","ancestors","cause","ruleId","fatal","stack","actual","expected","note","url"],"sourceRoot":""}