@arcadeai/design-system 3.39.1 → 3.39.2

package/dist/index-3rscXtm3.js

@@ -0,0 +1,4708 @@
+function Yt(t) {
+  return t && t.__esModule && Object.prototype.hasOwnProperty.call(t, "default") ? t.default : t;
+}
+function ks(t) {
+  const e = [], n = String(t || "");
+  let r = n.indexOf(","), s = 0, i = !1;
+  for (; !i; ) {
+    r === -1 && (r = n.length, i = !0);
+    const l = n.slice(s, r).trim();
+    (l || !i) && e.push(l), s = r + 1, r = n.indexOf(",", s);
+  }
+  return e;
+}
+function ct(t, e) {
+  const n = e || {};
+  return (t[t.length - 1] === "" ? [...t, ""] : t).join(
+    (n.padRight ? " " : "") + "," + (n.padLeft === !1 ? "" : " ")
+  ).trim();
+}
+function Es() {
+}
+const Jt = /^[$_\p{ID_Start}][$_\u{200C}\u{200D}\p{ID_Continue}]*$/u, Qt = /^[$_\p{ID_Start}][-$_\u{200C}\u{200D}\p{ID_Continue}]*$/u, Zt = {};
+function $e(t, e) {
+  return (Zt.jsx ? Qt : Jt).test(t);
+}
+const en = /[ \t\n\f\r]/g;
+function pe(t) {
+  return typeof t == "object" ? t.type === "text" ? Ue(t.value) : !1 : Ue(t);
+}
+function Ue(t) {
+  return t.replace(en, "") === "";
+}
+class Z {
+  /**
+   * @param {SchemaType['property']} property
+   *   Property.
+   * @param {SchemaType['normal']} normal
+   *   Normal.
+   * @param {Space | undefined} [space]
+   *   Space.
+   * @returns
+   *   Schema.
+   */
+  constructor(e, n, r) {
+    this.normal = n, this.property = e, r && (this.space = r);
+  }
+}
+Z.prototype.normal = {};
+Z.prototype.property = {};
+Z.prototype.space = void 0;
+function ht(t, e) {
+  const n = {}, r = {};
+  for (const s of t)
+    Object.assign(n, s.property), Object.assign(r, s.normal);
+  return new Z(n, r, e);
+}
+function Se(t) {
+  return t.toLowerCase();
+}
+class A {
+  /**
+   * @param {string} property
+   *   Property.
+   * @param {string} attribute
+   *   Attribute.
+   * @returns
+   *   Info.
+   */
+  constructor(e, n) {
+    this.attribute = n, this.property = e;
+  }
+}
+A.prototype.attribute = "";
+A.prototype.booleanish = !1;
+A.prototype.boolean = !1;
+A.prototype.commaOrSpaceSeparated = !1;
+A.prototype.commaSeparated = !1;
+A.prototype.defined = !1;
+A.prototype.mustUseProperty = !1;
+A.prototype.number = !1;
+A.prototype.overloadedBoolean = !1;
+A.prototype.property = "";
+A.prototype.spaceSeparated = !1;
+A.prototype.space = void 0;
+let tn = 0;
+const m = G(), b = G(), be = G(), c = G(), S = G(), $ = G(), I = G();
+function G() {
+  return 2 ** ++tn;
+}
+const ve = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  boolean: m,
+  booleanish: b,
+  commaOrSpaceSeparated: I,
+  commaSeparated: $,
+  number: c,
+  overloadedBoolean: be,
+  spaceSeparated: S
+}, Symbol.toStringTag, { value: "Module" })), de = (
+  /** @type {ReadonlyArray<keyof typeof types>} */
+  Object.keys(ve)
+);
+class Le extends A {
+  /**
+   * @constructor
+   * @param {string} property
+   *   Property.
+   * @param {string} attribute
+   *   Attribute.
+   * @param {number | null | undefined} [mask]
+   *   Mask.
+   * @param {Space | undefined} [space]
+   *   Space.
+   * @returns
+   *   Info.
+   */
+  constructor(e, n, r, s) {
+    let i = -1;
+    if (super(e, n), ze(this, "space", s), typeof r == "number")
+      for (; ++i < de.length; ) {
+        const l = de[i];
+        ze(this, de[i], (r & ve[l]) === ve[l]);
+      }
+  }
+}
+Le.prototype.defined = !0;
+function ze(t, e, n) {
+  n && (t[e] = n);
+}
+function z(t) {
+  const e = {}, n = {};
+  for (const [r, s] of Object.entries(t.properties)) {
+    const i = new Le(
+      r,
+      t.transform(t.attributes || {}, r),
+      s,
+      t.space
+    );
+    t.mustUseProperty && t.mustUseProperty.includes(r) && (i.mustUseProperty = !0), e[r] = i, n[Se(r)] = r, n[Se(i.attribute)] = r;
+  }
+  return new Z(e, n, t.space);
+}
+const pt = z({
+  properties: {
+    ariaActiveDescendant: null,
+    ariaAtomic: b,
+    ariaAutoComplete: null,
+    ariaBusy: b,
+    ariaChecked: b,
+    ariaColCount: c,
+    ariaColIndex: c,
+    ariaColSpan: c,
+    ariaControls: S,
+    ariaCurrent: null,
+    ariaDescribedBy: S,
+    ariaDetails: null,
+    ariaDisabled: b,
+    ariaDropEffect: S,
+    ariaErrorMessage: null,
+    ariaExpanded: b,
+    ariaFlowTo: S,
+    ariaGrabbed: b,
+    ariaHasPopup: null,
+    ariaHidden: b,
+    ariaInvalid: null,
+    ariaKeyShortcuts: null,
+    ariaLabel: null,
+    ariaLabelledBy: S,
+    ariaLevel: c,
+    ariaLive: null,
+    ariaModal: b,
+    ariaMultiLine: b,
+    ariaMultiSelectable: b,
+    ariaOrientation: null,
+    ariaOwns: S,
+    ariaPlaceholder: null,
+    ariaPosInSet: c,
+    ariaPressed: b,
+    ariaReadOnly: b,
+    ariaRelevant: null,
+    ariaRequired: b,
+    ariaRoleDescription: S,
+    ariaRowCount: c,
+    ariaRowIndex: c,
+    ariaRowSpan: c,
+    ariaSelected: b,
+    ariaSetSize: c,
+    ariaSort: null,
+    ariaValueMax: c,
+    ariaValueMin: c,
+    ariaValueNow: c,
+    ariaValueText: null,
+    role: null
+  },
+  transform(t, e) {
+    return e === "role" ? e : "aria-" + e.slice(4).toLowerCase();
+  }
+});
+function dt(t, e) {
+  return e in t ? t[e] : e;
+}
+function ft(t, e) {
+  return dt(t, e.toLowerCase());
+}
+const nn = z({
+  attributes: {
+    acceptcharset: "accept-charset",
+    classname: "class",
+    htmlfor: "for",
+    httpequiv: "http-equiv"
+  },
+  mustUseProperty: ["checked", "multiple", "muted", "selected"],
+  properties: {
+    // Standard Properties.
+    abbr: null,
+    accept: $,
+    acceptCharset: S,
+    accessKey: S,
+    action: null,
+    allow: null,
+    allowFullScreen: m,
+    allowPaymentRequest: m,
+    allowUserMedia: m,
+    alt: null,
+    as: null,
+    async: m,
+    autoCapitalize: null,
+    autoComplete: S,
+    autoFocus: m,
+    autoPlay: m,
+    blocking: S,
+    capture: null,
+    charSet: null,
+    checked: m,
+    cite: null,
+    className: S,
+    cols: c,
+    colSpan: null,
+    content: null,
+    contentEditable: b,
+    controls: m,
+    controlsList: S,
+    coords: c | $,
+    crossOrigin: null,
+    data: null,
+    dateTime: null,
+    decoding: null,
+    default: m,
+    defer: m,
+    dir: null,
+    dirName: null,
+    disabled: m,
+    download: be,
+    draggable: b,
+    encType: null,
+    enterKeyHint: null,
+    fetchPriority: null,
+    form: null,
+    formAction: null,
+    formEncType: null,
+    formMethod: null,
+    formNoValidate: m,
+    formTarget: null,
+    headers: S,
+    height: c,
+    hidden: be,
+    high: c,
+    href: null,
+    hrefLang: null,
+    htmlFor: S,
+    httpEquiv: S,
+    id: null,
+    imageSizes: null,
+    imageSrcSet: null,
+    inert: m,
+    inputMode: null,
+    integrity: null,
+    is: null,
+    isMap: m,
+    itemId: null,
+    itemProp: S,
+    itemRef: S,
+    itemScope: m,
+    itemType: S,
+    kind: null,
+    label: null,
+    lang: null,
+    language: null,
+    list: null,
+    loading: null,
+    loop: m,
+    low: c,
+    manifest: null,
+    max: null,
+    maxLength: c,
+    media: null,
+    method: null,
+    min: null,
+    minLength: c,
+    multiple: m,
+    muted: m,
+    name: null,
+    nonce: null,
+    noModule: m,
+    noValidate: m,
+    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: m,
+    optimum: c,
+    pattern: null,
+    ping: S,
+    placeholder: null,
+    playsInline: m,
+    popover: null,
+    popoverTarget: null,
+    popoverTargetAction: null,
+    poster: null,
+    preload: null,
+    readOnly: m,
+    referrerPolicy: null,
+    rel: S,
+    required: m,
+    reversed: m,
+    rows: c,
+    rowSpan: c,
+    sandbox: S,
+    scope: null,
+    scoped: m,
+    seamless: m,
+    selected: m,
+    shadowRootClonable: m,
+    shadowRootDelegatesFocus: m,
+    shadowRootMode: null,
+    shape: null,
+    size: c,
+    sizes: null,
+    slot: null,
+    span: c,
+    spellCheck: b,
+    src: null,
+    srcDoc: null,
+    srcLang: null,
+    srcSet: null,
+    start: c,
+    step: null,
+    style: null,
+    tabIndex: c,
+    target: null,
+    title: null,
+    translate: null,
+    type: null,
+    typeMustMatch: m,
+    useMap: null,
+    value: b,
+    width: c,
+    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: S,
+    // `<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: c,
+    // `<table>`. Use CSS `border-width` instead,
+    borderColor: null,
+    // `<table>`. Use CSS `border-color` instead,
+    bottomMargin: c,
+    // `<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: m,
+    // Lists. Use CSS to reduce space between items instead
+    declare: m,
+    // `<object>`
+    event: null,
+    // `<script>`
+    face: null,
+    // `<font>`. Use CSS instead
+    frame: null,
+    // `<table>`
+    frameBorder: null,
+    // `<iframe>`. Use CSS `border` instead
+    hSpace: c,
+    // `<img>` and `<object>`
+    leftMargin: c,
+    // `<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: c,
+    // `<body>`
+    marginWidth: c,
+    // `<body>`
+    noResize: m,
+    // `<frame>`
+    noHref: m,
+    // `<area>`. Use no href instead of an explicit `nohref`
+    noShade: m,
+    // `<hr>`. Use background-color and height instead of borders
+    noWrap: m,
+    // `<td>` and `<th>`
+    object: null,
+    // `<applet>`
+    profile: null,
+    // `<head>`
+    prompt: null,
+    // `<isindex>`
+    rev: null,
+    // `<link>`
+    rightMargin: c,
+    // `<body>`
+    rules: null,
+    // `<table>`
+    scheme: null,
+    // `<meta>`
+    scrolling: b,
+    // `<frame>`. Use overflow in the child context
+    standby: null,
+    // `<object>`
+    summary: null,
+    // `<table>`
+    text: null,
+    // `<body>`. Use CSS `color` instead
+    topMargin: c,
+    // `<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: c,
+    // `<img>` and `<object>`
+    // Non-standard Properties.
+    allowTransparency: null,
+    autoCorrect: null,
+    autoSave: null,
+    disablePictureInPicture: m,
+    disableRemotePlayback: m,
+    prefix: null,
+    property: null,
+    results: c,
+    security: null,
+    unselectable: null
+  },
+  space: "html",
+  transform: ft
+}), rn = z({
+  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",
+    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: I,
+    accentHeight: c,
+    accumulate: null,
+    additive: null,
+    alignmentBaseline: null,
+    alphabetic: c,
+    amplitude: c,
+    arabicForm: null,
+    ascent: c,
+    attributeName: null,
+    attributeType: null,
+    azimuth: c,
+    bandwidth: null,
+    baselineShift: null,
+    baseFrequency: null,
+    baseProfile: null,
+    bbox: null,
+    begin: null,
+    bias: c,
+    by: null,
+    calcMode: null,
+    capHeight: c,
+    className: S,
+    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: c,
+    diffuseConstant: c,
+    direction: null,
+    display: null,
+    dur: null,
+    divisor: c,
+    dominantBaseline: null,
+    download: m,
+    dx: null,
+    dy: null,
+    edgeMode: null,
+    editable: null,
+    elevation: c,
+    enableBackground: null,
+    end: null,
+    event: null,
+    exponent: c,
+    externalResourcesRequired: null,
+    fill: null,
+    fillOpacity: c,
+    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: $,
+    g2: $,
+    glyphName: $,
+    glyphOrientationHorizontal: null,
+    glyphOrientationVertical: null,
+    glyphRef: null,
+    gradientTransform: null,
+    gradientUnits: null,
+    handler: null,
+    hanging: c,
+    hatchContentUnits: null,
+    hatchUnits: null,
+    height: null,
+    href: null,
+    hrefLang: null,
+    horizAdvX: c,
+    horizOriginX: c,
+    horizOriginY: c,
+    id: null,
+    ideographic: c,
+    imageRendering: null,
+    initialVisibility: null,
+    in: null,
+    in2: null,
+    intercept: c,
+    k: c,
+    k1: c,
+    k2: c,
+    k3: c,
+    k4: c,
+    kernelMatrix: I,
+    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: c,
+    local: null,
+    markerEnd: null,
+    markerMid: null,
+    markerStart: null,
+    markerHeight: null,
+    markerUnits: null,
+    markerWidth: null,
+    mask: null,
+    maskContentUnits: null,
+    maskUnits: null,
+    mathematical: null,
+    max: null,
+    media: null,
+    mediaCharacterEncoding: null,
+    mediaContentEncodings: null,
+    mediaSize: c,
+    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: c,
+    overlineThickness: c,
+    paintOrder: null,
+    panose1: null,
+    path: null,
+    pathLength: c,
+    patternContentUnits: null,
+    patternTransform: null,
+    patternUnits: null,
+    phase: null,
+    ping: S,
+    pitch: null,
+    playbackOrder: null,
+    pointerEvents: null,
+    points: null,
+    pointsAtX: c,
+    pointsAtY: c,
+    pointsAtZ: c,
+    preserveAlpha: null,
+    preserveAspectRatio: null,
+    primitiveUnits: null,
+    propagate: null,
+    property: I,
+    r: null,
+    radius: null,
+    referrerPolicy: null,
+    refX: null,
+    refY: null,
+    rel: I,
+    rev: I,
+    renderingIntent: null,
+    repeatCount: null,
+    repeatDur: null,
+    requiredExtensions: I,
+    requiredFeatures: I,
+    requiredFonts: I,
+    requiredFormats: I,
+    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: c,
+    specularExponent: c,
+    spreadMethod: null,
+    spacing: null,
+    startOffset: null,
+    stdDeviation: null,
+    stemh: null,
+    stemv: null,
+    stitchTiles: null,
+    stopColor: null,
+    stopOpacity: null,
+    strikethroughPosition: c,
+    strikethroughThickness: c,
+    string: null,
+    stroke: null,
+    strokeDashArray: I,
+    strokeDashOffset: null,
+    strokeLineCap: null,
+    strokeLineJoin: null,
+    strokeMiterLimit: c,
+    strokeOpacity: c,
+    strokeWidth: null,
+    style: null,
+    surfaceScale: c,
+    syncBehavior: null,
+    syncBehaviorDefault: null,
+    syncMaster: null,
+    syncTolerance: null,
+    syncToleranceDefault: null,
+    systemLanguage: I,
+    tabIndex: c,
+    tableValues: null,
+    target: null,
+    targetX: c,
+    targetY: c,
+    textAnchor: null,
+    textDecoration: null,
+    textRendering: null,
+    textLength: null,
+    timelineBegin: null,
+    title: null,
+    transformBehavior: null,
+    type: null,
+    typeOf: I,
+    to: null,
+    transform: null,
+    transformOrigin: null,
+    u1: null,
+    u2: null,
+    underlinePosition: c,
+    underlineThickness: c,
+    unicode: null,
+    unicodeBidi: null,
+    unicodeRange: null,
+    unitsPerEm: c,
+    values: null,
+    vAlphabetic: c,
+    vMathematical: c,
+    vectorEffect: null,
+    vHanging: c,
+    vIdeographic: c,
+    version: null,
+    vertAdvY: c,
+    vertOriginX: c,
+    vertOriginY: c,
+    viewBox: null,
+    viewTarget: null,
+    visibility: null,
+    width: null,
+    widths: null,
+    wordSpacing: null,
+    writingMode: null,
+    x: null,
+    x1: null,
+    x2: null,
+    xChannelSelector: null,
+    xHeight: c,
+    y: null,
+    y1: null,
+    y2: null,
+    yChannelSelector: null,
+    z: null,
+    zoomAndPan: null
+  },
+  space: "svg",
+  transform: dt
+}), mt = z({
+  properties: {
+    xLinkActuate: null,
+    xLinkArcRole: null,
+    xLinkHref: null,
+    xLinkRole: null,
+    xLinkShow: null,
+    xLinkTitle: null,
+    xLinkType: null
+  },
+  space: "xlink",
+  transform(t, e) {
+    return "xlink:" + e.slice(5).toLowerCase();
+  }
+}), gt = z({
+  attributes: { xmlnsxlink: "xmlns:xlink" },
+  properties: { xmlnsXLink: null, xmlns: null },
+  space: "xmlns",
+  transform: ft
+}), yt = z({
+  properties: { xmlBase: null, xmlLang: null, xmlSpace: null },
+  space: "xml",
+  transform(t, e) {
+    return "xml:" + e.slice(3).toLowerCase();
+  }
+}), sn = {
+  classId: "classID",
+  dataType: "datatype",
+  itemId: "itemID",
+  strokeDashArray: "strokeDasharray",
+  strokeDashOffset: "strokeDashoffset",
+  strokeLineCap: "strokeLinecap",
+  strokeLineJoin: "strokeLinejoin",
+  strokeMiterLimit: "strokeMiterlimit",
+  typeOf: "typeof",
+  xLinkActuate: "xlinkActuate",
+  xLinkArcRole: "xlinkArcrole",
+  xLinkHref: "xlinkHref",
+  xLinkRole: "xlinkRole",
+  xLinkShow: "xlinkShow",
+  xLinkTitle: "xlinkTitle",
+  xLinkType: "xlinkType",
+  xmlnsXLink: "xmlnsXlink"
+}, ln = /[A-Z]/g, qe = /-[a-z]/g, on = /^data[-\w.:]+$/i;
+function _t(t, e) {
+  const n = Se(e);
+  let r = e, s = A;
+  if (n in t.normal)
+    return t.property[t.normal[n]];
+  if (n.length > 4 && n.slice(0, 4) === "data" && on.test(e)) {
+    if (e.charAt(4) === "-") {
+      const i = e.slice(5).replace(qe, un);
+      r = "data" + i.charAt(0).toUpperCase() + i.slice(1);
+    } else {
+      const i = e.slice(4);
+      if (!qe.test(i)) {
+        let l = i.replace(ln, an);
+        l.charAt(0) !== "-" && (l = "-" + l), e = "data" + l;
+      }
+    }
+    s = Le;
+  }
+  return new s(r, e);
+}
+function an(t) {
+  return "-" + t.toLowerCase();
+}
+function un(t) {
+  return t.charAt(1).toUpperCase();
+}
+const Ct = ht([pt, nn, mt, gt, yt], "html"), ee = ht([pt, rn, mt, gt, yt], "svg");
+function As(t) {
+  const e = String(t || "").trim();
+  return e ? e.split(/[ \t\n\r\f]+/g) : [];
+}
+function St(t) {
+  return t.join(" ").trim();
+}
+var F = {}, fe, We;
+function cn() {
+  if (We) return fe;
+  We = 1;
+  var t = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//g, e = /\n/g, n = /^\s*/, r = /^(\*?[-#/*\\\w]+(\[[0-9a-z_-]+\])?)\s*/, s = /^:\s*/, i = /^((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};])+)/, l = /^[;\s]*/, a = /^\s+|\s+$/g, o = `
+`, u = "/", h = "*", p = "", _ = "comment", f = "declaration";
+  function d(y, v) {
+    if (typeof y != "string")
+      throw new TypeError("First argument must be a string");
+    if (!y) return [];
+    v = v || {};
+    var R = 1, k = 1;
+    function M(C) {
+      var g = C.match(e);
+      g && (R += g.length);
+      var T = C.lastIndexOf(o);
+      k = ~T ? C.length - T : k + C.length;
+    }
+    function P() {
+      var C = { line: R, column: k };
+      return function(g) {
+        return g.position = new j(C), je(), g;
+      };
+    }
+    function j(C) {
+      this.start = C, this.end = { line: R, column: k }, this.source = v.source;
+    }
+    j.prototype.content = y;
+    function B(C) {
+      var g = new Error(
+        v.source + ":" + R + ":" + k + ": " + C
+      );
+      if (g.reason = C, g.filename = v.source, g.line = R, g.column = k, g.source = y, !v.silent) throw g;
+    }
+    function q(C) {
+      var g = C.exec(y);
+      if (g) {
+        var T = g[0];
+        return M(T), y = y.slice(T.length), g;
+      }
+    }
+    function je() {
+      q(n);
+    }
+    function Be(C) {
+      var g;
+      for (C = C || []; g = Fe(); )
+        g !== !1 && C.push(g);
+      return C;
+    }
+    function Fe() {
+      var C = P();
+      if (!(u != y.charAt(0) || h != y.charAt(1))) {
+        for (var g = 2; p != y.charAt(g) && (h != y.charAt(g) || u != y.charAt(g + 1)); )
+          ++g;
+        if (g += 2, p === y.charAt(g - 1))
+          return B("End of comment missing");
+        var T = y.slice(2, g - 2);
+        return k += 2, M(T), y = y.slice(g), k += 2, C({
+          type: _,
+          comment: T
+        });
+      }
+    }
+    function Xt() {
+      var C = P(), g = q(r);
+      if (g) {
+        if (Fe(), !q(s)) return B("property missing ':'");
+        var T = q(i), Vt = C({
+          type: f,
+          property: N(g[0].replace(t, p)),
+          value: T ? N(T[0].replace(t, p)) : p
+        });
+        return q(l), Vt;
+      }
+    }
+    function Kt() {
+      var C = [];
+      Be(C);
+      for (var g; g = Xt(); )
+        g !== !1 && (C.push(g), Be(C));
+      return C;
+    }
+    return je(), Kt();
+  }
+  function N(y) {
+    return y ? y.replace(a, p) : p;
+  }
+  return fe = d, fe;
+}
+var He;
+function hn() {
+  if (He) return F;
+  He = 1;
+  var t = F && F.__importDefault || function(r) {
+    return r && r.__esModule ? r : { default: r };
+  };
+  Object.defineProperty(F, "__esModule", { value: !0 }), F.default = n;
+  const e = t(cn());
+  function n(r, s) {
+    let i = null;
+    if (!r || typeof r != "string")
+      return i;
+    const l = (0, e.default)(r), a = typeof s == "function";
+    return l.forEach((o) => {
+      if (o.type !== "declaration")
+        return;
+      const { property: u, value: h } = o;
+      a ? s(u, h, o) : h && (i = i || {}, i[u] = h);
+    }), i;
+  }
+  return F;
+}
+var W = {}, Xe;
+function pn() {
+  if (Xe) return W;
+  Xe = 1, Object.defineProperty(W, "__esModule", { value: !0 }), W.camelCase = void 0;
+  var t = /^--[a-zA-Z0-9_-]+$/, e = /-([a-z])/g, n = /^[^-]+$/, r = /^-(webkit|moz|ms|o|khtml)-/, s = /^-(ms)-/, i = function(u) {
+    return !u || n.test(u) || t.test(u);
+  }, l = function(u, h) {
+    return h.toUpperCase();
+  }, a = function(u, h) {
+    return "".concat(h, "-");
+  }, o = function(u, h) {
+    return h === void 0 && (h = {}), i(u) ? u : (u = u.toLowerCase(), h.reactCompat ? u = u.replace(s, a) : u = u.replace(r, a), u.replace(e, l));
+  };
+  return W.camelCase = o, W;
+}
+var H, Ke;
+function dn() {
+  if (Ke) return H;
+  Ke = 1;
+  var t = H && H.__importDefault || function(s) {
+    return s && s.__esModule ? s : { default: s };
+  }, e = t(hn()), n = pn();
+  function r(s, i) {
+    var l = {};
+    return !s || typeof s != "string" || (0, e.default)(s, function(a, o) {
+      a && o && (l[(0, n.camelCase)(a, i)] = o);
+    }), l;
+  }
+  return r.default = r, H = r, H;
+}
+var fn = dn();
+const mn = /* @__PURE__ */ Yt(fn), gn = vt("end"), bt = vt("start");
+function vt(t) {
+  return e;
+  function e(n) {
+    const r = n && n.position && n.position[t] || {};
+    if (typeof r.line == "number" && r.line > 0 && typeof r.column == "number" && r.column > 0)
+      return {
+        line: r.line,
+        column: r.column,
+        offset: typeof r.offset == "number" && r.offset > -1 ? r.offset : void 0
+      };
+  }
+}
+function Ns(t) {
+  const e = bt(t), n = gn(t);
+  if (e && n)
+    return { start: e, end: n };
+}
+function yn(t) {
+  return !t || typeof t != "object" ? "" : "position" in t || "type" in t ? Ve(t.position) : "start" in t || "end" in t ? Ve(t) : "line" in t || "column" in t ? Re(t) : "";
+}
+function Re(t) {
+  return Ye(t && t.line) + ":" + Ye(t && t.column);
+}
+function Ve(t) {
+  return Re(t && t.start) + "-" + Re(t && t.end);
+}
+function Ye(t) {
+  return t && typeof t == "number" ? t : 1;
+}
+class E extends Error {
+  /**
+   * Create a message for `reason`.
+   *
+   * > 🪦 **Note**: also has obsolete signatures.
+   *
+   * @overload
+   * @param {string} reason
+   * @param {Options | null | undefined} [options]
+   * @returns
+   *
+   * @overload
+   * @param {string} reason
+   * @param {Node | NodeLike | null | undefined} parent
+   * @param {string | null | undefined} [origin]
+   * @returns
+   *
+   * @overload
+   * @param {string} reason
+   * @param {Point | Position | null | undefined} place
+   * @param {string | null | undefined} [origin]
+   * @returns
+   *
+   * @overload
+   * @param {string} reason
+   * @param {string | null | undefined} [origin]
+   * @returns
+   *
+   * @overload
+   * @param {Error | VFileMessage} cause
+   * @param {Node | NodeLike | null | undefined} parent
+   * @param {string | null | undefined} [origin]
+   * @returns
+   *
+   * @overload
+   * @param {Error | VFileMessage} cause
+   * @param {Point | Position | null | undefined} place
+   * @param {string | null | undefined} [origin]
+   * @returns
+   *
+   * @overload
+   * @param {Error | VFileMessage} cause
+   * @param {string | null | undefined} [origin]
+   * @returns
+   *
+   * @param {Error | VFileMessage | string} causeOrReason
+   *   Reason for message, should use markdown.
+   * @param {Node | NodeLike | Options | Point | Position | string | null | undefined} [optionsOrParentOrPlace]
+   *   Configuration (optional).
+   * @param {string | null | undefined} [origin]
+   *   Place in code where the message originates (example:
+   *   `'my-package:my-rule'` or `'my-rule'`).
+   * @returns
+   *   Instance of `VFileMessage`.
+   */
+  // eslint-disable-next-line complexity
+  constructor(e, n, r) {
+    super(), typeof n == "string" && (r = n, n = void 0);
+    let s = "", i = {}, l = !1;
+    if (n && ("line" in n && "column" in n ? i = { place: n } : "start" in n && "end" in n ? i = { place: n } : "type" in n ? i = {
+      ancestors: [n],
+      place: n.position
+    } : i = { ...n }), typeof e == "string" ? s = e : !i.cause && e && (l = !0, s = e.message, i.cause = e), !i.ruleId && !i.source && typeof r == "string") {
+      const o = r.indexOf(":");
+      o === -1 ? i.ruleId = r : (i.source = r.slice(0, o), i.ruleId = r.slice(o + 1));
+    }
+    if (!i.place && i.ancestors && i.ancestors) {
+      const o = i.ancestors[i.ancestors.length - 1];
+      o && (i.place = o.position);
+    }
+    const a = i.place && "start" in i.place ? i.place.start : i.place;
+    this.ancestors = i.ancestors || void 0, this.cause = i.cause || void 0, this.column = a ? a.column : void 0, this.fatal = void 0, this.file = "", this.message = s, this.line = a ? a.line : void 0, this.name = yn(i.place) || "1:1", this.place = i.place || void 0, this.reason = this.message, this.ruleId = i.ruleId || void 0, this.source = i.source || void 0, this.stack = l && i.cause && typeof i.cause.stack == "string" ? i.cause.stack : "", this.actual = void 0, this.expected = void 0, this.note = void 0, this.url = void 0;
+  }
+}
+E.prototype.file = "";
+E.prototype.name = "";
+E.prototype.reason = "";
+E.prototype.message = "";
+E.prototype.stack = "";
+E.prototype.column = void 0;
+E.prototype.line = void 0;
+E.prototype.ancestors = void 0;
+E.prototype.cause = void 0;
+E.prototype.fatal = void 0;
+E.prototype.place = void 0;
+E.prototype.ruleId = void 0;
+E.prototype.source = void 0;
+const Te = {}.hasOwnProperty, _n = /* @__PURE__ */ new Map(), Cn = /[A-Z]/g, Sn = /* @__PURE__ */ new Set(["table", "tbody", "thead", "tfoot", "tr"]), bn = /* @__PURE__ */ new Set(["td", "th"]), Rt = "https://github.com/syntax-tree/hast-util-to-jsx-runtime";
+function Ps(t, e) {
+  if (!e || e.Fragment === void 0)
+    throw new TypeError("Expected `Fragment` in options");
+  const n = e.filePath || void 0;
+  let r;
+  if (e.development) {
+    if (typeof e.jsxDEV != "function")
+      throw new TypeError(
+        "Expected `jsxDEV` in options when `development: true`"
+      );
+    r = Nn(n, e.jsxDEV);
+  } else {
+    if (typeof e.jsx != "function")
+      throw new TypeError("Expected `jsx` in production options");
+    if (typeof e.jsxs != "function")
+      throw new TypeError("Expected `jsxs` in production options");
+    r = An(n, e.jsx, e.jsxs);
+  }
+  const s = {
+    Fragment: e.Fragment,
+    ancestors: [],
+    components: e.components || {},
+    create: r,
+    elementAttributeNameCase: e.elementAttributeNameCase || "react",
+    evaluater: e.createEvaluater ? e.createEvaluater() : void 0,
+    filePath: n,
+    ignoreInvalidStyle: e.ignoreInvalidStyle || !1,
+    passKeys: e.passKeys !== !1,
+    passNode: e.passNode || !1,
+    schema: e.space === "svg" ? ee : Ct,
+    stylePropertyNameCase: e.stylePropertyNameCase || "dom",
+    tableCellAlignToStyle: e.tableCellAlignToStyle !== !1
+  }, i = wt(s, t, void 0);
+  return i && typeof i != "string" ? i : s.create(
+    t,
+    s.Fragment,
+    { children: i || void 0 },
+    void 0
+  );
+}
+function wt(t, e, n) {
+  if (e.type === "element")
+    return vn(t, e, n);
+  if (e.type === "mdxFlowExpression" || e.type === "mdxTextExpression")
+    return Rn(t, e);
+  if (e.type === "mdxJsxFlowElement" || e.type === "mdxJsxTextElement")
+    return xn(t, e, n);
+  if (e.type === "mdxjsEsm")
+    return wn(t, e);
+  if (e.type === "root")
+    return kn(t, e, n);
+  if (e.type === "text")
+    return En(t, e);
+}
+function vn(t, e, n) {
+  const r = t.schema;
+  let s = r;
+  e.tagName.toLowerCase() === "svg" && r.space === "html" && (s = ee, t.schema = s), t.ancestors.push(e);
+  const i = kt(t, e.tagName, !1), l = Pn(t, e);
+  let a = Oe(t, e);
+  return Sn.has(e.tagName) && (a = a.filter(function(o) {
+    return typeof o == "string" ? !pe(o) : !0;
+  })), xt(t, l, i, e), Me(l, a), t.ancestors.pop(), t.schema = r, t.create(e, i, l, n);
+}
+function Rn(t, e) {
+  if (e.data && e.data.estree && t.evaluater) {
+    const r = e.data.estree.body[0];
+    return r.type, /** @type {Child | undefined} */
+    t.evaluater.evaluateExpression(r.expression);
+  }
+  V(t, e.position);
+}
+function wn(t, e) {
+  if (e.data && e.data.estree && t.evaluater)
+    return (
+      /** @type {Child | undefined} */
+      t.evaluater.evaluateProgram(e.data.estree)
+    );
+  V(t, e.position);
+}
+function xn(t, e, n) {
+  const r = t.schema;
+  let s = r;
+  e.name === "svg" && r.space === "html" && (s = ee, t.schema = s), t.ancestors.push(e);
+  const i = e.name === null ? t.Fragment : kt(t, e.name, !0), l = In(t, e), a = Oe(t, e);
+  return xt(t, l, i, e), Me(l, a), t.ancestors.pop(), t.schema = r, t.create(e, i, l, n);
+}
+function kn(t, e, n) {
+  const r = {};
+  return Me(r, Oe(t, e)), t.create(e, t.Fragment, r, n);
+}
+function En(t, e) {
+  return e.value;
+}
+function xt(t, e, n, r) {
+  typeof n != "string" && n !== t.Fragment && t.passNode && (e.node = r);
+}
+function Me(t, e) {
+  if (e.length > 0) {
+    const n = e.length > 1 ? e : e[0];
+    n && (t.children = n);
+  }
+}
+function An(t, e, n) {
+  return r;
+  function r(s, i, l, a) {
+    const u = Array.isArray(l.children) ? n : e;
+    return a ? u(i, l, a) : u(i, l);
+  }
+}
+function Nn(t, e) {
+  return n;
+  function n(r, s, i, l) {
+    const a = Array.isArray(i.children), o = bt(r);
+    return e(
+      s,
+      i,
+      l,
+      a,
+      {
+        columnNumber: o ? o.column - 1 : void 0,
+        fileName: t,
+        lineNumber: o ? o.line : void 0
+      },
+      void 0
+    );
+  }
+}
+function Pn(t, e) {
+  const n = {};
+  let r, s;
+  for (s in e.properties)
+    if (s !== "children" && Te.call(e.properties, s)) {
+      const i = Ln(t, s, e.properties[s]);
+      if (i) {
+        const [l, a] = i;
+        t.tableCellAlignToStyle && l === "align" && typeof a == "string" && bn.has(e.tagName) ? r = a : n[l] = a;
+      }
+    }
+  if (r) {
+    const i = (
+      /** @type {Style} */
+      n.style || (n.style = {})
+    );
+    i[t.stylePropertyNameCase === "css" ? "text-align" : "textAlign"] = r;
+  }
+  return n;
+}
+function In(t, e) {
+  const n = {};
+  for (const r of e.attributes)
+    if (r.type === "mdxJsxExpressionAttribute")
+      if (r.data && r.data.estree && t.evaluater) {
+        const i = r.data.estree.body[0];
+        i.type;
+        const l = i.expression;
+        l.type;
+        const a = l.properties[0];
+        a.type, Object.assign(
+          n,
+          t.evaluater.evaluateExpression(a.argument)
+        );
+      } else
+        V(t, e.position);
+    else {
+      const s = r.name;
+      let i;
+      if (r.value && typeof r.value == "object")
+        if (r.value.data && r.value.data.estree && t.evaluater) {
+          const a = r.value.data.estree.body[0];
+          a.type, i = t.evaluater.evaluateExpression(a.expression);
+        } else
+          V(t, e.position);
+      else
+        i = r.value === null ? !0 : r.value;
+      n[s] = /** @type {Props[keyof Props]} */
+      i;
+    }
+  return n;
+}
+function Oe(t, e) {
+  const n = [];
+  let r = -1;
+  const s = t.passKeys ? /* @__PURE__ */ new Map() : _n;
+  for (; ++r < e.children.length; ) {
+    const i = e.children[r];
+    let l;
+    if (t.passKeys) {
+      const o = i.type === "element" ? i.tagName : i.type === "mdxJsxFlowElement" || i.type === "mdxJsxTextElement" ? i.name : void 0;
+      if (o) {
+        const u = s.get(o) || 0;
+        l = o + "-" + u, s.set(o, u + 1);
+      }
+    }
+    const a = wt(t, i, l);
+    a !== void 0 && n.push(a);
+  }
+  return n;
+}
+function Ln(t, e, n) {
+  const r = _t(t.schema, e);
+  if (!(n == null || typeof n == "number" && Number.isNaN(n))) {
+    if (Array.isArray(n) && (n = r.commaSeparated ? ct(n) : St(n)), r.property === "style") {
+      let s = typeof n == "object" ? n : Tn(t, String(n));
+      return t.stylePropertyNameCase === "css" && (s = Mn(s)), ["style", s];
+    }
+    return [
+      t.elementAttributeNameCase === "react" && r.space ? sn[r.property] || r.property : r.attribute,
+      n
+    ];
+  }
+}
+function Tn(t, e) {
+  try {
+    return mn(e, { reactCompat: !0 });
+  } catch (n) {
+    if (t.ignoreInvalidStyle)
+      return {};
+    const r = (
+      /** @type {Error} */
+      n
+    ), s = new E("Cannot parse `style` attribute", {
+      ancestors: t.ancestors,
+      cause: r,
+      ruleId: "style",
+      source: "hast-util-to-jsx-runtime"
+    });
+    throw s.file = t.filePath || void 0, s.url = Rt + "#cannot-parse-style-attribute", s;
+  }
+}
+function kt(t, e, n) {
+  let r;
+  if (!n)
+    r = { type: "Literal", value: e };
+  else if (e.includes(".")) {
+    const s = e.split(".");
+    let i = -1, l;
+    for (; ++i < s.length; ) {
+      const a = $e(s[i]) ? { type: "Identifier", name: s[i] } : { type: "Literal", value: s[i] };
+      l = l ? {
+        type: "MemberExpression",
+        object: l,
+        property: a,
+        computed: !!(i && a.type === "Literal"),
+        optional: !1
+      } : a;
+    }
+    r = l;
+  } else
+    r = $e(e) && !/^[a-z]/.test(e) ? { type: "Identifier", name: e } : { type: "Literal", value: e };
+  if (r.type === "Literal") {
+    const s = (
+      /** @type {string | number} */
+      r.value
+    );
+    return Te.call(t.components, s) ? t.components[s] : s;
+  }
+  if (t.evaluater)
+    return t.evaluater.evaluateExpression(r);
+  V(t);
+}
+function V(t, e) {
+  const n = new E(
+    "Cannot handle MDX estrees without `createEvaluater`",
+    {
+      ancestors: t.ancestors,
+      place: e,
+      ruleId: "mdx-estree",
+      source: "hast-util-to-jsx-runtime"
+    }
+  );
+  throw n.file = t.filePath || void 0, n.url = Rt + "#cannot-handle-mdx-estrees-without-createevaluater", n;
+}
+function Mn(t) {
+  const e = {};
+  let n;
+  for (n in t)
+    Te.call(t, n) && (e[On(n)] = t[n]);
+  return e;
+}
+function On(t) {
+  let e = t.replace(Cn, Dn);
+  return e.slice(0, 3) === "ms-" && (e = "-" + e), e;
+}
+function Dn(t) {
+  return "-" + t.toLowerCase();
+}
+function Gn(t) {
+  return De(t);
+}
+function De(t) {
+  return Array.isArray(t) ? jn(t) : t instanceof RegExp ? t : typeof t == "object" ? Bn(t) : t;
+}
+function jn(t) {
+  let e = [];
+  for (let n = 0, r = t.length; n < r; n++)
+    e[n] = De(t[n]);
+  return e;
+}
+function Bn(t) {
+  let e = {};
+  for (let n in t)
+    e[n] = De(t[n]);
+  return e;
+}
+function Et(t, ...e) {
+  return e.forEach((n) => {
+    for (let r in n)
+      t[r] = n[r];
+  }), t;
+}
+function At(t) {
+  const e = ~t.lastIndexOf("/") || ~t.lastIndexOf("\\");
+  return e === 0 ? t : ~e === t.length - 1 ? At(t.substring(0, t.length - 1)) : t.substr(~e + 1);
+}
+var me = /\$(\d+)|\${(\d+):\/(downcase|upcase)}/g, ne = class {
+  static hasCaptures(t) {
+    return t === null ? !1 : (me.lastIndex = 0, me.test(t));
+  }
+  static replaceCaptures(t, e, n) {
+    return t.replace(me, (r, s, i, l) => {
+      let a = n[parseInt(s || i, 10)];
+      if (a) {
+        let o = e.substring(a.start, a.end);
+        for (; o[0] === "."; )
+          o = o.substring(1);
+        switch (l) {
+          case "downcase":
+            return o.toLowerCase();
+          case "upcase":
+            return o.toUpperCase();
+          default:
+            return o;
+        }
+      } else
+        return r;
+    });
+  }
+};
+function Nt(t, e) {
+  return t < e ? -1 : t > e ? 1 : 0;
+}
+function Pt(t, e) {
+  if (t === null && e === null)
+    return 0;
+  if (!t)
+    return -1;
+  if (!e)
+    return 1;
+  let n = t.length, r = e.length;
+  if (n === r) {
+    for (let s = 0; s < n; s++) {
+      let i = Nt(t[s], e[s]);
+      if (i !== 0)
+        return i;
+    }
+    return 0;
+  }
+  return n - r;
+}
+function Je(t) {
+  return !!(/^#[0-9a-f]{6}$/i.test(t) || /^#[0-9a-f]{8}$/i.test(t) || /^#[0-9a-f]{3}$/i.test(t) || /^#[0-9a-f]{4}$/i.test(t));
+}
+function It(t) {
+  return t.replace(/[\-\\\{\}\*\+\?\|\^\$\.\,\[\]\(\)\#\s]/g, "\\$&");
+}
+var Lt = class {
+  constructor(t) {
+    this.fn = t;
+  }
+  cache = /* @__PURE__ */ new Map();
+  get(t) {
+    if (this.cache.has(t))
+      return this.cache.get(t);
+    const e = this.fn(t);
+    return this.cache.set(t, e), e;
+  }
+}, we = class {
+  constructor(t, e, n) {
+    this._colorMap = t, this._defaults = e, this._root = n;
+  }
+  static createFromRawTheme(t, e) {
+    return this.createFromParsedTheme(Un(t), e);
+  }
+  static createFromParsedTheme(t, e) {
+    return Wn(t, e);
+  }
+  _cachedMatchRoot = new Lt(
+    (t) => this._root.match(t)
+  );
+  getColorMap() {
+    return this._colorMap.getColorMap();
+  }
+  getDefaults() {
+    return this._defaults;
+  }
+  match(t) {
+    if (t === null)
+      return this._defaults;
+    const e = t.scopeName, r = this._cachedMatchRoot.get(e).find(
+      (s) => Fn(t.parent, s.parentScopes)
+    );
+    return r ? new Tt(
+      r.fontStyle,
+      r.foreground,
+      r.background
+    ) : null;
+  }
+}, ge = class ie {
+  constructor(e, n) {
+    this.parent = e, this.scopeName = n;
+  }
+  static push(e, n) {
+    for (const r of n)
+      e = new ie(e, r);
+    return e;
+  }
+  static from(...e) {
+    let n = null;
+    for (let r = 0; r < e.length; r++)
+      n = new ie(n, e[r]);
+    return n;
+  }
+  push(e) {
+    return new ie(this, e);
+  }
+  getSegments() {
+    let e = this;
+    const n = [];
+    for (; e; )
+      n.push(e.scopeName), e = e.parent;
+    return n.reverse(), n;
+  }
+  toString() {
+    return this.getSegments().join(" ");
+  }
+  extends(e) {
+    return this === e ? !0 : this.parent === null ? !1 : this.parent.extends(e);
+  }
+  getExtensionIfDefined(e) {
+    const n = [];
+    let r = this;
+    for (; r && r !== e; )
+      n.push(r.scopeName), r = r.parent;
+    return r === e ? n.reverse() : void 0;
+  }
+};
+function Fn(t, e) {
+  if (e.length === 0)
+    return !0;
+  for (let n = 0; n < e.length; n++) {
+    let r = e[n], s = !1;
+    if (r === ">") {
+      if (n === e.length - 1)
+        return !1;
+      r = e[++n], s = !0;
+    }
+    for (; t && !$n(t.scopeName, r); ) {
+      if (s)
+        return !1;
+      t = t.parent;
+    }
+    if (!t)
+      return !1;
+    t = t.parent;
+  }
+  return !0;
+}
+function $n(t, e) {
+  return e === t || t.startsWith(e) && t[e.length] === ".";
+}
+var Tt = class {
+  constructor(t, e, n) {
+    this.fontStyle = t, this.foregroundId = e, this.backgroundId = n;
+  }
+};
+function Un(t) {
+  if (!t)
+    return [];
+  if (!t.settings || !Array.isArray(t.settings))
+    return [];
+  let e = t.settings, n = [], r = 0;
+  for (let s = 0, i = e.length; s < i; s++) {
+    let l = e[s];
+    if (!l.settings)
+      continue;
+    let a;
+    if (typeof l.scope == "string") {
+      let p = l.scope;
+      p = p.replace(/^[,]+/, ""), p = p.replace(/[,]+$/, ""), a = p.split(",");
+    } else Array.isArray(l.scope) ? a = l.scope : a = [""];
+    let o = -1;
+    if (typeof l.settings.fontStyle == "string") {
+      o = 0;
+      let p = l.settings.fontStyle.split(" ");
+      for (let _ = 0, f = p.length; _ < f; _++)
+        switch (p[_]) {
+          case "italic":
+            o = o | 1;
+            break;
+          case "bold":
+            o = o | 2;
+            break;
+          case "underline":
+            o = o | 4;
+            break;
+          case "strikethrough":
+            o = o | 8;
+            break;
+        }
+    }
+    let u = null;
+    typeof l.settings.foreground == "string" && Je(l.settings.foreground) && (u = l.settings.foreground);
+    let h = null;
+    typeof l.settings.background == "string" && Je(l.settings.background) && (h = l.settings.background);
+    for (let p = 0, _ = a.length; p < _; p++) {
+      let d = a[p].trim().split(" "), N = d[d.length - 1], y = null;
+      d.length > 1 && (y = d.slice(0, d.length - 1), y.reverse()), n[r++] = new zn(
+        N,
+        y,
+        s,
+        o,
+        u,
+        h
+      );
+    }
+  }
+  return n;
+}
+var zn = class {
+  constructor(t, e, n, r, s, i) {
+    this.scope = t, this.parentScopes = e, this.index = n, this.fontStyle = r, this.foreground = s, this.background = i;
+  }
+}, qn = /* @__PURE__ */ ((t) => (t[t.NotSet = -1] = "NotSet", t[t.None = 0] = "None", t[t.Italic = 1] = "Italic", t[t.Bold = 2] = "Bold", t[t.Underline = 4] = "Underline", t[t.Strikethrough = 8] = "Strikethrough", t))(qn || {});
+function Wn(t, e) {
+  t.sort((o, u) => {
+    let h = Nt(o.scope, u.scope);
+    return h !== 0 || (h = Pt(o.parentScopes, u.parentScopes), h !== 0) ? h : o.index - u.index;
+  });
+  let n = 0, r = "#000000", s = "#ffffff";
+  for (; t.length >= 1 && t[0].scope === ""; ) {
+    let o = t.shift();
+    o.fontStyle !== -1 && (n = o.fontStyle), o.foreground !== null && (r = o.foreground), o.background !== null && (s = o.background);
+  }
+  let i = new Hn(e), l = new Tt(n, i.getId(r), i.getId(s)), a = new Kn(new xe(0, null, -1, 0, 0), []);
+  for (let o = 0, u = t.length; o < u; o++) {
+    let h = t[o];
+    a.insert(0, h.scope, h.parentScopes, h.fontStyle, i.getId(h.foreground), i.getId(h.background));
+  }
+  return new we(i, l, a);
+}
+var Hn = class {
+  _isFrozen;
+  _lastColorId;
+  _id2color;
+  _color2id;
+  constructor(t) {
+    if (this._lastColorId = 0, this._id2color = [], this._color2id = /* @__PURE__ */ Object.create(null), Array.isArray(t)) {
+      this._isFrozen = !0;
+      for (let e = 0, n = t.length; e < n; e++)
+        this._color2id[t[e]] = e, this._id2color[e] = t[e];
+    } else
+      this._isFrozen = !1;
+  }
+  getId(t) {
+    if (t === null)
+      return 0;
+    t = t.toUpperCase();
+    let e = this._color2id[t];
+    if (e)
+      return e;
+    if (this._isFrozen)
+      throw new Error(`Missing color in color map - ${t}`);
+    return e = ++this._lastColorId, this._color2id[t] = e, this._id2color[e] = t, e;
+  }
+  getColorMap() {
+    return this._id2color.slice(0);
+  }
+}, Xn = Object.freeze([]), xe = class Mt {
+  scopeDepth;
+  parentScopes;
+  fontStyle;
+  foreground;
+  background;
+  constructor(e, n, r, s, i) {
+    this.scopeDepth = e, this.parentScopes = n || Xn, this.fontStyle = r, this.foreground = s, this.background = i;
+  }
+  clone() {
+    return new Mt(this.scopeDepth, this.parentScopes, this.fontStyle, this.foreground, this.background);
+  }
+  static cloneArr(e) {
+    let n = [];
+    for (let r = 0, s = e.length; r < s; r++)
+      n[r] = e[r].clone();
+    return n;
+  }
+  acceptOverwrite(e, n, r, s) {
+    this.scopeDepth > e ? console.log("how did this happen?") : this.scopeDepth = e, n !== -1 && (this.fontStyle = n), r !== 0 && (this.foreground = r), s !== 0 && (this.background = s);
+  }
+}, Kn = class ke {
+  constructor(e, n = [], r = {}) {
+    this._mainRule = e, this._children = r, this._rulesWithParentScopes = n;
+  }
+  _rulesWithParentScopes;
+  static _cmpBySpecificity(e, n) {
+    if (e.scopeDepth !== n.scopeDepth)
+      return n.scopeDepth - e.scopeDepth;
+    let r = 0, s = 0;
+    for (; e.parentScopes[r] === ">" && r++, n.parentScopes[s] === ">" && s++, !(r >= e.parentScopes.length || s >= n.parentScopes.length); ) {
+      const i = n.parentScopes[s].length - e.parentScopes[r].length;
+      if (i !== 0)
+        return i;
+      r++, s++;
+    }
+    return n.parentScopes.length - e.parentScopes.length;
+  }
+  match(e) {
+    if (e !== "") {
+      let r = e.indexOf("."), s, i;
+      if (r === -1 ? (s = e, i = "") : (s = e.substring(0, r), i = e.substring(r + 1)), this._children.hasOwnProperty(s))
+        return this._children[s].match(i);
+    }
+    const n = this._rulesWithParentScopes.concat(this._mainRule);
+    return n.sort(ke._cmpBySpecificity), n;
+  }
+  insert(e, n, r, s, i, l) {
+    if (n === "") {
+      this._doInsertHere(e, r, s, i, l);
+      return;
+    }
+    let a = n.indexOf("."), o, u;
+    a === -1 ? (o = n, u = "") : (o = n.substring(0, a), u = n.substring(a + 1));
+    let h;
+    this._children.hasOwnProperty(o) ? h = this._children[o] : (h = new ke(this._mainRule.clone(), xe.cloneArr(this._rulesWithParentScopes)), this._children[o] = h), h.insert(e + 1, u, r, s, i, l);
+  }
+  _doInsertHere(e, n, r, s, i) {
+    if (n === null) {
+      this._mainRule.acceptOverwrite(e, r, s, i);
+      return;
+    }
+    for (let l = 0, a = this._rulesWithParentScopes.length; l < a; l++) {
+      let o = this._rulesWithParentScopes[l];
+      if (Pt(o.parentScopes, n) === 0) {
+        o.acceptOverwrite(e, r, s, i);
+        return;
+      }
+    }
+    r === -1 && (r = this._mainRule.fontStyle), s === 0 && (s = this._mainRule.foreground), i === 0 && (i = this._mainRule.background), this._rulesWithParentScopes.push(new xe(e, n, r, s, i));
+  }
+}, oe = class L {
+  static toBinaryStr(e) {
+    return e.toString(2).padStart(32, "0");
+  }
+  static print(e) {
+    const n = L.getLanguageId(e), r = L.getTokenType(e), s = L.getFontStyle(e), i = L.getForeground(e), l = L.getBackground(e);
+    console.log({
+      languageId: n,
+      tokenType: r,
+      fontStyle: s,
+      foreground: i,
+      background: l
+    });
+  }
+  static getLanguageId(e) {
+    return (e & 255) >>> 0;
+  }
+  static getTokenType(e) {
+    return (e & 768) >>> 8;
+  }
+  static containsBalancedBrackets(e) {
+    return (e & 1024) !== 0;
+  }
+  static getFontStyle(e) {
+    return (e & 30720) >>> 11;
+  }
+  static getForeground(e) {
+    return (e & 16744448) >>> 15;
+  }
+  static getBackground(e) {
+    return (e & 4278190080) >>> 24;
+  }
+  /**
+   * Updates the fields in `metadata`.
+   * A value of `0`, `NotSet` or `null` indicates that the corresponding field should be left as is.
+   */
+  static set(e, n, r, s, i, l, a) {
+    let o = L.getLanguageId(e), u = L.getTokenType(e), h = L.containsBalancedBrackets(e) ? 1 : 0, p = L.getFontStyle(e), _ = L.getForeground(e), f = L.getBackground(e);
+    return n !== 0 && (o = n), r !== 8 && (u = r), s !== null && (h = s ? 1 : 0), i !== -1 && (p = i), l !== 0 && (_ = l), a !== 0 && (f = a), (o << 0 | u << 8 | h << 10 | p << 11 | _ << 15 | f << 24) >>> 0;
+  }
+};
+function ae(t, e) {
+  const n = [], r = Vn(t);
+  let s = r.next();
+  for (; s !== null; ) {
+    let o = 0;
+    if (s.length === 2 && s.charAt(1) === ":") {
+      switch (s.charAt(0)) {
+        case "R":
+          o = 1;
+          break;
+        case "L":
+          o = -1;
+          break;
+        default:
+          console.log(`Unknown priority ${s} in scope selector`);
+      }
+      s = r.next();
+    }
+    let u = l();
+    if (n.push({ matcher: u, priority: o }), s !== ",")
+      break;
+    s = r.next();
+  }
+  return n;
+  function i() {
+    if (s === "-") {
+      s = r.next();
+      const o = i();
+      return (u) => !!o && !o(u);
+    }
+    if (s === "(") {
+      s = r.next();
+      const o = a();
+      return s === ")" && (s = r.next()), o;
+    }
+    if (Qe(s)) {
+      const o = [];
+      do
+        o.push(s), s = r.next();
+      while (Qe(s));
+      return (u) => e(o, u);
+    }
+    return null;
+  }
+  function l() {
+    const o = [];
+    let u = i();
+    for (; u; )
+      o.push(u), u = i();
+    return (h) => o.every((p) => p(h));
+  }
+  function a() {
+    const o = [];
+    let u = l();
+    for (; u && (o.push(u), s === "|" || s === ","); ) {
+      do
+        s = r.next();
+      while (s === "|" || s === ",");
+      u = l();
+    }
+    return (h) => o.some((p) => p(h));
+  }
+}
+function Qe(t) {
+  return !!t && !!t.match(/[\w\.:]+/);
+}
+function Vn(t) {
+  let e = /([LR]:|[\w\.:][\w\.:\-]*|[\,\|\-\(\)])/g, n = e.exec(t);
+  return {
+    next: () => {
+      if (!n)
+        return null;
+      const r = n[0];
+      return n = e.exec(t), r;
+    }
+  };
+}
+function Ot(t) {
+  typeof t.dispose == "function" && t.dispose();
+}
+var Y = class {
+  constructor(t) {
+    this.scopeName = t;
+  }
+  toKey() {
+    return this.scopeName;
+  }
+}, Yn = class {
+  constructor(t, e) {
+    this.scopeName = t, this.ruleName = e;
+  }
+  toKey() {
+    return `${this.scopeName}#${this.ruleName}`;
+  }
+}, Jn = class {
+  _references = [];
+  _seenReferenceKeys = /* @__PURE__ */ new Set();
+  get references() {
+    return this._references;
+  }
+  visitedRule = /* @__PURE__ */ new Set();
+  add(t) {
+    const e = t.toKey();
+    this._seenReferenceKeys.has(e) || (this._seenReferenceKeys.add(e), this._references.push(t));
+  }
+}, Qn = class {
+  constructor(t, e) {
+    this.repo = t, this.initialScopeName = e, this.seenFullScopeRequests.add(this.initialScopeName), this.Q = [new Y(this.initialScopeName)];
+  }
+  seenFullScopeRequests = /* @__PURE__ */ new Set();
+  seenPartialScopeRequests = /* @__PURE__ */ new Set();
+  Q;
+  processQueue() {
+    const t = this.Q;
+    this.Q = [];
+    const e = new Jn();
+    for (const n of t)
+      Zn(n, this.initialScopeName, this.repo, e);
+    for (const n of e.references)
+      if (n instanceof Y) {
+        if (this.seenFullScopeRequests.has(n.scopeName))
+          continue;
+        this.seenFullScopeRequests.add(n.scopeName), this.Q.push(n);
+      } else {
+        if (this.seenFullScopeRequests.has(n.scopeName) || this.seenPartialScopeRequests.has(n.toKey()))
+          continue;
+        this.seenPartialScopeRequests.add(n.toKey()), this.Q.push(n);
+      }
+  }
+};
+function Zn(t, e, n, r) {
+  const s = n.lookup(t.scopeName);
+  if (!s) {
+    if (t.scopeName === e)
+      throw new Error(`No grammar provided for <${e}>`);
+    return;
+  }
+  const i = n.lookup(e);
+  t instanceof Y ? le({ baseGrammar: i, selfGrammar: s }, r) : Ee(
+    t.ruleName,
+    { baseGrammar: i, selfGrammar: s, repository: s.repository },
+    r
+  );
+  const l = n.injections(t.scopeName);
+  if (l)
+    for (const a of l)
+      r.add(new Y(a));
+}
+function Ee(t, e, n) {
+  if (e.repository && e.repository[t]) {
+    const r = e.repository[t];
+    ue([r], e, n);
+  }
+}
+function le(t, e) {
+  t.selfGrammar.patterns && Array.isArray(t.selfGrammar.patterns) && ue(
+    t.selfGrammar.patterns,
+    { ...t, repository: t.selfGrammar.repository },
+    e
+  ), t.selfGrammar.injections && ue(
+    Object.values(t.selfGrammar.injections),
+    { ...t, repository: t.selfGrammar.repository },
+    e
+  );
+}
+function ue(t, e, n) {
+  for (const r of t) {
+    if (n.visitedRule.has(r))
+      continue;
+    n.visitedRule.add(r);
+    const s = r.repository ? Et({}, e.repository, r.repository) : e.repository;
+    Array.isArray(r.patterns) && ue(r.patterns, { ...e, repository: s }, n);
+    const i = r.include;
+    if (!i)
+      continue;
+    const l = Dt(i);
+    switch (l.kind) {
+      case 0:
+        le({ ...e, selfGrammar: e.baseGrammar }, n);
+        break;
+      case 1:
+        le(e, n);
+        break;
+      case 2:
+        Ee(l.ruleName, { ...e, repository: s }, n);
+        break;
+      case 3:
+      case 4:
+        const a = l.scopeName === e.selfGrammar.scopeName ? e.selfGrammar : l.scopeName === e.baseGrammar.scopeName ? e.baseGrammar : void 0;
+        if (a) {
+          const o = { baseGrammar: e.baseGrammar, selfGrammar: a, repository: s };
+          l.kind === 4 ? Ee(l.ruleName, o, n) : le(o, n);
+        } else
+          l.kind === 4 ? n.add(new Yn(l.scopeName, l.ruleName)) : n.add(new Y(l.scopeName));
+        break;
+    }
+  }
+}
+var er = class {
+  kind = 0;
+}, tr = class {
+  kind = 1;
+}, nr = class {
+  constructor(t) {
+    this.ruleName = t;
+  }
+  kind = 2;
+}, rr = class {
+  constructor(t) {
+    this.scopeName = t;
+  }
+  kind = 3;
+}, sr = class {
+  constructor(t, e) {
+    this.scopeName = t, this.ruleName = e;
+  }
+  kind = 4;
+};
+function Dt(t) {
+  if (t === "$base")
+    return new er();
+  if (t === "$self")
+    return new tr();
+  const e = t.indexOf("#");
+  if (e === -1)
+    return new rr(t);
+  if (e === 0)
+    return new nr(t.substring(1));
+  {
+    const n = t.substring(0, e), r = t.substring(e + 1);
+    return new sr(n, r);
+  }
+}
+var ir = /\\(\d+)/, Ze = /\\(\d+)/g, lr = -1, Gt = -2;
+var te = class {
+  $location;
+  id;
+  _nameIsCapturing;
+  _name;
+  _contentNameIsCapturing;
+  _contentName;
+  constructor(t, e, n, r) {
+    this.$location = t, this.id = e, this._name = n || null, this._nameIsCapturing = ne.hasCaptures(this._name), this._contentName = r || null, this._contentNameIsCapturing = ne.hasCaptures(this._contentName);
+  }
+  get debugName() {
+    const t = this.$location ? `${At(this.$location.filename)}:${this.$location.line}` : "unknown";
+    return `${this.constructor.name}#${this.id} @ ${t}`;
+  }
+  getName(t, e) {
+    return !this._nameIsCapturing || this._name === null || t === null || e === null ? this._name : ne.replaceCaptures(this._name, t, e);
+  }
+  getContentName(t, e) {
+    return !this._contentNameIsCapturing || this._contentName === null ? this._contentName : ne.replaceCaptures(this._contentName, t, e);
+  }
+}, or = class extends te {
+  retokenizeCapturedWithRuleId;
+  constructor(t, e, n, r, s) {
+    super(t, e, n, r), this.retokenizeCapturedWithRuleId = s;
+  }
+  dispose() {
+  }
+  collectPatterns(t, e) {
+    throw new Error("Not supported!");
+  }
+  compile(t, e) {
+    throw new Error("Not supported!");
+  }
+  compileAG(t, e, n, r) {
+    throw new Error("Not supported!");
+  }
+}, ar = class extends te {
+  _match;
+  captures;
+  _cachedCompiledPatterns;
+  constructor(t, e, n, r, s) {
+    super(t, e, n, null), this._match = new J(r, this.id), this.captures = s, this._cachedCompiledPatterns = null;
+  }
+  dispose() {
+    this._cachedCompiledPatterns && (this._cachedCompiledPatterns.dispose(), this._cachedCompiledPatterns = null);
+  }
+  get debugMatchRegExp() {
+    return `${this._match.source}`;
+  }
+  collectPatterns(t, e) {
+    e.push(this._match);
+  }
+  compile(t, e) {
+    return this._getCachedCompiledPatterns(t).compile(t);
+  }
+  compileAG(t, e, n, r) {
+    return this._getCachedCompiledPatterns(t).compileAG(t, n, r);
+  }
+  _getCachedCompiledPatterns(t) {
+    return this._cachedCompiledPatterns || (this._cachedCompiledPatterns = new Q(), this.collectPatterns(t, this._cachedCompiledPatterns)), this._cachedCompiledPatterns;
+  }
+}, et = class extends te {
+  hasMissingPatterns;
+  patterns;
+  _cachedCompiledPatterns;
+  constructor(t, e, n, r, s) {
+    super(t, e, n, r), this.patterns = s.patterns, this.hasMissingPatterns = s.hasMissingPatterns, this._cachedCompiledPatterns = null;
+  }
+  dispose() {
+    this._cachedCompiledPatterns && (this._cachedCompiledPatterns.dispose(), this._cachedCompiledPatterns = null);
+  }
+  collectPatterns(t, e) {
+    for (const n of this.patterns)
+      t.getRule(n).collectPatterns(t, e);
+  }
+  compile(t, e) {
+    return this._getCachedCompiledPatterns(t).compile(t);
+  }
+  compileAG(t, e, n, r) {
+    return this._getCachedCompiledPatterns(t).compileAG(t, n, r);
+  }
+  _getCachedCompiledPatterns(t) {
+    return this._cachedCompiledPatterns || (this._cachedCompiledPatterns = new Q(), this.collectPatterns(t, this._cachedCompiledPatterns)), this._cachedCompiledPatterns;
+  }
+}, Ae = class extends te {
+  _begin;
+  beginCaptures;
+  _end;
+  endHasBackReferences;
+  endCaptures;
+  applyEndPatternLast;
+  hasMissingPatterns;
+  patterns;
+  _cachedCompiledPatterns;
+  constructor(t, e, n, r, s, i, l, a, o, u) {
+    super(t, e, n, r), this._begin = new J(s, this.id), this.beginCaptures = i, this._end = new J(l || "￿", -1), this.endHasBackReferences = this._end.hasBackReferences, this.endCaptures = a, this.applyEndPatternLast = o || !1, this.patterns = u.patterns, this.hasMissingPatterns = u.hasMissingPatterns, this._cachedCompiledPatterns = null;
+  }
+  dispose() {
+    this._cachedCompiledPatterns && (this._cachedCompiledPatterns.dispose(), this._cachedCompiledPatterns = null);
+  }
+  get debugBeginRegExp() {
+    return `${this._begin.source}`;
+  }
+  get debugEndRegExp() {
+    return `${this._end.source}`;
+  }
+  getEndWithResolvedBackReferences(t, e) {
+    return this._end.resolveBackReferences(t, e);
+  }
+  collectPatterns(t, e) {
+    e.push(this._begin);
+  }
+  compile(t, e) {
+    return this._getCachedCompiledPatterns(t, e).compile(t);
+  }
+  compileAG(t, e, n, r) {
+    return this._getCachedCompiledPatterns(t, e).compileAG(t, n, r);
+  }
+  _getCachedCompiledPatterns(t, e) {
+    if (!this._cachedCompiledPatterns) {
+      this._cachedCompiledPatterns = new Q();
+      for (const n of this.patterns)
+        t.getRule(n).collectPatterns(t, this._cachedCompiledPatterns);
+      this.applyEndPatternLast ? this._cachedCompiledPatterns.push(this._end.hasBackReferences ? this._end.clone() : this._end) : this._cachedCompiledPatterns.unshift(this._end.hasBackReferences ? this._end.clone() : this._end);
+    }
+    return this._end.hasBackReferences && (this.applyEndPatternLast ? this._cachedCompiledPatterns.setSource(this._cachedCompiledPatterns.length() - 1, e) : this._cachedCompiledPatterns.setSource(0, e)), this._cachedCompiledPatterns;
+  }
+}, ce = class extends te {
+  _begin;
+  beginCaptures;
+  whileCaptures;
+  _while;
+  whileHasBackReferences;
+  hasMissingPatterns;
+  patterns;
+  _cachedCompiledPatterns;
+  _cachedCompiledWhilePatterns;
+  constructor(t, e, n, r, s, i, l, a, o) {
+    super(t, e, n, r), this._begin = new J(s, this.id), this.beginCaptures = i, this.whileCaptures = a, this._while = new J(l, Gt), this.whileHasBackReferences = this._while.hasBackReferences, this.patterns = o.patterns, this.hasMissingPatterns = o.hasMissingPatterns, this._cachedCompiledPatterns = null, this._cachedCompiledWhilePatterns = null;
+  }
+  dispose() {
+    this._cachedCompiledPatterns && (this._cachedCompiledPatterns.dispose(), this._cachedCompiledPatterns = null), this._cachedCompiledWhilePatterns && (this._cachedCompiledWhilePatterns.dispose(), this._cachedCompiledWhilePatterns = null);
+  }
+  get debugBeginRegExp() {
+    return `${this._begin.source}`;
+  }
+  get debugWhileRegExp() {
+    return `${this._while.source}`;
+  }
+  getWhileWithResolvedBackReferences(t, e) {
+    return this._while.resolveBackReferences(t, e);
+  }
+  collectPatterns(t, e) {
+    e.push(this._begin);
+  }
+  compile(t, e) {
+    return this._getCachedCompiledPatterns(t).compile(t);
+  }
+  compileAG(t, e, n, r) {
+    return this._getCachedCompiledPatterns(t).compileAG(t, n, r);
+  }
+  _getCachedCompiledPatterns(t) {
+    if (!this._cachedCompiledPatterns) {
+      this._cachedCompiledPatterns = new Q();
+      for (const e of this.patterns)
+        t.getRule(e).collectPatterns(t, this._cachedCompiledPatterns);
+    }
+    return this._cachedCompiledPatterns;
+  }
+  compileWhile(t, e) {
+    return this._getCachedCompiledWhilePatterns(t, e).compile(t);
+  }
+  compileWhileAG(t, e, n, r) {
+    return this._getCachedCompiledWhilePatterns(t, e).compileAG(t, n, r);
+  }
+  _getCachedCompiledWhilePatterns(t, e) {
+    return this._cachedCompiledWhilePatterns || (this._cachedCompiledWhilePatterns = new Q(), this._cachedCompiledWhilePatterns.push(this._while.hasBackReferences ? this._while.clone() : this._while)), this._while.hasBackReferences && this._cachedCompiledWhilePatterns.setSource(0, e || "￿"), this._cachedCompiledWhilePatterns;
+  }
+}, jt = class x {
+  static createCaptureRule(e, n, r, s, i) {
+    return e.registerRule((l) => new or(n, l, r, s, i));
+  }
+  static getCompiledRuleId(e, n, r) {
+    return e.id || n.registerRule((s) => {
+      if (e.id = s, e.match)
+        return new ar(
+          e.$vscodeTextmateLocation,
+          e.id,
+          e.name,
+          e.match,
+          x._compileCaptures(e.captures, n, r)
+        );
+      if (typeof e.begin > "u") {
+        e.repository && (r = Et({}, r, e.repository));
+        let i = e.patterns;
+        return typeof i > "u" && e.include && (i = [{ include: e.include }]), new et(
+          e.$vscodeTextmateLocation,
+          e.id,
+          e.name,
+          e.contentName,
+          x._compilePatterns(i, n, r)
+        );
+      }
+      return e.while ? new ce(
+        e.$vscodeTextmateLocation,
+        e.id,
+        e.name,
+        e.contentName,
+        e.begin,
+        x._compileCaptures(e.beginCaptures || e.captures, n, r),
+        e.while,
+        x._compileCaptures(e.whileCaptures || e.captures, n, r),
+        x._compilePatterns(e.patterns, n, r)
+      ) : new Ae(
+        e.$vscodeTextmateLocation,
+        e.id,
+        e.name,
+        e.contentName,
+        e.begin,
+        x._compileCaptures(e.beginCaptures || e.captures, n, r),
+        e.end,
+        x._compileCaptures(e.endCaptures || e.captures, n, r),
+        e.applyEndPatternLast,
+        x._compilePatterns(e.patterns, n, r)
+      );
+    }), e.id;
+  }
+  static _compileCaptures(e, n, r) {
+    let s = [];
+    if (e) {
+      let i = 0;
+      for (const l in e) {
+        if (l === "$vscodeTextmateLocation")
+          continue;
+        const a = parseInt(l, 10);
+        a > i && (i = a);
+      }
+      for (let l = 0; l <= i; l++)
+        s[l] = null;
+      for (const l in e) {
+        if (l === "$vscodeTextmateLocation")
+          continue;
+        const a = parseInt(l, 10);
+        let o = 0;
+        e[l].patterns && (o = x.getCompiledRuleId(e[l], n, r)), s[a] = x.createCaptureRule(n, e[l].$vscodeTextmateLocation, e[l].name, e[l].contentName, o);
+      }
+    }
+    return s;
+  }
+  static _compilePatterns(e, n, r) {
+    let s = [];
+    if (e)
+      for (let i = 0, l = e.length; i < l; i++) {
+        const a = e[i];
+        let o = -1;
+        if (a.include) {
+          const u = Dt(a.include);
+          switch (u.kind) {
+            case 0:
+            case 1:
+              o = x.getCompiledRuleId(r[a.include], n, r);
+              break;
+            case 2:
+              let h = r[u.ruleName];
+              h && (o = x.getCompiledRuleId(h, n, r));
+              break;
+            case 3:
+            case 4:
+              const p = u.scopeName, _ = u.kind === 4 ? u.ruleName : null, f = n.getExternalGrammar(p, r);
+              if (f)
+                if (_) {
+                  let d = f.repository[_];
+                  d && (o = x.getCompiledRuleId(d, n, f.repository));
+                } else
+                  o = x.getCompiledRuleId(f.repository.$self, n, f.repository);
+              break;
+          }
+        } else
+          o = x.getCompiledRuleId(a, n, r);
+        if (o !== -1) {
+          const u = n.getRule(o);
+          let h = !1;
+          if ((u instanceof et || u instanceof Ae || u instanceof ce) && u.hasMissingPatterns && u.patterns.length === 0 && (h = !0), h)
+            continue;
+          s.push(o);
+        }
+      }
+    return {
+      patterns: s,
+      hasMissingPatterns: (e ? e.length : 0) !== s.length
+    };
+  }
+}, J = class Bt {
+  source;
+  ruleId;
+  hasAnchor;
+  hasBackReferences;
+  _anchorCache;
+  constructor(e, n) {
+    if (e && typeof e == "string") {
+      const r = e.length;
+      let s = 0, i = [], l = !1;
+      for (let a = 0; a < r; a++)
+        if (e.charAt(a) === "\\" && a + 1 < r) {
+          const u = e.charAt(a + 1);
+          u === "z" ? (i.push(e.substring(s, a)), i.push("$(?!\\n)(?<!\\n)"), s = a + 2) : (u === "A" || u === "G") && (l = !0), a++;
+        }
+      this.hasAnchor = l, s === 0 ? this.source = e : (i.push(e.substring(s, r)), this.source = i.join(""));
+    } else
+      this.hasAnchor = !1, this.source = e;
+    this.hasAnchor ? this._anchorCache = this._buildAnchorCache() : this._anchorCache = null, this.ruleId = n, typeof this.source == "string" ? this.hasBackReferences = ir.test(this.source) : this.hasBackReferences = !1;
+  }
+  clone() {
+    return new Bt(this.source, this.ruleId);
+  }
+  setSource(e) {
+    this.source !== e && (this.source = e, this.hasAnchor && (this._anchorCache = this._buildAnchorCache()));
+  }
+  resolveBackReferences(e, n) {
+    if (typeof this.source != "string")
+      throw new Error("This method should only be called if the source is a string");
+    let r = n.map((s) => e.substring(s.start, s.end));
+    return Ze.lastIndex = 0, this.source.replace(Ze, (s, i) => It(r[parseInt(i, 10)] || ""));
+  }
+  _buildAnchorCache() {
+    if (typeof this.source != "string")
+      throw new Error("This method should only be called if the source is a string");
+    let e = [], n = [], r = [], s = [], i, l, a, o;
+    for (i = 0, l = this.source.length; i < l; i++)
+      a = this.source.charAt(i), e[i] = a, n[i] = a, r[i] = a, s[i] = a, a === "\\" && i + 1 < l && (o = this.source.charAt(i + 1), o === "A" ? (e[i + 1] = "￿", n[i + 1] = "￿", r[i + 1] = "A", s[i + 1] = "A") : o === "G" ? (e[i + 1] = "￿", n[i + 1] = "G", r[i + 1] = "￿", s[i + 1] = "G") : (e[i + 1] = o, n[i + 1] = o, r[i + 1] = o, s[i + 1] = o), i++);
+    return {
+      A0_G0: e.join(""),
+      A0_G1: n.join(""),
+      A1_G0: r.join(""),
+      A1_G1: s.join("")
+    };
+  }
+  resolveAnchors(e, n) {
+    return !this.hasAnchor || !this._anchorCache || typeof this.source != "string" ? this.source : e ? n ? this._anchorCache.A1_G1 : this._anchorCache.A1_G0 : n ? this._anchorCache.A0_G1 : this._anchorCache.A0_G0;
+  }
+}, Q = class {
+  _items;
+  _hasAnchors;
+  _cached;
+  _anchorCache;
+  constructor() {
+    this._items = [], this._hasAnchors = !1, this._cached = null, this._anchorCache = {
+      A0_G0: null,
+      A0_G1: null,
+      A1_G0: null,
+      A1_G1: null
+    };
+  }
+  dispose() {
+    this._disposeCaches();
+  }
+  _disposeCaches() {
+    this._cached && (this._cached.dispose(), this._cached = null), this._anchorCache.A0_G0 && (this._anchorCache.A0_G0.dispose(), this._anchorCache.A0_G0 = null), this._anchorCache.A0_G1 && (this._anchorCache.A0_G1.dispose(), this._anchorCache.A0_G1 = null), this._anchorCache.A1_G0 && (this._anchorCache.A1_G0.dispose(), this._anchorCache.A1_G0 = null), this._anchorCache.A1_G1 && (this._anchorCache.A1_G1.dispose(), this._anchorCache.A1_G1 = null);
+  }
+  push(t) {
+    this._items.push(t), this._hasAnchors = this._hasAnchors || t.hasAnchor;
+  }
+  unshift(t) {
+    this._items.unshift(t), this._hasAnchors = this._hasAnchors || t.hasAnchor;
+  }
+  length() {
+    return this._items.length;
+  }
+  setSource(t, e) {
+    this._items[t].source !== e && (this._disposeCaches(), this._items[t].setSource(e));
+  }
+  compile(t) {
+    if (!this._cached) {
+      let e = this._items.map((n) => n.source);
+      this._cached = new tt(t, e, this._items.map((n) => n.ruleId));
+    }
+    return this._cached;
+  }
+  compileAG(t, e, n) {
+    return this._hasAnchors ? e ? n ? (this._anchorCache.A1_G1 || (this._anchorCache.A1_G1 = this._resolveAnchors(t, e, n)), this._anchorCache.A1_G1) : (this._anchorCache.A1_G0 || (this._anchorCache.A1_G0 = this._resolveAnchors(t, e, n)), this._anchorCache.A1_G0) : n ? (this._anchorCache.A0_G1 || (this._anchorCache.A0_G1 = this._resolveAnchors(t, e, n)), this._anchorCache.A0_G1) : (this._anchorCache.A0_G0 || (this._anchorCache.A0_G0 = this._resolveAnchors(t, e, n)), this._anchorCache.A0_G0) : this.compile(t);
+  }
+  _resolveAnchors(t, e, n) {
+    let r = this._items.map((s) => s.resolveAnchors(e, n));
+    return new tt(t, r, this._items.map((s) => s.ruleId));
+  }
+}, tt = class {
+  constructor(t, e, n) {
+    this.regExps = e, this.rules = n, this.scanner = t.createOnigScanner(e);
+  }
+  scanner;
+  dispose() {
+    typeof this.scanner.dispose == "function" && this.scanner.dispose();
+  }
+  toString() {
+    const t = [];
+    for (let e = 0, n = this.rules.length; e < n; e++)
+      t.push("   - " + this.rules[e] + ": " + this.regExps[e]);
+    return t.join(`
+`);
+  }
+  findNextMatchSync(t, e, n) {
+    const r = this.scanner.findNextMatchSync(t, e, n);
+    return r ? {
+      ruleId: this.rules[r.index],
+      captureIndices: r.captureIndices
+    } : null;
+  }
+}, ye = class {
+  constructor(t, e) {
+    this.languageId = t, this.tokenType = e;
+  }
+}, ur = class Ne {
+  _defaultAttributes;
+  _embeddedLanguagesMatcher;
+  constructor(e, n) {
+    this._defaultAttributes = new ye(
+      e,
+      8
+      /* NotSet */
+    ), this._embeddedLanguagesMatcher = new cr(Object.entries(n || {}));
+  }
+  getDefaultAttributes() {
+    return this._defaultAttributes;
+  }
+  getBasicScopeAttributes(e) {
+    return e === null ? Ne._NULL_SCOPE_METADATA : this._getBasicScopeAttributes.get(e);
+  }
+  static _NULL_SCOPE_METADATA = new ye(0, 0);
+  _getBasicScopeAttributes = new Lt((e) => {
+    const n = this._scopeToLanguage(e), r = this._toStandardTokenType(e);
+    return new ye(n, r);
+  });
+  /**
+   * Given a produced TM scope, return the language that token describes or null if unknown.
+   * e.g. source.html => html, source.css.embedded.html => css, punctuation.definition.tag.html => null
+   */
+  _scopeToLanguage(e) {
+    return this._embeddedLanguagesMatcher.match(e) || 0;
+  }
+  _toStandardTokenType(e) {
+    const n = e.match(Ne.STANDARD_TOKEN_TYPE_REGEXP);
+    if (!n)
+      return 8;
+    switch (n[1]) {
+      case "comment":
+        return 1;
+      case "string":
+        return 2;
+      case "regex":
+        return 3;
+      case "meta.embedded":
+        return 0;
+    }
+    throw new Error("Unexpected match for standard token type!");
+  }
+  static STANDARD_TOKEN_TYPE_REGEXP = /\b(comment|string|regex|meta\.embedded)\b/;
+}, cr = class {
+  values;
+  scopesRegExp;
+  constructor(t) {
+    if (t.length === 0)
+      this.values = null, this.scopesRegExp = null;
+    else {
+      this.values = new Map(t);
+      const e = t.map(
+        ([n, r]) => It(n)
+      );
+      e.sort(), e.reverse(), this.scopesRegExp = new RegExp(
+        `^((${e.join(")|(")}))($|\\.)`,
+        ""
+      );
+    }
+  }
+  match(t) {
+    if (!this.scopesRegExp)
+      return;
+    const e = t.match(this.scopesRegExp);
+    if (e)
+      return this.values.get(e[1]);
+  }
+};
+typeof process < "u" && process.env.VSCODE_TEXTMATE_DEBUG;
+var nt = class {
+  constructor(t, e) {
+    this.stack = t, this.stoppedEarly = e;
+  }
+};
+function Ft(t, e, n, r, s, i, l, a) {
+  const o = e.content.length;
+  let u = !1, h = -1;
+  if (l) {
+    const f = hr(
+      t,
+      e,
+      n,
+      r,
+      s,
+      i
+    );
+    s = f.stack, r = f.linePos, n = f.isFirstLine, h = f.anchorPosition;
+  }
+  const p = Date.now();
+  for (; !u; ) {
+    if (a !== 0 && Date.now() - p > a)
+      return new nt(s, !0);
+    _();
+  }
+  return new nt(s, !1);
+  function _() {
+    const f = pr(
+      t,
+      e,
+      n,
+      r,
+      s,
+      h
+    );
+    if (!f) {
+      i.produce(s, o), u = !0;
+      return;
+    }
+    const d = f.captureIndices, N = f.matchedRuleId, y = d && d.length > 0 ? d[0].end > r : !1;
+    if (N === lr) {
+      const v = s.getRule(t);
+      i.produce(s, d[0].start), s = s.withContentNameScopesList(s.nameScopesList), X(
+        t,
+        e,
+        n,
+        s,
+        i,
+        v.endCaptures,
+        d
+      ), i.produce(s, d[0].end);
+      const R = s;
+      if (s = s.parent, h = R.getAnchorPos(), !y && R.getEnterPos() === r) {
+        s = R, i.produce(s, o), u = !0;
+        return;
+      }
+    } else {
+      const v = t.getRule(N);
+      i.produce(s, d[0].start);
+      const R = s, k = v.getName(e.content, d), M = s.contentNameScopesList.pushAttributed(
+        k,
+        t
+      );
+      if (s = s.push(
+        N,
+        r,
+        h,
+        d[0].end === o,
+        null,
+        M,
+        M
+      ), v instanceof Ae) {
+        const P = v;
+        X(
+          t,
+          e,
+          n,
+          s,
+          i,
+          P.beginCaptures,
+          d
+        ), i.produce(s, d[0].end), h = d[0].end;
+        const j = P.getContentName(
+          e.content,
+          d
+        ), B = M.pushAttributed(
+          j,
+          t
+        );
+        if (s = s.withContentNameScopesList(B), P.endHasBackReferences && (s = s.withEndRule(
+          P.getEndWithResolvedBackReferences(
+            e.content,
+            d
+          )
+        )), !y && R.hasSameRuleAs(s)) {
+          s = s.pop(), i.produce(s, o), u = !0;
+          return;
+        }
+      } else if (v instanceof ce) {
+        const P = v;
+        X(
+          t,
+          e,
+          n,
+          s,
+          i,
+          P.beginCaptures,
+          d
+        ), i.produce(s, d[0].end), h = d[0].end;
+        const j = P.getContentName(
+          e.content,
+          d
+        ), B = M.pushAttributed(
+          j,
+          t
+        );
+        if (s = s.withContentNameScopesList(B), P.whileHasBackReferences && (s = s.withEndRule(
+          P.getWhileWithResolvedBackReferences(
+            e.content,
+            d
+          )
+        )), !y && R.hasSameRuleAs(s)) {
+          s = s.pop(), i.produce(s, o), u = !0;
+          return;
+        }
+      } else if (X(
+        t,
+        e,
+        n,
+        s,
+        i,
+        v.captures,
+        d
+      ), i.produce(s, d[0].end), s = s.pop(), !y) {
+        s = s.safePop(), i.produce(s, o), u = !0;
+        return;
+      }
+    }
+    d[0].end > r && (r = d[0].end, n = !1);
+  }
+}
+function hr(t, e, n, r, s, i) {
+  let l = s.beginRuleCapturedEOL ? 0 : -1;
+  const a = [];
+  for (let o = s; o; o = o.pop()) {
+    const u = o.getRule(t);
+    u instanceof ce && a.push({
+      rule: u,
+      stack: o
+    });
+  }
+  for (let o = a.pop(); o; o = a.pop()) {
+    const { ruleScanner: u, findOptions: h } = mr(o.rule, t, o.stack.endRule, n, r === l), p = u.findNextMatchSync(e, r, h);
+    if (p) {
+      if (p.ruleId !== Gt) {
+        s = o.stack.pop();
+        break;
+      }
+      p.captureIndices && p.captureIndices.length && (i.produce(o.stack, p.captureIndices[0].start), X(t, e, n, o.stack, i, o.rule.whileCaptures, p.captureIndices), i.produce(o.stack, p.captureIndices[0].end), l = p.captureIndices[0].end, p.captureIndices[0].end > r && (r = p.captureIndices[0].end, n = !1));
+    } else {
+      s = o.stack.pop();
+      break;
+    }
+  }
+  return { stack: s, linePos: r, anchorPosition: l, isFirstLine: n };
+}
+function pr(t, e, n, r, s, i) {
+  const l = dr(t, e, n, r, s, i), a = t.getInjections();
+  if (a.length === 0)
+    return l;
+  const o = fr(a, t, e, n, r, s, i);
+  if (!o)
+    return l;
+  if (!l)
+    return o;
+  const u = l.captureIndices[0].start, h = o.captureIndices[0].start;
+  return h < u || o.priorityMatch && h === u ? o : l;
+}
+function dr(t, e, n, r, s, i) {
+  const l = s.getRule(t), { ruleScanner: a, findOptions: o } = $t(l, t, s.endRule, n, r === i), u = a.findNextMatchSync(e, r, o);
+  return u ? {
+    captureIndices: u.captureIndices,
+    matchedRuleId: u.ruleId
+  } : null;
+}
+function fr(t, e, n, r, s, i, l) {
+  let a = Number.MAX_VALUE, o = null, u, h = 0;
+  const p = i.contentNameScopesList.getScopeNames();
+  for (let _ = 0, f = t.length; _ < f; _++) {
+    const d = t[_];
+    if (!d.matcher(p))
+      continue;
+    const N = e.getRule(d.ruleId), { ruleScanner: y, findOptions: v } = $t(N, e, null, r, s === l), R = y.findNextMatchSync(n, s, v);
+    if (!R)
+      continue;
+    const k = R.captureIndices[0].start;
+    if (!(k >= a) && (a = k, o = R.captureIndices, u = R.ruleId, h = d.priority, a === s))
+      break;
+  }
+  return o ? {
+    priorityMatch: h === -1,
+    captureIndices: o,
+    matchedRuleId: u
+  } : null;
+}
+function $t(t, e, n, r, s) {
+  return {
+    ruleScanner: t.compileAG(e, n, r, s),
+    findOptions: 0
+    /* None */
+  };
+}
+function mr(t, e, n, r, s) {
+  return {
+    ruleScanner: t.compileWhileAG(e, n, r, s),
+    findOptions: 0
+    /* None */
+  };
+}
+function X(t, e, n, r, s, i, l) {
+  if (i.length === 0)
+    return;
+  const a = e.content, o = Math.min(i.length, l.length), u = [], h = l[0].end;
+  for (let p = 0; p < o; p++) {
+    const _ = i[p];
+    if (_ === null)
+      continue;
+    const f = l[p];
+    if (f.length === 0)
+      continue;
+    if (f.start > h)
+      break;
+    for (; u.length > 0 && u[u.length - 1].endPos <= f.start; )
+      s.produceFromScopes(u[u.length - 1].scopes, u[u.length - 1].endPos), u.pop();
+    if (u.length > 0 ? s.produceFromScopes(u[u.length - 1].scopes, f.start) : s.produce(r, f.start), _.retokenizeCapturedWithRuleId) {
+      const N = _.getName(a, l), y = r.contentNameScopesList.pushAttributed(N, t), v = _.getContentName(a, l), R = y.pushAttributed(v, t), k = r.push(_.retokenizeCapturedWithRuleId, f.start, -1, !1, null, y, R), M = t.createOnigString(a.substring(0, f.end));
+      Ft(
+        t,
+        M,
+        n && f.start === 0,
+        f.start,
+        k,
+        s,
+        !1,
+        /* no time limit */
+        0
+      ), Ot(M);
+      continue;
+    }
+    const d = _.getName(a, l);
+    if (d !== null) {
+      const y = (u.length > 0 ? u[u.length - 1].scopes : r.contentNameScopesList).pushAttributed(d, t);
+      u.push(new gr(y, f.end));
+    }
+  }
+  for (; u.length > 0; )
+    s.produceFromScopes(u[u.length - 1].scopes, u[u.length - 1].endPos), u.pop();
+}
+var gr = class {
+  scopes;
+  endPos;
+  constructor(t, e) {
+    this.scopes = t, this.endPos = e;
+  }
+};
+function yr(t, e, n, r, s, i, l, a) {
+  return new Cr(
+    t,
+    e,
+    n,
+    r,
+    s,
+    i,
+    l,
+    a
+  );
+}
+function rt(t, e, n, r, s) {
+  const i = ae(e, he), l = jt.getCompiledRuleId(n, r, s.repository);
+  for (const a of i)
+    t.push({
+      debugSelector: e,
+      matcher: a.matcher,
+      ruleId: l,
+      grammar: s,
+      priority: a.priority
+    });
+}
+function he(t, e) {
+  if (e.length < t.length)
+    return !1;
+  let n = 0;
+  return t.every((r) => {
+    for (let s = n; s < e.length; s++)
+      if (_r(e[s], r))
+        return n = s + 1, !0;
+    return !1;
+  });
+}
+function _r(t, e) {
+  if (!t)
+    return !1;
+  if (t === e)
+    return !0;
+  const n = e.length;
+  return t.length > n && t.substr(0, n) === e && t[n] === ".";
+}
+var Cr = class {
+  constructor(t, e, n, r, s, i, l, a) {
+    if (this._rootScopeName = t, this.balancedBracketSelectors = i, this._onigLib = a, this._basicScopeAttributesProvider = new ur(
+      n,
+      r
+    ), this._rootId = -1, this._lastRuleId = 0, this._ruleId2desc = [null], this._includedGrammars = {}, this._grammarRepository = l, this._grammar = st(e, null), this._injections = null, this._tokenTypeMatchers = [], s)
+      for (const o of Object.keys(s)) {
+        const u = ae(o, he);
+        for (const h of u)
+          this._tokenTypeMatchers.push({
+            matcher: h.matcher,
+            type: s[o]
+          });
+      }
+  }
+  _rootId;
+  _lastRuleId;
+  _ruleId2desc;
+  _includedGrammars;
+  _grammarRepository;
+  _grammar;
+  _injections;
+  _basicScopeAttributesProvider;
+  _tokenTypeMatchers;
+  get themeProvider() {
+    return this._grammarRepository;
+  }
+  dispose() {
+    for (const t of this._ruleId2desc)
+      t && t.dispose();
+  }
+  createOnigScanner(t) {
+    return this._onigLib.createOnigScanner(t);
+  }
+  createOnigString(t) {
+    return this._onigLib.createOnigString(t);
+  }
+  getMetadataForScope(t) {
+    return this._basicScopeAttributesProvider.getBasicScopeAttributes(t);
+  }
+  _collectInjections() {
+    const t = {
+      lookup: (s) => s === this._rootScopeName ? this._grammar : this.getExternalGrammar(s),
+      injections: (s) => this._grammarRepository.injections(s)
+    }, e = [], n = this._rootScopeName, r = t.lookup(n);
+    if (r) {
+      const s = r.injections;
+      if (s)
+        for (let l in s)
+          rt(
+            e,
+            l,
+            s[l],
+            this,
+            r
+          );
+      const i = this._grammarRepository.injections(n);
+      i && i.forEach((l) => {
+        const a = this.getExternalGrammar(l);
+        if (a) {
+          const o = a.injectionSelector;
+          o && rt(
+            e,
+            o,
+            a,
+            this,
+            a
+          );
+        }
+      });
+    }
+    return e.sort((s, i) => s.priority - i.priority), e;
+  }
+  getInjections() {
+    return this._injections === null && (this._injections = this._collectInjections()), this._injections;
+  }
+  registerRule(t) {
+    const e = ++this._lastRuleId, n = t(e);
+    return this._ruleId2desc[e] = n, n;
+  }
+  getRule(t) {
+    return this._ruleId2desc[t];
+  }
+  getExternalGrammar(t, e) {
+    if (this._includedGrammars[t])
+      return this._includedGrammars[t];
+    if (this._grammarRepository) {
+      const n = this._grammarRepository.lookup(t);
+      if (n)
+        return this._includedGrammars[t] = st(
+          n,
+          e && e.$base
+        ), this._includedGrammars[t];
+    }
+  }
+  tokenizeLine(t, e, n = 0) {
+    const r = this._tokenize(t, e, !1, n);
+    return {
+      tokens: r.lineTokens.getResult(r.ruleStack, r.lineLength),
+      ruleStack: r.ruleStack,
+      stoppedEarly: r.stoppedEarly
+    };
+  }
+  tokenizeLine2(t, e, n = 0) {
+    const r = this._tokenize(t, e, !0, n);
+    return {
+      tokens: r.lineTokens.getBinaryResult(r.ruleStack, r.lineLength),
+      ruleStack: r.ruleStack,
+      stoppedEarly: r.stoppedEarly
+    };
+  }
+  _tokenize(t, e, n, r) {
+    this._rootId === -1 && (this._rootId = jt.getCompiledRuleId(
+      this._grammar.repository.$self,
+      this,
+      this._grammar.repository
+    ), this.getInjections());
+    let s;
+    if (!e || e === Pe.NULL) {
+      s = !0;
+      const u = this._basicScopeAttributesProvider.getDefaultAttributes(), h = this.themeProvider.getDefaults(), p = oe.set(
+        0,
+        u.languageId,
+        u.tokenType,
+        null,
+        h.fontStyle,
+        h.foregroundId,
+        h.backgroundId
+      ), _ = this.getRule(this._rootId).getName(
+        null,
+        null
+      );
+      let f;
+      _ ? f = K.createRootAndLookUpScopeName(
+        _,
+        p,
+        this
+      ) : f = K.createRoot(
+        "unknown",
+        p
+      ), e = new Pe(
+        null,
+        this._rootId,
+        -1,
+        -1,
+        !1,
+        null,
+        f,
+        f
+      );
+    } else
+      s = !1, e.reset();
+    t = t + `
+`;
+    const i = this.createOnigString(t), l = i.content.length, a = new br(
+      n,
+      t,
+      this._tokenTypeMatchers,
+      this.balancedBracketSelectors
+    ), o = Ft(
+      this,
+      i,
+      s,
+      0,
+      e,
+      a,
+      !0,
+      r
+    );
+    return Ot(i), {
+      lineLength: l,
+      lineTokens: a,
+      ruleStack: o.stack,
+      stoppedEarly: o.stoppedEarly
+    };
+  }
+};
+function st(t, e) {
+  return t = Gn(t), t.repository = t.repository || {}, t.repository.$self = {
+    $vscodeTextmateLocation: t.$vscodeTextmateLocation,
+    patterns: t.patterns,
+    name: t.scopeName
+  }, t.repository.$base = e || t.repository.$self, t;
+}
+var K = class O {
+  /**
+   * Invariant:
+   * ```
+   * if (parent && !scopePath.extends(parent.scopePath)) {
+   * 	throw new Error();
+   * }
+   * ```
+   */
+  constructor(e, n, r) {
+    this.parent = e, this.scopePath = n, this.tokenAttributes = r;
+  }
+  static fromExtension(e, n) {
+    let r = e, s = e?.scopePath ?? null;
+    for (const i of n)
+      s = ge.push(s, i.scopeNames), r = new O(r, s, i.encodedTokenAttributes);
+    return r;
+  }
+  static createRoot(e, n) {
+    return new O(null, new ge(null, e), n);
+  }
+  static createRootAndLookUpScopeName(e, n, r) {
+    const s = r.getMetadataForScope(e), i = new ge(null, e), l = r.themeProvider.themeMatch(i), a = O.mergeAttributes(
+      n,
+      s,
+      l
+    );
+    return new O(null, i, a);
+  }
+  get scopeName() {
+    return this.scopePath.scopeName;
+  }
+  toString() {
+    return this.getScopeNames().join(" ");
+  }
+  equals(e) {
+    return O.equals(this, e);
+  }
+  static equals(e, n) {
+    do {
+      if (e === n || !e && !n)
+        return !0;
+      if (!e || !n || e.scopeName !== n.scopeName || e.tokenAttributes !== n.tokenAttributes)
+        return !1;
+      e = e.parent, n = n.parent;
+    } while (!0);
+  }
+  static mergeAttributes(e, n, r) {
+    let s = -1, i = 0, l = 0;
+    return r !== null && (s = r.fontStyle, i = r.foregroundId, l = r.backgroundId), oe.set(
+      e,
+      n.languageId,
+      n.tokenType,
+      null,
+      s,
+      i,
+      l
+    );
+  }
+  pushAttributed(e, n) {
+    if (e === null)
+      return this;
+    if (e.indexOf(" ") === -1)
+      return O._pushAttributed(this, e, n);
+    const r = e.split(/ /g);
+    let s = this;
+    for (const i of r)
+      s = O._pushAttributed(s, i, n);
+    return s;
+  }
+  static _pushAttributed(e, n, r) {
+    const s = r.getMetadataForScope(n), i = e.scopePath.push(n), l = r.themeProvider.themeMatch(i), a = O.mergeAttributes(
+      e.tokenAttributes,
+      s,
+      l
+    );
+    return new O(e, i, a);
+  }
+  getScopeNames() {
+    return this.scopePath.getSegments();
+  }
+  getExtensionIfDefined(e) {
+    const n = [];
+    let r = this;
+    for (; r && r !== e; )
+      n.push({
+        encodedTokenAttributes: r.tokenAttributes,
+        scopeNames: r.scopePath.getExtensionIfDefined(r.parent?.scopePath ?? null)
+      }), r = r.parent;
+    return r === e ? n.reverse() : void 0;
+  }
+}, Pe = class D {
+  /**
+   * Invariant:
+   * ```
+   * if (contentNameScopesList !== nameScopesList && contentNameScopesList?.parent !== nameScopesList) {
+   * 	throw new Error();
+   * }
+   * if (this.parent && !nameScopesList.extends(this.parent.contentNameScopesList)) {
+   * 	throw new Error();
+   * }
+   * ```
+   */
+  constructor(e, n, r, s, i, l, a, o) {
+    this.parent = e, this.ruleId = n, this.beginRuleCapturedEOL = i, this.endRule = l, this.nameScopesList = a, this.contentNameScopesList = o, this.depth = this.parent ? this.parent.depth + 1 : 1, this._enterPos = r, this._anchorPos = s;
+  }
+  _stackElementBrand = void 0;
+  // TODO remove me
+  static NULL = new D(
+    null,
+    0,
+    0,
+    0,
+    !1,
+    null,
+    null,
+    null
+  );
+  /**
+   * The position on the current line where this state was pushed.
+   * This is relevant only while tokenizing a line, to detect endless loops.
+   * Its value is meaningless across lines.
+   */
+  _enterPos;
+  /**
+   * The captured anchor position when this stack element was pushed.
+   * This is relevant only while tokenizing a line, to restore the anchor position when popping.
+   * Its value is meaningless across lines.
+   */
+  _anchorPos;
+  /**
+   * The depth of the stack.
+   */
+  depth;
+  equals(e) {
+    return e === null ? !1 : D._equals(this, e);
+  }
+  static _equals(e, n) {
+    return e === n ? !0 : this._structuralEquals(e, n) ? K.equals(e.contentNameScopesList, n.contentNameScopesList) : !1;
+  }
+  /**
+   * A structural equals check. Does not take into account `scopes`.
+   */
+  static _structuralEquals(e, n) {
+    do {
+      if (e === n || !e && !n)
+        return !0;
+      if (!e || !n || e.depth !== n.depth || e.ruleId !== n.ruleId || e.endRule !== n.endRule)
+        return !1;
+      e = e.parent, n = n.parent;
+    } while (!0);
+  }
+  clone() {
+    return this;
+  }
+  static _reset(e) {
+    for (; e; )
+      e._enterPos = -1, e._anchorPos = -1, e = e.parent;
+  }
+  reset() {
+    D._reset(this);
+  }
+  pop() {
+    return this.parent;
+  }
+  safePop() {
+    return this.parent ? this.parent : this;
+  }
+  push(e, n, r, s, i, l, a) {
+    return new D(
+      this,
+      e,
+      n,
+      r,
+      s,
+      i,
+      l,
+      a
+    );
+  }
+  getEnterPos() {
+    return this._enterPos;
+  }
+  getAnchorPos() {
+    return this._anchorPos;
+  }
+  getRule(e) {
+    return e.getRule(this.ruleId);
+  }
+  toString() {
+    const e = [];
+    return this._writeString(e, 0), "[" + e.join(",") + "]";
+  }
+  _writeString(e, n) {
+    return this.parent && (n = this.parent._writeString(e, n)), e[n++] = `(${this.ruleId}, ${this.nameScopesList?.toString()}, ${this.contentNameScopesList?.toString()})`, n;
+  }
+  withContentNameScopesList(e) {
+    return this.contentNameScopesList === e ? this : this.parent.push(
+      this.ruleId,
+      this._enterPos,
+      this._anchorPos,
+      this.beginRuleCapturedEOL,
+      this.endRule,
+      this.nameScopesList,
+      e
+    );
+  }
+  withEndRule(e) {
+    return this.endRule === e ? this : new D(
+      this.parent,
+      this.ruleId,
+      this._enterPos,
+      this._anchorPos,
+      this.beginRuleCapturedEOL,
+      e,
+      this.nameScopesList,
+      this.contentNameScopesList
+    );
+  }
+  // Used to warn of endless loops
+  hasSameRuleAs(e) {
+    let n = this;
+    for (; n && n._enterPos === e._enterPos; ) {
+      if (n.ruleId === e.ruleId)
+        return !0;
+      n = n.parent;
+    }
+    return !1;
+  }
+  toStateStackFrame() {
+    return {
+      ruleId: this.ruleId,
+      beginRuleCapturedEOL: this.beginRuleCapturedEOL,
+      endRule: this.endRule,
+      nameScopesList: this.nameScopesList?.getExtensionIfDefined(this.parent?.nameScopesList ?? null) ?? [],
+      contentNameScopesList: this.contentNameScopesList?.getExtensionIfDefined(this.nameScopesList) ?? []
+    };
+  }
+  static pushFrame(e, n) {
+    const r = K.fromExtension(e?.nameScopesList ?? null, n.nameScopesList);
+    return new D(
+      e,
+      n.ruleId,
+      n.enterPos ?? -1,
+      n.anchorPos ?? -1,
+      n.beginRuleCapturedEOL,
+      n.endRule,
+      r,
+      K.fromExtension(r, n.contentNameScopesList)
+    );
+  }
+}, Sr = class {
+  balancedBracketScopes;
+  unbalancedBracketScopes;
+  allowAny = !1;
+  constructor(t, e) {
+    this.balancedBracketScopes = t.flatMap(
+      (n) => n === "*" ? (this.allowAny = !0, []) : ae(n, he).map((r) => r.matcher)
+    ), this.unbalancedBracketScopes = e.flatMap(
+      (n) => ae(n, he).map((r) => r.matcher)
+    );
+  }
+  get matchesAlways() {
+    return this.allowAny && this.unbalancedBracketScopes.length === 0;
+  }
+  get matchesNever() {
+    return this.balancedBracketScopes.length === 0 && !this.allowAny;
+  }
+  match(t) {
+    for (const e of this.unbalancedBracketScopes)
+      if (e(t))
+        return !1;
+    for (const e of this.balancedBracketScopes)
+      if (e(t))
+        return !0;
+    return this.allowAny;
+  }
+}, br = class {
+  constructor(t, e, n, r) {
+    this.balancedBracketSelectors = r, this._emitBinaryTokens = t, this._tokenTypeOverrides = n, this._lineText = null, this._tokens = [], this._binaryTokens = [], this._lastTokenEndIndex = 0;
+  }
+  _emitBinaryTokens;
+  /**
+   * defined only if `false`.
+   */
+  _lineText;
+  /**
+   * used only if `_emitBinaryTokens` is false.
+   */
+  _tokens;
+  /**
+   * used only if `_emitBinaryTokens` is true.
+   */
+  _binaryTokens;
+  _lastTokenEndIndex;
+  _tokenTypeOverrides;
+  produce(t, e) {
+    this.produceFromScopes(t.contentNameScopesList, e);
+  }
+  produceFromScopes(t, e) {
+    if (this._lastTokenEndIndex >= e)
+      return;
+    if (this._emitBinaryTokens) {
+      let r = t?.tokenAttributes ?? 0, s = !1;
+      if (this.balancedBracketSelectors?.matchesAlways && (s = !0), this._tokenTypeOverrides.length > 0 || this.balancedBracketSelectors && !this.balancedBracketSelectors.matchesAlways && !this.balancedBracketSelectors.matchesNever) {
+        const i = t?.getScopeNames() ?? [];
+        for (const l of this._tokenTypeOverrides)
+          l.matcher(i) && (r = oe.set(
+            r,
+            0,
+            l.type,
+            null,
+            -1,
+            0,
+            0
+          ));
+        this.balancedBracketSelectors && (s = this.balancedBracketSelectors.match(i));
+      }
+      if (s && (r = oe.set(
+        r,
+        0,
+        8,
+        s,
+        -1,
+        0,
+        0
+      )), this._binaryTokens.length > 0 && this._binaryTokens[this._binaryTokens.length - 1] === r) {
+        this._lastTokenEndIndex = e;
+        return;
+      }
+      this._binaryTokens.push(this._lastTokenEndIndex), this._binaryTokens.push(r), this._lastTokenEndIndex = e;
+      return;
+    }
+    const n = t?.getScopeNames() ?? [];
+    this._tokens.push({
+      startIndex: this._lastTokenEndIndex,
+      endIndex: e,
+      // value: lineText.substring(lastTokenEndIndex, endIndex),
+      scopes: n
+    }), this._lastTokenEndIndex = e;
+  }
+  getResult(t, e) {
+    return this._tokens.length > 0 && this._tokens[this._tokens.length - 1].startIndex === e - 1 && this._tokens.pop(), this._tokens.length === 0 && (this._lastTokenEndIndex = -1, this.produce(t, e), this._tokens[this._tokens.length - 1].startIndex = 0), this._tokens;
+  }
+  getBinaryResult(t, e) {
+    this._binaryTokens.length > 0 && this._binaryTokens[this._binaryTokens.length - 2] === e - 1 && (this._binaryTokens.pop(), this._binaryTokens.pop()), this._binaryTokens.length === 0 && (this._lastTokenEndIndex = -1, this.produce(t, e), this._binaryTokens[this._binaryTokens.length - 2] = 0);
+    const n = new Uint32Array(this._binaryTokens.length);
+    for (let r = 0, s = this._binaryTokens.length; r < s; r++)
+      n[r] = this._binaryTokens[r];
+    return n;
+  }
+}, vr = class {
+  constructor(t, e) {
+    this._onigLib = e, this._theme = t;
+  }
+  _grammars = /* @__PURE__ */ new Map();
+  _rawGrammars = /* @__PURE__ */ new Map();
+  _injectionGrammars = /* @__PURE__ */ new Map();
+  _theme;
+  dispose() {
+    for (const t of this._grammars.values())
+      t.dispose();
+  }
+  setTheme(t) {
+    this._theme = t;
+  }
+  getColorMap() {
+    return this._theme.getColorMap();
+  }
+  /**
+   * Add `grammar` to registry and return a list of referenced scope names
+   */
+  addGrammar(t, e) {
+    this._rawGrammars.set(t.scopeName, t), e && this._injectionGrammars.set(t.scopeName, e);
+  }
+  /**
+   * Lookup a raw grammar.
+   */
+  lookup(t) {
+    return this._rawGrammars.get(t);
+  }
+  /**
+   * Returns the injections for the given grammar
+   */
+  injections(t) {
+    return this._injectionGrammars.get(t);
+  }
+  /**
+   * Get the default theme settings
+   */
+  getDefaults() {
+    return this._theme.getDefaults();
+  }
+  /**
+   * Match a scope in the theme.
+   */
+  themeMatch(t) {
+    return this._theme.match(t);
+  }
+  /**
+   * Lookup a grammar.
+   */
+  grammarForScopeName(t, e, n, r, s) {
+    if (!this._grammars.has(t)) {
+      let i = this._rawGrammars.get(t);
+      if (!i)
+        return null;
+      this._grammars.set(t, yr(
+        t,
+        i,
+        e,
+        n,
+        r,
+        s,
+        this,
+        this._onigLib
+      ));
+    }
+    return this._grammars.get(t);
+  }
+}, Is = class {
+  _options;
+  _syncRegistry;
+  _ensureGrammarCache;
+  constructor(e) {
+    this._options = e, this._syncRegistry = new vr(
+      we.createFromRawTheme(e.theme, e.colorMap),
+      e.onigLib
+    ), this._ensureGrammarCache = /* @__PURE__ */ new Map();
+  }
+  dispose() {
+    this._syncRegistry.dispose();
+  }
+  /**
+   * Change the theme. Once called, no previous `ruleStack` should be used anymore.
+   */
+  setTheme(e, n) {
+    this._syncRegistry.setTheme(we.createFromRawTheme(e, n));
+  }
+  /**
+   * Returns a lookup array for color ids.
+   */
+  getColorMap() {
+    return this._syncRegistry.getColorMap();
+  }
+  /**
+   * Load the grammar for `scopeName` and all referenced included grammars asynchronously.
+   * Please do not use language id 0.
+   */
+  loadGrammarWithEmbeddedLanguages(e, n, r) {
+    return this.loadGrammarWithConfiguration(e, n, { embeddedLanguages: r });
+  }
+  /**
+   * Load the grammar for `scopeName` and all referenced included grammars asynchronously.
+   * Please do not use language id 0.
+   */
+  loadGrammarWithConfiguration(e, n, r) {
+    return this._loadGrammar(
+      e,
+      n,
+      r.embeddedLanguages,
+      r.tokenTypes,
+      new Sr(
+        r.balancedBracketSelectors || [],
+        r.unbalancedBracketSelectors || []
+      )
+    );
+  }
+  /**
+   * Load the grammar for `scopeName` and all referenced included grammars asynchronously.
+   */
+  loadGrammar(e) {
+    return this._loadGrammar(e, 0, null, null, null);
+  }
+  _loadGrammar(e, n, r, s, i) {
+    const l = new Qn(this._syncRegistry, e);
+    for (; l.Q.length > 0; )
+      l.Q.map((a) => this._loadSingleGrammar(a.scopeName)), l.processQueue();
+    return this._grammarForScopeName(
+      e,
+      n,
+      r,
+      s,
+      i
+    );
+  }
+  _loadSingleGrammar(e) {
+    this._ensureGrammarCache.has(e) || (this._doLoadSingleGrammar(e), this._ensureGrammarCache.set(e, !0));
+  }
+  _doLoadSingleGrammar(e) {
+    const n = this._options.loadGrammar(e);
+    if (n) {
+      const r = typeof this._options.getInjections == "function" ? this._options.getInjections(e) : void 0;
+      this._syncRegistry.addGrammar(n, r);
+    }
+  }
+  /**
+   * Adds a rawGrammar.
+   */
+  addGrammar(e, n = [], r = 0, s = null) {
+    return this._syncRegistry.addGrammar(e, n), this._grammarForScopeName(e.scopeName, r, s);
+  }
+  /**
+   * Get the grammar for `scopeName`. The grammar must first be created via `loadGrammar` or `addGrammar`.
+   */
+  _grammarForScopeName(e, n = 0, r = null, s = null, i = null) {
+    return this._syncRegistry.grammarForScopeName(
+      e,
+      n,
+      r,
+      s,
+      i
+    );
+  }
+}, Ts = Pe.NULL;
+const Rr = [
+  "area",
+  "base",
+  "basefont",
+  "bgsound",
+  "br",
+  "col",
+  "command",
+  "embed",
+  "frame",
+  "hr",
+  "image",
+  "img",
+  "input",
+  "keygen",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+], it = {}.hasOwnProperty;
+function wr(t, e) {
+  const n = e || {};
+  function r(s, ...i) {
+    let l = r.invalid;
+    const a = r.handlers;
+    if (s && it.call(s, t)) {
+      const o = String(s[t]);
+      l = it.call(a, o) ? a[o] : r.unknown;
+    }
+    if (l)
+      return l.call(this, s, ...i);
+  }
+  return r.handlers = n.handlers || {}, r.invalid = n.invalid, r.unknown = n.unknown, r;
+}
+const xr = /["&'<>`]/g, kr = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g, Er = (
+  // eslint-disable-next-line no-control-regex, unicorn/no-hex-escape
+  /[\x01-\t\v\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g
+), Ar = /[|\\{}()[\]^$+*?.]/g, lt = /* @__PURE__ */ new WeakMap();
+function Nr(t, e) {
+  if (t = t.replace(
+    e.subset ? Pr(e.subset) : xr,
+    r
+  ), e.subset || e.escapeOnly)
+    return t;
+  return t.replace(kr, n).replace(Er, r);
+  function n(s, i, l) {
+    return e.format(
+      (s.charCodeAt(0) - 55296) * 1024 + s.charCodeAt(1) - 56320 + 65536,
+      l.charCodeAt(i + 2),
+      e
+    );
+  }
+  function r(s, i, l) {
+    return e.format(
+      s.charCodeAt(0),
+      l.charCodeAt(i + 1),
+      e
+    );
+  }
+}
+function Pr(t) {
+  let e = lt.get(t);
+  return e || (e = Ir(t), lt.set(t, e)), e;
+}
+function Ir(t) {
+  const e = [];
+  let n = -1;
+  for (; ++n < t.length; )
+    e.push(t[n].replace(Ar, "\\$&"));
+  return new RegExp("(?:" + e.join("|") + ")", "g");
+}
+const Lr = /[\dA-Fa-f]/;
+function Tr(t, e, n) {
+  const r = "&#x" + t.toString(16).toUpperCase();
+  return n && e && !Lr.test(String.fromCharCode(e)) ? r : r + ";";
+}
+const Mr = /\d/;
+function Or(t, e, n) {
+  const r = "&#" + String(t);
+  return n && e && !Mr.test(String.fromCharCode(e)) ? r : r + ";";
+}
+const Dr = [
+  "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"
+], _e = {
+  nbsp: " ",
+  iexcl: "¡",
+  cent: "¢",
+  pound: "£",
+  curren: "¤",
+  yen: "¥",
+  brvbar: "¦",
+  sect: "§",
+  uml: "¨",
+  copy: "©",
+  ordf: "ª",
+  laquo: "«",
+  not: "¬",
+  shy: "­",
+  reg: "®",
+  macr: "¯",
+  deg: "°",
+  plusmn: "±",
+  sup2: "²",
+  sup3: "³",
+  acute: "´",
+  micro: "µ",
+  para: "¶",
+  middot: "·",
+  cedil: "¸",
+  sup1: "¹",
+  ordm: "º",
+  raquo: "»",
+  frac14: "¼",
+  frac12: "½",
+  frac34: "¾",
+  iquest: "¿",
+  Agrave: "À",
+  Aacute: "Á",
+  Acirc: "Â",
+  Atilde: "Ã",
+  Auml: "Ä",
+  Aring: "Å",
+  AElig: "Æ",
+  Ccedil: "Ç",
+  Egrave: "È",
+  Eacute: "É",
+  Ecirc: "Ê",
+  Euml: "Ë",
+  Igrave: "Ì",
+  Iacute: "Í",
+  Icirc: "Î",
+  Iuml: "Ï",
+  ETH: "Ð",
+  Ntilde: "Ñ",
+  Ograve: "Ò",
+  Oacute: "Ó",
+  Ocirc: "Ô",
+  Otilde: "Õ",
+  Ouml: "Ö",
+  times: "×",
+  Oslash: "Ø",
+  Ugrave: "Ù",
+  Uacute: "Ú",
+  Ucirc: "Û",
+  Uuml: "Ü",
+  Yacute: "Ý",
+  THORN: "Þ",
+  szlig: "ß",
+  agrave: "à",
+  aacute: "á",
+  acirc: "â",
+  atilde: "ã",
+  auml: "ä",
+  aring: "å",
+  aelig: "æ",
+  ccedil: "ç",
+  egrave: "è",
+  eacute: "é",
+  ecirc: "ê",
+  euml: "ë",
+  igrave: "ì",
+  iacute: "í",
+  icirc: "î",
+  iuml: "ï",
+  eth: "ð",
+  ntilde: "ñ",
+  ograve: "ò",
+  oacute: "ó",
+  ocirc: "ô",
+  otilde: "õ",
+  ouml: "ö",
+  divide: "÷",
+  oslash: "ø",
+  ugrave: "ù",
+  uacute: "ú",
+  ucirc: "û",
+  uuml: "ü",
+  yacute: "ý",
+  thorn: "þ",
+  yuml: "ÿ",
+  fnof: "ƒ",
+  Alpha: "Α",
+  Beta: "Β",
+  Gamma: "Γ",
+  Delta: "Δ",
+  Epsilon: "Ε",
+  Zeta: "Ζ",
+  Eta: "Η",
+  Theta: "Θ",
+  Iota: "Ι",
+  Kappa: "Κ",
+  Lambda: "Λ",
+  Mu: "Μ",
+  Nu: "Ν",
+  Xi: "Ξ",
+  Omicron: "Ο",
+  Pi: "Π",
+  Rho: "Ρ",
+  Sigma: "Σ",
+  Tau: "Τ",
+  Upsilon: "Υ",
+  Phi: "Φ",
+  Chi: "Χ",
+  Psi: "Ψ",
+  Omega: "Ω",
+  alpha: "α",
+  beta: "β",
+  gamma: "γ",
+  delta: "δ",
+  epsilon: "ε",
+  zeta: "ζ",
+  eta: "η",
+  theta: "θ",
+  iota: "ι",
+  kappa: "κ",
+  lambda: "λ",
+  mu: "μ",
+  nu: "ν",
+  xi: "ξ",
+  omicron: "ο",
+  pi: "π",
+  rho: "ρ",
+  sigmaf: "ς",
+  sigma: "σ",
+  tau: "τ",
+  upsilon: "υ",
+  phi: "φ",
+  chi: "χ",
+  psi: "ψ",
+  omega: "ω",
+  thetasym: "ϑ",
+  upsih: "ϒ",
+  piv: "ϖ",
+  bull: "•",
+  hellip: "…",
+  prime: "′",
+  Prime: "″",
+  oline: "‾",
+  frasl: "⁄",
+  weierp: "℘",
+  image: "ℑ",
+  real: "ℜ",
+  trade: "™",
+  alefsym: "ℵ",
+  larr: "←",
+  uarr: "↑",
+  rarr: "→",
+  darr: "↓",
+  harr: "↔",
+  crarr: "↵",
+  lArr: "⇐",
+  uArr: "⇑",
+  rArr: "⇒",
+  dArr: "⇓",
+  hArr: "⇔",
+  forall: "∀",
+  part: "∂",
+  exist: "∃",
+  empty: "∅",
+  nabla: "∇",
+  isin: "∈",
+  notin: "∉",
+  ni: "∋",
+  prod: "∏",
+  sum: "∑",
+  minus: "−",
+  lowast: "∗",
+  radic: "√",
+  prop: "∝",
+  infin: "∞",
+  ang: "∠",
+  and: "∧",
+  or: "∨",
+  cap: "∩",
+  cup: "∪",
+  int: "∫",
+  there4: "∴",
+  sim: "∼",
+  cong: "≅",
+  asymp: "≈",
+  ne: "≠",
+  equiv: "≡",
+  le: "≤",
+  ge: "≥",
+  sub: "⊂",
+  sup: "⊃",
+  nsub: "⊄",
+  sube: "⊆",
+  supe: "⊇",
+  oplus: "⊕",
+  otimes: "⊗",
+  perp: "⊥",
+  sdot: "⋅",
+  lceil: "⌈",
+  rceil: "⌉",
+  lfloor: "⌊",
+  rfloor: "⌋",
+  lang: "〈",
+  rang: "〉",
+  loz: "◊",
+  spades: "♠",
+  clubs: "♣",
+  hearts: "♥",
+  diams: "♦",
+  quot: '"',
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  OElig: "Œ",
+  oelig: "œ",
+  Scaron: "Š",
+  scaron: "š",
+  Yuml: "Ÿ",
+  circ: "ˆ",
+  tilde: "˜",
+  ensp: " ",
+  emsp: " ",
+  thinsp: " ",
+  zwnj: "‌",
+  zwj: "‍",
+  lrm: "‎",
+  rlm: "‏",
+  ndash: "–",
+  mdash: "—",
+  lsquo: "‘",
+  rsquo: "’",
+  sbquo: "‚",
+  ldquo: "“",
+  rdquo: "”",
+  bdquo: "„",
+  dagger: "†",
+  Dagger: "‡",
+  permil: "‰",
+  lsaquo: "‹",
+  rsaquo: "›",
+  euro: "€"
+}, Gr = [
+  "cent",
+  "copy",
+  "divide",
+  "gt",
+  "lt",
+  "not",
+  "para",
+  "times"
+], Ut = {}.hasOwnProperty, Ie = {};
+let re;
+for (re in _e)
+  Ut.call(_e, re) && (Ie[_e[re]] = re);
+const jr = /[^\dA-Za-z]/;
+function Br(t, e, n, r) {
+  const s = String.fromCharCode(t);
+  if (Ut.call(Ie, s)) {
+    const i = Ie[s], l = "&" + i;
+    return n && Dr.includes(i) && !Gr.includes(i) && (!r || e && e !== 61 && jr.test(String.fromCharCode(e))) ? l : l + ";";
+  }
+  return "";
+}
+function Fr(t, e, n) {
+  let r = Tr(t, e, n.omitOptionalSemicolons), s;
+  if ((n.useNamedReferences || n.useShortestReferences) && (s = Br(
+    t,
+    e,
+    n.omitOptionalSemicolons,
+    n.attribute
+  )), (n.useShortestReferences || !s) && n.useShortestReferences) {
+    const i = Or(t, e, n.omitOptionalSemicolons);
+    i.length < r.length && (r = i);
+  }
+  return s && (!n.useShortestReferences || s.length < r.length) ? s : r;
+}
+function U(t, e) {
+  return Nr(t, Object.assign({ format: Fr }, e));
+}
+const $r = /^>|^->|<!--|-->|--!>|<!-$/g, Ur = [">"], zr = ["<", ">"];
+function qr(t, e, n, r) {
+  return r.settings.bogusComments ? "<?" + U(
+    t.value,
+    Object.assign({}, r.settings.characterReferences, {
+      subset: Ur
+    })
+  ) + ">" : "<!--" + t.value.replace($r, s) + "-->";
+  function s(i) {
+    return U(
+      i,
+      Object.assign({}, r.settings.characterReferences, {
+        subset: zr
+      })
+    );
+  }
+}
+function Wr(t, e, n, r) {
+  return "<!" + (r.settings.upperDoctype ? "DOCTYPE" : "doctype") + (r.settings.tightDoctype ? "" : " ") + "html>";
+}
+function ot(t, e) {
+  const n = String(t);
+  if (typeof e != "string")
+    throw new TypeError("Expected character");
+  let r = 0, s = n.indexOf(e);
+  for (; s !== -1; )
+    r++, s = n.indexOf(e, s + e.length);
+  return r;
+}
+const w = qt(1), zt = qt(-1), Hr = [];
+function qt(t) {
+  return e;
+  function e(n, r, s) {
+    const i = n ? n.children : Hr;
+    let l = (r || 0) + t, a = i[l];
+    if (!s)
+      for (; a && pe(a); )
+        l += t, a = i[l];
+    return a;
+  }
+}
+const Xr = {}.hasOwnProperty;
+function Wt(t) {
+  return e;
+  function e(n, r, s) {
+    return Xr.call(t, n.tagName) && t[n.tagName](n, r, s);
+  }
+}
+const Ge = Wt({
+  body: Vr,
+  caption: Ce,
+  colgroup: Ce,
+  dd: Zr,
+  dt: Qr,
+  head: Ce,
+  html: Kr,
+  li: Jr,
+  optgroup: es,
+  option: ts,
+  p: Yr,
+  rp: at,
+  rt: at,
+  tbody: rs,
+  td: ut,
+  tfoot: ss,
+  th: ut,
+  thead: ns,
+  tr: is
+});
+function Ce(t, e, n) {
+  const r = w(n, e, !0);
+  return !r || r.type !== "comment" && !(r.type === "text" && pe(r.value.charAt(0)));
+}
+function Kr(t, e, n) {
+  const r = w(n, e);
+  return !r || r.type !== "comment";
+}
+function Vr(t, e, n) {
+  const r = w(n, e);
+  return !r || r.type !== "comment";
+}
+function Yr(t, e, n) {
+  const r = w(n, e);
+  return r ? r.type === "element" && (r.tagName === "address" || r.tagName === "article" || r.tagName === "aside" || r.tagName === "blockquote" || r.tagName === "details" || r.tagName === "div" || r.tagName === "dl" || r.tagName === "fieldset" || r.tagName === "figcaption" || r.tagName === "figure" || r.tagName === "footer" || r.tagName === "form" || r.tagName === "h1" || r.tagName === "h2" || r.tagName === "h3" || r.tagName === "h4" || r.tagName === "h5" || r.tagName === "h6" || r.tagName === "header" || r.tagName === "hgroup" || r.tagName === "hr" || r.tagName === "main" || r.tagName === "menu" || r.tagName === "nav" || r.tagName === "ol" || r.tagName === "p" || r.tagName === "pre" || r.tagName === "section" || r.tagName === "table" || r.tagName === "ul") : !n || // Confusing parent.
+  !(n.type === "element" && (n.tagName === "a" || n.tagName === "audio" || n.tagName === "del" || n.tagName === "ins" || n.tagName === "map" || n.tagName === "noscript" || n.tagName === "video"));
+}
+function Jr(t, e, n) {
+  const r = w(n, e);
+  return !r || r.type === "element" && r.tagName === "li";
+}
+function Qr(t, e, n) {
+  const r = w(n, e);
+  return !!(r && r.type === "element" && (r.tagName === "dt" || r.tagName === "dd"));
+}
+function Zr(t, e, n) {
+  const r = w(n, e);
+  return !r || r.type === "element" && (r.tagName === "dt" || r.tagName === "dd");
+}
+function at(t, e, n) {
+  const r = w(n, e);
+  return !r || r.type === "element" && (r.tagName === "rp" || r.tagName === "rt");
+}
+function es(t, e, n) {
+  const r = w(n, e);
+  return !r || r.type === "element" && r.tagName === "optgroup";
+}
+function ts(t, e, n) {
+  const r = w(n, e);
+  return !r || r.type === "element" && (r.tagName === "option" || r.tagName === "optgroup");
+}
+function ns(t, e, n) {
+  const r = w(n, e);
+  return !!(r && r.type === "element" && (r.tagName === "tbody" || r.tagName === "tfoot"));
+}
+function rs(t, e, n) {
+  const r = w(n, e);
+  return !r || r.type === "element" && (r.tagName === "tbody" || r.tagName === "tfoot");
+}
+function ss(t, e, n) {
+  return !w(n, e);
+}
+function is(t, e, n) {
+  const r = w(n, e);
+  return !r || r.type === "element" && r.tagName === "tr";
+}
+function ut(t, e, n) {
+  const r = w(n, e);
+  return !r || r.type === "element" && (r.tagName === "td" || r.tagName === "th");
+}
+const ls = Wt({
+  body: us,
+  colgroup: cs,
+  head: as,
+  html: os,
+  tbody: hs
+});
+function os(t) {
+  const e = w(t, -1);
+  return !e || e.type !== "comment";
+}
+function as(t) {
+  const e = /* @__PURE__ */ new Set();
+  for (const r of t.children)
+    if (r.type === "element" && (r.tagName === "base" || r.tagName === "title")) {
+      if (e.has(r.tagName)) return !1;
+      e.add(r.tagName);
+    }
+  const n = t.children[0];
+  return !n || n.type === "element";
+}
+function us(t) {
+  const e = w(t, -1, !0);
+  return !e || e.type !== "comment" && !(e.type === "text" && pe(e.value.charAt(0))) && !(e.type === "element" && (e.tagName === "meta" || e.tagName === "link" || e.tagName === "script" || e.tagName === "style" || e.tagName === "template"));
+}
+function cs(t, e, n) {
+  const r = zt(n, e), s = w(t, -1, !0);
+  return n && r && r.type === "element" && r.tagName === "colgroup" && Ge(r, n.children.indexOf(r), n) ? !1 : !!(s && s.type === "element" && s.tagName === "col");
+}
+function hs(t, e, n) {
+  const r = zt(n, e), s = w(t, -1);
+  return n && r && r.type === "element" && (r.tagName === "thead" || r.tagName === "tbody") && Ge(r, n.children.indexOf(r), n) ? !1 : !!(s && s.type === "element" && s.tagName === "tr");
+}
+const se = {
+  // See: <https://html.spec.whatwg.org/#attribute-name-state>.
+  name: [
+    [`	
+\f\r &/=>`.split(""), `	
+\f\r "&'/=>\``.split("")],
+    [`\0	
+\f\r "&'/<=>`.split(""), `\0	
+\f\r "&'/<=>\``.split("")]
+  ],
+  // See: <https://html.spec.whatwg.org/#attribute-value-(unquoted)-state>.
+  unquoted: [
+    [`	
+\f\r &>`.split(""), `\0	
+\f\r "&'<=>\``.split("")],
+    [`\0	
+\f\r "&'<=>\``.split(""), `\0	
+\f\r "&'<=>\``.split("")]
+  ],
+  // See: <https://html.spec.whatwg.org/#attribute-value-(single-quoted)-state>.
+  single: [
+    ["&'".split(""), "\"&'`".split("")],
+    ["\0&'".split(""), "\0\"&'`".split("")]
+  ],
+  // See: <https://html.spec.whatwg.org/#attribute-value-(double-quoted)-state>.
+  double: [
+    ['"&'.split(""), "\"&'`".split("")],
+    ['\0"&'.split(""), "\0\"&'`".split("")]
+  ]
+};
+function ps(t, e, n, r) {
+  const s = r.schema, i = s.space === "svg" ? !1 : r.settings.omitOptionalTags;
+  let l = s.space === "svg" ? r.settings.closeEmptyElements : r.settings.voids.includes(t.tagName.toLowerCase());
+  const a = [];
+  let o;
+  s.space === "html" && t.tagName === "svg" && (r.schema = ee);
+  const u = ds(r, t.properties), h = r.all(
+    s.space === "html" && t.tagName === "template" ? t.content : t
+  );
+  return r.schema = s, h && (l = !1), (u || !i || !ls(t, e, n)) && (a.push("<", t.tagName, u ? " " + u : ""), l && (s.space === "svg" || r.settings.closeSelfClosing) && (o = u.charAt(u.length - 1), (!r.settings.tightSelfClosing || o === "/" || o && o !== '"' && o !== "'") && a.push(" "), a.push("/")), a.push(">")), a.push(h), !l && (!i || !Ge(t, e, n)) && a.push("</" + t.tagName + ">"), a.join("");
+}
+function ds(t, e) {
+  const n = [];
+  let r = -1, s;
+  if (e) {
+    for (s in e)
+      if (e[s] !== null && e[s] !== void 0) {
+        const i = fs(t, s, e[s]);
+        i && n.push(i);
+      }
+  }
+  for (; ++r < n.length; ) {
+    const i = t.settings.tightAttributes ? n[r].charAt(n[r].length - 1) : void 0;
+    r !== n.length - 1 && i !== '"' && i !== "'" && (n[r] += " ");
+  }
+  return n.join("");
+}
+function fs(t, e, n) {
+  const r = _t(t.schema, e), s = t.settings.allowParseErrors && t.schema.space === "html" ? 0 : 1, i = t.settings.allowDangerousCharacters ? 0 : 1;
+  let l = t.quote, a;
+  if (r.overloadedBoolean && (n === r.attribute || n === "") ? n = !0 : (r.boolean || r.overloadedBoolean) && (typeof n != "string" || n === r.attribute || n === "") && (n = !!n), n == null || n === !1 || typeof n == "number" && Number.isNaN(n))
+    return "";
+  const o = U(
+    r.attribute,
+    Object.assign({}, t.settings.characterReferences, {
+      // Always encode without parse errors in non-HTML.
+      subset: se.name[s][i]
+    })
+  );
+  return n === !0 || (n = Array.isArray(n) ? (r.commaSeparated ? ct : St)(n, {
+    padLeft: !t.settings.tightCommaSeparatedLists
+  }) : String(n), t.settings.collapseEmptyAttributes && !n) ? o : (t.settings.preferUnquoted && (a = U(
+    n,
+    Object.assign({}, t.settings.characterReferences, {
+      attribute: !0,
+      subset: se.unquoted[s][i]
+    })
+  )), a !== n && (t.settings.quoteSmart && ot(n, l) > ot(n, t.alternative) && (l = t.alternative), a = l + U(
+    n,
+    Object.assign({}, t.settings.characterReferences, {
+      // Always encode without parse errors in non-HTML.
+      subset: (l === "'" ? se.single : se.double)[s][i],
+      attribute: !0
+    })
+  ) + l), o + (a && "=" + a));
+}
+const ms = ["<", "&"];
+function Ht(t, e, n, r) {
+  return n && n.type === "element" && (n.tagName === "script" || n.tagName === "style") ? t.value : U(
+    t.value,
+    Object.assign({}, r.settings.characterReferences, {
+      subset: ms
+    })
+  );
+}
+function gs(t, e, n, r) {
+  return r.settings.allowDangerousHtml ? t.value : Ht(t, e, n, r);
+}
+function ys(t, e, n, r) {
+  return r.all(t);
+}
+const _s = wr("type", {
+  invalid: Cs,
+  unknown: Ss,
+  handlers: { comment: qr, doctype: Wr, element: ps, raw: gs, root: ys, text: Ht }
+});
+function Cs(t) {
+  throw new Error("Expected node, not `" + t + "`");
+}
+function Ss(t) {
+  const e = (
+    /** @type {Nodes} */
+    t
+  );
+  throw new Error("Cannot compile unknown node `" + e.type + "`");
+}
+const bs = {}, vs = {}, Rs = [];
+function Ms(t, e) {
+  const n = e || bs, r = n.quote || '"', s = r === '"' ? "'" : '"';
+  if (r !== '"' && r !== "'")
+    throw new Error("Invalid quote `" + r + "`, expected `'` or `\"`");
+  return {
+    one: ws,
+    all: xs,
+    settings: {
+      omitOptionalTags: n.omitOptionalTags || !1,
+      allowParseErrors: n.allowParseErrors || !1,
+      allowDangerousCharacters: n.allowDangerousCharacters || !1,
+      quoteSmart: n.quoteSmart || !1,
+      preferUnquoted: n.preferUnquoted || !1,
+      tightAttributes: n.tightAttributes || !1,
+      upperDoctype: n.upperDoctype || !1,
+      tightDoctype: n.tightDoctype || !1,
+      bogusComments: n.bogusComments || !1,
+      tightCommaSeparatedLists: n.tightCommaSeparatedLists || !1,
+      tightSelfClosing: n.tightSelfClosing || !1,
+      collapseEmptyAttributes: n.collapseEmptyAttributes || !1,
+      allowDangerousHtml: n.allowDangerousHtml || !1,
+      voids: n.voids || Rr,
+      characterReferences: n.characterReferences || vs,
+      closeSelfClosing: n.closeSelfClosing || !1,
+      closeEmptyElements: n.closeEmptyElements || !1
+    },
+    schema: n.space === "svg" ? ee : Ct,
+    quote: r,
+    alternative: s
+  }.one(
+    Array.isArray(t) ? { type: "root", children: t } : t,
+    void 0,
+    void 0
+  );
+}
+function ws(t, e, n) {
+  return _s(t, e, n, this);
+}
+function xs(t) {
+  const e = [], n = t && t.children || Rs;
+  let r = -1;
+  for (; ++r < n.length; )
+    e[r] = this.one(n[r], r, t);
+  return e.join("");
+}
+export {
+  oe as E,
+  qn as F,
+  Ts as I,
+  Is as R,
+  we as T,
+  E as V,
+  Ps as a,
+  ks as b,
+  ot as c,
+  ct as d,
+  St as e,
+  _t as f,
+  bt as g,
+  Ct as h,
+  Rr as i,
+  gn as j,
+  Ns as k,
+  yn as l,
+  Yt as m,
+  Se as n,
+  Es as o,
+  As as p,
+  ee as s,
+  Ms as t,
+  wr as z
+};