import {
  a as mn
} from "./chunk-E3M3C3LC.js";
import {
  a as hn
} from "./chunk-3KOMQOID.js";
import {
  a as vn
} from "./chunk-KBQ3BV4Z.js";
import {
  a as gn
} from "./chunk-LCS5NGRN.js";
import {
  a as n,
  c as y
} from "./chunk-IO47FP3U.js";

// ../node_modules/xtend/immutable.js
var Ue = y((vl, Re) => {
  Re.exports = xn;
  var yn = Object.prototype.hasOwnProperty;
  function xn() {
    for (var e = {}, r = 0; r < arguments.length; r++) {
      var a = arguments[r];
      for (var o in a)
        yn.call(a, o) && (e[o] = a[o]);
    }
    return e;
  }
  n(xn, "extend");
});

// ../node_modules/hastscript/node_modules/property-information/lib/util/schema.js
var be = y((ml, ze) => {
  "use strict";
  ze.exports = je;
  var xe = je.prototype;
  xe.space = null;
  xe.normal = {};
  xe.property = {};
  function je(e, r, a) {
    this.property = e, this.normal = r, a && (this.space = a);
  }
  n(je, "Schema");
});

// ../node_modules/hastscript/node_modules/property-information/lib/util/merge.js
var We = y((xl, Be) => {
  "use strict";
  var He = Ue(), bn = be();
  Be.exports = wn;
  function wn(e) {
    for (var r = e.length, a = [], o = [], l = -1, d, x; ++l < r; )
      d = e[l], a.push(d.property), o.push(d.normal), x = d.space;
    return new bn(
      He.apply(null, a),
      He.apply(null, o),
      x
    );
  }
  n(wn, "merge");
});

// ../node_modules/hastscript/node_modules/property-information/normalize.js
var de = y((wl, Fe) => {
  "use strict";
  Fe.exports = Cn;
  function Cn(e) {
    return e.toLowerCase();
  }
  n(Cn, "normalize");
});

// ../node_modules/hastscript/node_modules/property-information/lib/util/info.js
var we = y((Sl, Ge) => {
  "use strict";
  Ge.exports = Ve;
  var U = Ve.prototype;
  U.space = null;
  U.attribute = null;
  U.property = null;
  U.boolean = !1;
  U.booleanish = !1;
  U.overloadedBoolean = !1;
  U.number = !1;
  U.commaSeparated = !1;
  U.spaceSeparated = !1;
  U.commaOrSpaceSeparated = !1;
  U.mustUseProperty = !1;
  U.defined = !1;
  function Ve(e, r) {
    this.property = e, this.attribute = r;
  }
  n(Ve, "Info");
});

// ../node_modules/hastscript/node_modules/property-information/lib/util/types.js
var pe = y((G) => {
  "use strict";
  var Sn = 0;
  G.boolean = Y();
  G.booleanish = Y();
  G.overloadedBoolean = Y();
  G.number = Y();
  G.spaceSeparated = Y();
  G.commaSeparated = Y();
  G.commaOrSpaceSeparated = Y();
  function Y() {
    return Math.pow(2, ++Sn);
  }
  n(Y, "increment");
});

// ../node_modules/hastscript/node_modules/property-information/lib/util/defined-info.js
var Se = y((El, Ye) => {
  "use strict";
  var Xe = we(), Ke = pe();
  Ye.exports = Ce;
  Ce.prototype = new Xe();
  Ce.prototype.defined = !0;
  var Je = [
    "boolean",
    "booleanish",
    "overloadedBoolean",
    "number",
    "commaSeparated",
    "spaceSeparated",
    "commaOrSpaceSeparated"
  ], qn = Je.length;
  function Ce(e, r, a, o) {
    var l = -1, d;
    for ($e(this, "space", o), Xe.call(this, e, r); ++l < qn; )
      d = Je[l], $e(this, d, (a & Ke[d]) === Ke[d]);
  }
  n(Ce, "DefinedInfo");
  function $e(e, r, a) {
    a && (e[r] = a);
  }
  n($e, "mark");
});

// ../node_modules/hastscript/node_modules/property-information/lib/util/create.js
var ee = y((kl, Ze) => {
  "use strict";
  var Qe = de(), An = be(), Pn = Se();
  Ze.exports = En;
  function En(e) {
    var r = e.space, a = e.mustUseProperty || [], o = e.attributes || {}, l = e.properties, d = e.transform, x = {}, C = {}, v, P;
    for (v in l)
      P = new Pn(
        v,
        d(o, v),
        l[v],
        r
      ), a.indexOf(v) !== -1 && (P.mustUseProperty = !0), x[v] = P, C[Qe(v)] = v, C[Qe(P.attribute)] = v;
    return new An(x, C, r);
  }
  n(En, "create");
});

// ../node_modules/hastscript/node_modules/property-information/lib/xlink.js
var er = y((Ml, _e) => {
  "use strict";
  var Ln = ee();
  _e.exports = Ln({
    space: "xlink",
    transform: kn,
    properties: {
      xLinkActuate: null,
      xLinkArcRole: null,
      xLinkHref: null,
      xLinkRole: null,
      xLinkShow: null,
      xLinkTitle: null,
      xLinkType: null
    }
  });
  function kn(e, r) {
    return "xlink:" + r.slice(5).toLowerCase();
  }
  n(kn, "xlinkTransform");
});

// ../node_modules/hastscript/node_modules/property-information/lib/xml.js
var nr = y((Il, rr) => {
  "use strict";
  var Tn = ee();
  rr.exports = Tn({
    space: "xml",
    transform: Mn,
    properties: {
      xmlLang: null,
      xmlBase: null,
      xmlSpace: null
    }
  });
  function Mn(e, r) {
    return "xml:" + r.slice(3).toLowerCase();
  }
  n(Mn, "xmlTransform");
});

// ../node_modules/hastscript/node_modules/property-information/lib/util/case-sensitive-transform.js
var lr = y((Nl, ar) => {
  "use strict";
  ar.exports = On;
  function On(e, r) {
    return r in e ? e[r] : r;
  }
  n(On, "caseSensitiveTransform");
});

// ../node_modules/hastscript/node_modules/property-information/lib/util/case-insensitive-transform.js
var qe = y((Ul, tr) => {
  "use strict";
  var In = lr();
  tr.exports = Dn;
  function Dn(e, r) {
    return In(e, r.toLowerCase());
  }
  n(Dn, "caseInsensitiveTransform");
});

// ../node_modules/hastscript/node_modules/property-information/lib/xmlns.js
var or = y((zl, ir) => {
  "use strict";
  var Nn = ee(), Rn = qe();
  ir.exports = Nn({
    space: "xmlns",
    attributes: {
      xmlnsxlink: "xmlns:xlink"
    },
    transform: Rn,
    properties: {
      xmlns: null,
      xmlnsXLink: null
    }
  });
});

// ../node_modules/hastscript/node_modules/property-information/lib/aria.js
var sr = y((Hl, ur) => {
  "use strict";
  var Ae = pe(), Un = ee(), I = Ae.booleanish, j = Ae.number, Q = Ae.spaceSeparated;
  ur.exports = Un({
    transform: jn,
    properties: {
      ariaActiveDescendant: null,
      ariaAtomic: I,
      ariaAutoComplete: null,
      ariaBusy: I,
      ariaChecked: I,
      ariaColCount: j,
      ariaColIndex: j,
      ariaColSpan: j,
      ariaControls: Q,
      ariaCurrent: null,
      ariaDescribedBy: Q,
      ariaDetails: null,
      ariaDisabled: I,
      ariaDropEffect: Q,
      ariaErrorMessage: null,
      ariaExpanded: I,
      ariaFlowTo: Q,
      ariaGrabbed: I,
      ariaHasPopup: null,
      ariaHidden: I,
      ariaInvalid: null,
      ariaKeyShortcuts: null,
      ariaLabel: null,
      ariaLabelledBy: Q,
      ariaLevel: j,
      ariaLive: null,
      ariaModal: I,
      ariaMultiLine: I,
      ariaMultiSelectable: I,
      ariaOrientation: null,
      ariaOwns: Q,
      ariaPlaceholder: null,
      ariaPosInSet: j,
      ariaPressed: I,
      ariaReadOnly: I,
      ariaRelevant: null,
      ariaRequired: I,
      ariaRoleDescription: Q,
      ariaRowCount: j,
      ariaRowIndex: j,
      ariaRowSpan: j,
      ariaSelected: I,
      ariaSetSize: j,
      ariaSort: null,
      ariaValueMax: j,
      ariaValueMin: j,
      ariaValueNow: j,
      ariaValueText: null,
      role: null
    }
  });
  function jn(e, r) {
    return r === "role" ? r : "aria-" + r.slice(4).toLowerCase();
  }
  n(jn, "ariaTransform");
});

