@kingsimba/nc-ui 0.1.25 → 0.1.27

package/dist/YamlTextArea-ee1d1TLc.js

@@ -0,0 +1,4713 @@
+import { jsx as ge, Fragment as Zt, jsxs as en } from "react/jsx-runtime";
+import Vt, { createElement as Xt, useCallback as ye, useMemo as ln, useState as Sn, useRef as Ne, useEffect as nn } from "react";
+var oe = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {}, Vn = {}, U = oe && oe.__assign || function() {
+  return U = Object.assign || function(e) {
+    for (var n, t = 1, r = arguments.length; t < r; t++) {
+      n = arguments[t];
+      for (var a in n) Object.prototype.hasOwnProperty.call(n, a) && (e[a] = n[a]);
+    }
+    return e;
+  }, U.apply(this, arguments);
+}, Qt = oe && oe.__createBinding || (Object.create ? function(e, n, t, r) {
+  r === void 0 && (r = t);
+  var a = Object.getOwnPropertyDescriptor(n, t);
+  (!a || ("get" in a ? !n.__esModule : a.writable || a.configurable)) && (a = { enumerable: !0, get: function() {
+    return n[t];
+  } }), Object.defineProperty(e, r, a);
+} : function(e, n, t, r) {
+  r === void 0 && (r = t), e[r] = n[t];
+}), Jt = oe && oe.__setModuleDefault || (Object.create ? function(e, n) {
+  Object.defineProperty(e, "default", { enumerable: !0, value: n });
+} : function(e, n) {
+  e.default = n;
+}), er = oe && oe.__importStar || function(e) {
+  if (e && e.__esModule) return e;
+  var n = {};
+  if (e != null) for (var t in e) t !== "default" && Object.prototype.hasOwnProperty.call(e, t) && Qt(n, e, t);
+  return Jt(n, e), n;
+}, nr = oe && oe.__rest || function(e, n) {
+  var t = {};
+  for (var r in e) Object.prototype.hasOwnProperty.call(e, r) && n.indexOf(r) < 0 && (t[r] = e[r]);
+  if (e != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var a = 0, r = Object.getOwnPropertySymbols(e); a < r.length; a++)
+      n.indexOf(r[a]) < 0 && Object.prototype.propertyIsEnumerable.call(e, r[a]) && (t[r[a]] = e[r[a]]);
+  return t;
+};
+Object.defineProperty(Vn, "__esModule", { value: !0 });
+var J = er(Vt), tr = 89, ze = 90, rr = 77, _n = 57, Fn = 219, Cn = 222, Tn = 192, In = 100, ar = 3e3, ir = typeof window < "u" && "navigator" in window && /Win/i.test(navigator.platform), tn = typeof window < "u" && "navigator" in window && /(Mac|iPhone|iPod|iPad)/i.test(navigator.platform), Ye = "npm__react-simple-code-editor__textarea", or = (
+  /* CSS */
+  `
+/**
+ * Reset the text fill color so that placeholder is visible
+ */
+.`.concat(Ye, `:empty {
+  -webkit-text-fill-color: inherit !important;
+}
+
+/**
+ * Hack to apply on some CSS on IE10 and IE11
+ */
+@media all and (-ms-high-contrast: none), (-ms-high-contrast: active) {
+  /**
+    * IE doesn't support '-webkit-text-fill-color'
+    * So we use 'color: transparent' to make the text transparent on IE
+    * Unlike other browsers, it doesn't affect caret color in IE
+    */
+  .`).concat(Ye, ` {
+    color: transparent !important;
+  }
+
+  .`).concat(Ye, `::selection {
+    background-color: #accef7 !important;
+    color: transparent !important;
+  }
+}
+`)
+), lr = J.forwardRef(function(n, t) {
+  var r = n.autoFocus, a = n.disabled, o = n.form, i = n.highlight, l = n.ignoreTabKey, s = l === void 0 ? !1 : l, u = n.insertSpaces, g = u === void 0 ? !0 : u, f = n.maxLength, m = n.minLength, v = n.name, c = n.onBlur, p = n.onClick, d = n.onFocus, b = n.onKeyDown, y = n.onKeyUp, w = n.onValueChange, E = n.padding, k = E === void 0 ? 0 : E, N = n.placeholder, L = n.preClassName, M = n.readOnly, D = n.required, W = n.style, q = n.tabSize, _ = q === void 0 ? 2 : q, O = n.textareaClassName, T = n.textareaId, $ = n.value, Y = nr(n, ["autoFocus", "disabled", "form", "highlight", "ignoreTabKey", "insertSpaces", "maxLength", "minLength", "name", "onBlur", "onClick", "onFocus", "onKeyDown", "onKeyUp", "onValueChange", "padding", "placeholder", "preClassName", "readOnly", "required", "style", "tabSize", "textareaClassName", "textareaId", "value"]), F = J.useRef({
+    stack: [],
+    offset: -1
+  }), R = J.useRef(null), be = J.useState(!0), V = be[0], le = be[1], ne = {
+    paddingTop: typeof k == "object" ? k.top : k,
+    paddingRight: typeof k == "object" ? k.right : k,
+    paddingBottom: typeof k == "object" ? k.bottom : k,
+    paddingLeft: typeof k == "object" ? k.left : k
+  }, te = i($), ee = function(x, I) {
+    return x.substring(0, I).split(`
+`);
+  }, ve = J.useCallback(function(x, I) {
+    var S, C, B;
+    I === void 0 && (I = !1);
+    var H = F.current, se = H.stack, Te = H.offset;
+    if (se.length && Te > -1) {
+      F.current.stack = se.slice(0, Te + 1);
+      var Ie = F.current.stack.length;
+      if (Ie > In) {
+        var Ae = Ie - In;
+        F.current.stack = se.slice(Ae, Ie), F.current.offset = Math.max(F.current.offset - Ae, 0);
+      }
+    }
+    var re = Date.now();
+    if (I) {
+      var de = F.current.stack[F.current.offset];
+      if (de && re - de.timestamp < ar) {
+        var Oe = /[^a-z0-9]([a-z0-9]+)$/i, X = (S = ee(de.value, de.selectionStart).pop()) === null || S === void 0 ? void 0 : S.match(Oe), Le = (C = ee(x.value, x.selectionStart).pop()) === null || C === void 0 ? void 0 : C.match(Oe);
+        if (X != null && X[1] && (!((B = Le == null ? void 0 : Le[1]) === null || B === void 0) && B.startsWith(X[1]))) {
+          F.current.stack[F.current.offset] = U(U({}, x), { timestamp: re });
+          return;
+        }
+      }
+    }
+    F.current.stack.push(U(U({}, x), { timestamp: re })), F.current.offset++;
+  }, []), we = J.useCallback(function() {
+    var x = R.current;
+    if (x) {
+      var I = x.value, S = x.selectionStart, C = x.selectionEnd;
+      ve({
+        value: I,
+        selectionStart: S,
+        selectionEnd: C
+      });
+    }
+  }, [ve]), pe = function(x) {
+    var I = R.current;
+    I && (I.value = x.value, I.selectionStart = x.selectionStart, I.selectionEnd = x.selectionEnd, w == null || w(x.value));
+  }, fe = function(x) {
+    var I = R.current, S = F.current.stack[F.current.offset];
+    S && I && (F.current.stack[F.current.offset] = U(U({}, S), { selectionStart: I.selectionStart, selectionEnd: I.selectionEnd })), ve(x), pe(x);
+  }, Ce = function() {
+    var x = F.current, I = x.stack, S = x.offset, C = I[S - 1];
+    C && (pe(C), F.current.offset = Math.max(S - 1, 0));
+  }, Ht = function() {
+    var x = F.current, I = x.stack, S = x.offset, C = I[S + 1];
+    C && (pe(C), F.current.offset = Math.min(S + 1, I.length - 1));
+  }, Kt = function(x) {
+    if (!(b && (b(x), x.defaultPrevented))) {
+      x.key === "Escape" && x.currentTarget.blur();
+      var I = x.currentTarget, S = I.value, C = I.selectionStart, B = I.selectionEnd, H = (g ? " " : "	").repeat(_);
+      if (x.key === "Tab" && !s && V)
+        if (x.preventDefault(), x.shiftKey) {
+          var se = ee(S, C), Te = se.length - 1, Ie = ee(S, B).length - 1, Ae = S.split(`
+`).map(function(Re, An) {
+            return An >= Te && An <= Ie && Re.startsWith(H) ? Re.substring(H.length) : Re;
+          }).join(`
+`);
+          if (S !== Ae) {
+            var re = se[Te];
+            fe({
+              value: Ae,
+              // Move the start cursor if first line in selection was modified
+              // It was modified only if it started with a tab
+              selectionStart: re != null && re.startsWith(H) ? C - H.length : C,
+              // Move the end cursor by total number of characters removed
+              selectionEnd: B - (S.length - Ae.length)
+            });
+          }
+        } else if (C !== B) {
+          var se = ee(S, C), de = se.length - 1, Oe = ee(S, B).length - 1, re = se[de];
+          fe({
+            value: S.split(`
+`).map(function(kn, En) {
+              return En >= de && En <= Oe ? H + kn : kn;
+            }).join(`
+`),
+            // Move the start cursor by number of characters added in first line of selection
+            // Don't move it if it there was no text before cursor
+            selectionStart: re && /\S/.test(re) ? C + H.length : C,
+            // Move the end cursor by total number of characters added
+            selectionEnd: B + H.length * (Oe - de + 1)
+          });
+        } else {
+          var X = C + H.length;
+          fe({
+            // Insert tab character at caret
+            value: S.substring(0, C) + H + S.substring(B),
+            // Update caret position
+            selectionStart: X,
+            selectionEnd: X
+          });
+        }
+      else if (x.key === "Backspace") {
+        var Le = C !== B, qt = S.substring(0, C);
+        if (qt.endsWith(H) && !Le) {
+          x.preventDefault();
+          var X = C - H.length;
+          fe({
+            // Remove tab character at caret
+            value: S.substring(0, C - H.length) + S.substring(B),
+            // Update caret position
+            selectionStart: X,
+            selectionEnd: X
+          });
+        }
+      } else if (x.key === "Enter") {
+        if (C === B) {
+          var Je = ee(S, C).pop(), Ue = Je == null ? void 0 : Je.match(/^\s+/);
+          if (Ue != null && Ue[0]) {
+            x.preventDefault();
+            var wn = `
+` + Ue[0], X = C + wn.length;
+            fe({
+              // Insert indentation character at caret
+              value: S.substring(0, C) + wn + S.substring(B),
+              // Update caret position
+              selectionStart: X,
+              selectionEnd: X
+            });
+          }
+        }
+      } else if (x.keyCode === _n || x.keyCode === Fn || x.keyCode === Cn || x.keyCode === Tn) {
+        var ue = void 0;
+        x.keyCode === _n && x.shiftKey ? ue = ["(", ")"] : x.keyCode === Fn ? x.shiftKey ? ue = ["{", "}"] : ue = ["[", "]"] : x.keyCode === Cn ? x.shiftKey ? ue = ['"', '"'] : ue = ["'", "'"] : x.keyCode === Tn && !x.shiftKey && (ue = ["`", "`"]), C !== B && ue && (x.preventDefault(), fe({
+          value: S.substring(0, C) + ue[0] + S.substring(C, B) + ue[1] + S.substring(B),
+          // Update caret position
+          selectionStart: C,
+          selectionEnd: B + 2
+        }));
+      } else (tn ? (
+        // Trigger undo with ⌘+Z on Mac
+        x.metaKey && x.keyCode === ze
+      ) : (
+        // Trigger undo with Ctrl+Z on other platforms
+        x.ctrlKey && x.keyCode === ze
+      )) && !x.shiftKey && !x.altKey ? (x.preventDefault(), Ce()) : (tn ? (
+        // Trigger redo with ⌘+Shift+Z on Mac
+        x.metaKey && x.keyCode === ze && x.shiftKey
+      ) : ir ? (
+        // Trigger redo with Ctrl+Y on Windows
+        x.ctrlKey && x.keyCode === tr
+      ) : (
+        // Trigger redo with Ctrl+Shift+Z on other platforms
+        x.ctrlKey && x.keyCode === ze && x.shiftKey
+      )) && !x.altKey ? (x.preventDefault(), Ht()) : x.keyCode === rr && x.ctrlKey && (!tn || x.shiftKey) && (x.preventDefault(), le(function(Re) {
+        return !Re;
+      }));
+    }
+  }, Wt = function(x) {
+    var I = x.currentTarget, S = I.value, C = I.selectionStart, B = I.selectionEnd;
+    ve({
+      value: S,
+      selectionStart: C,
+      selectionEnd: B
+    }, !0), w(S);
+  };
+  return J.useEffect(function() {
+    we();
+  }, [we]), J.useImperativeHandle(t, function() {
+    return {
+      get session() {
+        return {
+          history: F.current
+        };
+      },
+      set session(x) {
+        F.current = x.history;
+      }
+    };
+  }, []), J.createElement(
+    "div",
+    U({}, Y, { style: U(U({}, De.container), W) }),
+    J.createElement("pre", U({ className: L, "aria-hidden": "true", style: U(U(U({}, De.editor), De.highlight), ne) }, typeof te == "string" ? { dangerouslySetInnerHTML: { __html: te + "<br />" } } : { children: te })),
+    J.createElement("textarea", { ref: function(x) {
+      return R.current = x;
+    }, style: U(U(U({}, De.editor), De.textarea), ne), className: Ye + (O ? " ".concat(O) : ""), id: T, value: $, onChange: Wt, onKeyDown: Kt, onClick: p, onKeyUp: y, onFocus: d, onBlur: c, disabled: a, form: o, maxLength: f, minLength: m, name: v, placeholder: N, readOnly: M, required: D, autoFocus: r, autoCapitalize: "off", autoComplete: "off", autoCorrect: "off", spellCheck: !1, "data-gramm": !1 }),
+    J.createElement("style", { dangerouslySetInnerHTML: { __html: or } })
+  );
+}), De = {
+  container: {
+    position: "relative",
+    textAlign: "left",
+    boxSizing: "border-box",
+    padding: 0,
+    overflow: "hidden"
+  },
+  textarea: {
+    position: "absolute",
+    top: 0,
+    left: 0,
+    height: "100%",
+    width: "100%",
+    resize: "none",
+    color: "inherit",
+    overflow: "hidden",
+    MozOsxFontSmoothing: "grayscale",
+    WebkitFontSmoothing: "antialiased",
+    WebkitTextFillColor: "transparent"
+  },
+  highlight: {
+    position: "relative",
+    pointerEvents: "none"
+  },
+  editor: {
+    margin: 0,
+    border: 0,
+    background: "none",
+    boxSizing: "inherit",
+    display: "inherit",
+    fontFamily: "inherit",
+    fontSize: "inherit",
+    fontStyle: "inherit",
+    fontVariantLigatures: "inherit",
+    fontWeight: "inherit",
+    letterSpacing: "inherit",
+    lineHeight: "inherit",
+    tabSize: "inherit",
+    textIndent: "inherit",
+    textRendering: "inherit",
+    textTransform: "inherit",
+    whiteSpace: "pre-wrap",
+    wordBreak: "keep-all",
+    overflowWrap: "break-word"
+  }
+}, sr = Vn.default = lr;
+function Xn(e) {
+  var n, t, r = "";
+  if (typeof e == "string" || typeof e == "number") r += e;
+  else if (typeof e == "object") if (Array.isArray(e)) {
+    var a = e.length;
+    for (n = 0; n < a; n++) e[n] && (t = Xn(e[n])) && (r && (r += " "), r += t);
+  } else for (t in e) e[t] && (r && (r += " "), r += t);
+  return r;
+}
+function Qn() {
+  for (var e, n, t = 0, r = "", a = arguments.length; t < a; t++) (e = arguments[t]) && (n = Xn(e)) && (r && (r += " "), r += n);
+  return r;
+}
+var ur = Object.create, Ve = Object.defineProperty, cr = Object.defineProperties, pr = Object.getOwnPropertyDescriptor, fr = Object.getOwnPropertyDescriptors, Jn = Object.getOwnPropertyNames, Ge = Object.getOwnPropertySymbols, dr = Object.getPrototypeOf, gn = Object.prototype.hasOwnProperty, et = Object.prototype.propertyIsEnumerable, On = (e, n, t) => n in e ? Ve(e, n, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[n] = t, ae = (e, n) => {
+  for (var t in n || (n = {}))
+    gn.call(n, t) && On(e, t, n[t]);
+  if (Ge)
+    for (var t of Ge(n))
+      et.call(n, t) && On(e, t, n[t]);
+  return e;
+}, Xe = (e, n) => cr(e, fr(n)), nt = (e, n) => {
+  var t = {};
+  for (var r in e)
+    gn.call(e, r) && n.indexOf(r) < 0 && (t[r] = e[r]);
+  if (e != null && Ge)
+    for (var r of Ge(e))
+      n.indexOf(r) < 0 && et.call(e, r) && (t[r] = e[r]);
+  return t;
+}, gr = (e, n) => function() {
+  return n || (0, e[Jn(e)[0]])((n = { exports: {} }).exports, n), n.exports;
+}, yr = (e, n) => {
+  for (var t in n)
+    Ve(e, t, { get: n[t], enumerable: !0 });
+}, hr = (e, n, t, r) => {
+  if (n && typeof n == "object" || typeof n == "function")
+    for (let a of Jn(n))
+      !gn.call(e, a) && a !== t && Ve(e, a, { get: () => n[a], enumerable: !(r = pr(n, a)) || r.enumerable });
+  return e;
+}, mr = (e, n, t) => (t = e != null ? ur(dr(e)) : {}, hr(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  !e || !e.__esModule ? Ve(t, "default", { value: e, enumerable: !0 }) : t,
+  e
+)), br = gr({
+  "../../node_modules/.pnpm/prismjs@1.29.0_patch_hash=vrxx3pzkik6jpmgpayxfjunetu/node_modules/prismjs/prism.js"(e, n) {
+    var t = function() {
+      var r = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i, a = 0, o = {}, i = {
+        /**
+         * 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 c(p) {
+            return p instanceof l ? new l(p.type, c(p.content), p.alias) : Array.isArray(p) ? p.map(c) : p.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(c) {
+            return Object.prototype.toString.call(c).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(c) {
+            return c.__id || Object.defineProperty(c, "__id", { value: ++a }), c.__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 c(p, d) {
+            d = d || {};
+            var b, y;
+            switch (i.util.type(p)) {
+              case "Object":
+                if (y = i.util.objId(p), d[y])
+                  return d[y];
+                b = /** @type {Record<string, any>} */
+                {}, d[y] = b;
+                for (var w in p)
+                  p.hasOwnProperty(w) && (b[w] = c(p[w], d));
+                return (
+                  /** @type {any} */
+                  b
+                );
+              case "Array":
+                return y = i.util.objId(p), d[y] ? d[y] : (b = [], d[y] = b, p.forEach(function(E, k) {
+                  b[k] = c(E, d);
+                }), /** @type {any} */
+                b);
+              default:
+                return p;
+            }
+          },
+          /**
+           * 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(c) {
+            for (; c; ) {
+              var p = r.exec(c.className);
+              if (p)
+                return p[1].toLowerCase();
+              c = c.parentElement;
+            }
+            return "none";
+          },
+          /**
+           * Sets the Prism `language-xxxx` class of the given element.
+           *
+           * @param {Element} element
+           * @param {string} language
+           * @returns {void}
+           */
+          setLanguage: function(c, p) {
+            c.className = c.className.replace(RegExp(r, "gi"), ""), c.classList.add("language-" + p);
+          },
+          /**
+           * 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(c, p, d) {
+            for (var b = "no-" + p; c; ) {
+              var y = c.classList;
+              if (y.contains(p))
+                return !0;
+              if (y.contains(b))
+                return !1;
+              c = c.parentElement;
+            }
+            return !!d;
+          }
+        },
+        /**
+         * 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: function(c, p) {
+            var d = i.util.clone(i.languages[c]);
+            for (var b in p)
+              d[b] = p[b];
+            return d;
+          },
+          /**
+           * 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(c, p, d, b) {
+            b = b || /** @type {any} */
+            i.languages;
+            var y = b[c], w = {};
+            for (var E in y)
+              if (y.hasOwnProperty(E)) {
+                if (E == p)
+                  for (var k in d)
+                    d.hasOwnProperty(k) && (w[k] = d[k]);
+                d.hasOwnProperty(E) || (w[E] = y[E]);
+              }
+            var N = b[c];
+            return b[c] = w, i.languages.DFS(i.languages, function(L, M) {
+              M === N && L != c && (this[L] = w);
+            }), w;
+          },
+          // Traverse a language definition with Depth First Search
+          DFS: function c(p, d, b, y) {
+            y = y || {};
+            var w = i.util.objId;
+            for (var E in p)
+              if (p.hasOwnProperty(E)) {
+                d.call(p, E, p[E], b || E);
+                var k = p[E], N = i.util.type(k);
+                N === "Object" && !y[w(k)] ? (y[w(k)] = !0, c(k, d, null, y)) : N === "Array" && !y[w(k)] && (y[w(k)] = !0, c(k, d, E, y));
+              }
+          }
+        },
+        plugins: {},
+        /**
+         * Low-level function, only use if you know what you’re doing. It accepts a string of text as input
+         * and the language definitions to use, and returns a string with the HTML produced.
+         *
+         * The following hooks will be run:
+         * 1. `before-tokenize`
+         * 2. `after-tokenize`
+         * 3. `wrap`: On each {@link Token}.
+         *
+         * @param {string} text A string with the code to be highlighted.
+         * @param {Grammar} grammar An object containing the tokens to use.
+         *
+         * Usually a language definition like `Prism.languages.markup`.
+         * @param {string} language The name of the language definition passed to `grammar`.
+         * @returns {string} The highlighted HTML.
+         * @memberof Prism
+         * @public
+         * @example
+         * Prism.highlight('var foo = true;', Prism.languages.javascript, 'javascript');
+         */
+        highlight: function(c, p, d) {
+          var b = {
+            code: c,
+            grammar: p,
+            language: d
+          };
+          if (i.hooks.run("before-tokenize", b), !b.grammar)
+            throw new Error('The language "' + b.language + '" has no grammar.');
+          return b.tokens = i.tokenize(b.code, b.grammar), i.hooks.run("after-tokenize", b), l.stringify(i.util.encode(b.tokens), b.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(c, p) {
+          var d = p.rest;
+          if (d) {
+            for (var b in d)
+              p[b] = d[b];
+            delete p.rest;
+          }
+          var y = new g();
+          return f(y, y.head, c), u(c, y, p, y.head, 0), v(y);
+        },
+        /**
+         * @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(c, p) {
+            var d = i.hooks.all;
+            d[c] = d[c] || [], d[c].push(p);
+          },
+          /**
+           * 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(c, p) {
+            var d = i.hooks.all[c];
+            if (!(!d || !d.length))
+              for (var b = 0, y; y = d[b++]; )
+                y(p);
+          }
+        },
+        Token: l
+      };
+      function l(c, p, d, b) {
+        this.type = c, this.content = p, this.alias = d, this.length = (b || "").length | 0;
+      }
+      l.stringify = function c(p, d) {
+        if (typeof p == "string")
+          return p;
+        if (Array.isArray(p)) {
+          var b = "";
+          return p.forEach(function(N) {
+            b += c(N, d);
+          }), b;
+        }
+        var y = {
+          type: p.type,
+          content: c(p.content, d),
+          tag: "span",
+          classes: ["token", p.type],
+          attributes: {},
+          language: d
+        }, w = p.alias;
+        w && (Array.isArray(w) ? Array.prototype.push.apply(y.classes, w) : y.classes.push(w)), i.hooks.run("wrap", y);
+        var E = "";
+        for (var k in y.attributes)
+          E += " " + k + '="' + (y.attributes[k] || "").replace(/"/g, "&quot;") + '"';
+        return "<" + y.tag + ' class="' + y.classes.join(" ") + '"' + E + ">" + y.content + "</" + y.tag + ">";
+      };
+      function s(c, p, d, b) {
+        c.lastIndex = p;
+        var y = c.exec(d);
+        if (y && b && y[1]) {
+          var w = y[1].length;
+          y.index += w, y[0] = y[0].slice(w);
+        }
+        return y;
+      }
+      function u(c, p, d, b, y, w) {
+        for (var E in d)
+          if (!(!d.hasOwnProperty(E) || !d[E])) {
+            var k = d[E];
+            k = Array.isArray(k) ? k : [k];
+            for (var N = 0; N < k.length; ++N) {
+              if (w && w.cause == E + "," + N)
+                return;
+              var L = k[N], M = L.inside, D = !!L.lookbehind, W = !!L.greedy, q = L.alias;
+              if (W && !L.pattern.global) {
+                var _ = L.pattern.toString().match(/[imsuy]*$/)[0];
+                L.pattern = RegExp(L.pattern.source, _ + "g");
+              }
+              for (var O = L.pattern || L, T = b.next, $ = y; T !== p.tail && !(w && $ >= w.reach); $ += T.value.length, T = T.next) {
+                var Y = T.value;
+                if (p.length > c.length)
+                  return;
+                if (!(Y instanceof l)) {
+                  var F = 1, R;
+                  if (W) {
+                    if (R = s(O, $, c, D), !R || R.index >= c.length)
+                      break;
+                    var ne = R.index, be = R.index + R[0].length, V = $;
+                    for (V += T.value.length; ne >= V; )
+                      T = T.next, V += T.value.length;
+                    if (V -= T.value.length, $ = V, T.value instanceof l)
+                      continue;
+                    for (var le = T; le !== p.tail && (V < be || typeof le.value == "string"); le = le.next)
+                      F++, V += le.value.length;
+                    F--, Y = c.slice($, V), R.index -= $;
+                  } else if (R = s(O, 0, Y, D), !R)
+                    continue;
+                  var ne = R.index, te = R[0], ee = Y.slice(0, ne), ve = Y.slice(ne + te.length), we = $ + Y.length;
+                  w && we > w.reach && (w.reach = we);
+                  var pe = T.prev;
+                  ee && (pe = f(p, pe, ee), $ += ee.length), m(p, pe, F);
+                  var fe = new l(E, M ? i.tokenize(te, M) : te, q, te);
+                  if (T = f(p, pe, fe), ve && f(p, T, ve), F > 1) {
+                    var Ce = {
+                      cause: E + "," + N,
+                      reach: we
+                    };
+                    u(c, p, d, T.prev, $, Ce), w && Ce.reach > w.reach && (w.reach = Ce.reach);
+                  }
+                }
+              }
+            }
+          }
+      }
+      function g() {
+        var c = { value: null, prev: null, next: null }, p = { value: null, prev: c, next: null };
+        c.next = p, this.head = c, this.tail = p, this.length = 0;
+      }
+      function f(c, p, d) {
+        var b = p.next, y = { value: d, prev: p, next: b };
+        return p.next = y, b.prev = y, c.length++, y;
+      }
+      function m(c, p, d) {
+        for (var b = p.next, y = 0; y < d && b !== c.tail; y++)
+          b = b.next;
+        p.next = b, b.prev = p, c.length -= y;
+      }
+      function v(c) {
+        for (var p = [], d = c.head.next; d !== c.tail; )
+          p.push(d.value), d = d.next;
+        return p;
+      }
+      return i;
+    }();
+    n.exports = t, t.default = t;
+  }
+}), h = mr(br());
+h.languages.markup = { comment: { pattern: /<!--(?:(?!<!--)[\s\S])*?-->/, greedy: !0 }, prolog: { pattern: /<\?[\s\S]+?\?>/, greedy: !0 }, doctype: { pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i, greedy: !0, inside: { "internal-subset": { pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/, lookbehind: !0, greedy: !0, inside: null }, 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" }, { pattern: /^(\s*)["']|["']$/, lookbehind: !0 }] } }, punctuation: /\/?>/, "attr-name": { pattern: /[^\s>\/]+/, inside: { namespace: /^[^\s>\/:]+:/ } } } }, entity: [{ pattern: /&[\da-z]{1,8};/i, alias: "named-entity" }, /&#x?[\da-f]{1,8};/i] }, h.languages.markup.tag.inside["attr-value"].inside.entity = h.languages.markup.entity, h.languages.markup.doctype.inside["internal-subset"].inside = h.languages.markup, h.hooks.add("wrap", function(e) {
+  e.type === "entity" && (e.attributes.title = e.content.replace(/&amp;/, "&"));
+}), Object.defineProperty(h.languages.markup.tag, "addInlined", { value: function(e, r) {
+  var t = {}, t = (t["language-" + r] = { pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i, lookbehind: !0, inside: h.languages[r] }, t.cdata = /^<!\[CDATA\[|\]\]>$/i, { "included-cdata": { pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i, inside: t } }), r = (t["language-" + r] = { pattern: /[\s\S]+/, inside: h.languages[r] }, {});
+  r[e] = { pattern: RegExp(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g, function() {
+    return e;
+  }), "i"), lookbehind: !0, greedy: !0, inside: t }, h.languages.insertBefore("markup", "cdata", r);
+} }), Object.defineProperty(h.languages.markup.tag, "addAttribute", { value: function(e, n) {
+  h.languages.markup.tag.inside["special-attr"].push({ pattern: RegExp(/(^|["'\s])/.source + "(?:" + e + ")" + /\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: [n, "language-" + n], inside: h.languages[n] }, punctuation: [{ pattern: /^=/, alias: "attr-equals" }, /"|'/] } } } });
+} }), h.languages.html = h.languages.markup, h.languages.mathml = h.languages.markup, h.languages.svg = h.languages.markup, h.languages.xml = h.languages.extend("markup", {}), h.languages.ssml = h.languages.xml, h.languages.atom = h.languages.xml, h.languages.rss = h.languages.xml, function(e) {
+  var n = { pattern: /\\[\\(){}[\]^$+*?|.]/, alias: "escape" }, t = /\\(?:x[\da-fA-F]{2}|u[\da-fA-F]{4}|u\{[\da-fA-F]+\}|0[0-7]{0,2}|[123][0-7]{2}|c[a-zA-Z]|.)/, r = "(?:[^\\\\-]|" + t.source + ")", r = RegExp(r + "-" + r), a = { pattern: /(<|')[^<>']+(?=[>']$)/, lookbehind: !0, alias: "variable" };
+  e.languages.regex = { "char-class": { pattern: /((?:^|[^\\])(?:\\\\)*)\[(?:[^\\\]]|\\[\s\S])*\]/, lookbehind: !0, inside: { "char-class-negation": { pattern: /(^\[)\^/, lookbehind: !0, alias: "operator" }, "char-class-punctuation": { pattern: /^\[|\]$/, alias: "punctuation" }, range: { pattern: r, inside: { escape: t, "range-punctuation": { pattern: /-/, alias: "operator" } } }, "special-escape": n, "char-set": { pattern: /\\[wsd]|\\p\{[^{}]+\}/i, alias: "class-name" }, escape: t } }, "special-escape": n, "char-set": { pattern: /\.|\\[wsd]|\\p\{[^{}]+\}/i, alias: "class-name" }, backreference: [{ pattern: /\\(?![123][0-7]{2})[1-9]/, alias: "keyword" }, { pattern: /\\k<[^<>']+>/, alias: "keyword", inside: { "group-name": a } }], anchor: { pattern: /[$^]|\\[ABbGZz]/, alias: "function" }, escape: t, group: [{ pattern: /\((?:\?(?:<[^<>']+>|'[^<>']+'|[>:]|<?[=!]|[idmnsuxU]+(?:-[idmnsuxU]+)?:?))?/, alias: "punctuation", inside: { "group-name": a } }, { pattern: /\)/, alias: "punctuation" }], quantifier: { pattern: /(?:[+*?]|\{\d+(?:,\d*)?\})[?+]?/, alias: "number" }, alternation: { pattern: /\|/, alias: "keyword" } };
+}(h), h.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: /[{}[\];(),.:]/ }, h.languages.javascript = h.languages.extend("clike", { "class-name": [h.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 }], function: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/, number: { pattern: RegExp(/(^|[^\w$])/.source + "(?:" + /NaN|Infinity/.source + "|" + /0[bB][01]+(?:_[01]+)*n?/.source + "|" + /0[oO][0-7]+(?:_[0-7]+)*n?/.source + "|" + /0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source + "|" + /\d+(?:_\d+)*n/.source + "|" + /(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/.source + ")" + /(?![\w$])/.source), lookbehind: !0 }, operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/ }), h.languages.javascript["class-name"][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/, h.languages.insertBefore("javascript", "keyword", { regex: { pattern: RegExp(/((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)/.source + /\//.source + "(?:" + /(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}/.source + "|" + /(?:\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.)*\])*\])*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}v[dgimyus]{0,7}/.source + ")" + /(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/.source), lookbehind: !0, greedy: !0, inside: { "regex-source": { pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/, lookbehind: !0, alias: "language-regex", inside: h.languages.regex }, "regex-delimiter": /^\/|\/$/, "regex-flags": /^[a-z]+$/ } }, "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: h.languages.javascript }, { pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i, lookbehind: !0, inside: h.languages.javascript }, { pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/, lookbehind: !0, inside: h.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: h.languages.javascript }], constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/ }), h.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: h.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" } }), h.languages.insertBefore("javascript", "operator", { "literal-property": { pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m, lookbehind: !0, alias: "property" } }), h.languages.markup && (h.languages.markup.tag.addInlined("script", "javascript"), h.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")), h.languages.js = h.languages.javascript, h.languages.actionscript = h.languages.extend("javascript", { keyword: /\b(?:as|break|case|catch|class|const|default|delete|do|dynamic|each|else|extends|final|finally|for|function|get|if|implements|import|in|include|instanceof|interface|internal|is|namespace|native|new|null|override|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|use|var|void|while|with)\b/, operator: /\+\+|--|(?:[+\-*\/%^]|&&?|\|\|?|<<?|>>?>?|[!=]=?)=?|[~?@]/ }), h.languages.actionscript["class-name"].alias = "function", delete h.languages.actionscript.parameter, delete h.languages.actionscript["literal-property"], h.languages.markup && h.languages.insertBefore("actionscript", "string", { xml: { pattern: /(^|[^.])<\/?\w+(?:\s+[^\s>\/=]+=("|')(?:\\[\s\S]|(?!\2)[^\\])*\2)*\s*\/?>/, lookbehind: !0, inside: h.languages.markup } }), function(e) {
+  var n = /#(?!\{).+/, t = { pattern: /#\{[^}]+\}/, alias: "variable" };
+  e.languages.coffeescript = e.languages.extend("javascript", { comment: n, string: [{ pattern: /'(?:\\[\s\S]|[^\\'])*'/, greedy: !0 }, { pattern: /"(?:\\[\s\S]|[^\\"])*"/, greedy: !0, inside: { interpolation: t } }], keyword: /\b(?:and|break|by|catch|class|continue|debugger|delete|do|each|else|extend|extends|false|finally|for|if|in|instanceof|is|isnt|let|loop|namespace|new|no|not|null|of|off|on|or|own|return|super|switch|then|this|throw|true|try|typeof|undefined|unless|until|when|while|window|with|yes|yield)\b/, "class-member": { pattern: /@(?!\d)\w+/, alias: "variable" } }), e.languages.insertBefore("coffeescript", "comment", { "multiline-comment": { pattern: /###[\s\S]+?###/, alias: "comment" }, "block-regex": { pattern: /\/{3}[\s\S]*?\/{3}/, alias: "regex", inside: { comment: n, interpolation: t } } }), e.languages.insertBefore("coffeescript", "string", { "inline-javascript": { pattern: /`(?:\\[\s\S]|[^\\`])*`/, inside: { delimiter: { pattern: /^`|`$/, alias: "punctuation" }, script: { pattern: /[\s\S]+/, alias: "language-javascript", inside: e.languages.javascript } } }, "multiline-string": [{ pattern: /'''[\s\S]*?'''/, greedy: !0, alias: "string" }, { pattern: /"""[\s\S]*?"""/, greedy: !0, alias: "string", inside: { interpolation: t } }] }), e.languages.insertBefore("coffeescript", "keyword", { property: /(?!\d)\w+(?=\s*:(?!:))/ }), delete e.languages.coffeescript["template-string"], e.languages.coffee = e.languages.coffeescript;
+}(h), function(e) {
+  var n = e.languages.javadoclike = { parameter: { pattern: /(^[\t ]*(?:\/{3}|\*|\/\*\*)\s*@(?:arg|arguments|param)\s+)\w+/m, lookbehind: !0 }, keyword: { pattern: /(^[\t ]*(?:\/{3}|\*|\/\*\*)\s*|\{)@[a-z][a-zA-Z-]+\b/m, lookbehind: !0 }, punctuation: /[{}]/ };
+  Object.defineProperty(n, "addSupport", { value: function(t, r) {
+    (t = typeof t == "string" ? [t] : t).forEach(function(a) {
+      var o = function(f) {
+        f.inside || (f.inside = {}), f.inside.rest = r;
+      }, i = "doc-comment";
+      if (l = e.languages[a]) {
+        var l, s = l[i];
+        if ((s = s || (l = e.languages.insertBefore(a, "comment", { "doc-comment": { pattern: /(^|[^\\])\/\*\*[^/][\s\S]*?(?:\*\/|$)/, lookbehind: !0, alias: "comment" } }))[i]) instanceof RegExp && (s = l[i] = { pattern: s }), Array.isArray(s))
+          for (var u = 0, g = s.length; u < g; u++)
+            s[u] instanceof RegExp && (s[u] = { pattern: s[u] }), o(s[u]);
+        else
+          o(s);
+      }
+    });
+  } }), n.addSupport(["java", "javascript", "php"], n);
+}(h), function(e) {
+  var n = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/, n = (e.languages.css = { comment: /\/\*[\s\S]*?\*\//, atrule: { pattern: RegExp("@[\\w-](?:" + /[^;{\s"']|\s+(?!\s)/.source + "|" + n.source + ")*?" + /(?:;|(?=\s*\{))/.source), 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 } } }, url: { pattern: RegExp("\\burl\\((?:" + n.source + "|" + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ")\\)", "i"), greedy: !0, inside: { function: /^url/i, punctuation: /^\(|\)$/, string: { pattern: RegExp("^" + n.source + "$"), alias: "url" } } }, selector: { pattern: RegExp(`(^|[{}\\s])[^{}\\s](?:[^{};"'\\s]|\\s+(?![\\s{])|` + n.source + ")*(?=\\s*\\{)"), lookbehind: !0 }, string: { pattern: n, 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: /[(){};:,]/ }, e.languages.css.atrule.inside.rest = e.languages.css, e.languages.markup);
+  n && (n.tag.addInlined("style", "css"), n.tag.addAttribute("style", "css"));
+}(h), function(e) {
+  var n = /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/, n = (e.languages.css.selector = { pattern: e.languages.css.selector.pattern, lookbehind: !0, inside: n = { "pseudo-element": /:(?:after|before|first-letter|first-line|selection)|::[-\w]+/, "pseudo-class": /:[-\w]+/, class: /\.[-\w]+/, id: /#[-\w]+/, attribute: { pattern: RegExp(`\\[(?:[^[\\]"']|` + n.source + ")*\\]"), greedy: !0, inside: { punctuation: /^\[|\]$/, "case-sensitivity": { pattern: /(\s)[si]$/i, lookbehind: !0, alias: "keyword" }, namespace: { pattern: /^(\s*)(?:(?!\s)[-*\w\xA0-\uFFFF])*\|(?!=)/, lookbehind: !0, inside: { punctuation: /\|$/ } }, "attr-name": { pattern: /^(\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+/, lookbehind: !0 }, "attr-value": [n, { pattern: /(=\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+(?=\s*$)/, lookbehind: !0 }], operator: /[|~*^$]?=/ } }, "n-th": [{ pattern: /(\(\s*)[+-]?\d*[\dn](?:\s*[+-]\s*\d+)?(?=\s*\))/, lookbehind: !0, inside: { number: /[\dn]+/, operator: /[+-]/ } }, { pattern: /(\(\s*)(?:even|odd)(?=\s*\))/i, lookbehind: !0 }], combinator: />|\+|~|\|\|/, punctuation: /[(),]/ } }, e.languages.css.atrule.inside["selector-function-argument"].inside = n, e.languages.insertBefore("css", "property", { variable: { pattern: /(^|[^-\w\xA0-\uFFFF])--(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*/i, lookbehind: !0 } }), { pattern: /(\b\d+)(?:%|[a-z]+(?![\w-]))/, lookbehind: !0 }), t = { pattern: /(^|[^\w.-])-?(?:\d+(?:\.\d+)?|\.\d+)/, lookbehind: !0 };
+  e.languages.insertBefore("css", "function", { operator: { pattern: /(\s)[+\-*\/](?=\s)/, lookbehind: !0 }, hexcode: { pattern: /\B#[\da-f]{3,8}\b/i, alias: "color" }, color: [{ pattern: /(^|[^\w-])(?:AliceBlue|AntiqueWhite|Aqua|Aquamarine|Azure|Beige|Bisque|Black|BlanchedAlmond|Blue|BlueViolet|Brown|BurlyWood|CadetBlue|Chartreuse|Chocolate|Coral|CornflowerBlue|Cornsilk|Crimson|Cyan|DarkBlue|DarkCyan|DarkGoldenRod|DarkGr[ae]y|DarkGreen|DarkKhaki|DarkMagenta|DarkOliveGreen|DarkOrange|DarkOrchid|DarkRed|DarkSalmon|DarkSeaGreen|DarkSlateBlue|DarkSlateGr[ae]y|DarkTurquoise|DarkViolet|DeepPink|DeepSkyBlue|DimGr[ae]y|DodgerBlue|FireBrick|FloralWhite|ForestGreen|Fuchsia|Gainsboro|GhostWhite|Gold|GoldenRod|Gr[ae]y|Green|GreenYellow|HoneyDew|HotPink|IndianRed|Indigo|Ivory|Khaki|Lavender|LavenderBlush|LawnGreen|LemonChiffon|LightBlue|LightCoral|LightCyan|LightGoldenRodYellow|LightGr[ae]y|LightGreen|LightPink|LightSalmon|LightSeaGreen|LightSkyBlue|LightSlateGr[ae]y|LightSteelBlue|LightYellow|Lime|LimeGreen|Linen|Magenta|Maroon|MediumAquaMarine|MediumBlue|MediumOrchid|MediumPurple|MediumSeaGreen|MediumSlateBlue|MediumSpringGreen|MediumTurquoise|MediumVioletRed|MidnightBlue|MintCream|MistyRose|Moccasin|NavajoWhite|Navy|OldLace|Olive|OliveDrab|Orange|OrangeRed|Orchid|PaleGoldenRod|PaleGreen|PaleTurquoise|PaleVioletRed|PapayaWhip|PeachPuff|Peru|Pink|Plum|PowderBlue|Purple|RebeccaPurple|Red|RosyBrown|RoyalBlue|SaddleBrown|Salmon|SandyBrown|SeaGreen|SeaShell|Sienna|Silver|SkyBlue|SlateBlue|SlateGr[ae]y|Snow|SpringGreen|SteelBlue|Tan|Teal|Thistle|Tomato|Transparent|Turquoise|Violet|Wheat|White|WhiteSmoke|Yellow|YellowGreen)(?![\w-])/i, lookbehind: !0 }, { pattern: /\b(?:hsl|rgb)\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*\)\B|\b(?:hsl|rgb)a\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*,\s*(?:0|0?\.\d+|1)\s*\)\B/i, inside: { unit: n, number: t, function: /[\w-]+(?=\()/, punctuation: /[(),]/ } }], entity: /\\[\da-f]{1,8}/i, unit: n, number: t });
+}(h), function(e) {
+  var n = /[*&][^\s[\]{},]+/, t = /!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/, r = "(?:" + t.source + "(?:[ 	]+" + n.source + ")?|" + n.source + "(?:[ 	]+" + t.source + ")?)", a = /(?:[^\s\x00-\x08\x0e-\x1f!"#%&'*,\-:>?@[\]`{|}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]|[?:-]<PLAIN>)(?:[ \t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*/.source.replace(/<PLAIN>/g, function() {
+    return /[^\s\x00-\x08\x0e-\x1f,[\]{}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]/.source;
+  }), o = /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/.source;
+  function i(l, s) {
+    s = (s || "").replace(/m/g, "") + "m";
+    var u = /([:\-,[{]\s*(?:\s<<prop>>[ \t]+)?)(?:<<value>>)(?=[ \t]*(?:$|,|\]|\}|(?:[\r\n]\s*)?#))/.source.replace(/<<prop>>/g, function() {
+      return r;
+    }).replace(/<<value>>/g, function() {
+      return l;
+    });
+    return RegExp(u, s);
+  }
+  e.languages.yaml = { scalar: { pattern: RegExp(/([\-:]\s*(?:\s<<prop>>[ \t]+)?[|>])[ \t]*(?:((?:\r?\n|\r)[ \t]+)\S[^\r\n]*(?:\2[^\r\n]+)*)/.source.replace(/<<prop>>/g, function() {
+    return r;
+  })), lookbehind: !0, alias: "string" }, comment: /#.*/, key: { pattern: RegExp(/((?:^|[:\-,[{\r\n?])[ \t]*(?:<<prop>>[ \t]+)?)<<key>>(?=\s*:\s)/.source.replace(/<<prop>>/g, function() {
+    return r;
+  }).replace(/<<key>>/g, function() {
+    return "(?:" + a + "|" + o + ")";
+  })), lookbehind: !0, greedy: !0, alias: "atrule" }, directive: { pattern: /(^[ \t]*)%.+/m, lookbehind: !0, alias: "important" }, datetime: { pattern: i(/\d{4}-\d\d?-\d\d?(?:[tT]|[ \t]+)\d\d?:\d{2}:\d{2}(?:\.\d*)?(?:[ \t]*(?:Z|[-+]\d\d?(?::\d{2})?))?|\d{4}-\d{2}-\d{2}|\d\d?:\d{2}(?::\d{2}(?:\.\d*)?)?/.source), lookbehind: !0, alias: "number" }, boolean: { pattern: i(/false|true/.source, "i"), lookbehind: !0, alias: "important" }, null: { pattern: i(/null|~/.source, "i"), lookbehind: !0, alias: "important" }, string: { pattern: i(o), lookbehind: !0, greedy: !0 }, number: { pattern: i(/[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|\.inf|\.nan)/.source, "i"), lookbehind: !0 }, tag: t, important: n, punctuation: /---|[:[\]{}\-,|>?]|\.\.\./ }, e.languages.yml = e.languages.yaml;
+}(h), function(e) {
+  var n = /(?:\\.|[^\\\n\r]|(?:\n|\r\n?)(?![\r\n]))/.source;
+  function t(u) {
+    return u = u.replace(/<inner>/g, function() {
+      return n;
+    }), RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + "(?:" + u + ")");
+  }
+  var r = /(?:\\.|``(?:[^`\r\n]|`(?!`))+``|`[^`\r\n]+`|[^\\|\r\n`])+/.source, a = /\|?__(?:\|__)+\|?(?:(?:\n|\r\n?)|(?![\s\S]))/.source.replace(/__/g, function() {
+    return r;
+  }), o = /\|?[ \t]*:?-{3,}:?[ \t]*(?:\|[ \t]*:?-{3,}:?[ \t]*)+\|?(?:\n|\r\n?)/.source, i = (e.languages.markdown = e.languages.extend("markup", {}), e.languages.insertBefore("markdown", "prolog", { "front-matter-block": { pattern: /(^(?:\s*[\r\n])?)---(?!.)[\s\S]*?[\r\n]---(?!.)/, lookbehind: !0, greedy: !0, inside: { punctuation: /^---|---$/, "front-matter": { pattern: /\S+(?:\s+\S+)*/, alias: ["yaml", "language-yaml"], inside: e.languages.yaml } } }, blockquote: { pattern: /^>(?:[\t ]*>)*/m, alias: "punctuation" }, table: { pattern: RegExp("^" + a + o + "(?:" + a + ")*", "m"), inside: { "table-data-rows": { pattern: RegExp("^(" + a + o + ")(?:" + a + ")*$"), lookbehind: !0, inside: { "table-data": { pattern: RegExp(r), inside: e.languages.markdown }, punctuation: /\|/ } }, "table-line": { pattern: RegExp("^(" + a + ")" + o + "$"), lookbehind: !0, inside: { punctuation: /\||:?-{3,}:?/ } }, "table-header-row": { pattern: RegExp("^" + a + "$"), inside: { "table-header": { pattern: RegExp(r), alias: "important", inside: e.languages.markdown }, punctuation: /\|/ } } } }, code: [{ pattern: /((?:^|\n)[ \t]*\n|(?:^|\r\n?)[ \t]*\r\n?)(?: {4}|\t).+(?:(?:\n|\r\n?)(?: {4}|\t).+)*/, lookbehind: !0, alias: "keyword" }, { pattern: /^```[\s\S]*?^```$/m, greedy: !0, inside: { "code-block": { pattern: /^(```.*(?:\n|\r\n?))[\s\S]+?(?=(?:\n|\r\n?)^```$)/m, lookbehind: !0 }, "code-language": { pattern: /^(```).+/, lookbehind: !0 }, punctuation: /```/ } }], title: [{ pattern: /\S.*(?:\n|\r\n?)(?:==+|--+)(?=[ \t]*$)/m, alias: "important", inside: { punctuation: /==+$|--+$/ } }, { pattern: /(^\s*)#.+/m, lookbehind: !0, alias: "important", inside: { punctuation: /^#+|#+$/ } }], hr: { pattern: /(^\s*)([*-])(?:[\t ]*\2){2,}(?=\s*$)/m, lookbehind: !0, alias: "punctuation" }, list: { pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m, lookbehind: !0, alias: "punctuation" }, "url-reference": { pattern: /!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/, inside: { variable: { pattern: /^(!?\[)[^\]]+/, lookbehind: !0 }, string: /(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/, punctuation: /^[\[\]!:]|[<>]/ }, alias: "url" }, bold: { pattern: t(/\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\b|\*\*(?:(?!\*)<inner>|\*(?:(?!\*)<inner>)+\*)+\*\*/.source), lookbehind: !0, greedy: !0, inside: { content: { pattern: /(^..)[\s\S]+(?=..$)/, lookbehind: !0, inside: {} }, punctuation: /\*\*|__/ } }, italic: { pattern: t(/\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\b|\*(?:(?!\*)<inner>|\*\*(?:(?!\*)<inner>)+\*\*)+\*/.source), lookbehind: !0, greedy: !0, inside: { content: { pattern: /(^.)[\s\S]+(?=.$)/, lookbehind: !0, inside: {} }, punctuation: /[*_]/ } }, strike: { pattern: t(/(~~?)(?:(?!~)<inner>)+\2/.source), lookbehind: !0, greedy: !0, inside: { content: { pattern: /(^~~?)[\s\S]+(?=\1$)/, lookbehind: !0, inside: {} }, punctuation: /~~?/ } }, "code-snippet": { pattern: /(^|[^\\`])(?:``[^`\r\n]+(?:`[^`\r\n]+)*``(?!`)|`[^`\r\n]+`(?!`))/, lookbehind: !0, greedy: !0, alias: ["code", "keyword"] }, url: { pattern: t(/!?\[(?:(?!\])<inner>)+\](?:\([^\s)]+(?:[\t ]+"(?:\\.|[^"\\])*")?\)|[ \t]?\[(?:(?!\])<inner>)+\])/.source), lookbehind: !0, greedy: !0, inside: { operator: /^!/, content: { pattern: /(^\[)[^\]]+(?=\])/, lookbehind: !0, inside: {} }, variable: { pattern: /(^\][ \t]?\[)[^\]]+(?=\]$)/, lookbehind: !0 }, url: { pattern: /(^\]\()[^\s)]+/, lookbehind: !0 }, string: { pattern: /(^[ \t]+)"(?:\\.|[^"\\])*"(?=\)$)/, lookbehind: !0 } } } }), ["url", "bold", "italic", "strike"].forEach(function(u) {
+    ["url", "bold", "italic", "strike", "code-snippet"].forEach(function(g) {
+      u !== g && (e.languages.markdown[u].inside.content.inside[g] = e.languages.markdown[g]);
+    });
+  }), e.hooks.add("after-tokenize", function(u) {
+    u.language !== "markdown" && u.language !== "md" || function g(f) {
+      if (f && typeof f != "string")
+        for (var m = 0, v = f.length; m < v; m++) {
+          var c, p = f[m];
+          p.type !== "code" ? g(p.content) : (c = p.content[1], p = p.content[3], c && p && c.type === "code-language" && p.type === "code-block" && typeof c.content == "string" && (c = c.content.replace(/\b#/g, "sharp").replace(/\b\+\+/g, "pp"), c = "language-" + (c = (/[a-z][\w-]*/i.exec(c) || [""])[0].toLowerCase()), p.alias ? typeof p.alias == "string" ? p.alias = [p.alias, c] : p.alias.push(c) : p.alias = [c]));
+        }
+    }(u.tokens);
+  }), e.hooks.add("wrap", function(u) {
+    if (u.type === "code-block") {
+      for (var g = "", f = 0, m = u.classes.length; f < m; f++) {
+        var v = u.classes[f], v = /language-(.+)/.exec(v);
+        if (v) {
+          g = v[1];
+          break;
+        }
+      }
+      var c, p = e.languages[g];
+      p ? u.content = e.highlight(function(d) {
+        return d = d.replace(i, ""), d = d.replace(/&(\w{1,8}|#x?[\da-f]{1,8});/gi, function(b, y) {
+          var w;
+          return (y = y.toLowerCase())[0] === "#" ? (w = y[1] === "x" ? parseInt(y.slice(2), 16) : Number(y.slice(1)), s(w)) : l[y] || b;
+        });
+      }(u.content), p, g) : g && g !== "none" && e.plugins.autoloader && (c = "md-" + (/* @__PURE__ */ new Date()).valueOf() + "-" + Math.floor(1e16 * Math.random()), u.attributes.id = c, e.plugins.autoloader.loadLanguages(g, function() {
+        var d = document.getElementById(c);
+        d && (d.innerHTML = e.highlight(d.textContent, e.languages[g], g));
+      }));
+    }
+  }), RegExp(e.languages.markup.tag.pattern.source, "gi")), l = { amp: "&", lt: "<", gt: ">", quot: '"' }, s = String.fromCodePoint || String.fromCharCode;
+  e.languages.md = e.languages.markdown;
+}(h), h.languages.graphql = { comment: /#.*/, description: { pattern: /(?:"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*")(?=\s*[a-z_])/i, greedy: !0, alias: "string", inside: { "language-markdown": { pattern: /(^"(?:"")?)(?!\1)[\s\S]+(?=\1$)/, lookbehind: !0, inside: h.languages.markdown } } }, string: { pattern: /"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*"/, greedy: !0 }, number: /(?:\B-|\b)\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i, boolean: /\b(?:false|true)\b/, variable: /\$[a-z_]\w*/i, directive: { pattern: /@[a-z_]\w*/i, alias: "function" }, "attr-name": { pattern: /\b[a-z_]\w*(?=\s*(?:\((?:[^()"]|"(?:\\.|[^\\"\r\n])*")*\))?:)/i, greedy: !0 }, "atom-input": { pattern: /\b[A-Z]\w*Input\b/, alias: "class-name" }, scalar: /\b(?:Boolean|Float|ID|Int|String)\b/, constant: /\b[A-Z][A-Z_\d]*\b/, "class-name": { pattern: /(\b(?:enum|implements|interface|on|scalar|type|union)\s+|&\s*|:\s*|\[)[A-Z_]\w*/, lookbehind: !0 }, fragment: { pattern: /(\bfragment\s+|\.{3}\s*(?!on\b))[a-zA-Z_]\w*/, lookbehind: !0, alias: "function" }, "definition-mutation": { pattern: /(\bmutation\s+)[a-zA-Z_]\w*/, lookbehind: !0, alias: "function" }, "definition-query": { pattern: /(\bquery\s+)[a-zA-Z_]\w*/, lookbehind: !0, alias: "function" }, keyword: /\b(?:directive|enum|extend|fragment|implements|input|interface|mutation|on|query|repeatable|scalar|schema|subscription|type|union)\b/, operator: /[!=|&]|\.{3}/, "property-query": /\w+(?=\s*\()/, object: /\w+(?=\s*\{)/, punctuation: /[!(){}\[\]:=,]/, property: /\w+/ }, h.hooks.add("after-tokenize", function(e) {
+  if (e.language === "graphql")
+    for (var n = e.tokens.filter(function(c) {
+      return typeof c != "string" && c.type !== "comment" && c.type !== "scalar";
+    }), t = 0; t < n.length; ) {
+      var r = n[t++];
+      if (r.type === "keyword" && r.content === "mutation") {
+        var a = [];
+        if (f(["definition-mutation", "punctuation"]) && g(1).content === "(") {
+          t += 2;
+          var o = m(/^\($/, /^\)$/);
+          if (o === -1)
+            continue;
+          for (; t < o; t++) {
+            var i = g(0);
+            i.type === "variable" && (v(i, "variable-input"), a.push(i.content));
+          }
+          t = o + 1;
+        }
+        if (f(["punctuation", "property-query"]) && g(0).content === "{" && (t++, v(g(0), "property-mutation"), 0 < a.length)) {
+          var l = m(/^\{$/, /^\}$/);
+          if (l !== -1)
+            for (var s = t; s < l; s++) {
+              var u = n[s];
+              u.type === "variable" && 0 <= a.indexOf(u.content) && v(u, "variable-input");
+            }
+        }
+      }
+    }
+  function g(c) {
+    return n[t + c];
+  }
+  function f(c, p) {
+    p = p || 0;
+    for (var d = 0; d < c.length; d++) {
+      var b = g(d + p);
+      if (!b || b.type !== c[d])
+        return;
+    }
+    return 1;
+  }
+  function m(c, p) {
+    for (var d = 1, b = t; b < n.length; b++) {
+      var y = n[b], w = y.content;
+      if (y.type === "punctuation" && typeof w == "string") {
+        if (c.test(w))
+          d++;
+        else if (p.test(w) && --d === 0)
+          return b;
+      }
+    }
+    return -1;
+  }
+  function v(c, p) {
+    var d = c.alias;
+    d ? Array.isArray(d) || (c.alias = d = [d]) : c.alias = d = [], d.push(p);
+  }
+}), h.languages.sql = { comment: { pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/|#).*)/, lookbehind: !0 }, variable: [{ pattern: /@(["'`])(?:\\[\s\S]|(?!\1)[^\\])+\1/, greedy: !0 }, /@[\w.$]+/], string: { pattern: /(^|[^@\\])("|')(?:\\[\s\S]|(?!\2)[^\\]|\2\2)*\2/, greedy: !0, lookbehind: !0 }, identifier: { pattern: /(^|[^@\\])`(?:\\[\s\S]|[^`\\]|``)*`/, greedy: !0, lookbehind: !0, inside: { punctuation: /^`|`$/ } }, function: /\b(?:AVG|COUNT|FIRST|FORMAT|LAST|LCASE|LEN|MAX|MID|MIN|MOD|NOW|ROUND|SUM|UCASE)(?=\s*\()/i, keyword: /\b(?:ACTION|ADD|AFTER|ALGORITHM|ALL|ALTER|ANALYZE|ANY|APPLY|AS|ASC|AUTHORIZATION|AUTO_INCREMENT|BACKUP|BDB|BEGIN|BERKELEYDB|BIGINT|BINARY|BIT|BLOB|BOOL|BOOLEAN|BREAK|BROWSE|BTREE|BULK|BY|CALL|CASCADED?|CASE|CHAIN|CHAR(?:ACTER|SET)?|CHECK(?:POINT)?|CLOSE|CLUSTERED|COALESCE|COLLATE|COLUMNS?|COMMENT|COMMIT(?:TED)?|COMPUTE|CONNECT|CONSISTENT|CONSTRAINT|CONTAINS(?:TABLE)?|CONTINUE|CONVERT|CREATE|CROSS|CURRENT(?:_DATE|_TIME|_TIMESTAMP|_USER)?|CURSOR|CYCLE|DATA(?:BASES?)?|DATE(?:TIME)?|DAY|DBCC|DEALLOCATE|DEC|DECIMAL|DECLARE|DEFAULT|DEFINER|DELAYED|DELETE|DELIMITERS?|DENY|DESC|DESCRIBE|DETERMINISTIC|DISABLE|DISCARD|DISK|DISTINCT|DISTINCTROW|DISTRIBUTED|DO|DOUBLE|DROP|DUMMY|DUMP(?:FILE)?|DUPLICATE|ELSE(?:IF)?|ENABLE|ENCLOSED|END|ENGINE|ENUM|ERRLVL|ERRORS|ESCAPED?|EXCEPT|EXEC(?:UTE)?|EXISTS|EXIT|EXPLAIN|EXTENDED|FETCH|FIELDS|FILE|FILLFACTOR|FIRST|FIXED|FLOAT|FOLLOWING|FOR(?: EACH ROW)?|FORCE|FOREIGN|FREETEXT(?:TABLE)?|FROM|FULL|FUNCTION|GEOMETRY(?:COLLECTION)?|GLOBAL|GOTO|GRANT|GROUP|HANDLER|HASH|HAVING|HOLDLOCK|HOUR|IDENTITY(?:COL|_INSERT)?|IF|IGNORE|IMPORT|INDEX|INFILE|INNER|INNODB|INOUT|INSERT|INT|INTEGER|INTERSECT|INTERVAL|INTO|INVOKER|ISOLATION|ITERATE|JOIN|KEYS?|KILL|LANGUAGE|LAST|LEAVE|LEFT|LEVEL|LIMIT|LINENO|LINES|LINESTRING|LOAD|LOCAL|LOCK|LONG(?:BLOB|TEXT)|LOOP|MATCH(?:ED)?|MEDIUM(?:BLOB|INT|TEXT)|MERGE|MIDDLEINT|MINUTE|MODE|MODIFIES|MODIFY|MONTH|MULTI(?:LINESTRING|POINT|POLYGON)|NATIONAL|NATURAL|NCHAR|NEXT|NO|NONCLUSTERED|NULLIF|NUMERIC|OFF?|OFFSETS?|ON|OPEN(?:DATASOURCE|QUERY|ROWSET)?|OPTIMIZE|OPTION(?:ALLY)?|ORDER|OUT(?:ER|FILE)?|OVER|PARTIAL|PARTITION|PERCENT|PIVOT|PLAN|POINT|POLYGON|PRECEDING|PRECISION|PREPARE|PREV|PRIMARY|PRINT|PRIVILEGES|PROC(?:EDURE)?|PUBLIC|PURGE|QUICK|RAISERROR|READS?|REAL|RECONFIGURE|REFERENCES|RELEASE|RENAME|REPEAT(?:ABLE)?|REPLACE|REPLICATION|REQUIRE|RESIGNAL|RESTORE|RESTRICT|RETURN(?:ING|S)?|REVOKE|RIGHT|ROLLBACK|ROUTINE|ROW(?:COUNT|GUIDCOL|S)?|RTREE|RULE|SAVE(?:POINT)?|SCHEMA|SECOND|SELECT|SERIAL(?:IZABLE)?|SESSION(?:_USER)?|SET(?:USER)?|SHARE|SHOW|SHUTDOWN|SIMPLE|SMALLINT|SNAPSHOT|SOME|SONAME|SQL|START(?:ING)?|STATISTICS|STATUS|STRIPED|SYSTEM_USER|TABLES?|TABLESPACE|TEMP(?:ORARY|TABLE)?|TERMINATED|TEXT(?:SIZE)?|THEN|TIME(?:STAMP)?|TINY(?:BLOB|INT|TEXT)|TOP?|TRAN(?:SACTIONS?)?|TRIGGER|TRUNCATE|TSEQUAL|TYPES?|UNBOUNDED|UNCOMMITTED|UNDEFINED|UNION|UNIQUE|UNLOCK|UNPIVOT|UNSIGNED|UPDATE(?:TEXT)?|USAGE|USE|USER|USING|VALUES?|VAR(?:BINARY|CHAR|CHARACTER|YING)|VIEW|WAITFOR|WARNINGS|WHEN|WHERE|WHILE|WITH(?: ROLLUP|IN)?|WORK|WRITE(?:TEXT)?|YEAR)\b/i, boolean: /\b(?:FALSE|NULL|TRUE)\b/i, number: /\b0x[\da-f]+\b|\b\d+(?:\.\d*)?|\B\.\d+\b/i, operator: /[-+*\/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?|\b(?:AND|BETWEEN|DIV|ILIKE|IN|IS|LIKE|NOT|OR|REGEXP|RLIKE|SOUNDS LIKE|XOR)\b/i, punctuation: /[;[\]()`,.]/ }, function(e) {
+  var n = e.languages.javascript["template-string"], t = n.pattern.source, r = n.inside.interpolation, a = r.inside["interpolation-punctuation"], o = r.pattern.source;
+  function i(f, m) {
+    if (e.languages[f])
+      return { pattern: RegExp("((?:" + m + ")\\s*)" + t), lookbehind: !0, greedy: !0, inside: { "template-punctuation": { pattern: /^`|`$/, alias: "string" }, "embedded-code": { pattern: /[\s\S]+/, alias: f } } };
+  }
+  function l(f, m, v) {
+    return f = { code: f, grammar: m, language: v }, e.hooks.run("before-tokenize", f), f.tokens = e.tokenize(f.code, f.grammar), e.hooks.run("after-tokenize", f), f.tokens;
+  }
+  function s(f, m, v) {
+    var d = e.tokenize(f, { interpolation: { pattern: RegExp(o), lookbehind: !0 } }), c = 0, p = {}, d = l(d.map(function(y) {
+      if (typeof y == "string")
+        return y;
+      for (var w, E, y = y.content; f.indexOf((E = c++, w = "___" + v.toUpperCase() + "_" + E + "___")) !== -1; )
+        ;
+      return p[w] = y, w;
+    }).join(""), m, v), b = Object.keys(p);
+    return c = 0, function y(w) {
+      for (var E = 0; E < w.length; E++) {
+        if (c >= b.length)
+          return;
+        var k, N, L, M, D, W, q, _ = w[E];
+        typeof _ == "string" || typeof _.content == "string" ? (k = b[c], (q = (W = typeof _ == "string" ? _ : _.content).indexOf(k)) !== -1 && (++c, N = W.substring(0, q), D = p[k], L = void 0, (M = {})["interpolation-punctuation"] = a, (M = e.tokenize(D, M)).length === 3 && ((L = [1, 1]).push.apply(L, l(M[1], e.languages.javascript, "javascript")), M.splice.apply(M, L)), L = new e.Token("interpolation", M, r.alias, D), M = W.substring(q + k.length), D = [], N && D.push(N), D.push(L), M && (y(W = [M]), D.push.apply(D, W)), typeof _ == "string" ? (w.splice.apply(w, [E, 1].concat(D)), E += D.length - 1) : _.content = D)) : (q = _.content, Array.isArray(q) ? y(q) : y([q]));
+      }
+    }(d), new e.Token(v, d, "language-" + v, f);
+  }
+  e.languages.javascript["template-string"] = [i("css", /\b(?:styled(?:\([^)]*\))?(?:\s*\.\s*\w+(?:\([^)]*\))*)*|css(?:\s*\.\s*(?:global|resolve))?|createGlobalStyle|keyframes)/.source), i("html", /\bhtml|\.\s*(?:inner|outer)HTML\s*\+?=/.source), i("svg", /\bsvg/.source), i("markdown", /\b(?:markdown|md)/.source), i("graphql", /\b(?:gql|graphql(?:\s*\.\s*experimental)?)/.source), i("sql", /\bsql/.source), n].filter(Boolean);
+  var u = { javascript: !0, js: !0, typescript: !0, ts: !0, jsx: !0, tsx: !0 };
+  function g(f) {
+    return typeof f == "string" ? f : Array.isArray(f) ? f.map(g).join("") : g(f.content);
+  }
+  e.hooks.add("after-tokenize", function(f) {
+    f.language in u && function m(v) {
+      for (var c = 0, p = v.length; c < p; c++) {
+        var d, b, y, w = v[c];
+        typeof w != "string" && (d = w.content, Array.isArray(d) ? w.type === "template-string" ? (w = d[1], d.length === 3 && typeof w != "string" && w.type === "embedded-code" && (b = g(w), w = w.alias, w = Array.isArray(w) ? w[0] : w, y = e.languages[w]) && (d[1] = s(b, y, w))) : m(d) : typeof d != "string" && m([d]));
+      }
+    }(f.tokens);
+  });
+}(h), function(e) {
+  e.languages.typescript = e.languages.extend("javascript", { "class-name": { pattern: /(\b(?:class|extends|implements|instanceof|interface|new|type)\s+)(?!keyof\b)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?:\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/, lookbehind: !0, greedy: !0, inside: null }, builtin: /\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\b/ }), e.languages.typescript.keyword.push(/\b(?:abstract|declare|is|keyof|readonly|require)\b/, /\b(?:asserts|infer|interface|module|namespace|type)\b(?=\s*(?:[{_$a-zA-Z\xA0-\uFFFF]|$))/, /\btype\b(?=\s*(?:[\{*]|$))/), delete e.languages.typescript.parameter, delete e.languages.typescript["literal-property"];
+  var n = e.languages.extend("typescript", {});
+  delete n["class-name"], e.languages.typescript["class-name"].inside = n, e.languages.insertBefore("typescript", "function", { decorator: { pattern: /@[$\w\xA0-\uFFFF]+/, inside: { at: { pattern: /^@/, alias: "operator" }, function: /^[\s\S]+/ } }, "generic-function": { pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\s*\()/, greedy: !0, inside: { function: /^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/, generic: { pattern: /<[\s\S]+/, alias: "class-name", inside: n } } } }), e.languages.ts = e.languages.typescript;
+}(h), function(e) {
+  var n = e.languages.javascript, t = /\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})+\}/.source, r = "(@(?:arg|argument|param|property)\\s+(?:" + t + "\\s+)?)";
+  e.languages.jsdoc = e.languages.extend("javadoclike", { parameter: { pattern: RegExp(r + /(?:(?!\s)[$\w\xA0-\uFFFF.])+(?=\s|$)/.source), lookbehind: !0, inside: { punctuation: /\./ } } }), e.languages.insertBefore("jsdoc", "keyword", { "optional-parameter": { pattern: RegExp(r + /\[(?:(?!\s)[$\w\xA0-\uFFFF.])+(?:=[^[\]]+)?\](?=\s|$)/.source), lookbehind: !0, inside: { parameter: { pattern: /(^\[)[$\w\xA0-\uFFFF\.]+/, lookbehind: !0, inside: { punctuation: /\./ } }, code: { pattern: /(=)[\s\S]*(?=\]$)/, lookbehind: !0, inside: n, alias: "language-javascript" }, punctuation: /[=[\]]/ } }, "class-name": [{ pattern: RegExp(/(@(?:augments|class|extends|interface|memberof!?|template|this|typedef)\s+(?:<TYPE>\s+)?)[A-Z]\w*(?:\.[A-Z]\w*)*/.source.replace(/<TYPE>/g, function() {
+    return t;
+  })), lookbehind: !0, inside: { punctuation: /\./ } }, { pattern: RegExp("(@[a-z]+\\s+)" + t), lookbehind: !0, inside: { string: n.string, number: n.number, boolean: n.boolean, keyword: e.languages.typescript.keyword, operator: /=>|\.\.\.|[&|?:*]/, punctuation: /[.,;=<>{}()[\]]/ } }], example: { pattern: /(@example\s+(?!\s))(?:[^@\s]|\s+(?!\s))+?(?=\s*(?:\*\s*)?(?:@\w|\*\/))/, lookbehind: !0, inside: { code: { pattern: /^([\t ]*(?:\*\s*)?)\S.*$/m, lookbehind: !0, inside: n, alias: "language-javascript" } } } }), e.languages.javadoclike.addSupport("javascript", e.languages.jsdoc);
+}(h), function(e) {
+  e.languages.flow = e.languages.extend("javascript", {}), e.languages.insertBefore("flow", "keyword", { type: [{ pattern: /\b(?:[Bb]oolean|Function|[Nn]umber|[Ss]tring|[Ss]ymbol|any|mixed|null|void)\b/, alias: "class-name" }] }), e.languages.flow["function-variable"].pattern = /(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=\s*(?:function\b|(?:\([^()]*\)(?:\s*:\s*\w+)?|(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/i, delete e.languages.flow.parameter, e.languages.insertBefore("flow", "operator", { "flow-punctuation": { pattern: /\{\||\|\}/, alias: "punctuation" } }), Array.isArray(e.languages.flow.keyword) || (e.languages.flow.keyword = [e.languages.flow.keyword]), e.languages.flow.keyword.unshift({ pattern: /(^|[^$]\b)(?:Class|declare|opaque|type)\b(?!\$)/, lookbehind: !0 }, { pattern: /(^|[^$]\B)\$(?:Diff|Enum|Exact|Keys|ObjMap|PropertyType|Record|Shape|Subtype|Supertype|await)\b(?!\$)/, lookbehind: !0 });
+}(h), h.languages.n4js = h.languages.extend("javascript", { keyword: /\b(?:Array|any|boolean|break|case|catch|class|const|constructor|continue|debugger|declare|default|delete|do|else|enum|export|extends|false|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|module|new|null|number|package|private|protected|public|return|set|static|string|super|switch|this|throw|true|try|typeof|var|void|while|with|yield)\b/ }), h.languages.insertBefore("n4js", "constant", { annotation: { pattern: /@+\w+/, alias: "operator" } }), h.languages.n4jsd = h.languages.n4js, function(e) {
+  function n(i, l) {
+    return RegExp(i.replace(/<ID>/g, function() {
+      return /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/.source;
+    }), l);
+  }
+  e.languages.insertBefore("javascript", "function-variable", { "method-variable": { pattern: RegExp("(\\.\\s*)" + e.languages.javascript["function-variable"].pattern.source), lookbehind: !0, alias: ["function-variable", "method", "function", "property-access"] } }), e.languages.insertBefore("javascript", "function", { method: { pattern: RegExp("(\\.\\s*)" + e.languages.javascript.function.source), lookbehind: !0, alias: ["function", "property-access"] } }), e.languages.insertBefore("javascript", "constant", { "known-class-name": [{ pattern: /\b(?:(?:Float(?:32|64)|(?:Int|Uint)(?:8|16|32)|Uint8Clamped)?Array|ArrayBuffer|BigInt|Boolean|DataView|Date|Error|Function|Intl|JSON|(?:Weak)?(?:Map|Set)|Math|Number|Object|Promise|Proxy|Reflect|RegExp|String|Symbol|WebAssembly)\b/, alias: "class-name" }, { pattern: /\b(?:[A-Z]\w*)Error\b/, alias: "class-name" }] }), e.languages.insertBefore("javascript", "keyword", { imports: { pattern: n(/(\bimport\b\s*)(?:<ID>(?:\s*,\s*(?:\*\s*as\s+<ID>|\{[^{}]*\}))?|\*\s*as\s+<ID>|\{[^{}]*\})(?=\s*\bfrom\b)/.source), lookbehind: !0, inside: e.languages.javascript }, exports: { pattern: n(/(\bexport\b\s*)(?:\*(?:\s*as\s+<ID>)?(?=\s*\bfrom\b)|\{[^{}]*\})/.source), lookbehind: !0, inside: e.languages.javascript } }), e.languages.javascript.keyword.unshift({ pattern: /\b(?:as|default|export|from|import)\b/, alias: "module" }, { pattern: /\b(?:await|break|catch|continue|do|else|finally|for|if|return|switch|throw|try|while|yield)\b/, alias: "control-flow" }, { pattern: /\bnull\b/, alias: ["null", "nil"] }, { pattern: /\bundefined\b/, alias: "nil" }), e.languages.insertBefore("javascript", "operator", { spread: { pattern: /\.{3}/, alias: "operator" }, arrow: { pattern: /=>/, alias: "operator" } }), e.languages.insertBefore("javascript", "punctuation", { "property-access": { pattern: n(/(\.\s*)#?<ID>/.source), lookbehind: !0 }, "maybe-class-name": { pattern: /(^|[^$\w\xA0-\uFFFF])[A-Z][$\w\xA0-\uFFFF]+/, lookbehind: !0 }, dom: { pattern: /\b(?:document|(?:local|session)Storage|location|navigator|performance|window)\b/, alias: "variable" }, console: { pattern: /\bconsole(?=\s*\.)/, alias: "class-name" } });
+  for (var t = ["function", "function-variable", "method", "method-variable", "property-access"], r = 0; r < t.length; r++) {
+    var o = t[r], a = e.languages.javascript[o], o = (a = e.util.type(a) === "RegExp" ? e.languages.javascript[o] = { pattern: a } : a).inside || {};
+    (a.inside = o)["maybe-class-name"] = /^[A-Z][\s\S]*/;
+  }
+}(h), function(e) {
+  var n = e.util.clone(e.languages.javascript), t = /(?:\s|\/\/.*(?!.)|\/\*(?:[^*]|\*(?!\/))\*\/)/.source, r = /(?:\{(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])*\})/.source, a = /(?:\{<S>*\.{3}(?:[^{}]|<BRACES>)*\})/.source;
+  function o(s, u) {
+    return s = s.replace(/<S>/g, function() {
+      return t;
+    }).replace(/<BRACES>/g, function() {
+      return r;
+    }).replace(/<SPREAD>/g, function() {
+      return a;
+    }), RegExp(s, u);
+  }
+  a = o(a).source, e.languages.jsx = e.languages.extend("markup", n), e.languages.jsx.tag.pattern = o(/<\/?(?:[\w.:-]+(?:<S>+(?:[\w.:$-]+(?:=(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s{'"/>=]+|<BRACES>))?|<SPREAD>))*<S>*\/?)?>/.source), e.languages.jsx.tag.inside.tag.pattern = /^<\/?[^\s>\/]*/, e.languages.jsx.tag.inside["attr-value"].pattern = /=(?!\{)(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s'">]+)/, e.languages.jsx.tag.inside.tag.inside["class-name"] = /^[A-Z]\w*(?:\.[A-Z]\w*)*$/, e.languages.jsx.tag.inside.comment = n.comment, e.languages.insertBefore("inside", "attr-name", { spread: { pattern: o(/<SPREAD>/.source), inside: e.languages.jsx } }, e.languages.jsx.tag), e.languages.insertBefore("inside", "special-attr", { script: { pattern: o(/=<BRACES>/.source), alias: "language-javascript", inside: { "script-punctuation": { pattern: /^=(?=\{)/, alias: "punctuation" }, rest: e.languages.jsx } } }, e.languages.jsx.tag);
+  function i(s) {
+    for (var u = [], g = 0; g < s.length; g++) {
+      var f = s[g], m = !1;
+      typeof f != "string" && (f.type === "tag" && f.content[0] && f.content[0].type === "tag" ? f.content[0].content[0].content === "</" ? 0 < u.length && u[u.length - 1].tagName === l(f.content[0].content[1]) && u.pop() : f.content[f.content.length - 1].content !== "/>" && u.push({ tagName: l(f.content[0].content[1]), openedBraces: 0 }) : 0 < u.length && f.type === "punctuation" && f.content === "{" ? u[u.length - 1].openedBraces++ : 0 < u.length && 0 < u[u.length - 1].openedBraces && f.type === "punctuation" && f.content === "}" ? u[u.length - 1].openedBraces-- : m = !0), (m || typeof f == "string") && 0 < u.length && u[u.length - 1].openedBraces === 0 && (m = l(f), g < s.length - 1 && (typeof s[g + 1] == "string" || s[g + 1].type === "plain-text") && (m += l(s[g + 1]), s.splice(g + 1, 1)), 0 < g && (typeof s[g - 1] == "string" || s[g - 1].type === "plain-text") && (m = l(s[g - 1]) + m, s.splice(g - 1, 1), g--), s[g] = new e.Token("plain-text", m, null, m)), f.content && typeof f.content != "string" && i(f.content);
+    }
+  }
+  var l = function(s) {
+    return s ? typeof s == "string" ? s : typeof s.content == "string" ? s.content : s.content.map(l).join("") : "";
+  };
+  e.hooks.add("after-tokenize", function(s) {
+    s.language !== "jsx" && s.language !== "tsx" || i(s.tokens);
+  });
+}(h), function(e) {
+  var n = e.util.clone(e.languages.typescript), n = (e.languages.tsx = e.languages.extend("jsx", n), delete e.languages.tsx.parameter, delete e.languages.tsx["literal-property"], e.languages.tsx.tag);
+  n.pattern = RegExp(/(^|[^\w$]|(?=<\/))/.source + "(?:" + n.pattern.source + ")", n.pattern.flags), n.lookbehind = !0;
+}(h), h.languages.swift = { comment: { pattern: /(^|[^\\:])(?:\/\/.*|\/\*(?:[^/*]|\/(?!\*)|\*(?!\/)|\/\*(?:[^*]|\*(?!\/))*\*\/)*\*\/)/, lookbehind: !0, greedy: !0 }, "string-literal": [{ pattern: RegExp(/(^|[^"#])/.source + "(?:" + /"(?:\\(?:\((?:[^()]|\([^()]*\))*\)|\r\n|[^(])|[^\\\r\n"])*"/.source + "|" + /"""(?:\\(?:\((?:[^()]|\([^()]*\))*\)|[^(])|[^\\"]|"(?!""))*"""/.source + ")" + /(?!["#])/.source), lookbehind: !0, greedy: !0, inside: { interpolation: { pattern: /(\\\()(?:[^()]|\([^()]*\))*(?=\))/, lookbehind: !0, inside: null }, "interpolation-punctuation": { pattern: /^\)|\\\($/, alias: "punctuation" }, punctuation: /\\(?=[\r\n])/, string: /[\s\S]+/ } }, { pattern: RegExp(/(^|[^"#])(#+)/.source + "(?:" + /"(?:\\(?:#+\((?:[^()]|\([^()]*\))*\)|\r\n|[^#])|[^\\\r\n])*?"/.source + "|" + /"""(?:\\(?:#+\((?:[^()]|\([^()]*\))*\)|[^#])|[^\\])*?"""/.source + ")\\2"), lookbehind: !0, greedy: !0, inside: { interpolation: { pattern: /(\\#+\()(?:[^()]|\([^()]*\))*(?=\))/, lookbehind: !0, inside: null }, "interpolation-punctuation": { pattern: /^\)|\\#+\($/, alias: "punctuation" }, string: /[\s\S]+/ } }], directive: { pattern: RegExp(/#/.source + "(?:" + /(?:elseif|if)\b/.source + "(?:[ 	]*" + /(?:![ \t]*)?(?:\b\w+\b(?:[ \t]*\((?:[^()]|\([^()]*\))*\))?|\((?:[^()]|\([^()]*\))*\))(?:[ \t]*(?:&&|\|\|))?/.source + ")+|" + /(?:else|endif)\b/.source + ")"), alias: "property", inside: { "directive-name": /^#\w+/, boolean: /\b(?:false|true)\b/, number: /\b\d+(?:\.\d+)*\b/, operator: /!|&&|\|\||[<>]=?/, punctuation: /[(),]/ } }, literal: { pattern: /#(?:colorLiteral|column|dsohandle|file(?:ID|Literal|Path)?|function|imageLiteral|line)\b/, alias: "constant" }, "other-directive": { pattern: /#\w+\b/, alias: "property" }, attribute: { pattern: /@\w+/, alias: "atrule" }, "function-definition": { pattern: /(\bfunc\s+)\w+/, lookbehind: !0, alias: "function" }, label: { pattern: /\b(break|continue)\s+\w+|\b[a-zA-Z_]\w*(?=\s*:\s*(?:for|repeat|while)\b)/, lookbehind: !0, alias: "important" }, keyword: /\b(?:Any|Protocol|Self|Type|actor|as|assignment|associatedtype|associativity|async|await|break|case|catch|class|continue|convenience|default|defer|deinit|didSet|do|dynamic|else|enum|extension|fallthrough|fileprivate|final|for|func|get|guard|higherThan|if|import|in|indirect|infix|init|inout|internal|is|isolated|lazy|left|let|lowerThan|mutating|none|nonisolated|nonmutating|open|operator|optional|override|postfix|precedencegroup|prefix|private|protocol|public|repeat|required|rethrows|return|right|safe|self|set|some|static|struct|subscript|super|switch|throw|throws|try|typealias|unowned|unsafe|var|weak|where|while|willSet)\b/, boolean: /\b(?:false|true)\b/, nil: { pattern: /\bnil\b/, alias: "constant" }, "short-argument": /\$\d+\b/, omit: { pattern: /\b_\b/, alias: "keyword" }, number: /\b(?:[\d_]+(?:\.[\de_]+)?|0x[a-f0-9_]+(?:\.[a-f0-9p_]+)?|0b[01_]+|0o[0-7_]+)\b/i, "class-name": /\b[A-Z](?:[A-Z_\d]*[a-z]\w*)?\b/, function: /\b[a-z_]\w*(?=\s*\()/i, constant: /\b(?:[A-Z_]{2,}|k[A-Z][A-Za-z_]+)\b/, operator: /[-+*/%=!<>&|^~?]+|\.[.\-+*/%=!<>&|^~?]+/, punctuation: /[{}[\]();,.:\\]/ }, h.languages.swift["string-literal"].forEach(function(e) {
+  e.inside.interpolation.inside = h.languages.swift;
+}), function(e) {
+  e.languages.kotlin = e.languages.extend("clike", { keyword: { pattern: /(^|[^.])\b(?:abstract|actual|annotation|as|break|by|catch|class|companion|const|constructor|continue|crossinline|data|do|dynamic|else|enum|expect|external|final|finally|for|fun|get|if|import|in|infix|init|inline|inner|interface|internal|is|lateinit|noinline|null|object|open|operator|out|override|package|private|protected|public|reified|return|sealed|set|super|suspend|tailrec|this|throw|to|try|typealias|val|var|vararg|when|where|while)\b/, lookbehind: !0 }, function: [{ pattern: /(?:`[^\r\n`]+`|\b\w+)(?=\s*\()/, greedy: !0 }, { pattern: /(\.)(?:`[^\r\n`]+`|\w+)(?=\s*\{)/, lookbehind: !0, greedy: !0 }], number: /\b(?:0[xX][\da-fA-F]+(?:_[\da-fA-F]+)*|0[bB][01]+(?:_[01]+)*|\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?(?:[eE][+-]?\d+(?:_\d+)*)?[fFL]?)\b/, operator: /\+[+=]?|-[-=>]?|==?=?|!(?:!|==?)?|[\/*%<>]=?|[?:]:?|\.\.|&&|\|\||\b(?:and|inv|or|shl|shr|ushr|xor)\b/ }), delete e.languages.kotlin["class-name"];
+  var n = { "interpolation-punctuation": { pattern: /^\$\{?|\}$/, alias: "punctuation" }, expression: { pattern: /[\s\S]+/, inside: e.languages.kotlin } };
+  e.languages.insertBefore("kotlin", "string", { "string-literal": [{ pattern: /"""(?:[^$]|\$(?:(?!\{)|\{[^{}]*\}))*?"""/, alias: "multiline", inside: { interpolation: { pattern: /\$(?:[a-z_]\w*|\{[^{}]*\})/i, inside: n }, string: /[\s\S]+/ } }, { pattern: /"(?:[^"\\\r\n$]|\\.|\$(?:(?!\{)|\{[^{}]*\}))*"/, alias: "singleline", inside: { interpolation: { pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:[a-z_]\w*|\{[^{}]*\})/i, lookbehind: !0, inside: n }, string: /[\s\S]+/ } }], char: { pattern: /'(?:[^'\\\r\n]|\\(?:.|u[a-fA-F0-9]{0,4}))'/, greedy: !0 } }), delete e.languages.kotlin.string, e.languages.insertBefore("kotlin", "keyword", { annotation: { pattern: /\B@(?:\w+:)?(?:[A-Z]\w*|\[[^\]]+\])/, alias: "builtin" } }), e.languages.insertBefore("kotlin", "function", { label: { pattern: /\b\w+@|@\w+\b/, alias: "symbol" } }), e.languages.kt = e.languages.kotlin, e.languages.kts = e.languages.kotlin;
+}(h), h.languages.c = h.languages.extend("clike", { comment: { pattern: /\/\/(?:[^\r\n\\]|\\(?:\r\n?|\n|(?![\r\n])))*|\/\*[\s\S]*?(?:\*\/|$)/, greedy: !0 }, string: { pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/, greedy: !0 }, "class-name": { pattern: /(\b(?:enum|struct)\s+(?:__attribute__\s*\(\([\s\S]*?\)\)\s*)?)\w+|\b[a-z]\w*_t\b/, lookbehind: !0 }, keyword: /\b(?:_Alignas|_Alignof|_Atomic|_Bool|_Complex|_Generic|_Imaginary|_Noreturn|_Static_assert|_Thread_local|__attribute__|asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|inline|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|typeof|union|unsigned|void|volatile|while)\b/, function: /\b[a-z_]\w*(?=\s*\()/i, number: /(?:\b0x(?:[\da-f]+(?:\.[\da-f]*)?|\.[\da-f]+)(?:p[+-]?\d+)?|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ful]{0,4}/i, operator: />>=?|<<=?|->|([-+&|:])\1|[?:~]|[-+*/%&|^!=<>]=?/ }), h.languages.insertBefore("c", "string", { char: { pattern: /'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n]){0,32}'/, greedy: !0 } }), h.languages.insertBefore("c", "string", { macro: { pattern: /(^[\t ]*)#\s*[a-z](?:[^\r\n\\/]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|\\(?:\r\n|[\s\S]))*/im, lookbehind: !0, greedy: !0, alias: "property", inside: { string: [{ pattern: /^(#\s*include\s*)<[^>]+>/, lookbehind: !0 }, h.languages.c.string], char: h.languages.c.char, comment: h.languages.c.comment, "macro-name": [{ pattern: /(^#\s*define\s+)\w+\b(?!\()/i, lookbehind: !0 }, { pattern: /(^#\s*define\s+)\w+\b(?=\()/i, lookbehind: !0, alias: "function" }], directive: { pattern: /^(#\s*)[a-z]+/, lookbehind: !0, alias: "keyword" }, "directive-hash": /^#/, punctuation: /##|\\(?=[\r\n])/, expression: { pattern: /\S[\s\S]*/, inside: h.languages.c } } } }), h.languages.insertBefore("c", "function", { constant: /\b(?:EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|__DATE__|__FILE__|__LINE__|__TIMESTAMP__|__TIME__|__func__|stderr|stdin|stdout)\b/ }), delete h.languages.c.boolean, h.languages.objectivec = h.languages.extend("c", { string: { pattern: /@?"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/, greedy: !0 }, keyword: /\b(?:asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|in|inline|int|long|register|return|self|short|signed|sizeof|static|struct|super|switch|typedef|typeof|union|unsigned|void|volatile|while)\b|(?:@interface|@end|@implementation|@protocol|@class|@public|@protected|@private|@property|@try|@catch|@finally|@throw|@synthesize|@dynamic|@selector)\b/, operator: /-[->]?|\+\+?|!=?|<<?=?|>>?=?|==?|&&?|\|\|?|[~^%?*\/@]/ }), delete h.languages.objectivec["class-name"], h.languages.objc = h.languages.objectivec, h.languages.reason = h.languages.extend("clike", { string: { pattern: /"(?:\\(?:\r\n|[\s\S])|[^\\\r\n"])*"/, greedy: !0 }, "class-name": /\b[A-Z]\w*/, keyword: /\b(?:and|as|assert|begin|class|constraint|do|done|downto|else|end|exception|external|for|fun|function|functor|if|in|include|inherit|initializer|lazy|let|method|module|mutable|new|nonrec|object|of|open|or|private|rec|sig|struct|switch|then|to|try|type|val|virtual|when|while|with)\b/, operator: /\.{3}|:[:=]|\|>|->|=(?:==?|>)?|<=?|>=?|[|^?'#!~`]|[+\-*\/]\.?|\b(?:asr|land|lor|lsl|lsr|lxor|mod)\b/ }), h.languages.insertBefore("reason", "class-name", { char: { pattern: /'(?:\\x[\da-f]{2}|\\o[0-3][0-7][0-7]|\\\d{3}|\\.|[^'\\\r\n])'/, greedy: !0 }, constructor: /\b[A-Z]\w*\b(?!\s*\.)/, label: { pattern: /\b[a-z]\w*(?=::)/, alias: "symbol" } }), delete h.languages.reason.function, function(e) {
+  for (var n = /\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|<self>)*\*\//.source, t = 0; t < 2; t++)
+    n = n.replace(/<self>/g, function() {
+      return n;
+    });
+  n = n.replace(/<self>/g, function() {
+    return /[^\s\S]/.source;
+  }), e.languages.rust = { comment: [{ pattern: RegExp(/(^|[^\\])/.source + n), lookbehind: !0, greedy: !0 }, { pattern: /(^|[^\\:])\/\/.*/, lookbehind: !0, greedy: !0 }], string: { pattern: /b?"(?:\\[\s\S]|[^\\"])*"|b?r(#*)"(?:[^"]|"(?!\1))*"\1/, greedy: !0 }, char: { pattern: /b?'(?:\\(?:x[0-7][\da-fA-F]|u\{(?:[\da-fA-F]_*){1,6}\}|.)|[^\\\r\n\t'])'/, greedy: !0 }, attribute: { pattern: /#!?\[(?:[^\[\]"]|"(?:\\[\s\S]|[^\\"])*")*\]/, greedy: !0, alias: "attr-name", inside: { string: null } }, "closure-params": { pattern: /([=(,:]\s*|\bmove\s*)\|[^|]*\||\|[^|]*\|(?=\s*(?:\{|->))/, lookbehind: !0, greedy: !0, inside: { "closure-punctuation": { pattern: /^\||\|$/, alias: "punctuation" }, rest: null } }, "lifetime-annotation": { pattern: /'\w+/, alias: "symbol" }, "fragment-specifier": { pattern: /(\$\w+:)[a-z]+/, lookbehind: !0, alias: "punctuation" }, variable: /\$\w+/, "function-definition": { pattern: /(\bfn\s+)\w+/, lookbehind: !0, alias: "function" }, "type-definition": { pattern: /(\b(?:enum|struct|trait|type|union)\s+)\w+/, lookbehind: !0, alias: "class-name" }, "module-declaration": [{ pattern: /(\b(?:crate|mod)\s+)[a-z][a-z_\d]*/, lookbehind: !0, alias: "namespace" }, { pattern: /(\b(?:crate|self|super)\s*)::\s*[a-z][a-z_\d]*\b(?:\s*::(?:\s*[a-z][a-z_\d]*\s*::)*)?/, lookbehind: !0, alias: "namespace", inside: { punctuation: /::/ } }], keyword: [/\b(?:Self|abstract|as|async|await|become|box|break|const|continue|crate|do|dyn|else|enum|extern|final|fn|for|if|impl|in|let|loop|macro|match|mod|move|mut|override|priv|pub|ref|return|self|static|struct|super|trait|try|type|typeof|union|unsafe|unsized|use|virtual|where|while|yield)\b/, /\b(?:bool|char|f(?:32|64)|[ui](?:8|16|32|64|128|size)|str)\b/], function: /\b[a-z_]\w*(?=\s*(?:::\s*<|\())/, macro: { pattern: /\b\w+!/, alias: "property" }, constant: /\b[A-Z_][A-Z_\d]+\b/, "class-name": /\b[A-Z]\w*\b/, namespace: { pattern: /(?:\b[a-z][a-z_\d]*\s*::\s*)*\b[a-z][a-z_\d]*\s*::(?!\s*<)/, inside: { punctuation: /::/ } }, number: /\b(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*|(?:(?:\d(?:_?\d)*)?\.)?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)(?:_?(?:f32|f64|[iu](?:8|16|32|64|size)?))?\b/, boolean: /\b(?:false|true)\b/, punctuation: /->|\.\.=|\.{1,3}|::|[{}[\];(),:]/, operator: /[-+*\/%!^]=?|=[=>]?|&[&=]?|\|[|=]?|<<?=?|>>?=?|[@?]/ }, e.languages.rust["closure-params"].inside.rest = e.languages.rust, e.languages.rust.attribute.inside.string = e.languages.rust.string;
+}(h), h.languages.go = h.languages.extend("clike", { string: { pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"|`[^`]*`/, lookbehind: !0, greedy: !0 }, keyword: /\b(?:break|case|chan|const|continue|default|defer|else|fallthrough|for|func|go(?:to)?|if|import|interface|map|package|range|return|select|struct|switch|type|var)\b/, boolean: /\b(?:_|false|iota|nil|true)\b/, number: [/\b0(?:b[01_]+|o[0-7_]+)i?\b/i, /\b0x(?:[a-f\d_]+(?:\.[a-f\d_]*)?|\.[a-f\d_]+)(?:p[+-]?\d+(?:_\d+)*)?i?(?!\w)/i, /(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?[\d_]+)?i?(?!\w)/i], operator: /[*\/%^!=]=?|\+[=+]?|-[=-]?|\|[=|]?|&(?:=|&|\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\.\.\./, builtin: /\b(?:append|bool|byte|cap|close|complex|complex(?:64|128)|copy|delete|error|float(?:32|64)|u?int(?:8|16|32|64)?|imag|len|make|new|panic|print(?:ln)?|real|recover|rune|string|uintptr)\b/ }), h.languages.insertBefore("go", "string", { char: { pattern: /'(?:\\.|[^'\\\r\n]){0,10}'/, greedy: !0 } }), delete h.languages.go["class-name"], function(e) {
+  var n = /\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|char8_t|class|co_await|co_return|co_yield|compl|concept|const|const_cast|consteval|constexpr|constinit|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|final|float|for|friend|goto|if|import|inline|int|int16_t|int32_t|int64_t|int8_t|long|module|mutable|namespace|new|noexcept|nullptr|operator|override|private|protected|public|register|reinterpret_cast|requires|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|uint16_t|uint32_t|uint64_t|uint8_t|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/, t = /\b(?!<keyword>)\w+(?:\s*\.\s*\w+)*\b/.source.replace(/<keyword>/g, function() {
+    return n.source;
+  });
+  e.languages.cpp = e.languages.extend("c", { "class-name": [{ pattern: RegExp(/(\b(?:class|concept|enum|struct|typename)\s+)(?!<keyword>)\w+/.source.replace(/<keyword>/g, function() {
+    return n.source;
+  })), lookbehind: !0 }, /\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/, /\b[A-Z_]\w*(?=\s*::\s*~\w+\s*\()/i, /\b\w+(?=\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\s*::\s*\w+\s*\()/], keyword: n, number: { pattern: /(?:\b0b[01']+|\b0x(?:[\da-f']+(?:\.[\da-f']*)?|\.[\da-f']+)(?:p[+-]?[\d']+)?|(?:\b[\d']+(?:\.[\d']*)?|\B\.[\d']+)(?:e[+-]?[\d']+)?)[ful]{0,4}/i, greedy: !0 }, operator: />>=?|<<=?|->|--|\+\+|&&|\|\||[?:~]|<=>|[-+*/%&|^!=<>]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/, boolean: /\b(?:false|true)\b/ }), e.languages.insertBefore("cpp", "string", { module: { pattern: RegExp(/(\b(?:import|module)\s+)/.source + "(?:" + /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|<[^<>\r\n]*>/.source + "|" + /<mod-name>(?:\s*:\s*<mod-name>)?|:\s*<mod-name>/.source.replace(/<mod-name>/g, function() {
+    return t;
+  }) + ")"), lookbehind: !0, greedy: !0, inside: { string: /^[<"][\s\S]+/, operator: /:/, punctuation: /\./ } }, "raw-string": { pattern: /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/, alias: "string", greedy: !0 } }), e.languages.insertBefore("cpp", "keyword", { "generic-function": { pattern: /\b(?!operator\b)[a-z_]\w*\s*<(?:[^<>]|<[^<>]*>)*>(?=\s*\()/i, inside: { function: /^\w+/, generic: { pattern: /<[\s\S]+/, alias: "class-name", inside: e.languages.cpp } } } }), e.languages.insertBefore("cpp", "operator", { "double-colon": { pattern: /::/, alias: "punctuation" } }), e.languages.insertBefore("cpp", "class-name", { "base-clause": { pattern: /(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/, lookbehind: !0, greedy: !0, inside: e.languages.extend("cpp", {}) } }), e.languages.insertBefore("inside", "double-colon", { "class-name": /\b[a-z_]\w*\b(?!\s*::)/i }, e.languages.cpp["base-clause"]);
+}(h), h.languages.python = { comment: { pattern: /(^|[^\\])#.*/, lookbehind: !0, greedy: !0 }, "string-interpolation": { pattern: /(?:f|fr|rf)(?:("""|''')[\s\S]*?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i, greedy: !0, inside: { interpolation: { pattern: /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}])+\})+\})+\}/, lookbehind: !0, inside: { "format-spec": { pattern: /(:)[^:(){}]+(?=\}$)/, lookbehind: !0 }, "conversion-option": { pattern: /![sra](?=[:}]$)/, alias: "punctuation" }, rest: null } }, string: /[\s\S]+/ } }, "triple-quoted-string": { pattern: /(?:[rub]|br|rb)?("""|''')[\s\S]*?\1/i, greedy: !0, alias: "string" }, string: { pattern: /(?:[rub]|br|rb)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i, greedy: !0 }, function: { pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g, lookbehind: !0 }, "class-name": { pattern: /(\bclass\s+)\w+/i, lookbehind: !0 }, decorator: { pattern: /(^[\t ]*)@\w+(?:\.\w+)*/m, lookbehind: !0, alias: ["annotation", "punctuation"], inside: { punctuation: /\./ } }, keyword: /\b(?:_(?=\s*:)|and|as|assert|async|await|break|case|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\b/, builtin: /\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\b/, boolean: /\b(?:False|None|True)\b/, number: /\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f0-9])+)\b|(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:e[+-]?\d+(?:_\d+)*)?j?(?!\w)/i, operator: /[-+%=]=?|!=|:=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/, punctuation: /[{}[\];(),.:]/ }, h.languages.python["string-interpolation"].inside.interpolation.inside.rest = h.languages.python, h.languages.py = h.languages.python, h.languages.json = { property: { pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?=\s*:)/, lookbehind: !0, greedy: !0 }, string: { pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?!\s*:)/, lookbehind: !0, greedy: !0 }, comment: { pattern: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/, greedy: !0 }, number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i, punctuation: /[{}[\],]/, operator: /:/, boolean: /\b(?:false|true)\b/, null: { pattern: /\bnull\b/, alias: "keyword" } }, h.languages.webmanifest = h.languages.json;
+var sn = {};
+yr(sn, {
+  dracula: () => xr,
+  duotoneDark: () => Ar,
+  duotoneLight: () => Er,
+  github: () => _r,
+  gruvboxMaterialDark: () => na,
+  gruvboxMaterialLight: () => ra,
+  jettwaveDark: () => Wr,
+  jettwaveLight: () => Zr,
+  nightOwl: () => Cr,
+  nightOwlLight: () => Ir,
+  oceanicNext: () => Lr,
+  okaidia: () => Nr,
+  oneDark: () => Xr,
+  oneLight: () => Jr,
+  palenight: () => Br,
+  shadesOfPurple: () => Mr,
+  synthwave84: () => $r,
+  ultramin: () => zr,
+  vsDark: () => tt,
+  vsLight: () => Hr
+});
+var vr = {
+  plain: {
+    color: "#F8F8F2",
+    backgroundColor: "#282A36"
+  },
+  styles: [
+    {
+      types: ["prolog", "constant", "builtin"],
+      style: {
+        color: "rgb(189, 147, 249)"
+      }
+    },
+    {
+      types: ["inserted", "function"],
+      style: {
+        color: "rgb(80, 250, 123)"
+      }
+    },
+    {
+      types: ["deleted"],
+      style: {
+        color: "rgb(255, 85, 85)"
+      }
+    },
+    {
+      types: ["changed"],
+      style: {
+        color: "rgb(255, 184, 108)"
+      }
+    },
+    {
+      types: ["punctuation", "symbol"],
+      style: {
+        color: "rgb(248, 248, 242)"
+      }
+    },
+    {
+      types: ["string", "char", "tag", "selector"],
+      style: {
+        color: "rgb(255, 121, 198)"
+      }
+    },
+    {
+      types: ["keyword", "variable"],
+      style: {
+        color: "rgb(189, 147, 249)",
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["comment"],
+      style: {
+        color: "rgb(98, 114, 164)"
+      }
+    },
+    {
+      types: ["attr-name"],
+      style: {
+        color: "rgb(241, 250, 140)"
+      }
+    }
+  ]
+}, xr = vr, wr = {
+  plain: {
+    backgroundColor: "#2a2734",
+    color: "#9a86fd"
+  },
+  styles: [
+    {
+      types: ["comment", "prolog", "doctype", "cdata", "punctuation"],
+      style: {
+        color: "#6c6783"
+      }
+    },
+    {
+      types: ["namespace"],
+      style: {
+        opacity: 0.7
+      }
+    },
+    {
+      types: ["tag", "operator", "number"],
+      style: {
+        color: "#e09142"
+      }
+    },
+    {
+      types: ["property", "function"],
+      style: {
+        color: "#9a86fd"
+      }
+    },
+    {
+      types: ["tag-id", "selector", "atrule-id"],
+      style: {
+        color: "#eeebff"
+      }
+    },
+    {
+      types: ["attr-name"],
+      style: {
+        color: "#c4b9fe"
+      }
+    },
+    {
+      types: [
+        "boolean",
+        "string",
+        "entity",
+        "url",
+        "attr-value",
+        "keyword",
+        "control",
+        "directive",
+        "unit",
+        "statement",
+        "regex",
+        "atrule",
+        "placeholder",
+        "variable"
+      ],
+      style: {
+        color: "#ffcc99"
+      }
+    },
+    {
+      types: ["deleted"],
+      style: {
+        textDecorationLine: "line-through"
+      }
+    },
+    {
+      types: ["inserted"],
+      style: {
+        textDecorationLine: "underline"
+      }
+    },
+    {
+      types: ["italic"],
+      style: {
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["important", "bold"],
+      style: {
+        fontWeight: "bold"
+      }
+    },
+    {
+      types: ["important"],
+      style: {
+        color: "#c4b9fe"
+      }
+    }
+  ]
+}, Ar = wr, kr = {
+  plain: {
+    backgroundColor: "#faf8f5",
+    color: "#728fcb"
+  },
+  styles: [
+    {
+      types: ["comment", "prolog", "doctype", "cdata", "punctuation"],
+      style: {
+        color: "#b6ad9a"
+      }
+    },
+    {
+      types: ["namespace"],
+      style: {
+        opacity: 0.7
+      }
+    },
+    {
+      types: ["tag", "operator", "number"],
+      style: {
+        color: "#063289"
+      }
+    },
+    {
+      types: ["property", "function"],
+      style: {
+        color: "#b29762"
+      }
+    },
+    {
+      types: ["tag-id", "selector", "atrule-id"],
+      style: {
+        color: "#2d2006"
+      }
+    },
+    {
+      types: ["attr-name"],
+      style: {
+        color: "#896724"
+      }
+    },
+    {
+      types: [
+        "boolean",
+        "string",
+        "entity",
+        "url",
+        "attr-value",
+        "keyword",
+        "control",
+        "directive",
+        "unit",
+        "statement",
+        "regex",
+        "atrule"
+      ],
+      style: {
+        color: "#728fcb"
+      }
+    },
+    {
+      types: ["placeholder", "variable"],
+      style: {
+        color: "#93abdc"
+      }
+    },
+    {
+      types: ["deleted"],
+      style: {
+        textDecorationLine: "line-through"
+      }
+    },
+    {
+      types: ["inserted"],
+      style: {
+        textDecorationLine: "underline"
+      }
+    },
+    {
+      types: ["italic"],
+      style: {
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["important", "bold"],
+      style: {
+        fontWeight: "bold"
+      }
+    },
+    {
+      types: ["important"],
+      style: {
+        color: "#896724"
+      }
+    }
+  ]
+}, Er = kr, Sr = {
+  plain: {
+    color: "#393A34",
+    backgroundColor: "#f6f8fa"
+  },
+  styles: [
+    {
+      types: ["comment", "prolog", "doctype", "cdata"],
+      style: {
+        color: "#999988",
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["namespace"],
+      style: {
+        opacity: 0.7
+      }
+    },
+    {
+      types: ["string", "attr-value"],
+      style: {
+        color: "#e3116c"
+      }
+    },
+    {
+      types: ["punctuation", "operator"],
+      style: {
+        color: "#393A34"
+      }
+    },
+    {
+      types: [
+        "entity",
+        "url",
+        "symbol",
+        "number",
+        "boolean",
+        "variable",
+        "constant",
+        "property",
+        "regex",
+        "inserted"
+      ],
+      style: {
+        color: "#36acaa"
+      }
+    },
+    {
+      types: ["atrule", "keyword", "attr-name", "selector"],
+      style: {
+        color: "#00a4db"
+      }
+    },
+    {
+      types: ["function", "deleted", "tag"],
+      style: {
+        color: "#d73a49"
+      }
+    },
+    {
+      types: ["function-variable"],
+      style: {
+        color: "#6f42c1"
+      }
+    },
+    {
+      types: ["tag", "selector", "keyword"],
+      style: {
+        color: "#00009f"
+      }
+    }
+  ]
+}, _r = Sr, Fr = {
+  plain: {
+    color: "#d6deeb",
+    backgroundColor: "#011627"
+  },
+  styles: [
+    {
+      types: ["changed"],
+      style: {
+        color: "rgb(162, 191, 252)",
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["deleted"],
+      style: {
+        color: "rgba(239, 83, 80, 0.56)",
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["inserted", "attr-name"],
+      style: {
+        color: "rgb(173, 219, 103)",
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["comment"],
+      style: {
+        color: "rgb(99, 119, 119)",
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["string", "url"],
+      style: {
+        color: "rgb(173, 219, 103)"
+      }
+    },
+    {
+      types: ["variable"],
+      style: {
+        color: "rgb(214, 222, 235)"
+      }
+    },
+    {
+      types: ["number"],
+      style: {
+        color: "rgb(247, 140, 108)"
+      }
+    },
+    {
+      types: ["builtin", "char", "constant", "function"],
+      style: {
+        color: "rgb(130, 170, 255)"
+      }
+    },
+    {
+      // This was manually added after the auto-generation
+      // so that punctuations are not italicised
+      types: ["punctuation"],
+      style: {
+        color: "rgb(199, 146, 234)"
+      }
+    },
+    {
+      types: ["selector", "doctype"],
+      style: {
+        color: "rgb(199, 146, 234)",
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["class-name"],
+      style: {
+        color: "rgb(255, 203, 139)"
+      }
+    },
+    {
+      types: ["tag", "operator", "keyword"],
+      style: {
+        color: "rgb(127, 219, 202)"
+      }
+    },
+    {
+      types: ["boolean"],
+      style: {
+        color: "rgb(255, 88, 116)"
+      }
+    },
+    {
+      types: ["property"],
+      style: {
+        color: "rgb(128, 203, 196)"
+      }
+    },
+    {
+      types: ["namespace"],
+      style: {
+        color: "rgb(178, 204, 214)"
+      }
+    }
+  ]
+}, Cr = Fr, Tr = {
+  plain: {
+    color: "#403f53",
+    backgroundColor: "#FBFBFB"
+  },
+  styles: [
+    {
+      types: ["changed"],
+      style: {
+        color: "rgb(162, 191, 252)",
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["deleted"],
+      style: {
+        color: "rgba(239, 83, 80, 0.56)",
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["inserted", "attr-name"],
+      style: {
+        color: "rgb(72, 118, 214)",
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["comment"],
+      style: {
+        color: "rgb(152, 159, 177)",
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["string", "builtin", "char", "constant", "url"],
+      style: {
+        color: "rgb(72, 118, 214)"
+      }
+    },
+    {
+      types: ["variable"],
+      style: {
+        color: "rgb(201, 103, 101)"
+      }
+    },
+    {
+      types: ["number"],
+      style: {
+        color: "rgb(170, 9, 130)"
+      }
+    },
+    {
+      // This was manually added after the auto-generation
+      // so that punctuations are not italicised
+      types: ["punctuation"],
+      style: {
+        color: "rgb(153, 76, 195)"
+      }
+    },
+    {
+      types: ["function", "selector", "doctype"],
+      style: {
+        color: "rgb(153, 76, 195)",
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["class-name"],
+      style: {
+        color: "rgb(17, 17, 17)"
+      }
+    },
+    {
+      types: ["tag"],
+      style: {
+        color: "rgb(153, 76, 195)"
+      }
+    },
+    {
+      types: ["operator", "property", "keyword", "namespace"],
+      style: {
+        color: "rgb(12, 150, 155)"
+      }
+    },
+    {
+      types: ["boolean"],
+      style: {
+        color: "rgb(188, 84, 84)"
+      }
+    }
+  ]
+}, Ir = Tr, Q = {
+  char: "#D8DEE9",
+  comment: "#999999",
+  keyword: "#c5a5c5",
+  primitive: "#5a9bcf",
+  string: "#8dc891",
+  variable: "#d7deea",
+  boolean: "#ff8b50",
+  tag: "#fc929e",
+  function: "#79b6f2",
+  className: "#FAC863"
+}, Or = {
+  plain: {
+    backgroundColor: "#282c34",
+    color: "#ffffff"
+  },
+  styles: [
+    {
+      types: ["attr-name"],
+      style: {
+        color: Q.keyword
+      }
+    },
+    {
+      types: ["attr-value"],
+      style: {
+        color: Q.string
+      }
+    },
+    {
+      types: [
+        "comment",
+        "block-comment",
+        "prolog",
+        "doctype",
+        "cdata",
+        "shebang"
+      ],
+      style: {
+        color: Q.comment
+      }
+    },
+    {
+      types: [
+        "property",
+        "number",
+        "function-name",
+        "constant",
+        "symbol",
+        "deleted"
+      ],
+      style: {
+        color: Q.primitive
+      }
+    },
+    {
+      types: ["boolean"],
+      style: {
+        color: Q.boolean
+      }
+    },
+    {
+      types: ["tag"],
+      style: {
+        color: Q.tag
+      }
+    },
+    {
+      types: ["string"],
+      style: {
+        color: Q.string
+      }
+    },
+    {
+      types: ["punctuation"],
+      style: {
+        color: Q.string
+      }
+    },
+    {
+      types: ["selector", "char", "builtin", "inserted"],
+      style: {
+        color: Q.char
+      }
+    },
+    {
+      types: ["function"],
+      style: {
+        color: Q.function
+      }
+    },
+    {
+      types: ["operator", "entity", "url", "variable"],
+      style: {
+        color: Q.variable
+      }
+    },
+    {
+      types: ["keyword"],
+      style: {
+        color: Q.keyword
+      }
+    },
+    {
+      types: ["atrule", "class-name"],
+      style: {
+        color: Q.className
+      }
+    },
+    {
+      types: ["important"],
+      style: {
+        fontWeight: "400"
+      }
+    },
+    {
+      types: ["bold"],
+      style: {
+        fontWeight: "bold"
+      }
+    },
+    {
+      types: ["italic"],
+      style: {
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["namespace"],
+      style: {
+        opacity: 0.7
+      }
+    }
+  ]
+}, Lr = Or, Rr = {
+  plain: {
+    color: "#f8f8f2",
+    backgroundColor: "#272822"
+  },
+  styles: [
+    {
+      types: ["changed"],
+      style: {
+        color: "rgb(162, 191, 252)",
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["deleted"],
+      style: {
+        color: "#f92672",
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["inserted"],
+      style: {
+        color: "rgb(173, 219, 103)",
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["comment"],
+      style: {
+        color: "#8292a2",
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["string", "url"],
+      style: {
+        color: "#a6e22e"
+      }
+    },
+    {
+      types: ["variable"],
+      style: {
+        color: "#f8f8f2"
+      }
+    },
+    {
+      types: ["number"],
+      style: {
+        color: "#ae81ff"
+      }
+    },
+    {
+      types: ["builtin", "char", "constant", "function", "class-name"],
+      style: {
+        color: "#e6db74"
+      }
+    },
+    {
+      types: ["punctuation"],
+      style: {
+        color: "#f8f8f2"
+      }
+    },
+    {
+      types: ["selector", "doctype"],
+      style: {
+        color: "#a6e22e",
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["tag", "operator", "keyword"],
+      style: {
+        color: "#66d9ef"
+      }
+    },
+    {
+      types: ["boolean"],
+      style: {
+        color: "#ae81ff"
+      }
+    },
+    {
+      types: ["namespace"],
+      style: {
+        color: "rgb(178, 204, 214)",
+        opacity: 0.7
+      }
+    },
+    {
+      types: ["tag", "property"],
+      style: {
+        color: "#f92672"
+      }
+    },
+    {
+      types: ["attr-name"],
+      style: {
+        color: "#a6e22e !important"
+      }
+    },
+    {
+      types: ["doctype"],
+      style: {
+        color: "#8292a2"
+      }
+    },
+    {
+      types: ["rule"],
+      style: {
+        color: "#e6db74"
+      }
+    }
+  ]
+}, Nr = Rr, Dr = {
+  plain: {
+    color: "#bfc7d5",
+    backgroundColor: "#292d3e"
+  },
+  styles: [
+    {
+      types: ["comment"],
+      style: {
+        color: "rgb(105, 112, 152)",
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["string", "inserted"],
+      style: {
+        color: "rgb(195, 232, 141)"
+      }
+    },
+    {
+      types: ["number"],
+      style: {
+        color: "rgb(247, 140, 108)"
+      }
+    },
+    {
+      types: ["builtin", "char", "constant", "function"],
+      style: {
+        color: "rgb(130, 170, 255)"
+      }
+    },
+    {
+      types: ["punctuation", "selector"],
+      style: {
+        color: "rgb(199, 146, 234)"
+      }
+    },
+    {
+      types: ["variable"],
+      style: {
+        color: "rgb(191, 199, 213)"
+      }
+    },
+    {
+      types: ["class-name", "attr-name"],
+      style: {
+        color: "rgb(255, 203, 107)"
+      }
+    },
+    {
+      types: ["tag", "deleted"],
+      style: {
+        color: "rgb(255, 85, 114)"
+      }
+    },
+    {
+      types: ["operator"],
+      style: {
+        color: "rgb(137, 221, 255)"
+      }
+    },
+    {
+      types: ["boolean"],
+      style: {
+        color: "rgb(255, 88, 116)"
+      }
+    },
+    {
+      types: ["keyword"],
+      style: {
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["doctype"],
+      style: {
+        color: "rgb(199, 146, 234)",
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["namespace"],
+      style: {
+        color: "rgb(178, 204, 214)"
+      }
+    },
+    {
+      types: ["url"],
+      style: {
+        color: "rgb(221, 221, 221)"
+      }
+    }
+  ]
+}, Br = Dr, Pr = {
+  plain: {
+    color: "#9EFEFF",
+    backgroundColor: "#2D2A55"
+  },
+  styles: [
+    {
+      types: ["changed"],
+      style: {
+        color: "rgb(255, 238, 128)"
+      }
+    },
+    {
+      types: ["deleted"],
+      style: {
+        color: "rgba(239, 83, 80, 0.56)"
+      }
+    },
+    {
+      types: ["inserted"],
+      style: {
+        color: "rgb(173, 219, 103)"
+      }
+    },
+    {
+      types: ["comment"],
+      style: {
+        color: "rgb(179, 98, 255)",
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["punctuation"],
+      style: {
+        color: "rgb(255, 255, 255)"
+      }
+    },
+    {
+      types: ["constant"],
+      style: {
+        color: "rgb(255, 98, 140)"
+      }
+    },
+    {
+      types: ["string", "url"],
+      style: {
+        color: "rgb(165, 255, 144)"
+      }
+    },
+    {
+      types: ["variable"],
+      style: {
+        color: "rgb(255, 238, 128)"
+      }
+    },
+    {
+      types: ["number", "boolean"],
+      style: {
+        color: "rgb(255, 98, 140)"
+      }
+    },
+    {
+      types: ["attr-name"],
+      style: {
+        color: "rgb(255, 180, 84)"
+      }
+    },
+    {
+      types: [
+        "keyword",
+        "operator",
+        "property",
+        "namespace",
+        "tag",
+        "selector",
+        "doctype"
+      ],
+      style: {
+        color: "rgb(255, 157, 0)"
+      }
+    },
+    {
+      types: ["builtin", "char", "constant", "function", "class-name"],
+      style: {
+        color: "rgb(250, 208, 0)"
+      }
+    }
+  ]
+}, Mr = Pr, jr = {
+  plain: {
+    backgroundColor: "linear-gradient(to bottom, #2a2139 75%, #34294f)",
+    backgroundImage: "#34294f",
+    color: "#f92aad",
+    textShadow: "0 0 2px #100c0f, 0 0 5px #dc078e33, 0 0 10px #fff3"
+  },
+  styles: [
+    {
+      types: ["comment", "block-comment", "prolog", "doctype", "cdata"],
+      style: {
+        color: "#495495",
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["punctuation"],
+      style: {
+        color: "#ccc"
+      }
+    },
+    {
+      types: [
+        "tag",
+        "attr-name",
+        "namespace",
+        "number",
+        "unit",
+        "hexcode",
+        "deleted"
+      ],
+      style: {
+        color: "#e2777a"
+      }
+    },
+    {
+      types: ["property", "selector"],
+      style: {
+        color: "#72f1b8",
+        textShadow: "0 0 2px #100c0f, 0 0 10px #257c5575, 0 0 35px #21272475"
+      }
+    },
+    {
+      types: ["function-name"],
+      style: {
+        color: "#6196cc"
+      }
+    },
+    {
+      types: ["boolean", "selector-id", "function"],
+      style: {
+        color: "#fdfdfd",
+        textShadow: "0 0 2px #001716, 0 0 3px #03edf975, 0 0 5px #03edf975, 0 0 8px #03edf975"
+      }
+    },
+    {
+      types: ["class-name", "maybe-class-name", "builtin"],
+      style: {
+        color: "#fff5f6",
+        textShadow: "0 0 2px #000, 0 0 10px #fc1f2c75, 0 0 5px #fc1f2c75, 0 0 25px #fc1f2c75"
+      }
+    },
+    {
+      types: ["constant", "symbol"],
+      style: {
+        color: "#f92aad",
+        textShadow: "0 0 2px #100c0f, 0 0 5px #dc078e33, 0 0 10px #fff3"
+      }
+    },
+    {
+      types: ["important", "atrule", "keyword", "selector-class"],
+      style: {
+        color: "#f4eee4",
+        textShadow: "0 0 2px #393a33, 0 0 8px #f39f0575, 0 0 2px #f39f0575"
+      }
+    },
+    {
+      types: ["string", "char", "attr-value", "regex", "variable"],
+      style: {
+        color: "#f87c32"
+      }
+    },
+    {
+      types: ["parameter"],
+      style: {
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["entity", "url"],
+      style: {
+        color: "#67cdcc"
+      }
+    },
+    {
+      types: ["operator"],
+      style: {
+        color: "ffffffee"
+      }
+    },
+    {
+      types: ["important", "bold"],
+      style: {
+        fontWeight: "bold"
+      }
+    },
+    {
+      types: ["italic"],
+      style: {
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["entity"],
+      style: {
+        cursor: "help"
+      }
+    },
+    {
+      types: ["inserted"],
+      style: {
+        color: "green"
+      }
+    }
+  ]
+}, $r = jr, Ur = {
+  plain: {
+    color: "#282a2e",
+    backgroundColor: "#ffffff"
+  },
+  styles: [
+    {
+      types: ["comment"],
+      style: {
+        color: "rgb(197, 200, 198)"
+      }
+    },
+    {
+      types: ["string", "number", "builtin", "variable"],
+      style: {
+        color: "rgb(150, 152, 150)"
+      }
+    },
+    {
+      types: ["class-name", "function", "tag", "attr-name"],
+      style: {
+        color: "rgb(40, 42, 46)"
+      }
+    }
+  ]
+}, zr = Ur, Yr = {
+  plain: {
+    color: "#9CDCFE",
+    backgroundColor: "#1E1E1E"
+  },
+  styles: [
+    {
+      types: ["prolog"],
+      style: {
+        color: "rgb(0, 0, 128)"
+      }
+    },
+    {
+      types: ["comment"],
+      style: {
+        color: "rgb(106, 153, 85)"
+      }
+    },
+    {
+      types: ["builtin", "changed", "keyword", "interpolation-punctuation"],
+      style: {
+        color: "rgb(86, 156, 214)"
+      }
+    },
+    {
+      types: ["number", "inserted"],
+      style: {
+        color: "rgb(181, 206, 168)"
+      }
+    },
+    {
+      types: ["constant"],
+      style: {
+        color: "rgb(100, 102, 149)"
+      }
+    },
+    {
+      types: ["attr-name", "variable"],
+      style: {
+        color: "rgb(156, 220, 254)"
+      }
+    },
+    {
+      types: ["deleted", "string", "attr-value", "template-punctuation"],
+      style: {
+        color: "rgb(206, 145, 120)"
+      }
+    },
+    {
+      types: ["selector"],
+      style: {
+        color: "rgb(215, 186, 125)"
+      }
+    },
+    {
+      // Fix tag color
+      types: ["tag"],
+      style: {
+        color: "rgb(78, 201, 176)"
+      }
+    },
+    {
+      // Fix tag color for HTML
+      types: ["tag"],
+      languages: ["markup"],
+      style: {
+        color: "rgb(86, 156, 214)"
+      }
+    },
+    {
+      types: ["punctuation", "operator"],
+      style: {
+        color: "rgb(212, 212, 212)"
+      }
+    },
+    {
+      // Fix punctuation color for HTML
+      types: ["punctuation"],
+      languages: ["markup"],
+      style: {
+        color: "#808080"
+      }
+    },
+    {
+      types: ["function"],
+      style: {
+        color: "rgb(220, 220, 170)"
+      }
+    },
+    {
+      types: ["class-name"],
+      style: {
+        color: "rgb(78, 201, 176)"
+      }
+    },
+    {
+      types: ["char"],
+      style: {
+        color: "rgb(209, 105, 105)"
+      }
+    }
+  ]
+}, tt = Yr, Gr = {
+  plain: {
+    color: "#000000",
+    backgroundColor: "#ffffff"
+  },
+  styles: [
+    {
+      types: ["comment"],
+      style: {
+        color: "rgb(0, 128, 0)"
+      }
+    },
+    {
+      types: ["builtin"],
+      style: {
+        color: "rgb(0, 112, 193)"
+      }
+    },
+    {
+      types: ["number", "variable", "inserted"],
+      style: {
+        color: "rgb(9, 134, 88)"
+      }
+    },
+    {
+      types: ["operator"],
+      style: {
+        color: "rgb(0, 0, 0)"
+      }
+    },
+    {
+      types: ["constant", "char"],
+      style: {
+        color: "rgb(129, 31, 63)"
+      }
+    },
+    {
+      types: ["tag"],
+      style: {
+        color: "rgb(128, 0, 0)"
+      }
+    },
+    {
+      types: ["attr-name"],
+      style: {
+        color: "rgb(255, 0, 0)"
+      }
+    },
+    {
+      types: ["deleted", "string"],
+      style: {
+        color: "rgb(163, 21, 21)"
+      }
+    },
+    {
+      types: ["changed", "punctuation"],
+      style: {
+        color: "rgb(4, 81, 165)"
+      }
+    },
+    {
+      types: ["function", "keyword"],
+      style: {
+        color: "rgb(0, 0, 255)"
+      }
+    },
+    {
+      types: ["class-name"],
+      style: {
+        color: "rgb(38, 127, 153)"
+      }
+    }
+  ]
+}, Hr = Gr, Kr = {
+  plain: {
+    color: "#f8fafc",
+    backgroundColor: "#011627"
+  },
+  styles: [
+    {
+      types: ["prolog"],
+      style: {
+        color: "#000080"
+      }
+    },
+    {
+      types: ["comment"],
+      style: {
+        color: "#6A9955"
+      }
+    },
+    {
+      types: ["builtin", "changed", "keyword", "interpolation-punctuation"],
+      style: {
+        color: "#569CD6"
+      }
+    },
+    {
+      types: ["number", "inserted"],
+      style: {
+        color: "#B5CEA8"
+      }
+    },
+    {
+      types: ["constant"],
+      style: {
+        color: "#f8fafc"
+      }
+    },
+    {
+      types: ["attr-name", "variable"],
+      style: {
+        color: "#9CDCFE"
+      }
+    },
+    {
+      types: ["deleted", "string", "attr-value", "template-punctuation"],
+      style: {
+        color: "#cbd5e1"
+      }
+    },
+    {
+      types: ["selector"],
+      style: {
+        color: "#D7BA7D"
+      }
+    },
+    {
+      types: ["tag"],
+      style: {
+        color: "#0ea5e9"
+      }
+    },
+    {
+      types: ["tag"],
+      languages: ["markup"],
+      style: {
+        color: "#0ea5e9"
+      }
+    },
+    {
+      types: ["punctuation", "operator"],
+      style: {
+        color: "#D4D4D4"
+      }
+    },
+    {
+      types: ["punctuation"],
+      languages: ["markup"],
+      style: {
+        color: "#808080"
+      }
+    },
+    {
+      types: ["function"],
+      style: {
+        color: "#7dd3fc"
+      }
+    },
+    {
+      types: ["class-name"],
+      style: {
+        color: "#0ea5e9"
+      }
+    },
+    {
+      types: ["char"],
+      style: {
+        color: "#D16969"
+      }
+    }
+  ]
+}, Wr = Kr, qr = {
+  plain: {
+    color: "#0f172a",
+    backgroundColor: "#f1f5f9"
+  },
+  styles: [
+    {
+      types: ["prolog"],
+      style: {
+        color: "#000080"
+      }
+    },
+    {
+      types: ["comment"],
+      style: {
+        color: "#6A9955"
+      }
+    },
+    {
+      types: ["builtin", "changed", "keyword", "interpolation-punctuation"],
+      style: {
+        color: "#0c4a6e"
+      }
+    },
+    {
+      types: ["number", "inserted"],
+      style: {
+        color: "#B5CEA8"
+      }
+    },
+    {
+      types: ["constant"],
+      style: {
+        color: "#0f172a"
+      }
+    },
+    {
+      types: ["attr-name", "variable"],
+      style: {
+        color: "#0c4a6e"
+      }
+    },
+    {
+      types: ["deleted", "string", "attr-value", "template-punctuation"],
+      style: {
+        color: "#64748b"
+      }
+    },
+    {
+      types: ["selector"],
+      style: {
+        color: "#D7BA7D"
+      }
+    },
+    {
+      types: ["tag"],
+      style: {
+        color: "#0ea5e9"
+      }
+    },
+    {
+      types: ["tag"],
+      languages: ["markup"],
+      style: {
+        color: "#0ea5e9"
+      }
+    },
+    {
+      types: ["punctuation", "operator"],
+      style: {
+        color: "#475569"
+      }
+    },
+    {
+      types: ["punctuation"],
+      languages: ["markup"],
+      style: {
+        color: "#808080"
+      }
+    },
+    {
+      types: ["function"],
+      style: {
+        color: "#0e7490"
+      }
+    },
+    {
+      types: ["class-name"],
+      style: {
+        color: "#0ea5e9"
+      }
+    },
+    {
+      types: ["char"],
+      style: {
+        color: "#D16969"
+      }
+    }
+  ]
+}, Zr = qr, Vr = {
+  plain: {
+    backgroundColor: "hsl(220, 13%, 18%)",
+    color: "hsl(220, 14%, 71%)",
+    textShadow: "0 1px rgba(0, 0, 0, 0.3)"
+  },
+  styles: [
+    {
+      types: ["comment", "prolog", "cdata"],
+      style: {
+        color: "hsl(220, 10%, 40%)"
+      }
+    },
+    {
+      types: ["doctype", "punctuation", "entity"],
+      style: {
+        color: "hsl(220, 14%, 71%)"
+      }
+    },
+    {
+      types: [
+        "attr-name",
+        "class-name",
+        "maybe-class-name",
+        "boolean",
+        "constant",
+        "number",
+        "atrule"
+      ],
+      style: { color: "hsl(29, 54%, 61%)" }
+    },
+    {
+      types: ["keyword"],
+      style: { color: "hsl(286, 60%, 67%)" }
+    },
+    {
+      types: ["property", "tag", "symbol", "deleted", "important"],
+      style: {
+        color: "hsl(355, 65%, 65%)"
+      }
+    },
+    {
+      types: [
+        "selector",
+        "string",
+        "char",
+        "builtin",
+        "inserted",
+        "regex",
+        "attr-value"
+      ],
+      style: {
+        color: "hsl(95, 38%, 62%)"
+      }
+    },
+    {
+      types: ["variable", "operator", "function"],
+      style: {
+        color: "hsl(207, 82%, 66%)"
+      }
+    },
+    {
+      types: ["url"],
+      style: {
+        color: "hsl(187, 47%, 55%)"
+      }
+    },
+    {
+      types: ["deleted"],
+      style: {
+        textDecorationLine: "line-through"
+      }
+    },
+    {
+      types: ["inserted"],
+      style: {
+        textDecorationLine: "underline"
+      }
+    },
+    {
+      types: ["italic"],
+      style: {
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["important", "bold"],
+      style: {
+        fontWeight: "bold"
+      }
+    },
+    {
+      types: ["important"],
+      style: {
+        color: "hsl(220, 14%, 71%)"
+      }
+    }
+  ]
+}, Xr = Vr, Qr = {
+  plain: {
+    backgroundColor: "hsl(230, 1%, 98%)",
+    color: "hsl(230, 8%, 24%)"
+  },
+  styles: [
+    {
+      types: ["comment", "prolog", "cdata"],
+      style: {
+        color: "hsl(230, 4%, 64%)"
+      }
+    },
+    {
+      types: ["doctype", "punctuation", "entity"],
+      style: {
+        color: "hsl(230, 8%, 24%)"
+      }
+    },
+    {
+      types: [
+        "attr-name",
+        "class-name",
+        "boolean",
+        "constant",
+        "number",
+        "atrule"
+      ],
+      style: {
+        color: "hsl(35, 99%, 36%)"
+      }
+    },
+    {
+      types: ["keyword"],
+      style: {
+        color: "hsl(301, 63%, 40%)"
+      }
+    },
+    {
+      types: ["property", "tag", "symbol", "deleted", "important"],
+      style: {
+        color: "hsl(5, 74%, 59%)"
+      }
+    },
+    {
+      types: [
+        "selector",
+        "string",
+        "char",
+        "builtin",
+        "inserted",
+        "regex",
+        "attr-value",
+        "punctuation"
+      ],
+      style: {
+        color: "hsl(119, 34%, 47%)"
+      }
+    },
+    {
+      types: ["variable", "operator", "function"],
+      style: {
+        color: "hsl(221, 87%, 60%)"
+      }
+    },
+    {
+      types: ["url"],
+      style: {
+        color: "hsl(198, 99%, 37%)"
+      }
+    },
+    {
+      types: ["deleted"],
+      style: {
+        textDecorationLine: "line-through"
+      }
+    },
+    {
+      types: ["inserted"],
+      style: {
+        textDecorationLine: "underline"
+      }
+    },
+    {
+      types: ["italic"],
+      style: {
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["important", "bold"],
+      style: {
+        fontWeight: "bold"
+      }
+    },
+    {
+      types: ["important"],
+      style: {
+        color: "hsl(230, 8%, 24%)"
+      }
+    }
+  ]
+}, Jr = Qr, ea = {
+  plain: {
+    color: "#ebdbb2",
+    backgroundColor: "#292828"
+  },
+  styles: [
+    {
+      types: [
+        "imports",
+        "class-name",
+        "maybe-class-name",
+        "constant",
+        "doctype",
+        "builtin",
+        "function"
+      ],
+      style: {
+        color: "#d8a657"
+      }
+    },
+    {
+      types: ["property-access"],
+      style: {
+        color: "#7daea3"
+      }
+    },
+    {
+      types: ["tag"],
+      style: {
+        color: "#e78a4e"
+      }
+    },
+    {
+      types: ["attr-name", "char", "url", "regex"],
+      style: {
+        color: "#a9b665"
+      }
+    },
+    {
+      types: ["attr-value", "string"],
+      style: {
+        color: "#89b482"
+      }
+    },
+    {
+      types: ["comment", "prolog", "cdata", "operator", "inserted"],
+      style: {
+        color: "#a89984"
+      }
+    },
+    {
+      types: [
+        "delimiter",
+        "boolean",
+        "keyword",
+        "selector",
+        "important",
+        "atrule",
+        "property",
+        "variable",
+        "deleted"
+      ],
+      style: {
+        color: "#ea6962"
+      }
+    },
+    {
+      types: ["entity", "number", "symbol"],
+      style: {
+        color: "#d3869b"
+      }
+    }
+  ]
+}, na = ea, ta = {
+  plain: {
+    color: "#654735",
+    backgroundColor: "#f9f5d7"
+  },
+  styles: [
+    {
+      types: [
+        "delimiter",
+        "boolean",
+        "keyword",
+        "selector",
+        "important",
+        "atrule",
+        "property",
+        "variable",
+        "deleted"
+      ],
+      style: {
+        color: "#af2528"
+      }
+    },
+    {
+      types: [
+        "imports",
+        "class-name",
+        "maybe-class-name",
+        "constant",
+        "doctype",
+        "builtin"
+      ],
+      style: {
+        color: "#b4730e"
+      }
+    },
+    {
+      types: ["string", "attr-value"],
+      style: {
+        color: "#477a5b"
+      }
+    },
+    {
+      types: ["property-access"],
+      style: {
+        color: "#266b79"
+      }
+    },
+    {
+      types: ["function", "attr-name", "char", "url"],
+      style: {
+        color: "#72761e"
+      }
+    },
+    {
+      types: ["tag"],
+      style: {
+        color: "#b94c07"
+      }
+    },
+    {
+      types: ["comment", "prolog", "cdata", "operator", "inserted"],
+      style: {
+        color: "#a89984"
+      }
+    },
+    {
+      types: ["entity", "number", "symbol"],
+      style: {
+        color: "#924f79"
+      }
+    }
+  ]
+}, ra = ta, aa = (e) => ye(
+  (n) => {
+    var t = n, { className: r, style: a, line: o } = t, i = nt(t, ["className", "style", "line"]);
+    const l = Xe(ae({}, i), {
+      className: Qn("token-line", r)
+    });
+    return typeof e == "object" && "plain" in e && (l.style = e.plain), typeof a == "object" && (l.style = ae(ae({}, l.style || {}), a)), l;
+  },
+  [e]
+), ia = (e) => {
+  const n = ye(
+    ({ types: t, empty: r }) => {
+      if (e != null) {
+        {
+          if (t.length === 1 && t[0] === "plain")
+            return r != null ? { display: "inline-block" } : void 0;
+          if (t.length === 1 && r != null)
+            return e[t[0]];
+        }
+        return Object.assign(
+          r != null ? { display: "inline-block" } : {},
+          ...t.map((a) => e[a])
+        );
+      }
+    },
+    [e]
+  );
+  return ye(
+    (t) => {
+      var r = t, { token: a, className: o, style: i } = r, l = nt(r, ["token", "className", "style"]);
+      const s = Xe(ae({}, l), {
+        className: Qn("token", ...a.types, o),
+        children: a.content,
+        style: n(a)
+      });
+      return i != null && (s.style = ae(ae({}, s.style || {}), i)), s;
+    },
+    [n]
+  );
+}, oa = /\r\n|\r|\n/, Ln = (e) => {
+  e.length === 0 ? e.push({
+    types: ["plain"],
+    content: `
+`,
+    empty: !0
+  }) : e.length === 1 && e[0].content === "" && (e[0].content = `
+`, e[0].empty = !0);
+}, Rn = (e, n) => {
+  const t = e.length;
+  return t > 0 && e[t - 1] === n ? e : e.concat(n);
+}, la = (e) => {
+  const n = [[]], t = [e], r = [0], a = [e.length];
+  let o = 0, i = 0, l = [];
+  const s = [l];
+  for (; i > -1; ) {
+    for (; (o = r[i]++) < a[i]; ) {
+      let u, g = n[i];
+      const m = t[i][o];
+      if (typeof m == "string" ? (g = i > 0 ? g : ["plain"], u = m) : (g = Rn(g, m.type), m.alias && (g = Rn(g, m.alias)), u = m.content), typeof u != "string") {
+        i++, n.push(g), t.push(u), r.push(0), a.push(u.length);
+        continue;
+      }
+      const v = u.split(oa), c = v.length;
+      l.push({
+        types: g,
+        content: v[0]
+      });
+      for (let p = 1; p < c; p++)
+        Ln(l), s.push(l = []), l.push({
+          types: g,
+          content: v[p]
+        });
+    }
+    i--, n.pop(), t.pop(), r.pop(), a.pop();
+  }
+  return Ln(l), s;
+}, Nn = la, sa = ({ prism: e, code: n, grammar: t, language: r }) => ln(() => {
+  if (t == null)
+    return Nn([n]);
+  const a = {
+    code: n,
+    grammar: t,
+    language: r,
+    tokens: []
+  };
+  return e.hooks.run("before-tokenize", a), a.tokens = e.tokenize(n, t), e.hooks.run("after-tokenize", a), Nn(a.tokens);
+}, [
+  n,
+  t,
+  r,
+  // prism is a stable import
+  e
+]), ua = (e, n) => {
+  const { plain: t } = e, r = e.styles.reduce((a, o) => {
+    const { languages: i, style: l } = o;
+    return i && !i.includes(n) || o.types.forEach((s) => {
+      const u = ae(ae({}, a[s]), l);
+      a[s] = u;
+    }), a;
+  }, {});
+  return r.root = t, r.plain = Xe(ae({}, t), { backgroundColor: void 0 }), r;
+}, ca = ua, pa = ({
+  children: e,
+  language: n,
+  code: t,
+  theme: r,
+  prism: a
+}) => {
+  const o = n.toLowerCase(), i = ca(r, o), l = aa(i), s = ia(i), u = a.languages[o], g = sa({ prism: a, language: o, code: t, grammar: u });
+  return e({
+    tokens: g,
+    className: `prism-code language-${o}`,
+    style: i != null ? i.root : {},
+    getLineProps: l,
+    getTokenProps: s
+  });
+}, fa = (e) => Xt(pa, Xe(ae({}, e), {
+  prism: e.prism || h,
+  theme: e.theme || tt,
+  code: e.code,
+  language: e.language
+}));
+/*! Bundled license information:
+
+prismjs/prism.js:
+  (**
+   * Prism: Lightweight, robust, elegant syntax highlighting
+   *
+   * @license MIT <https://opensource.org/licenses/MIT>
+   * @author Lea Verou <https://lea.verou.me>
+   * @namespace
+   * @public
+   *)
+*/
+/*! js-yaml 4.1.1 https://github.com/nodeca/js-yaml @license MIT */
+function rt(e) {
+  return typeof e > "u" || e === null;
+}
+function da(e) {
+  return typeof e == "object" && e !== null;
+}
+function ga(e) {
+  return Array.isArray(e) ? e : rt(e) ? [] : [e];
+}
+function ya(e, n) {
+  var t, r, a, o;
+  if (n)
+    for (o = Object.keys(n), t = 0, r = o.length; t < r; t += 1)
+      a = o[t], e[a] = n[a];
+  return e;
+}
+function ha(e, n) {
+  var t = "", r;
+  for (r = 0; r < n; r += 1)
+    t += e;
+  return t;
+}
+function ma(e) {
+  return e === 0 && Number.NEGATIVE_INFINITY === 1 / e;
+}
+var ba = rt, va = da, xa = ga, wa = ha, Aa = ma, ka = ya, j = {
+  isNothing: ba,
+  isObject: va,
+  toArray: xa,
+  repeat: wa,
+  isNegativeZero: Aa,
+  extend: ka
+};
+function at(e, n) {
+  var t = "", r = e.reason || "(unknown reason)";
+  return e.mark ? (e.mark.name && (t += 'in "' + e.mark.name + '" '), t += "(" + (e.mark.line + 1) + ":" + (e.mark.column + 1) + ")", !n && e.mark.snippet && (t += `
+
+` + e.mark.snippet), r + " " + t) : r;
+}
+function Pe(e, n) {
+  Error.call(this), this.name = "YAMLException", this.reason = e, this.mark = n, this.message = at(this, !1), Error.captureStackTrace ? Error.captureStackTrace(this, this.constructor) : this.stack = new Error().stack || "";
+}
+Pe.prototype = Object.create(Error.prototype);
+Pe.prototype.constructor = Pe;
+Pe.prototype.toString = function(n) {
+  return this.name + ": " + at(this, n);
+};
+var K = Pe;
+function rn(e, n, t, r, a) {
+  var o = "", i = "", l = Math.floor(a / 2) - 1;
+  return r - n > l && (o = " ... ", n = r - l + o.length), t - r > l && (i = " ...", t = r + l - i.length), {
+    str: o + e.slice(n, t).replace(/\t/g, "→") + i,
+    pos: r - n + o.length
+    // relative position
+  };
+}
+function an(e, n) {
+  return j.repeat(" ", n - e.length) + e;
+}
+function Ea(e, n) {
+  if (n = Object.create(n || null), !e.buffer) return null;
+  n.maxLength || (n.maxLength = 79), typeof n.indent != "number" && (n.indent = 1), typeof n.linesBefore != "number" && (n.linesBefore = 3), typeof n.linesAfter != "number" && (n.linesAfter = 2);
+  for (var t = /\r?\n|\r|\0/g, r = [0], a = [], o, i = -1; o = t.exec(e.buffer); )
+    a.push(o.index), r.push(o.index + o[0].length), e.position <= o.index && i < 0 && (i = r.length - 2);
+  i < 0 && (i = r.length - 1);
+  var l = "", s, u, g = Math.min(e.line + n.linesAfter, a.length).toString().length, f = n.maxLength - (n.indent + g + 3);
+  for (s = 1; s <= n.linesBefore && !(i - s < 0); s++)
+    u = rn(
+      e.buffer,
+      r[i - s],
+      a[i - s],
+      e.position - (r[i] - r[i - s]),
+      f
+    ), l = j.repeat(" ", n.indent) + an((e.line - s + 1).toString(), g) + " | " + u.str + `
+` + l;
+  for (u = rn(e.buffer, r[i], a[i], e.position, f), l += j.repeat(" ", n.indent) + an((e.line + 1).toString(), g) + " | " + u.str + `
+`, l += j.repeat("-", n.indent + g + 3 + u.pos) + `^
+`, s = 1; s <= n.linesAfter && !(i + s >= a.length); s++)
+    u = rn(
+      e.buffer,
+      r[i + s],
+      a[i + s],
+      e.position - (r[i] - r[i + s]),
+      f
+    ), l += j.repeat(" ", n.indent) + an((e.line + s + 1).toString(), g) + " | " + u.str + `
+`;
+  return l.replace(/\n$/, "");
+}
+var Sa = Ea, _a = [
+  "kind",
+  "multi",
+  "resolve",
+  "construct",
+  "instanceOf",
+  "predicate",
+  "represent",
+  "representName",
+  "defaultStyle",
+  "styleAliases"
+], Fa = [
+  "scalar",
+  "sequence",
+  "mapping"
+];
+function Ca(e) {
+  var n = {};
+  return e !== null && Object.keys(e).forEach(function(t) {
+    e[t].forEach(function(r) {
+      n[String(r)] = t;
+    });
+  }), n;
+}
+function Ta(e, n) {
+  if (n = n || {}, Object.keys(n).forEach(function(t) {
+    if (_a.indexOf(t) === -1)
+      throw new K('Unknown option "' + t + '" is met in definition of "' + e + '" YAML type.');
+  }), this.options = n, this.tag = e, this.kind = n.kind || null, this.resolve = n.resolve || function() {
+    return !0;
+  }, this.construct = n.construct || function(t) {
+    return t;
+  }, this.instanceOf = n.instanceOf || null, this.predicate = n.predicate || null, this.represent = n.represent || null, this.representName = n.representName || null, this.defaultStyle = n.defaultStyle || null, this.multi = n.multi || !1, this.styleAliases = Ca(n.styleAliases || null), Fa.indexOf(this.kind) === -1)
+    throw new K('Unknown kind "' + this.kind + '" is specified for "' + e + '" YAML type.');
+}
+var z = Ta;
+function Dn(e, n) {
+  var t = [];
+  return e[n].forEach(function(r) {
+    var a = t.length;
+    t.forEach(function(o, i) {
+      o.tag === r.tag && o.kind === r.kind && o.multi === r.multi && (a = i);
+    }), t[a] = r;
+  }), t;
+}
+function Ia() {
+  var e = {
+    scalar: {},
+    sequence: {},
+    mapping: {},
+    fallback: {},
+    multi: {
+      scalar: [],
+      sequence: [],
+      mapping: [],
+      fallback: []
+    }
+  }, n, t;
+  function r(a) {
+    a.multi ? (e.multi[a.kind].push(a), e.multi.fallback.push(a)) : e[a.kind][a.tag] = e.fallback[a.tag] = a;
+  }
+  for (n = 0, t = arguments.length; n < t; n += 1)
+    arguments[n].forEach(r);
+  return e;
+}
+function un(e) {
+  return this.extend(e);
+}
+un.prototype.extend = function(n) {
+  var t = [], r = [];
+  if (n instanceof z)
+    r.push(n);
+  else if (Array.isArray(n))
+    r = r.concat(n);
+  else if (n && (Array.isArray(n.implicit) || Array.isArray(n.explicit)))
+    n.implicit && (t = t.concat(n.implicit)), n.explicit && (r = r.concat(n.explicit));
+  else
+    throw new K("Schema.extend argument should be a Type, [ Type ], or a schema definition ({ implicit: [...], explicit: [...] })");
+  t.forEach(function(o) {
+    if (!(o instanceof z))
+      throw new K("Specified list of YAML types (or a single Type object) contains a non-Type object.");
+    if (o.loadKind && o.loadKind !== "scalar")
+      throw new K("There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.");
+    if (o.multi)
+      throw new K("There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit.");
+  }), r.forEach(function(o) {
+    if (!(o instanceof z))
+      throw new K("Specified list of YAML types (or a single Type object) contains a non-Type object.");
+  });
+  var a = Object.create(un.prototype);
+  return a.implicit = (this.implicit || []).concat(t), a.explicit = (this.explicit || []).concat(r), a.compiledImplicit = Dn(a, "implicit"), a.compiledExplicit = Dn(a, "explicit"), a.compiledTypeMap = Ia(a.compiledImplicit, a.compiledExplicit), a;
+};
+var it = un, ot = new z("tag:yaml.org,2002:str", {
+  kind: "scalar",
+  construct: function(e) {
+    return e !== null ? e : "";
+  }
+}), lt = new z("tag:yaml.org,2002:seq", {
+  kind: "sequence",
+  construct: function(e) {
+    return e !== null ? e : [];
+  }
+}), st = new z("tag:yaml.org,2002:map", {
+  kind: "mapping",
+  construct: function(e) {
+    return e !== null ? e : {};
+  }
+}), ut = new it({
+  explicit: [
+    ot,
+    lt,
+    st
+  ]
+});
+function Oa(e) {
+  if (e === null) return !0;
+  var n = e.length;
+  return n === 1 && e === "~" || n === 4 && (e === "null" || e === "Null" || e === "NULL");
+}
+function La() {
+  return null;
+}
+function Ra(e) {
+  return e === null;
+}
+var ct = new z("tag:yaml.org,2002:null", {
+  kind: "scalar",
+  resolve: Oa,
+  construct: La,
+  predicate: Ra,
+  represent: {
+    canonical: function() {
+      return "~";
+    },
+    lowercase: function() {
+      return "null";
+    },
+    uppercase: function() {
+      return "NULL";
+    },
+    camelcase: function() {
+      return "Null";
+    },
+    empty: function() {
+      return "";
+    }
+  },
+  defaultStyle: "lowercase"
+});
+function Na(e) {
+  if (e === null) return !1;
+  var n = e.length;
+  return n === 4 && (e === "true" || e === "True" || e === "TRUE") || n === 5 && (e === "false" || e === "False" || e === "FALSE");
+}
+function Da(e) {
+  return e === "true" || e === "True" || e === "TRUE";
+}
+function Ba(e) {
+  return Object.prototype.toString.call(e) === "[object Boolean]";
+}
+var pt = new z("tag:yaml.org,2002:bool", {
+  kind: "scalar",
+  resolve: Na,
+  construct: Da,
+  predicate: Ba,
+  represent: {
+    lowercase: function(e) {
+      return e ? "true" : "false";
+    },
+    uppercase: function(e) {
+      return e ? "TRUE" : "FALSE";
+    },
+    camelcase: function(e) {
+      return e ? "True" : "False";
+    }
+  },
+  defaultStyle: "lowercase"
+});
+function Pa(e) {
+  return 48 <= e && e <= 57 || 65 <= e && e <= 70 || 97 <= e && e <= 102;
+}
+function Ma(e) {
+  return 48 <= e && e <= 55;
+}
+function ja(e) {
+  return 48 <= e && e <= 57;
+}
+function $a(e) {
+  if (e === null) return !1;
+  var n = e.length, t = 0, r = !1, a;
+  if (!n) return !1;
+  if (a = e[t], (a === "-" || a === "+") && (a = e[++t]), a === "0") {
+    if (t + 1 === n) return !0;
+    if (a = e[++t], a === "b") {
+      for (t++; t < n; t++)
+        if (a = e[t], a !== "_") {
+          if (a !== "0" && a !== "1") return !1;
+          r = !0;
+        }
+      return r && a !== "_";
+    }
+    if (a === "x") {
+      for (t++; t < n; t++)
+        if (a = e[t], a !== "_") {
+          if (!Pa(e.charCodeAt(t))) return !1;
+          r = !0;
+        }
+      return r && a !== "_";
+    }
+    if (a === "o") {
+      for (t++; t < n; t++)
+        if (a = e[t], a !== "_") {
+          if (!Ma(e.charCodeAt(t))) return !1;
+          r = !0;
+        }
+      return r && a !== "_";
+    }
+  }
+  if (a === "_") return !1;
+  for (; t < n; t++)
+    if (a = e[t], a !== "_") {
+      if (!ja(e.charCodeAt(t)))
+        return !1;
+      r = !0;
+    }
+  return !(!r || a === "_");
+}
+function Ua(e) {
+  var n = e, t = 1, r;
+  if (n.indexOf("_") !== -1 && (n = n.replace(/_/g, "")), r = n[0], (r === "-" || r === "+") && (r === "-" && (t = -1), n = n.slice(1), r = n[0]), n === "0") return 0;
+  if (r === "0") {
+    if (n[1] === "b") return t * parseInt(n.slice(2), 2);
+    if (n[1] === "x") return t * parseInt(n.slice(2), 16);
+    if (n[1] === "o") return t * parseInt(n.slice(2), 8);
+  }
+  return t * parseInt(n, 10);
+}
+function za(e) {
+  return Object.prototype.toString.call(e) === "[object Number]" && e % 1 === 0 && !j.isNegativeZero(e);
+}
+var ft = new z("tag:yaml.org,2002:int", {
+  kind: "scalar",
+  resolve: $a,
+  construct: Ua,
+  predicate: za,
+  represent: {
+    binary: function(e) {
+      return e >= 0 ? "0b" + e.toString(2) : "-0b" + e.toString(2).slice(1);
+    },
+    octal: function(e) {
+      return e >= 0 ? "0o" + e.toString(8) : "-0o" + e.toString(8).slice(1);
+    },
+    decimal: function(e) {
+      return e.toString(10);
+    },
+    /* eslint-disable max-len */
+    hexadecimal: function(e) {
+      return e >= 0 ? "0x" + e.toString(16).toUpperCase() : "-0x" + e.toString(16).toUpperCase().slice(1);
+    }
+  },
+  defaultStyle: "decimal",
+  styleAliases: {
+    binary: [2, "bin"],
+    octal: [8, "oct"],
+    decimal: [10, "dec"],
+    hexadecimal: [16, "hex"]
+  }
+}), Ya = new RegExp(
+  // 2.5e4, 2.5 and integers
+  "^(?:[-+]?(?:[0-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$"
+);
+function Ga(e) {
+  return !(e === null || !Ya.test(e) || // Quick hack to not allow integers end with `_`
+  // Probably should update regexp & check speed
+  e[e.length - 1] === "_");
+}
+function Ha(e) {
+  var n, t;
+  return n = e.replace(/_/g, "").toLowerCase(), t = n[0] === "-" ? -1 : 1, "+-".indexOf(n[0]) >= 0 && (n = n.slice(1)), n === ".inf" ? t === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY : n === ".nan" ? NaN : t * parseFloat(n, 10);
+}
+var Ka = /^[-+]?[0-9]+e/;
+function Wa(e, n) {
+  var t;
+  if (isNaN(e))
+    switch (n) {
+      case "lowercase":
+        return ".nan";
+      case "uppercase":
+        return ".NAN";
+      case "camelcase":
+        return ".NaN";
+    }
+  else if (Number.POSITIVE_INFINITY === e)
+    switch (n) {
+      case "lowercase":
+        return ".inf";
+      case "uppercase":
+        return ".INF";
+      case "camelcase":
+        return ".Inf";
+    }
+  else if (Number.NEGATIVE_INFINITY === e)
+    switch (n) {
+      case "lowercase":
+        return "-.inf";
+      case "uppercase":
+        return "-.INF";
+      case "camelcase":
+        return "-.Inf";
+    }
+  else if (j.isNegativeZero(e))
+    return "-0.0";
+  return t = e.toString(10), Ka.test(t) ? t.replace("e", ".e") : t;
+}
+function qa(e) {
+  return Object.prototype.toString.call(e) === "[object Number]" && (e % 1 !== 0 || j.isNegativeZero(e));
+}
+var dt = new z("tag:yaml.org,2002:float", {
+  kind: "scalar",
+  resolve: Ga,
+  construct: Ha,
+  predicate: qa,
+  represent: Wa,
+  defaultStyle: "lowercase"
+}), gt = ut.extend({
+  implicit: [
+    ct,
+    pt,
+    ft,
+    dt
+  ]
+}), yt = gt, ht = new RegExp(
+  "^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$"
+), mt = new RegExp(
+  "^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$"
+);
+function Za(e) {
+  return e === null ? !1 : ht.exec(e) !== null || mt.exec(e) !== null;
+}
+function Va(e) {
+  var n, t, r, a, o, i, l, s = 0, u = null, g, f, m;
+  if (n = ht.exec(e), n === null && (n = mt.exec(e)), n === null) throw new Error("Date resolve error");
+  if (t = +n[1], r = +n[2] - 1, a = +n[3], !n[4])
+    return new Date(Date.UTC(t, r, a));
+  if (o = +n[4], i = +n[5], l = +n[6], n[7]) {
+    for (s = n[7].slice(0, 3); s.length < 3; )
+      s += "0";
+    s = +s;
+  }
+  return n[9] && (g = +n[10], f = +(n[11] || 0), u = (g * 60 + f) * 6e4, n[9] === "-" && (u = -u)), m = new Date(Date.UTC(t, r, a, o, i, l, s)), u && m.setTime(m.getTime() - u), m;
+}
+function Xa(e) {
+  return e.toISOString();
+}
+var bt = new z("tag:yaml.org,2002:timestamp", {
+  kind: "scalar",
+  resolve: Za,
+  construct: Va,
+  instanceOf: Date,
+  represent: Xa
+});
+function Qa(e) {
+  return e === "<<" || e === null;
+}
+var vt = new z("tag:yaml.org,2002:merge", {
+  kind: "scalar",
+  resolve: Qa
+}), yn = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=
+\r`;
+function Ja(e) {
+  if (e === null) return !1;
+  var n, t, r = 0, a = e.length, o = yn;
+  for (t = 0; t < a; t++)
+    if (n = o.indexOf(e.charAt(t)), !(n > 64)) {
+      if (n < 0) return !1;
+      r += 6;
+    }
+  return r % 8 === 0;
+}
+function ei(e) {
+  var n, t, r = e.replace(/[\r\n=]/g, ""), a = r.length, o = yn, i = 0, l = [];
+  for (n = 0; n < a; n++)
+    n % 4 === 0 && n && (l.push(i >> 16 & 255), l.push(i >> 8 & 255), l.push(i & 255)), i = i << 6 | o.indexOf(r.charAt(n));
+  return t = a % 4 * 6, t === 0 ? (l.push(i >> 16 & 255), l.push(i >> 8 & 255), l.push(i & 255)) : t === 18 ? (l.push(i >> 10 & 255), l.push(i >> 2 & 255)) : t === 12 && l.push(i >> 4 & 255), new Uint8Array(l);
+}
+function ni(e) {
+  var n = "", t = 0, r, a, o = e.length, i = yn;
+  for (r = 0; r < o; r++)
+    r % 3 === 0 && r && (n += i[t >> 18 & 63], n += i[t >> 12 & 63], n += i[t >> 6 & 63], n += i[t & 63]), t = (t << 8) + e[r];
+  return a = o % 3, a === 0 ? (n += i[t >> 18 & 63], n += i[t >> 12 & 63], n += i[t >> 6 & 63], n += i[t & 63]) : a === 2 ? (n += i[t >> 10 & 63], n += i[t >> 4 & 63], n += i[t << 2 & 63], n += i[64]) : a === 1 && (n += i[t >> 2 & 63], n += i[t << 4 & 63], n += i[64], n += i[64]), n;
+}
+function ti(e) {
+  return Object.prototype.toString.call(e) === "[object Uint8Array]";
+}
+var xt = new z("tag:yaml.org,2002:binary", {
+  kind: "scalar",
+  resolve: Ja,
+  construct: ei,
+  predicate: ti,
+  represent: ni
+}), ri = Object.prototype.hasOwnProperty, ai = Object.prototype.toString;
+function ii(e) {
+  if (e === null) return !0;
+  var n = [], t, r, a, o, i, l = e;
+  for (t = 0, r = l.length; t < r; t += 1) {
+    if (a = l[t], i = !1, ai.call(a) !== "[object Object]") return !1;
+    for (o in a)
+      if (ri.call(a, o))
+        if (!i) i = !0;
+        else return !1;
+    if (!i) return !1;
+    if (n.indexOf(o) === -1) n.push(o);
+    else return !1;
+  }
+  return !0;
+}
+function oi(e) {
+  return e !== null ? e : [];
+}
+var wt = new z("tag:yaml.org,2002:omap", {
+  kind: "sequence",
+  resolve: ii,
+  construct: oi
+}), li = Object.prototype.toString;
+function si(e) {
+  if (e === null) return !0;
+  var n, t, r, a, o, i = e;
+  for (o = new Array(i.length), n = 0, t = i.length; n < t; n += 1) {
+    if (r = i[n], li.call(r) !== "[object Object]" || (a = Object.keys(r), a.length !== 1)) return !1;
+    o[n] = [a[0], r[a[0]]];
+  }
+  return !0;
+}
+function ui(e) {
+  if (e === null) return [];
+  var n, t, r, a, o, i = e;
+  for (o = new Array(i.length), n = 0, t = i.length; n < t; n += 1)
+    r = i[n], a = Object.keys(r), o[n] = [a[0], r[a[0]]];
+  return o;
+}
+var At = new z("tag:yaml.org,2002:pairs", {
+  kind: "sequence",
+  resolve: si,
+  construct: ui
+}), ci = Object.prototype.hasOwnProperty;
+function pi(e) {
+  if (e === null) return !0;
+  var n, t = e;
+  for (n in t)
+    if (ci.call(t, n) && t[n] !== null)
+      return !1;
+  return !0;
+}
+function fi(e) {
+  return e !== null ? e : {};
+}
+var kt = new z("tag:yaml.org,2002:set", {
+  kind: "mapping",
+  resolve: pi,
+  construct: fi
+}), hn = yt.extend({
+  implicit: [
+    bt,
+    vt
+  ],
+  explicit: [
+    xt,
+    wt,
+    At,
+    kt
+  ]
+}), me = Object.prototype.hasOwnProperty, He = 1, Et = 2, St = 3, Ke = 4, on = 1, di = 2, Bn = 3, gi = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/, yi = /[\x85\u2028\u2029]/, hi = /[,\[\]\{\}]/, _t = /^(?:!|!!|![a-z\-]+!)$/i, Ft = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;
+function Pn(e) {
+  return Object.prototype.toString.call(e);
+}
+function ie(e) {
+  return e === 10 || e === 13;
+}
+function xe(e) {
+  return e === 9 || e === 32;
+}
+function Z(e) {
+  return e === 9 || e === 32 || e === 10 || e === 13;
+}
+function Se(e) {
+  return e === 44 || e === 91 || e === 93 || e === 123 || e === 125;
+}
+function mi(e) {
+  var n;
+  return 48 <= e && e <= 57 ? e - 48 : (n = e | 32, 97 <= n && n <= 102 ? n - 97 + 10 : -1);
+}
+function bi(e) {
+  return e === 120 ? 2 : e === 117 ? 4 : e === 85 ? 8 : 0;
+}
+function vi(e) {
+  return 48 <= e && e <= 57 ? e - 48 : -1;
+}
+function Mn(e) {
+  return e === 48 ? "\0" : e === 97 ? "\x07" : e === 98 ? "\b" : e === 116 || e === 9 ? "	" : e === 110 ? `
+` : e === 118 ? "\v" : e === 102 ? "\f" : e === 114 ? "\r" : e === 101 ? "\x1B" : e === 32 ? " " : e === 34 ? '"' : e === 47 ? "/" : e === 92 ? "\\" : e === 78 ? "…" : e === 95 ? " " : e === 76 ? "\u2028" : e === 80 ? "\u2029" : "";
+}
+function xi(e) {
+  return e <= 65535 ? String.fromCharCode(e) : String.fromCharCode(
+    (e - 65536 >> 10) + 55296,
+    (e - 65536 & 1023) + 56320
+  );
+}
+function Ct(e, n, t) {
+  n === "__proto__" ? Object.defineProperty(e, n, {
+    configurable: !0,
+    enumerable: !0,
+    writable: !0,
+    value: t
+  }) : e[n] = t;
+}
+var Tt = new Array(256), It = new Array(256);
+for (var ke = 0; ke < 256; ke++)
+  Tt[ke] = Mn(ke) ? 1 : 0, It[ke] = Mn(ke);
+function wi(e, n) {
+  this.input = e, this.filename = n.filename || null, this.schema = n.schema || hn, this.onWarning = n.onWarning || null, this.legacy = n.legacy || !1, this.json = n.json || !1, this.listener = n.listener || null, this.implicitTypes = this.schema.compiledImplicit, this.typeMap = this.schema.compiledTypeMap, this.length = e.length, this.position = 0, this.line = 0, this.lineStart = 0, this.lineIndent = 0, this.firstTabInLine = -1, this.documents = [];
+}
+function Ot(e, n) {
+  var t = {
+    name: e.filename,
+    buffer: e.input.slice(0, -1),
+    // omit trailing \0
+    position: e.position,
+    line: e.line,
+    column: e.position - e.lineStart
+  };
+  return t.snippet = Sa(t), new K(n, t);
+}
+function A(e, n) {
+  throw Ot(e, n);
+}
+function We(e, n) {
+  e.onWarning && e.onWarning.call(null, Ot(e, n));
+}
+var jn = {
+  YAML: function(n, t, r) {
+    var a, o, i;
+    n.version !== null && A(n, "duplication of %YAML directive"), r.length !== 1 && A(n, "YAML directive accepts exactly one argument"), a = /^([0-9]+)\.([0-9]+)$/.exec(r[0]), a === null && A(n, "ill-formed argument of the YAML directive"), o = parseInt(a[1], 10), i = parseInt(a[2], 10), o !== 1 && A(n, "unacceptable YAML version of the document"), n.version = r[0], n.checkLineBreaks = i < 2, i !== 1 && i !== 2 && We(n, "unsupported YAML version of the document");
+  },
+  TAG: function(n, t, r) {
+    var a, o;
+    r.length !== 2 && A(n, "TAG directive accepts exactly two arguments"), a = r[0], o = r[1], _t.test(a) || A(n, "ill-formed tag handle (first argument) of the TAG directive"), me.call(n.tagMap, a) && A(n, 'there is a previously declared suffix for "' + a + '" tag handle'), Ft.test(o) || A(n, "ill-formed tag prefix (second argument) of the TAG directive");
+    try {
+      o = decodeURIComponent(o);
+    } catch {
+      A(n, "tag prefix is malformed: " + o);
+    }
+    n.tagMap[a] = o;
+  }
+};
+function he(e, n, t, r) {
+  var a, o, i, l;
+  if (n < t) {
+    if (l = e.input.slice(n, t), r)
+      for (a = 0, o = l.length; a < o; a += 1)
+        i = l.charCodeAt(a), i === 9 || 32 <= i && i <= 1114111 || A(e, "expected valid JSON character");
+    else gi.test(l) && A(e, "the stream contains non-printable characters");
+    e.result += l;
+  }
+}
+function $n(e, n, t, r) {
+  var a, o, i, l;
+  for (j.isObject(t) || A(e, "cannot merge mappings; the provided source object is unacceptable"), a = Object.keys(t), i = 0, l = a.length; i < l; i += 1)
+    o = a[i], me.call(n, o) || (Ct(n, o, t[o]), r[o] = !0);
+}
+function _e(e, n, t, r, a, o, i, l, s) {
+  var u, g;
+  if (Array.isArray(a))
+    for (a = Array.prototype.slice.call(a), u = 0, g = a.length; u < g; u += 1)
+      Array.isArray(a[u]) && A(e, "nested arrays are not supported inside keys"), typeof a == "object" && Pn(a[u]) === "[object Object]" && (a[u] = "[object Object]");
+  if (typeof a == "object" && Pn(a) === "[object Object]" && (a = "[object Object]"), a = String(a), n === null && (n = {}), r === "tag:yaml.org,2002:merge")
+    if (Array.isArray(o))
+      for (u = 0, g = o.length; u < g; u += 1)
+        $n(e, n, o[u], t);
+    else
+      $n(e, n, o, t);
+  else
+    !e.json && !me.call(t, a) && me.call(n, a) && (e.line = i || e.line, e.lineStart = l || e.lineStart, e.position = s || e.position, A(e, "duplicated mapping key")), Ct(n, a, o), delete t[a];
+  return n;
+}
+function mn(e) {
+  var n;
+  n = e.input.charCodeAt(e.position), n === 10 ? e.position++ : n === 13 ? (e.position++, e.input.charCodeAt(e.position) === 10 && e.position++) : A(e, "a line break is expected"), e.line += 1, e.lineStart = e.position, e.firstTabInLine = -1;
+}
+function P(e, n, t) {
+  for (var r = 0, a = e.input.charCodeAt(e.position); a !== 0; ) {
+    for (; xe(a); )
+      a === 9 && e.firstTabInLine === -1 && (e.firstTabInLine = e.position), a = e.input.charCodeAt(++e.position);
+    if (n && a === 35)
+      do
+        a = e.input.charCodeAt(++e.position);
+      while (a !== 10 && a !== 13 && a !== 0);
+    if (ie(a))
+      for (mn(e), a = e.input.charCodeAt(e.position), r++, e.lineIndent = 0; a === 32; )
+        e.lineIndent++, a = e.input.charCodeAt(++e.position);
+    else
+      break;
+  }
+  return t !== -1 && r !== 0 && e.lineIndent < t && We(e, "deficient indentation"), r;
+}
+function Qe(e) {
+  var n = e.position, t;
+  return t = e.input.charCodeAt(n), !!((t === 45 || t === 46) && t === e.input.charCodeAt(n + 1) && t === e.input.charCodeAt(n + 2) && (n += 3, t = e.input.charCodeAt(n), t === 0 || Z(t)));
+}
+function bn(e, n) {
+  n === 1 ? e.result += " " : n > 1 && (e.result += j.repeat(`
+`, n - 1));
+}
+function Ai(e, n, t) {
+  var r, a, o, i, l, s, u, g, f = e.kind, m = e.result, v;
+  if (v = e.input.charCodeAt(e.position), Z(v) || Se(v) || v === 35 || v === 38 || v === 42 || v === 33 || v === 124 || v === 62 || v === 39 || v === 34 || v === 37 || v === 64 || v === 96 || (v === 63 || v === 45) && (a = e.input.charCodeAt(e.position + 1), Z(a) || t && Se(a)))
+    return !1;
+  for (e.kind = "scalar", e.result = "", o = i = e.position, l = !1; v !== 0; ) {
+    if (v === 58) {
+      if (a = e.input.charCodeAt(e.position + 1), Z(a) || t && Se(a))
+        break;
+    } else if (v === 35) {
+      if (r = e.input.charCodeAt(e.position - 1), Z(r))
+        break;
+    } else {
+      if (e.position === e.lineStart && Qe(e) || t && Se(v))
+        break;
+      if (ie(v))
+        if (s = e.line, u = e.lineStart, g = e.lineIndent, P(e, !1, -1), e.lineIndent >= n) {
+          l = !0, v = e.input.charCodeAt(e.position);
+          continue;
+        } else {
+          e.position = i, e.line = s, e.lineStart = u, e.lineIndent = g;
+          break;
+        }
+    }
+    l && (he(e, o, i, !1), bn(e, e.line - s), o = i = e.position, l = !1), xe(v) || (i = e.position + 1), v = e.input.charCodeAt(++e.position);
+  }
+  return he(e, o, i, !1), e.result ? !0 : (e.kind = f, e.result = m, !1);
+}
+function ki(e, n) {
+  var t, r, a;
+  if (t = e.input.charCodeAt(e.position), t !== 39)
+    return !1;
+  for (e.kind = "scalar", e.result = "", e.position++, r = a = e.position; (t = e.input.charCodeAt(e.position)) !== 0; )
+    if (t === 39)
+      if (he(e, r, e.position, !0), t = e.input.charCodeAt(++e.position), t === 39)
+        r = e.position, e.position++, a = e.position;
+      else
+        return !0;
+    else ie(t) ? (he(e, r, a, !0), bn(e, P(e, !1, n)), r = a = e.position) : e.position === e.lineStart && Qe(e) ? A(e, "unexpected end of the document within a single quoted scalar") : (e.position++, a = e.position);
+  A(e, "unexpected end of the stream within a single quoted scalar");
+}
+function Ei(e, n) {
+  var t, r, a, o, i, l;
+  if (l = e.input.charCodeAt(e.position), l !== 34)
+    return !1;
+  for (e.kind = "scalar", e.result = "", e.position++, t = r = e.position; (l = e.input.charCodeAt(e.position)) !== 0; ) {
+    if (l === 34)
+      return he(e, t, e.position, !0), e.position++, !0;
+    if (l === 92) {
+      if (he(e, t, e.position, !0), l = e.input.charCodeAt(++e.position), ie(l))
+        P(e, !1, n);
+      else if (l < 256 && Tt[l])
+        e.result += It[l], e.position++;
+      else if ((i = bi(l)) > 0) {
+        for (a = i, o = 0; a > 0; a--)
+          l = e.input.charCodeAt(++e.position), (i = mi(l)) >= 0 ? o = (o << 4) + i : A(e, "expected hexadecimal character");
+        e.result += xi(o), e.position++;
+      } else
+        A(e, "unknown escape sequence");
+      t = r = e.position;
+    } else ie(l) ? (he(e, t, r, !0), bn(e, P(e, !1, n)), t = r = e.position) : e.position === e.lineStart && Qe(e) ? A(e, "unexpected end of the document within a double quoted scalar") : (e.position++, r = e.position);
+  }
+  A(e, "unexpected end of the stream within a double quoted scalar");
+}
+function Si(e, n) {
+  var t = !0, r, a, o, i = e.tag, l, s = e.anchor, u, g, f, m, v, c = /* @__PURE__ */ Object.create(null), p, d, b, y;
+  if (y = e.input.charCodeAt(e.position), y === 91)
+    g = 93, v = !1, l = [];
+  else if (y === 123)
+    g = 125, v = !0, l = {};
+  else
+    return !1;
+  for (e.anchor !== null && (e.anchorMap[e.anchor] = l), y = e.input.charCodeAt(++e.position); y !== 0; ) {
+    if (P(e, !0, n), y = e.input.charCodeAt(e.position), y === g)
+      return e.position++, e.tag = i, e.anchor = s, e.kind = v ? "mapping" : "sequence", e.result = l, !0;
+    t ? y === 44 && A(e, "expected the node content, but found ','") : A(e, "missed comma between flow collection entries"), d = p = b = null, f = m = !1, y === 63 && (u = e.input.charCodeAt(e.position + 1), Z(u) && (f = m = !0, e.position++, P(e, !0, n))), r = e.line, a = e.lineStart, o = e.position, Fe(e, n, He, !1, !0), d = e.tag, p = e.result, P(e, !0, n), y = e.input.charCodeAt(e.position), (m || e.line === r) && y === 58 && (f = !0, y = e.input.charCodeAt(++e.position), P(e, !0, n), Fe(e, n, He, !1, !0), b = e.result), v ? _e(e, l, c, d, p, b, r, a, o) : f ? l.push(_e(e, null, c, d, p, b, r, a, o)) : l.push(p), P(e, !0, n), y = e.input.charCodeAt(e.position), y === 44 ? (t = !0, y = e.input.charCodeAt(++e.position)) : t = !1;
+  }
+  A(e, "unexpected end of the stream within a flow collection");
+}
+function _i(e, n) {
+  var t, r, a = on, o = !1, i = !1, l = n, s = 0, u = !1, g, f;
+  if (f = e.input.charCodeAt(e.position), f === 124)
+    r = !1;
+  else if (f === 62)
+    r = !0;
+  else
+    return !1;
+  for (e.kind = "scalar", e.result = ""; f !== 0; )
+    if (f = e.input.charCodeAt(++e.position), f === 43 || f === 45)
+      on === a ? a = f === 43 ? Bn : di : A(e, "repeat of a chomping mode identifier");
+    else if ((g = vi(f)) >= 0)
+      g === 0 ? A(e, "bad explicit indentation width of a block scalar; it cannot be less than one") : i ? A(e, "repeat of an indentation width identifier") : (l = n + g - 1, i = !0);
+    else
+      break;
+  if (xe(f)) {
+    do
+      f = e.input.charCodeAt(++e.position);
+    while (xe(f));
+    if (f === 35)
+      do
+        f = e.input.charCodeAt(++e.position);
+      while (!ie(f) && f !== 0);
+  }
+  for (; f !== 0; ) {
+    for (mn(e), e.lineIndent = 0, f = e.input.charCodeAt(e.position); (!i || e.lineIndent < l) && f === 32; )
+      e.lineIndent++, f = e.input.charCodeAt(++e.position);
+    if (!i && e.lineIndent > l && (l = e.lineIndent), ie(f)) {
+      s++;
+      continue;
+    }
+    if (e.lineIndent < l) {
+      a === Bn ? e.result += j.repeat(`
+`, o ? 1 + s : s) : a === on && o && (e.result += `
+`);
+      break;
+    }
+    for (r ? xe(f) ? (u = !0, e.result += j.repeat(`
+`, o ? 1 + s : s)) : u ? (u = !1, e.result += j.repeat(`
+`, s + 1)) : s === 0 ? o && (e.result += " ") : e.result += j.repeat(`
+`, s) : e.result += j.repeat(`
+`, o ? 1 + s : s), o = !0, i = !0, s = 0, t = e.position; !ie(f) && f !== 0; )
+      f = e.input.charCodeAt(++e.position);
+    he(e, t, e.position, !1);
+  }
+  return !0;
+}
+function Un(e, n) {
+  var t, r = e.tag, a = e.anchor, o = [], i, l = !1, s;
+  if (e.firstTabInLine !== -1) return !1;
+  for (e.anchor !== null && (e.anchorMap[e.anchor] = o), s = e.input.charCodeAt(e.position); s !== 0 && (e.firstTabInLine !== -1 && (e.position = e.firstTabInLine, A(e, "tab characters must not be used in indentation")), !(s !== 45 || (i = e.input.charCodeAt(e.position + 1), !Z(i)))); ) {
+    if (l = !0, e.position++, P(e, !0, -1) && e.lineIndent <= n) {
+      o.push(null), s = e.input.charCodeAt(e.position);
+      continue;
+    }
+    if (t = e.line, Fe(e, n, St, !1, !0), o.push(e.result), P(e, !0, -1), s = e.input.charCodeAt(e.position), (e.line === t || e.lineIndent > n) && s !== 0)
+      A(e, "bad indentation of a sequence entry");
+    else if (e.lineIndent < n)
+      break;
+  }
+  return l ? (e.tag = r, e.anchor = a, e.kind = "sequence", e.result = o, !0) : !1;
+}
+function Fi(e, n, t) {
+  var r, a, o, i, l, s, u = e.tag, g = e.anchor, f = {}, m = /* @__PURE__ */ Object.create(null), v = null, c = null, p = null, d = !1, b = !1, y;
+  if (e.firstTabInLine !== -1) return !1;
+  for (e.anchor !== null && (e.anchorMap[e.anchor] = f), y = e.input.charCodeAt(e.position); y !== 0; ) {
+    if (!d && e.firstTabInLine !== -1 && (e.position = e.firstTabInLine, A(e, "tab characters must not be used in indentation")), r = e.input.charCodeAt(e.position + 1), o = e.line, (y === 63 || y === 58) && Z(r))
+      y === 63 ? (d && (_e(e, f, m, v, c, null, i, l, s), v = c = p = null), b = !0, d = !0, a = !0) : d ? (d = !1, a = !0) : A(e, "incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line"), e.position += 1, y = r;
+    else {
+      if (i = e.line, l = e.lineStart, s = e.position, !Fe(e, t, Et, !1, !0))
+        break;
+      if (e.line === o) {
+        for (y = e.input.charCodeAt(e.position); xe(y); )
+          y = e.input.charCodeAt(++e.position);
+        if (y === 58)
+          y = e.input.charCodeAt(++e.position), Z(y) || A(e, "a whitespace character is expected after the key-value separator within a block mapping"), d && (_e(e, f, m, v, c, null, i, l, s), v = c = p = null), b = !0, d = !1, a = !1, v = e.tag, c = e.result;
+        else if (b)
+          A(e, "can not read an implicit mapping pair; a colon is missed");
+        else
+          return e.tag = u, e.anchor = g, !0;
+      } else if (b)
+        A(e, "can not read a block mapping entry; a multiline key may not be an implicit key");
+      else
+        return e.tag = u, e.anchor = g, !0;
+    }
+    if ((e.line === o || e.lineIndent > n) && (d && (i = e.line, l = e.lineStart, s = e.position), Fe(e, n, Ke, !0, a) && (d ? c = e.result : p = e.result), d || (_e(e, f, m, v, c, p, i, l, s), v = c = p = null), P(e, !0, -1), y = e.input.charCodeAt(e.position)), (e.line === o || e.lineIndent > n) && y !== 0)
+      A(e, "bad indentation of a mapping entry");
+    else if (e.lineIndent < n)
+      break;
+  }
+  return d && _e(e, f, m, v, c, null, i, l, s), b && (e.tag = u, e.anchor = g, e.kind = "mapping", e.result = f), b;
+}
+function Ci(e) {
+  var n, t = !1, r = !1, a, o, i;
+  if (i = e.input.charCodeAt(e.position), i !== 33) return !1;
+  if (e.tag !== null && A(e, "duplication of a tag property"), i = e.input.charCodeAt(++e.position), i === 60 ? (t = !0, i = e.input.charCodeAt(++e.position)) : i === 33 ? (r = !0, a = "!!", i = e.input.charCodeAt(++e.position)) : a = "!", n = e.position, t) {
+    do
+      i = e.input.charCodeAt(++e.position);
+    while (i !== 0 && i !== 62);
+    e.position < e.length ? (o = e.input.slice(n, e.position), i = e.input.charCodeAt(++e.position)) : A(e, "unexpected end of the stream within a verbatim tag");
+  } else {
+    for (; i !== 0 && !Z(i); )
+      i === 33 && (r ? A(e, "tag suffix cannot contain exclamation marks") : (a = e.input.slice(n - 1, e.position + 1), _t.test(a) || A(e, "named tag handle cannot contain such characters"), r = !0, n = e.position + 1)), i = e.input.charCodeAt(++e.position);
+    o = e.input.slice(n, e.position), hi.test(o) && A(e, "tag suffix cannot contain flow indicator characters");
+  }
+  o && !Ft.test(o) && A(e, "tag name cannot contain such characters: " + o);
+  try {
+    o = decodeURIComponent(o);
+  } catch {
+    A(e, "tag name is malformed: " + o);
+  }
+  return t ? e.tag = o : me.call(e.tagMap, a) ? e.tag = e.tagMap[a] + o : a === "!" ? e.tag = "!" + o : a === "!!" ? e.tag = "tag:yaml.org,2002:" + o : A(e, 'undeclared tag handle "' + a + '"'), !0;
+}
+function Ti(e) {
+  var n, t;
+  if (t = e.input.charCodeAt(e.position), t !== 38) return !1;
+  for (e.anchor !== null && A(e, "duplication of an anchor property"), t = e.input.charCodeAt(++e.position), n = e.position; t !== 0 && !Z(t) && !Se(t); )
+    t = e.input.charCodeAt(++e.position);
+  return e.position === n && A(e, "name of an anchor node must contain at least one character"), e.anchor = e.input.slice(n, e.position), !0;
+}
+function Ii(e) {
+  var n, t, r;
+  if (r = e.input.charCodeAt(e.position), r !== 42) return !1;
+  for (r = e.input.charCodeAt(++e.position), n = e.position; r !== 0 && !Z(r) && !Se(r); )
+    r = e.input.charCodeAt(++e.position);
+  return e.position === n && A(e, "name of an alias node must contain at least one character"), t = e.input.slice(n, e.position), me.call(e.anchorMap, t) || A(e, 'unidentified alias "' + t + '"'), e.result = e.anchorMap[t], P(e, !0, -1), !0;
+}
+function Fe(e, n, t, r, a) {
+  var o, i, l, s = 1, u = !1, g = !1, f, m, v, c, p, d;
+  if (e.listener !== null && e.listener("open", e), e.tag = null, e.anchor = null, e.kind = null, e.result = null, o = i = l = Ke === t || St === t, r && P(e, !0, -1) && (u = !0, e.lineIndent > n ? s = 1 : e.lineIndent === n ? s = 0 : e.lineIndent < n && (s = -1)), s === 1)
+    for (; Ci(e) || Ti(e); )
+      P(e, !0, -1) ? (u = !0, l = o, e.lineIndent > n ? s = 1 : e.lineIndent === n ? s = 0 : e.lineIndent < n && (s = -1)) : l = !1;
+  if (l && (l = u || a), (s === 1 || Ke === t) && (He === t || Et === t ? p = n : p = n + 1, d = e.position - e.lineStart, s === 1 ? l && (Un(e, d) || Fi(e, d, p)) || Si(e, p) ? g = !0 : (i && _i(e, p) || ki(e, p) || Ei(e, p) ? g = !0 : Ii(e) ? (g = !0, (e.tag !== null || e.anchor !== null) && A(e, "alias node should not have any properties")) : Ai(e, p, He === t) && (g = !0, e.tag === null && (e.tag = "?")), e.anchor !== null && (e.anchorMap[e.anchor] = e.result)) : s === 0 && (g = l && Un(e, d))), e.tag === null)
+    e.anchor !== null && (e.anchorMap[e.anchor] = e.result);
+  else if (e.tag === "?") {
+    for (e.result !== null && e.kind !== "scalar" && A(e, 'unacceptable node kind for !<?> tag; it should be "scalar", not "' + e.kind + '"'), f = 0, m = e.implicitTypes.length; f < m; f += 1)
+      if (c = e.implicitTypes[f], c.resolve(e.result)) {
+        e.result = c.construct(e.result), e.tag = c.tag, e.anchor !== null && (e.anchorMap[e.anchor] = e.result);
+        break;
+      }
+  } else if (e.tag !== "!") {
+    if (me.call(e.typeMap[e.kind || "fallback"], e.tag))
+      c = e.typeMap[e.kind || "fallback"][e.tag];
+    else
+      for (c = null, v = e.typeMap.multi[e.kind || "fallback"], f = 0, m = v.length; f < m; f += 1)
+        if (e.tag.slice(0, v[f].tag.length) === v[f].tag) {
+          c = v[f];
+          break;
+        }
+    c || A(e, "unknown tag !<" + e.tag + ">"), e.result !== null && c.kind !== e.kind && A(e, "unacceptable node kind for !<" + e.tag + '> tag; it should be "' + c.kind + '", not "' + e.kind + '"'), c.resolve(e.result, e.tag) ? (e.result = c.construct(e.result, e.tag), e.anchor !== null && (e.anchorMap[e.anchor] = e.result)) : A(e, "cannot resolve a node with !<" + e.tag + "> explicit tag");
+  }
+  return e.listener !== null && e.listener("close", e), e.tag !== null || e.anchor !== null || g;
+}
+function Oi(e) {
+  var n = e.position, t, r, a, o = !1, i;
+  for (e.version = null, e.checkLineBreaks = e.legacy, e.tagMap = /* @__PURE__ */ Object.create(null), e.anchorMap = /* @__PURE__ */ Object.create(null); (i = e.input.charCodeAt(e.position)) !== 0 && (P(e, !0, -1), i = e.input.charCodeAt(e.position), !(e.lineIndent > 0 || i !== 37)); ) {
+    for (o = !0, i = e.input.charCodeAt(++e.position), t = e.position; i !== 0 && !Z(i); )
+      i = e.input.charCodeAt(++e.position);
+    for (r = e.input.slice(t, e.position), a = [], r.length < 1 && A(e, "directive name must not be less than one character in length"); i !== 0; ) {
+      for (; xe(i); )
+        i = e.input.charCodeAt(++e.position);
+      if (i === 35) {
+        do
+          i = e.input.charCodeAt(++e.position);
+        while (i !== 0 && !ie(i));
+        break;
+      }
+      if (ie(i)) break;
+      for (t = e.position; i !== 0 && !Z(i); )
+        i = e.input.charCodeAt(++e.position);
+      a.push(e.input.slice(t, e.position));
+    }
+    i !== 0 && mn(e), me.call(jn, r) ? jn[r](e, r, a) : We(e, 'unknown document directive "' + r + '"');
+  }
+  if (P(e, !0, -1), e.lineIndent === 0 && e.input.charCodeAt(e.position) === 45 && e.input.charCodeAt(e.position + 1) === 45 && e.input.charCodeAt(e.position + 2) === 45 ? (e.position += 3, P(e, !0, -1)) : o && A(e, "directives end mark is expected"), Fe(e, e.lineIndent - 1, Ke, !1, !0), P(e, !0, -1), e.checkLineBreaks && yi.test(e.input.slice(n, e.position)) && We(e, "non-ASCII line breaks are interpreted as content"), e.documents.push(e.result), e.position === e.lineStart && Qe(e)) {
+    e.input.charCodeAt(e.position) === 46 && (e.position += 3, P(e, !0, -1));
+    return;
+  }
+  if (e.position < e.length - 1)
+    A(e, "end of the stream or a document separator is expected");
+  else
+    return;
+}
+function Lt(e, n) {
+  e = String(e), n = n || {}, e.length !== 0 && (e.charCodeAt(e.length - 1) !== 10 && e.charCodeAt(e.length - 1) !== 13 && (e += `
+`), e.charCodeAt(0) === 65279 && (e = e.slice(1)));
+  var t = new wi(e, n), r = e.indexOf("\0");
+  for (r !== -1 && (t.position = r, A(t, "null byte is not allowed in input")), t.input += "\0"; t.input.charCodeAt(t.position) === 32; )
+    t.lineIndent += 1, t.position += 1;
+  for (; t.position < t.length - 1; )
+    Oi(t);
+  return t.documents;
+}
+function Li(e, n, t) {
+  n !== null && typeof n == "object" && typeof t > "u" && (t = n, n = null);
+  var r = Lt(e, t);
+  if (typeof n != "function")
+    return r;
+  for (var a = 0, o = r.length; a < o; a += 1)
+    n(r[a]);
+}
+function Ri(e, n) {
+  var t = Lt(e, n);
+  if (t.length !== 0) {
+    if (t.length === 1)
+      return t[0];
+    throw new K("expected a single document in the stream, but found more");
+  }
+}
+var Ni = Li, Di = Ri, Rt = {
+  loadAll: Ni,
+  load: Di
+}, Nt = Object.prototype.toString, Dt = Object.prototype.hasOwnProperty, vn = 65279, Bi = 9, Me = 10, Pi = 13, Mi = 32, ji = 33, $i = 34, cn = 35, Ui = 37, zi = 38, Yi = 39, Gi = 42, Bt = 44, Hi = 45, qe = 58, Ki = 61, Wi = 62, qi = 63, Zi = 64, Pt = 91, Mt = 93, Vi = 96, jt = 123, Xi = 124, $t = 125, G = {};
+G[0] = "\\0";
+G[7] = "\\a";
+G[8] = "\\b";
+G[9] = "\\t";
+G[10] = "\\n";
+G[11] = "\\v";
+G[12] = "\\f";
+G[13] = "\\r";
+G[27] = "\\e";
+G[34] = '\\"';
+G[92] = "\\\\";
+G[133] = "\\N";
+G[160] = "\\_";
+G[8232] = "\\L";
+G[8233] = "\\P";
+var Qi = [
+  "y",
+  "Y",
+  "yes",
+  "Yes",
+  "YES",
+  "on",
+  "On",
+  "ON",
+  "n",
+  "N",
+  "no",
+  "No",
+  "NO",
+  "off",
+  "Off",
+  "OFF"
+], Ji = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
+function eo(e, n) {
+  var t, r, a, o, i, l, s;
+  if (n === null) return {};
+  for (t = {}, r = Object.keys(n), a = 0, o = r.length; a < o; a += 1)
+    i = r[a], l = String(n[i]), i.slice(0, 2) === "!!" && (i = "tag:yaml.org,2002:" + i.slice(2)), s = e.compiledTypeMap.fallback[i], s && Dt.call(s.styleAliases, l) && (l = s.styleAliases[l]), t[i] = l;
+  return t;
+}
+function no(e) {
+  var n, t, r;
+  if (n = e.toString(16).toUpperCase(), e <= 255)
+    t = "x", r = 2;
+  else if (e <= 65535)
+    t = "u", r = 4;
+  else if (e <= 4294967295)
+    t = "U", r = 8;
+  else
+    throw new K("code point within a string may not be greater than 0xFFFFFFFF");
+  return "\\" + t + j.repeat("0", r - n.length) + n;
+}
+var to = 1, je = 2;
+function ro(e) {
+  this.schema = e.schema || hn, this.indent = Math.max(1, e.indent || 2), this.noArrayIndent = e.noArrayIndent || !1, this.skipInvalid = e.skipInvalid || !1, this.flowLevel = j.isNothing(e.flowLevel) ? -1 : e.flowLevel, this.styleMap = eo(this.schema, e.styles || null), this.sortKeys = e.sortKeys || !1, this.lineWidth = e.lineWidth || 80, this.noRefs = e.noRefs || !1, this.noCompatMode = e.noCompatMode || !1, this.condenseFlow = e.condenseFlow || !1, this.quotingType = e.quotingType === '"' ? je : to, this.forceQuotes = e.forceQuotes || !1, this.replacer = typeof e.replacer == "function" ? e.replacer : null, this.implicitTypes = this.schema.compiledImplicit, this.explicitTypes = this.schema.compiledExplicit, this.tag = null, this.result = "", this.duplicates = [], this.usedDuplicates = null;
+}
+function zn(e, n) {
+  for (var t = j.repeat(" ", n), r = 0, a = -1, o = "", i, l = e.length; r < l; )
+    a = e.indexOf(`
+`, r), a === -1 ? (i = e.slice(r), r = l) : (i = e.slice(r, a + 1), r = a + 1), i.length && i !== `
+` && (o += t), o += i;
+  return o;
+}
+function pn(e, n) {
+  return `
+` + j.repeat(" ", e.indent * n);
+}
+function ao(e, n) {
+  var t, r, a;
+  for (t = 0, r = e.implicitTypes.length; t < r; t += 1)
+    if (a = e.implicitTypes[t], a.resolve(n))
+      return !0;
+  return !1;
+}
+function Ze(e) {
+  return e === Mi || e === Bi;
+}
+function $e(e) {
+  return 32 <= e && e <= 126 || 161 <= e && e <= 55295 && e !== 8232 && e !== 8233 || 57344 <= e && e <= 65533 && e !== vn || 65536 <= e && e <= 1114111;
+}
+function Yn(e) {
+  return $e(e) && e !== vn && e !== Pi && e !== Me;
+}
+function Gn(e, n, t) {
+  var r = Yn(e), a = r && !Ze(e);
+  return (
+    // ns-plain-safe
+    (t ? (
+      // c = flow-in
+      r
+    ) : r && e !== Bt && e !== Pt && e !== Mt && e !== jt && e !== $t) && e !== cn && !(n === qe && !a) || Yn(n) && !Ze(n) && e === cn || n === qe && a
+  );
+}
+function io(e) {
+  return $e(e) && e !== vn && !Ze(e) && e !== Hi && e !== qi && e !== qe && e !== Bt && e !== Pt && e !== Mt && e !== jt && e !== $t && e !== cn && e !== zi && e !== Gi && e !== ji && e !== Xi && e !== Ki && e !== Wi && e !== Yi && e !== $i && e !== Ui && e !== Zi && e !== Vi;
+}
+function oo(e) {
+  return !Ze(e) && e !== qe;
+}
+function Be(e, n) {
+  var t = e.charCodeAt(n), r;
+  return t >= 55296 && t <= 56319 && n + 1 < e.length && (r = e.charCodeAt(n + 1), r >= 56320 && r <= 57343) ? (t - 55296) * 1024 + r - 56320 + 65536 : t;
+}
+function Ut(e) {
+  var n = /^\n* /;
+  return n.test(e);
+}
+var zt = 1, fn = 2, Yt = 3, Gt = 4, Ee = 5;
+function lo(e, n, t, r, a, o, i, l) {
+  var s, u = 0, g = null, f = !1, m = !1, v = r !== -1, c = -1, p = io(Be(e, 0)) && oo(Be(e, e.length - 1));
+  if (n || i)
+    for (s = 0; s < e.length; u >= 65536 ? s += 2 : s++) {
+      if (u = Be(e, s), !$e(u))
+        return Ee;
+      p = p && Gn(u, g, l), g = u;
+    }
+  else {
+    for (s = 0; s < e.length; u >= 65536 ? s += 2 : s++) {
+      if (u = Be(e, s), u === Me)
+        f = !0, v && (m = m || // Foldable line = too long, and not more-indented.
+        s - c - 1 > r && e[c + 1] !== " ", c = s);
+      else if (!$e(u))
+        return Ee;
+      p = p && Gn(u, g, l), g = u;
+    }
+    m = m || v && s - c - 1 > r && e[c + 1] !== " ";
+  }
+  return !f && !m ? p && !i && !a(e) ? zt : o === je ? Ee : fn : t > 9 && Ut(e) ? Ee : i ? o === je ? Ee : fn : m ? Gt : Yt;
+}
+function so(e, n, t, r, a) {
+  e.dump = function() {
+    if (n.length === 0)
+      return e.quotingType === je ? '""' : "''";
+    if (!e.noCompatMode && (Qi.indexOf(n) !== -1 || Ji.test(n)))
+      return e.quotingType === je ? '"' + n + '"' : "'" + n + "'";
+    var o = e.indent * Math.max(1, t), i = e.lineWidth === -1 ? -1 : Math.max(Math.min(e.lineWidth, 40), e.lineWidth - o), l = r || e.flowLevel > -1 && t >= e.flowLevel;
+    function s(u) {
+      return ao(e, u);
+    }
+    switch (lo(
+      n,
+      l,
+      e.indent,
+      i,
+      s,
+      e.quotingType,
+      e.forceQuotes && !r,
+      a
+    )) {
+      case zt:
+        return n;
+      case fn:
+        return "'" + n.replace(/'/g, "''") + "'";
+      case Yt:
+        return "|" + Hn(n, e.indent) + Kn(zn(n, o));
+      case Gt:
+        return ">" + Hn(n, e.indent) + Kn(zn(uo(n, i), o));
+      case Ee:
+        return '"' + co(n) + '"';
+      default:
+        throw new K("impossible error: invalid scalar style");
+    }
+  }();
+}
+function Hn(e, n) {
+  var t = Ut(e) ? String(n) : "", r = e[e.length - 1] === `
+`, a = r && (e[e.length - 2] === `
+` || e === `
+`), o = a ? "+" : r ? "" : "-";
+  return t + o + `
+`;
+}
+function Kn(e) {
+  return e[e.length - 1] === `
+` ? e.slice(0, -1) : e;
+}
+function uo(e, n) {
+  for (var t = /(\n+)([^\n]*)/g, r = function() {
+    var u = e.indexOf(`
+`);
+    return u = u !== -1 ? u : e.length, t.lastIndex = u, Wn(e.slice(0, u), n);
+  }(), a = e[0] === `
+` || e[0] === " ", o, i; i = t.exec(e); ) {
+    var l = i[1], s = i[2];
+    o = s[0] === " ", r += l + (!a && !o && s !== "" ? `
+` : "") + Wn(s, n), a = o;
+  }
+  return r;
+}
+function Wn(e, n) {
+  if (e === "" || e[0] === " ") return e;
+  for (var t = / [^ ]/g, r, a = 0, o, i = 0, l = 0, s = ""; r = t.exec(e); )
+    l = r.index, l - a > n && (o = i > a ? i : l, s += `
+` + e.slice(a, o), a = o + 1), i = l;
+  return s += `
+`, e.length - a > n && i > a ? s += e.slice(a, i) + `
+` + e.slice(i + 1) : s += e.slice(a), s.slice(1);
+}
+function co(e) {
+  for (var n = "", t = 0, r, a = 0; a < e.length; t >= 65536 ? a += 2 : a++)
+    t = Be(e, a), r = G[t], !r && $e(t) ? (n += e[a], t >= 65536 && (n += e[a + 1])) : n += r || no(t);
+  return n;
+}
+function po(e, n, t) {
+  var r = "", a = e.tag, o, i, l;
+  for (o = 0, i = t.length; o < i; o += 1)
+    l = t[o], e.replacer && (l = e.replacer.call(t, String(o), l)), (ce(e, n, l, !1, !1) || typeof l > "u" && ce(e, n, null, !1, !1)) && (r !== "" && (r += "," + (e.condenseFlow ? "" : " ")), r += e.dump);
+  e.tag = a, e.dump = "[" + r + "]";
+}
+function qn(e, n, t, r) {
+  var a = "", o = e.tag, i, l, s;
+  for (i = 0, l = t.length; i < l; i += 1)
+    s = t[i], e.replacer && (s = e.replacer.call(t, String(i), s)), (ce(e, n + 1, s, !0, !0, !1, !0) || typeof s > "u" && ce(e, n + 1, null, !0, !0, !1, !0)) && ((!r || a !== "") && (a += pn(e, n)), e.dump && Me === e.dump.charCodeAt(0) ? a += "-" : a += "- ", a += e.dump);
+  e.tag = o, e.dump = a || "[]";
+}
+function fo(e, n, t) {
+  var r = "", a = e.tag, o = Object.keys(t), i, l, s, u, g;
+  for (i = 0, l = o.length; i < l; i += 1)
+    g = "", r !== "" && (g += ", "), e.condenseFlow && (g += '"'), s = o[i], u = t[s], e.replacer && (u = e.replacer.call(t, s, u)), ce(e, n, s, !1, !1) && (e.dump.length > 1024 && (g += "? "), g += e.dump + (e.condenseFlow ? '"' : "") + ":" + (e.condenseFlow ? "" : " "), ce(e, n, u, !1, !1) && (g += e.dump, r += g));
+  e.tag = a, e.dump = "{" + r + "}";
+}
+function go(e, n, t, r) {
+  var a = "", o = e.tag, i = Object.keys(t), l, s, u, g, f, m;
+  if (e.sortKeys === !0)
+    i.sort();
+  else if (typeof e.sortKeys == "function")
+    i.sort(e.sortKeys);
+  else if (e.sortKeys)
+    throw new K("sortKeys must be a boolean or a function");
+  for (l = 0, s = i.length; l < s; l += 1)
+    m = "", (!r || a !== "") && (m += pn(e, n)), u = i[l], g = t[u], e.replacer && (g = e.replacer.call(t, u, g)), ce(e, n + 1, u, !0, !0, !0) && (f = e.tag !== null && e.tag !== "?" || e.dump && e.dump.length > 1024, f && (e.dump && Me === e.dump.charCodeAt(0) ? m += "?" : m += "? "), m += e.dump, f && (m += pn(e, n)), ce(e, n + 1, g, !0, f) && (e.dump && Me === e.dump.charCodeAt(0) ? m += ":" : m += ": ", m += e.dump, a += m));
+  e.tag = o, e.dump = a || "{}";
+}
+function Zn(e, n, t) {
+  var r, a, o, i, l, s;
+  for (a = t ? e.explicitTypes : e.implicitTypes, o = 0, i = a.length; o < i; o += 1)
+    if (l = a[o], (l.instanceOf || l.predicate) && (!l.instanceOf || typeof n == "object" && n instanceof l.instanceOf) && (!l.predicate || l.predicate(n))) {
+      if (t ? l.multi && l.representName ? e.tag = l.representName(n) : e.tag = l.tag : e.tag = "?", l.represent) {
+        if (s = e.styleMap[l.tag] || l.defaultStyle, Nt.call(l.represent) === "[object Function]")
+          r = l.represent(n, s);
+        else if (Dt.call(l.represent, s))
+          r = l.represent[s](n, s);
+        else
+          throw new K("!<" + l.tag + '> tag resolver accepts not "' + s + '" style');
+        e.dump = r;
+      }
+      return !0;
+    }
+  return !1;
+}
+function ce(e, n, t, r, a, o, i) {
+  e.tag = null, e.dump = t, Zn(e, t, !1) || Zn(e, t, !0);
+  var l = Nt.call(e.dump), s = r, u;
+  r && (r = e.flowLevel < 0 || e.flowLevel > n);
+  var g = l === "[object Object]" || l === "[object Array]", f, m;
+  if (g && (f = e.duplicates.indexOf(t), m = f !== -1), (e.tag !== null && e.tag !== "?" || m || e.indent !== 2 && n > 0) && (a = !1), m && e.usedDuplicates[f])
+    e.dump = "*ref_" + f;
+  else {
+    if (g && m && !e.usedDuplicates[f] && (e.usedDuplicates[f] = !0), l === "[object Object]")
+      r && Object.keys(e.dump).length !== 0 ? (go(e, n, e.dump, a), m && (e.dump = "&ref_" + f + e.dump)) : (fo(e, n, e.dump), m && (e.dump = "&ref_" + f + " " + e.dump));
+    else if (l === "[object Array]")
+      r && e.dump.length !== 0 ? (e.noArrayIndent && !i && n > 0 ? qn(e, n - 1, e.dump, a) : qn(e, n, e.dump, a), m && (e.dump = "&ref_" + f + e.dump)) : (po(e, n, e.dump), m && (e.dump = "&ref_" + f + " " + e.dump));
+    else if (l === "[object String]")
+      e.tag !== "?" && so(e, e.dump, n, o, s);
+    else {
+      if (l === "[object Undefined]")
+        return !1;
+      if (e.skipInvalid) return !1;
+      throw new K("unacceptable kind of an object to dump " + l);
+    }
+    e.tag !== null && e.tag !== "?" && (u = encodeURI(
+      e.tag[0] === "!" ? e.tag.slice(1) : e.tag
+    ).replace(/!/g, "%21"), e.tag[0] === "!" ? u = "!" + u : u.slice(0, 18) === "tag:yaml.org,2002:" ? u = "!!" + u.slice(18) : u = "!<" + u + ">", e.dump = u + " " + e.dump);
+  }
+  return !0;
+}
+function yo(e, n) {
+  var t = [], r = [], a, o;
+  for (dn(e, t, r), a = 0, o = r.length; a < o; a += 1)
+    n.duplicates.push(t[r[a]]);
+  n.usedDuplicates = new Array(o);
+}
+function dn(e, n, t) {
+  var r, a, o;
+  if (e !== null && typeof e == "object")
+    if (a = n.indexOf(e), a !== -1)
+      t.indexOf(a) === -1 && t.push(a);
+    else if (n.push(e), Array.isArray(e))
+      for (a = 0, o = e.length; a < o; a += 1)
+        dn(e[a], n, t);
+    else
+      for (r = Object.keys(e), a = 0, o = r.length; a < o; a += 1)
+        dn(e[r[a]], n, t);
+}
+function ho(e, n) {
+  n = n || {};
+  var t = new ro(n);
+  t.noRefs || yo(e, t);
+  var r = e;
+  return t.replacer && (r = t.replacer.call({ "": r }, "", r)), ce(t, 0, r, !0, !0) ? t.dump + `
+` : "";
+}
+var mo = ho, bo = {
+  dump: mo
+};
+function xn(e, n) {
+  return function() {
+    throw new Error("Function yaml." + e + " is removed in js-yaml 4. Use yaml." + n + " instead, which is now safe by default.");
+  };
+}
+var vo = z, xo = it, wo = ut, Ao = gt, ko = yt, Eo = hn, So = Rt.load, _o = Rt.loadAll, Fo = bo.dump, Co = K, To = {
+  binary: xt,
+  float: dt,
+  map: st,
+  null: ct,
+  pairs: At,
+  set: kt,
+  timestamp: bt,
+  bool: pt,
+  int: ft,
+  merge: vt,
+  omap: wt,
+  seq: lt,
+  str: ot
+}, Io = xn("safeLoad", "load"), Oo = xn("safeLoadAll", "loadAll"), Lo = xn("safeDump", "dump"), Ro = {
+  Type: vo,
+  Schema: xo,
+  FAILSAFE_SCHEMA: wo,
+  JSON_SCHEMA: Ao,
+  CORE_SCHEMA: ko,
+  DEFAULT_SCHEMA: Eo,
+  load: So,
+  loadAll: _o,
+  dump: Fo,
+  YAMLException: Co,
+  types: To,
+  safeLoad: Io,
+  safeLoadAll: Oo,
+  safeDump: Lo
+};
+h.languages.yaml || (h.languages.yaml = {
+  scalar: {
+    pattern: /([\-:]\s*(?:![^\s]+)?[ \t]*[|>])[ \t]*(?:((?:\r?\n|\r)[ \t]+)\S[^\r\n]*(?:\2[^\r\n]+)*)/,
+    lookbehind: !0,
+    alias: "string"
+  },
+  comment: /#.*/,
+  key: {
+    pattern: /(\s*(?:^|[:\-,[{\r\n?])[ \t]*(?:![^\s]+)?[ \t]*)[^\r\n{[\]},#\s]+?(?=\s*:\s)/,
+    lookbehind: !0,
+    alias: "atrule"
+  },
+  directive: {
+    pattern: /(^[ \t]*)%.+/m,
+    lookbehind: !0,
+    alias: "tag"
+  },
+  datetime: {
+    pattern: /([:\-,[{]\s*(?:![^\s]+)?[ \t]*)(?:\d{4}-\d\d?-\d\d?(?:[tT]|[ \t]+)\d\d?:\d{2}:\d{2}(?:\.\d*)?(?:[ \t]*(?:Z|[-+]\d\d?(?::\d{2})?))?|\d{4}-\d{2}-\d{2}|\d\d?:\d{2}(?::\d{2}(?:\.\d*)?)?)(?=[ \t]*(?:$|,|\]|\}))/m,
+    lookbehind: !0,
+    alias: "number"
+  },
+  boolean: {
+    pattern: /([:\-,[{]\s*(?:![^\s]+)?[ \t]*)(?:false|true)(?=[ \t]*(?:$|,|\]|\}|[\r\n]))/im,
+    lookbehind: !0,
+    alias: "boolean"
+  },
+  null: {
+    pattern: /([:\-,[{]\s*(?:![^\s]+)?[ \t]*)(?:null|~)(?=[ \t]*(?:$|,|\]|\}|[\r\n]))/im,
+    lookbehind: !0,
+    alias: "constant"
+  },
+  string: {
+    pattern: /([:\-,[{]\s*(?:![^\s]+)?[ \t]*)("|')(?:(?!\2)[^\\\r\n]|\\.)*\2(?=[ \t]*(?:$|,|\]|\}|(?:[\r\n]\s*)?#))/m,
+    lookbehind: !0,
+    greedy: !0
+  },
+  number: {
+    pattern: /([:\-,[{]\s*(?:![^\s]+)?[ \t]*)[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|\.inf|\.nan)(?=[ \t]*(?:$|,|\]|\}|[\r\n]))/im,
+    lookbehind: !0
+  },
+  tag: /![^\s]+/,
+  anchor: /[&*][\w]+/,
+  punctuation: /---|[:[\]{}\-,|>?]|\.\.\./
+});
+function Bo({
+  value: e,
+  onChange: n,
+  onValidationChange: t,
+  readOnly: r = !1,
+  minHeight: a = 100,
+  maxHeight: o,
+  debounceMs: i = 500,
+  className: l = "",
+  style: s = {},
+  language: u = "yaml"
+}) {
+  const [g, f] = Sn(null), m = Ne(null), v = Ne(t), c = Ne(!1);
+  v.current = t;
+  const p = ye((_) => {
+    if (!_.trim()) return null;
+    if (u === "json")
+      try {
+        return JSON.parse(_), null;
+      } catch (O) {
+        const T = (O == null ? void 0 : O.message) || "Invalid JSON", $ = /position\s+(\d+)/i.exec(T);
+        let Y = 1;
+        if ($) {
+          const F = Math.min(parseInt($[1], 10), _.length);
+          Y = 1;
+          for (let R = 0; R < F; R++)
+            _.charCodeAt(R) === 10 && Y++;
+        } else {
+          const F = /line\s+(\d+)/i.exec(T);
+          F && (Y = parseInt(F[1], 10) || 1);
+        }
+        return { line: Y, message: T };
+      }
+    try {
+      return Ro.load(_), null;
+    } catch (O) {
+      const T = O.mark;
+      return {
+        line: (T == null ? void 0 : T.line) !== void 0 ? T.line + 1 : 1,
+        message: O.message || "Invalid YAML"
+      };
+    }
+  }, [u]), d = ye((_) => {
+    var O;
+    f(_), (O = v.current) == null || O.call(v, !_, _ == null ? void 0 : _.message);
+  }, []), b = ye(
+    (_) => {
+      r || (c.current = !0, m.current && clearTimeout(m.current), m.current = setTimeout(() => {
+        d(p(_)), m.current = null;
+      }, i), n(_));
+    },
+    [n, p, d, i, r]
+  );
+  nn(() => () => {
+    m.current && clearTimeout(m.current);
+  }, []), nn(() => {
+    if (c.current) {
+      c.current = !1;
+      return;
+    }
+    m.current && (clearTimeout(m.current), m.current = null), d(p(e));
+  }, [e, p, d]);
+  const y = ln(() => e.split(`
+`).length, [e]), w = ln(() => Array.from({ length: y }, (_, O) => O + 1).join(`
+`), [y]), [E, k] = Sn(!1);
+  nn(() => {
+    const _ = () => {
+      const T = getComputedStyle(document.documentElement).getPropertyValue("--nc-bg").trim();
+      k(T.startsWith("#0") || T.startsWith("#1") || T.startsWith("#2") || T.startsWith("#3"));
+    };
+    _();
+    const O = new MutationObserver(_);
+    return O.observe(document.documentElement, { attributes: !0, attributeFilter: ["class", "data-theme"] }), () => O.disconnect();
+  }, []);
+  const N = E ? sn.vsDark : sn.vsLight, L = ye(
+    (_) => {
+      const O = _[0];
+      return O === "boolean" ? { color: E ? "#569cd6" : "#0000ff" } : O === "constant" || O === "null" ? { color: E ? "#569cd6" : "#0000ff" } : {};
+    },
+    [E]
+  ), M = ye(
+    (_) => /* @__PURE__ */ ge(fa, { theme: N, code: _, language: u, children: ({ tokens: O, getLineProps: T, getTokenProps: $ }) => /* @__PURE__ */ ge(Zt, { children: O.map((Y, F) => {
+      const R = F + 1, be = (g == null ? void 0 : g.line) === R;
+      return /* @__PURE__ */ ge(
+        "div",
+        {
+          ...T({ line: Y }),
+          style: {
+            background: be ? "color-mix(in srgb, var(--nc-danger) 15%, transparent)" : void 0,
+            textDecoration: be ? "underline wavy var(--nc-danger)" : void 0
+          },
+          children: Y.map((V, le) => {
+            const ne = $({ token: V }), te = L(V.types);
+            return /* @__PURE__ */ ge(
+              "span",
+              {
+                ...ne,
+                style: {
+                  ...ne.style,
+                  ...te,
+                  opacity: r ? 0.7 : void 0
+                }
+              },
+              le
+            );
+          })
+        },
+        F
+      );
+    }) }) }),
+    [g, N, L, u, r]
+  ), D = Ne(null), W = Ne(null), q = () => {
+    D.current && W.current && (W.current.scrollTop = D.current.scrollTop);
+  };
+  return /* @__PURE__ */ en(
+    "div",
+    {
+      className: `nc-yaml-textarea ${l}`.trim(),
+      style: { display: "flex", flexDirection: "column", gap: 4, ...s },
+      children: [
+        /* @__PURE__ */ ge("style", { children: `
+        .yaml-editor-container,
+        .yaml-editor-container * {
+          white-space: pre !important;
+          overflow-wrap: normal !important;
+          word-wrap: normal !important;
+          word-break: keep-all !important;
+        }
+        .yaml-editor-container textarea,
+        .yaml-editor-container pre {
+          white-space: pre !important;
+          overflow-wrap: normal !important;
+          word-wrap: normal !important;
+          word-break: keep-all !important;
+          overflow-x: visible !important;
+          resize: none !important;
+        }
+        .yaml-editor-container.read-only textarea {
+          caret-color: transparent !important;
+          color: var(--nc-text-weak) !important;
+        }
+      ` }),
+        /* @__PURE__ */ en(
+          "div",
+          {
+            className: `nc-yaml-textarea-container${g ? " error" : ""}`,
+            style: {
+              border: `1px solid ${g ? "var(--nc-danger)" : "var(--nc-border)"}`,
+              background: r ? "var(--nc-bg-secondary)" : "var(--nc-bg-tertiary)",
+              minHeight: a,
+              maxHeight: o
+            },
+            children: [
+              /* @__PURE__ */ ge(
+                "div",
+                {
+                  ref: W,
+                  style: {
+                    padding: "10px 8px",
+                    paddingRight: 12,
+                    background: "var(--nc-bg-tertiary)",
+                    borderRight: "1px solid var(--nc-border)",
+                    color: "var(--nc-text-weak)",
+                    fontFamily: 'Consolas, Monaco, "Courier New", monospace',
+                    fontSize: 13,
+                    lineHeight: "1.5",
+                    textAlign: "right",
+                    userSelect: "none",
+                    whiteSpace: "pre",
+                    minWidth: 40,
+                    overflow: "hidden"
+                  },
+                  children: w
+                }
+              ),
+              /* @__PURE__ */ ge(
+                "div",
+                {
+                  ref: D,
+                  className: `yaml-editor-container${r ? " read-only" : ""}`,
+                  style: {
+                    flex: 1,
+                    overflowX: "auto",
+                    overflowY: "auto",
+                    color: "var(--nc-text)"
+                  },
+                  onScroll: q,
+                  children: /* @__PURE__ */ ge(
+                    sr,
+                    {
+                      value: e,
+                      onValueChange: b,
+                      highlight: M,
+                      padding: 10,
+                      readOnly: r,
+                      style: {
+                        fontFamily: 'Consolas, Monaco, "Courier New", monospace',
+                        fontSize: 13,
+                        lineHeight: "1.5",
+                        minHeight: Math.max(a - 2, 0),
+                        background: "transparent",
+                        color: "var(--nc-text)",
+                        whiteSpace: "pre",
+                        minWidth: "max-content"
+                      },
+                      textareaClassName: "yaml-editor-textarea"
+                    }
+                  )
+                }
+              )
+            ]
+          }
+        ),
+        g && /* @__PURE__ */ en(
+          "div",
+          {
+            style: {
+              color: "var(--nc-danger)",
+              fontSize: 12,
+              padding: "4px 8px",
+              background: "color-mix(in srgb, var(--nc-danger) 10%, transparent)",
+              borderRadius: 4
+            },
+            children: [
+              "Line ",
+              g.line,
+              ": ",
+              g.message
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+export {
+  Bo as Y,
+  Qn as c
+};
+//# sourceMappingURL=YamlTextArea-ee1d1TLc.js.map