@cliff-studio/sanity-plugin-bunny-input 2.0.0 → 2.0.2

package/dist/_chunks-es/refractor.js

@@ -1,4654 +0,0 @@
-import { distExports } from "./index.js";
-import { jsx, jsxs, Fragment } from "react/jsx-runtime";
-import { createElement } from "react";
-class Schema {
-  /**
-   * @param {SchemaType['property']} property
-   *   Property.
-   * @param {SchemaType['normal']} normal
-   *   Normal.
-   * @param {Space | undefined} [space]
-   *   Space.
-   * @returns
-   *   Schema.
-   */
-  constructor(property, normal, space) {
-    this.normal = normal, this.property = property, space && (this.space = space);
-  }
-}
-Schema.prototype.normal = {};
-Schema.prototype.property = {};
-Schema.prototype.space = void 0;
-function merge(definitions, space) {
-  const property = {}, normal = {};
-  for (const definition of definitions)
-    Object.assign(property, definition.property), Object.assign(normal, definition.normal);
-  return new Schema(property, normal, space);
-}
-function normalize(value) {
-  return value.toLowerCase();
-}
-class Info {
-  /**
-   * @param {string} property
-   *   Property.
-   * @param {string} attribute
-   *   Attribute.
-   * @returns
-   *   Info.
-   */
-  constructor(property, attribute) {
-    this.attribute = attribute, this.property = property;
-  }
-}
-Info.prototype.attribute = "";
-Info.prototype.booleanish = !1;
-Info.prototype.boolean = !1;
-Info.prototype.commaOrSpaceSeparated = !1;
-Info.prototype.commaSeparated = !1;
-Info.prototype.defined = !1;
-Info.prototype.mustUseProperty = !1;
-Info.prototype.number = !1;
-Info.prototype.overloadedBoolean = !1;
-Info.prototype.property = "";
-Info.prototype.spaceSeparated = !1;
-Info.prototype.space = void 0;
-let powers = 0;
-const boolean = increment(), booleanish = increment(), overloadedBoolean = increment(), number = increment(), spaceSeparated = increment(), commaSeparated = increment(), commaOrSpaceSeparated = increment();
-function increment() {
-  return 2 ** ++powers;
-}
-var types = /* @__PURE__ */ Object.freeze({
-  __proto__: null,
-  boolean,
-  booleanish,
-  commaOrSpaceSeparated,
-  commaSeparated,
-  number,
-  overloadedBoolean,
-  spaceSeparated
-});
-const checks = (
-  /** @type {ReadonlyArray<keyof typeof types>} */
-  Object.keys(types)
-);
-class DefinedInfo extends Info {
-  /**
-   * @constructor
-   * @param {string} property
-   *   Property.
-   * @param {string} attribute
-   *   Attribute.
-   * @param {number | null | undefined} [mask]
-   *   Mask.
-   * @param {Space | undefined} [space]
-   *   Space.
-   * @returns
-   *   Info.
-   */
-  constructor(property, attribute, mask, space) {
-    let index = -1;
-    if (super(property, attribute), mark(this, "space", space), typeof mask == "number")
-      for (; ++index < checks.length; ) {
-        const check = checks[index];
-        mark(this, checks[index], (mask & types[check]) === types[check]);
-      }
-  }
-}
-DefinedInfo.prototype.defined = !0;
-function mark(values, key, value) {
-  value && (values[key] = value);
-}
-function create(definition) {
-  const properties = {}, normals = {};
-  for (const [property, value] of Object.entries(definition.properties)) {
-    const info = new DefinedInfo(
-      property,
-      definition.transform(definition.attributes || {}, property),
-      value,
-      definition.space
-    );
-    definition.mustUseProperty && definition.mustUseProperty.includes(property) && (info.mustUseProperty = !0), properties[property] = info, normals[normalize(property)] = property, normals[normalize(info.attribute)] = property;
-  }
-  return new Schema(properties, normals, definition.space);
-}
-const aria = create({
-  properties: {
-    ariaActiveDescendant: null,
-    ariaAtomic: booleanish,
-    ariaAutoComplete: null,
-    ariaBusy: booleanish,
-    ariaChecked: booleanish,
-    ariaColCount: number,
-    ariaColIndex: number,
-    ariaColSpan: number,
-    ariaControls: spaceSeparated,
-    ariaCurrent: null,
-    ariaDescribedBy: spaceSeparated,
-    ariaDetails: null,
-    ariaDisabled: booleanish,
-    ariaDropEffect: spaceSeparated,
-    ariaErrorMessage: null,
-    ariaExpanded: booleanish,
-    ariaFlowTo: spaceSeparated,
-    ariaGrabbed: booleanish,
-    ariaHasPopup: null,
-    ariaHidden: booleanish,
-    ariaInvalid: null,
-    ariaKeyShortcuts: null,
-    ariaLabel: null,
-    ariaLabelledBy: spaceSeparated,
-    ariaLevel: number,
-    ariaLive: null,
-    ariaModal: booleanish,
-    ariaMultiLine: booleanish,
-    ariaMultiSelectable: booleanish,
-    ariaOrientation: null,
-    ariaOwns: spaceSeparated,
-    ariaPlaceholder: null,
-    ariaPosInSet: number,
-    ariaPressed: booleanish,
-    ariaReadOnly: booleanish,
-    ariaRelevant: null,
-    ariaRequired: booleanish,
-    ariaRoleDescription: spaceSeparated,
-    ariaRowCount: number,
-    ariaRowIndex: number,
-    ariaRowSpan: number,
-    ariaSelected: booleanish,
-    ariaSetSize: number,
-    ariaSort: null,
-    ariaValueMax: number,
-    ariaValueMin: number,
-    ariaValueNow: number,
-    ariaValueText: null,
-    role: null
-  },
-  transform(_2, property) {
-    return property === "role" ? property : "aria-" + property.slice(4).toLowerCase();
-  }
-});
-function caseSensitiveTransform(attributes2, attribute) {
-  return attribute in attributes2 ? attributes2[attribute] : attribute;
-}
-function caseInsensitiveTransform(attributes2, property) {
-  return caseSensitiveTransform(attributes2, property.toLowerCase());
-}
-const html$1 = create({
-  attributes: {
-    acceptcharset: "accept-charset",
-    classname: "class",
-    htmlfor: "for",
-    httpequiv: "http-equiv"
-  },
-  mustUseProperty: ["checked", "multiple", "muted", "selected"],
-  properties: {
-    // Standard Properties.
-    abbr: null,
-    accept: commaSeparated,
-    acceptCharset: spaceSeparated,
-    accessKey: spaceSeparated,
-    action: null,
-    allow: null,
-    allowFullScreen: boolean,
-    allowPaymentRequest: boolean,
-    allowUserMedia: boolean,
-    alpha: boolean,
-    alt: null,
-    as: null,
-    async: boolean,
-    autoCapitalize: null,
-    autoComplete: spaceSeparated,
-    autoFocus: boolean,
-    autoPlay: boolean,
-    blocking: spaceSeparated,
-    capture: null,
-    charSet: null,
-    checked: boolean,
-    cite: null,
-    className: spaceSeparated,
-    closedBy: null,
-    colorSpace: null,
-    cols: number,
-    colSpan: number,
-    command: null,
-    commandFor: null,
-    content: null,
-    contentEditable: booleanish,
-    controls: boolean,
-    controlsList: spaceSeparated,
-    coords: number | commaSeparated,
-    crossOrigin: null,
-    data: null,
-    dateTime: null,
-    decoding: null,
-    default: boolean,
-    defer: boolean,
-    dir: null,
-    dirName: null,
-    disabled: boolean,
-    download: overloadedBoolean,
-    draggable: booleanish,
-    encType: null,
-    enterKeyHint: null,
-    fetchPriority: null,
-    form: null,
-    formAction: null,
-    formEncType: null,
-    formMethod: null,
-    formNoValidate: boolean,
-    formTarget: null,
-    headers: spaceSeparated,
-    height: number,
-    hidden: overloadedBoolean,
-    high: number,
-    href: null,
-    hrefLang: null,
-    htmlFor: spaceSeparated,
-    httpEquiv: spaceSeparated,
-    id: null,
-    imageSizes: null,
-    imageSrcSet: null,
-    inert: boolean,
-    inputMode: null,
-    integrity: null,
-    is: null,
-    isMap: boolean,
-    itemId: null,
-    itemProp: spaceSeparated,
-    itemRef: spaceSeparated,
-    itemScope: boolean,
-    itemType: spaceSeparated,
-    kind: null,
-    label: null,
-    lang: null,
-    language: null,
-    list: null,
-    loading: null,
-    loop: boolean,
-    low: number,
-    manifest: null,
-    max: null,
-    maxLength: number,
-    media: null,
-    method: null,
-    min: null,
-    minLength: number,
-    multiple: boolean,
-    muted: boolean,
-    name: null,
-    nonce: null,
-    noModule: boolean,
-    noValidate: boolean,
-    onAbort: null,
-    onAfterPrint: null,
-    onAuxClick: null,
-    onBeforeMatch: null,
-    onBeforePrint: null,
-    onBeforeToggle: null,
-    onBeforeUnload: null,
-    onBlur: null,
-    onCancel: null,
-    onCanPlay: null,
-    onCanPlayThrough: null,
-    onChange: null,
-    onClick: null,
-    onClose: null,
-    onContextLost: null,
-    onContextMenu: null,
-    onContextRestored: null,
-    onCopy: null,
-    onCueChange: null,
-    onCut: null,
-    onDblClick: null,
-    onDrag: null,
-    onDragEnd: null,
-    onDragEnter: null,
-    onDragExit: null,
-    onDragLeave: null,
-    onDragOver: null,
-    onDragStart: null,
-    onDrop: null,
-    onDurationChange: null,
-    onEmptied: null,
-    onEnded: null,
-    onError: null,
-    onFocus: null,
-    onFormData: null,
-    onHashChange: null,
-    onInput: null,
-    onInvalid: null,
-    onKeyDown: null,
-    onKeyPress: null,
-    onKeyUp: null,
-    onLanguageChange: null,
-    onLoad: null,
-    onLoadedData: null,
-    onLoadedMetadata: null,
-    onLoadEnd: null,
-    onLoadStart: null,
-    onMessage: null,
-    onMessageError: null,
-    onMouseDown: null,
-    onMouseEnter: null,
-    onMouseLeave: null,
-    onMouseMove: null,
-    onMouseOut: null,
-    onMouseOver: null,
-    onMouseUp: null,
-    onOffline: null,
-    onOnline: null,
-    onPageHide: null,
-    onPageShow: null,
-    onPaste: null,
-    onPause: null,
-    onPlay: null,
-    onPlaying: null,
-    onPopState: null,
-    onProgress: null,
-    onRateChange: null,
-    onRejectionHandled: null,
-    onReset: null,
-    onResize: null,
-    onScroll: null,
-    onScrollEnd: null,
-    onSecurityPolicyViolation: null,
-    onSeeked: null,
-    onSeeking: null,
-    onSelect: null,
-    onSlotChange: null,
-    onStalled: null,
-    onStorage: null,
-    onSubmit: null,
-    onSuspend: null,
-    onTimeUpdate: null,
-    onToggle: null,
-    onUnhandledRejection: null,
-    onUnload: null,
-    onVolumeChange: null,
-    onWaiting: null,
-    onWheel: null,
-    open: boolean,
-    optimum: number,
-    pattern: null,
-    ping: spaceSeparated,
-    placeholder: null,
-    playsInline: boolean,
-    popover: null,
-    popoverTarget: null,
-    popoverTargetAction: null,
-    poster: null,
-    preload: null,
-    readOnly: boolean,
-    referrerPolicy: null,
-    rel: spaceSeparated,
-    required: boolean,
-    reversed: boolean,
-    rows: number,
-    rowSpan: number,
-    sandbox: spaceSeparated,
-    scope: null,
-    scoped: boolean,
-    seamless: boolean,
-    selected: boolean,
-    shadowRootClonable: boolean,
-    shadowRootCustomElementRegistry: boolean,
-    shadowRootDelegatesFocus: boolean,
-    shadowRootMode: null,
-    shadowRootSerializable: boolean,
-    shape: null,
-    size: number,
-    sizes: null,
-    slot: null,
-    span: number,
-    spellCheck: booleanish,
-    src: null,
-    srcDoc: null,
-    srcLang: null,
-    srcSet: null,
-    start: number,
-    step: null,
-    style: null,
-    tabIndex: number,
-    target: null,
-    title: null,
-    translate: null,
-    type: null,
-    typeMustMatch: boolean,
-    useMap: null,
-    value: booleanish,
-    width: number,
-    wrap: null,
-    writingSuggestions: null,
-    // Legacy.
-    // See: https://html.spec.whatwg.org/#other-elements,-attributes-and-apis
-    align: null,
-    // Several. Use CSS `text-align` instead,
-    aLink: null,
-    // `<body>`. Use CSS `a:active {color}` instead
-    archive: spaceSeparated,
-    // `<object>`. List of URIs to archives
-    axis: null,
-    // `<td>` and `<th>`. Use `scope` on `<th>`
-    background: null,
-    // `<body>`. Use CSS `background-image` instead
-    bgColor: null,
-    // `<body>` and table elements. Use CSS `background-color` instead
-    border: number,
-    // `<table>`. Use CSS `border-width` instead,
-    borderColor: null,
-    // `<table>`. Use CSS `border-color` instead,
-    bottomMargin: number,
-    // `<body>`
-    cellPadding: null,
-    // `<table>`
-    cellSpacing: null,
-    // `<table>`
-    char: null,
-    // Several table elements. When `align=char`, sets the character to align on
-    charOff: null,
-    // Several table elements. When `char`, offsets the alignment
-    classId: null,
-    // `<object>`
-    clear: null,
-    // `<br>`. Use CSS `clear` instead
-    code: null,
-    // `<object>`
-    codeBase: null,
-    // `<object>`
-    codeType: null,
-    // `<object>`
-    color: null,
-    // `<font>` and `<hr>`. Use CSS instead
-    compact: boolean,
-    // Lists. Use CSS to reduce space between items instead
-    declare: boolean,
-    // `<object>`
-    event: null,
-    // `<script>`
-    face: null,
-    // `<font>`. Use CSS instead
-    frame: null,
-    // `<table>`
-    frameBorder: null,
-    // `<iframe>`. Use CSS `border` instead
-    hSpace: number,
-    // `<img>` and `<object>`
-    leftMargin: number,
-    // `<body>`
-    link: null,
-    // `<body>`. Use CSS `a:link {color: *}` instead
-    longDesc: null,
-    // `<frame>`, `<iframe>`, and `<img>`. Use an `<a>`
-    lowSrc: null,
-    // `<img>`. Use a `<picture>`
-    marginHeight: number,
-    // `<body>`
-    marginWidth: number,
-    // `<body>`
-    noResize: boolean,
-    // `<frame>`
-    noHref: boolean,
-    // `<area>`. Use no href instead of an explicit `nohref`
-    noShade: boolean,
-    // `<hr>`. Use background-color and height instead of borders
-    noWrap: boolean,
-    // `<td>` and `<th>`
-    object: null,
-    // `<applet>`
-    profile: null,
-    // `<head>`
-    prompt: null,
-    // `<isindex>`
-    rev: null,
-    // `<link>`
-    rightMargin: number,
-    // `<body>`
-    rules: null,
-    // `<table>`
-    scheme: null,
-    // `<meta>`
-    scrolling: booleanish,
-    // `<frame>`. Use overflow in the child context
-    standby: null,
-    // `<object>`
-    summary: null,
-    // `<table>`
-    text: null,
-    // `<body>`. Use CSS `color` instead
-    topMargin: number,
-    // `<body>`
-    valueType: null,
-    // `<param>`
-    version: null,
-    // `<html>`. Use a doctype.
-    vAlign: null,
-    // Several. Use CSS `vertical-align` instead
-    vLink: null,
-    // `<body>`. Use CSS `a:visited {color}` instead
-    vSpace: number,
-    // `<img>` and `<object>`
-    // Non-standard Properties.
-    allowTransparency: null,
-    autoCorrect: null,
-    autoSave: null,
-    credentialless: boolean,
-    disablePictureInPicture: boolean,
-    disableRemotePlayback: boolean,
-    exportParts: commaSeparated,
-    part: spaceSeparated,
-    prefix: null,
-    property: null,
-    results: number,
-    security: null,
-    unselectable: null
-  },
-  space: "html",
-  transform: caseInsensitiveTransform
-}), svg$1 = create({
-  attributes: {
-    accentHeight: "accent-height",
-    alignmentBaseline: "alignment-baseline",
-    arabicForm: "arabic-form",
-    baselineShift: "baseline-shift",
-    capHeight: "cap-height",
-    className: "class",
-    clipPath: "clip-path",
-    clipRule: "clip-rule",
-    colorInterpolation: "color-interpolation",
-    colorInterpolationFilters: "color-interpolation-filters",
-    colorProfile: "color-profile",
-    colorRendering: "color-rendering",
-    crossOrigin: "crossorigin",
-    dataType: "datatype",
-    dominantBaseline: "dominant-baseline",
-    enableBackground: "enable-background",
-    fillOpacity: "fill-opacity",
-    fillRule: "fill-rule",
-    floodColor: "flood-color",
-    floodOpacity: "flood-opacity",
-    fontFamily: "font-family",
-    fontSize: "font-size",
-    fontSizeAdjust: "font-size-adjust",
-    fontStretch: "font-stretch",
-    fontStyle: "font-style",
-    fontVariant: "font-variant",
-    fontWeight: "font-weight",
-    glyphName: "glyph-name",
-    glyphOrientationHorizontal: "glyph-orientation-horizontal",
-    glyphOrientationVertical: "glyph-orientation-vertical",
-    hrefLang: "hreflang",
-    horizAdvX: "horiz-adv-x",
-    horizOriginX: "horiz-origin-x",
-    horizOriginY: "horiz-origin-y",
-    imageRendering: "image-rendering",
-    letterSpacing: "letter-spacing",
-    lightingColor: "lighting-color",
-    markerEnd: "marker-end",
-    markerMid: "marker-mid",
-    markerStart: "marker-start",
-    maskType: "mask-type",
-    navDown: "nav-down",
-    navDownLeft: "nav-down-left",
-    navDownRight: "nav-down-right",
-    navLeft: "nav-left",
-    navNext: "nav-next",
-    navPrev: "nav-prev",
-    navRight: "nav-right",
-    navUp: "nav-up",
-    navUpLeft: "nav-up-left",
-    navUpRight: "nav-up-right",
-    onAbort: "onabort",
-    onActivate: "onactivate",
-    onAfterPrint: "onafterprint",
-    onBeforePrint: "onbeforeprint",
-    onBegin: "onbegin",
-    onCancel: "oncancel",
-    onCanPlay: "oncanplay",
-    onCanPlayThrough: "oncanplaythrough",
-    onChange: "onchange",
-    onClick: "onclick",
-    onClose: "onclose",
-    onCopy: "oncopy",
-    onCueChange: "oncuechange",
-    onCut: "oncut",
-    onDblClick: "ondblclick",
-    onDrag: "ondrag",
-    onDragEnd: "ondragend",
-    onDragEnter: "ondragenter",
-    onDragExit: "ondragexit",
-    onDragLeave: "ondragleave",
-    onDragOver: "ondragover",
-    onDragStart: "ondragstart",
-    onDrop: "ondrop",
-    onDurationChange: "ondurationchange",
-    onEmptied: "onemptied",
-    onEnd: "onend",
-    onEnded: "onended",
-    onError: "onerror",
-    onFocus: "onfocus",
-    onFocusIn: "onfocusin",
-    onFocusOut: "onfocusout",
-    onHashChange: "onhashchange",
-    onInput: "oninput",
-    onInvalid: "oninvalid",
-    onKeyDown: "onkeydown",
-    onKeyPress: "onkeypress",
-    onKeyUp: "onkeyup",
-    onLoad: "onload",
-    onLoadedData: "onloadeddata",
-    onLoadedMetadata: "onloadedmetadata",
-    onLoadStart: "onloadstart",
-    onMessage: "onmessage",
-    onMouseDown: "onmousedown",
-    onMouseEnter: "onmouseenter",
-    onMouseLeave: "onmouseleave",
-    onMouseMove: "onmousemove",
-    onMouseOut: "onmouseout",
-    onMouseOver: "onmouseover",
-    onMouseUp: "onmouseup",
-    onMouseWheel: "onmousewheel",
-    onOffline: "onoffline",
-    onOnline: "ononline",
-    onPageHide: "onpagehide",
-    onPageShow: "onpageshow",
-    onPaste: "onpaste",
-    onPause: "onpause",
-    onPlay: "onplay",
-    onPlaying: "onplaying",
-    onPopState: "onpopstate",
-    onProgress: "onprogress",
-    onRateChange: "onratechange",
-    onRepeat: "onrepeat",
-    onReset: "onreset",
-    onResize: "onresize",
-    onScroll: "onscroll",
-    onSeeked: "onseeked",
-    onSeeking: "onseeking",
-    onSelect: "onselect",
-    onShow: "onshow",
-    onStalled: "onstalled",
-    onStorage: "onstorage",
-    onSubmit: "onsubmit",
-    onSuspend: "onsuspend",
-    onTimeUpdate: "ontimeupdate",
-    onToggle: "ontoggle",
-    onUnload: "onunload",
-    onVolumeChange: "onvolumechange",
-    onWaiting: "onwaiting",
-    onZoom: "onzoom",
-    overlinePosition: "overline-position",
-    overlineThickness: "overline-thickness",
-    paintOrder: "paint-order",
-    panose1: "panose-1",
-    pointerEvents: "pointer-events",
-    referrerPolicy: "referrerpolicy",
-    renderingIntent: "rendering-intent",
-    shapeRendering: "shape-rendering",
-    stopColor: "stop-color",
-    stopOpacity: "stop-opacity",
-    strikethroughPosition: "strikethrough-position",
-    strikethroughThickness: "strikethrough-thickness",
-    strokeDashArray: "stroke-dasharray",
-    strokeDashOffset: "stroke-dashoffset",
-    strokeLineCap: "stroke-linecap",
-    strokeLineJoin: "stroke-linejoin",
-    strokeMiterLimit: "stroke-miterlimit",
-    strokeOpacity: "stroke-opacity",
-    strokeWidth: "stroke-width",
-    tabIndex: "tabindex",
-    textAnchor: "text-anchor",
-    textDecoration: "text-decoration",
-    textRendering: "text-rendering",
-    transformOrigin: "transform-origin",
-    typeOf: "typeof",
-    underlinePosition: "underline-position",
-    underlineThickness: "underline-thickness",
-    unicodeBidi: "unicode-bidi",
-    unicodeRange: "unicode-range",
-    unitsPerEm: "units-per-em",
-    vAlphabetic: "v-alphabetic",
-    vHanging: "v-hanging",
-    vIdeographic: "v-ideographic",
-    vMathematical: "v-mathematical",
-    vectorEffect: "vector-effect",
-    vertAdvY: "vert-adv-y",
-    vertOriginX: "vert-origin-x",
-    vertOriginY: "vert-origin-y",
-    wordSpacing: "word-spacing",
-    writingMode: "writing-mode",
-    xHeight: "x-height",
-    // These were camelcased in Tiny. Now lowercased in SVG 2
-    playbackOrder: "playbackorder",
-    timelineBegin: "timelinebegin"
-  },
-  properties: {
-    about: commaOrSpaceSeparated,
-    accentHeight: number,
-    accumulate: null,
-    additive: null,
-    alignmentBaseline: null,
-    alphabetic: number,
-    amplitude: number,
-    arabicForm: null,
-    ascent: number,
-    attributeName: null,
-    attributeType: null,
-    azimuth: number,
-    bandwidth: null,
-    baselineShift: null,
-    baseFrequency: null,
-    baseProfile: null,
-    bbox: null,
-    begin: null,
-    bias: number,
-    by: null,
-    calcMode: null,
-    capHeight: number,
-    className: spaceSeparated,
-    clip: null,
-    clipPath: null,
-    clipPathUnits: null,
-    clipRule: null,
-    color: null,
-    colorInterpolation: null,
-    colorInterpolationFilters: null,
-    colorProfile: null,
-    colorRendering: null,
-    content: null,
-    contentScriptType: null,
-    contentStyleType: null,
-    crossOrigin: null,
-    cursor: null,
-    cx: null,
-    cy: null,
-    d: null,
-    dataType: null,
-    defaultAction: null,
-    descent: number,
-    diffuseConstant: number,
-    direction: null,
-    display: null,
-    dur: null,
-    divisor: number,
-    dominantBaseline: null,
-    download: boolean,
-    dx: null,
-    dy: null,
-    edgeMode: null,
-    editable: null,
-    elevation: number,
-    enableBackground: null,
-    end: null,
-    event: null,
-    exponent: number,
-    externalResourcesRequired: null,
-    fill: null,
-    fillOpacity: number,
-    fillRule: null,
-    filter: null,
-    filterRes: null,
-    filterUnits: null,
-    floodColor: null,
-    floodOpacity: null,
-    focusable: null,
-    focusHighlight: null,
-    fontFamily: null,
-    fontSize: null,
-    fontSizeAdjust: null,
-    fontStretch: null,
-    fontStyle: null,
-    fontVariant: null,
-    fontWeight: null,
-    format: null,
-    fr: null,
-    from: null,
-    fx: null,
-    fy: null,
-    g1: commaSeparated,
-    g2: commaSeparated,
-    glyphName: commaSeparated,
-    glyphOrientationHorizontal: null,
-    glyphOrientationVertical: null,
-    glyphRef: null,
-    gradientTransform: null,
-    gradientUnits: null,
-    handler: null,
-    hanging: number,
-    hatchContentUnits: null,
-    hatchUnits: null,
-    height: null,
-    href: null,
-    hrefLang: null,
-    horizAdvX: number,
-    horizOriginX: number,
-    horizOriginY: number,
-    id: null,
-    ideographic: number,
-    imageRendering: null,
-    initialVisibility: null,
-    in: null,
-    in2: null,
-    intercept: number,
-    k: number,
-    k1: number,
-    k2: number,
-    k3: number,
-    k4: number,
-    kernelMatrix: commaOrSpaceSeparated,
-    kernelUnitLength: null,
-    keyPoints: null,
-    // SEMI_COLON_SEPARATED
-    keySplines: null,
-    // SEMI_COLON_SEPARATED
-    keyTimes: null,
-    // SEMI_COLON_SEPARATED
-    kerning: null,
-    lang: null,
-    lengthAdjust: null,
-    letterSpacing: null,
-    lightingColor: null,
-    limitingConeAngle: number,
-    local: null,
-    markerEnd: null,
-    markerMid: null,
-    markerStart: null,
-    markerHeight: null,
-    markerUnits: null,
-    markerWidth: null,
-    mask: null,
-    maskContentUnits: null,
-    maskType: null,
-    maskUnits: null,
-    mathematical: null,
-    max: null,
-    media: null,
-    mediaCharacterEncoding: null,
-    mediaContentEncodings: null,
-    mediaSize: number,
-    mediaTime: null,
-    method: null,
-    min: null,
-    mode: null,
-    name: null,
-    navDown: null,
-    navDownLeft: null,
-    navDownRight: null,
-    navLeft: null,
-    navNext: null,
-    navPrev: null,
-    navRight: null,
-    navUp: null,
-    navUpLeft: null,
-    navUpRight: null,
-    numOctaves: null,
-    observer: null,
-    offset: null,
-    onAbort: null,
-    onActivate: null,
-    onAfterPrint: null,
-    onBeforePrint: null,
-    onBegin: null,
-    onCancel: null,
-    onCanPlay: null,
-    onCanPlayThrough: null,
-    onChange: null,
-    onClick: null,
-    onClose: null,
-    onCopy: null,
-    onCueChange: null,
-    onCut: null,
-    onDblClick: null,
-    onDrag: null,
-    onDragEnd: null,
-    onDragEnter: null,
-    onDragExit: null,
-    onDragLeave: null,
-    onDragOver: null,
-    onDragStart: null,
-    onDrop: null,
-    onDurationChange: null,
-    onEmptied: null,
-    onEnd: null,
-    onEnded: null,
-    onError: null,
-    onFocus: null,
-    onFocusIn: null,
-    onFocusOut: null,
-    onHashChange: null,
-    onInput: null,
-    onInvalid: null,
-    onKeyDown: null,
-    onKeyPress: null,
-    onKeyUp: null,
-    onLoad: null,
-    onLoadedData: null,
-    onLoadedMetadata: null,
-    onLoadStart: null,
-    onMessage: null,
-    onMouseDown: null,
-    onMouseEnter: null,
-    onMouseLeave: null,
-    onMouseMove: null,
-    onMouseOut: null,
-    onMouseOver: null,
-    onMouseUp: null,
-    onMouseWheel: null,
-    onOffline: null,
-    onOnline: null,
-    onPageHide: null,
-    onPageShow: null,
-    onPaste: null,
-    onPause: null,
-    onPlay: null,
-    onPlaying: null,
-    onPopState: null,
-    onProgress: null,
-    onRateChange: null,
-    onRepeat: null,
-    onReset: null,
-    onResize: null,
-    onScroll: null,
-    onSeeked: null,
-    onSeeking: null,
-    onSelect: null,
-    onShow: null,
-    onStalled: null,
-    onStorage: null,
-    onSubmit: null,
-    onSuspend: null,
-    onTimeUpdate: null,
-    onToggle: null,
-    onUnload: null,
-    onVolumeChange: null,
-    onWaiting: null,
-    onZoom: null,
-    opacity: null,
-    operator: null,
-    order: null,
-    orient: null,
-    orientation: null,
-    origin: null,
-    overflow: null,
-    overlay: null,
-    overlinePosition: number,
-    overlineThickness: number,
-    paintOrder: null,
-    panose1: null,
-    path: null,
-    pathLength: number,
-    patternContentUnits: null,
-    patternTransform: null,
-    patternUnits: null,
-    phase: null,
-    ping: spaceSeparated,
-    pitch: null,
-    playbackOrder: null,
-    pointerEvents: null,
-    points: null,
-    pointsAtX: number,
-    pointsAtY: number,
-    pointsAtZ: number,
-    preserveAlpha: null,
-    preserveAspectRatio: null,
-    primitiveUnits: null,
-    propagate: null,
-    property: commaOrSpaceSeparated,
-    r: null,
-    radius: null,
-    referrerPolicy: null,
-    refX: null,
-    refY: null,
-    rel: commaOrSpaceSeparated,
-    rev: commaOrSpaceSeparated,
-    renderingIntent: null,
-    repeatCount: null,
-    repeatDur: null,
-    requiredExtensions: commaOrSpaceSeparated,
-    requiredFeatures: commaOrSpaceSeparated,
-    requiredFonts: commaOrSpaceSeparated,
-    requiredFormats: commaOrSpaceSeparated,
-    resource: null,
-    restart: null,
-    result: null,
-    rotate: null,
-    rx: null,
-    ry: null,
-    scale: null,
-    seed: null,
-    shapeRendering: null,
-    side: null,
-    slope: null,
-    snapshotTime: null,
-    specularConstant: number,
-    specularExponent: number,
-    spreadMethod: null,
-    spacing: null,
-    startOffset: null,
-    stdDeviation: null,
-    stemh: null,
-    stemv: null,
-    stitchTiles: null,
-    stopColor: null,
-    stopOpacity: null,
-    strikethroughPosition: number,
-    strikethroughThickness: number,
-    string: null,
-    stroke: null,
-    strokeDashArray: commaOrSpaceSeparated,
-    strokeDashOffset: null,
-    strokeLineCap: null,
-    strokeLineJoin: null,
-    strokeMiterLimit: number,
-    strokeOpacity: number,
-    strokeWidth: null,
-    style: null,
-    surfaceScale: number,
-    syncBehavior: null,
-    syncBehaviorDefault: null,
-    syncMaster: null,
-    syncTolerance: null,
-    syncToleranceDefault: null,
-    systemLanguage: commaOrSpaceSeparated,
-    tabIndex: number,
-    tableValues: null,
-    target: null,
-    targetX: number,
-    targetY: number,
-    textAnchor: null,
-    textDecoration: null,
-    textRendering: null,
-    textLength: null,
-    timelineBegin: null,
-    title: null,
-    transformBehavior: null,
-    type: null,
-    typeOf: commaOrSpaceSeparated,
-    to: null,
-    transform: null,
-    transformOrigin: null,
-    u1: null,
-    u2: null,
-    underlinePosition: number,
-    underlineThickness: number,
-    unicode: null,
-    unicodeBidi: null,
-    unicodeRange: null,
-    unitsPerEm: number,
-    values: null,
-    vAlphabetic: number,
-    vMathematical: number,
-    vectorEffect: null,
-    vHanging: number,
-    vIdeographic: number,
-    version: null,
-    vertAdvY: number,
-    vertOriginX: number,
-    vertOriginY: number,
-    viewBox: null,
-    viewTarget: null,
-    visibility: null,
-    width: null,
-    widths: null,
-    wordSpacing: null,
-    writingMode: null,
-    x: null,
-    x1: null,
-    x2: null,
-    xChannelSelector: null,
-    xHeight: number,
-    y: null,
-    y1: null,
-    y2: null,
-    yChannelSelector: null,
-    z: null,
-    zoomAndPan: null
-  },
-  space: "svg",
-  transform: caseSensitiveTransform
-}), xlink = create({
-  properties: {
-    xLinkActuate: null,
-    xLinkArcRole: null,
-    xLinkHref: null,
-    xLinkRole: null,
-    xLinkShow: null,
-    xLinkTitle: null,
-    xLinkType: null
-  },
-  space: "xlink",
-  transform(_2, property) {
-    return "xlink:" + property.slice(5).toLowerCase();
-  }
-}), xmlns = create({
-  attributes: { xmlnsxlink: "xmlns:xlink" },
-  properties: { xmlnsXLink: null, xmlns: null },
-  space: "xmlns",
-  transform: caseInsensitiveTransform
-}), xml = create({
-  properties: { xmlBase: null, xmlLang: null, xmlSpace: null },
-  space: "xml",
-  transform(_2, property) {
-    return "xml:" + property.slice(3).toLowerCase();
-  }
-}), cap = /[A-Z]/g, dash = /-[a-z]/g, valid = /^data[-\w.:]+$/i;
-function find(schema, value) {
-  const normal = normalize(value);
-  let property = value, Type = Info;
-  if (normal in schema.normal)
-    return schema.property[schema.normal[normal]];
-  if (normal.length > 4 && normal.slice(0, 4) === "data" && valid.test(value)) {
-    if (value.charAt(4) === "-") {
-      const rest = value.slice(5).replace(dash, camelcase);
-      property = "data" + rest.charAt(0).toUpperCase() + rest.slice(1);
-    } else {
-      const rest = value.slice(4);
-      if (!dash.test(rest)) {
-        let dashes = rest.replace(cap, kebab);
-        dashes.charAt(0) !== "-" && (dashes = "-" + dashes), value = "data" + dashes;
-      }
-    }
-    Type = DefinedInfo;
-  }
-  return new Type(property, value);
-}
-function kebab($0) {
-  return "-" + $0.toLowerCase();
-}
-function camelcase($0) {
-  return $0.charAt(1).toUpperCase();
-}
-const html = merge([aria, html$1, xlink, xmlns, xml], "html"), svg = merge([aria, svg$1, xlink, xmlns, xml], "svg");
-function parse$1(value) {
-  const tokens = [], input = String(value || "");
-  let index = input.indexOf(","), start = 0, end = !1;
-  for (; !end; ) {
-    index === -1 && (index = input.length, end = !0);
-    const token = input.slice(start, index).trim();
-    (token || !end) && tokens.push(token), start = index + 1, index = input.indexOf(",", start);
-  }
-  return tokens;
-}
-const search = /[#.]/g;
-function parseSelector(selector, defaultTagName) {
-  const value = selector || "", props = {};
-  let start = 0, previous, tagName;
-  for (; start < value.length; ) {
-    search.lastIndex = start;
-    const match = search.exec(value), subvalue = value.slice(start, match ? match.index : value.length);
-    subvalue && (previous ? previous === "#" ? props.id = subvalue : Array.isArray(props.className) ? props.className.push(subvalue) : props.className = [subvalue] : tagName = subvalue, start += subvalue.length), match && (previous = match[0], start++);
-  }
-  return {
-    type: "element",
-    // @ts-expect-error: tag name is parsed.
-    tagName: tagName || defaultTagName || "div",
-    properties: props,
-    children: []
-  };
-}
-function parse(value) {
-  const input = String(value || "").trim();
-  return input ? input.split(/[ \t\n\r\f]+/g) : [];
-}
-function createH(schema, defaultTagName, caseSensitive) {
-  const adjust = caseSensitive ? createAdjustMap(caseSensitive) : void 0;
-  function h2(selector, properties, ...children) {
-    let node;
-    if (selector == null) {
-      node = { type: "root", children: [] };
-      const child = (
-        /** @type {Child} */
-        properties
-      );
-      children.unshift(child);
-    } else {
-      node = parseSelector(selector, defaultTagName);
-      const lower = node.tagName.toLowerCase(), adjusted = adjust ? adjust.get(lower) : void 0;
-      if (node.tagName = adjusted || lower, isChild(properties))
-        children.unshift(properties);
-      else
-        for (const [key, value] of Object.entries(properties))
-          addProperty(schema, node.properties, key, value);
-    }
-    for (const child of children)
-      addChild(node.children, child);
-    return node.type === "element" && node.tagName === "template" && (node.content = { type: "root", children: node.children }, node.children = []), node;
-  }
-  return h2;
-}
-function isChild(value) {
-  if (value === null || typeof value != "object" || Array.isArray(value))
-    return !0;
-  if (typeof value.type != "string") return !1;
-  const record = (
-    /** @type {Record<string, unknown>} */
-    value
-  ), keys = Object.keys(value);
-  for (const key of keys) {
-    const value2 = record[key];
-    if (value2 && typeof value2 == "object") {
-      if (!Array.isArray(value2)) return !0;
-      const list = (
-        /** @type {ReadonlyArray<unknown>} */
-        value2
-      );
-      for (const item of list)
-        if (typeof item != "number" && typeof item != "string")
-          return !0;
-    }
-  }
-  return !!("children" in value && Array.isArray(value.children));
-}
-function addProperty(schema, properties, key, value) {
-  const info = find(schema, key);
-  let result;
-  if (value != null) {
-    if (typeof value == "number") {
-      if (Number.isNaN(value)) return;
-      result = value;
-    } else typeof value == "boolean" ? result = value : typeof value == "string" ? info.spaceSeparated ? result = parse(value) : info.commaSeparated ? result = parse$1(value) : info.commaOrSpaceSeparated ? result = parse(parse$1(value).join(" ")) : result = parsePrimitive(info, info.property, value) : Array.isArray(value) ? result = [...value] : result = info.property === "style" ? style(value) : String(value);
-    if (Array.isArray(result)) {
-      const finalResult = [];
-      for (const item of result)
-        finalResult.push(
-          /** @type {number | string} */
-          parsePrimitive(info, info.property, item)
-        );
-      result = finalResult;
-    }
-    info.property === "className" && Array.isArray(properties.className) && (result = properties.className.concat(
-      /** @type {Array<number | string> | number | string} */
-      result
-    )), properties[info.property] = result;
-  }
-}
-function addChild(nodes, value) {
-  if (value != null) if (typeof value == "number" || typeof value == "string")
-    nodes.push({ type: "text", value: String(value) });
-  else if (Array.isArray(value))
-    for (const child of value)
-      addChild(nodes, child);
-  else if (typeof value == "object" && "type" in value)
-    value.type === "root" ? addChild(nodes, value.children) : nodes.push(value);
-  else
-    throw new Error("Expected node, nodes, or string, got `" + value + "`");
-}
-function parsePrimitive(info, name, value) {
-  if (typeof value == "string") {
-    if (info.number && value && !Number.isNaN(Number(value)))
-      return Number(value);
-    if ((info.boolean || info.overloadedBoolean) && (value === "" || normalize(value) === normalize(name)))
-      return !0;
-  }
-  return value;
-}
-function style(styles) {
-  const result = [];
-  for (const [key, value] of Object.entries(styles))
-    result.push([key, value].join(": "));
-  return result.join("; ");
-}
-function createAdjustMap(values) {
-  const result = /* @__PURE__ */ new Map();
-  for (const value of values)
-    result.set(value.toLowerCase(), value);
-  return result;
-}
-const svgCaseSensitiveTagNames = [
-  "altGlyph",
-  "altGlyphDef",
-  "altGlyphItem",
-  "animateColor",
-  "animateMotion",
-  "animateTransform",
-  "clipPath",
-  "feBlend",
-  "feColorMatrix",
-  "feComponentTransfer",
-  "feComposite",
-  "feConvolveMatrix",
-  "feDiffuseLighting",
-  "feDisplacementMap",
-  "feDistantLight",
-  "feDropShadow",
-  "feFlood",
-  "feFuncA",
-  "feFuncB",
-  "feFuncG",
-  "feFuncR",
-  "feGaussianBlur",
-  "feImage",
-  "feMerge",
-  "feMergeNode",
-  "feMorphology",
-  "feOffset",
-  "fePointLight",
-  "feSpecularLighting",
-  "feSpotLight",
-  "feTile",
-  "feTurbulence",
-  "foreignObject",
-  "glyphRef",
-  "linearGradient",
-  "radialGradient",
-  "solidColor",
-  "textArea",
-  "textPath"
-], h = createH(html, "div");
-createH(svg, "g", svgCaseSensitiveTagNames);
-const characterEntitiesLegacy = [
-  "AElig",
-  "AMP",
-  "Aacute",
-  "Acirc",
-  "Agrave",
-  "Aring",
-  "Atilde",
-  "Auml",
-  "COPY",
-  "Ccedil",
-  "ETH",
-  "Eacute",
-  "Ecirc",
-  "Egrave",
-  "Euml",
-  "GT",
-  "Iacute",
-  "Icirc",
-  "Igrave",
-  "Iuml",
-  "LT",
-  "Ntilde",
-  "Oacute",
-  "Ocirc",
-  "Ograve",
-  "Oslash",
-  "Otilde",
-  "Ouml",
-  "QUOT",
-  "REG",
-  "THORN",
-  "Uacute",
-  "Ucirc",
-  "Ugrave",
-  "Uuml",
-  "Yacute",
-  "aacute",
-  "acirc",
-  "acute",
-  "aelig",
-  "agrave",
-  "amp",
-  "aring",
-  "atilde",
-  "auml",
-  "brvbar",
-  "ccedil",
-  "cedil",
-  "cent",
-  "copy",
-  "curren",
-  "deg",
-  "divide",
-  "eacute",
-  "ecirc",
-  "egrave",
-  "eth",
-  "euml",
-  "frac12",
-  "frac14",
-  "frac34",
-  "gt",
-  "iacute",
-  "icirc",
-  "iexcl",
-  "igrave",
-  "iquest",
-  "iuml",
-  "laquo",
-  "lt",
-  "macr",
-  "micro",
-  "middot",
-  "nbsp",
-  "not",
-  "ntilde",
-  "oacute",
-  "ocirc",
-  "ograve",
-  "ordf",
-  "ordm",
-  "oslash",
-  "otilde",
-  "ouml",
-  "para",
-  "plusmn",
-  "pound",
-  "quot",
-  "raquo",
-  "reg",
-  "sect",
-  "shy",
-  "sup1",
-  "sup2",
-  "sup3",
-  "szlig",
-  "thorn",
-  "times",
-  "uacute",
-  "ucirc",
-  "ugrave",
-  "uml",
-  "uuml",
-  "yacute",
-  "yen",
-  "yuml"
-], characterReferenceInvalid = {
-  0: "\uFFFD",
-  128: "\u20AC",
-  130: "\u201A",
-  131: "\u0192",
-  132: "\u201E",
-  133: "\u2026",
-  134: "\u2020",
-  135: "\u2021",
-  136: "\u02C6",
-  137: "\u2030",
-  138: "\u0160",
-  139: "\u2039",
-  140: "\u0152",
-  142: "\u017D",
-  145: "\u2018",
-  146: "\u2019",
-  147: "\u201C",
-  148: "\u201D",
-  149: "\u2022",
-  150: "\u2013",
-  151: "\u2014",
-  152: "\u02DC",
-  153: "\u2122",
-  154: "\u0161",
-  155: "\u203A",
-  156: "\u0153",
-  158: "\u017E",
-  159: "\u0178"
-};
-function isDecimal(character) {
-  const code = typeof character == "string" ? character.charCodeAt(0) : character;
-  return code >= 48 && code <= 57;
-}
-function isHexadecimal(character) {
-  const code = typeof character == "string" ? character.charCodeAt(0) : character;
-  return code >= 97 && code <= 102 || code >= 65 && code <= 70 || code >= 48 && code <= 57;
-}
-function isAlphabetical(character) {
-  const code = typeof character == "string" ? character.charCodeAt(0) : character;
-  return code >= 97 && code <= 122 || code >= 65 && code <= 90;
-}
-function isAlphanumerical(character) {
-  return isAlphabetical(character) || isDecimal(character);
-}
-const characterEntities = {
-  AElig: "\xC6",
-  AMP: "&",
-  Aacute: "\xC1",
-  Abreve: "\u0102",
-  Acirc: "\xC2",
-  Acy: "\u0410",
-  Afr: "\u{1D504}",
-  Agrave: "\xC0",
-  Alpha: "\u0391",
-  Amacr: "\u0100",
-  And: "\u2A53",
-  Aogon: "\u0104",
-  Aopf: "\u{1D538}",
-  ApplyFunction: "\u2061",
-  Aring: "\xC5",
-  Ascr: "\u{1D49C}",
-  Assign: "\u2254",
-  Atilde: "\xC3",
-  Auml: "\xC4",
-  Backslash: "\u2216",
-  Barv: "\u2AE7",
-  Barwed: "\u2306",
-  Bcy: "\u0411",
-  Because: "\u2235",
-  Bernoullis: "\u212C",
-  Beta: "\u0392",
-  Bfr: "\u{1D505}",
-  Bopf: "\u{1D539}",
-  Breve: "\u02D8",
-  Bscr: "\u212C",
-  Bumpeq: "\u224E",
-  CHcy: "\u0427",
-  COPY: "\xA9",
-  Cacute: "\u0106",
-  Cap: "\u22D2",
-  CapitalDifferentialD: "\u2145",
-  Cayleys: "\u212D",
-  Ccaron: "\u010C",
-  Ccedil: "\xC7",
-  Ccirc: "\u0108",
-  Cconint: "\u2230",
-  Cdot: "\u010A",
-  Cedilla: "\xB8",
-  CenterDot: "\xB7",
-  Cfr: "\u212D",
-  Chi: "\u03A7",
-  CircleDot: "\u2299",
-  CircleMinus: "\u2296",
-  CirclePlus: "\u2295",
-  CircleTimes: "\u2297",
-  ClockwiseContourIntegral: "\u2232",
-  CloseCurlyDoubleQuote: "\u201D",
-  CloseCurlyQuote: "\u2019",
-  Colon: "\u2237",
-  Colone: "\u2A74",
-  Congruent: "\u2261",
-  Conint: "\u222F",
-  ContourIntegral: "\u222E",
-  Copf: "\u2102",
-  Coproduct: "\u2210",
-  CounterClockwiseContourIntegral: "\u2233",
-  Cross: "\u2A2F",
-  Cscr: "\u{1D49E}",
-  Cup: "\u22D3",
-  CupCap: "\u224D",
-  DD: "\u2145",
-  DDotrahd: "\u2911",
-  DJcy: "\u0402",
-  DScy: "\u0405",
-  DZcy: "\u040F",
-  Dagger: "\u2021",
-  Darr: "\u21A1",
-  Dashv: "\u2AE4",
-  Dcaron: "\u010E",
-  Dcy: "\u0414",
-  Del: "\u2207",
-  Delta: "\u0394",
-  Dfr: "\u{1D507}",
-  DiacriticalAcute: "\xB4",
-  DiacriticalDot: "\u02D9",
-  DiacriticalDoubleAcute: "\u02DD",
-  DiacriticalGrave: "`",
-  DiacriticalTilde: "\u02DC",
-  Diamond: "\u22C4",
-  DifferentialD: "\u2146",
-  Dopf: "\u{1D53B}",
-  Dot: "\xA8",
-  DotDot: "\u20DC",
-  DotEqual: "\u2250",
-  DoubleContourIntegral: "\u222F",
-  DoubleDot: "\xA8",
-  DoubleDownArrow: "\u21D3",
-  DoubleLeftArrow: "\u21D0",
-  DoubleLeftRightArrow: "\u21D4",
-  DoubleLeftTee: "\u2AE4",
-  DoubleLongLeftArrow: "\u27F8",
-  DoubleLongLeftRightArrow: "\u27FA",
-  DoubleLongRightArrow: "\u27F9",
-  DoubleRightArrow: "\u21D2",
-  DoubleRightTee: "\u22A8",
-  DoubleUpArrow: "\u21D1",
-  DoubleUpDownArrow: "\u21D5",
-  DoubleVerticalBar: "\u2225",
-  DownArrow: "\u2193",
-  DownArrowBar: "\u2913",
-  DownArrowUpArrow: "\u21F5",
-  DownBreve: "\u0311",
-  DownLeftRightVector: "\u2950",
-  DownLeftTeeVector: "\u295E",
-  DownLeftVector: "\u21BD",
-  DownLeftVectorBar: "\u2956",
-  DownRightTeeVector: "\u295F",
-  DownRightVector: "\u21C1",
-  DownRightVectorBar: "\u2957",
-  DownTee: "\u22A4",
-  DownTeeArrow: "\u21A7",
-  Downarrow: "\u21D3",
-  Dscr: "\u{1D49F}",
-  Dstrok: "\u0110",
-  ENG: "\u014A",
-  ETH: "\xD0",
-  Eacute: "\xC9",
-  Ecaron: "\u011A",
-  Ecirc: "\xCA",
-  Ecy: "\u042D",
-  Edot: "\u0116",
-  Efr: "\u{1D508}",
-  Egrave: "\xC8",
-  Element: "\u2208",
-  Emacr: "\u0112",
-  EmptySmallSquare: "\u25FB",
-  EmptyVerySmallSquare: "\u25AB",
-  Eogon: "\u0118",
-  Eopf: "\u{1D53C}",
-  Epsilon: "\u0395",
-  Equal: "\u2A75",
-  EqualTilde: "\u2242",
-  Equilibrium: "\u21CC",
-  Escr: "\u2130",
-  Esim: "\u2A73",
-  Eta: "\u0397",
-  Euml: "\xCB",
-  Exists: "\u2203",
-  ExponentialE: "\u2147",
-  Fcy: "\u0424",
-  Ffr: "\u{1D509}",
-  FilledSmallSquare: "\u25FC",
-  FilledVerySmallSquare: "\u25AA",
-  Fopf: "\u{1D53D}",
-  ForAll: "\u2200",
-  Fouriertrf: "\u2131",
-  Fscr: "\u2131",
-  GJcy: "\u0403",
-  GT: ">",
-  Gamma: "\u0393",
-  Gammad: "\u03DC",
-  Gbreve: "\u011E",
-  Gcedil: "\u0122",
-  Gcirc: "\u011C",
-  Gcy: "\u0413",
-  Gdot: "\u0120",
-  Gfr: "\u{1D50A}",
-  Gg: "\u22D9",
-  Gopf: "\u{1D53E}",
-  GreaterEqual: "\u2265",
-  GreaterEqualLess: "\u22DB",
-  GreaterFullEqual: "\u2267",
-  GreaterGreater: "\u2AA2",
-  GreaterLess: "\u2277",
-  GreaterSlantEqual: "\u2A7E",
-  GreaterTilde: "\u2273",
-  Gscr: "\u{1D4A2}",
-  Gt: "\u226B",
-  HARDcy: "\u042A",
-  Hacek: "\u02C7",
-  Hat: "^",
-  Hcirc: "\u0124",
-  Hfr: "\u210C",
-  HilbertSpace: "\u210B",
-  Hopf: "\u210D",
-  HorizontalLine: "\u2500",
-  Hscr: "\u210B",
-  Hstrok: "\u0126",
-  HumpDownHump: "\u224E",
-  HumpEqual: "\u224F",
-  IEcy: "\u0415",
-  IJlig: "\u0132",
-  IOcy: "\u0401",
-  Iacute: "\xCD",
-  Icirc: "\xCE",
-  Icy: "\u0418",
-  Idot: "\u0130",
-  Ifr: "\u2111",
-  Igrave: "\xCC",
-  Im: "\u2111",
-  Imacr: "\u012A",
-  ImaginaryI: "\u2148",
-  Implies: "\u21D2",
-  Int: "\u222C",
-  Integral: "\u222B",
-  Intersection: "\u22C2",
-  InvisibleComma: "\u2063",
-  InvisibleTimes: "\u2062",
-  Iogon: "\u012E",
-  Iopf: "\u{1D540}",
-  Iota: "\u0399",
-  Iscr: "\u2110",
-  Itilde: "\u0128",
-  Iukcy: "\u0406",
-  Iuml: "\xCF",
-  Jcirc: "\u0134",
-  Jcy: "\u0419",
-  Jfr: "\u{1D50D}",
-  Jopf: "\u{1D541}",
-  Jscr: "\u{1D4A5}",
-  Jsercy: "\u0408",
-  Jukcy: "\u0404",
-  KHcy: "\u0425",
-  KJcy: "\u040C",
-  Kappa: "\u039A",
-  Kcedil: "\u0136",
-  Kcy: "\u041A",
-  Kfr: "\u{1D50E}",
-  Kopf: "\u{1D542}",
-  Kscr: "\u{1D4A6}",
-  LJcy: "\u0409",
-  LT: "<",
-  Lacute: "\u0139",
-  Lambda: "\u039B",
-  Lang: "\u27EA",
-  Laplacetrf: "\u2112",
-  Larr: "\u219E",
-  Lcaron: "\u013D",
-  Lcedil: "\u013B",
-  Lcy: "\u041B",
-  LeftAngleBracket: "\u27E8",
-  LeftArrow: "\u2190",
-  LeftArrowBar: "\u21E4",
-  LeftArrowRightArrow: "\u21C6",
-  LeftCeiling: "\u2308",
-  LeftDoubleBracket: "\u27E6",
-  LeftDownTeeVector: "\u2961",
-  LeftDownVector: "\u21C3",
-  LeftDownVectorBar: "\u2959",
-  LeftFloor: "\u230A",
-  LeftRightArrow: "\u2194",
-  LeftRightVector: "\u294E",
-  LeftTee: "\u22A3",
-  LeftTeeArrow: "\u21A4",
-  LeftTeeVector: "\u295A",
-  LeftTriangle: "\u22B2",
-  LeftTriangleBar: "\u29CF",
-  LeftTriangleEqual: "\u22B4",
-  LeftUpDownVector: "\u2951",
-  LeftUpTeeVector: "\u2960",
-  LeftUpVector: "\u21BF",
-  LeftUpVectorBar: "\u2958",
-  LeftVector: "\u21BC",
-  LeftVectorBar: "\u2952",
-  Leftarrow: "\u21D0",
-  Leftrightarrow: "\u21D4",
-  LessEqualGreater: "\u22DA",
-  LessFullEqual: "\u2266",
-  LessGreater: "\u2276",
-  LessLess: "\u2AA1",
-  LessSlantEqual: "\u2A7D",
-  LessTilde: "\u2272",
-  Lfr: "\u{1D50F}",
-  Ll: "\u22D8",
-  Lleftarrow: "\u21DA",
-  Lmidot: "\u013F",
-  LongLeftArrow: "\u27F5",
-  LongLeftRightArrow: "\u27F7",
-  LongRightArrow: "\u27F6",
-  Longleftarrow: "\u27F8",
-  Longleftrightarrow: "\u27FA",
-  Longrightarrow: "\u27F9",
-  Lopf: "\u{1D543}",
-  LowerLeftArrow: "\u2199",
-  LowerRightArrow: "\u2198",
-  Lscr: "\u2112",
-  Lsh: "\u21B0",
-  Lstrok: "\u0141",
-  Lt: "\u226A",
-  Map: "\u2905",
-  Mcy: "\u041C",
-  MediumSpace: "\u205F",
-  Mellintrf: "\u2133",
-  Mfr: "\u{1D510}",
-  MinusPlus: "\u2213",
-  Mopf: "\u{1D544}",
-  Mscr: "\u2133",
-  Mu: "\u039C",
-  NJcy: "\u040A",
-  Nacute: "\u0143",
-  Ncaron: "\u0147",
-  Ncedil: "\u0145",
-  Ncy: "\u041D",
-  NegativeMediumSpace: "\u200B",
-  NegativeThickSpace: "\u200B",
-  NegativeThinSpace: "\u200B",
-  NegativeVeryThinSpace: "\u200B",
-  NestedGreaterGreater: "\u226B",
-  NestedLessLess: "\u226A",
-  NewLine: `
-`,
-  Nfr: "\u{1D511}",
-  NoBreak: "\u2060",
-  NonBreakingSpace: "\xA0",
-  Nopf: "\u2115",
-  Not: "\u2AEC",
-  NotCongruent: "\u2262",
-  NotCupCap: "\u226D",
-  NotDoubleVerticalBar: "\u2226",
-  NotElement: "\u2209",
-  NotEqual: "\u2260",
-  NotEqualTilde: "\u2242\u0338",
-  NotExists: "\u2204",
-  NotGreater: "\u226F",
-  NotGreaterEqual: "\u2271",
-  NotGreaterFullEqual: "\u2267\u0338",
-  NotGreaterGreater: "\u226B\u0338",
-  NotGreaterLess: "\u2279",
-  NotGreaterSlantEqual: "\u2A7E\u0338",
-  NotGreaterTilde: "\u2275",
-  NotHumpDownHump: "\u224E\u0338",
-  NotHumpEqual: "\u224F\u0338",
-  NotLeftTriangle: "\u22EA",
-  NotLeftTriangleBar: "\u29CF\u0338",
-  NotLeftTriangleEqual: "\u22EC",
-  NotLess: "\u226E",
-  NotLessEqual: "\u2270",
-  NotLessGreater: "\u2278",
-  NotLessLess: "\u226A\u0338",
-  NotLessSlantEqual: "\u2A7D\u0338",
-  NotLessTilde: "\u2274",
-  NotNestedGreaterGreater: "\u2AA2\u0338",
-  NotNestedLessLess: "\u2AA1\u0338",
-  NotPrecedes: "\u2280",
-  NotPrecedesEqual: "\u2AAF\u0338",
-  NotPrecedesSlantEqual: "\u22E0",
-  NotReverseElement: "\u220C",
-  NotRightTriangle: "\u22EB",
-  NotRightTriangleBar: "\u29D0\u0338",
-  NotRightTriangleEqual: "\u22ED",
-  NotSquareSubset: "\u228F\u0338",
-  NotSquareSubsetEqual: "\u22E2",
-  NotSquareSuperset: "\u2290\u0338",
-  NotSquareSupersetEqual: "\u22E3",
-  NotSubset: "\u2282\u20D2",
-  NotSubsetEqual: "\u2288",
-  NotSucceeds: "\u2281",
-  NotSucceedsEqual: "\u2AB0\u0338",
-  NotSucceedsSlantEqual: "\u22E1",
-  NotSucceedsTilde: "\u227F\u0338",
-  NotSuperset: "\u2283\u20D2",
-  NotSupersetEqual: "\u2289",
-  NotTilde: "\u2241",
-  NotTildeEqual: "\u2244",
-  NotTildeFullEqual: "\u2247",
-  NotTildeTilde: "\u2249",
-  NotVerticalBar: "\u2224",
-  Nscr: "\u{1D4A9}",
-  Ntilde: "\xD1",
-  Nu: "\u039D",
-  OElig: "\u0152",
-  Oacute: "\xD3",
-  Ocirc: "\xD4",
-  Ocy: "\u041E",
-  Odblac: "\u0150",
-  Ofr: "\u{1D512}",
-  Ograve: "\xD2",
-  Omacr: "\u014C",
-  Omega: "\u03A9",
-  Omicron: "\u039F",
-  Oopf: "\u{1D546}",
-  OpenCurlyDoubleQuote: "\u201C",
-  OpenCurlyQuote: "\u2018",
-  Or: "\u2A54",
-  Oscr: "\u{1D4AA}",
-  Oslash: "\xD8",
-  Otilde: "\xD5",
-  Otimes: "\u2A37",
-  Ouml: "\xD6",
-  OverBar: "\u203E",
-  OverBrace: "\u23DE",
-  OverBracket: "\u23B4",
-  OverParenthesis: "\u23DC",
-  PartialD: "\u2202",
-  Pcy: "\u041F",
-  Pfr: "\u{1D513}",
-  Phi: "\u03A6",
-  Pi: "\u03A0",
-  PlusMinus: "\xB1",
-  Poincareplane: "\u210C",
-  Popf: "\u2119",
-  Pr: "\u2ABB",
-  Precedes: "\u227A",
-  PrecedesEqual: "\u2AAF",
-  PrecedesSlantEqual: "\u227C",
-  PrecedesTilde: "\u227E",
-  Prime: "\u2033",
-  Product: "\u220F",
-  Proportion: "\u2237",
-  Proportional: "\u221D",
-  Pscr: "\u{1D4AB}",
-  Psi: "\u03A8",
-  QUOT: '"',
-  Qfr: "\u{1D514}",
-  Qopf: "\u211A",
-  Qscr: "\u{1D4AC}",
-  RBarr: "\u2910",
-  REG: "\xAE",
-  Racute: "\u0154",
-  Rang: "\u27EB",
-  Rarr: "\u21A0",
-  Rarrtl: "\u2916",
-  Rcaron: "\u0158",
-  Rcedil: "\u0156",
-  Rcy: "\u0420",
-  Re: "\u211C",
-  ReverseElement: "\u220B",
-  ReverseEquilibrium: "\u21CB",
-  ReverseUpEquilibrium: "\u296F",
-  Rfr: "\u211C",
-  Rho: "\u03A1",
-  RightAngleBracket: "\u27E9",
-  RightArrow: "\u2192",
-  RightArrowBar: "\u21E5",
-  RightArrowLeftArrow: "\u21C4",
-  RightCeiling: "\u2309",
-  RightDoubleBracket: "\u27E7",
-  RightDownTeeVector: "\u295D",
-  RightDownVector: "\u21C2",
-  RightDownVectorBar: "\u2955",
-  RightFloor: "\u230B",
-  RightTee: "\u22A2",
-  RightTeeArrow: "\u21A6",
-  RightTeeVector: "\u295B",
-  RightTriangle: "\u22B3",
-  RightTriangleBar: "\u29D0",
-  RightTriangleEqual: "\u22B5",
-  RightUpDownVector: "\u294F",
-  RightUpTeeVector: "\u295C",
-  RightUpVector: "\u21BE",
-  RightUpVectorBar: "\u2954",
-  RightVector: "\u21C0",
-  RightVectorBar: "\u2953",
-  Rightarrow: "\u21D2",
-  Ropf: "\u211D",
-  RoundImplies: "\u2970",
-  Rrightarrow: "\u21DB",
-  Rscr: "\u211B",
-  Rsh: "\u21B1",
-  RuleDelayed: "\u29F4",
-  SHCHcy: "\u0429",
-  SHcy: "\u0428",
-  SOFTcy: "\u042C",
-  Sacute: "\u015A",
-  Sc: "\u2ABC",
-  Scaron: "\u0160",
-  Scedil: "\u015E",
-  Scirc: "\u015C",
-  Scy: "\u0421",
-  Sfr: "\u{1D516}",
-  ShortDownArrow: "\u2193",
-  ShortLeftArrow: "\u2190",
-  ShortRightArrow: "\u2192",
-  ShortUpArrow: "\u2191",
-  Sigma: "\u03A3",
-  SmallCircle: "\u2218",
-  Sopf: "\u{1D54A}",
-  Sqrt: "\u221A",
-  Square: "\u25A1",
-  SquareIntersection: "\u2293",
-  SquareSubset: "\u228F",
-  SquareSubsetEqual: "\u2291",
-  SquareSuperset: "\u2290",
-  SquareSupersetEqual: "\u2292",
-  SquareUnion: "\u2294",
-  Sscr: "\u{1D4AE}",
-  Star: "\u22C6",
-  Sub: "\u22D0",
-  Subset: "\u22D0",
-  SubsetEqual: "\u2286",
-  Succeeds: "\u227B",
-  SucceedsEqual: "\u2AB0",
-  SucceedsSlantEqual: "\u227D",
-  SucceedsTilde: "\u227F",
-  SuchThat: "\u220B",
-  Sum: "\u2211",
-  Sup: "\u22D1",
-  Superset: "\u2283",
-  SupersetEqual: "\u2287",
-  Supset: "\u22D1",
-  THORN: "\xDE",
-  TRADE: "\u2122",
-  TSHcy: "\u040B",
-  TScy: "\u0426",
-  Tab: "	",
-  Tau: "\u03A4",
-  Tcaron: "\u0164",
-  Tcedil: "\u0162",
-  Tcy: "\u0422",
-  Tfr: "\u{1D517}",
-  Therefore: "\u2234",
-  Theta: "\u0398",
-  ThickSpace: "\u205F\u200A",
-  ThinSpace: "\u2009",
-  Tilde: "\u223C",
-  TildeEqual: "\u2243",
-  TildeFullEqual: "\u2245",
-  TildeTilde: "\u2248",
-  Topf: "\u{1D54B}",
-  TripleDot: "\u20DB",
-  Tscr: "\u{1D4AF}",
-  Tstrok: "\u0166",
-  Uacute: "\xDA",
-  Uarr: "\u219F",
-  Uarrocir: "\u2949",
-  Ubrcy: "\u040E",
-  Ubreve: "\u016C",
-  Ucirc: "\xDB",
-  Ucy: "\u0423",
-  Udblac: "\u0170",
-  Ufr: "\u{1D518}",
-  Ugrave: "\xD9",
-  Umacr: "\u016A",
-  UnderBar: "_",
-  UnderBrace: "\u23DF",
-  UnderBracket: "\u23B5",
-  UnderParenthesis: "\u23DD",
-  Union: "\u22C3",
-  UnionPlus: "\u228E",
-  Uogon: "\u0172",
-  Uopf: "\u{1D54C}",
-  UpArrow: "\u2191",
-  UpArrowBar: "\u2912",
-  UpArrowDownArrow: "\u21C5",
-  UpDownArrow: "\u2195",
-  UpEquilibrium: "\u296E",
-  UpTee: "\u22A5",
-  UpTeeArrow: "\u21A5",
-  Uparrow: "\u21D1",
-  Updownarrow: "\u21D5",
-  UpperLeftArrow: "\u2196",
-  UpperRightArrow: "\u2197",
-  Upsi: "\u03D2",
-  Upsilon: "\u03A5",
-  Uring: "\u016E",
-  Uscr: "\u{1D4B0}",
-  Utilde: "\u0168",
-  Uuml: "\xDC",
-  VDash: "\u22AB",
-  Vbar: "\u2AEB",
-  Vcy: "\u0412",
-  Vdash: "\u22A9",
-  Vdashl: "\u2AE6",
-  Vee: "\u22C1",
-  Verbar: "\u2016",
-  Vert: "\u2016",
-  VerticalBar: "\u2223",
-  VerticalLine: "|",
-  VerticalSeparator: "\u2758",
-  VerticalTilde: "\u2240",
-  VeryThinSpace: "\u200A",
-  Vfr: "\u{1D519}",
-  Vopf: "\u{1D54D}",
-  Vscr: "\u{1D4B1}",
-  Vvdash: "\u22AA",
-  Wcirc: "\u0174",
-  Wedge: "\u22C0",
-  Wfr: "\u{1D51A}",
-  Wopf: "\u{1D54E}",
-  Wscr: "\u{1D4B2}",
-  Xfr: "\u{1D51B}",
-  Xi: "\u039E",
-  Xopf: "\u{1D54F}",
-  Xscr: "\u{1D4B3}",
-  YAcy: "\u042F",
-  YIcy: "\u0407",
-  YUcy: "\u042E",
-  Yacute: "\xDD",
-  Ycirc: "\u0176",
-  Ycy: "\u042B",
-  Yfr: "\u{1D51C}",
-  Yopf: "\u{1D550}",
-  Yscr: "\u{1D4B4}",
-  Yuml: "\u0178",
-  ZHcy: "\u0416",
-  Zacute: "\u0179",
-  Zcaron: "\u017D",
-  Zcy: "\u0417",
-  Zdot: "\u017B",
-  ZeroWidthSpace: "\u200B",
-  Zeta: "\u0396",
-  Zfr: "\u2128",
-  Zopf: "\u2124",
-  Zscr: "\u{1D4B5}",
-  aacute: "\xE1",
-  abreve: "\u0103",
-  ac: "\u223E",
-  acE: "\u223E\u0333",
-  acd: "\u223F",
-  acirc: "\xE2",
-  acute: "\xB4",
-  acy: "\u0430",
-  aelig: "\xE6",
-  af: "\u2061",
-  afr: "\u{1D51E}",
-  agrave: "\xE0",
-  alefsym: "\u2135",
-  aleph: "\u2135",
-  alpha: "\u03B1",
-  amacr: "\u0101",
-  amalg: "\u2A3F",
-  amp: "&",
-  and: "\u2227",
-  andand: "\u2A55",
-  andd: "\u2A5C",
-  andslope: "\u2A58",
-  andv: "\u2A5A",
-  ang: "\u2220",
-  ange: "\u29A4",
-  angle: "\u2220",
-  angmsd: "\u2221",
-  angmsdaa: "\u29A8",
-  angmsdab: "\u29A9",
-  angmsdac: "\u29AA",
-  angmsdad: "\u29AB",
-  angmsdae: "\u29AC",
-  angmsdaf: "\u29AD",
-  angmsdag: "\u29AE",
-  angmsdah: "\u29AF",
-  angrt: "\u221F",
-  angrtvb: "\u22BE",
-  angrtvbd: "\u299D",
-  angsph: "\u2222",
-  angst: "\xC5",
-  angzarr: "\u237C",
-  aogon: "\u0105",
-  aopf: "\u{1D552}",
-  ap: "\u2248",
-  apE: "\u2A70",
-  apacir: "\u2A6F",
-  ape: "\u224A",
-  apid: "\u224B",
-  apos: "'",
-  approx: "\u2248",
-  approxeq: "\u224A",
-  aring: "\xE5",
-  ascr: "\u{1D4B6}",
-  ast: "*",
-  asymp: "\u2248",
-  asympeq: "\u224D",
-  atilde: "\xE3",
-  auml: "\xE4",
-  awconint: "\u2233",
-  awint: "\u2A11",
-  bNot: "\u2AED",
-  backcong: "\u224C",
-  backepsilon: "\u03F6",
-  backprime: "\u2035",
-  backsim: "\u223D",
-  backsimeq: "\u22CD",
-  barvee: "\u22BD",
-  barwed: "\u2305",
-  barwedge: "\u2305",
-  bbrk: "\u23B5",
-  bbrktbrk: "\u23B6",
-  bcong: "\u224C",
-  bcy: "\u0431",
-  bdquo: "\u201E",
-  becaus: "\u2235",
-  because: "\u2235",
-  bemptyv: "\u29B0",
-  bepsi: "\u03F6",
-  bernou: "\u212C",
-  beta: "\u03B2",
-  beth: "\u2136",
-  between: "\u226C",
-  bfr: "\u{1D51F}",
-  bigcap: "\u22C2",
-  bigcirc: "\u25EF",
-  bigcup: "\u22C3",
-  bigodot: "\u2A00",
-  bigoplus: "\u2A01",
-  bigotimes: "\u2A02",
-  bigsqcup: "\u2A06",
-  bigstar: "\u2605",
-  bigtriangledown: "\u25BD",
-  bigtriangleup: "\u25B3",
-  biguplus: "\u2A04",
-  bigvee: "\u22C1",
-  bigwedge: "\u22C0",
-  bkarow: "\u290D",
-  blacklozenge: "\u29EB",
-  blacksquare: "\u25AA",
-  blacktriangle: "\u25B4",
-  blacktriangledown: "\u25BE",
-  blacktriangleleft: "\u25C2",
-  blacktriangleright: "\u25B8",
-  blank: "\u2423",
-  blk12: "\u2592",
-  blk14: "\u2591",
-  blk34: "\u2593",
-  block: "\u2588",
-  bne: "=\u20E5",
-  bnequiv: "\u2261\u20E5",
-  bnot: "\u2310",
-  bopf: "\u{1D553}",
-  bot: "\u22A5",
-  bottom: "\u22A5",
-  bowtie: "\u22C8",
-  boxDL: "\u2557",
-  boxDR: "\u2554",
-  boxDl: "\u2556",
-  boxDr: "\u2553",
-  boxH: "\u2550",
-  boxHD: "\u2566",
-  boxHU: "\u2569",
-  boxHd: "\u2564",
-  boxHu: "\u2567",
-  boxUL: "\u255D",
-  boxUR: "\u255A",
-  boxUl: "\u255C",
-  boxUr: "\u2559",
-  boxV: "\u2551",
-  boxVH: "\u256C",
-  boxVL: "\u2563",
-  boxVR: "\u2560",
-  boxVh: "\u256B",
-  boxVl: "\u2562",
-  boxVr: "\u255F",
-  boxbox: "\u29C9",
-  boxdL: "\u2555",
-  boxdR: "\u2552",
-  boxdl: "\u2510",
-  boxdr: "\u250C",
-  boxh: "\u2500",
-  boxhD: "\u2565",
-  boxhU: "\u2568",
-  boxhd: "\u252C",
-  boxhu: "\u2534",
-  boxminus: "\u229F",
-  boxplus: "\u229E",
-  boxtimes: "\u22A0",
-  boxuL: "\u255B",
-  boxuR: "\u2558",
-  boxul: "\u2518",
-  boxur: "\u2514",
-  boxv: "\u2502",
-  boxvH: "\u256A",
-  boxvL: "\u2561",
-  boxvR: "\u255E",
-  boxvh: "\u253C",
-  boxvl: "\u2524",
-  boxvr: "\u251C",
-  bprime: "\u2035",
-  breve: "\u02D8",
-  brvbar: "\xA6",
-  bscr: "\u{1D4B7}",
-  bsemi: "\u204F",
-  bsim: "\u223D",
-  bsime: "\u22CD",
-  bsol: "\\",
-  bsolb: "\u29C5",
-  bsolhsub: "\u27C8",
-  bull: "\u2022",
-  bullet: "\u2022",
-  bump: "\u224E",
-  bumpE: "\u2AAE",
-  bumpe: "\u224F",
-  bumpeq: "\u224F",
-  cacute: "\u0107",
-  cap: "\u2229",
-  capand: "\u2A44",
-  capbrcup: "\u2A49",
-  capcap: "\u2A4B",
-  capcup: "\u2A47",
-  capdot: "\u2A40",
-  caps: "\u2229\uFE00",
-  caret: "\u2041",
-  caron: "\u02C7",
-  ccaps: "\u2A4D",
-  ccaron: "\u010D",
-  ccedil: "\xE7",
-  ccirc: "\u0109",
-  ccups: "\u2A4C",
-  ccupssm: "\u2A50",
-  cdot: "\u010B",
-  cedil: "\xB8",
-  cemptyv: "\u29B2",
-  cent: "\xA2",
-  centerdot: "\xB7",
-  cfr: "\u{1D520}",
-  chcy: "\u0447",
-  check: "\u2713",
-  checkmark: "\u2713",
-  chi: "\u03C7",
-  cir: "\u25CB",
-  cirE: "\u29C3",
-  circ: "\u02C6",
-  circeq: "\u2257",
-  circlearrowleft: "\u21BA",
-  circlearrowright: "\u21BB",
-  circledR: "\xAE",
-  circledS: "\u24C8",
-  circledast: "\u229B",
-  circledcirc: "\u229A",
-  circleddash: "\u229D",
-  cire: "\u2257",
-  cirfnint: "\u2A10",
-  cirmid: "\u2AEF",
-  cirscir: "\u29C2",
-  clubs: "\u2663",
-  clubsuit: "\u2663",
-  colon: ":",
-  colone: "\u2254",
-  coloneq: "\u2254",
-  comma: ",",
-  commat: "@",
-  comp: "\u2201",
-  compfn: "\u2218",
-  complement: "\u2201",
-  complexes: "\u2102",
-  cong: "\u2245",
-  congdot: "\u2A6D",
-  conint: "\u222E",
-  copf: "\u{1D554}",
-  coprod: "\u2210",
-  copy: "\xA9",
-  copysr: "\u2117",
-  crarr: "\u21B5",
-  cross: "\u2717",
-  cscr: "\u{1D4B8}",
-  csub: "\u2ACF",
-  csube: "\u2AD1",
-  csup: "\u2AD0",
-  csupe: "\u2AD2",
-  ctdot: "\u22EF",
-  cudarrl: "\u2938",
-  cudarrr: "\u2935",
-  cuepr: "\u22DE",
-  cuesc: "\u22DF",
-  cularr: "\u21B6",
-  cularrp: "\u293D",
-  cup: "\u222A",
-  cupbrcap: "\u2A48",
-  cupcap: "\u2A46",
-  cupcup: "\u2A4A",
-  cupdot: "\u228D",
-  cupor: "\u2A45",
-  cups: "\u222A\uFE00",
-  curarr: "\u21B7",
-  curarrm: "\u293C",
-  curlyeqprec: "\u22DE",
-  curlyeqsucc: "\u22DF",
-  curlyvee: "\u22CE",
-  curlywedge: "\u22CF",
-  curren: "\xA4",
-  curvearrowleft: "\u21B6",
-  curvearrowright: "\u21B7",
-  cuvee: "\u22CE",
-  cuwed: "\u22CF",
-  cwconint: "\u2232",
-  cwint: "\u2231",
-  cylcty: "\u232D",
-  dArr: "\u21D3",
-  dHar: "\u2965",
-  dagger: "\u2020",
-  daleth: "\u2138",
-  darr: "\u2193",
-  dash: "\u2010",
-  dashv: "\u22A3",
-  dbkarow: "\u290F",
-  dblac: "\u02DD",
-  dcaron: "\u010F",
-  dcy: "\u0434",
-  dd: "\u2146",
-  ddagger: "\u2021",
-  ddarr: "\u21CA",
-  ddotseq: "\u2A77",
-  deg: "\xB0",
-  delta: "\u03B4",
-  demptyv: "\u29B1",
-  dfisht: "\u297F",
-  dfr: "\u{1D521}",
-  dharl: "\u21C3",
-  dharr: "\u21C2",
-  diam: "\u22C4",
-  diamond: "\u22C4",
-  diamondsuit: "\u2666",
-  diams: "\u2666",
-  die: "\xA8",
-  digamma: "\u03DD",
-  disin: "\u22F2",
-  div: "\xF7",
-  divide: "\xF7",
-  divideontimes: "\u22C7",
-  divonx: "\u22C7",
-  djcy: "\u0452",
-  dlcorn: "\u231E",
-  dlcrop: "\u230D",
-  dollar: "$",
-  dopf: "\u{1D555}",
-  dot: "\u02D9",
-  doteq: "\u2250",
-  doteqdot: "\u2251",
-  dotminus: "\u2238",
-  dotplus: "\u2214",
-  dotsquare: "\u22A1",
-  doublebarwedge: "\u2306",
-  downarrow: "\u2193",
-  downdownarrows: "\u21CA",
-  downharpoonleft: "\u21C3",
-  downharpoonright: "\u21C2",
-  drbkarow: "\u2910",
-  drcorn: "\u231F",
-  drcrop: "\u230C",
-  dscr: "\u{1D4B9}",
-  dscy: "\u0455",
-  dsol: "\u29F6",
-  dstrok: "\u0111",
-  dtdot: "\u22F1",
-  dtri: "\u25BF",
-  dtrif: "\u25BE",
-  duarr: "\u21F5",
-  duhar: "\u296F",
-  dwangle: "\u29A6",
-  dzcy: "\u045F",
-  dzigrarr: "\u27FF",
-  eDDot: "\u2A77",
-  eDot: "\u2251",
-  eacute: "\xE9",
-  easter: "\u2A6E",
-  ecaron: "\u011B",
-  ecir: "\u2256",
-  ecirc: "\xEA",
-  ecolon: "\u2255",
-  ecy: "\u044D",
-  edot: "\u0117",
-  ee: "\u2147",
-  efDot: "\u2252",
-  efr: "\u{1D522}",
-  eg: "\u2A9A",
-  egrave: "\xE8",
-  egs: "\u2A96",
-  egsdot: "\u2A98",
-  el: "\u2A99",
-  elinters: "\u23E7",
-  ell: "\u2113",
-  els: "\u2A95",
-  elsdot: "\u2A97",
-  emacr: "\u0113",
-  empty: "\u2205",
-  emptyset: "\u2205",
-  emptyv: "\u2205",
-  emsp13: "\u2004",
-  emsp14: "\u2005",
-  emsp: "\u2003",
-  eng: "\u014B",
-  ensp: "\u2002",
-  eogon: "\u0119",
-  eopf: "\u{1D556}",
-  epar: "\u22D5",
-  eparsl: "\u29E3",
-  eplus: "\u2A71",
-  epsi: "\u03B5",
-  epsilon: "\u03B5",
-  epsiv: "\u03F5",
-  eqcirc: "\u2256",
-  eqcolon: "\u2255",
-  eqsim: "\u2242",
-  eqslantgtr: "\u2A96",
-  eqslantless: "\u2A95",
-  equals: "=",
-  equest: "\u225F",
-  equiv: "\u2261",
-  equivDD: "\u2A78",
-  eqvparsl: "\u29E5",
-  erDot: "\u2253",
-  erarr: "\u2971",
-  escr: "\u212F",
-  esdot: "\u2250",
-  esim: "\u2242",
-  eta: "\u03B7",
-  eth: "\xF0",
-  euml: "\xEB",
-  euro: "\u20AC",
-  excl: "!",
-  exist: "\u2203",
-  expectation: "\u2130",
-  exponentiale: "\u2147",
-  fallingdotseq: "\u2252",
-  fcy: "\u0444",
-  female: "\u2640",
-  ffilig: "\uFB03",
-  fflig: "\uFB00",
-  ffllig: "\uFB04",
-  ffr: "\u{1D523}",
-  filig: "\uFB01",
-  fjlig: "fj",
-  flat: "\u266D",
-  fllig: "\uFB02",
-  fltns: "\u25B1",
-  fnof: "\u0192",
-  fopf: "\u{1D557}",
-  forall: "\u2200",
-  fork: "\u22D4",
-  forkv: "\u2AD9",
-  fpartint: "\u2A0D",
-  frac12: "\xBD",
-  frac13: "\u2153",
-  frac14: "\xBC",
-  frac15: "\u2155",
-  frac16: "\u2159",
-  frac18: "\u215B",
-  frac23: "\u2154",
-  frac25: "\u2156",
-  frac34: "\xBE",
-  frac35: "\u2157",
-  frac38: "\u215C",
-  frac45: "\u2158",
-  frac56: "\u215A",
-  frac58: "\u215D",
-  frac78: "\u215E",
-  frasl: "\u2044",
-  frown: "\u2322",
-  fscr: "\u{1D4BB}",
-  gE: "\u2267",
-  gEl: "\u2A8C",
-  gacute: "\u01F5",
-  gamma: "\u03B3",
-  gammad: "\u03DD",
-  gap: "\u2A86",
-  gbreve: "\u011F",
-  gcirc: "\u011D",
-  gcy: "\u0433",
-  gdot: "\u0121",
-  ge: "\u2265",
-  gel: "\u22DB",
-  geq: "\u2265",
-  geqq: "\u2267",
-  geqslant: "\u2A7E",
-  ges: "\u2A7E",
-  gescc: "\u2AA9",
-  gesdot: "\u2A80",
-  gesdoto: "\u2A82",
-  gesdotol: "\u2A84",
-  gesl: "\u22DB\uFE00",
-  gesles: "\u2A94",
-  gfr: "\u{1D524}",
-  gg: "\u226B",
-  ggg: "\u22D9",
-  gimel: "\u2137",
-  gjcy: "\u0453",
-  gl: "\u2277",
-  glE: "\u2A92",
-  gla: "\u2AA5",
-  glj: "\u2AA4",
-  gnE: "\u2269",
-  gnap: "\u2A8A",
-  gnapprox: "\u2A8A",
-  gne: "\u2A88",
-  gneq: "\u2A88",
-  gneqq: "\u2269",
-  gnsim: "\u22E7",
-  gopf: "\u{1D558}",
-  grave: "`",
-  gscr: "\u210A",
-  gsim: "\u2273",
-  gsime: "\u2A8E",
-  gsiml: "\u2A90",
-  gt: ">",
-  gtcc: "\u2AA7",
-  gtcir: "\u2A7A",
-  gtdot: "\u22D7",
-  gtlPar: "\u2995",
-  gtquest: "\u2A7C",
-  gtrapprox: "\u2A86",
-  gtrarr: "\u2978",
-  gtrdot: "\u22D7",
-  gtreqless: "\u22DB",
-  gtreqqless: "\u2A8C",
-  gtrless: "\u2277",
-  gtrsim: "\u2273",
-  gvertneqq: "\u2269\uFE00",
-  gvnE: "\u2269\uFE00",
-  hArr: "\u21D4",
-  hairsp: "\u200A",
-  half: "\xBD",
-  hamilt: "\u210B",
-  hardcy: "\u044A",
-  harr: "\u2194",
-  harrcir: "\u2948",
-  harrw: "\u21AD",
-  hbar: "\u210F",
-  hcirc: "\u0125",
-  hearts: "\u2665",
-  heartsuit: "\u2665",
-  hellip: "\u2026",
-  hercon: "\u22B9",
-  hfr: "\u{1D525}",
-  hksearow: "\u2925",
-  hkswarow: "\u2926",
-  hoarr: "\u21FF",
-  homtht: "\u223B",
-  hookleftarrow: "\u21A9",
-  hookrightarrow: "\u21AA",
-  hopf: "\u{1D559}",
-  horbar: "\u2015",
-  hscr: "\u{1D4BD}",
-  hslash: "\u210F",
-  hstrok: "\u0127",
-  hybull: "\u2043",
-  hyphen: "\u2010",
-  iacute: "\xED",
-  ic: "\u2063",
-  icirc: "\xEE",
-  icy: "\u0438",
-  iecy: "\u0435",
-  iexcl: "\xA1",
-  iff: "\u21D4",
-  ifr: "\u{1D526}",
-  igrave: "\xEC",
-  ii: "\u2148",
-  iiiint: "\u2A0C",
-  iiint: "\u222D",
-  iinfin: "\u29DC",
-  iiota: "\u2129",
-  ijlig: "\u0133",
-  imacr: "\u012B",
-  image: "\u2111",
-  imagline: "\u2110",
-  imagpart: "\u2111",
-  imath: "\u0131",
-  imof: "\u22B7",
-  imped: "\u01B5",
-  in: "\u2208",
-  incare: "\u2105",
-  infin: "\u221E",
-  infintie: "\u29DD",
-  inodot: "\u0131",
-  int: "\u222B",
-  intcal: "\u22BA",
-  integers: "\u2124",
-  intercal: "\u22BA",
-  intlarhk: "\u2A17",
-  intprod: "\u2A3C",
-  iocy: "\u0451",
-  iogon: "\u012F",
-  iopf: "\u{1D55A}",
-  iota: "\u03B9",
-  iprod: "\u2A3C",
-  iquest: "\xBF",
-  iscr: "\u{1D4BE}",
-  isin: "\u2208",
-  isinE: "\u22F9",
-  isindot: "\u22F5",
-  isins: "\u22F4",
-  isinsv: "\u22F3",
-  isinv: "\u2208",
-  it: "\u2062",
-  itilde: "\u0129",
-  iukcy: "\u0456",
-  iuml: "\xEF",
-  jcirc: "\u0135",
-  jcy: "\u0439",
-  jfr: "\u{1D527}",
-  jmath: "\u0237",
-  jopf: "\u{1D55B}",
-  jscr: "\u{1D4BF}",
-  jsercy: "\u0458",
-  jukcy: "\u0454",
-  kappa: "\u03BA",
-  kappav: "\u03F0",
-  kcedil: "\u0137",
-  kcy: "\u043A",
-  kfr: "\u{1D528}",
-  kgreen: "\u0138",
-  khcy: "\u0445",
-  kjcy: "\u045C",
-  kopf: "\u{1D55C}",
-  kscr: "\u{1D4C0}",
-  lAarr: "\u21DA",
-  lArr: "\u21D0",
-  lAtail: "\u291B",
-  lBarr: "\u290E",
-  lE: "\u2266",
-  lEg: "\u2A8B",
-  lHar: "\u2962",
-  lacute: "\u013A",
-  laemptyv: "\u29B4",
-  lagran: "\u2112",
-  lambda: "\u03BB",
-  lang: "\u27E8",
-  langd: "\u2991",
-  langle: "\u27E8",
-  lap: "\u2A85",
-  laquo: "\xAB",
-  larr: "\u2190",
-  larrb: "\u21E4",
-  larrbfs: "\u291F",
-  larrfs: "\u291D",
-  larrhk: "\u21A9",
-  larrlp: "\u21AB",
-  larrpl: "\u2939",
-  larrsim: "\u2973",
-  larrtl: "\u21A2",
-  lat: "\u2AAB",
-  latail: "\u2919",
-  late: "\u2AAD",
-  lates: "\u2AAD\uFE00",
-  lbarr: "\u290C",
-  lbbrk: "\u2772",
-  lbrace: "{",
-  lbrack: "[",
-  lbrke: "\u298B",
-  lbrksld: "\u298F",
-  lbrkslu: "\u298D",
-  lcaron: "\u013E",
-  lcedil: "\u013C",
-  lceil: "\u2308",
-  lcub: "{",
-  lcy: "\u043B",
-  ldca: "\u2936",
-  ldquo: "\u201C",
-  ldquor: "\u201E",
-  ldrdhar: "\u2967",
-  ldrushar: "\u294B",
-  ldsh: "\u21B2",
-  le: "\u2264",
-  leftarrow: "\u2190",
-  leftarrowtail: "\u21A2",
-  leftharpoondown: "\u21BD",
-  leftharpoonup: "\u21BC",
-  leftleftarrows: "\u21C7",
-  leftrightarrow: "\u2194",
-  leftrightarrows: "\u21C6",
-  leftrightharpoons: "\u21CB",
-  leftrightsquigarrow: "\u21AD",
-  leftthreetimes: "\u22CB",
-  leg: "\u22DA",
-  leq: "\u2264",
-  leqq: "\u2266",
-  leqslant: "\u2A7D",
-  les: "\u2A7D",
-  lescc: "\u2AA8",
-  lesdot: "\u2A7F",
-  lesdoto: "\u2A81",
-  lesdotor: "\u2A83",
-  lesg: "\u22DA\uFE00",
-  lesges: "\u2A93",
-  lessapprox: "\u2A85",
-  lessdot: "\u22D6",
-  lesseqgtr: "\u22DA",
-  lesseqqgtr: "\u2A8B",
-  lessgtr: "\u2276",
-  lesssim: "\u2272",
-  lfisht: "\u297C",
-  lfloor: "\u230A",
-  lfr: "\u{1D529}",
-  lg: "\u2276",
-  lgE: "\u2A91",
-  lhard: "\u21BD",
-  lharu: "\u21BC",
-  lharul: "\u296A",
-  lhblk: "\u2584",
-  ljcy: "\u0459",
-  ll: "\u226A",
-  llarr: "\u21C7",
-  llcorner: "\u231E",
-  llhard: "\u296B",
-  lltri: "\u25FA",
-  lmidot: "\u0140",
-  lmoust: "\u23B0",
-  lmoustache: "\u23B0",
-  lnE: "\u2268",
-  lnap: "\u2A89",
-  lnapprox: "\u2A89",
-  lne: "\u2A87",
-  lneq: "\u2A87",
-  lneqq: "\u2268",
-  lnsim: "\u22E6",
-  loang: "\u27EC",
-  loarr: "\u21FD",
-  lobrk: "\u27E6",
-  longleftarrow: "\u27F5",
-  longleftrightarrow: "\u27F7",
-  longmapsto: "\u27FC",
-  longrightarrow: "\u27F6",
-  looparrowleft: "\u21AB",
-  looparrowright: "\u21AC",
-  lopar: "\u2985",
-  lopf: "\u{1D55D}",
-  loplus: "\u2A2D",
-  lotimes: "\u2A34",
-  lowast: "\u2217",
-  lowbar: "_",
-  loz: "\u25CA",
-  lozenge: "\u25CA",
-  lozf: "\u29EB",
-  lpar: "(",
-  lparlt: "\u2993",
-  lrarr: "\u21C6",
-  lrcorner: "\u231F",
-  lrhar: "\u21CB",
-  lrhard: "\u296D",
-  lrm: "\u200E",
-  lrtri: "\u22BF",
-  lsaquo: "\u2039",
-  lscr: "\u{1D4C1}",
-  lsh: "\u21B0",
-  lsim: "\u2272",
-  lsime: "\u2A8D",
-  lsimg: "\u2A8F",
-  lsqb: "[",
-  lsquo: "\u2018",
-  lsquor: "\u201A",
-  lstrok: "\u0142",
-  lt: "<",
-  ltcc: "\u2AA6",
-  ltcir: "\u2A79",
-  ltdot: "\u22D6",
-  lthree: "\u22CB",
-  ltimes: "\u22C9",
-  ltlarr: "\u2976",
-  ltquest: "\u2A7B",
-  ltrPar: "\u2996",
-  ltri: "\u25C3",
-  ltrie: "\u22B4",
-  ltrif: "\u25C2",
-  lurdshar: "\u294A",
-  luruhar: "\u2966",
-  lvertneqq: "\u2268\uFE00",
-  lvnE: "\u2268\uFE00",
-  mDDot: "\u223A",
-  macr: "\xAF",
-  male: "\u2642",
-  malt: "\u2720",
-  maltese: "\u2720",
-  map: "\u21A6",
-  mapsto: "\u21A6",
-  mapstodown: "\u21A7",
-  mapstoleft: "\u21A4",
-  mapstoup: "\u21A5",
-  marker: "\u25AE",
-  mcomma: "\u2A29",
-  mcy: "\u043C",
-  mdash: "\u2014",
-  measuredangle: "\u2221",
-  mfr: "\u{1D52A}",
-  mho: "\u2127",
-  micro: "\xB5",
-  mid: "\u2223",
-  midast: "*",
-  midcir: "\u2AF0",
-  middot: "\xB7",
-  minus: "\u2212",
-  minusb: "\u229F",
-  minusd: "\u2238",
-  minusdu: "\u2A2A",
-  mlcp: "\u2ADB",
-  mldr: "\u2026",
-  mnplus: "\u2213",
-  models: "\u22A7",
-  mopf: "\u{1D55E}",
-  mp: "\u2213",
-  mscr: "\u{1D4C2}",
-  mstpos: "\u223E",
-  mu: "\u03BC",
-  multimap: "\u22B8",
-  mumap: "\u22B8",
-  nGg: "\u22D9\u0338",
-  nGt: "\u226B\u20D2",
-  nGtv: "\u226B\u0338",
-  nLeftarrow: "\u21CD",
-  nLeftrightarrow: "\u21CE",
-  nLl: "\u22D8\u0338",
-  nLt: "\u226A\u20D2",
-  nLtv: "\u226A\u0338",
-  nRightarrow: "\u21CF",
-  nVDash: "\u22AF",
-  nVdash: "\u22AE",
-  nabla: "\u2207",
-  nacute: "\u0144",
-  nang: "\u2220\u20D2",
-  nap: "\u2249",
-  napE: "\u2A70\u0338",
-  napid: "\u224B\u0338",
-  napos: "\u0149",
-  napprox: "\u2249",
-  natur: "\u266E",
-  natural: "\u266E",
-  naturals: "\u2115",
-  nbsp: "\xA0",
-  nbump: "\u224E\u0338",
-  nbumpe: "\u224F\u0338",
-  ncap: "\u2A43",
-  ncaron: "\u0148",
-  ncedil: "\u0146",
-  ncong: "\u2247",
-  ncongdot: "\u2A6D\u0338",
-  ncup: "\u2A42",
-  ncy: "\u043D",
-  ndash: "\u2013",
-  ne: "\u2260",
-  neArr: "\u21D7",
-  nearhk: "\u2924",
-  nearr: "\u2197",
-  nearrow: "\u2197",
-  nedot: "\u2250\u0338",
-  nequiv: "\u2262",
-  nesear: "\u2928",
-  nesim: "\u2242\u0338",
-  nexist: "\u2204",
-  nexists: "\u2204",
-  nfr: "\u{1D52B}",
-  ngE: "\u2267\u0338",
-  nge: "\u2271",
-  ngeq: "\u2271",
-  ngeqq: "\u2267\u0338",
-  ngeqslant: "\u2A7E\u0338",
-  nges: "\u2A7E\u0338",
-  ngsim: "\u2275",
-  ngt: "\u226F",
-  ngtr: "\u226F",
-  nhArr: "\u21CE",
-  nharr: "\u21AE",
-  nhpar: "\u2AF2",
-  ni: "\u220B",
-  nis: "\u22FC",
-  nisd: "\u22FA",
-  niv: "\u220B",
-  njcy: "\u045A",
-  nlArr: "\u21CD",
-  nlE: "\u2266\u0338",
-  nlarr: "\u219A",
-  nldr: "\u2025",
-  nle: "\u2270",
-  nleftarrow: "\u219A",
-  nleftrightarrow: "\u21AE",
-  nleq: "\u2270",
-  nleqq: "\u2266\u0338",
-  nleqslant: "\u2A7D\u0338",
-  nles: "\u2A7D\u0338",
-  nless: "\u226E",
-  nlsim: "\u2274",
-  nlt: "\u226E",
-  nltri: "\u22EA",
-  nltrie: "\u22EC",
-  nmid: "\u2224",
-  nopf: "\u{1D55F}",
-  not: "\xAC",
-  notin: "\u2209",
-  notinE: "\u22F9\u0338",
-  notindot: "\u22F5\u0338",
-  notinva: "\u2209",
-  notinvb: "\u22F7",
-  notinvc: "\u22F6",
-  notni: "\u220C",
-  notniva: "\u220C",
-  notnivb: "\u22FE",
-  notnivc: "\u22FD",
-  npar: "\u2226",
-  nparallel: "\u2226",
-  nparsl: "\u2AFD\u20E5",
-  npart: "\u2202\u0338",
-  npolint: "\u2A14",
-  npr: "\u2280",
-  nprcue: "\u22E0",
-  npre: "\u2AAF\u0338",
-  nprec: "\u2280",
-  npreceq: "\u2AAF\u0338",
-  nrArr: "\u21CF",
-  nrarr: "\u219B",
-  nrarrc: "\u2933\u0338",
-  nrarrw: "\u219D\u0338",
-  nrightarrow: "\u219B",
-  nrtri: "\u22EB",
-  nrtrie: "\u22ED",
-  nsc: "\u2281",
-  nsccue: "\u22E1",
-  nsce: "\u2AB0\u0338",
-  nscr: "\u{1D4C3}",
-  nshortmid: "\u2224",
-  nshortparallel: "\u2226",
-  nsim: "\u2241",
-  nsime: "\u2244",
-  nsimeq: "\u2244",
-  nsmid: "\u2224",
-  nspar: "\u2226",
-  nsqsube: "\u22E2",
-  nsqsupe: "\u22E3",
-  nsub: "\u2284",
-  nsubE: "\u2AC5\u0338",
-  nsube: "\u2288",
-  nsubset: "\u2282\u20D2",
-  nsubseteq: "\u2288",
-  nsubseteqq: "\u2AC5\u0338",
-  nsucc: "\u2281",
-  nsucceq: "\u2AB0\u0338",
-  nsup: "\u2285",
-  nsupE: "\u2AC6\u0338",
-  nsupe: "\u2289",
-  nsupset: "\u2283\u20D2",
-  nsupseteq: "\u2289",
-  nsupseteqq: "\u2AC6\u0338",
-  ntgl: "\u2279",
-  ntilde: "\xF1",
-  ntlg: "\u2278",
-  ntriangleleft: "\u22EA",
-  ntrianglelefteq: "\u22EC",
-  ntriangleright: "\u22EB",
-  ntrianglerighteq: "\u22ED",
-  nu: "\u03BD",
-  num: "#",
-  numero: "\u2116",
-  numsp: "\u2007",
-  nvDash: "\u22AD",
-  nvHarr: "\u2904",
-  nvap: "\u224D\u20D2",
-  nvdash: "\u22AC",
-  nvge: "\u2265\u20D2",
-  nvgt: ">\u20D2",
-  nvinfin: "\u29DE",
-  nvlArr: "\u2902",
-  nvle: "\u2264\u20D2",
-  nvlt: "<\u20D2",
-  nvltrie: "\u22B4\u20D2",
-  nvrArr: "\u2903",
-  nvrtrie: "\u22B5\u20D2",
-  nvsim: "\u223C\u20D2",
-  nwArr: "\u21D6",
-  nwarhk: "\u2923",
-  nwarr: "\u2196",
-  nwarrow: "\u2196",
-  nwnear: "\u2927",
-  oS: "\u24C8",
-  oacute: "\xF3",
-  oast: "\u229B",
-  ocir: "\u229A",
-  ocirc: "\xF4",
-  ocy: "\u043E",
-  odash: "\u229D",
-  odblac: "\u0151",
-  odiv: "\u2A38",
-  odot: "\u2299",
-  odsold: "\u29BC",
-  oelig: "\u0153",
-  ofcir: "\u29BF",
-  ofr: "\u{1D52C}",
-  ogon: "\u02DB",
-  ograve: "\xF2",
-  ogt: "\u29C1",
-  ohbar: "\u29B5",
-  ohm: "\u03A9",
-  oint: "\u222E",
-  olarr: "\u21BA",
-  olcir: "\u29BE",
-  olcross: "\u29BB",
-  oline: "\u203E",
-  olt: "\u29C0",
-  omacr: "\u014D",
-  omega: "\u03C9",
-  omicron: "\u03BF",
-  omid: "\u29B6",
-  ominus: "\u2296",
-  oopf: "\u{1D560}",
-  opar: "\u29B7",
-  operp: "\u29B9",
-  oplus: "\u2295",
-  or: "\u2228",
-  orarr: "\u21BB",
-  ord: "\u2A5D",
-  order: "\u2134",
-  orderof: "\u2134",
-  ordf: "\xAA",
-  ordm: "\xBA",
-  origof: "\u22B6",
-  oror: "\u2A56",
-  orslope: "\u2A57",
-  orv: "\u2A5B",
-  oscr: "\u2134",
-  oslash: "\xF8",
-  osol: "\u2298",
-  otilde: "\xF5",
-  otimes: "\u2297",
-  otimesas: "\u2A36",
-  ouml: "\xF6",
-  ovbar: "\u233D",
-  par: "\u2225",
-  para: "\xB6",
-  parallel: "\u2225",
-  parsim: "\u2AF3",
-  parsl: "\u2AFD",
-  part: "\u2202",
-  pcy: "\u043F",
-  percnt: "%",
-  period: ".",
-  permil: "\u2030",
-  perp: "\u22A5",
-  pertenk: "\u2031",
-  pfr: "\u{1D52D}",
-  phi: "\u03C6",
-  phiv: "\u03D5",
-  phmmat: "\u2133",
-  phone: "\u260E",
-  pi: "\u03C0",
-  pitchfork: "\u22D4",
-  piv: "\u03D6",
-  planck: "\u210F",
-  planckh: "\u210E",
-  plankv: "\u210F",
-  plus: "+",
-  plusacir: "\u2A23",
-  plusb: "\u229E",
-  pluscir: "\u2A22",
-  plusdo: "\u2214",
-  plusdu: "\u2A25",
-  pluse: "\u2A72",
-  plusmn: "\xB1",
-  plussim: "\u2A26",
-  plustwo: "\u2A27",
-  pm: "\xB1",
-  pointint: "\u2A15",
-  popf: "\u{1D561}",
-  pound: "\xA3",
-  pr: "\u227A",
-  prE: "\u2AB3",
-  prap: "\u2AB7",
-  prcue: "\u227C",
-  pre: "\u2AAF",
-  prec: "\u227A",
-  precapprox: "\u2AB7",
-  preccurlyeq: "\u227C",
-  preceq: "\u2AAF",
-  precnapprox: "\u2AB9",
-  precneqq: "\u2AB5",
-  precnsim: "\u22E8",
-  precsim: "\u227E",
-  prime: "\u2032",
-  primes: "\u2119",
-  prnE: "\u2AB5",
-  prnap: "\u2AB9",
-  prnsim: "\u22E8",
-  prod: "\u220F",
-  profalar: "\u232E",
-  profline: "\u2312",
-  profsurf: "\u2313",
-  prop: "\u221D",
-  propto: "\u221D",
-  prsim: "\u227E",
-  prurel: "\u22B0",
-  pscr: "\u{1D4C5}",
-  psi: "\u03C8",
-  puncsp: "\u2008",
-  qfr: "\u{1D52E}",
-  qint: "\u2A0C",
-  qopf: "\u{1D562}",
-  qprime: "\u2057",
-  qscr: "\u{1D4C6}",
-  quaternions: "\u210D",
-  quatint: "\u2A16",
-  quest: "?",
-  questeq: "\u225F",
-  quot: '"',
-  rAarr: "\u21DB",
-  rArr: "\u21D2",
-  rAtail: "\u291C",
-  rBarr: "\u290F",
-  rHar: "\u2964",
-  race: "\u223D\u0331",
-  racute: "\u0155",
-  radic: "\u221A",
-  raemptyv: "\u29B3",
-  rang: "\u27E9",
-  rangd: "\u2992",
-  range: "\u29A5",
-  rangle: "\u27E9",
-  raquo: "\xBB",
-  rarr: "\u2192",
-  rarrap: "\u2975",
-  rarrb: "\u21E5",
-  rarrbfs: "\u2920",
-  rarrc: "\u2933",
-  rarrfs: "\u291E",
-  rarrhk: "\u21AA",
-  rarrlp: "\u21AC",
-  rarrpl: "\u2945",
-  rarrsim: "\u2974",
-  rarrtl: "\u21A3",
-  rarrw: "\u219D",
-  ratail: "\u291A",
-  ratio: "\u2236",
-  rationals: "\u211A",
-  rbarr: "\u290D",
-  rbbrk: "\u2773",
-  rbrace: "}",
-  rbrack: "]",
-  rbrke: "\u298C",
-  rbrksld: "\u298E",
-  rbrkslu: "\u2990",
-  rcaron: "\u0159",
-  rcedil: "\u0157",
-  rceil: "\u2309",
-  rcub: "}",
-  rcy: "\u0440",
-  rdca: "\u2937",
-  rdldhar: "\u2969",
-  rdquo: "\u201D",
-  rdquor: "\u201D",
-  rdsh: "\u21B3",
-  real: "\u211C",
-  realine: "\u211B",
-  realpart: "\u211C",
-  reals: "\u211D",
-  rect: "\u25AD",
-  reg: "\xAE",
-  rfisht: "\u297D",
-  rfloor: "\u230B",
-  rfr: "\u{1D52F}",
-  rhard: "\u21C1",
-  rharu: "\u21C0",
-  rharul: "\u296C",
-  rho: "\u03C1",
-  rhov: "\u03F1",
-  rightarrow: "\u2192",
-  rightarrowtail: "\u21A3",
-  rightharpoondown: "\u21C1",
-  rightharpoonup: "\u21C0",
-  rightleftarrows: "\u21C4",
-  rightleftharpoons: "\u21CC",
-  rightrightarrows: "\u21C9",
-  rightsquigarrow: "\u219D",
-  rightthreetimes: "\u22CC",
-  ring: "\u02DA",
-  risingdotseq: "\u2253",
-  rlarr: "\u21C4",
-  rlhar: "\u21CC",
-  rlm: "\u200F",
-  rmoust: "\u23B1",
-  rmoustache: "\u23B1",
-  rnmid: "\u2AEE",
-  roang: "\u27ED",
-  roarr: "\u21FE",
-  robrk: "\u27E7",
-  ropar: "\u2986",
-  ropf: "\u{1D563}",
-  roplus: "\u2A2E",
-  rotimes: "\u2A35",
-  rpar: ")",
-  rpargt: "\u2994",
-  rppolint: "\u2A12",
-  rrarr: "\u21C9",
-  rsaquo: "\u203A",
-  rscr: "\u{1D4C7}",
-  rsh: "\u21B1",
-  rsqb: "]",
-  rsquo: "\u2019",
-  rsquor: "\u2019",
-  rthree: "\u22CC",
-  rtimes: "\u22CA",
-  rtri: "\u25B9",
-  rtrie: "\u22B5",
-  rtrif: "\u25B8",
-  rtriltri: "\u29CE",
-  ruluhar: "\u2968",
-  rx: "\u211E",
-  sacute: "\u015B",
-  sbquo: "\u201A",
-  sc: "\u227B",
-  scE: "\u2AB4",
-  scap: "\u2AB8",
-  scaron: "\u0161",
-  sccue: "\u227D",
-  sce: "\u2AB0",
-  scedil: "\u015F",
-  scirc: "\u015D",
-  scnE: "\u2AB6",
-  scnap: "\u2ABA",
-  scnsim: "\u22E9",
-  scpolint: "\u2A13",
-  scsim: "\u227F",
-  scy: "\u0441",
-  sdot: "\u22C5",
-  sdotb: "\u22A1",
-  sdote: "\u2A66",
-  seArr: "\u21D8",
-  searhk: "\u2925",
-  searr: "\u2198",
-  searrow: "\u2198",
-  sect: "\xA7",
-  semi: ";",
-  seswar: "\u2929",
-  setminus: "\u2216",
-  setmn: "\u2216",
-  sext: "\u2736",
-  sfr: "\u{1D530}",
-  sfrown: "\u2322",
-  sharp: "\u266F",
-  shchcy: "\u0449",
-  shcy: "\u0448",
-  shortmid: "\u2223",
-  shortparallel: "\u2225",
-  shy: "\xAD",
-  sigma: "\u03C3",
-  sigmaf: "\u03C2",
-  sigmav: "\u03C2",
-  sim: "\u223C",
-  simdot: "\u2A6A",
-  sime: "\u2243",
-  simeq: "\u2243",
-  simg: "\u2A9E",
-  simgE: "\u2AA0",
-  siml: "\u2A9D",
-  simlE: "\u2A9F",
-  simne: "\u2246",
-  simplus: "\u2A24",
-  simrarr: "\u2972",
-  slarr: "\u2190",
-  smallsetminus: "\u2216",
-  smashp: "\u2A33",
-  smeparsl: "\u29E4",
-  smid: "\u2223",
-  smile: "\u2323",
-  smt: "\u2AAA",
-  smte: "\u2AAC",
-  smtes: "\u2AAC\uFE00",
-  softcy: "\u044C",
-  sol: "/",
-  solb: "\u29C4",
-  solbar: "\u233F",
-  sopf: "\u{1D564}",
-  spades: "\u2660",
-  spadesuit: "\u2660",
-  spar: "\u2225",
-  sqcap: "\u2293",
-  sqcaps: "\u2293\uFE00",
-  sqcup: "\u2294",
-  sqcups: "\u2294\uFE00",
-  sqsub: "\u228F",
-  sqsube: "\u2291",
-  sqsubset: "\u228F",
-  sqsubseteq: "\u2291",
-  sqsup: "\u2290",
-  sqsupe: "\u2292",
-  sqsupset: "\u2290",
-  sqsupseteq: "\u2292",
-  squ: "\u25A1",
-  square: "\u25A1",
-  squarf: "\u25AA",
-  squf: "\u25AA",
-  srarr: "\u2192",
-  sscr: "\u{1D4C8}",
-  ssetmn: "\u2216",
-  ssmile: "\u2323",
-  sstarf: "\u22C6",
-  star: "\u2606",
-  starf: "\u2605",
-  straightepsilon: "\u03F5",
-  straightphi: "\u03D5",
-  strns: "\xAF",
-  sub: "\u2282",
-  subE: "\u2AC5",
-  subdot: "\u2ABD",
-  sube: "\u2286",
-  subedot: "\u2AC3",
-  submult: "\u2AC1",
-  subnE: "\u2ACB",
-  subne: "\u228A",
-  subplus: "\u2ABF",
-  subrarr: "\u2979",
-  subset: "\u2282",
-  subseteq: "\u2286",
-  subseteqq: "\u2AC5",
-  subsetneq: "\u228A",
-  subsetneqq: "\u2ACB",
-  subsim: "\u2AC7",
-  subsub: "\u2AD5",
-  subsup: "\u2AD3",
-  succ: "\u227B",
-  succapprox: "\u2AB8",
-  succcurlyeq: "\u227D",
-  succeq: "\u2AB0",
-  succnapprox: "\u2ABA",
-  succneqq: "\u2AB6",
-  succnsim: "\u22E9",
-  succsim: "\u227F",
-  sum: "\u2211",
-  sung: "\u266A",
-  sup1: "\xB9",
-  sup2: "\xB2",
-  sup3: "\xB3",
-  sup: "\u2283",
-  supE: "\u2AC6",
-  supdot: "\u2ABE",
-  supdsub: "\u2AD8",
-  supe: "\u2287",
-  supedot: "\u2AC4",
-  suphsol: "\u27C9",
-  suphsub: "\u2AD7",
-  suplarr: "\u297B",
-  supmult: "\u2AC2",
-  supnE: "\u2ACC",
-  supne: "\u228B",
-  supplus: "\u2AC0",
-  supset: "\u2283",
-  supseteq: "\u2287",
-  supseteqq: "\u2AC6",
-  supsetneq: "\u228B",
-  supsetneqq: "\u2ACC",
-  supsim: "\u2AC8",
-  supsub: "\u2AD4",
-  supsup: "\u2AD6",
-  swArr: "\u21D9",
-  swarhk: "\u2926",
-  swarr: "\u2199",
-  swarrow: "\u2199",
-  swnwar: "\u292A",
-  szlig: "\xDF",
-  target: "\u2316",
-  tau: "\u03C4",
-  tbrk: "\u23B4",
-  tcaron: "\u0165",
-  tcedil: "\u0163",
-  tcy: "\u0442",
-  tdot: "\u20DB",
-  telrec: "\u2315",
-  tfr: "\u{1D531}",
-  there4: "\u2234",
-  therefore: "\u2234",
-  theta: "\u03B8",
-  thetasym: "\u03D1",
-  thetav: "\u03D1",
-  thickapprox: "\u2248",
-  thicksim: "\u223C",
-  thinsp: "\u2009",
-  thkap: "\u2248",
-  thksim: "\u223C",
-  thorn: "\xFE",
-  tilde: "\u02DC",
-  times: "\xD7",
-  timesb: "\u22A0",
-  timesbar: "\u2A31",
-  timesd: "\u2A30",
-  tint: "\u222D",
-  toea: "\u2928",
-  top: "\u22A4",
-  topbot: "\u2336",
-  topcir: "\u2AF1",
-  topf: "\u{1D565}",
-  topfork: "\u2ADA",
-  tosa: "\u2929",
-  tprime: "\u2034",
-  trade: "\u2122",
-  triangle: "\u25B5",
-  triangledown: "\u25BF",
-  triangleleft: "\u25C3",
-  trianglelefteq: "\u22B4",
-  triangleq: "\u225C",
-  triangleright: "\u25B9",
-  trianglerighteq: "\u22B5",
-  tridot: "\u25EC",
-  trie: "\u225C",
-  triminus: "\u2A3A",
-  triplus: "\u2A39",
-  trisb: "\u29CD",
-  tritime: "\u2A3B",
-  trpezium: "\u23E2",
-  tscr: "\u{1D4C9}",
-  tscy: "\u0446",
-  tshcy: "\u045B",
-  tstrok: "\u0167",
-  twixt: "\u226C",
-  twoheadleftarrow: "\u219E",
-  twoheadrightarrow: "\u21A0",
-  uArr: "\u21D1",
-  uHar: "\u2963",
-  uacute: "\xFA",
-  uarr: "\u2191",
-  ubrcy: "\u045E",
-  ubreve: "\u016D",
-  ucirc: "\xFB",
-  ucy: "\u0443",
-  udarr: "\u21C5",
-  udblac: "\u0171",
-  udhar: "\u296E",
-  ufisht: "\u297E",
-  ufr: "\u{1D532}",
-  ugrave: "\xF9",
-  uharl: "\u21BF",
-  uharr: "\u21BE",
-  uhblk: "\u2580",
-  ulcorn: "\u231C",
-  ulcorner: "\u231C",
-  ulcrop: "\u230F",
-  ultri: "\u25F8",
-  umacr: "\u016B",
-  uml: "\xA8",
-  uogon: "\u0173",
-  uopf: "\u{1D566}",
-  uparrow: "\u2191",
-  updownarrow: "\u2195",
-  upharpoonleft: "\u21BF",
-  upharpoonright: "\u21BE",
-  uplus: "\u228E",
-  upsi: "\u03C5",
-  upsih: "\u03D2",
-  upsilon: "\u03C5",
-  upuparrows: "\u21C8",
-  urcorn: "\u231D",
-  urcorner: "\u231D",
-  urcrop: "\u230E",
-  uring: "\u016F",
-  urtri: "\u25F9",
-  uscr: "\u{1D4CA}",
-  utdot: "\u22F0",
-  utilde: "\u0169",
-  utri: "\u25B5",
-  utrif: "\u25B4",
-  uuarr: "\u21C8",
-  uuml: "\xFC",
-  uwangle: "\u29A7",
-  vArr: "\u21D5",
-  vBar: "\u2AE8",
-  vBarv: "\u2AE9",
-  vDash: "\u22A8",
-  vangrt: "\u299C",
-  varepsilon: "\u03F5",
-  varkappa: "\u03F0",
-  varnothing: "\u2205",
-  varphi: "\u03D5",
-  varpi: "\u03D6",
-  varpropto: "\u221D",
-  varr: "\u2195",
-  varrho: "\u03F1",
-  varsigma: "\u03C2",
-  varsubsetneq: "\u228A\uFE00",
-  varsubsetneqq: "\u2ACB\uFE00",
-  varsupsetneq: "\u228B\uFE00",
-  varsupsetneqq: "\u2ACC\uFE00",
-  vartheta: "\u03D1",
-  vartriangleleft: "\u22B2",
-  vartriangleright: "\u22B3",
-  vcy: "\u0432",
-  vdash: "\u22A2",
-  vee: "\u2228",
-  veebar: "\u22BB",
-  veeeq: "\u225A",
-  vellip: "\u22EE",
-  verbar: "|",
-  vert: "|",
-  vfr: "\u{1D533}",
-  vltri: "\u22B2",
-  vnsub: "\u2282\u20D2",
-  vnsup: "\u2283\u20D2",
-  vopf: "\u{1D567}",
-  vprop: "\u221D",
-  vrtri: "\u22B3",
-  vscr: "\u{1D4CB}",
-  vsubnE: "\u2ACB\uFE00",
-  vsubne: "\u228A\uFE00",
-  vsupnE: "\u2ACC\uFE00",
-  vsupne: "\u228B\uFE00",
-  vzigzag: "\u299A",
-  wcirc: "\u0175",
-  wedbar: "\u2A5F",
-  wedge: "\u2227",
-  wedgeq: "\u2259",
-  weierp: "\u2118",
-  wfr: "\u{1D534}",
-  wopf: "\u{1D568}",
-  wp: "\u2118",
-  wr: "\u2240",
-  wreath: "\u2240",
-  wscr: "\u{1D4CC}",
-  xcap: "\u22C2",
-  xcirc: "\u25EF",
-  xcup: "\u22C3",
-  xdtri: "\u25BD",
-  xfr: "\u{1D535}",
-  xhArr: "\u27FA",
-  xharr: "\u27F7",
-  xi: "\u03BE",
-  xlArr: "\u27F8",
-  xlarr: "\u27F5",
-  xmap: "\u27FC",
-  xnis: "\u22FB",
-  xodot: "\u2A00",
-  xopf: "\u{1D569}",
-  xoplus: "\u2A01",
-  xotime: "\u2A02",
-  xrArr: "\u27F9",
-  xrarr: "\u27F6",
-  xscr: "\u{1D4CD}",
-  xsqcup: "\u2A06",
-  xuplus: "\u2A04",
-  xutri: "\u25B3",
-  xvee: "\u22C1",
-  xwedge: "\u22C0",
-  yacute: "\xFD",
-  yacy: "\u044F",
-  ycirc: "\u0177",
-  ycy: "\u044B",
-  yen: "\xA5",
-  yfr: "\u{1D536}",
-  yicy: "\u0457",
-  yopf: "\u{1D56A}",
-  yscr: "\u{1D4CE}",
-  yucy: "\u044E",
-  yuml: "\xFF",
-  zacute: "\u017A",
-  zcaron: "\u017E",
-  zcy: "\u0437",
-  zdot: "\u017C",
-  zeetrf: "\u2128",
-  zeta: "\u03B6",
-  zfr: "\u{1D537}",
-  zhcy: "\u0436",
-  zigrarr: "\u21DD",
-  zopf: "\u{1D56B}",
-  zscr: "\u{1D4CF}",
-  zwj: "\u200D",
-  zwnj: "\u200C"
-}, own$1 = {}.hasOwnProperty;
-function decodeNamedCharacterReference(value) {
-  return own$1.call(characterEntities, value) ? characterEntities[value] : !1;
-}
-const messages = [
-  "",
-  /* 1: Non terminated (named) */
-  "Named character references must be terminated by a semicolon",
-  /* 2: Non terminated (numeric) */
-  "Numeric character references must be terminated by a semicolon",
-  /* 3: Empty (named) */
-  "Named character references cannot be empty",
-  /* 4: Empty (numeric) */
-  "Numeric character references cannot be empty",
-  /* 5: Unknown (named) */
-  "Named character references must be known",
-  /* 6: Disallowed (numeric) */
-  "Numeric character references cannot be disallowed",
-  /* 7: Prohibited (numeric) */
-  "Numeric character references cannot be outside the permissible Unicode range"
-];
-function parseEntities(value, options) {
-  const settings = {}, additional = typeof settings.additional == "string" ? settings.additional.charCodeAt(0) : settings.additional, result = [];
-  let index = 0, lines = -1, queue = "", point, indent;
-  settings.position && ("start" in settings.position || "indent" in settings.position ? (indent = settings.position.indent, point = settings.position.start) : point = settings.position);
-  let line = (point ? point.line : 0) || 1, column = (point ? point.column : 0) || 1, previous = now(), character;
-  for (index--; ++index <= value.length; )
-    if (character === 10 && (column = (indent ? indent[lines] : 0) || 1), character = value.charCodeAt(index), character === 38) {
-      const following = value.charCodeAt(index + 1);
-      if (following === 9 || following === 10 || following === 12 || following === 32 || following === 38 || following === 60 || Number.isNaN(following) || additional && following === additional) {
-        queue += String.fromCharCode(character), column++;
-        continue;
-      }
-      const start = index + 1;
-      let begin = start, end = start, type;
-      if (following === 35) {
-        end = ++begin;
-        const following2 = value.charCodeAt(end);
-        following2 === 88 || following2 === 120 ? (type = "hexadecimal", end = ++begin) : type = "decimal";
-      } else
-        type = "named";
-      let characterReferenceCharacters = "", characterReference = "", characters = "";
-      const test = type === "named" ? isAlphanumerical : type === "decimal" ? isDecimal : isHexadecimal;
-      for (end--; ++end <= value.length; ) {
-        const following2 = value.charCodeAt(end);
-        if (!test(following2))
-          break;
-        characters += String.fromCharCode(following2), type === "named" && characterEntitiesLegacy.includes(characters) && (characterReferenceCharacters = characters, characterReference = decodeNamedCharacterReference(characters));
-      }
-      let terminated = value.charCodeAt(end) === 59;
-      if (terminated) {
-        end++;
-        const namedReference = type === "named" ? decodeNamedCharacterReference(characters) : !1;
-        namedReference && (characterReferenceCharacters = characters, characterReference = namedReference);
-      }
-      let diff = 1 + end - start, reference = "";
-      if (!(!terminated && settings.nonTerminated === !1)) if (!characters)
-        type !== "named" && warning(4, diff);
-      else if (type === "named") {
-        if (terminated && !characterReference)
-          warning(5, 1);
-        else if (characterReferenceCharacters !== characters && (end = begin + characterReferenceCharacters.length, diff = 1 + end - begin, terminated = !1), !terminated) {
-          const reason = characterReferenceCharacters ? 1 : 3;
-          if (settings.attribute) {
-            const following2 = value.charCodeAt(end);
-            following2 === 61 ? (warning(reason, diff), characterReference = "") : isAlphanumerical(following2) ? characterReference = "" : warning(reason, diff);
-          } else
-            warning(reason, diff);
-        }
-        reference = characterReference;
-      } else {
-        terminated || warning(2, diff);
-        let referenceCode = Number.parseInt(
-          characters,
-          type === "hexadecimal" ? 16 : 10
-        );
-        if (prohibited(referenceCode))
-          warning(7, diff), reference = "\uFFFD";
-        else if (referenceCode in characterReferenceInvalid)
-          warning(6, diff), reference = characterReferenceInvalid[referenceCode];
-        else {
-          let output = "";
-          disallowed(referenceCode) && warning(6, diff), referenceCode > 65535 && (referenceCode -= 65536, output += String.fromCharCode(
-            referenceCode >>> 10 | 55296
-          ), referenceCode = 56320 | referenceCode & 1023), reference = output + String.fromCharCode(referenceCode);
-        }
-      }
-      if (reference) {
-        flush(), previous = now(), index = end - 1, column += end - start + 1, result.push(reference);
-        const next = now();
-        next.offset++, settings.reference && settings.reference.call(
-          settings.referenceContext || void 0,
-          reference,
-          { start: previous, end: next },
-          value.slice(start - 1, end)
-        ), previous = next;
-      } else
-        characters = value.slice(start - 1, end), queue += characters, column += characters.length, index = end - 1;
-    } else
-      character === 10 && (line++, lines++, column = 0), Number.isNaN(character) ? flush() : (queue += String.fromCharCode(character), column++);
-  return result.join("");
-  function now() {
-    return {
-      line,
-      column,
-      offset: index + ((point ? point.offset : 0) || 0)
-    };
-  }
-  function warning(code, offset) {
-    let position;
-    settings.warning && (position = now(), position.column += offset, position.offset += offset, settings.warning.call(
-      settings.warningContext || void 0,
-      messages[code],
-      position,
-      code
-    ));
-  }
-  function flush() {
-    queue && (result.push(queue), settings.text && settings.text.call(settings.textContext || void 0, queue, {
-      start: previous,
-      end: now()
-    }), queue = "");
-  }
-}
-function prohibited(code) {
-  return code >= 55296 && code <= 57343 || code > 1114111;
-}
-function disallowed(code) {
-  return code >= 1 && code <= 8 || code === 11 || code >= 13 && code <= 31 || code >= 127 && code <= 159 || code >= 64976 && code <= 65007 || (code & 65535) === 65535 || (code & 65535) === 65534;
-}
-var uniqueId = 0, plainTextGrammar = {}, _ = {
-  /**
-   * A namespace for utility methods.
-   *
-   * All function in this namespace that are not explicitly marked as _public_ are for __internal use only__ and may
-   * change or disappear at any time.
-   *
-   * @namespace
-   * @memberof Prism
-   */
-  util: {
-    /**
-     * Returns the name of the type of the given value.
-     *
-     * @param {any} o
-     * @returns {string}
-     * @example
-     * type(null)      === 'Null'
-     * type(undefined) === 'Undefined'
-     * type(123)       === 'Number'
-     * type('foo')     === 'String'
-     * type(true)      === 'Boolean'
-     * type([1, 2])    === 'Array'
-     * type({})        === 'Object'
-     * type(String)    === 'Function'
-     * type(/abc+/)    === 'RegExp'
-     */
-    type: function(o) {
-      return Object.prototype.toString.call(o).slice(8, -1);
-    },
-    /**
-     * Returns a unique number for the given object. Later calls will still return the same number.
-     *
-     * @param {Object} obj
-     * @returns {number}
-     */
-    objId: function(obj) {
-      return obj.__id || Object.defineProperty(obj, "__id", { value: ++uniqueId }), obj.__id;
-    },
-    /**
-     * Creates a deep clone of the given object.
-     *
-     * The main intended use of this function is to clone language definitions.
-     *
-     * @param {T} o
-     * @param {Record<number, any>} [visited]
-     * @returns {T}
-     * @template T
-     */
-    clone: function deepClone(o, visited) {
-      visited = visited || {};
-      var clone, id;
-      switch (_.util.type(o)) {
-        case "Object":
-          if (id = _.util.objId(o), visited[id])
-            return visited[id];
-          clone = /** @type {Record<string, any>} */
-          {}, visited[id] = clone;
-          for (var key in o)
-            o.hasOwnProperty(key) && (clone[key] = deepClone(o[key], visited));
-          return (
-            /** @type {any} */
-            clone
-          );
-        case "Array":
-          return id = _.util.objId(o), visited[id] ? visited[id] : (clone = [], visited[id] = clone, /** @type {any} */
-          o.forEach(
-            function(v, i) {
-              clone[i] = deepClone(v, visited);
-            }
-          ), /** @type {any} */
-          clone);
-        default:
-          return o;
-      }
-    }
-  },
-  /**
-   * This namespace contains all currently loaded languages and the some helper functions to create and modify languages.
-   *
-   * @namespace
-   * @memberof Prism
-   * @public
-   */
-  languages: {
-    /**
-     * The grammar for plain, unformatted text.
-     */
-    plain: plainTextGrammar,
-    plaintext: plainTextGrammar,
-    text: plainTextGrammar,
-    txt: plainTextGrammar,
-    /**
-     * Creates a deep copy of the language with the given id and appends the given tokens.
-     *
-     * If a token in `redef` also appears in the copied language, then the existing token in the copied language
-     * will be overwritten at its original position.
-     *
-     * ## Best practices
-     *
-     * Since the position of overwriting tokens (token in `redef` that overwrite tokens in the copied language)
-     * doesn't matter, they can technically be in any order. However, this can be confusing to others that trying to
-     * understand the language definition because, normally, the order of tokens matters in Prism grammars.
-     *
-     * Therefore, it is encouraged to order overwriting tokens according to the positions of the overwritten tokens.
-     * Furthermore, all non-overwriting tokens should be placed after the overwriting ones.
-     *
-     * @param {string} id The id of the language to extend. This has to be a key in `Prism.languages`.
-     * @param {Grammar} redef The new tokens to append.
-     * @returns {Grammar} The new language created.
-     * @public
-     * @example
-     * Prism.languages['css-with-colors'] = Prism.languages.extend('css', {
-     *     // Prism.languages.css already has a 'comment' token, so this token will overwrite CSS' 'comment' token
-     *     // at its original position
-     *     'comment': { ... },
-     *     // CSS doesn't have a 'color' token, so this token will be appended
-     *     'color': /\b(?:red|green|blue)\b/
-     * });
-     */
-    extend: function(id, redef) {
-      var lang = _.util.clone(_.languages[id]);
-      for (var key in redef)
-        lang[key] = redef[key];
-      return lang;
-    },
-    /**
-     * Inserts tokens _before_ another token in a language definition or any other grammar.
-     *
-     * ## Usage
-     *
-     * This helper method makes it easy to modify existing languages. For example, the CSS language definition
-     * not only defines CSS highlighting for CSS documents, but also needs to define highlighting for CSS embedded
-     * in HTML through `<style>` elements. To do this, it needs to modify `Prism.languages.markup` and add the
-     * appropriate tokens. However, `Prism.languages.markup` is a regular JavaScript object literal, so if you do
-     * this:
-     *
-     * ```js
-     * Prism.languages.markup.style = {
-     *     // token
-     * };
-     * ```
-     *
-     * then the `style` token will be added (and processed) at the end. `insertBefore` allows you to insert tokens
-     * before existing tokens. For the CSS example above, you would use it like this:
-     *
-     * ```js
-     * Prism.languages.insertBefore('markup', 'cdata', {
-     *     'style': {
-     *         // token
-     *     }
-     * });
-     * ```
-     *
-     * ## Special cases
-     *
-     * If the grammars of `inside` and `insert` have tokens with the same name, the tokens in `inside`'s grammar
-     * will be ignored.
-     *
-     * This behavior can be used to insert tokens after `before`:
-     *
-     * ```js
-     * Prism.languages.insertBefore('markup', 'comment', {
-     *     'comment': Prism.languages.markup.comment,
-     *     // tokens after 'comment'
-     * });
-     * ```
-     *
-     * ## Limitations
-     *
-     * The main problem `insertBefore` has to solve is iteration order. Since ES2015, the iteration order for object
-     * properties is guaranteed to be the insertion order (except for integer keys) but some browsers behave
-     * differently when keys are deleted and re-inserted. So `insertBefore` can't be implemented by temporarily
-     * deleting properties which is necessary to insert at arbitrary positions.
-     *
-     * To solve this problem, `insertBefore` doesn't actually insert the given tokens into the target object.
-     * Instead, it will create a new object and replace all references to the target object with the new one. This
-     * can be done without temporarily deleting properties, so the iteration order is well-defined.
-     *
-     * However, only references that can be reached from `Prism.languages` or `insert` will be replaced. I.e. if
-     * you hold the target object in a variable, then the value of the variable will not change.
-     *
-     * ```js
-     * var oldMarkup = Prism.languages.markup;
-     * var newMarkup = Prism.languages.insertBefore('markup', 'comment', { ... });
-     *
-     * assert(oldMarkup !== Prism.languages.markup);
-     * assert(newMarkup === Prism.languages.markup);
-     * ```
-     *
-     * @param {string} inside The property of `root` (e.g. a language id in `Prism.languages`) that contains the
-     * object to be modified.
-     * @param {string} before The key to insert before.
-     * @param {Grammar} insert An object containing the key-value pairs to be inserted.
-     * @param {Object<string, any>} [root] The object containing `inside`, i.e. the object that contains the
-     * object to be modified.
-     *
-     * Defaults to `Prism.languages`.
-     * @returns {Grammar} The new grammar object.
-     * @public
-     */
-    insertBefore: function(inside, before, insert, root) {
-      root = root || /** @type {any} */
-      _.languages;
-      var grammar = root[inside], ret = {};
-      for (var token in grammar)
-        if (grammar.hasOwnProperty(token)) {
-          if (token == before)
-            for (var newToken in insert)
-              insert.hasOwnProperty(newToken) && (ret[newToken] = insert[newToken]);
-          insert.hasOwnProperty(token) || (ret[token] = grammar[token]);
-        }
-      var old = root[inside];
-      return root[inside] = ret, _.languages.DFS(_.languages, function(key, value) {
-        value === old && key != inside && (this[key] = ret);
-      }), ret;
-    },
-    // Traverse a language definition with Depth First Search
-    DFS: function DFS(o, callback, type, visited) {
-      visited = visited || {};
-      var objId = _.util.objId;
-      for (var i in o)
-        if (o.hasOwnProperty(i)) {
-          callback.call(o, i, o[i], type || i);
-          var property = o[i], propertyType = _.util.type(property);
-          propertyType === "Object" && !visited[objId(property)] ? (visited[objId(property)] = !0, DFS(property, callback, null, visited)) : propertyType === "Array" && !visited[objId(property)] && (visited[objId(property)] = !0, DFS(property, callback, i, visited));
-        }
-    }
-  },
-  plugins: {},
-  /**
-   * Low-level function, only use if you know what you’re doing. It accepts a string of text as input
-   * and the language definitions to use, and returns a string with the HTML produced.
-   *
-   * The following hooks will be run:
-   * 1. `before-tokenize`
-   * 2. `after-tokenize`
-   * 3. `wrap`: On each {@link Token}.
-   *
-   * @param {string} text A string with the code to be highlighted.
-   * @param {Grammar} grammar An object containing the tokens to use.
-   *
-   * Usually a language definition like `Prism.languages.markup`.
-   * @param {string} language The name of the language definition passed to `grammar`.
-   * @returns {string} The highlighted HTML.
-   * @memberof Prism
-   * @public
-   * @example
-   * Prism.highlight('var foo = true;', Prism.languages.javascript, 'javascript');
-   */
-  highlight: function(text, grammar, language) {
-    var env = {
-      code: text,
-      grammar,
-      language
-    };
-    if (_.hooks.run("before-tokenize", env), !env.grammar)
-      throw new Error('The language "' + env.language + '" has no grammar.');
-    return env.tokens = _.tokenize(env.code, env.grammar), _.hooks.run("after-tokenize", env), Token.stringify(_.util.encode(env.tokens), env.language);
-  },
-  /**
-   * This is the heart of Prism, and the most low-level function you can use. It accepts a string of text as input
-   * and the language definitions to use, and returns an array with the tokenized code.
-   *
-   * When the language definition includes nested tokens, the function is called recursively on each of these tokens.
-   *
-   * This method could be useful in other contexts as well, as a very crude parser.
-   *
-   * @param {string} text A string with the code to be highlighted.
-   * @param {Grammar} grammar An object containing the tokens to use.
-   *
-   * Usually a language definition like `Prism.languages.markup`.
-   * @returns {TokenStream} An array of strings and tokens, a token stream.
-   * @memberof Prism
-   * @public
-   * @example
-   * let code = `var foo = 0;`;
-   * let tokens = Prism.tokenize(code, Prism.languages.javascript);
-   * tokens.forEach(token => {
-   *     if (token instanceof Prism.Token && token.type === 'number') {
-   *         console.log(`Found numeric literal: ${token.content}`);
-   *     }
-   * });
-   */
-  tokenize: function(text, grammar) {
-    var rest = grammar.rest;
-    if (rest) {
-      for (var token in rest)
-        grammar[token] = rest[token];
-      delete grammar.rest;
-    }
-    var tokenList = new LinkedList();
-    return addAfter(tokenList, tokenList.head, text), matchGrammar(text, tokenList, grammar, tokenList.head, 0), toArray(tokenList);
-  },
-  /**
-   * @namespace
-   * @memberof Prism
-   * @public
-   */
-  hooks: {
-    all: {},
-    /**
-     * Adds the given callback to the list of callbacks for the given hook.
-     *
-     * The callback will be invoked when the hook it is registered for is run.
-     * Hooks are usually directly run by a highlight function but you can also run hooks yourself.
-     *
-     * One callback function can be registered to multiple hooks and the same hook multiple times.
-     *
-     * @param {string} name The name of the hook.
-     * @param {HookCallback} callback The callback function which is given environment variables.
-     * @public
-     */
-    add: function(name, callback) {
-      var hooks = _.hooks.all;
-      hooks[name] = hooks[name] || [], hooks[name].push(callback);
-    },
-    /**
-     * Runs a hook invoking all registered callbacks with the given environment variables.
-     *
-     * Callbacks will be invoked synchronously and in the order in which they were registered.
-     *
-     * @param {string} name The name of the hook.
-     * @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.
-     * @public
-     */
-    run: function(name, env) {
-      var callbacks = _.hooks.all[name];
-      if (!(!callbacks || !callbacks.length))
-        for (var i = 0, callback; callback = callbacks[i++]; )
-          callback(env);
-    }
-  },
-  Token
-};
-function Token(type, content, alias2, matchedStr) {
-  this.type = type, this.content = content, this.alias = alias2, this.length = (matchedStr || "").length | 0;
-}
-function matchPattern(pattern, pos, text, lookbehind) {
-  pattern.lastIndex = pos;
-  var match = pattern.exec(text);
-  if (match && lookbehind && match[1]) {
-    var lookbehindLength = match[1].length;
-    match.index += lookbehindLength, match[0] = match[0].slice(lookbehindLength);
-  }
-  return match;
-}
-function matchGrammar(text, tokenList, grammar, startNode, startPos, rematch) {
-  for (var token in grammar)
-    if (!(!grammar.hasOwnProperty(token) || !grammar[token])) {
-      var patterns = grammar[token];
-      patterns = Array.isArray(patterns) ? patterns : [patterns];
-      for (var j = 0; j < patterns.length; ++j) {
-        if (rematch && rematch.cause == token + "," + j)
-          return;
-        var patternObj = patterns[j], inside = patternObj.inside, lookbehind = !!patternObj.lookbehind, greedy = !!patternObj.greedy, alias2 = patternObj.alias;
-        if (greedy && !patternObj.pattern.global) {
-          var flags = patternObj.pattern.toString().match(/[imsuy]*$/)[0];
-          patternObj.pattern = RegExp(patternObj.pattern.source, flags + "g");
-        }
-        for (var pattern = patternObj.pattern || patternObj, currentNode = startNode.next, pos = startPos; currentNode !== tokenList.tail && !(rematch && pos >= rematch.reach); pos += currentNode.value.length, currentNode = currentNode.next) {
-          var str = currentNode.value;
-          if (tokenList.length > text.length)
-            return;
-          if (!(str instanceof Token)) {
-            var removeCount = 1, match;
-            if (greedy) {
-              if (match = matchPattern(pattern, pos, text, lookbehind), !match || match.index >= text.length)
-                break;
-              var from = match.index, to = match.index + match[0].length, p = pos;
-              for (p += currentNode.value.length; from >= p; )
-                currentNode = currentNode.next, p += currentNode.value.length;
-              if (p -= currentNode.value.length, pos = p, currentNode.value instanceof Token)
-                continue;
-              for (var k = currentNode; k !== tokenList.tail && (p < to || typeof k.value == "string"); k = k.next)
-                removeCount++, p += k.value.length;
-              removeCount--, str = text.slice(pos, p), match.index -= pos;
-            } else if (match = matchPattern(pattern, 0, str, lookbehind), !match)
-              continue;
-            var from = match.index, matchStr = match[0], before = str.slice(0, from), after = str.slice(from + matchStr.length), reach = pos + str.length;
-            rematch && reach > rematch.reach && (rematch.reach = reach);
-            var removeFrom = currentNode.prev;
-            before && (removeFrom = addAfter(tokenList, removeFrom, before), pos += before.length), removeRange(tokenList, removeFrom, removeCount);
-            var wrapped = new Token(
-              token,
-              inside ? _.tokenize(matchStr, inside) : matchStr,
-              alias2,
-              matchStr
-            );
-            if (currentNode = addAfter(tokenList, removeFrom, wrapped), after && addAfter(tokenList, currentNode, after), removeCount > 1) {
-              var nestedRematch = {
-                cause: token + "," + j,
-                reach
-              };
-              matchGrammar(
-                text,
-                tokenList,
-                grammar,
-                currentNode.prev,
-                pos,
-                nestedRematch
-              ), rematch && nestedRematch.reach > rematch.reach && (rematch.reach = nestedRematch.reach);
-            }
-          }
-        }
-      }
-    }
-}
-function LinkedList() {
-  var head = { value: null, prev: null, next: null }, tail = { value: null, prev: head, next: null };
-  head.next = tail, this.head = head, this.tail = tail, this.length = 0;
-}
-function addAfter(list, node, value) {
-  var next = node.next, newNode = { value, prev: node, next };
-  return node.next = newNode, next.prev = newNode, list.length++, newNode;
-}
-function removeRange(list, node, count) {
-  for (var next = node.next, i = 0; i < count && next !== list.tail; i++)
-    next = next.next;
-  node.next = next, next.prev = node, list.length -= i;
-}
-function toArray(list) {
-  for (var array = [], node = list.head.next; node !== list.tail; )
-    array.push(node.value), node = node.next;
-  return array;
-}
-const Prism = _;
-function Refractor$1() {
-}
-Refractor$1.prototype = Prism;
-const refractor = new Refractor$1();
-refractor.highlight = highlight;
-refractor.register = register;
-refractor.alias = alias;
-refractor.registered = registered;
-refractor.listLanguages = listLanguages;
-refractor.util.encode = encode;
-refractor.Token.stringify = stringify;
-function highlight(value, language) {
-  if (typeof value != "string")
-    throw new TypeError("Expected `string` for `value`, got `" + value + "`");
-  let grammar, name;
-  if (language && typeof language == "object")
-    grammar = language;
-  else {
-    if (name = language, typeof name != "string")
-      throw new TypeError("Expected `string` for `name`, got `" + name + "`");
-    if (Object.hasOwn(refractor.languages, name))
-      grammar = refractor.languages[name];
-    else
-      throw new Error("Unknown language: `" + name + "` is not registered");
-  }
-  return {
-    type: "root",
-    // @ts-expect-error: we hacked Prism to accept and return the things we want.
-    children: Prism.highlight.call(refractor, value, grammar, name)
-  };
-}
-function register(syntax) {
-  if (typeof syntax != "function" || !syntax.displayName)
-    throw new Error("Expected `function` for `syntax`, got `" + syntax + "`");
-  Object.hasOwn(refractor.languages, syntax.displayName) || syntax(refractor);
-}
-function alias(language, alias2) {
-  const languages = refractor.languages;
-  let map = {};
-  typeof language == "string" ? alias2 && (map[language] = alias2) : map = language;
-  let key;
-  for (key in map)
-    if (Object.hasOwn(map, key)) {
-      const value = map[key], list = typeof value == "string" ? [value] : value;
-      let index = -1;
-      for (; ++index < list.length; )
-        languages[list[index]] = languages[key];
-    }
-}
-function registered(aliasOrLanguage) {
-  if (typeof aliasOrLanguage != "string")
-    throw new TypeError(
-      "Expected `string` for `aliasOrLanguage`, got `" + aliasOrLanguage + "`"
-    );
-  return Object.hasOwn(refractor.languages, aliasOrLanguage);
-}
-function listLanguages() {
-  const languages = refractor.languages, list = [];
-  let language;
-  for (language in languages)
-    Object.hasOwn(languages, language) && typeof languages[language] == "object" && list.push(language);
-  return list;
-}
-function stringify(value, language) {
-  if (typeof value == "string")
-    return { type: "text", value };
-  if (Array.isArray(value)) {
-    const result = [];
-    let index = -1;
-    for (; ++index < value.length; )
-      value[index] !== null && value[index] !== void 0 && value[index] !== "" && result.push(
-        /** @type {Element | Text} */
-        stringify(value[index], language)
-      );
-    return result;
-  }
-  const env = {
-    attributes: {},
-    classes: ["token", value.type],
-    content: stringify(value.content, language),
-    language,
-    tag: "span",
-    type: value.type
-  };
-  return value.alias && env.classes.push(
-    ...typeof value.alias == "string" ? [value.alias] : value.alias
-  ), refractor.hooks.run("wrap", env), h(
-    env.tag + "." + env.classes.join("."),
-    attributes(env.attributes),
-    env.content
-  );
-}
-function encode(tokens) {
-  return tokens;
-}
-function attributes(record) {
-  let key;
-  for (key in record)
-    Object.hasOwn(record, key) && (record[key] = parseEntities(record[key]));
-  return record;
-}
-const convert = (
-  // Note: overloads in JSDoc can’t yet use different `@template`s.
-  /**
-   * @type {(
-   *   (<Condition extends string>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &
-   *   (<Condition extends Props>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &
-   *   (<Condition extends TestFunction>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &
-   *   ((test?: null | undefined) => (node?: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &
-   *   ((test?: Test) => Check)
-   * )}
-   */
-  /**
-   * @param {Test} [test]
-   * @returns {Check}
-   */
-  function(test) {
-    if (test == null)
-      return ok;
-    if (typeof test == "function")
-      return castFactory(test);
-    if (typeof test == "object")
-      return Array.isArray(test) ? anyFactory(test) : (
-        // Cast because `ReadonlyArray` goes into the above but `isArray`
-        // narrows to `Array`.
-        propertiesFactory(
-          /** @type {Props} */
-          test
-        )
-      );
-    if (typeof test == "string")
-      return typeFactory(test);
-    throw new Error("Expected function, string, or object as test");
-  }
-);
-function anyFactory(tests) {
-  const checks2 = [];
-  let index = -1;
-  for (; ++index < tests.length; )
-    checks2[index] = convert(tests[index]);
-  return castFactory(any);
-  function any(...parameters) {
-    let index2 = -1;
-    for (; ++index2 < checks2.length; )
-      if (checks2[index2].apply(this, parameters)) return !0;
-    return !1;
-  }
-}
-function propertiesFactory(check) {
-  const checkAsRecord = (
-    /** @type {Record<string, unknown>} */
-    check
-  );
-  return castFactory(all);
-  function all(node) {
-    const nodeAsRecord = (
-      /** @type {Record<string, unknown>} */
-      /** @type {unknown} */
-      node
-    );
-    let key;
-    for (key in check)
-      if (nodeAsRecord[key] !== checkAsRecord[key]) return !1;
-    return !0;
-  }
-}
-function typeFactory(check) {
-  return castFactory(type);
-  function type(node) {
-    return node && node.type === check;
-  }
-}
-function castFactory(testFunction) {
-  return check;
-  function check(value, index, parent2) {
-    return !!(looksLikeANode(value) && testFunction.call(
-      this,
-      value,
-      typeof index == "number" ? index : void 0,
-      parent2 || void 0
-    ));
-  }
-}
-function ok() {
-  return !0;
-}
-function looksLikeANode(value) {
-  return value !== null && typeof value == "object" && "type" in value;
-}
-const own = {}.hasOwnProperty;
-function filter(tree, options, test) {
-  const is = convert(options), cascadeRaw = options && typeof options == "object" && "cascade" in options ? (
-    /** @type {boolean | null | undefined} */
-    options.cascade
-  ) : void 0, cascade = cascadeRaw ?? !0;
-  return preorder(tree);
-  function preorder(node, index, parentNode) {
-    const children = [];
-    if (!is(node, index, parentNode)) return;
-    if (parent(node)) {
-      let childIndex = -1;
-      for (; ++childIndex < node.children.length; ) {
-        const result = preorder(node.children[childIndex], childIndex, node);
-        result && children.push(result);
-      }
-      if (cascade && node.children.length > 0 && children.length === 0)
-        return;
-    }
-    const next = {};
-    let key;
-    for (key in node)
-      own.call(node, key) && (next[key] = key === "children" ? children : node[key]);
-    return next;
-  }
-}
-function parent(node) {
-  return "children" in node && node.children !== void 0;
-}
-const empty = [], CONTINUE = !0, EXIT = !1, SKIP = "skip";
-function visitParents(tree, test, visitor, reverse) {
-  let check;
-  typeof test == "function" && typeof visitor != "function" ? (reverse = visitor, visitor = test) : check = test;
-  const is = convert(check), step = reverse ? -1 : 1;
-  factory(tree, void 0, [])();
-  function factory(node, index, parents) {
-    const value = (
-      /** @type {Record<string, unknown>} */
-      node && typeof node == "object" ? node : {}
-    );
-    if (typeof value.type == "string") {
-      const name = (
-        // `hast`
-        typeof value.tagName == "string" ? value.tagName : (
-          // `xast`
-          typeof value.name == "string" ? value.name : void 0
-        )
-      );
-      Object.defineProperty(visit, "name", {
-        value: "node (" + (node.type + (name ? "<" + name + ">" : "")) + ")"
-      });
-    }
-    return visit;
-    function visit() {
-      let result = empty, subresult, offset, grandparents;
-      if ((!test || is(node, index, parents[parents.length - 1] || void 0)) && (result = toResult(visitor(node, parents)), result[0] === EXIT))
-        return result;
-      if ("children" in node && node.children) {
-        const nodeAsParent = (
-          /** @type {UnistParent} */
-          node
-        );
-        if (nodeAsParent.children && result[0] !== SKIP)
-          for (offset = (reverse ? nodeAsParent.children.length : -1) + step, grandparents = parents.concat(nodeAsParent); offset > -1 && offset < nodeAsParent.children.length; ) {
-            const child = nodeAsParent.children[offset];
-            if (subresult = factory(child, offset, grandparents)(), subresult[0] === EXIT)
-              return subresult;
-            offset = typeof subresult[1] == "number" ? subresult[1] : offset + step;
-          }
-      }
-      return result;
-    }
-  }
-}
-function toResult(value) {
-  return Array.isArray(value) ? value : typeof value == "number" ? [CONTINUE, value] : value == null ? empty : [value];
-}
-var __defProp$2 = Object.defineProperty, __defProps$2 = Object.defineProperties, __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$2 = Object.getOwnPropertySymbols, __hasOwnProp$2 = Object.prototype.hasOwnProperty, __propIsEnum$2 = Object.prototype.propertyIsEnumerable, __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$2 = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp$2.call(b, prop) && __defNormalProp$2(a, prop, b[prop]);
-  if (__getOwnPropSymbols$2)
-    for (var prop of __getOwnPropSymbols$2(b))
-      __propIsEnum$2.call(b, prop) && __defNormalProp$2(a, prop, b[prop]);
-  return a;
-}, __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
-function addMarkers(ast, options) {
-  const markers = options.markers.map((marker) => typeof marker == "number" ? { line: marker } : marker).sort((nodeA, nodeB) => nodeA.line - nodeB.line), numbered = lineNumberify(ast.children).nodes;
-  return markers.length === 0 || numbered.length === 0 ? __spreadProps$2(__spreadValues$2({}, ast), { children: numbered }) : wrapLines(numbered, markers, options);
-}
-function lineNumberify(ast, context = { lineNumber: 1 }) {
-  const resultNodes = [];
-  return ast.reduce(
-    (result, node) => {
-      if (node.type === "doctype")
-        return result;
-      const lineStart = context.lineNumber;
-      if (node.type === "text") {
-        if (node.value.indexOf(`
-`) === -1)
-          return setLineInfo(node, lineStart, lineStart), result.nodes.push(node), result;
-        const lines = node.value.split(`
-`);
-        for (let i = 0; i < lines.length; i++) {
-          const lineNum = i === 0 ? context.lineNumber : ++context.lineNumber, text = {
-            type: "text",
-            value: i === lines.length - 1 ? lines[i] : `${lines[i]}
-`
-          }, withLineInfo = setLineInfo(text, lineNum, lineNum);
-          result.nodes.push(withLineInfo);
-        }
-        return result.lineNumber = context.lineNumber, result;
-      }
-      if (node.type === "element" && node.children) {
-        const processed = lineNumberify(node.children, context), firstChild = processed.nodes.find(isElementOrText), lastChild = processed.nodes.findLast(isElementOrText);
-        return setLineInfo(
-          node,
-          firstChild ? getLineStart(firstChild, lineStart) : lineStart,
-          lastChild ? getLineEnd(lastChild, lineStart) : lineStart
-        ), node.children = processed.nodes, result.lineNumber = processed.lineNumber, result.nodes.push(node), result;
-      }
-      return result.nodes.push(node), result;
-    },
-    { nodes: resultNodes, lineNumber: context.lineNumber }
-  );
-}
-function isElementOrText(node) {
-  return node.type === "element" || node.type === "text";
-}
-function getLineStart(node, fallbackLineStart = 1) {
-  return node.data && typeof node.data.lineStart == "number" ? node.data.lineStart : fallbackLineStart;
-}
-function getLineEnd(node, fallbackLineEnd = 1) {
-  return node.data && typeof node.data.lineEnd == "number" ? node.data.lineEnd : fallbackLineEnd;
-}
-function setLineInfo(node, lineStart, lineEnd) {
-  return node.data || (node.data = {}), node.data.lineStart = lineStart, node.data.lineEnd = lineEnd, node;
-}
-function unwrapLine(markerLine, nodes) {
-  const tree = { type: "root", children: nodes }, headMap = /* @__PURE__ */ new WeakMap(), lineMap = /* @__PURE__ */ new WeakMap(), tailMap = /* @__PURE__ */ new WeakMap(), cloned = [];
-  function addCopy(map, node, ancestors) {
-    cloned.push(node), ancestors.forEach((ancestor) => {
-      map.has(ancestor) || (map.set(ancestor, Object.assign({}, ancestor, { children: [] })), ancestor !== tree && cloned.push(ancestor));
-    });
-    let i = ancestors.length;
-    for (; i--; ) {
-      const ancestor = map.get(ancestors[i]);
-      if (!ancestor || !("children" in ancestor))
-        continue;
-      const child = ancestors[i + 1], leaf = map.get(child) || node;
-      ancestor.children.indexOf(leaf) === -1 && ancestor.children.push(leaf);
-    }
-  }
-  visitParents(tree, (node, ancestors) => {
-    if (!("children" in node || !isElementOrText(node))) {
-      if (getLineStart(node) < markerLine) {
-        addCopy(headMap, node, ancestors);
-        return;
-      }
-      if (getLineStart(node) === markerLine) {
-        addCopy(lineMap, node, ancestors);
-        return;
-      }
-      getLineEnd(node) > markerLine && cloned.some((clone) => ancestors.includes(clone)) && addCopy(tailMap, node, ancestors);
-    }
-  });
-  const filtered = filter(tree, (node) => cloned.indexOf(node) === -1), getChildren = (map) => {
-    const rootNode = map.get(tree);
-    return rootNode ? (visitParents(rootNode, (leaf, ancestors) => {
-      if (isElementOrText(leaf) && "children" in leaf) {
-        setLineInfo(leaf, 0, 0);
-        return;
-      }
-      ancestors.forEach((ancestor) => {
-        setLineInfo(
-          ancestor,
-          Math.max(getLineStart(ancestor), getLineStart(leaf)),
-          Math.max(getLineEnd(ancestor), getLineEnd(leaf))
-        );
-      });
-    }), rootNode.children) : [];
-  };
-  return [
-    ...getChildren(headMap),
-    ...getChildren(lineMap),
-    ...getChildren(tailMap),
-    ...filtered ? filtered.children : []
-  ];
-}
-function wrapBatch(children, marker, options) {
-  const className = marker.className || "refractor-marker", baseData = {
-    lineStart: marker.line,
-    lineEnd: getLineEnd(children[children.length - 1]),
-    isMarker: !0
-  };
-  return {
-    type: "element",
-    tagName: "div",
-    data: marker.component ? __spreadProps$2(__spreadValues$2({}, baseData), { component: marker.component, markerProperties: options }) : baseData,
-    properties: { className },
-    children
-  };
-}
-function wrapLines(treeNodes, markers, options) {
-  const ast = markers.reduce(
-    (acc, marker) => unwrapLine(marker.line, acc),
-    treeNodes
-  ), wrapped = [];
-  let astIndex = 0;
-  for (let m = 0; m < markers.length; m++) {
-    const marker = markers[m];
-    for (let node = ast[astIndex]; node && getLineEnd(node) < marker.line; node = ast[++astIndex])
-      wrapped.push(node);
-    const batch = [];
-    for (let node = ast[astIndex]; node && getLineEnd(node) === marker.line; node = ast[++astIndex])
-      node.type !== "doctype" && batch.push(node);
-    batch.length > 0 && wrapped.push(wrapBatch(batch, marker, options));
-  }
-  for (; astIndex < ast.length; )
-    wrapped.push(ast[astIndex++]);
-  return { type: "root", children: wrapped };
-}
-var __defProp$1 = Object.defineProperty, __defProps$1 = Object.defineProperties, __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$1 = Object.getOwnPropertySymbols, __hasOwnProp$1 = Object.prototype.hasOwnProperty, __propIsEnum$1 = Object.prototype.propertyIsEnumerable, __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$1 = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp$1.call(b, prop) && __defNormalProp$1(a, prop, b[prop]);
-  if (__getOwnPropSymbols$1)
-    for (var prop of __getOwnPropSymbols$1(b))
-      __propIsEnum$1.call(b, prop) && __defNormalProp$1(a, prop, b[prop]);
-  return a;
-}, __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
-function mapWithDepth(depth) {
-  return function(child, i) {
-    return mapChild(child, i, depth);
-  };
-}
-function mapChild(child, i, depth) {
-  if (child.type === "doctype")
-    return null;
-  if (!("tagName" in child))
-    return child.value;
-  let className = "";
-  typeof child.properties < "u" && (className = Array.isArray(child.properties.className) ? child.properties.className.join(" ") : `${child.properties.className}`);
-  const key = `fract-${depth}-${i}`, children = child.children && child.children.map(mapWithDepth(depth + 1));
-  return isReactRefractorMarkerDataWithComponent(child.data) ? createElement(
-    child.data.component,
-    __spreadProps$1(__spreadValues$1(__spreadValues$1({ key }, child.properties), child.data.markerProperties), { className }),
-    children
-  ) : createElement(child.tagName, { key, className }, children);
-}
-function isReactRefractorMarkerDataWithComponent(data) {
-  return typeof data == "object" && data !== null && "component" in data && "markerProperties" in data;
-}
-var __defProp = Object.defineProperty, __defProps = Object.defineProperties, __getOwnPropDescs = Object.getOwnPropertyDescriptors, __getOwnPropSymbols = Object.getOwnPropertySymbols, __hasOwnProp = Object.prototype.hasOwnProperty, __propIsEnum = Object.prototype.propertyIsEnumerable, __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    __hasOwnProp.call(b, prop) && __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b))
-      __propIsEnum.call(b, prop) && __defNormalProp(a, prop, b[prop]);
-  return a;
-}, __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-const DEFAULT_CLASSNAME = "refractor";
-function Refractor(props) {
-  const className = props.className || DEFAULT_CLASSNAME, langClassName = `language-${props.language}`, codeProps = { className: langClassName }, preClass = [className, langClassName].filter(Boolean).join(" ");
-  if (props.inline && (codeProps.style = { display: "inline" }, codeProps.className = className), props.plainText) {
-    const code2 = /* @__PURE__ */ jsx("code", __spreadProps(__spreadValues({}, codeProps), { children: props.value }));
-    return props.inline ? code2 : /* @__PURE__ */ jsx("pre", { className: preClass, children: code2 });
-  }
-  let ast = refractor.highlight(props.value, props.language);
-  props.markers && props.markers.length > 0 && (ast = addMarkers(ast, { markers: props.markers }));
-  const value = ast.children.length === 0 ? props.value : ast.children.map(mapWithDepth(0)), code = /* @__PURE__ */ jsx("code", __spreadProps(__spreadValues({}, codeProps), { children: value }));
-  return props.inline ? code : /* @__PURE__ */ jsx("pre", { className: preClass, children: code });
-}
-const hasLanguage = (lang) => refractor.registered(lang);
-function LazyRefractor(props) {
-  let $ = distExports.c(13), { language: languageProp, value } = props, language = typeof languageProp == "string" ? languageProp : void 0, t0;
-  $[0] === language ? t0 = $[1] : (t0 = language ? hasLanguage(language) : !1, $[0] = language, $[1] = t0);
-  let registered2 = t0, t1;
-  $[2] !== language || $[3] !== registered2 || $[4] !== value ? (t1 = !(language && registered2) && /* @__PURE__ */ jsx("code", { children: value }), $[2] = language, $[3] = registered2, $[4] = value, $[5] = t1) : t1 = $[5];
-  let t2;
-  $[6] !== language || $[7] !== registered2 || $[8] !== value ? (t2 = language && registered2 && /* @__PURE__ */ jsx(Refractor, {
-    inline: !0,
-    language,
-    value: String(value)
-  }), $[6] = language, $[7] = registered2, $[8] = value, $[9] = t2) : t2 = $[9];
-  let t3;
-  return $[10] !== t1 || $[11] !== t2 ? (t3 = /* @__PURE__ */ jsxs(Fragment, { children: [t1, t2] }), $[10] = t1, $[11] = t2, $[12] = t3) : t3 = $[12], t3;
-}
-LazyRefractor.displayName = "LazyRefractor";
-export {
-  LazyRefractor as default
-};
-//# sourceMappingURL=refractor.js.map