sanity 3.94.1-next.5.ec6157041e → 3.94.1

package/dist/Refractor-Zss2QEe8.mjs

@@ -0,0 +1,2568 @@
+import { c as be, g as bn } from "./index-C9NvTy6s.mjs";
+import cn from "react";
+var Fe, xr;
+function xn() {
+  if (xr) return Fe;
+  xr = 1, Fe = n;
+  var t = Object.prototype.hasOwnProperty;
+  function n() {
+    for (var l = {}, e = 0; e < arguments.length; e++) {
+      var g = arguments[e];
+      for (var d in g)
+        t.call(g, d) && (l[d] = g[d]);
+    }
+    return l;
+  }
+  return Fe;
+}
+var qe, wr;
+function fn() {
+  if (wr) return qe;
+  wr = 1, qe = n;
+  var t = n.prototype;
+  t.space = null, t.normal = {}, t.property = {};
+  function n(l, e, g) {
+    this.property = l, this.normal = e, g && (this.space = g);
+  }
+  return qe;
+}
+var Ee, kr;
+function wn() {
+  if (kr) return Ee;
+  kr = 1;
+  var t = xn(), n = fn();
+  Ee = l;
+  function l(e) {
+    for (var g = e.length, d = [], c = [], a = -1, v, m; ++a < g; )
+      v = e[a], d.push(v.property), c.push(v.normal), m = v.space;
+    return new n(
+      t.apply(null, d),
+      t.apply(null, c),
+      m
+    );
+  }
+  return Ee;
+}
+var Re, Sr;
+function dr() {
+  if (Sr) return Re;
+  Sr = 1, Re = t;
+  function t(n) {
+    return n.toLowerCase();
+  }
+  return Re;
+}
+var Te, Ar;
+function dn() {
+  if (Ar) return Te;
+  Ar = 1, Te = n;
+  var t = n.prototype;
+  t.space = null, t.attribute = null, t.property = null, t.boolean = !1, t.booleanish = !1, t.overloadedBoolean = !1, t.number = !1, t.commaSeparated = !1, t.spaceSeparated = !1, t.commaOrSpaceSeparated = !1, t.mustUseProperty = !1, t.defined = !1;
+  function n(l, e) {
+    this.property = l, this.attribute = e;
+  }
+  return Te;
+}
+var W = {}, Cr;
+function pr() {
+  if (Cr) return W;
+  Cr = 1;
+  var t = 0;
+  W.boolean = n(), W.booleanish = n(), W.overloadedBoolean = n(), W.number = n(), W.spaceSeparated = n(), W.commaSeparated = n(), W.commaOrSpaceSeparated = n();
+  function n() {
+    return Math.pow(2, ++t);
+  }
+  return W;
+}
+var Ne, Fr;
+function pn() {
+  if (Fr) return Ne;
+  Fr = 1;
+  var t = dn(), n = pr();
+  Ne = g, g.prototype = new t(), g.prototype.defined = !0;
+  var l = [
+    "boolean",
+    "booleanish",
+    "overloadedBoolean",
+    "number",
+    "commaSeparated",
+    "spaceSeparated",
+    "commaOrSpaceSeparated"
+  ], e = l.length;
+  function g(c, a, v, m) {
+    var k = -1, h;
+    for (d(this, "space", m), t.call(this, c, a); ++k < e; )
+      h = l[k], d(this, h, (v & n[h]) === n[h]);
+  }
+  function d(c, a, v) {
+    v && (c[a] = v);
+  }
+  return Ne;
+}
+var Ie, qr;
+function pe() {
+  if (qr) return Ie;
+  qr = 1;
+  var t = dr(), n = fn(), l = pn();
+  Ie = e;
+  function e(g) {
+    var d = g.space, c = g.mustUseProperty || [], a = g.attributes || {}, v = g.properties, m = g.transform, k = {}, h = {}, x, A;
+    for (x in v)
+      A = new l(
+        x,
+        m(a, x),
+        v[x],
+        d
+      ), c.indexOf(x) !== -1 && (A.mustUseProperty = !0), k[x] = A, h[t(x)] = x, h[t(A.attribute)] = x;
+    return new n(k, h, d);
+  }
+  return Ie;
+}
+var Me, Er;
+function kn() {
+  if (Er) return Me;
+  Er = 1;
+  var t = pe();
+  Me = t({
+    space: "xlink",
+    transform: n,
+    properties: {
+      xLinkActuate: null,
+      xLinkArcRole: null,
+      xLinkHref: null,
+      xLinkRole: null,
+      xLinkShow: null,
+      xLinkTitle: null,
+      xLinkType: null
+    }
+  });
+  function n(l, e) {
+    return "xlink:" + e.slice(5).toLowerCase();
+  }
+  return Me;
+}
+var $e, Rr;
+function Sn() {
+  if (Rr) return $e;
+  Rr = 1;
+  var t = pe();
+  $e = t({
+    space: "xml",
+    transform: n,
+    properties: {
+      xmlLang: null,
+      xmlBase: null,
+      xmlSpace: null
+    }
+  });
+  function n(l, e) {
+    return "xml:" + e.slice(3).toLowerCase();
+  }
+  return $e;
+}
+var Oe, Tr;
+function An() {
+  if (Tr) return Oe;
+  Tr = 1, Oe = t;
+  function t(n, l) {
+    return l in n ? n[l] : l;
+  }
+  return Oe;
+}
+var Le, Nr;
+function gn() {
+  if (Nr) return Le;
+  Nr = 1;
+  var t = An();
+  Le = n;
+  function n(l, e) {
+    return t(l, e.toLowerCase());
+  }
+  return Le;
+}
+var je, Ir;
+function Cn() {
+  if (Ir) return je;
+  Ir = 1;
+  var t = pe(), n = gn();
+  return je = t({
+    space: "xmlns",
+    attributes: {
+      xmlnsxlink: "xmlns:xlink"
+    },
+    transform: n,
+    properties: {
+      xmlns: null,
+      xmlnsXLink: null
+    }
+  }), je;
+}
+var De, Mr;
+function Fn() {
+  if (Mr) return De;
+  Mr = 1;
+  var t = pr(), n = pe(), l = t.booleanish, e = t.number, g = t.spaceSeparated;
+  De = n({
+    transform: d,
+    properties: {
+      ariaActiveDescendant: null,
+      ariaAtomic: l,
+      ariaAutoComplete: null,
+      ariaBusy: l,
+      ariaChecked: l,
+      ariaColCount: e,
+      ariaColIndex: e,
+      ariaColSpan: e,
+      ariaControls: g,
+      ariaCurrent: null,
+      ariaDescribedBy: g,
+      ariaDetails: null,
+      ariaDisabled: l,
+      ariaDropEffect: g,
+      ariaErrorMessage: null,
+      ariaExpanded: l,
+      ariaFlowTo: g,
+      ariaGrabbed: l,
+      ariaHasPopup: null,
+      ariaHidden: l,
+      ariaInvalid: null,
+      ariaKeyShortcuts: null,
+      ariaLabel: null,
+      ariaLabelledBy: g,
+      ariaLevel: e,
+      ariaLive: null,
+      ariaModal: l,
+      ariaMultiLine: l,
+      ariaMultiSelectable: l,
+      ariaOrientation: null,
+      ariaOwns: g,
+      ariaPlaceholder: null,
+      ariaPosInSet: e,
+      ariaPressed: l,
+      ariaReadOnly: l,
+      ariaRelevant: null,
+      ariaRequired: l,
+      ariaRoleDescription: g,
+      ariaRowCount: e,
+      ariaRowIndex: e,
+      ariaRowSpan: e,
+      ariaSelected: l,
+      ariaSetSize: e,
+      ariaSort: null,
+      ariaValueMax: e,
+      ariaValueMin: e,
+      ariaValueNow: e,
+      ariaValueText: null,
+      role: null
+    }
+  });
+  function d(c, a) {
+    return a === "role" ? a : "aria-" + a.slice(4).toLowerCase();
+  }
+  return De;
+}
+var _e, $r;
+function qn() {
+  if ($r) return _e;
+  $r = 1;
+  var t = pr(), n = pe(), l = gn(), e = t.boolean, g = t.overloadedBoolean, d = t.booleanish, c = t.number, a = t.spaceSeparated, v = t.commaSeparated;
+  return _e = n({
+    space: "html",
+    attributes: {
+      acceptcharset: "accept-charset",
+      classname: "class",
+      htmlfor: "for",
+      httpequiv: "http-equiv"
+    },
+    transform: l,
+    mustUseProperty: ["checked", "multiple", "muted", "selected"],
+    properties: {
+      // Standard Properties.
+      abbr: null,
+      accept: v,
+      acceptCharset: a,
+      accessKey: a,
+      action: null,
+      allow: null,
+      allowFullScreen: e,
+      allowPaymentRequest: e,
+      allowUserMedia: e,
+      alt: null,
+      as: null,
+      async: e,
+      autoCapitalize: null,
+      autoComplete: a,
+      autoFocus: e,
+      autoPlay: e,
+      capture: e,
+      charSet: null,
+      checked: e,
+      cite: null,
+      className: a,
+      cols: c,
+      colSpan: null,
+      content: null,
+      contentEditable: d,
+      controls: e,
+      controlsList: a,
+      coords: c | v,
+      crossOrigin: null,
+      data: null,
+      dateTime: null,
+      decoding: null,
+      default: e,
+      defer: e,
+      dir: null,
+      dirName: null,
+      disabled: e,
+      download: g,
+      draggable: d,
+      encType: null,
+      enterKeyHint: null,
+      form: null,
+      formAction: null,
+      formEncType: null,
+      formMethod: null,
+      formNoValidate: e,
+      formTarget: null,
+      headers: a,
+      height: c,
+      hidden: e,
+      high: c,
+      href: null,
+      hrefLang: null,
+      htmlFor: a,
+      httpEquiv: a,
+      id: null,
+      imageSizes: null,
+      imageSrcSet: v,
+      inputMode: null,
+      integrity: null,
+      is: null,
+      isMap: e,
+      itemId: null,
+      itemProp: a,
+      itemRef: a,
+      itemScope: e,
+      itemType: a,
+      kind: null,
+      label: null,
+      lang: null,
+      language: null,
+      list: null,
+      loading: null,
+      loop: e,
+      low: c,
+      manifest: null,
+      max: null,
+      maxLength: c,
+      media: null,
+      method: null,
+      min: null,
+      minLength: c,
+      multiple: e,
+      muted: e,
+      name: null,
+      nonce: null,
+      noModule: e,
+      noValidate: e,
+      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: e,
+      optimum: c,
+      pattern: null,
+      ping: a,
+      placeholder: null,
+      playsInline: e,
+      poster: null,
+      preload: null,
+      readOnly: e,
+      referrerPolicy: null,
+      rel: a,
+      required: e,
+      reversed: e,
+      rows: c,
+      rowSpan: c,
+      sandbox: a,
+      scope: null,
+      scoped: e,
+      seamless: e,
+      selected: e,
+      shape: null,
+      size: c,
+      sizes: null,
+      slot: null,
+      span: c,
+      spellCheck: d,
+      src: null,
+      srcDoc: null,
+      srcLang: null,
+      srcSet: v,
+      start: c,
+      step: null,
+      style: null,
+      tabIndex: c,
+      target: null,
+      title: null,
+      translate: null,
+      type: null,
+      typeMustMatch: e,
+      useMap: null,
+      value: d,
+      width: c,
+      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: a,
+      // `<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: e,
+      // Lists. Use CSS to reduce space between items instead
+      declare: e,
+      // `<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: e,
+      // `<frame>`
+      noHref: e,
+      // `<area>`. Use no href instead of an explicit `nohref`
+      noShade: e,
+      // `<hr>`. Use background-color and height instead of borders
+      noWrap: e,
+      // `<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: d,
+      // `<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: e,
+      disableRemotePlayback: e,
+      prefix: null,
+      property: null,
+      results: c,
+      security: null,
+      unselectable: null
+    }
+  }), _e;
+}
+var Ue, Or;
+function En() {
+  if (Or) return Ue;
+  Or = 1;
+  var t = wn(), n = kn(), l = Sn(), e = Cn(), g = Fn(), d = qn();
+  return Ue = t([l, n, e, g, d]), Ue;
+}
+var Pe, Lr;
+function Rn() {
+  if (Lr) return Pe;
+  Lr = 1;
+  var t = dr(), n = pn(), l = dn(), e = "data";
+  Pe = a;
+  var g = /^data[-\w.:]+$/i, d = /-[a-z]/g, c = /[A-Z]/g;
+  function a(x, A) {
+    var y = t(A), S = A, w = l;
+    return y in x.normal ? x.property[x.normal[y]] : (y.length > 4 && y.slice(0, 4) === e && g.test(A) && (A.charAt(4) === "-" ? S = v(A) : A = m(A), w = n), new w(S, A));
+  }
+  function v(x) {
+    var A = x.slice(5).replace(d, h);
+    return e + A.charAt(0).toUpperCase() + A.slice(1);
+  }
+  function m(x) {
+    var A = x.slice(4);
+    return d.test(A) ? x : (A = A.replace(c, k), A.charAt(0) !== "-" && (A = "-" + A), e + A);
+  }
+  function k(x) {
+    return "-" + x.toLowerCase();
+  }
+  function h(x) {
+    return x.charAt(1).toUpperCase();
+  }
+  return Pe;
+}
+var ze, jr;
+function Tn() {
+  if (jr) return ze;
+  jr = 1, ze = n;
+  var t = /[#.]/g;
+  function n(l, e) {
+    for (var g = l || "", d = e || "div", c = {}, a = 0, v, m, k; a < g.length; )
+      t.lastIndex = a, k = t.exec(g), v = g.slice(a, k ? k.index : g.length), v && (m ? m === "#" ? c.id = v : c.className ? c.className.push(v) : c.className = [v] : d = v, a += v.length), k && (m = k[0], a++);
+    return { type: "element", tagName: d, properties: c, children: [] };
+  }
+  return ze;
+}
+var me = {}, Dr;
+function Nn() {
+  if (Dr) return me;
+  Dr = 1, me.parse = e, me.stringify = g;
+  var t = "", n = " ", l = /[ \t\n\r\f]+/g;
+  function e(d) {
+    var c = String(d || t).trim();
+    return c === t ? [] : c.split(l);
+  }
+  function g(d) {
+    return d.join(n).trim();
+  }
+  return me;
+}
+var ye = {}, _r;
+function In() {
+  if (_r) return ye;
+  _r = 1, ye.parse = e, ye.stringify = g;
+  var t = ",", n = " ", l = "";
+  function e(d) {
+    for (var c = [], a = String(d || l), v = a.indexOf(t), m = 0, k = !1, h; !k; )
+      v === -1 && (v = a.length, k = !0), h = a.slice(m, v).trim(), (h || !k) && c.push(h), m = v + 1, v = a.indexOf(t, m);
+    return c;
+  }
+  function g(d, c) {
+    var a = c || {}, v = a.padLeft === !1 ? l : n, m = a.padRight ? n : l;
+    return d[d.length - 1] === l && (d = d.concat(l)), d.join(m + t + v).trim();
+  }
+  return ye;
+}
+var He, Ur;
+function Mn() {
+  if (Ur) return He;
+  Ur = 1;
+  var t = Rn(), n = dr(), l = Tn(), e = Nn().parse, g = In().parse;
+  He = c;
+  var d = {}.hasOwnProperty;
+  function c(y, S, w) {
+    var C = w ? A(w) : null;
+    return u;
+    function u(f, o) {
+      var r = l(f, S), s = Array.prototype.slice.call(arguments, 2), b = r.tagName.toLowerCase(), p;
+      if (r.tagName = C && d.call(C, b) ? C[b] : b, o && a(o, r) && (s.unshift(o), o = null), o)
+        for (p in o)
+          i(r.properties, p, o[p]);
+      return m(r.children, s), r.tagName === "template" && (r.content = { type: "root", children: r.children }, r.children = []), r;
+    }
+    function i(f, o, r) {
+      var s, b, p;
+      r == null || r !== r || (s = t(y, o), b = s.property, p = r, typeof p == "string" && (s.spaceSeparated ? p = e(p) : s.commaSeparated ? p = g(p) : s.commaOrSpaceSeparated && (p = e(g(p).join(" ")))), b === "style" && typeof r != "string" && (p = x(p)), b === "className" && f.className && (p = f.className.concat(p)), f[b] = k(s, b, p));
+    }
+  }
+  function a(y, S) {
+    return typeof y == "string" || "length" in y || v(S.tagName, y);
+  }
+  function v(y, S) {
+    var w = S.type;
+    return y === "input" || !w || typeof w != "string" ? !1 : typeof S.children == "object" && "length" in S.children ? !0 : (w = w.toLowerCase(), y === "button" ? w !== "menu" && w !== "submit" && w !== "reset" && w !== "button" : "value" in S);
+  }
+  function m(y, S) {
+    var w, C;
+    if (typeof S == "string" || typeof S == "number") {
+      y.push({ type: "text", value: String(S) });
+      return;
+    }
+    if (typeof S == "object" && "length" in S) {
+      for (w = -1, C = S.length; ++w < C; )
+        m(y, S[w]);
+      return;
+    }
+    if (typeof S != "object" || !("type" in S))
+      throw new Error("Expected node, nodes, or string, got `" + S + "`");
+    y.push(S);
+  }
+  function k(y, S, w) {
+    var C, u, i;
+    if (typeof w != "object" || !("length" in w))
+      return h(y, S, w);
+    for (u = w.length, C = -1, i = []; ++C < u; )
+      i[C] = h(y, S, w[C]);
+    return i;
+  }
+  function h(y, S, w) {
+    var C = w;
+    return y.number || y.positiveNumber ? !isNaN(C) && C !== "" && (C = Number(C)) : (y.boolean || y.overloadedBoolean) && typeof C == "string" && (C === "" || n(w) === n(S)) && (C = !0), C;
+  }
+  function x(y) {
+    var S = [], w;
+    for (w in y)
+      S.push([w, y[w]].join(": "));
+    return S.join("; ");
+  }
+  function A(y) {
+    for (var S = y.length, w = -1, C = {}, u; ++w < S; )
+      u = y[w], C[u.toLowerCase()] = u;
+    return C;
+  }
+  return He;
+}
+var Be, Pr;
+function $n() {
+  if (Pr) return Be;
+  Pr = 1;
+  var t = En(), n = Mn(), l = n(t, "div");
+  return l.displayName = "html", Be = l, Be;
+}
+var We, zr;
+function On() {
+  return zr || (zr = 1, We = $n()), We;
+}
+const Ln = "Æ", jn = "&", Dn = "Á", _n = "Â", Un = "À", Pn = "Å", zn = "Ã", Hn = "Ä", Bn = "©", Wn = "Ç", Xn = "Ð", Vn = "É", Zn = "Ê", Gn = "È", Kn = "Ë", Jn = ">", Yn = "Í", Qn = "Î", ea = "Ì", ra = "Ï", na = "<", aa = "Ñ", ta = "Ó", ia = "Ô", la = "Ò", ua = "Ø", oa = "Õ", sa = "Ö", ca = '"', fa = "®", da = "Þ", pa = "Ú", ga = "Û", va = "Ù", ha = "Ü", ma = "Ý", ya = "á", ba = "â", xa = "´", wa = "æ", ka = "à", Sa = "&", Aa = "å", Ca = "ã", Fa = "ä", qa = "¦", Ea = "ç", Ra = "¸", Ta = "¢", Na = "©", Ia = "¤", Ma = "°", $a = "÷", Oa = "é", La = "ê", ja = "è", Da = "ð", _a = "ë", Ua = "½", Pa = "¼", za = "¾", Ha = ">", Ba = "í", Wa = "î", Xa = "¡", Va = "ì", Za = "¿", Ga = "ï", Ka = "«", Ja = "<", Ya = "¯", Qa = "µ", et = "·", rt = " ", nt = "¬", at = "ñ", tt = "ó", it = "ô", lt = "ò", ut = "ª", ot = "º", st = "ø", ct = "õ", ft = "ö", dt = "¶", pt = "±", gt = "£", vt = '"', ht = "»", mt = "®", yt = "§", bt = "­", xt = "¹", wt = "²", kt = "³", St = "ß", At = "þ", Ct = "×", Ft = "ú", qt = "û", Et = "ù", Rt = "¨", Tt = "ü", Nt = "ý", It = "¥", Mt = "ÿ", $t = {
+  AElig: Ln,
+  AMP: jn,
+  Aacute: Dn,
+  Acirc: _n,
+  Agrave: Un,
+  Aring: Pn,
+  Atilde: zn,
+  Auml: Hn,
+  COPY: Bn,
+  Ccedil: Wn,
+  ETH: Xn,
+  Eacute: Vn,
+  Ecirc: Zn,
+  Egrave: Gn,
+  Euml: Kn,
+  GT: Jn,
+  Iacute: Yn,
+  Icirc: Qn,
+  Igrave: ea,
+  Iuml: ra,
+  LT: na,
+  Ntilde: aa,
+  Oacute: ta,
+  Ocirc: ia,
+  Ograve: la,
+  Oslash: ua,
+  Otilde: oa,
+  Ouml: sa,
+  QUOT: ca,
+  REG: fa,
+  THORN: da,
+  Uacute: pa,
+  Ucirc: ga,
+  Ugrave: va,
+  Uuml: ha,
+  Yacute: ma,
+  aacute: ya,
+  acirc: ba,
+  acute: xa,
+  aelig: wa,
+  agrave: ka,
+  amp: Sa,
+  aring: Aa,
+  atilde: Ca,
+  auml: Fa,
+  brvbar: qa,
+  ccedil: Ea,
+  cedil: Ra,
+  cent: Ta,
+  copy: Na,
+  curren: Ia,
+  deg: Ma,
+  divide: $a,
+  eacute: Oa,
+  ecirc: La,
+  egrave: ja,
+  eth: Da,
+  euml: _a,
+  frac12: Ua,
+  frac14: Pa,
+  frac34: za,
+  gt: Ha,
+  iacute: Ba,
+  icirc: Wa,
+  iexcl: Xa,
+  igrave: Va,
+  iquest: Za,
+  iuml: Ga,
+  laquo: Ka,
+  lt: Ja,
+  macr: Ya,
+  micro: Qa,
+  middot: et,
+  nbsp: rt,
+  not: nt,
+  ntilde: at,
+  oacute: tt,
+  ocirc: it,
+  ograve: lt,
+  ordf: ut,
+  ordm: ot,
+  oslash: st,
+  otilde: ct,
+  ouml: ft,
+  para: dt,
+  plusmn: pt,
+  pound: gt,
+  quot: vt,
+  raquo: ht,
+  reg: mt,
+  sect: yt,
+  shy: bt,
+  sup1: xt,
+  sup2: wt,
+  sup3: kt,
+  szlig: St,
+  thorn: At,
+  times: Ct,
+  uacute: Ft,
+  ucirc: qt,
+  ugrave: Et,
+  uml: Rt,
+  uuml: Tt,
+  yacute: Nt,
+  yen: It,
+  yuml: Mt
+}, Ot = {
+  0: "�",
+  128: "€",
+  130: "‚",
+  131: "ƒ",
+  132: "„",
+  133: "…",
+  134: "†",
+  135: "‡",
+  136: "ˆ",
+  137: "‰",
+  138: "Š",
+  139: "‹",
+  140: "Œ",
+  142: "Ž",
+  145: "‘",
+  146: "’",
+  147: "“",
+  148: "”",
+  149: "•",
+  150: "–",
+  151: "—",
+  152: "˜",
+  153: "™",
+  154: "š",
+  155: "›",
+  156: "œ",
+  158: "ž",
+  159: "Ÿ"
+};
+var Xe, Hr;
+function vn() {
+  if (Hr) return Xe;
+  Hr = 1, Xe = t;
+  function t(n) {
+    var l = typeof n == "string" ? n.charCodeAt(0) : n;
+    return l >= 48 && l <= 57;
+  }
+  return Xe;
+}
+var Ve, Br;
+function Lt() {
+  if (Br) return Ve;
+  Br = 1, Ve = t;
+  function t(n) {
+    var l = typeof n == "string" ? n.charCodeAt(0) : n;
+    return l >= 97 && l <= 102 || l >= 65 && l <= 70 || l >= 48 && l <= 57;
+  }
+  return Ve;
+}
+var Ze, Wr;
+function jt() {
+  if (Wr) return Ze;
+  Wr = 1, Ze = t;
+  function t(n) {
+    var l = typeof n == "string" ? n.charCodeAt(0) : n;
+    return l >= 97 && l <= 122 || l >= 65 && l <= 90;
+  }
+  return Ze;
+}
+var Ge, Xr;
+function Dt() {
+  if (Xr) return Ge;
+  Xr = 1;
+  var t = jt(), n = vn();
+  Ge = l;
+  function l(e) {
+    return t(e) || n(e);
+  }
+  return Ge;
+}
+var Ke, Vr;
+function _t() {
+  if (Vr) return Ke;
+  Vr = 1;
+  var t, n = 59;
+  Ke = l;
+  function l(e) {
+    var g = "&" + e + ";", d;
+    return t = t || document.createElement("i"), t.innerHTML = g, d = t.textContent, d.charCodeAt(d.length - 1) === n && e !== "semi" || d === g ? !1 : d;
+  }
+  return Ke;
+}
+var Je, Zr;
+function Ut() {
+  if (Zr) return Je;
+  Zr = 1;
+  var t = $t, n = Ot, l = vn(), e = Lt(), g = Dt(), d = _t();
+  Je = D;
+  var c = {}.hasOwnProperty, a = String.fromCharCode, v = Function.prototype, m = {
+    warning: null,
+    reference: null,
+    text: null,
+    warningContext: null,
+    referenceContext: null,
+    textContext: null,
+    position: {},
+    additional: null,
+    attribute: !1,
+    nonTerminated: !0
+  }, k = 9, h = 10, x = 12, A = 32, y = 38, S = 59, w = 60, C = 61, u = 35, i = 88, f = 120, o = 65533, r = "named", s = "hexadecimal", b = "decimal", p = {};
+  p[s] = 16, p[b] = 10;
+  var F = {};
+  F[r] = g, F[b] = l, F[s] = e;
+  var q = 1, O = 2, H = 3, ie = 4, ge = 5, le = 6, ue = 7, R = {};
+  R[q] = "Named character references must be terminated by a semicolon", R[O] = "Numeric character references must be terminated by a semicolon", R[H] = "Named character references cannot be empty", R[ie] = "Numeric character references cannot be empty", R[ge] = "Named character references must be known", R[le] = "Numeric character references cannot be disallowed", R[ue] = "Numeric character references cannot be outside the permissible Unicode range";
+  function D(E, T) {
+    var N = {}, U, _;
+    T || (T = {});
+    for (_ in m)
+      U = T[_], N[_] = U ?? m[_];
+    return (N.position.indent || N.position.start) && (N.indent = N.position.indent || [], N.position = N.position.start), X(E, N);
+  }
+  function X(E, T) {
+    var N = T.additional, U = T.nonTerminated, _ = T.text, ne = T.reference, oe = T.warning, se = T.textContext, ae = T.referenceContext, xe = T.warningContext, G = T.position, mn = T.indent || [], we = E.length, V = 0, gr = -1, K = G.column || 1, vr = G.line || 1, J = "", ke = [], te, Se, Y, j, Z, M, I, P, ve, Ae, Q, ce, ee, B, hr, fe, he, z, $;
+    for (typeof N == "string" && (N = N.charCodeAt(0)), fe = de(), P = oe ? yn : v, V--, we++; ++V < we; )
+      if (Z === h && (K = mn[gr] || 1), Z = E.charCodeAt(V), Z === y) {
+        if (I = E.charCodeAt(V + 1), I === k || I === h || I === x || I === A || I === y || I === w || I !== I || N && I === N) {
+          J += a(Z), K++;
+          continue;
+        }
+        for (ee = V + 1, ce = ee, $ = ee, I === u ? ($ = ++ce, I = E.charCodeAt($), I === i || I === f ? (B = s, $ = ++ce) : B = b) : B = r, te = "", Q = "", j = "", hr = F[B], $--; ++$ < we && (I = E.charCodeAt($), !!hr(I)); )
+          j += a(I), B === r && c.call(t, j) && (te = j, Q = t[j]);
+        Y = E.charCodeAt($) === S, Y && ($++, Se = B === r ? d(j) : !1, Se && (te = j, Q = Se)), z = 1 + $ - ee, !Y && !U || (j ? B === r ? (Y && !Q ? P(ge, 1) : (te !== j && ($ = ce + te.length, z = 1 + $ - ce, Y = !1), Y || (ve = te ? q : H, T.attribute ? (I = E.charCodeAt($), I === C ? (P(ve, z), Q = null) : g(I) ? Q = null : P(ve, z)) : P(ve, z))), M = Q) : (Y || P(O, z), M = parseInt(j, p[B]), re(M) ? (P(ue, z), M = a(o)) : M in n ? (P(le, z), M = n[M]) : (Ae = "", L(M) && P(le, z), M > 65535 && (M -= 65536, Ae += a(M >>> 10 | 55296), M = 56320 | M & 1023), M = Ae + a(M))) : B !== r && P(ie, z)), M ? (mr(), fe = de(), V = $ - 1, K += $ - ee + 1, ke.push(M), he = de(), he.offset++, ne && ne.call(
+          ae,
+          M,
+          { start: fe, end: he },
+          E.slice(ee - 1, $)
+        ), fe = he) : (j = E.slice(ee - 1, $), J += j, K += j.length, V = $ - 1);
+      } else
+        Z === 10 && (vr++, gr++, K = 0), Z === Z ? (J += a(Z), K++) : mr();
+    return ke.join("");
+    function de() {
+      return {
+        line: vr,
+        column: K,
+        offset: V + (G.offset || 0)
+      };
+    }
+    function yn(yr, br) {
+      var Ce = de();
+      Ce.column += br, Ce.offset += br, oe.call(xe, R[yr], Ce, yr);
+    }
+    function mr() {
+      J && (ke.push(J), _ && _.call(se, J, { start: fe, end: de() }), J = "");
+    }
+  }
+  function re(E) {
+    return E >= 55296 && E <= 57343 || E > 1114111;
+  }
+  function L(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;
+  }
+  return Je;
+}
+var Ye = { exports: {} }, Gr;
+function Pt() {
+  return Gr || (Gr = 1, function(t) {
+    var n = typeof window < "u" ? window : typeof WorkerGlobalScope < "u" && self instanceof WorkerGlobalScope ? self : {};
+    /**
+     * Prism: Lightweight, robust, elegant syntax highlighting
+     *
+     * @license MIT <https://opensource.org/licenses/MIT>
+     * @author Lea Verou <https://lea.verou.me>
+     * @namespace
+     * @public
+     */
+    var l = function(e) {
+      var g = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i, d = 0, c = {}, a = {
+        /**
+         * 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: function u(i) {
+            return i instanceof v ? new v(i.type, u(i.content), i.alias) : Array.isArray(i) ? i.map(u) : i.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/\u00a0/g, " ");
+          },
+          /**
+           * Returns the name of the type of the given value.
+           *
+           * @param {any} o
+           * @returns {string}
+           * @example
+           * type(null)      === 'Null'
+           * type(undefined) === 'Undefined'
+           * type(123)       === 'Number'
+           * type('foo')     === 'String'
+           * type(true)      === 'Boolean'
+           * type([1, 2])    === 'Array'
+           * type({})        === 'Object'
+           * type(String)    === 'Function'
+           * type(/abc+/)    === 'RegExp'
+           */
+          type: function(u) {
+            return Object.prototype.toString.call(u).slice(8, -1);
+          },
+          /**
+           * Returns a unique number for the given object. Later calls will still return the same number.
+           *
+           * @param {Object} obj
+           * @returns {number}
+           */
+          objId: function(u) {
+            return u.__id || Object.defineProperty(u, "__id", { value: ++d }), u.__id;
+          },
+          /**
+           * Creates a deep clone of the given object.
+           *
+           * The main intended use of this function is to clone language definitions.
+           *
+           * @param {T} o
+           * @param {Record<number, any>} [visited]
+           * @returns {T}
+           * @template T
+           */
+          clone: function u(i, f) {
+            f = f || {};
+            var o, r;
+            switch (a.util.type(i)) {
+              case "Object":
+                if (r = a.util.objId(i), f[r])
+                  return f[r];
+                o = /** @type {Record<string, any>} */
+                {}, f[r] = o;
+                for (var s in i)
+                  i.hasOwnProperty(s) && (o[s] = u(i[s], f));
+                return (
+                  /** @type {any} */
+                  o
+                );
+              case "Array":
+                return r = a.util.objId(i), f[r] ? f[r] : (o = [], f[r] = o, /** @type {Array} */
+                /** @type {any} */
+                i.forEach(function(b, p) {
+                  o[p] = u(b, f);
+                }), /** @type {any} */
+                o);
+              default:
+                return i;
+            }
+          },
+          /**
+           * 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: function(u) {
+            for (; u; ) {
+              var i = g.exec(u.className);
+              if (i)
+                return i[1].toLowerCase();
+              u = u.parentElement;
+            }
+            return "none";
+          },
+          /**
+           * Sets the Prism `language-xxxx` class of the given element.
+           *
+           * @param {Element} element
+           * @param {string} language
+           * @returns {void}
+           */
+          setLanguage: function(u, i) {
+            u.className = u.className.replace(RegExp(g, "gi"), ""), u.classList.add("language-" + i);
+          },
+          /**
+           * Returns the script element that is currently executing.
+           *
+           * This does __not__ work for line script element.
+           *
+           * @returns {HTMLScriptElement | null}
+           */
+          currentScript: function() {
+            if (typeof document > "u")
+              return null;
+            if ("currentScript" in document)
+              return (
+                /** @type {any} */
+                document.currentScript
+              );
+            try {
+              throw new Error();
+            } catch (o) {
+              var u = (/at [^(\r\n]*\((.*):[^:]+:[^:]+\)$/i.exec(o.stack) || [])[1];
+              if (u) {
+                var i = document.getElementsByTagName("script");
+                for (var f in i)
+                  if (i[f].src == u)
+                    return i[f];
+              }
+              return null;
+            }
+          },
+          /**
+           * 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: function(u, i, f) {
+            for (var o = "no-" + i; u; ) {
+              var r = u.classList;
+              if (r.contains(i))
+                return !0;
+              if (r.contains(o))
+                return !1;
+              u = u.parentElement;
+            }
+            return !!f;
+          }
+        },
+        /**
+         * 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: c,
+          plaintext: c,
+          text: c,
+          txt: c,
+          /**
+           * Creates a deep copy of the language with the given id and appends the given tokens.
+           *
+           * If a token in `redef` also appears in the copied language, then the existing token in the copied language
+           * will be overwritten at its original position.
+           *
+           * ## Best practices
+           *
+           * Since the position of overwriting tokens (token in `redef` that overwrite tokens in the copied language)
+           * doesn't matter, they can technically be in any order. However, this can be confusing to others that trying to
+           * understand the language definition because, normally, the order of tokens matters in Prism grammars.
+           *
+           * Therefore, it is encouraged to order overwriting tokens according to the positions of the overwritten tokens.
+           * Furthermore, all non-overwriting tokens should be placed after the overwriting ones.
+           *
+           * @param {string} id The id of the language to extend. This has to be a key in `Prism.languages`.
+           * @param {Grammar} redef The new tokens to append.
+           * @returns {Grammar} The new language created.
+           * @public
+           * @example
+           * Prism.languages['css-with-colors'] = Prism.languages.extend('css', {
+           *     // Prism.languages.css already has a 'comment' token, so this token will overwrite CSS' 'comment' token
+           *     // at its original position
+           *     'comment': { ... },
+           *     // CSS doesn't have a 'color' token, so this token will be appended
+           *     'color': /\b(?:red|green|blue)\b/
+           * });
+           */
+          extend: function(u, i) {
+            var f = a.util.clone(a.languages[u]);
+            for (var o in i)
+              f[o] = i[o];
+            return f;
+          },
+          /**
+           * Inserts tokens _before_ another token in a language definition or any other grammar.
+           *
+           * ## Usage
+           *
+           * This helper method makes it easy to modify existing languages. For example, the CSS language definition
+           * not only defines CSS highlighting for CSS documents, but also needs to define highlighting for CSS embedded
+           * in HTML through `<style>` elements. To do this, it needs to modify `Prism.languages.markup` and add the
+           * appropriate tokens. However, `Prism.languages.markup` is a regular JavaScript object literal, so if you do
+           * this:
+           *
+           * ```js
+           * Prism.languages.markup.style = {
+           *     // token
+           * };
+           * ```
+           *
+           * then the `style` token will be added (and processed) at the end. `insertBefore` allows you to insert tokens
+           * before existing tokens. For the CSS example above, you would use it like this:
+           *
+           * ```js
+           * Prism.languages.insertBefore('markup', 'cdata', {
+           *     'style': {
+           *         // token
+           *     }
+           * });
+           * ```
+           *
+           * ## Special cases
+           *
+           * If the grammars of `inside` and `insert` have tokens with the same name, the tokens in `inside`'s grammar
+           * will be ignored.
+           *
+           * This behavior can be used to insert tokens after `before`:
+           *
+           * ```js
+           * Prism.languages.insertBefore('markup', 'comment', {
+           *     'comment': Prism.languages.markup.comment,
+           *     // tokens after 'comment'
+           * });
+           * ```
+           *
+           * ## Limitations
+           *
+           * The main problem `insertBefore` has to solve is iteration order. Since ES2015, the iteration order for object
+           * properties is guaranteed to be the insertion order (except for integer keys) but some browsers behave
+           * differently when keys are deleted and re-inserted. So `insertBefore` can't be implemented by temporarily
+           * deleting properties which is necessary to insert at arbitrary positions.
+           *
+           * To solve this problem, `insertBefore` doesn't actually insert the given tokens into the target object.
+           * Instead, it will create a new object and replace all references to the target object with the new one. This
+           * can be done without temporarily deleting properties, so the iteration order is well-defined.
+           *
+           * However, only references that can be reached from `Prism.languages` or `insert` will be replaced. I.e. if
+           * you hold the target object in a variable, then the value of the variable will not change.
+           *
+           * ```js
+           * var oldMarkup = Prism.languages.markup;
+           * var newMarkup = Prism.languages.insertBefore('markup', 'comment', { ... });
+           *
+           * assert(oldMarkup !== Prism.languages.markup);
+           * assert(newMarkup === Prism.languages.markup);
+           * ```
+           *
+           * @param {string} inside The property of `root` (e.g. a language id in `Prism.languages`) that contains the
+           * object to be modified.
+           * @param {string} before The key to insert before.
+           * @param {Grammar} insert An object containing the key-value pairs to be inserted.
+           * @param {Object<string, any>} [root] The object containing `inside`, i.e. the object that contains the
+           * object to be modified.
+           *
+           * Defaults to `Prism.languages`.
+           * @returns {Grammar} The new grammar object.
+           * @public
+           */
+          insertBefore: function(u, i, f, o) {
+            o = o || /** @type {any} */
+            a.languages;
+            var r = o[u], s = {};
+            for (var b in r)
+              if (r.hasOwnProperty(b)) {
+                if (b == i)
+                  for (var p in f)
+                    f.hasOwnProperty(p) && (s[p] = f[p]);
+                f.hasOwnProperty(b) || (s[b] = r[b]);
+              }
+            var F = o[u];
+            return o[u] = s, a.languages.DFS(a.languages, function(q, O) {
+              O === F && q != u && (this[q] = s);
+            }), s;
+          },
+          // Traverse a language definition with Depth First Search
+          DFS: function u(i, f, o, r) {
+            r = r || {};
+            var s = a.util.objId;
+            for (var b in i)
+              if (i.hasOwnProperty(b)) {
+                f.call(i, b, i[b], o || b);
+                var p = i[b], F = a.util.type(p);
+                F === "Object" && !r[s(p)] ? (r[s(p)] = !0, u(p, f, null, r)) : F === "Array" && !r[s(p)] && (r[s(p)] = !0, u(p, f, b, r));
+              }
+          }
+        },
+        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: function(u, i) {
+          a.highlightAllUnder(document, u, i);
+        },
+        /**
+         * 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: function(u, i, f) {
+          var o = {
+            callback: f,
+            container: u,
+            selector: 'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'
+          };
+          a.hooks.run("before-highlightall", o), o.elements = Array.prototype.slice.apply(o.container.querySelectorAll(o.selector)), a.hooks.run("before-all-elements-highlight", o);
+          for (var r = 0, s; s = o.elements[r++]; )
+            a.highlightElement(s, i === !0, o.callback);
+        },
+        /**
+         * 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: function(u, i, f) {
+          var o = a.util.getLanguage(u), r = a.languages[o];
+          a.util.setLanguage(u, o);
+          var s = u.parentElement;
+          s && s.nodeName.toLowerCase() === "pre" && a.util.setLanguage(s, o);
+          var b = u.textContent, p = {
+            element: u,
+            language: o,
+            grammar: r,
+            code: b
+          };
+          function F(O) {
+            p.highlightedCode = O, a.hooks.run("before-insert", p), p.element.innerHTML = p.highlightedCode, a.hooks.run("after-highlight", p), a.hooks.run("complete", p), f && f.call(p.element);
+          }
+          if (a.hooks.run("before-sanity-check", p), s = p.element.parentElement, s && s.nodeName.toLowerCase() === "pre" && !s.hasAttribute("tabindex") && s.setAttribute("tabindex", "0"), !p.code) {
+            a.hooks.run("complete", p), f && f.call(p.element);
+            return;
+          }
+          if (a.hooks.run("before-highlight", p), !p.grammar) {
+            F(a.util.encode(p.code));
+            return;
+          }
+          if (i && e.Worker) {
+            var q = new Worker(a.filename);
+            q.onmessage = function(O) {
+              F(O.data);
+            }, q.postMessage(JSON.stringify({
+              language: p.language,
+              code: p.code,
+              immediateClose: !0
+            }));
+          } else
+            F(a.highlight(p.code, p.grammar, p.language));
+        },
+        /**
+         * Low-level function, only use if you know what you’re doing. It accepts a string of text as input
+         * and the language definitions to use, and returns a string with the HTML produced.
+         *
+         * The following hooks will be run:
+         * 1. `before-tokenize`
+         * 2. `after-tokenize`
+         * 3. `wrap`: On each {@link Token}.
+         *
+         * @param {string} text A string with the code to be highlighted.
+         * @param {Grammar} grammar An object containing the tokens to use.
+         *
+         * Usually a language definition like `Prism.languages.markup`.
+         * @param {string} language The name of the language definition passed to `grammar`.
+         * @returns {string} The highlighted HTML.
+         * @memberof Prism
+         * @public
+         * @example
+         * Prism.highlight('var foo = true;', Prism.languages.javascript, 'javascript');
+         */
+        highlight: function(u, i, f) {
+          var o = {
+            code: u,
+            grammar: i,
+            language: f
+          };
+          if (a.hooks.run("before-tokenize", o), !o.grammar)
+            throw new Error('The language "' + o.language + '" has no grammar.');
+          return o.tokens = a.tokenize(o.code, o.grammar), a.hooks.run("after-tokenize", o), v.stringify(a.util.encode(o.tokens), o.language);
+        },
+        /**
+         * This is the heart of Prism, and the most low-level function you can use. It accepts a string of text as input
+         * and the language definitions to use, and returns an array with the tokenized code.
+         *
+         * When the language definition includes nested tokens, the function is called recursively on each of these tokens.
+         *
+         * This method could be useful in other contexts as well, as a very crude parser.
+         *
+         * @param {string} text A string with the code to be highlighted.
+         * @param {Grammar} grammar An object containing the tokens to use.
+         *
+         * Usually a language definition like `Prism.languages.markup`.
+         * @returns {TokenStream} An array of strings and tokens, a token stream.
+         * @memberof Prism
+         * @public
+         * @example
+         * let code = `var foo = 0;`;
+         * let tokens = Prism.tokenize(code, Prism.languages.javascript);
+         * tokens.forEach(token => {
+         *     if (token instanceof Prism.Token && token.type === 'number') {
+         *         console.log(`Found numeric literal: ${token.content}`);
+         *     }
+         * });
+         */
+        tokenize: function(u, i) {
+          var f = i.rest;
+          if (f) {
+            for (var o in f)
+              i[o] = f[o];
+            delete i.rest;
+          }
+          var r = new h();
+          return x(r, r.head, u), k(u, r, i, r.head, 0), y(r);
+        },
+        /**
+         * @namespace
+         * @memberof Prism
+         * @public
+         */
+        hooks: {
+          all: {},
+          /**
+           * Adds the given callback to the list of callbacks for the given hook.
+           *
+           * The callback will be invoked when the hook it is registered for is run.
+           * Hooks are usually directly run by a highlight function but you can also run hooks yourself.
+           *
+           * One callback function can be registered to multiple hooks and the same hook multiple times.
+           *
+           * @param {string} name The name of the hook.
+           * @param {HookCallback} callback The callback function which is given environment variables.
+           * @public
+           */
+          add: function(u, i) {
+            var f = a.hooks.all;
+            f[u] = f[u] || [], f[u].push(i);
+          },
+          /**
+           * Runs a hook invoking all registered callbacks with the given environment variables.
+           *
+           * Callbacks will be invoked synchronously and in the order in which they were registered.
+           *
+           * @param {string} name The name of the hook.
+           * @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.
+           * @public
+           */
+          run: function(u, i) {
+            var f = a.hooks.all[u];
+            if (!(!f || !f.length))
+              for (var o = 0, r; r = f[o++]; )
+                r(i);
+          }
+        },
+        Token: v
+      };
+      e.Prism = a;
+      function v(u, i, f, o) {
+        this.type = u, this.content = i, this.alias = f, this.length = (o || "").length | 0;
+      }
+      v.stringify = function u(i, f) {
+        if (typeof i == "string")
+          return i;
+        if (Array.isArray(i)) {
+          var o = "";
+          return i.forEach(function(F) {
+            o += u(F, f);
+          }), o;
+        }
+        var r = {
+          type: i.type,
+          content: u(i.content, f),
+          tag: "span",
+          classes: ["token", i.type],
+          attributes: {},
+          language: f
+        }, s = i.alias;
+        s && (Array.isArray(s) ? Array.prototype.push.apply(r.classes, s) : r.classes.push(s)), a.hooks.run("wrap", r);
+        var b = "";
+        for (var p in r.attributes)
+          b += " " + p + '="' + (r.attributes[p] || "").replace(/"/g, "&quot;") + '"';
+        return "<" + r.tag + ' class="' + r.classes.join(" ") + '"' + b + ">" + r.content + "</" + r.tag + ">";
+      };
+      function m(u, i, f, o) {
+        u.lastIndex = i;
+        var r = u.exec(f);
+        if (r && o && r[1]) {
+          var s = r[1].length;
+          r.index += s, r[0] = r[0].slice(s);
+        }
+        return r;
+      }
+      function k(u, i, f, o, r, s) {
+        for (var b in f)
+          if (!(!f.hasOwnProperty(b) || !f[b])) {
+            var p = f[b];
+            p = Array.isArray(p) ? p : [p];
+            for (var F = 0; F < p.length; ++F) {
+              if (s && s.cause == b + "," + F)
+                return;
+              var q = p[F], O = q.inside, H = !!q.lookbehind, ie = !!q.greedy, ge = q.alias;
+              if (ie && !q.pattern.global) {
+                var le = q.pattern.toString().match(/[imsuy]*$/)[0];
+                q.pattern = RegExp(q.pattern.source, le + "g");
+              }
+              for (var ue = q.pattern || q, R = o.next, D = r; R !== i.tail && !(s && D >= s.reach); D += R.value.length, R = R.next) {
+                var X = R.value;
+                if (i.length > u.length)
+                  return;
+                if (!(X instanceof v)) {
+                  var re = 1, L;
+                  if (ie) {
+                    if (L = m(ue, D, u, H), !L || L.index >= u.length)
+                      break;
+                    var U = L.index, E = L.index + L[0].length, T = D;
+                    for (T += R.value.length; U >= T; )
+                      R = R.next, T += R.value.length;
+                    if (T -= R.value.length, D = T, R.value instanceof v)
+                      continue;
+                    for (var N = R; N !== i.tail && (T < E || typeof N.value == "string"); N = N.next)
+                      re++, T += N.value.length;
+                    re--, X = u.slice(D, T), L.index -= D;
+                  } else if (L = m(ue, 0, X, H), !L)
+                    continue;
+                  var U = L.index, _ = L[0], ne = X.slice(0, U), oe = X.slice(U + _.length), se = D + X.length;
+                  s && se > s.reach && (s.reach = se);
+                  var ae = R.prev;
+                  ne && (ae = x(i, ae, ne), D += ne.length), A(i, ae, re);
+                  var xe = new v(b, O ? a.tokenize(_, O) : _, ge, _);
+                  if (R = x(i, ae, xe), oe && x(i, R, oe), re > 1) {
+                    var G = {
+                      cause: b + "," + F,
+                      reach: se
+                    };
+                    k(u, i, f, R.prev, D, G), s && G.reach > s.reach && (s.reach = G.reach);
+                  }
+                }
+              }
+            }
+          }
+      }
+      function h() {
+        var u = { value: null, prev: null, next: null }, i = { value: null, prev: u, next: null };
+        u.next = i, this.head = u, this.tail = i, this.length = 0;
+      }
+      function x(u, i, f) {
+        var o = i.next, r = { value: f, prev: i, next: o };
+        return i.next = r, o.prev = r, u.length++, r;
+      }
+      function A(u, i, f) {
+        for (var o = i.next, r = 0; r < f && o !== u.tail; r++)
+          o = o.next;
+        i.next = o, o.prev = i, u.length -= r;
+      }
+      function y(u) {
+        for (var i = [], f = u.head.next; f !== u.tail; )
+          i.push(f.value), f = f.next;
+        return i;
+      }
+      if (!e.document)
+        return e.addEventListener && (a.disableWorkerMessageHandler || e.addEventListener("message", function(u) {
+          var i = JSON.parse(u.data), f = i.language, o = i.code, r = i.immediateClose;
+          e.postMessage(a.highlight(o, a.languages[f], f)), r && e.close();
+        }, !1)), a;
+      var S = a.util.currentScript();
+      S && (a.filename = S.src, S.hasAttribute("data-manual") && (a.manual = !0));
+      function w() {
+        a.manual || a.highlightAll();
+      }
+      if (!a.manual) {
+        var C = document.readyState;
+        C === "loading" || C === "interactive" && S && S.defer ? document.addEventListener("DOMContentLoaded", w) : window.requestAnimationFrame ? window.requestAnimationFrame(w) : window.setTimeout(w, 16);
+      }
+      return a;
+    }(n);
+    t.exports && (t.exports = l), typeof be < "u" && (be.Prism = l);
+  }(Ye)), Ye.exports;
+}
+var Qe, Kr;
+function zt() {
+  if (Kr) return Qe;
+  Kr = 1, Qe = t, t.displayName = "markup", t.aliases = ["html", "mathml", "svg", "xml", "ssml", "atom", "rss"];
+  function t(n) {
+    n.languages.markup = {
+      comment: {
+        pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
+        greedy: !0
+      },
+      prolog: {
+        pattern: /<\?[\s\S]+?\?>/,
+        greedy: !0
+      },
+      doctype: {
+        // https://www.w3.org/TR/xml/#NT-doctypedecl
+        pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
+        greedy: !0,
+        inside: {
+          "internal-subset": {
+            pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
+            lookbehind: !0,
+            greedy: !0,
+            inside: null
+            // see below
+          },
+          string: {
+            pattern: /"[^"]*"|'[^']*'/,
+            greedy: !0
+          },
+          punctuation: /^<!|>$|[[\]]/,
+          "doctype-tag": /^DOCTYPE/i,
+          name: /[^\s<>'"]+/
+        }
+      },
+      cdata: {
+        pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+        greedy: !0
+      },
+      tag: {
+        pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
+        greedy: !0,
+        inside: {
+          tag: {
+            pattern: /^<\/?[^\s>\/]+/,
+            inside: {
+              punctuation: /^<\/?/,
+              namespace: /^[^\s>\/:]+:/
+            }
+          },
+          "special-attr": [],
+          "attr-value": {
+            pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
+            inside: {
+              punctuation: [
+                {
+                  pattern: /^=/,
+                  alias: "attr-equals"
+                },
+                /"|'/
+              ]
+            }
+          },
+          punctuation: /\/?>/,
+          "attr-name": {
+            pattern: /[^\s>\/]+/,
+            inside: {
+              namespace: /^[^\s>\/:]+:/
+            }
+          }
+        }
+      },
+      entity: [
+        {
+          pattern: /&[\da-z]{1,8};/i,
+          alias: "named-entity"
+        },
+        /&#x?[\da-f]{1,8};/i
+      ]
+    }, n.languages.markup.tag.inside["attr-value"].inside.entity = n.languages.markup.entity, n.languages.markup.doctype.inside["internal-subset"].inside = n.languages.markup, n.hooks.add("wrap", function(l) {
+      l.type === "entity" && (l.attributes.title = l.content.value.replace(/&amp;/, "&"));
+    }), Object.defineProperty(n.languages.markup.tag, "addInlined", {
+      /**
+       * Adds an inlined language to markup.
+       *
+       * An example of an inlined language is CSS with `<style>` tags.
+       *
+       * @param {string} tagName The name of the tag that contains the inlined language. This name will be treated as
+       * case insensitive.
+       * @param {string} lang The language key.
+       * @example
+       * addInlined('style', 'css');
+       */
+      value: function(e, g) {
+        var d = {};
+        d["language-" + g] = {
+          pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
+          lookbehind: !0,
+          inside: n.languages[g]
+        }, d.cdata = /^<!\[CDATA\[|\]\]>$/i;
+        var c = {
+          "included-cdata": {
+            pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+            inside: d
+          }
+        };
+        c["language-" + g] = {
+          pattern: /[\s\S]+/,
+          inside: n.languages[g]
+        };
+        var a = {};
+        a[e] = {
+          pattern: RegExp(
+            /(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(
+              /__/g,
+              function() {
+                return e;
+              }
+            ),
+            "i"
+          ),
+          lookbehind: !0,
+          greedy: !0,
+          inside: c
+        }, n.languages.insertBefore("markup", "cdata", a);
+      }
+    }), Object.defineProperty(n.languages.markup.tag, "addAttribute", {
+      /**
+       * Adds an pattern to highlight languages embedded in HTML attributes.
+       *
+       * An example of an inlined language is CSS with `style` attributes.
+       *
+       * @param {string} attrName The name of the tag that contains the inlined language. This name will be treated as
+       * case insensitive.
+       * @param {string} lang The language key.
+       * @example
+       * addAttribute('style', 'css');
+       */
+      value: function(l, e) {
+        n.languages.markup.tag.inside["special-attr"].push({
+          pattern: RegExp(
+            /(^|["'\s])/.source + "(?:" + l + ")" + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source,
+            "i"
+          ),
+          lookbehind: !0,
+          inside: {
+            "attr-name": /^[^\s=]+/,
+            "attr-value": {
+              pattern: /=[\s\S]+/,
+              inside: {
+                value: {
+                  pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
+                  lookbehind: !0,
+                  alias: [e, "language-" + e],
+                  inside: n.languages[e]
+                },
+                punctuation: [
+                  {
+                    pattern: /^=/,
+                    alias: "attr-equals"
+                  },
+                  /"|'/
+                ]
+              }
+            }
+          }
+        });
+      }
+    }), n.languages.html = n.languages.markup, n.languages.mathml = n.languages.markup, n.languages.svg = n.languages.markup, n.languages.xml = n.languages.extend("markup", {}), n.languages.ssml = n.languages.xml, n.languages.atom = n.languages.xml, n.languages.rss = n.languages.xml;
+  }
+  return Qe;
+}
+var er, Jr;
+function Ht() {
+  if (Jr) return er;
+  Jr = 1, er = t, t.displayName = "css", t.aliases = [];
+  function t(n) {
+    (function(l) {
+      var e = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
+      l.languages.css = {
+        comment: /\/\*[\s\S]*?\*\//,
+        atrule: {
+          pattern: /@[\w-](?:[^;{\s]|\s+(?![\s{]))*(?:;|(?=\s*\{))/,
+          inside: {
+            rule: /^@[\w-]+/,
+            "selector-function-argument": {
+              pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
+              lookbehind: !0,
+              alias: "selector"
+            },
+            keyword: {
+              pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
+              lookbehind: !0
+            }
+            // See rest below
+          }
+        },
+        url: {
+          // https://drafts.csswg.org/css-values-3/#urls
+          pattern: RegExp(
+            "\\burl\\((?:" + e.source + "|" + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ")\\)",
+            "i"
+          ),
+          greedy: !0,
+          inside: {
+            function: /^url/i,
+            punctuation: /^\(|\)$/,
+            string: {
+              pattern: RegExp("^" + e.source + "$"),
+              alias: "url"
+            }
+          }
+        },
+        selector: {
+          pattern: RegExp(
+            `(^|[{}\\s])[^{}\\s](?:[^{};"'\\s]|\\s+(?![\\s{])|` + e.source + ")*(?=\\s*\\{)"
+          ),
+          lookbehind: !0
+        },
+        string: {
+          pattern: e,
+          greedy: !0
+        },
+        property: {
+          pattern: /(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,
+          lookbehind: !0
+        },
+        important: /!important\b/i,
+        function: {
+          pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i,
+          lookbehind: !0
+        },
+        punctuation: /[(){};:,]/
+      }, l.languages.css.atrule.inside.rest = l.languages.css;
+      var g = l.languages.markup;
+      g && (g.tag.addInlined("style", "css"), g.tag.addAttribute("style", "css"));
+    })(n);
+  }
+  return er;
+}
+var rr, Yr;
+function Bt() {
+  if (Yr) return rr;
+  Yr = 1, rr = t, t.displayName = "clike", t.aliases = [];
+  function t(n) {
+    n.languages.clike = {
+      comment: [
+        {
+          pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+          lookbehind: !0,
+          greedy: !0
+        },
+        {
+          pattern: /(^|[^\\:])\/\/.*/,
+          lookbehind: !0,
+          greedy: !0
+        }
+      ],
+      string: {
+        pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+        greedy: !0
+      },
+      "class-name": {
+        pattern: /(\b(?:class|extends|implements|instanceof|interface|new|trait)\s+|\bcatch\s+\()[\w.\\]+/i,
+        lookbehind: !0,
+        inside: {
+          punctuation: /[.\\]/
+        }
+      },
+      keyword: /\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\b/,
+      boolean: /\b(?:false|true)\b/,
+      function: /\b\w+(?=\()/,
+      number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
+      operator: /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/,
+      punctuation: /[{}[\];(),.:]/
+    };
+  }
+  return rr;
+}
+var nr, Qr;
+function Wt() {
+  if (Qr) return nr;
+  Qr = 1, nr = t, t.displayName = "javascript", t.aliases = ["js"];
+  function t(n) {
+    n.languages.javascript = n.languages.extend("clike", {
+      "class-name": [
+        n.languages.clike["class-name"],
+        {
+          pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,
+          lookbehind: !0
+        }
+      ],
+      keyword: [
+        {
+          pattern: /((?:^|\})\s*)catch\b/,
+          lookbehind: !0
+        },
+        {
+          pattern: /(^|[^.]|\.\.\.\s*)\b(?:as|assert(?=\s*\{)|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally(?=\s*(?:\{|$))|for|from(?=\s*(?:['"]|$))|function|(?:get|set)(?=\s*(?:[#\[$\w\xA0-\uFFFF]|$))|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/,
+          lookbehind: !0
+        }
+      ],
+      // Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)
+      function: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
+      number: {
+        pattern: RegExp(
+          /(^|[^\w$])/.source + "(?:" + // constant
+          (/NaN|Infinity/.source + "|" + // binary integer
+          /0[bB][01]+(?:_[01]+)*n?/.source + "|" + // octal integer
+          /0[oO][0-7]+(?:_[0-7]+)*n?/.source + "|" + // hexadecimal integer
+          /0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source + "|" + // decimal bigint
+          /\d+(?:_\d+)*n/.source + "|" + // decimal number (integer or float) but no bigint
+          /(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/.source) + ")" + /(?![\w$])/.source
+        ),
+        lookbehind: !0
+      },
+      operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/
+    }), n.languages.javascript["class-name"][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/, n.languages.insertBefore("javascript", "keyword", {
+      regex: {
+        // eslint-disable-next-line regexp/no-dupe-characters-character-class
+        pattern: /((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)\/(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/,
+        lookbehind: !0,
+        greedy: !0,
+        inside: {
+          "regex-source": {
+            pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
+            lookbehind: !0,
+            alias: "language-regex",
+            inside: n.languages.regex
+          },
+          "regex-delimiter": /^\/|\/$/,
+          "regex-flags": /^[a-z]+$/
+        }
+      },
+      // This must be declared before keyword because we use "function" inside the look-forward
+      "function-variable": {
+        pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,
+        alias: "function"
+      },
+      parameter: [
+        {
+          pattern: /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,
+          lookbehind: !0,
+          inside: n.languages.javascript
+        },
+        {
+          pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
+          lookbehind: !0,
+          inside: n.languages.javascript
+        },
+        {
+          pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
+          lookbehind: !0,
+          inside: n.languages.javascript
+        },
+        {
+          pattern: /((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/,
+          lookbehind: !0,
+          inside: n.languages.javascript
+        }
+      ],
+      constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/
+    }), n.languages.insertBefore("javascript", "string", {
+      hashbang: {
+        pattern: /^#!.*/,
+        greedy: !0,
+        alias: "comment"
+      },
+      "template-string": {
+        pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
+        greedy: !0,
+        inside: {
+          "template-punctuation": {
+            pattern: /^`|`$/,
+            alias: "string"
+          },
+          interpolation: {
+            pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
+            lookbehind: !0,
+            inside: {
+              "interpolation-punctuation": {
+                pattern: /^\$\{|\}$/,
+                alias: "punctuation"
+              },
+              rest: n.languages.javascript
+            }
+          },
+          string: /[\s\S]+/
+        }
+      },
+      "string-property": {
+        pattern: /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m,
+        lookbehind: !0,
+        greedy: !0,
+        alias: "property"
+      }
+    }), n.languages.insertBefore("javascript", "operator", {
+      "literal-property": {
+        pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
+        lookbehind: !0,
+        alias: "property"
+      }
+    }), n.languages.markup && (n.languages.markup.tag.addInlined("script", "javascript"), n.languages.markup.tag.addAttribute(
+      /on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)/.source,
+      "javascript"
+    )), n.languages.js = n.languages.javascript;
+  }
+  return nr;
+}
+var ar, en;
+function Xt() {
+  if (en) return ar;
+  en = 1;
+  var t = typeof globalThis == "object" ? globalThis : typeof self == "object" ? self : typeof window == "object" ? window : typeof be == "object" ? be : {}, n = o();
+  t.Prism = { manual: !0, disableWorkerMessageHandler: !0 };
+  var l = On(), e = Ut(), g = Pt(), d = zt(), c = Ht(), a = Bt(), v = Wt();
+  n();
+  var m = {}.hasOwnProperty;
+  function k() {
+  }
+  k.prototype = g;
+  var h = new k();
+  ar = h, h.highlight = y, h.register = x, h.alias = A, h.registered = S, h.listLanguages = w, x(d), x(c), x(a), x(v), h.util.encode = i, h.Token.stringify = C;
+  function x(r) {
+    if (typeof r != "function" || !r.displayName)
+      throw new Error("Expected `function` for `grammar`, got `" + r + "`");
+    h.languages[r.displayName] === void 0 && r(h);
+  }
+  function A(r, s) {
+    var b = h.languages, p = r, F, q, O, H;
+    s && (p = {}, p[r] = s);
+    for (F in p)
+      for (q = p[F], q = typeof q == "string" ? [q] : q, O = q.length, H = -1; ++H < O; )
+        b[q[H]] = b[F];
+  }
+  function y(r, s) {
+    var b = g.highlight, p;
+    if (typeof r != "string")
+      throw new Error("Expected `string` for `value`, got `" + r + "`");
+    if (h.util.type(s) === "Object")
+      p = s, s = null;
+    else {
+      if (typeof s != "string")
+        throw new Error("Expected `string` for `name`, got `" + s + "`");
+      if (m.call(h.languages, s))
+        p = h.languages[s];
+      else
+        throw new Error("Unknown language: `" + s + "` is not registered");
+    }
+    return b.call(this, r, p, s);
+  }
+  function S(r) {
+    if (typeof r != "string")
+      throw new Error("Expected `string` for `language`, got `" + r + "`");
+    return m.call(h.languages, r);
+  }
+  function w() {
+    var r = h.languages, s = [], b;
+    for (b in r)
+      m.call(r, b) && typeof r[b] == "object" && s.push(b);
+    return s;
+  }
+  function C(r, s, b) {
+    var p;
+    return typeof r == "string" ? { type: "text", value: r } : h.util.type(r) === "Array" ? u(r, s) : (p = {
+      type: r.type,
+      content: h.Token.stringify(r.content, s, b),
+      tag: "span",
+      classes: ["token", r.type],
+      attributes: {},
+      language: s,
+      parent: b
+    }, r.alias && (p.classes = p.classes.concat(r.alias)), h.hooks.run("wrap", p), l(
+      p.tag + "." + p.classes.join("."),
+      f(p.attributes),
+      p.content
+    ));
+  }
+  function u(r, s) {
+    for (var b = [], p = r.length, F = -1, q; ++F < p; )
+      q = r[F], q !== "" && q !== null && q !== void 0 && b.push(q);
+    for (F = -1, p = b.length; ++F < p; )
+      q = b[F], b[F] = h.Token.stringify(q, s, b);
+    return b;
+  }
+  function i(r) {
+    return r;
+  }
+  function f(r) {
+    var s;
+    for (s in r)
+      r[s] = e(r[s]);
+    return r;
+  }
+  function o() {
+    var r = "Prism" in t, s = r ? t.Prism : void 0;
+    return b;
+    function b() {
+      r ? t.Prism = s : delete t.Prism, r = void 0, s = void 0;
+    }
+  }
+  return ar;
+}
+var tr = {}, rn;
+function Vt() {
+  if (rn) return tr;
+  rn = 1;
+  var t = cn;
+  function n(e, g, d) {
+    if (e.tagName) {
+      var c = e.properties && Array.isArray(e.properties.className) ? e.properties.className.join(" ") : e.properties.className;
+      return t.createElement(e.tagName, Object.assign({
+        key: "fract-".concat(d, "-").concat(g)
+      }, e.properties, {
+        className: c
+      }), e.children && e.children.map(l(d + 1)));
+    }
+    return e.value;
+  }
+  function l(e) {
+    return function(d, c) {
+      return n(d, c, e);
+    };
+  }
+  return tr.depth = l, tr;
+}
+var ir, nn;
+function hn() {
+  if (nn) return ir;
+  nn = 1, ir = t;
+  function t(d) {
+    if (d == null)
+      return g;
+    if (typeof d == "string")
+      return e(d);
+    if (typeof d == "object")
+      return "length" in d ? l(d) : n(d);
+    if (typeof d == "function")
+      return d;
+    throw new Error("Expected function, string, or object as test");
+  }
+  function n(d) {
+    return c;
+    function c(a) {
+      var v;
+      for (v in d)
+        if (a[v] !== d[v]) return !1;
+      return !0;
+    }
+  }
+  function l(d) {
+    for (var c = [], a = -1; ++a < d.length; )
+      c[a] = t(d[a]);
+    return v;
+    function v() {
+      for (var m = -1; ++m < c.length; )
+        if (c[m].apply(this, arguments))
+          return !0;
+      return !1;
+    }
+  }
+  function e(d) {
+    return c;
+    function c(a) {
+      return !!(a && a.type === d);
+    }
+  }
+  function g() {
+    return !0;
+  }
+  return ir;
+}
+var lr, an;
+function Zt() {
+  if (an) return lr;
+  an = 1;
+  var t = hn();
+  lr = l;
+  var n = {}.hasOwnProperty;
+  function l(e, g, d) {
+    var c = t(d || g), a = g.cascade == null ? !0 : g.cascade;
+    return v(e, null, null);
+    function v(m, k, h) {
+      var x, A, y, S, w;
+      if (!c(m, k, h)) return null;
+      if (m.children) {
+        for (x = [], A = -1; ++A < m.children.length; )
+          y = v(m.children[A], A, m), y && x.push(y);
+        if (a && m.children.length && !x.length) return null;
+      }
+      S = {};
+      for (w in m)
+        n.call(m, w) && (S[w] = w === "children" ? x : m[w]);
+      return S;
+    }
+  }
+  return lr;
+}
+var ur, tn;
+function Gt() {
+  if (tn) return ur;
+  tn = 1, ur = t;
+  function t(n) {
+    return n;
+  }
+  return ur;
+}
+var or, ln;
+function Kt() {
+  if (ln) return or;
+  ln = 1, or = d;
+  var t = hn(), n = Gt(), l = !0, e = "skip", g = !1;
+  d.CONTINUE = l, d.SKIP = e, d.EXIT = g;
+  function d(a, v, m, k) {
+    var h, x;
+    typeof v == "function" && typeof m != "function" && (k = m, m = v, v = null), x = t(v), h = k ? -1 : 1, A(a, null, [])();
+    function A(y, S, w) {
+      var C = typeof y == "object" && y !== null ? y : {}, u;
+      return typeof C.type == "string" && (u = typeof C.tagName == "string" ? C.tagName : typeof C.name == "string" ? C.name : void 0, i.displayName = "node (" + n(C.type + (u ? "<" + u + ">" : "")) + ")"), i;
+      function i() {
+        var f = w.concat(y), o = [], r, s;
+        if ((!v || x(y, S, w[w.length - 1] || null)) && (o = c(m(y, w)), o[0] === g))
+          return o;
+        if (y.children && o[0] !== e)
+          for (s = (k ? y.children.length : -1) + h; s > -1 && s < y.children.length; ) {
+            if (r = A(y.children[s], s, f)(), r[0] === g)
+              return r;
+            s = typeof r[1] == "number" ? r[1] : s + h;
+          }
+        return o;
+      }
+    }
+  }
+  function c(a) {
+    return a !== null && typeof a == "object" && "length" in a ? a : typeof a == "number" ? [l, a] : [a];
+  }
+  return or;
+}
+var sr, un;
+function Jt() {
+  if (un) return sr;
+  un = 1, sr = typeof WeakMap == "function" ? t : n;
+  function t() {
+    this.map = /* @__PURE__ */ new WeakMap();
+  }
+  t.prototype.has = function(l) {
+    return this.map.has(l);
+  }, t.prototype.set = function(l, e) {
+    return this.map.set(l, e), this;
+  }, t.prototype.get = function(l) {
+    return this.map.get(l);
+  }, t.prototype.clear = function() {
+  };
+  function n() {
+    this.keys = [], this.values = [];
+  }
+  return n.prototype.has = function(l) {
+    return this.keys.indexOf(l) !== -1;
+  }, n.prototype.set = function(l, e) {
+    var g = this.keys.indexOf(l);
+    return g === -1 ? (this.keys.push(l), this.values.push(e)) : this.values[g] = e, this;
+  }, n.prototype.get = function(l) {
+    var e = this.keys.indexOf(l);
+    return e === -1 ? void 0 : this.values[e];
+  }, n.prototype.clear = function() {
+    this.keys = [], this.values = [];
+  }, sr;
+}
+var cr, on;
+function Yt() {
+  if (on) return cr;
+  on = 1;
+  var t = Zt(), n = Kt(), l = Jt();
+  function e(v) {
+    var m = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {
+      lineNumber: 1
+    };
+    return v.reduce(function(k, h) {
+      var x = m.lineNumber;
+      if (h.type === "text") {
+        if (h.value.indexOf(`
+`) === -1)
+          return h.lineStart = x, h.lineEnd = x, k.nodes.push(h), k;
+        for (var A = h.value.split(`
+`), y = 0; y < A.length; y++) {
+          var S = y === 0 ? m.lineNumber : ++m.lineNumber;
+          k.nodes.push({
+            type: "text",
+            value: y === A.length - 1 ? A[y] : "".concat(A[y], `
+`),
+            lineStart: S,
+            lineEnd: S
+          });
+        }
+        return k.lineNumber = m.lineNumber, k;
+      }
+      if (h.children) {
+        var w = e(h.children, m), C = w.nodes[0], u = w.nodes[w.nodes.length - 1];
+        return h.lineStart = C ? C.lineStart : x, h.lineEnd = u ? u.lineEnd : x, h.children = w.nodes, k.lineNumber = w.lineNumber, k.nodes.push(h), k;
+      }
+      return k.nodes.push(h), k;
+    }, {
+      nodes: [],
+      lineNumber: m.lineNumber
+    });
+  }
+  function g(v, m) {
+    var k = {
+      type: "root",
+      children: m
+    }, h = new l(), x = new l(), A = new l(), y = [];
+    function S(i, f, o) {
+      y.push(f), o.forEach(function(F) {
+        i.has(F) || (i.set(F, Object.assign({}, F, {
+          children: []
+        })), F !== k && y.push(F));
+      });
+      for (var r = o.length; r--; ) {
+        var s = i.get(o[r]), b = o[r + 1], p = i.get(b) || f;
+        s.children.indexOf(p) === -1 && s.children.push(p);
+      }
+    }
+    n(k, function(i, f) {
+      if (!i.children) {
+        if (i.lineStart < v) {
+          S(h, i, f);
+          return;
+        }
+        if (i.lineStart === v) {
+          S(x, i, f);
+          return;
+        }
+        i.lineEnd > v && y.some(function(o) {
+          return f.indexOf(o) !== -1;
+        }) && S(A, i, f);
+      }
+    });
+    var w = t(k, function(i) {
+      return y.indexOf(i) === -1;
+    }), C = function(f) {
+      var o = f.get(k);
+      return o ? (n(o, function(r, s) {
+        if (r.children) {
+          r.lineStart = 0, r.lineEnd = 0;
+          return;
+        }
+        s.forEach(function(b) {
+          b.lineStart = Math.max(b.lineStart, r.lineStart), b.lineEnd = Math.max(b.lineEnd, r.lineEnd);
+        });
+      }), o.children) : [];
+    }, u = [].concat(C(h), C(x), C(A), w ? w.children : []);
+    return h.clear(), x.clear(), A.clear(), u;
+  }
+  function d(v, m, k) {
+    var h = m.className || "refractor-marker";
+    return {
+      type: "element",
+      tagName: m.component || "div",
+      properties: m.component ? Object.assign({}, k, {
+        className: h
+      }) : {
+        className: h
+      },
+      children: v,
+      lineStart: m.line,
+      lineEnd: v[v.length - 1].lineEnd,
+      isMarker: !0
+    };
+  }
+  function c(v, m, k) {
+    if (m.length === 0 || v.length === 0)
+      return v;
+    for (var h = m.reduce(function(i, f) {
+      return g(f.line, i);
+    }, v), x = [], A = 0, y = 0; y < m.length; y++) {
+      for (var S = m[y], w = h[A]; w && w.lineEnd < S.line; w = h[++A])
+        x.push(w);
+      for (var C = [], u = h[A]; u && u.lineEnd === S.line; u = h[++A])
+        C.push(u);
+      C.length > 0 && x.push(d(C, S, k));
+    }
+    for (; A < h.length; )
+      x.push(h[A++]);
+    return x;
+  }
+  function a(v, m) {
+    var k = m.markers.map(function(x) {
+      return x.line ? x : {
+        line: x
+      };
+    }).sort(function(x, A) {
+      return x.line - A.line;
+    }), h = e(v).nodes;
+    return c(h, k, m);
+  }
+  return cr = a, cr;
+}
+var fr, sn;
+function Qt() {
+  if (sn) return fr;
+  sn = 1;
+  var t = cn, n = Xt(), l = Vt(), e = Yt(), g = t.createElement;
+  function d(c) {
+    var a = "language-".concat(c.language), v = {
+      className: a
+    }, m = {
+      className: [c.className || "refractor", a].filter(Boolean).join(" ")
+    };
+    c.inline && (v.style = {
+      display: "inline"
+    }, v.className = c.className || "refractor");
+    var k = n.highlight(c.value, c.language);
+    c.markers && c.markers.length > 0 && (k = e(k, {
+      markers: c.markers
+    }));
+    var h = k.length === 0 ? c.value : k.map(l.depth(0)), x = g("code", v, h);
+    return c.inline ? x : g("pre", m, x);
+  }
+  return d.registerLanguage = function(c) {
+    return n.register(c);
+  }, d.hasLanguage = function(c) {
+    return n.registered(c);
+  }, fr = d, fr;
+}
+var ei = Qt();
+const ai = /* @__PURE__ */ bn(ei);
+export {
+  ai as R,
+  Wt as r
+};
+//# sourceMappingURL=Refractor-Zss2QEe8.mjs.map