// ../node_modules/hastscript/node_modules/property-information/lib/html.js
var fr = y((Wl, cr) => {
  "use strict";
  var re = pe(), zn = ee(), Hn = qe(), g = re.boolean, Bn = re.overloadedBoolean, oe = re.booleanish, q = re.number, O = re.spaceSeparated, ge = re.commaSeparated;
  cr.exports = zn({
    space: "html",
    attributes: {
      acceptcharset: "accept-charset",
      classname: "class",
      htmlfor: "for",
      httpequiv: "http-equiv"
    },
    transform: Hn,
    mustUseProperty: ["checked", "multiple", "muted", "selected"],
    properties: {
      // Standard Properties.
      abbr: null,
      accept: ge,
      acceptCharset: O,
      accessKey: O,
      action: null,
      allow: null,
      allowFullScreen: g,
      allowPaymentRequest: g,
      allowUserMedia: g,
      alt: null,
      as: null,
      async: g,
      autoCapitalize: null,
      autoComplete: O,
      autoFocus: g,
      autoPlay: g,
      capture: g,
      charSet: null,
      checked: g,
      cite: null,
      className: O,
      cols: q,
      colSpan: null,
      content: null,
      contentEditable: oe,
      controls: g,
      controlsList: O,
      coords: q | ge,
      crossOrigin: null,
      data: null,
      dateTime: null,
      decoding: null,
      default: g,
      defer: g,
      dir: null,
      dirName: null,
      disabled: g,
      download: Bn,
      draggable: oe,
      encType: null,
      enterKeyHint: null,
      form: null,
      formAction: null,
      formEncType: null,
      formMethod: null,
      formNoValidate: g,
      formTarget: null,
      headers: O,
      height: q,
      hidden: g,
      high: q,
      href: null,
      hrefLang: null,
      htmlFor: O,
      httpEquiv: O,
      id: null,
      imageSizes: null,
      imageSrcSet: ge,
      inputMode: null,
      integrity: null,
      is: null,
      isMap: g,
      itemId: null,
      itemProp: O,
      itemRef: O,
      itemScope: g,
      itemType: O,
      kind: null,
      label: null,
      lang: null,
      language: null,
      list: null,
      loading: null,
      loop: g,
      low: q,
      manifest: null,
      max: null,
      maxLength: q,
      media: null,
      method: null,
      min: null,
      minLength: q,
      multiple: g,
      muted: g,
      name: null,
      nonce: null,
      noModule: g,
      noValidate: g,
      onAbort: null,
      onAfterPrint: null,
      onAuxClick: null,
      onBeforePrint: null,
      onBeforeUnload: null,
      onBlur: null,
      onCancel: null,
      onCanPlay: null,
      onCanPlayThrough: null,
      onChange: null,
      onClick: null,
      onClose: null,
      onContextMenu: 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,
      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: g,
      optimum: q,
      pattern: null,
      ping: O,
      placeholder: null,
      playsInline: g,
      poster: null,
      preload: null,
      readOnly: g,
      referrerPolicy: null,
      rel: O,
      required: g,
      reversed: g,
      rows: q,
      rowSpan: q,
      sandbox: O,
      scope: null,
      scoped: g,
      seamless: g,
      selected: g,
      shape: null,
      size: q,
      sizes: null,
      slot: null,
      span: q,
      spellCheck: oe,
      src: null,
      srcDoc: null,
      srcLang: null,
      srcSet: ge,
      start: q,
      step: null,
      style: null,
      tabIndex: q,
      target: null,
      title: null,
      translate: null,
      type: null,
      typeMustMatch: g,
      useMap: null,
      value: oe,
      width: q,
      wrap: 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: O,
      // `<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: q,
      // `<table>`. Use CSS `border-width` instead,
      borderColor: null,
      // `<table>`. Use CSS `border-color` instead,
      bottomMargin: q,
      // `<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: g,
      // Lists. Use CSS to reduce space between items instead
      declare: g,
      // `<object>`
      event: null,
      // `<script>`
      face: null,
      // `<font>`. Use CSS instead
      frame: null,
      // `<table>`
      frameBorder: null,
      // `<iframe>`. Use CSS `border` instead
      hSpace: q,
      // `<img>` and `<object>`
      leftMargin: q,
      // `<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: q,
      // `<body>`
      marginWidth: q,
      // `<body>`
      noResize: g,
      // `<frame>`
      noHref: g,
      // `<area>`. Use no href instead of an explicit `nohref`
      noShade: g,
      // `<hr>`. Use background-color and height instead of borders
      noWrap: g,
      // `<td>` and `<th>`
      object: null,
      // `<applet>`
      profile: null,
      // `<head>`
      prompt: null,
      // `<isindex>`
      rev: null,
      // `<link>`
      rightMargin: q,
      // `<body>`
      rules: null,
      // `<table>`
      scheme: null,
      // `<meta>`
      scrolling: oe,
      // `<frame>`. Use overflow in the child context
      standby: null,
      // `<object>`
      summary: null,
      // `<table>`
      text: null,
      // `<body>`. Use CSS `color` instead
      topMargin: q,
      // `<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: q,
      // `<img>` and `<object>`
      // Non-standard Properties.
      allowTransparency: null,
      autoCorrect: null,
      autoSave: null,
      disablePictureInPicture: g,
      disableRemotePlayback: g,
      prefix: null,
      property: null,
      results: q,
      security: null,
      unselectable: null
    }
  });
});

// ../node_modules/hastscript/node_modules/property-information/html.js
var pr = y((Fl, dr) => {
  "use strict";
  var Wn = We(), Fn = er(), Vn = nr(), Gn = or(), Kn = sr(), $n = fr();
  dr.exports = Wn([Vn, Fn, Gn, Kn, $n]);
});

// ../node_modules/hastscript/node_modules/property-information/find.js
var hr = y((Vl, vr) => {
  "use strict";
  var Xn = de(), Jn = Se(), Yn = we(), Pe = "data";
  vr.exports = _n;
  var Qn = /^data[-\w.:]+$/i, gr = /-[a-z]/g, Zn = /[A-Z]/g;
  function _n(e, r) {
    var a = Xn(r), o = r, l = Yn;
    return a in e.normal ? e.property[e.normal[a]] : (a.length > 4 && a.slice(0, 4) === Pe && Qn.test(r) && (r.charAt(4) === "-" ? o = ea(r) : r = ra(r), l = Jn), new l(o, r));
  }
  n(_n, "find");
  function ea(e) {
    var r = e.slice(5).replace(gr, aa);
    return Pe + r.charAt(0).toUpperCase() + r.slice(1);
  }
  n(ea, "datasetToProperty");
  function ra(e) {
    var r = e.slice(4);
    return gr.test(r) ? e : (r = r.replace(Zn, na), r.charAt(0) !== "-" && (r = "-" + r), Pe + r);
  }
  n(ra, "datasetToAttribute");
  function na(e) {
    return "-" + e.toLowerCase();
  }
  n(na, "kebab");
  function aa(e) {
    return e.charAt(1).toUpperCase();
  }
  n(aa, "camelcase");
});

// ../node_modules/hast-util-parse-selector/index.js
var xr = y((Kl, yr) => {
  "use strict";
  yr.exports = la;
  var mr = /[#.]/g;
  function la(e, r) {
    for (var a = e || "", o = r || "div", l = {}, d = 0, x, C, v; d < a.length; )
      mr.lastIndex = d, v = mr.exec(a), x = a.slice(d, v ? v.index : a.length), x && (C ? C === "#" ? l.id = x : l.className ? l.className.push(x) : l.className = [x] : o = x, d += x.length), v && (C = v[0], d++);
    return { type: "element", tagName: o, properties: l, children: [] };
  }
  n(la, "parse");
});

// ../node_modules/hastscript/node_modules/space-separated-tokens/index.js
var wr = y((Ee) => {
  "use strict";
  Ee.parse = oa;
  Ee.stringify = ua;
  var br = "", ta = " ", ia = /[ \t\n\r\f]+/g;
  function oa(e) {
    var r = String(e || br).trim();
    return r === br ? [] : r.split(ia);
  }
  n(oa, "parse");
  function ua(e) {
    return e.join(ta).trim();
  }
  n(ua, "stringify");
});

// ../node_modules/hastscript/node_modules/comma-separated-tokens/index.js
var Sr = y((ke) => {
  "use strict";
  ke.parse = sa;
  ke.stringify = ca;
  var Le = ",", Cr = " ", ue = "";
  function sa(e) {
    for (var r = [], a = String(e || ue), o = a.indexOf(Le), l = 0, d = !1, x; !d; )
      o === -1 && (o = a.length, d = !0), x = a.slice(l, o).trim(), (x || !d) && r.push(x), l = o + 1, o = a.indexOf(Le, l);
    return r;
  }
  n(sa, "parse");
  function ca(e, r) {
    var a = r || {}, o = a.padLeft === !1 ? ue : Cr, l = a.padRight ? Cr : ue;
    return e[e.length - 1] === ue && (e = e.concat(ue)), e.join(l + Le + o).trim();
  }
  n(ca, "stringify");
});

// ../node_modules/hastscript/factory.js
var Tr = y((Zl, kr) => {
  "use strict";
  var fa = hr(), qr = de(), da = xr(), Ar = wr().parse, Pr = Sr().parse;
  kr.exports = ga;
  var pa = {}.hasOwnProperty;
  function ga(e, r, a) {
    var o = a ? xa(a) : null;
    return l;
    function l(x, C) {
      var v = da(x, r), P = Array.prototype.slice.call(arguments, 2), M = v.tagName.toLowerCase(), E;
      if (v.tagName = o && pa.call(o, M) ? o[M] : M, C && va(C, v) && (P.unshift(C), C = null), C)
        for (E in C)
          d(v.properties, E, C[E]);
      return Lr(v.children, P), v.tagName === "template" && (v.content = { type: "root", children: v.children }, v.children = []), v;
    }
    function d(x, C, v) {
      var P, M, E;
      v == null || v !== v || (P = fa(e, C), M = P.property, E = v, typeof E == "string" && (P.spaceSeparated ? E = Ar(E) : P.commaSeparated ? E = Pr(E) : P.commaOrSpaceSeparated && (E = Ar(Pr(E).join(" ")))), M === "style" && typeof v != "string" && (E = ya(E)), M === "className" && x.className && (E = x.className.concat(E)), x[M] = ma(P, M, E));
    }
  }
  n(ga, "factory");
  function va(e, r) {
    return typeof e == "string" || "length" in e || ha(r.tagName, e);
  }
  n(va, "isChildren");
  function ha(e, r) {
    var a = r.type;
    return e === "input" || !a || typeof a != "string" ? !1 : typeof r.children == "object" && "length" in r.children ? !0 : (a = a.toLowerCase(), e === "button" ? a !== "menu" && a !== "submit" && a !== "reset" && a !== "button" : "value" in r);
  }
  n(ha, "isNode");
  function Lr(e, r) {
    var a, o;
    if (typeof r == "string" || typeof r == "number") {
      e.push({ type: "text", value: String(r) });
      return;
    }
    if (typeof r == "object" && "length" in r) {
      for (a = -1, o = r.length; ++a < o; )
        Lr(e, r[a]);
      return;
    }
    if (typeof r != "object" || !("type" in r))
      throw new Error("Expected node, nodes, or string, got `" + r + "`");
    e.push(r);
  }
  n(Lr, "addChild");
  function ma(e, r, a) {
    var o, l, d;
    if (typeof a != "object" || !("length" in a))
      return Er(e, r, a);
    for (l = a.length, o = -1, d = []; ++o < l; )
      d[o] = Er(e, r, a[o]);
    return d;
  }
  n(ma, "parsePrimitives");
  function Er(e, r, a) {
    var o = a;
    return e.number || e.positiveNumber ? !isNaN(o) && o !== "" && (o = Number(o)) : (e.boolean || e.overloadedBoolean) && typeof o == "string" && (o === "" || qr(a) === qr(r)) && (o = !0), o;
  }
  n(Er, "parsePrimitive");
  function ya(e) {
    var r = [], a;
    for (a in e)
      r.push([a, e[a]].join(": "));
    return r.join("; ");
  }
  n(ya, "style");
  function xa(e) {
    for (var r = e.length, a = -1, o = {}, l; ++a < r; )
      l = e[a], o[l.toLowerCase()] = l;
    return o;
  }
  n(xa, "createAdjustMap");
});

// ../node_modules/hastscript/html.js
var Ir = y((et, Or) => {
  "use strict";
  var ba = pr(), wa = Tr(), Mr = wa(ba, "div");
  Mr.displayName = "html";
  Or.exports = Mr;
});

// ../node_modules/hastscript/index.js
var Nr = y((rt, Dr) => {
  "use strict";
  Dr.exports = Ir();
});

// ../node_modules/refractor/node_modules/character-entities-legacy/index.json
var Rr = y((nt, Ca) => {
  Ca.exports = {
    AElig: "\xC6",
    AMP: "&",
    Aacute: "\xC1",
    Acirc: "\xC2",
    Agrave: "\xC0",
    Aring: "\xC5",
    Atilde: "\xC3",
    Auml: "\xC4",
    COPY: "\xA9",
    Ccedil: "\xC7",
    ETH: "\xD0",
    Eacute: "\xC9",
    Ecirc: "\xCA",
    Egrave: "\xC8",
    Euml: "\xCB",
    GT: ">",
    Iacute: "\xCD",
    Icirc: "\xCE",
    Igrave: "\xCC",
    Iuml: "\xCF",
    LT: "<",
    Ntilde: "\xD1",
    Oacute: "\xD3",
    Ocirc: "\xD4",
    Ograve: "\xD2",
    Oslash: "\xD8",
    Otilde: "\xD5",
    Ouml: "\xD6",
    QUOT: '"',
    REG: "\xAE",
    THORN: "\xDE",
    Uacute: "\xDA",
    Ucirc: "\xDB",
    Ugrave: "\xD9",
    Uuml: "\xDC",
    Yacute: "\xDD",
    aacute: "\xE1",
    acirc: "\xE2",
    acute: "\xB4",
    aelig: "\xE6",
    agrave: "\xE0",
    amp: "&",
    aring: "\xE5",
    atilde: "\xE3",
    auml: "\xE4",
    brvbar: "\xA6",
    ccedil: "\xE7",
    cedil: "\xB8",
    cent: "\xA2",
    copy: "\xA9",
    curren: "\xA4",
    deg: "\xB0",
    divide: "\xF7",
    eacute: "\xE9",
    ecirc: "\xEA",
    egrave: "\xE8",
    eth: "\xF0",
    euml: "\xEB",
    frac12: "\xBD",
    frac14: "\xBC",
    frac34: "\xBE",
    gt: ">",
    iacute: "\xED",
    icirc: "\xEE",
    iexcl: "\xA1",
    igrave: "\xEC",
    iquest: "\xBF",
    iuml: "\xEF",
    laquo: "\xAB",
    lt: "<",
    macr: "\xAF",
    micro: "\xB5",
    middot: "\xB7",
    nbsp: "\xA0",
    not: "\xAC",
    ntilde: "\xF1",
    oacute: "\xF3",
    ocirc: "\xF4",
    ograve: "\xF2",
    ordf: "\xAA",
    ordm: "\xBA",
    oslash: "\xF8",
    otilde: "\xF5",
    ouml: "\xF6",
    para: "\xB6",
    plusmn: "\xB1",
    pound: "\xA3",
    quot: '"',
    raquo: "\xBB",
    reg: "\xAE",
    sect: "\xA7",
    shy: "\xAD",
    sup1: "\xB9",
    sup2: "\xB2",
    sup3: "\xB3",
    szlig: "\xDF",
    thorn: "\xFE",
    times: "\xD7",
    uacute: "\xFA",
    ucirc: "\xFB",
    ugrave: "\xF9",
    uml: "\xA8",
    uuml: "\xFC",
    yacute: "\xFD",
    yen: "\xA5",
    yuml: "\xFF"
  };
});

// ../node_modules/refractor/node_modules/character-reference-invalid/index.json
var Ur = y((at, Sa) => {
  Sa.exports = {
    "0": "\uFFFD",
    "128": "\u20AC",
    "130": "\u201A",
    "131": "\u0192",
    "132": "\u201E",
    "133": "\u2026",
    "134": "\u2020",
    "135": "\u2021",
    "136": "\u02C6",
    "137": "\u2030",
    "138": "\u0160",
    "139": "\u2039",
    "140": "\u0152",
    "142": "\u017D",
    "145": "\u2018",
    "146": "\u2019",
    "147": "\u201C",
    "148": "\u201D",
    "149": "\u2022",
    "150": "\u2013",
    "151": "\u2014",
    "152": "\u02DC",
    "153": "\u2122",
    "154": "\u0161",
    "155": "\u203A",
    "156": "\u0153",
    "158": "\u017E",
    "159": "\u0178"
  };
});

// ../node_modules/refractor/node_modules/is-decimal/index.js
var Te = y((lt, jr) => {
  "use strict";
  jr.exports = qa;
  function qa(e) {
    var r = typeof e == "string" ? e.charCodeAt(0) : e;
    return r >= 48 && r <= 57;
  }
  n(qa, "decimal");
});

// ../node_modules/refractor/node_modules/is-hexadecimal/index.js
var Hr = y((it, zr) => {
  "use strict";
  zr.exports = Aa;
  function Aa(e) {
    var r = typeof e == "string" ? e.charCodeAt(0) : e;
    return r >= 97 && r <= 102 || r >= 65 && r <= 70 || r >= 48 && r <= 57;
  }
  n(Aa, "hexadecimal");
});

// ../node_modules/refractor/node_modules/is-alphabetical/index.js
var Wr = y((ut, Br) => {
  "use strict";
  Br.exports = Pa;
  function Pa(e) {
    var r = typeof e == "string" ? e.charCodeAt(0) : e;
    return r >= 97 && r <= 122 || r >= 65 && r <= 90;
  }
  n(Pa, "alphabetical");
});

// ../node_modules/refractor/node_modules/is-alphanumerical/index.js
var Vr = y((ct, Fr) => {
  "use strict";
  var Ea = Wr(), La = Te();
  Fr.exports = ka;
  function ka(e) {
    return Ea(e) || La(e);
  }
  n(ka, "alphanumerical");
});

// ../node_modules/refractor/node_modules/parse-entities/decode-entity.browser.js
var Kr = y((dt, Gr) => {
  "use strict";
  var ve, Ta = 59;
  Gr.exports = Ma;
  function Ma(e) {
    var r = "&" + e + ";", a;
    return ve = ve || document.createElement("i"), ve.innerHTML = r, a = ve.textContent, a.charCodeAt(a.length - 1) === Ta && e !== "semi" || a === r ? !1 : a;
  }
  n(Ma, "decodeEntity");
});

// ../node_modules/refractor/node_modules/parse-entities/index.js
var on = y((gt, tn) => {
  "use strict";
  var $r = Rr(), Xr = Ur(), Oa = Te(), Ia = Hr(), Zr = Vr(), Da = Kr();
  tn.exports = $a;
  var Na = {}.hasOwnProperty, ne = String.fromCharCode, Ra = Function.prototype, Jr = {
    warning: null,
    reference: null,
    text: null,
    warningContext: null,
    referenceContext: null,
    textContext: null,
    position: {},
    additional: null,
    attribute: !1,
    nonTerminated: !0
  }, Ua = 9, Yr = 10, ja = 12, za = 32, Qr = 38, Ha = 59, Ba = 60, Wa = 61, Fa = 35, Va = 88, Ga = 120, Ka = 65533, ae = "named", Oe = "hexadecimal", Ie = "decimal", De = {};
  De[Oe] = 16;
  De[Ie] = 10;
  var he = {};
  he[ae] = Zr;
  he[Ie] = Oa;
  he[Oe] = Ia;
  var _r = 1, en = 2, rn = 3, nn = 4, an = 5, Me = 6, ln = 7, K = {};
  K[_r] = "Named character references must be terminated by a semicolon";
  K[en] = "Numeric character references must be terminated by a semicolon";
  K[rn] = "Named character references cannot be empty";
  K[nn] = "Numeric character references cannot be empty";
  K[an] = "Named character references must be known";
  K[Me] = "Numeric character references cannot be disallowed";
  K[ln] = "Numeric character references cannot be outside the permissible Unicode range";
  function $a(e, r) {
    var a = {}, o, l;
    r || (r = {});
    for (l in Jr)
      o = r[l], a[l] = o ?? Jr[l];
    return (a.position.indent || a.position.start) && (a.indent = a.position.indent || [], a.position = a.position.start), Xa(e, a);
  }
  n($a, "parseEntities");
  function Xa(e, r) {
    var a = r.additional, o = r.nonTerminated, l = r.text, d = r.reference, x = r.warning, C = r.textContext, v = r.referenceContext, P = r.warningContext, M = r.position, E = r.indent || [], B = e.length, N = 0, le = -1, i = M.column || 1, t = M.line || 1, u = "", s = [], c, p, m, f, S, h, b, D, $, te, W, V, A, L, F, H, T, R, w;
    for (typeof a == "string" && (a = a.charCodeAt(0)), H = z(), D = x ? Z : Ra, N--, B++; ++N < B; )
      if (S === Yr && (i = E[le] || 1), S = e.charCodeAt(N), S === Qr) {
        if (b = e.charCodeAt(N + 1), b === Ua || b === Yr || b === ja || b === za || b === Qr || b === Ba || b !== b || a && b === a) {
          u += ne(S), i++;
          continue;
        }
        for (A = N + 1, V = A, w = A, b === Fa ? (w = ++V, b = e.charCodeAt(w), b === Va || b === Ga ? (L = Oe, w = ++V) : L = Ie) : L = ae, c = "", W = "", f = "", F = he[L], w--; ++w < B && (b = e.charCodeAt(w), !!F(b)); )
          f += ne(b), L === ae && Na.call($r, f) && (c = f, W = $r[f]);
        m = e.charCodeAt(w) === Ha, m && (w++, p = L === ae ? Da(f) : !1, p && (c = f, W = p)), R = 1 + w - A, !m && !o || (f ? L === ae ? (m && !W ? D(an, 1) : (c !== f && (w = V + c.length, R = 1 + w - V, m = !1), m || ($ = c ? _r : rn, r.attribute ? (b = e.charCodeAt(w), b === Wa ? (D($, R), W = null) : Zr(b) ? W = null : D($, R)) : D($, R))), h = W) : (m || D(en, R), h = parseInt(f, De[L]), Ja(h) ? (D(ln, R), h = ne(Ka)) : h in Xr ? (D(Me, R), h = Xr[h]) : (te = "", Ya(h) && D(Me, R), h > 65535 && (h -= 65536, te += ne(h >>> 10 | 55296), h = 56320 | h & 1023), h = te + ne(h))) : L !== ae && D(nn, R)), h ? (X(), H = z(), N = w - 1, i += w - A + 1, s.push(h), T = z(), T.offset++, d && d.call(
          v,
          h,
          { start: H, end: T },
          e.slice(A - 1, w)
        ), H = T) : (f = e.slice(A - 1, w), u += f, i += f.length, N = w - 1);
      } else
        S === 10 && (t++, le++, i = 0), S === S ? (u += ne(S), i++) : X();
    return s.join("");
    function z() {
      return {
        line: t,
        column: i,
        offset: N + (M.offset || 0)
      };
    }
    function Z(_, ie) {
      var J = z();
      J.column += ie, J.offset += ie, x.call(P, K[_], J, _);
    }
    function X() {
      u && (s.push(u), l && l.call(C, u, { start: H, end: z() }), u = "");
    }
  }
  n(Xa, "parse");
  function Ja(e) {
    return e >= 55296 && e <= 57343 || e > 1114111;
  }
  n(Ja, "prohibited");
  function Ya(e) {
    return e >= 1 && e <= 8 || e === 11 || e >= 13 && e <= 31 || e >= 127 && e <= 159 || e >= 64976 && e <= 65007 || (e & 65535) === 65535 || (e & 65535) === 65534;
  }
  n(Ya, "disallowed");
});

// ../node_modules/refractor/node_modules/prismjs/components/prism-core.js
var sn = y((ht, me) => {
  var Qa = typeof window < "u" ? window : typeof WorkerGlobalScope < "u" && self instanceof WorkerGlobalScope ? self : {};
  var un = function(e) {
    var r = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i, a = 0, o = {}, l = {
      /**
       * By default, Prism will attempt to highlight all code elements (by calling {@link Prism.highlightAll}) on the
       * current page after the page finished loading. This might be a problem if e.g. you wanted to asynchronously load
       * additional languages or plugins yourself.
       *
       * By setting this value to `true`, Prism will not automatically highlight all code elements on the page.
       *
       * You obviously have to change this value before the automatic highlighting started. To do this, you can add an
       * empty Prism object into the global scope before loading the Prism script like this:
       *
       * ```js
       * window.Prism = window.Prism || {};
       * Prism.manual = true;
       * // add a new <script> to load Prism's script
       * ```
       *
       * @default false
       * @type {boolean}
       * @memberof Prism
       * @public
       */
      manual: e.Prism && e.Prism.manual,
      /**
       * By default, if Prism is in a web worker, it assumes that it is in a worker it created itself, so it uses
       * `addEventListener` to communicate with its parent instance. However, if you're using Prism manually in your
       * own worker, you don't want it to do this.
       *
       * By setting this value to `true`, Prism will not add its own listeners to the worker.
       *
       * You obviously have to change this value before Prism executes. To do this, you can add an
       * empty Prism object into the global scope before loading the Prism script like this:
       *
       * ```js
       * window.Prism = window.Prism || {};
       * Prism.disableWorkerMessageHandler = true;
       * // Load Prism's script
       * ```
       *
       * @default false
       * @type {boolean}
       * @memberof Prism
       * @public
       */
      disableWorkerMessageHandler: e.Prism && e.Prism.disableWorkerMessageHandler,
      /**
       * A namespace for utility methods.
       *
       * All function in this namespace that are not explicitly marked as _public_ are for __internal use only__ and may
       * change or disappear at any time.
       *
       * @namespace
       * @memberof Prism
       */
      util: {
        encode: /* @__PURE__ */ n(function i(t) {
          return t instanceof d ? new d(t.type, i(t.content), t.alias) : Array.isArray(t) ? t.map(i) : t.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/\u00a0/g, " ");
        }, "encode"),
        /**
         * Returns the name of the type of the given value.
         *
         * @param {any} o
         * @returns {string}
         * @example
         * type(null)      === 'Null'
         * type(undefined) === 'Undefined'
         * type(123)       === 'Number'
         * type('foo')     === 'String'
         * type(true)      === 'Boolean'
         * type([1, 2])    === 'Array'
         * type({})        === 'Object'
         * type(String)    === 'Function'
         * type(/abc+/)    === 'RegExp'
         */
        type: /* @__PURE__ */ n(function(i) {
          return Object.prototype.toString.call(i).slice(8, -1);
        }, "type"),
        /**
         * Returns a unique number for the given object. Later calls will still return the same number.
         *
         * @param {Object} obj
         * @returns {number}
         */
        objId: /* @__PURE__ */ n(function(i) {
          return i.__id || Object.defineProperty(i, "__id", { value: ++a }), i.__id;
        }, "objId"),
        /**
         * Creates a deep clone of the given object.
         *
         * The main intended use of this function is to clone language definitions.
         *
         * @param {T} o
         * @param {Record<number, any>} [visited]
         * @returns {T}
         * @template T
         */
        clone: /* @__PURE__ */ n(function i(t, u) {
          u = u || {};
          var s, c;
          switch (l.util.type(t)) {
            case "Object":
              if (c = l.util.objId(t), u[c])
                return u[c];
              s = /** @type {Record<string, any>} */
              {}, u[c] = s;
              for (var p in t)
                t.hasOwnProperty(p) && (s[p] = i(t[p], u));
              return (
                /** @type {any} */
                s
              );
            case "Array":
              return c = l.util.objId(t), u[c] ? u[c] : (s = [], u[c] = s, /** @type {Array} */
              /** @type {any} */
              t.forEach(function(m, f) {
                s[f] = i(m, u);
              }), /** @type {any} */
              s);
            default:
              return t;
          }
        }, "deepClone"),
        /**
         * Returns the Prism language of the given element set by a `language-xxxx` or `lang-xxxx` class.
         *
         * If no language is set for the element or the element is `null` or `undefined`, `none` will be returned.
         *
         * @param {Element} element
         * @returns {string}
         */
        getLanguage: /* @__PURE__ */ n(function(i) {
          for (; i; ) {
            var t = r.exec(i.className);
            if (t)
              return t[1].toLowerCase();
            i = i.parentElement;
          }
          return "none";
        }, "getLanguage"),
        /**
         * Sets the Prism `language-xxxx` class of the given element.
         *
         * @param {Element} element
         * @param {string} language
         * @returns {void}
         */
        setLanguage: /* @__PURE__ */ n(function(i, t) {
          i.className = i.className.replace(RegExp(r, "gi"), ""), i.classList.add("language-" + t);
        }, "setLanguage"),
        /**
         * Returns the script element that is currently executing.
         *
         * This does __not__ work for line script element.
         *
         * @returns {HTMLScriptElement | null}
         */
        currentScript: /* @__PURE__ */ n(function() {
          if (typeof document > "u")
            return null;
          if ("currentScript" in document)
            return (
              /** @type {any} */
              document.currentScript
            );
          try {
            throw new Error();
          } catch (s) {
            var i = (/at [^(\r\n]*\((.*):[^:]+:[^:]+\)$/i.exec(s.stack) || [])[1];
            if (i) {
              var t = document.getElementsByTagName("script");
              for (var u in t)
                if (t[u].src == i)
                  return t[u];
            }
            return null;
          }
        }, "currentScript"),
        /**
         * Returns whether a given class is active for `element`.
         *
         * The class can be activated if `element` or one of its ancestors has the given class and it can be deactivated
         * if `element` or one of its ancestors has the negated version of the given class. The _negated version_ of the
         * given class is just the given class with a `no-` prefix.
         *
         * Whether the class is active is determined by the closest ancestor of `element` (where `element` itself is
         * closest ancestor) that has the given class or the negated version of it. If neither `element` nor any of its
         * ancestors have the given class or the negated version of it, then the default activation will be returned.
         *
         * In the paradoxical situation where the closest ancestor contains __both__ the given class and the negated
         * version of it, the class is considered active.
         *
         * @param {Element} element
         * @param {string} className
         * @param {boolean} [defaultActivation=false]
         * @returns {boolean}
         */
        isActive: /* @__PURE__ */ n(function(i, t, u) {
          for (var s = "no-" + t; i; ) {
            var c = i.classList;
            if (c.contains(t))
              return !0;
            if (c.contains(s))
              return !1;
            i = i.parentElement;
          }
          return !!u;
        }, "isActive")
      },
      /**
       * This namespace contains all currently loaded languages and the some helper functions to create and modify languages.
       *
       * @namespace
       * @memberof Prism
       * @public
       */
      languages: {
        /**
         * The grammar for plain, unformatted text.
         */
        plain: o,
        plaintext: o,
        text: o,
        txt: o,
        /**
         * Creates a deep copy of the language with the given id and appends the given tokens.
         *
         * If a token in `redef` also appears in the copied language, then the existing token in the copied language
         * will be overwritten at its original position.
         *
         * ## Best practices
         *
         * Since the position of overwriting tokens (token in `redef` that overwrite tokens in the copied language)
         * doesn't matter, they can technically be in any order. However, this can be confusing to others that trying to
         * understand the language definition because, normally, the order of tokens matters in Prism grammars.
         *
         * Therefore, it is encouraged to order overwriting tokens according to the positions of the overwritten tokens.
         * Furthermore, all non-overwriting tokens should be placed after the overwriting ones.
         *
         * @param {string} id The id of the language to extend. This has to be a key in `Prism.languages`.
         * @param {Grammar} redef The new tokens to append.
         * @returns {Grammar} The new language created.
         * @public
         * @example
         * Prism.languages['css-with-colors'] = Prism.languages.extend('css', {
         *     // Prism.languages.css already has a 'comment' token, so this token will overwrite CSS' 'comment' token
         *     // at its original position
         *     'comment': { ... },
         *     // CSS doesn't have a 'color' token, so this token will be appended
         *     'color': /\b(?:red|green|blue)\b/
         * });
         */
        extend: /* @__PURE__ */ n(function(i, t) {
          var u = l.util.clone(l.languages[i]);
          for (var s in t)
            u[s] = t[s];
          return u;
        }, "extend"),
        /**
         * Inserts tokens _before_ another token in a language definition or any other grammar.
         *
         * ## Usage
         *
         * This helper method makes it easy to modify existing languages. For example, the CSS language definition
         * not only defines CSS highlighting for CSS documents, but also needs to define highlighting for CSS embedded
         * in HTML through `<style>` elements. To do this, it needs to modify `Prism.languages.markup` and add the
         * appropriate tokens. However, `Prism.languages.markup` is a regular JavaScript object literal, so if you do
         * this:
         *
         * ```js
         * Prism.languages.markup.style = {
         *     // token
         * };
         * ```
         *
         * then the `style` token will be added (and processed) at the end. `insertBefore` allows you to insert tokens
         * before existing tokens. For the CSS example above, you would use it like this:
         *
         * ```js
         * Prism.languages.insertBefore('markup', 'cdata', {
         *     'style': {
         *         // token
         *     }
         * });
         * ```
         *
         * ## Special cases
         *
         * If the grammars of `inside` and `insert` have tokens with the same name, the tokens in `inside`'s grammar
         * will be ignored.
         *
         * This behavior can be used to insert tokens after `before`:
         *
         * ```js
         * Prism.languages.insertBefore('markup', 'comment', {
         *     'comment': Prism.languages.markup.comment,
         *     // tokens after 'comment'
         * });
         * ```
         *
         * ## Limitations
         *
         * The main problem `insertBefore` has to solve is iteration order. Since ES2015, the iteration order for object
         * properties is guaranteed to be the insertion order (except for integer keys) but some browsers behave
         * differently when keys are deleted and re-inserted. So `insertBefore` can't be implemented by temporarily
         * deleting properties which is necessary to insert at arbitrary positions.
         *
         * To solve this problem, `insertBefore` doesn't actually insert the given tokens into the target object.
         * Instead, it will create a new object and replace all references to the target object with the new one. This
         * can be done without temporarily deleting properties, so the iteration order is well-defined.
         *
         * However, only references that can be reached from `Prism.languages` or `insert` will be replaced. I.e. if
         * you hold the target object in a variable, then the value of the variable will not change.
         *
         * ```js
         * var oldMarkup = Prism.languages.markup;
         * var newMarkup = Prism.languages.insertBefore('markup', 'comment', { ... });
         *
         * assert(oldMarkup !== Prism.languages.markup);
         * assert(newMarkup === Prism.languages.markup);
         * ```
         *
         * @param {string} inside The property of `root` (e.g. a language id in `Prism.languages`) that contains the
         * object to be modified.
         * @param {string} before The key to insert before.
         * @param {Grammar} insert An object containing the key-value pairs to be inserted.
         * @param {Object<string, any>} [root] The object containing `inside`, i.e. the object that contains the
         * object to be modified.
         *
         * Defaults to `Prism.languages`.
         * @returns {Grammar} The new grammar object.
         * @public
         */
        insertBefore: /* @__PURE__ */ n(function(i, t, u, s) {
          s = s || /** @type {any} */
          l.languages;
          var c = s[i], p = {};
          for (var m in c)
            if (c.hasOwnProperty(m)) {
              if (m == t)
                for (var f in u)
                  u.hasOwnProperty(f) && (p[f] = u[f]);
              u.hasOwnProperty(m) || (p[m] = c[m]);
            }
          var S = s[i];
          return s[i] = p, l.languages.DFS(l.languages, function(h, b) {
            b === S && h != i && (this[h] = p);
          }), p;
        }, "insertBefore"),
        // Traverse a language definition with Depth First Search
        DFS: /* @__PURE__ */ n(function i(t, u, s, c) {
          c = c || {};
          var p = l.util.objId;
          for (var m in t)
            if (t.hasOwnProperty(m)) {
              u.call(t, m, t[m], s || m);
              var f = t[m], S = l.util.type(f);
              S === "Object" && !c[p(f)] ? (c[p(f)] = !0, i(f, u, null, c)) : S === "Array" && !c[p(f)] && (c[p(f)] = !0, i(f, u, m, c));
            }
        }, "DFS")
      },
      plugins: {},
      /**
       * This is the most high-level function in Prism’s API.
       * It fetches all the elements that have a `.language-xxxx` class and then calls {@link Prism.highlightElement} on
       * each one of them.
       *
       * This is equivalent to `Prism.highlightAllUnder(document, async, callback)`.
       *
       * @param {boolean} [async=false] Same as in {@link Prism.highlightAllUnder}.
       * @param {HighlightCallback} [callback] Same as in {@link Prism.highlightAllUnder}.
       * @memberof Prism
       * @public
       */
      highlightAll: /* @__PURE__ */ n(function(i, t) {
        l.highlightAllUnder(document, i, t);
      }, "highlightAll"),
      /**
       * Fetches all the descendants of `container` that have a `.language-xxxx` class and then calls
       * {@link Prism.highlightElement} on each one of them.
       *
       * The following hooks will be run:
       * 1. `before-highlightall`
       * 2. `before-all-elements-highlight`
       * 3. All hooks of {@link Prism.highlightElement} for each element.
       *
       * @param {ParentNode} container The root element, whose descendants that have a `.language-xxxx` class will be highlighted.
       * @param {boolean} [async=false] Whether each element is to be highlighted asynchronously using Web Workers.
       * @param {HighlightCallback} [callback] An optional callback to be invoked on each element after its highlighting is done.
       * @memberof Prism
       * @public
       */
      highlightAllUnder: /* @__PURE__ */ n(function(i, t, u) {
        var s = {
          callback: u,
          container: i,
          selector: 'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'
        };
        l.hooks.run("before-highlightall", s), s.elements = Array.prototype.slice.apply(s.container.querySelectorAll(s.selector)), l.hooks.run("before-all-elements-highlight", s);
        for (var c = 0, p; p = s.elements[c++]; )
          l.highlightElement(p, t === !0, s.callback);
      }, "highlightAllUnder"),
      /**
       * Highlights the code inside a single element.
       *
       * The following hooks will be run:
       * 1. `before-sanity-check`
       * 2. `before-highlight`
       * 3. All hooks of {@link Prism.highlight}. These hooks will be run by an asynchronous worker if `async` is `true`.
       * 4. `before-insert`
       * 5. `after-highlight`
       * 6. `complete`
       *
       * Some the above hooks will be skipped if the element doesn't contain any text or there is no grammar loaded for
       * the element's language.
       *
       * @param {Element} element The element containing the code.
       * It must have a class of `language-xxxx` to be processed, where `xxxx` is a valid language identifier.
       * @param {boolean} [async=false] Whether the element is to be highlighted asynchronously using Web Workers
       * to improve performance and avoid blocking the UI when highlighting very large chunks of code. This option is
       * [disabled by default](https://prismjs.com/faq.html#why-is-asynchronous-highlighting-disabled-by-default).
       *
       * Note: All language definitions required to highlight the code must be included in the main `prism.js` file for
       * asynchronous highlighting to work. You can build your own bundle on the
       * [Download page](https://prismjs.com/download.html).
       * @param {HighlightCallback} [callback] An optional callback to be invoked after the highlighting is done.
       * Mostly useful when `async` is `true`, since in that case, the highlighting is done asynchronously.
       * @memberof Prism
       * @public
       */
      highlightElement: /* @__PURE__ */ n(function(i, t, u) {
        var s = l.util.getLanguage(i), c = l.languages[s];
        l.util.setLanguage(i, s);
        var p = i.parentElement;
        p && p.nodeName.toLowerCase() === "pre" && l.util.setLanguage(p, s);
        var m = i.textContent, f = {
          element: i,
          language: s,
          grammar: c,
          code: m
        };
        function S(b) {
          f.highlightedCode = b, l.hooks.run("before-insert", f), f.element.innerHTML = f.highlightedCode, l.hooks.run("after-highlight", f), l.hooks.run("complete", f), u && u.call(f.element);
        }
        if (n(S, "insertHighlightedCode"), l.hooks.run("before-sanity-check", f), p = f.element.parentElement, p && p.nodeName.toLowerCase() === "pre" && !p.hasAttribute("tabindex") && p.setAttribute("tabindex", "0"), !f.code) {
          l.hooks.run("complete", f), u && u.call(f.element);
          return;
        }
        if (l.hooks.run("before-highlight", f), !f.grammar) {
          S(l.util.encode(f.code));
          return;
        }
        if (t && e.Worker) {
          var h = new Worker(l.filename);
          h.onmessage = function(b) {
            S(b.data);
          }, h.postMessage(JSON.stringify({
            language: f.language,
            code: f.code,
            immediateClose: !0
          }));
        } else
          S(l.highlight(f.code, f.grammar, f.language));
      }, "highlightElement"),
      /**
       * Low-level function, only use if you know what you’re doing. It accepts a string of text as input
       * and the language definitions to use, and returns a string with the HTML produced.
       *
       * The following hooks will be run:
       * 1. `before-tokenize`
       * 2. `after-tokenize`
       * 3. `wrap`: On each {@link Token}.
       *
       * @param {string} text A string with the code to be highlighted.
       * @param {Grammar} grammar An object containing the tokens to use.
       *
       * Usually a language definition like `Prism.languages.markup`.
       * @param {string} language The name of the language definition passed to `grammar`.
       * @returns {string} The highlighted HTML.
       * @memberof Prism
       * @public
       * @example
       * Prism.highlight('var foo = true;', Prism.languages.javascript, 'javascript');
       */
      highlight: /* @__PURE__ */ n(function(i, t, u) {
        var s = {
          code: i,
          grammar: t,
          language: u
        };
        if (l.hooks.run("before-tokenize", s), !s.grammar)
          throw new Error('The language "' + s.language + '" has no grammar.');
        return s.tokens = l.tokenize(s.code, s.grammar), l.hooks.run("after-tokenize", s), d.stringify(l.util.encode(s.tokens), s.language);
      }, "highlight"),
      /**
       * This is the heart of Prism, and the most low-level function you can use. It accepts a string of text as input
       * and the language definitions to use, and returns an array with the tokenized code.
       *
       * When the language definition includes nested tokens, the function is called recursively on each of these tokens.
       *
       * This method could be useful in other contexts as well, as a very crude parser.
       *
       * @param {string} text A string with the code to be highlighted.
       * @param {Grammar} grammar An object containing the tokens to use.
       *
       * Usually a language definition like `Prism.languages.markup`.
       * @returns {TokenStream} An array of strings and tokens, a token stream.
       * @memberof Prism
       * @public
       * @example
       * let code = `var foo = 0;`;
       * let tokens = Prism.tokenize(code, Prism.languages.javascript);
       * tokens.forEach(token => {
       *     if (token instanceof Prism.Token && token.type === 'number') {
       *         console.log(`Found numeric literal: ${token.content}`);
       *     }
       * });
       */
      tokenize: /* @__PURE__ */ n(function(i, t) {
        var u = t.rest;
        if (u) {
          for (var s in u)
            t[s] = u[s];
          delete t.rest;
        }
        var c = new v();
        return P(c, c.head, i), C(i, c, t, c.head, 0), E(c);
      }, "tokenize"),
      /**
       * @namespace
       * @memberof Prism
       * @public
       */
      hooks: {
        all: {},
        /**
         * Adds the given callback to the list of callbacks for the given hook.
         *
         * The callback will be invoked when the hook it is registered for is run.
         * Hooks are usually directly run by a highlight function but you can also run hooks yourself.
         *
         * One callback function can be registered to multiple hooks and the same hook multiple times.
         *
         * @param {string} name The name of the hook.
         * @param {HookCallback} callback The callback function which is given environment variables.
         * @public
         */
        add: /* @__PURE__ */ n(function(i, t) {
          var u = l.hooks.all;
          u[i] = u[i] || [], u[i].push(t);
        }, "add"),
        /**
         * Runs a hook invoking all registered callbacks with the given environment variables.
         *
         * Callbacks will be invoked synchronously and in the order in which they were registered.
         *
         * @param {string} name The name of the hook.
         * @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.
         * @public
         */
        run: /* @__PURE__ */ n(function(i, t) {
          var u = l.hooks.all[i];
          if (!(!u || !u.length))
            for (var s = 0, c; c = u[s++]; )
              c(t);
        }, "run")
      },
      Token: d
    };
    e.Prism = l;
    function d(i, t, u, s) {
      this.type = i, this.content = t, this.alias = u, this.length = (s || "").length | 0;
    }
    n(d, "Token"), d.stringify = /* @__PURE__ */ n(function i(t, u) {
      if (typeof t == "string")
        return t;
      if (Array.isArray(t)) {
        var s = "";
        return t.forEach(function(S) {
          s += i(S, u);
        }), s;
      }
      var c = {
        type: t.type,
        content: i(t.content, u),
        tag: "span",
        classes: ["token", t.type],
        attributes: {},
        language: u
      }, p = t.alias;
      p && (Array.isArray(p) ? Array.prototype.push.apply(c.classes, p) : c.classes.push(p)), l.hooks.run("wrap", c);
      var m = "";
      for (var f in c.attributes)
        m += " " + f + '="' + (c.attributes[f] || "").replace(/"/g, "&quot;") + '"';
      return "<" + c.tag + ' class="' + c.classes.join(" ") + '"' + m + ">" + c.content + "</" + c.tag + ">";
    }, "stringify");
    function x(i, t, u, s) {
      i.lastIndex = t;
      var c = i.exec(u);
      if (c && s && c[1]) {
        var p = c[1].length;
        c.index += p, c[0] = c[0].slice(p);
      }
      return c;
    }
    n(x, "matchPattern");
    function C(i, t, u, s, c, p) {
      for (var m in u)
        if (!(!u.hasOwnProperty(m) || !u[m])) {
          var f = u[m];
          f = Array.isArray(f) ? f : [f];
          for (var S = 0; S < f.length; ++S) {
            if (p && p.cause == m + "," + S)
              return;
            var h = f[S], b = h.inside, D = !!h.lookbehind, $ = !!h.greedy, te = h.alias;
            if ($ && !h.pattern.global) {
              var W = h.pattern.toString().match(/[imsuy]*$/)[0];
              h.pattern = RegExp(h.pattern.source, W + "g");
            }
            for (var V = h.pattern || h, A = s.next, L = c; A !== t.tail && !(p && L >= p.reach); L += A.value.length, A = A.next) {
              var F = A.value;
              if (t.length > i.length)
                return;
              if (!(F instanceof d)) {
                var H = 1, T;
                if ($) {
                  if (T = x(V, L, i, D), !T || T.index >= i.length)
                    break;
                  var Z = T.index, R = T.index + T[0].length, w = L;
                  for (w += A.value.length; Z >= w; )
                    A = A.next, w += A.value.length;
                  if (w -= A.value.length, L = w, A.value instanceof d)
                    continue;
                  for (var z = A; z !== t.tail && (w < R || typeof z.value == "string"); z = z.next)
                    H++, w += z.value.length;
                  H--, F = i.slice(L, w), T.index -= L;
                } else if (T = x(V, 0, F, D), !T)
                  continue;
                var Z = T.index, X = T[0], _ = F.slice(0, Z), ie = F.slice(Z + X.length), J = L + F.length;
                p && J > p.reach && (p.reach = J);
                var fe = A.prev;
                _ && (fe = P(t, fe, _), L += _.length), M(t, fe, H);
                var pn = new d(m, b ? l.tokenize(X, b) : X, te, X);
                if (A = P(t, fe, pn), ie && P(t, A, ie), H > 1) {
                  var ye = {
                    cause: m + "," + S,
                    reach: J
                  };
                  C(i, t, u, A.prev, L, ye), p && ye.reach > p.reach && (p.reach = ye.reach);
                }
              }
            }
          }
        }
    }
    n(C, "matchGrammar");
    function v() {
      var i = { value: null, prev: null, next: null }, t = { value: null, prev: i, next: null };
      i.next = t, this.head = i, this.tail = t, this.length = 0;
    }
    n(v, "LinkedList");
    function P(i, t, u) {
      var s = t.next, c = { value: u, prev: t, next: s };
      return t.next = c, s.prev = c, i.length++, c;
    }
    n(P, "addAfter");
    function M(i, t, u) {
      for (var s = t.next, c = 0; c < u && s !== i.tail; c++)
        s = s.next;
      t.next = s, s.prev = t, i.length -= c;
    }
    n(M, "removeRange");
    function E(i) {
      for (var t = [], u = i.head.next; u !== i.tail; )
        t.push(u.value), u = u.next;
      return t;
    }
    if (n(E, "toArray"), !e.document)
      return e.addEventListener && (l.disableWorkerMessageHandler || e.addEventListener("message", function(i) {
        var t = JSON.parse(i.data), u = t.language, s = t.code, c = t.immediateClose;
        e.postMessage(l.highlight(s, l.languages[u], u)), c && e.close();
      }, !1)), l;
    var B = l.util.currentScript();
    B && (l.filename = B.src, B.hasAttribute("data-manual") && (l.manual = !0));
    function N() {
      l.manual || l.highlightAll();
    }
    if (n(N, "highlightAutomaticallyCallback"), !l.manual) {
      var le = document.readyState;
      le === "loading" || le === "interactive" && B && B.defer ? document.addEventListener("DOMContentLoaded", N) : window.requestAnimationFrame ? window.requestAnimationFrame(N) : window.setTimeout(N, 16);
    }
    return l;
  }(Qa);
  typeof me < "u" && me.exports && (me.exports = un);
  typeof global < "u" && (global.Prism = un);
});

// ../node_modules/refractor/core.js
var gl = y((yt, dn) => {
  var se = typeof globalThis == "object" ? globalThis : typeof self == "object" ? self : typeof window == "object" ? window : typeof global == "object" ? global : {}, Za = pl();
  se.Prism = { manual: !0, disableWorkerMessageHandler: !0 };
  var _a = Nr(), el = on(), cn = sn(), rl = mn(), nl = vn(), al = gn(), ll = hn();
  Za();
  var Ne = {}.hasOwnProperty;
  function fn() {
  }
  n(fn, "Refractor");
  fn.prototype = cn;
  var k = new fn();
  dn.exports = k;
  k.highlight = il;
  k.register = ce;
  k.alias = tl;
  k.registered = ol;
  k.listLanguages = ul;
  ce(rl);
  ce(nl);
  ce(al);
  ce(ll);
  k.util.encode = fl;
  k.Token.stringify = sl;
  function ce(e) {
    if (typeof e != "function" || !e.displayName)
      throw new Error("Expected `function` for `grammar`, got `" + e + "`");
    k.languages[e.displayName] === void 0 && e(k);
  }
  n(ce, "register");
  function tl(e, r) {
    var a = k.languages, o = e, l, d, x, C;
    r && (o = {}, o[e] = r);
    for (l in o)
      for (d = o[l], d = typeof d == "string" ? [d] : d, x = d.length, C = -1; ++C < x; )
        a[d[C]] = a[l];
  }
  n(tl, "alias");
  function il(e, r) {
    var a = cn.highlight, o;
    if (typeof e != "string")
      throw new Error("Expected `string` for `value`, got `" + e + "`");
    if (k.util.type(r) === "Object")
      o = r, r = null;
    else {
      if (typeof r != "string")
        throw new Error("Expected `string` for `name`, got `" + r + "`");
      if (Ne.call(k.languages, r))
        o = k.languages[r];
      else
        throw new Error("Unknown language: `" + r + "` is not registered");
    }
    return a.call(this, e, o, r);
  }
  n(il, "highlight");
  function ol(e) {
    if (typeof e != "string")
      throw new Error("Expected `string` for `language`, got `" + e + "`");
    return Ne.call(k.languages, e);
  }
  n(ol, "registered");
  function ul() {
    var e = k.languages, r = [], a;
    for (a in e)
      Ne.call(e, a) && typeof e[a] == "object" && r.push(a);
    return r;
  }
  n(ul, "listLanguages");
  function sl(e, r, a) {
    var o;
    return typeof e == "string" ? { type: "text", value: e } : k.util.type(e) === "Array" ? cl(e, r) : (o = {
      type: e.type,
      content: k.Token.stringify(e.content, r, a),
      tag: "span",
      classes: ["token", e.type],
      attributes: {},
      language: r,
      parent: a
    }, e.alias && (o.classes = o.classes.concat(e.alias)), k.hooks.run("wrap", o), _a(
      o.tag + "." + o.classes.join("."),
      dl(o.attributes),
      o.content
    ));
  }
  n(sl, "stringify");
  function cl(e, r) {
    for (var a = [], o = e.length, l = -1, d; ++l < o; )
      d = e[l], d !== "" && d !== null && d !== void 0 && a.push(d);
    for (l = -1, o = a.length; ++l < o; )
      d = a[l], a[l] = k.Token.stringify(d, r, a);
    return a;
  }
  n(cl, "stringifyAll");
  function fl(e) {
    return e;
  }
  n(fl, "encode");
  function dl(e) {
    var r;
    for (r in e)
      e[r] = el(e[r]);
    return e;
  }
  n(dl, "attributes");
  function pl() {
    var e = "Prism" in se, r = e ? se.Prism : void 0;
    return a;
    function a() {
      e ? se.Prism = r : delete se.Prism, e = void 0, r = void 0;
    }
  }
  n(pl, "capture");
});

export {
  gl as a
};
