zudoku 0.3.0-dev.3 → 0.3.0-dev.31

package/lib/MdxComponents-C0R6zobS.js

@@ -0,0 +1,3019 @@
+import { j as k } from "./jsx-runtime-SV6hXQua.js";
+import { c as q, b as Se, C as _e, L as Fe } from "./index-CPvRaBBB.js";
+import { createContext as ye, useRef as M, useEffect as G, useCallback as Z, useContext as fe, useState as X, useMemo as ne, createElement as Te } from "react";
+import { c as z, a as be } from "./cn-DpqTslo9.js";
+/**
+ * @license lucide-react v0.378.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const Re = q("Copy", [
+  ["rect", { width: "14", height: "14", x: "8", y: "8", rx: "2", ry: "2", key: "17jyea" }],
+  ["path", { d: "M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2", key: "zix9uf" }]
+]);
+/**
+ * @license lucide-react v0.378.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const le = q("Info", [
+  ["circle", { cx: "12", cy: "12", r: "10", key: "1mglay" }],
+  ["path", { d: "M12 16v-4", key: "1dtifu" }],
+  ["path", { d: "M12 8h.01", key: "e9boi3" }]
+]);
+/**
+ * @license lucide-react v0.378.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const Ie = q("Lightbulb", [
+  [
+    "path",
+    {
+      d: "M15 14c.2-1 .7-1.7 1.5-2.5 1-.9 1.5-2.2 1.5-3.5A6 6 0 0 0 6 8c0 1 .2 2.2 1.5 3.5.7.7 1.3 1.5 1.5 2.5",
+      key: "1gvzjb"
+    }
+  ],
+  ["path", { d: "M9 18h6", key: "x1upvd" }],
+  ["path", { d: "M10 22h4", key: "ceow96" }]
+]);
+/**
+ * @license lucide-react v0.378.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const Le = q("ShieldAlert", [
+  [
+    "path",
+    {
+      d: "M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z",
+      key: "oel41y"
+    }
+  ],
+  ["path", { d: "M12 8v4", key: "1got3b" }],
+  ["path", { d: "M12 16h.01", key: "1drbdi" }]
+]);
+/**
+ * @license lucide-react v0.378.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const Ce = q("TriangleAlert", [
+  [
+    "path",
+    {
+      d: "m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3",
+      key: "wmoenq"
+    }
+  ],
+  ["path", { d: "M12 9v4", key: "juzpu7" }],
+  ["path", { d: "M12 17h.01", key: "p32p05" }]
+]), Oe = {
+  note: {
+    border: "border-gray-300 dark:border-zinc-800",
+    bg: "bg-gray-100 dark:bg-zinc-800/50",
+    iconColor: "text-gray-600 dark:text-zinc-300",
+    titleColor: "text-gray-600 dark:text-zinc-300",
+    textColor: "text-gray-600 dark:text-zinc-300",
+    Icon: le
+  },
+  tip: {
+    border: "border-green-500 dark:border-green-800",
+    bg: "bg-green-200/25 dark:bg-green-950/70",
+    iconColor: "text-green-600 dark:text-green-200",
+    titleColor: "text-green-700 dark:text-green-200",
+    textColor: "text-green-600 dark:text-green-50",
+    Icon: Ie
+  },
+  info: {
+    border: "border-blue-400 dark:border-blue-900/60",
+    bg: "bg-blue-50 dark:bg-blue-950/40",
+    iconColor: "text-blue-400 dark:text-blue-200",
+    titleColor: "text-blue-700 dark:text-blue-200",
+    textColor: "text-blue-600 dark:text-blue-100",
+    Icon: le
+  },
+  caution: {
+    border: "border-yellow-400 dark:border-yellow-400/25",
+    bg: "bg-yellow-100/60 dark:bg-yellow-400/10",
+    iconColor: "text-yellow-500 dark:text-yellow-300",
+    titleColor: "text-yellow-600 dark:text-yellow-300",
+    textColor: "text-yellow-700 dark:text-yellow-200",
+    Icon: Ce
+  },
+  danger: {
+    border: "border-rose-400 dark:border-rose-800",
+    bg: "bg-rose-50 dark:bg-rose-950/40",
+    iconColor: "text-rose-400 dark:text-rose-300",
+    titleColor: "text-rose-800 dark:text-rose-300",
+    textColor: "text-rose-700 dark:text-rose-100",
+    Icon: Le
+  }
+}, j = ({ type: e, children: t, title: r, className: i }) => {
+  const { border: l, bg: b, iconColor: c, titleColor: d, textColor: p, Icon: y } = Oe[e];
+  return /* @__PURE__ */ k.jsxs(
+    "div",
+    {
+      className: z(
+        "not-prose grid grid-cols-[fit-content_1fr] grid-rows-[fit-content_1fr] gap-x-4 gap-y-2 text-md rounded-md border p-4",
+        "[&_a]:underline [&_a]:decoration-current [&_a]:decoration-from-font [&_a]:underline-offset-4 hover:[&_a]:decoration-1",
+        "[&_code]:!bg-transparent [&_code]:!border-none",
+        r && "items-center",
+        l,
+        b,
+        i
+      ),
+      children: [
+        /* @__PURE__ */ k.jsx(
+          y,
+          {
+            className: z(!r && "mt-1 translate-y-px", c),
+            size: 20,
+            "aria-hidden": "true"
+          }
+        ),
+        r && /* @__PURE__ */ k.jsx("h3", { className: z("font-medium", d), children: r }),
+        /* @__PURE__ */ k.jsx("div", { className: z("col-start-2", !r && "row-start-1", p), children: t })
+      ]
+    }
+  );
+}, me = ye(
+  void 0
+), Ne = () => {
+  const e = fe(me);
+  if (!e)
+    throw new Error(
+      "useViewportAnchor must be used within a CurrentAnchorProvider"
+    );
+  return e;
+}, De = () => {
+  const e = M(null), { observe: t, unobserve: r } = Ne();
+  return G(() => {
+    const l = e.current;
+    if (l)
+      return t(l), () => r(l);
+  }, [t, r]), { ref: Z((l) => {
+    l && (e.current = l);
+  }, []) };
+}, Zt = ({
+  children: e
+}) => {
+  const [t, r] = X(""), i = M(null), l = M(/* @__PURE__ */ new Set());
+  G(() => (i.current = new IntersectionObserver(
+    (d) => {
+      for (const p of d)
+        p.isIntersecting && p.target.id && r(p.target.id);
+    },
+    {
+      // 115px is the height of the sticky header
+      // see --header-height in `main.css`
+      rootMargin: "115px 0px -80% 0px",
+      threshold: 0.75
+    }
+  ), () => {
+    var d;
+    return (d = i.current) == null ? void 0 : d.disconnect();
+  }), []), G(() => {
+    const d = l.current, p = () => {
+      const y = window.scrollY === 0, h = window.innerHeight + window.scrollY >= document.body.scrollHeight;
+      y ? r("") : h && requestIdleCallback(() => {
+        const g = Array.from(d).pop();
+        r((g == null ? void 0 : g.id) ?? "");
+      });
+    };
+    return document.addEventListener("scroll", p), () => {
+      d.clear(), document.removeEventListener("scroll", p);
+    };
+  }, []);
+  const b = ne(() => ({
+    observe: (d) => {
+      !d || !i.current || (l.current.add(d), i.current.observe(d));
+    },
+    unobserve: (d) => {
+      !d || !i.current || (l.current.delete(d), i.current.unobserve(d));
+    }
+  }), []), c = ne(
+    () => ({ activeAnchor: t, setActiveAnchor: r, ...b }),
+    [t, r, b]
+  );
+  return /* @__PURE__ */ k.jsx(me.Provider, { value: c, children: e });
+}, Be = Se("group relative", {
+  variants: {
+    level: {
+      6: "text-md",
+      5: "text-lg",
+      4: "text-xl",
+      3: "text-xl font-semibold",
+      2: "text-2xl font-bold",
+      1: "text-4xl font-extrabold"
+    }
+  },
+  defaultVariants: {
+    level: 1
+  }
+}), je = (e) => {
+  switch (e) {
+    case 1:
+      return "h1";
+    case 2:
+      return "h2";
+    case 3:
+      return "h3";
+    case 4:
+      return "h4";
+    case 5:
+      return "h5";
+    case 6:
+      return "h6";
+    default:
+      return "h1";
+  }
+}, P = ({
+  level: e,
+  children: t,
+  id: r,
+  className: i,
+  registerSidebarAnchor: l
+}) => {
+  const b = je(e ?? 1), { ref: c } = De();
+  return /* @__PURE__ */ k.jsxs(
+    b,
+    {
+      className: Be({ className: i, level: e }),
+      ref: l ? c : void 0,
+      id: r,
+      children: [
+        r && /* @__PURE__ */ k.jsx(
+          "a",
+          {
+            href: `#${r}`,
+            className: "no-underline absolute text-primary -left-[0.8em] pr-2.5 opacity-0 group-hover:opacity-50 hover:!opacity-100 transition-opacity duration-200",
+            "aria-label": `Link to ${r}`,
+            children: "#"
+          }
+        ),
+        t
+      ]
+    }
+  );
+};
+var $e = Object.create, Q = Object.defineProperty, Pe = Object.defineProperties, ze = Object.getOwnPropertyDescriptor, Me = Object.getOwnPropertyDescriptors, he = Object.getOwnPropertyNames, K = Object.getOwnPropertySymbols, Ue = Object.getPrototypeOf, oe = Object.prototype.hasOwnProperty, ve = Object.prototype.propertyIsEnumerable, ue = (e, t, r) => t in e ? Q(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r, O = (e, t) => {
+  for (var r in t || (t = {}))
+    oe.call(t, r) && ue(e, r, t[r]);
+  if (K)
+    for (var r of K(t))
+      ve.call(t, r) && ue(e, r, t[r]);
+  return e;
+}, J = (e, t) => Pe(e, Me(t)), ke = (e, t) => {
+  var r = {};
+  for (var i in e)
+    oe.call(e, i) && t.indexOf(i) < 0 && (r[i] = e[i]);
+  if (e != null && K)
+    for (var i of K(e))
+      t.indexOf(i) < 0 && ve.call(e, i) && (r[i] = e[i]);
+  return r;
+}, Ge = (e, t) => function() {
+  return t || (0, e[he(e)[0]])((t = { exports: {} }).exports, t), t.exports;
+}, Ze = (e, t) => {
+  for (var r in t)
+    Q(e, r, { get: t[r], enumerable: !0 });
+}, qe = (e, t, r, i) => {
+  if (t && typeof t == "object" || typeof t == "function")
+    for (let l of he(t))
+      !oe.call(e, l) && l !== r && Q(e, l, { get: () => t[l], enumerable: !(i = ze(t, l)) || i.enumerable });
+  return e;
+}, He = (e, t, r) => (r = e != null ? $e(Ue(e)) : {}, qe(
+  // 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 ? Q(r, "default", { value: e, enumerable: !0 }) : r,
+  e
+)), We = Ge({
+  "../../node_modules/.pnpm/prismjs@1.29.0_patch_hash=vrxx3pzkik6jpmgpayxfjunetu/node_modules/prismjs/prism.js"(e, t) {
+    var r = function() {
+      var i = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i, l = 0, b = {}, c = {
+        /**
+         * 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 a(n) {
+            return n instanceof d ? new d(n.type, a(n.content), n.alias) : Array.isArray(n) ? n.map(a) : n.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(a) {
+            return Object.prototype.toString.call(a).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(a) {
+            return a.__id || Object.defineProperty(a, "__id", { value: ++l }), a.__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 a(n, s) {
+            s = s || {};
+            var f, u;
+            switch (c.util.type(n)) {
+              case "Object":
+                if (u = c.util.objId(n), s[u])
+                  return s[u];
+                f = /** @type {Record<string, any>} */
+                {}, s[u] = f;
+                for (var m in n)
+                  n.hasOwnProperty(m) && (f[m] = a(n[m], s));
+                return (
+                  /** @type {any} */
+                  f
+                );
+              case "Array":
+                return u = c.util.objId(n), s[u] ? s[u] : (f = [], s[u] = f, n.forEach(function(w, E) {
+                  f[E] = a(w, s);
+                }), /** @type {any} */
+                f);
+              default:
+                return n;
+            }
+          },
+          /**
+           * 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(a) {
+            for (; a; ) {
+              var n = i.exec(a.className);
+              if (n)
+                return n[1].toLowerCase();
+              a = a.parentElement;
+            }
+            return "none";
+          },
+          /**
+           * Sets the Prism `language-xxxx` class of the given element.
+           *
+           * @param {Element} element
+           * @param {string} language
+           * @returns {void}
+           */
+          setLanguage: function(a, n) {
+            a.className = a.className.replace(RegExp(i, "gi"), ""), a.classList.add("language-" + n);
+          },
+          /**
+           * 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(a, n, s) {
+            for (var f = "no-" + n; a; ) {
+              var u = a.classList;
+              if (u.contains(n))
+                return !0;
+              if (u.contains(f))
+                return !1;
+              a = a.parentElement;
+            }
+            return !!s;
+          }
+        },
+        /**
+         * 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: b,
+          plaintext: b,
+          text: b,
+          txt: b,
+          /**
+           * 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(a, n) {
+            var s = c.util.clone(c.languages[a]);
+            for (var f in n)
+              s[f] = n[f];
+            return s;
+          },
+          /**
+           * 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(a, n, s, f) {
+            f = f || /** @type {any} */
+            c.languages;
+            var u = f[a], m = {};
+            for (var w in u)
+              if (u.hasOwnProperty(w)) {
+                if (w == n)
+                  for (var E in s)
+                    s.hasOwnProperty(E) && (m[E] = s[E]);
+                s.hasOwnProperty(w) || (m[w] = u[w]);
+              }
+            var S = f[a];
+            return f[a] = m, c.languages.DFS(c.languages, function(A, F) {
+              F === S && A != a && (this[A] = m);
+            }), m;
+          },
+          // Traverse a language definition with Depth First Search
+          DFS: function a(n, s, f, u) {
+            u = u || {};
+            var m = c.util.objId;
+            for (var w in n)
+              if (n.hasOwnProperty(w)) {
+                s.call(n, w, n[w], f || w);
+                var E = n[w], S = c.util.type(E);
+                S === "Object" && !u[m(E)] ? (u[m(E)] = !0, a(E, s, null, u)) : S === "Array" && !u[m(E)] && (u[m(E)] = !0, a(E, s, w, u));
+              }
+          }
+        },
+        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(a, n, s) {
+          var f = {
+            code: a,
+            grammar: n,
+            language: s
+          };
+          if (c.hooks.run("before-tokenize", f), !f.grammar)
+            throw new Error('The language "' + f.language + '" has no grammar.');
+          return f.tokens = c.tokenize(f.code, f.grammar), c.hooks.run("after-tokenize", f), d.stringify(c.util.encode(f.tokens), f.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(a, n) {
+          var s = n.rest;
+          if (s) {
+            for (var f in s)
+              n[f] = s[f];
+            delete n.rest;
+          }
+          var u = new h();
+          return g(u, u.head, a), y(a, u, n, u.head, 0), x(u);
+        },
+        /**
+         * @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(a, n) {
+            var s = c.hooks.all;
+            s[a] = s[a] || [], s[a].push(n);
+          },
+          /**
+           * 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(a, n) {
+            var s = c.hooks.all[a];
+            if (!(!s || !s.length))
+              for (var f = 0, u; u = s[f++]; )
+                u(n);
+          }
+        },
+        Token: d
+      };
+      function d(a, n, s, f) {
+        this.type = a, this.content = n, this.alias = s, this.length = (f || "").length | 0;
+      }
+      d.stringify = function a(n, s) {
+        if (typeof n == "string")
+          return n;
+        if (Array.isArray(n)) {
+          var f = "";
+          return n.forEach(function(S) {
+            f += a(S, s);
+          }), f;
+        }
+        var u = {
+          type: n.type,
+          content: a(n.content, s),
+          tag: "span",
+          classes: ["token", n.type],
+          attributes: {},
+          language: s
+        }, m = n.alias;
+        m && (Array.isArray(m) ? Array.prototype.push.apply(u.classes, m) : u.classes.push(m)), c.hooks.run("wrap", u);
+        var w = "";
+        for (var E in u.attributes)
+          w += " " + E + '="' + (u.attributes[E] || "").replace(/"/g, "&quot;") + '"';
+        return "<" + u.tag + ' class="' + u.classes.join(" ") + '"' + w + ">" + u.content + "</" + u.tag + ">";
+      };
+      function p(a, n, s, f) {
+        a.lastIndex = n;
+        var u = a.exec(s);
+        if (u && f && u[1]) {
+          var m = u[1].length;
+          u.index += m, u[0] = u[0].slice(m);
+        }
+        return u;
+      }
+      function y(a, n, s, f, u, m) {
+        for (var w in s)
+          if (!(!s.hasOwnProperty(w) || !s[w])) {
+            var E = s[w];
+            E = Array.isArray(E) ? E : [E];
+            for (var S = 0; S < E.length; ++S) {
+              if (m && m.cause == w + "," + S)
+                return;
+              var A = E[S], F = A.inside, T = !!A.lookbehind, D = !!A.greedy, N = A.alias;
+              if (D && !A.pattern.global) {
+                var L = A.pattern.toString().match(/[imsuy]*$/)[0];
+                A.pattern = RegExp(A.pattern.source, L + "g");
+              }
+              for (var se = A.pattern || A, _ = f.next, C = u; _ !== n.tail && !(m && C >= m.reach); C += _.value.length, _ = _.next) {
+                var $ = _.value;
+                if (n.length > a.length)
+                  return;
+                if (!($ instanceof d)) {
+                  var H = 1, I;
+                  if (D) {
+                    if (I = p(se, C, a, T), !I || I.index >= a.length)
+                      break;
+                    var W = I.index, Ee = I.index + I[0].length, B = C;
+                    for (B += _.value.length; W >= B; )
+                      _ = _.next, B += _.value.length;
+                    if (B -= _.value.length, C = B, _.value instanceof d)
+                      continue;
+                    for (var U = _; U !== n.tail && (B < Ee || typeof U.value == "string"); U = U.next)
+                      H++, B += U.value.length;
+                    H--, $ = a.slice(C, B), I.index -= C;
+                  } else if (I = p(se, 0, $, T), !I)
+                    continue;
+                  var W = I.index, Y = I[0], ee = $.slice(0, W), ie = $.slice(W + Y.length), te = C + $.length;
+                  m && te > m.reach && (m.reach = te);
+                  var V = _.prev;
+                  ee && (V = g(n, V, ee), C += ee.length), v(n, V, H);
+                  var Ae = new d(w, F ? c.tokenize(Y, F) : Y, N, Y);
+                  if (_ = g(n, V, Ae), ie && g(n, _, ie), H > 1) {
+                    var re = {
+                      cause: w + "," + S,
+                      reach: te
+                    };
+                    y(a, n, s, _.prev, C, re), m && re.reach > m.reach && (m.reach = re.reach);
+                  }
+                }
+              }
+            }
+          }
+      }
+      function h() {
+        var a = { value: null, prev: null, next: null }, n = { value: null, prev: a, next: null };
+        a.next = n, this.head = a, this.tail = n, this.length = 0;
+      }
+      function g(a, n, s) {
+        var f = n.next, u = { value: s, prev: n, next: f };
+        return n.next = u, f.prev = u, a.length++, u;
+      }
+      function v(a, n, s) {
+        for (var f = n.next, u = 0; u < s && f !== a.tail; u++)
+          f = f.next;
+        n.next = f, f.prev = n, a.length -= u;
+      }
+      function x(a) {
+        for (var n = [], s = a.head.next; s !== a.tail; )
+          n.push(s.value), s = s.next;
+        return n;
+      }
+      return c;
+    }();
+    t.exports = r, r.default = r;
+  }
+}), o = He(We());
+o.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] }, o.languages.markup.tag.inside["attr-value"].inside.entity = o.languages.markup.entity, o.languages.markup.doctype.inside["internal-subset"].inside = o.languages.markup, o.hooks.add("wrap", function(e) {
+  e.type === "entity" && (e.attributes.title = e.content.replace(/&amp;/, "&"));
+}), Object.defineProperty(o.languages.markup.tag, "addInlined", { value: function(e, i) {
+  var r = {}, r = (r["language-" + i] = { pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i, lookbehind: !0, inside: o.languages[i] }, r.cdata = /^<!\[CDATA\[|\]\]>$/i, { "included-cdata": { pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i, inside: r } }), i = (r["language-" + i] = { pattern: /[\s\S]+/, inside: o.languages[i] }, {});
+  i[e] = { pattern: RegExp(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g, function() {
+    return e;
+  }), "i"), lookbehind: !0, greedy: !0, inside: r }, o.languages.insertBefore("markup", "cdata", i);
+} }), Object.defineProperty(o.languages.markup.tag, "addAttribute", { value: function(e, t) {
+  o.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: [t, "language-" + t], inside: o.languages[t] }, punctuation: [{ pattern: /^=/, alias: "attr-equals" }, /"|'/] } } } });
+} }), o.languages.html = o.languages.markup, o.languages.mathml = o.languages.markup, o.languages.svg = o.languages.markup, o.languages.xml = o.languages.extend("markup", {}), o.languages.ssml = o.languages.xml, o.languages.atom = o.languages.xml, o.languages.rss = o.languages.xml, function(e) {
+  var t = { pattern: /\\[\\(){}[\]^$+*?|.]/, alias: "escape" }, r = /\\(?: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]|.)/, i = "(?:[^\\\\-]|" + r.source + ")", i = RegExp(i + "-" + i), l = { 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: i, inside: { escape: r, "range-punctuation": { pattern: /-/, alias: "operator" } } }, "special-escape": t, "char-set": { pattern: /\\[wsd]|\\p\{[^{}]+\}/i, alias: "class-name" }, escape: r } }, "special-escape": t, "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": l } }], anchor: { pattern: /[$^]|\\[ABbGZz]/, alias: "function" }, escape: r, group: [{ pattern: /\((?:\?(?:<[^<>']+>|'[^<>']+'|[>:]|<?[=!]|[idmnsuxU]+(?:-[idmnsuxU]+)?:?))?/, alias: "punctuation", inside: { "group-name": l } }, { pattern: /\)/, alias: "punctuation" }], quantifier: { pattern: /(?:[+*?]|\{\d+(?:,\d*)?\})[?+]?/, alias: "number" }, alternation: { pattern: /\|/, alias: "keyword" } };
+}(o), o.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: /[{}[\];(),.:]/ }, o.languages.javascript = o.languages.extend("clike", { "class-name": [o.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}|\?\?=?|\?\.?|[~:]/ }), o.languages.javascript["class-name"][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/, o.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: o.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: o.languages.javascript }, { pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i, lookbehind: !0, inside: o.languages.javascript }, { pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/, lookbehind: !0, inside: o.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: o.languages.javascript }], constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/ }), o.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: o.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" } }), o.languages.insertBefore("javascript", "operator", { "literal-property": { pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m, lookbehind: !0, alias: "property" } }), o.languages.markup && (o.languages.markup.tag.addInlined("script", "javascript"), o.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")), o.languages.js = o.languages.javascript, o.languages.actionscript = o.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: /\+\+|--|(?:[+\-*\/%^]|&&?|\|\|?|<<?|>>?>?|[!=]=?)=?|[~?@]/ }), o.languages.actionscript["class-name"].alias = "function", delete o.languages.actionscript.parameter, delete o.languages.actionscript["literal-property"], o.languages.markup && o.languages.insertBefore("actionscript", "string", { xml: { pattern: /(^|[^.])<\/?\w+(?:\s+[^\s>\/=]+=("|')(?:\\[\s\S]|(?!\2)[^\\])*\2)*\s*\/?>/, lookbehind: !0, inside: o.languages.markup } }), function(e) {
+  var t = /#(?!\{).+/, r = { pattern: /#\{[^}]+\}/, alias: "variable" };
+  e.languages.coffeescript = e.languages.extend("javascript", { comment: t, string: [{ pattern: /'(?:\\[\s\S]|[^\\'])*'/, greedy: !0 }, { pattern: /"(?:\\[\s\S]|[^\\"])*"/, greedy: !0, inside: { interpolation: r } }], 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: t, interpolation: r } } }), 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: r } }] }), e.languages.insertBefore("coffeescript", "keyword", { property: /(?!\d)\w+(?=\s*:(?!:))/ }), delete e.languages.coffeescript["template-string"], e.languages.coffee = e.languages.coffeescript;
+}(o), function(e) {
+  var t = 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(t, "addSupport", { value: function(r, i) {
+    (r = typeof r == "string" ? [r] : r).forEach(function(l) {
+      var b = function(g) {
+        g.inside || (g.inside = {}), g.inside.rest = i;
+      }, c = "doc-comment";
+      if (d = e.languages[l]) {
+        var d, p = d[c];
+        if ((p = p || (d = e.languages.insertBefore(l, "comment", { "doc-comment": { pattern: /(^|[^\\])\/\*\*[^/][\s\S]*?(?:\*\/|$)/, lookbehind: !0, alias: "comment" } }))[c]) instanceof RegExp && (p = d[c] = { pattern: p }), Array.isArray(p))
+          for (var y = 0, h = p.length; y < h; y++)
+            p[y] instanceof RegExp && (p[y] = { pattern: p[y] }), b(p[y]);
+        else
+          b(p);
+      }
+    });
+  } }), t.addSupport(["java", "javascript", "php"], t);
+}(o), function(e) {
+  var t = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/, t = (e.languages.css = { comment: /\/\*[\s\S]*?\*\//, atrule: { pattern: RegExp("@[\\w-](?:" + /[^;{\s"']|\s+(?!\s)/.source + "|" + t.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\\((?:" + t.source + "|" + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ")\\)", "i"), greedy: !0, inside: { function: /^url/i, punctuation: /^\(|\)$/, string: { pattern: RegExp("^" + t.source + "$"), alias: "url" } } }, selector: { pattern: RegExp(`(^|[{}\\s])[^{}\\s](?:[^{};"'\\s]|\\s+(?![\\s{])|` + t.source + ")*(?=\\s*\\{)"), lookbehind: !0 }, string: { pattern: t, 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);
+  t && (t.tag.addInlined("style", "css"), t.tag.addAttribute("style", "css"));
+}(o), function(e) {
+  var t = /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/, t = (e.languages.css.selector = { pattern: e.languages.css.selector.pattern, lookbehind: !0, inside: t = { "pseudo-element": /:(?:after|before|first-letter|first-line|selection)|::[-\w]+/, "pseudo-class": /:[-\w]+/, class: /\.[-\w]+/, id: /#[-\w]+/, attribute: { pattern: RegExp(`\\[(?:[^[\\]"']|` + t.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": [t, { 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 = t, 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 }), r = { 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: t, number: r, function: /[\w-]+(?=\()/, punctuation: /[(),]/ } }], entity: /\\[\da-f]{1,8}/i, unit: t, number: r });
+}(o), function(e) {
+  var t = /[*&][^\s[\]{},]+/, r = /!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/, i = "(?:" + r.source + "(?:[ 	]+" + t.source + ")?|" + t.source + "(?:[ 	]+" + r.source + ")?)", l = /(?:[^\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;
+  }), b = /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/.source;
+  function c(d, p) {
+    p = (p || "").replace(/m/g, "") + "m";
+    var y = /([:\-,[{]\s*(?:\s<<prop>>[ \t]+)?)(?:<<value>>)(?=[ \t]*(?:$|,|\]|\}|(?:[\r\n]\s*)?#))/.source.replace(/<<prop>>/g, function() {
+      return i;
+    }).replace(/<<value>>/g, function() {
+      return d;
+    });
+    return RegExp(y, p);
+  }
+  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 i;
+  })), lookbehind: !0, alias: "string" }, comment: /#.*/, key: { pattern: RegExp(/((?:^|[:\-,[{\r\n?])[ \t]*(?:<<prop>>[ \t]+)?)<<key>>(?=\s*:\s)/.source.replace(/<<prop>>/g, function() {
+    return i;
+  }).replace(/<<key>>/g, function() {
+    return "(?:" + l + "|" + b + ")";
+  })), lookbehind: !0, greedy: !0, alias: "atrule" }, directive: { pattern: /(^[ \t]*)%.+/m, lookbehind: !0, alias: "important" }, datetime: { pattern: c(/\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: c(/false|true/.source, "i"), lookbehind: !0, alias: "important" }, null: { pattern: c(/null|~/.source, "i"), lookbehind: !0, alias: "important" }, string: { pattern: c(b), lookbehind: !0, greedy: !0 }, number: { pattern: c(/[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|\.inf|\.nan)/.source, "i"), lookbehind: !0 }, tag: r, important: t, punctuation: /---|[:[\]{}\-,|>?]|\.\.\./ }, e.languages.yml = e.languages.yaml;
+}(o), function(e) {
+  var t = /(?:\\.|[^\\\n\r]|(?:\n|\r\n?)(?![\r\n]))/.source;
+  function r(y) {
+    return y = y.replace(/<inner>/g, function() {
+      return t;
+    }), RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + "(?:" + y + ")");
+  }
+  var i = /(?:\\.|``(?:[^`\r\n]|`(?!`))+``|`[^`\r\n]+`|[^\\|\r\n`])+/.source, l = /\|?__(?:\|__)+\|?(?:(?:\n|\r\n?)|(?![\s\S]))/.source.replace(/__/g, function() {
+    return i;
+  }), b = /\|?[ \t]*:?-{3,}:?[ \t]*(?:\|[ \t]*:?-{3,}:?[ \t]*)+\|?(?:\n|\r\n?)/.source, c = (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("^" + l + b + "(?:" + l + ")*", "m"), inside: { "table-data-rows": { pattern: RegExp("^(" + l + b + ")(?:" + l + ")*$"), lookbehind: !0, inside: { "table-data": { pattern: RegExp(i), inside: e.languages.markdown }, punctuation: /\|/ } }, "table-line": { pattern: RegExp("^(" + l + ")" + b + "$"), lookbehind: !0, inside: { punctuation: /\||:?-{3,}:?/ } }, "table-header-row": { pattern: RegExp("^" + l + "$"), inside: { "table-header": { pattern: RegExp(i), 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: r(/\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\b|\*\*(?:(?!\*)<inner>|\*(?:(?!\*)<inner>)+\*)+\*\*/.source), lookbehind: !0, greedy: !0, inside: { content: { pattern: /(^..)[\s\S]+(?=..$)/, lookbehind: !0, inside: {} }, punctuation: /\*\*|__/ } }, italic: { pattern: r(/\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\b|\*(?:(?!\*)<inner>|\*\*(?:(?!\*)<inner>)+\*\*)+\*/.source), lookbehind: !0, greedy: !0, inside: { content: { pattern: /(^.)[\s\S]+(?=.$)/, lookbehind: !0, inside: {} }, punctuation: /[*_]/ } }, strike: { pattern: r(/(~~?)(?:(?!~)<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: r(/!?\[(?:(?!\])<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(y) {
+    ["url", "bold", "italic", "strike", "code-snippet"].forEach(function(h) {
+      y !== h && (e.languages.markdown[y].inside.content.inside[h] = e.languages.markdown[h]);
+    });
+  }), e.hooks.add("after-tokenize", function(y) {
+    y.language !== "markdown" && y.language !== "md" || function h(g) {
+      if (g && typeof g != "string")
+        for (var v = 0, x = g.length; v < x; v++) {
+          var a, n = g[v];
+          n.type !== "code" ? h(n.content) : (a = n.content[1], n = n.content[3], a && n && a.type === "code-language" && n.type === "code-block" && typeof a.content == "string" && (a = a.content.replace(/\b#/g, "sharp").replace(/\b\+\+/g, "pp"), a = "language-" + (a = (/[a-z][\w-]*/i.exec(a) || [""])[0].toLowerCase()), n.alias ? typeof n.alias == "string" ? n.alias = [n.alias, a] : n.alias.push(a) : n.alias = [a]));
+        }
+    }(y.tokens);
+  }), e.hooks.add("wrap", function(y) {
+    if (y.type === "code-block") {
+      for (var h = "", g = 0, v = y.classes.length; g < v; g++) {
+        var x = y.classes[g], x = /language-(.+)/.exec(x);
+        if (x) {
+          h = x[1];
+          break;
+        }
+      }
+      var a, n = e.languages[h];
+      n ? y.content = e.highlight(function(s) {
+        return s = s.replace(c, ""), s = s.replace(/&(\w{1,8}|#x?[\da-f]{1,8});/gi, function(f, u) {
+          var m;
+          return (u = u.toLowerCase())[0] === "#" ? (m = u[1] === "x" ? parseInt(u.slice(2), 16) : Number(u.slice(1)), p(m)) : d[u] || f;
+        });
+      }(y.content), n, h) : h && h !== "none" && e.plugins.autoloader && (a = "md-" + (/* @__PURE__ */ new Date()).valueOf() + "-" + Math.floor(1e16 * Math.random()), y.attributes.id = a, e.plugins.autoloader.loadLanguages(h, function() {
+        var s = document.getElementById(a);
+        s && (s.innerHTML = e.highlight(s.textContent, e.languages[h], h));
+      }));
+    }
+  }), RegExp(e.languages.markup.tag.pattern.source, "gi")), d = { amp: "&", lt: "<", gt: ">", quot: '"' }, p = String.fromCodePoint || String.fromCharCode;
+  e.languages.md = e.languages.markdown;
+}(o), o.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: o.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+/ }, o.hooks.add("after-tokenize", function(e) {
+  if (e.language === "graphql")
+    for (var t = e.tokens.filter(function(a) {
+      return typeof a != "string" && a.type !== "comment" && a.type !== "scalar";
+    }), r = 0; r < t.length; ) {
+      var i = t[r++];
+      if (i.type === "keyword" && i.content === "mutation") {
+        var l = [];
+        if (g(["definition-mutation", "punctuation"]) && h(1).content === "(") {
+          r += 2;
+          var b = v(/^\($/, /^\)$/);
+          if (b === -1)
+            continue;
+          for (; r < b; r++) {
+            var c = h(0);
+            c.type === "variable" && (x(c, "variable-input"), l.push(c.content));
+          }
+          r = b + 1;
+        }
+        if (g(["punctuation", "property-query"]) && h(0).content === "{" && (r++, x(h(0), "property-mutation"), 0 < l.length)) {
+          var d = v(/^\{$/, /^\}$/);
+          if (d !== -1)
+            for (var p = r; p < d; p++) {
+              var y = t[p];
+              y.type === "variable" && 0 <= l.indexOf(y.content) && x(y, "variable-input");
+            }
+        }
+      }
+    }
+  function h(a) {
+    return t[r + a];
+  }
+  function g(a, n) {
+    n = n || 0;
+    for (var s = 0; s < a.length; s++) {
+      var f = h(s + n);
+      if (!f || f.type !== a[s])
+        return;
+    }
+    return 1;
+  }
+  function v(a, n) {
+    for (var s = 1, f = r; f < t.length; f++) {
+      var u = t[f], m = u.content;
+      if (u.type === "punctuation" && typeof m == "string") {
+        if (a.test(m))
+          s++;
+        else if (n.test(m) && --s === 0)
+          return f;
+      }
+    }
+    return -1;
+  }
+  function x(a, n) {
+    var s = a.alias;
+    s ? Array.isArray(s) || (a.alias = s = [s]) : a.alias = s = [], s.push(n);
+  }
+}), o.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 t = e.languages.javascript["template-string"], r = t.pattern.source, i = t.inside.interpolation, l = i.inside["interpolation-punctuation"], b = i.pattern.source;
+  function c(g, v) {
+    if (e.languages[g])
+      return { pattern: RegExp("((?:" + v + ")\\s*)" + r), lookbehind: !0, greedy: !0, inside: { "template-punctuation": { pattern: /^`|`$/, alias: "string" }, "embedded-code": { pattern: /[\s\S]+/, alias: g } } };
+  }
+  function d(g, v, x) {
+    return g = { code: g, grammar: v, language: x }, e.hooks.run("before-tokenize", g), g.tokens = e.tokenize(g.code, g.grammar), e.hooks.run("after-tokenize", g), g.tokens;
+  }
+  function p(g, v, x) {
+    var s = e.tokenize(g, { interpolation: { pattern: RegExp(b), lookbehind: !0 } }), a = 0, n = {}, s = d(s.map(function(u) {
+      if (typeof u == "string")
+        return u;
+      for (var m, w, u = u.content; g.indexOf((w = a++, m = "___" + x.toUpperCase() + "_" + w + "___")) !== -1; )
+        ;
+      return n[m] = u, m;
+    }).join(""), v, x), f = Object.keys(n);
+    return a = 0, function u(m) {
+      for (var w = 0; w < m.length; w++) {
+        if (a >= f.length)
+          return;
+        var E, S, A, F, T, D, N, L = m[w];
+        typeof L == "string" || typeof L.content == "string" ? (E = f[a], (N = (D = typeof L == "string" ? L : L.content).indexOf(E)) !== -1 && (++a, S = D.substring(0, N), T = n[E], A = void 0, (F = {})["interpolation-punctuation"] = l, (F = e.tokenize(T, F)).length === 3 && ((A = [1, 1]).push.apply(A, d(F[1], e.languages.javascript, "javascript")), F.splice.apply(F, A)), A = new e.Token("interpolation", F, i.alias, T), F = D.substring(N + E.length), T = [], S && T.push(S), T.push(A), F && (u(D = [F]), T.push.apply(T, D)), typeof L == "string" ? (m.splice.apply(m, [w, 1].concat(T)), w += T.length - 1) : L.content = T)) : (N = L.content, Array.isArray(N) ? u(N) : u([N]));
+      }
+    }(s), new e.Token(x, s, "language-" + x, g);
+  }
+  e.languages.javascript["template-string"] = [c("css", /\b(?:styled(?:\([^)]*\))?(?:\s*\.\s*\w+(?:\([^)]*\))*)*|css(?:\s*\.\s*(?:global|resolve))?|createGlobalStyle|keyframes)/.source), c("html", /\bhtml|\.\s*(?:inner|outer)HTML\s*\+?=/.source), c("svg", /\bsvg/.source), c("markdown", /\b(?:markdown|md)/.source), c("graphql", /\b(?:gql|graphql(?:\s*\.\s*experimental)?)/.source), c("sql", /\bsql/.source), t].filter(Boolean);
+  var y = { javascript: !0, js: !0, typescript: !0, ts: !0, jsx: !0, tsx: !0 };
+  function h(g) {
+    return typeof g == "string" ? g : Array.isArray(g) ? g.map(h).join("") : h(g.content);
+  }
+  e.hooks.add("after-tokenize", function(g) {
+    g.language in y && function v(x) {
+      for (var a = 0, n = x.length; a < n; a++) {
+        var s, f, u, m = x[a];
+        typeof m != "string" && (s = m.content, Array.isArray(s) ? m.type === "template-string" ? (m = s[1], s.length === 3 && typeof m != "string" && m.type === "embedded-code" && (f = h(m), m = m.alias, m = Array.isArray(m) ? m[0] : m, u = e.languages[m]) && (s[1] = p(f, u, m))) : v(s) : typeof s != "string" && v([s]));
+      }
+    }(g.tokens);
+  });
+}(o), 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 t = e.languages.extend("typescript", {});
+  delete t["class-name"], e.languages.typescript["class-name"].inside = t, 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: t } } } }), e.languages.ts = e.languages.typescript;
+}(o), function(e) {
+  var t = e.languages.javascript, r = /\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})+\}/.source, i = "(@(?:arg|argument|param|property)\\s+(?:" + r + "\\s+)?)";
+  e.languages.jsdoc = e.languages.extend("javadoclike", { parameter: { pattern: RegExp(i + /(?:(?!\s)[$\w\xA0-\uFFFF.])+(?=\s|$)/.source), lookbehind: !0, inside: { punctuation: /\./ } } }), e.languages.insertBefore("jsdoc", "keyword", { "optional-parameter": { pattern: RegExp(i + /\[(?:(?!\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: t, 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 r;
+  })), lookbehind: !0, inside: { punctuation: /\./ } }, { pattern: RegExp("(@[a-z]+\\s+)" + r), lookbehind: !0, inside: { string: t.string, number: t.number, boolean: t.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: t, alias: "language-javascript" } } } }), e.languages.javadoclike.addSupport("javascript", e.languages.jsdoc);
+}(o), 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 });
+}(o), o.languages.n4js = o.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/ }), o.languages.insertBefore("n4js", "constant", { annotation: { pattern: /@+\w+/, alias: "operator" } }), o.languages.n4jsd = o.languages.n4js, function(e) {
+  function t(c, d) {
+    return RegExp(c.replace(/<ID>/g, function() {
+      return /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/.source;
+    }), d);
+  }
+  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: t(/(\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: t(/(\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: t(/(\.\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 r = ["function", "function-variable", "method", "method-variable", "property-access"], i = 0; i < r.length; i++) {
+    var b = r[i], l = e.languages.javascript[b], b = (l = e.util.type(l) === "RegExp" ? e.languages.javascript[b] = { pattern: l } : l).inside || {};
+    (l.inside = b)["maybe-class-name"] = /^[A-Z][\s\S]*/;
+  }
+}(o), function(e) {
+  var t = e.util.clone(e.languages.javascript), r = /(?:\s|\/\/.*(?!.)|\/\*(?:[^*]|\*(?!\/))\*\/)/.source, i = /(?:\{(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])*\})/.source, l = /(?:\{<S>*\.{3}(?:[^{}]|<BRACES>)*\})/.source;
+  function b(p, y) {
+    return p = p.replace(/<S>/g, function() {
+      return r;
+    }).replace(/<BRACES>/g, function() {
+      return i;
+    }).replace(/<SPREAD>/g, function() {
+      return l;
+    }), RegExp(p, y);
+  }
+  l = b(l).source, e.languages.jsx = e.languages.extend("markup", t), e.languages.jsx.tag.pattern = b(/<\/?(?:[\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 = t.comment, e.languages.insertBefore("inside", "attr-name", { spread: { pattern: b(/<SPREAD>/.source), inside: e.languages.jsx } }, e.languages.jsx.tag), e.languages.insertBefore("inside", "special-attr", { script: { pattern: b(/=<BRACES>/.source), alias: "language-javascript", inside: { "script-punctuation": { pattern: /^=(?=\{)/, alias: "punctuation" }, rest: e.languages.jsx } } }, e.languages.jsx.tag);
+  function c(p) {
+    for (var y = [], h = 0; h < p.length; h++) {
+      var g = p[h], v = !1;
+      typeof g != "string" && (g.type === "tag" && g.content[0] && g.content[0].type === "tag" ? g.content[0].content[0].content === "</" ? 0 < y.length && y[y.length - 1].tagName === d(g.content[0].content[1]) && y.pop() : g.content[g.content.length - 1].content !== "/>" && y.push({ tagName: d(g.content[0].content[1]), openedBraces: 0 }) : 0 < y.length && g.type === "punctuation" && g.content === "{" ? y[y.length - 1].openedBraces++ : 0 < y.length && 0 < y[y.length - 1].openedBraces && g.type === "punctuation" && g.content === "}" ? y[y.length - 1].openedBraces-- : v = !0), (v || typeof g == "string") && 0 < y.length && y[y.length - 1].openedBraces === 0 && (v = d(g), h < p.length - 1 && (typeof p[h + 1] == "string" || p[h + 1].type === "plain-text") && (v += d(p[h + 1]), p.splice(h + 1, 1)), 0 < h && (typeof p[h - 1] == "string" || p[h - 1].type === "plain-text") && (v = d(p[h - 1]) + v, p.splice(h - 1, 1), h--), p[h] = new e.Token("plain-text", v, null, v)), g.content && typeof g.content != "string" && c(g.content);
+    }
+  }
+  var d = function(p) {
+    return p ? typeof p == "string" ? p : typeof p.content == "string" ? p.content : p.content.map(d).join("") : "";
+  };
+  e.hooks.add("after-tokenize", function(p) {
+    p.language !== "jsx" && p.language !== "tsx" || c(p.tokens);
+  });
+}(o), function(e) {
+  var t = e.util.clone(e.languages.typescript), t = (e.languages.tsx = e.languages.extend("jsx", t), delete e.languages.tsx.parameter, delete e.languages.tsx["literal-property"], e.languages.tsx.tag);
+  t.pattern = RegExp(/(^|[^\w$]|(?=<\/))/.source + "(?:" + t.pattern.source + ")", t.pattern.flags), t.lookbehind = !0;
+}(o), o.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: /[{}[\]();,.:\\]/ }, o.languages.swift["string-literal"].forEach(function(e) {
+  e.inside.interpolation.inside = o.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 t = { "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: t }, string: /[\s\S]+/ } }, { pattern: /"(?:[^"\\\r\n$]|\\.|\$(?:(?!\{)|\{[^{}]*\}))*"/, alias: "singleline", inside: { interpolation: { pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:[a-z_]\w*|\{[^{}]*\})/i, lookbehind: !0, inside: t }, 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;
+}(o), o.languages.c = o.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|[?:~]|[-+*/%&|^!=<>]=?/ }), o.languages.insertBefore("c", "string", { char: { pattern: /'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n]){0,32}'/, greedy: !0 } }), o.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 }, o.languages.c.string], char: o.languages.c.char, comment: o.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: o.languages.c } } } }), o.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 o.languages.c.boolean, o.languages.objectivec = o.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 o.languages.objectivec["class-name"], o.languages.objc = o.languages.objectivec, o.languages.reason = o.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/ }), o.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 o.languages.reason.function, function(e) {
+  for (var t = /\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|<self>)*\*\//.source, r = 0; r < 2; r++)
+    t = t.replace(/<self>/g, function() {
+      return t;
+    });
+  t = t.replace(/<self>/g, function() {
+    return /[^\s\S]/.source;
+  }), e.languages.rust = { comment: [{ pattern: RegExp(/(^|[^\\])/.source + t), 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;
+}(o), o.languages.go = o.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/ }), o.languages.insertBefore("go", "string", { char: { pattern: /'(?:\\.|[^'\\\r\n]){0,10}'/, greedy: !0 } }), delete o.languages.go["class-name"], function(e) {
+  var t = /\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/, r = /\b(?!<keyword>)\w+(?:\s*\.\s*\w+)*\b/.source.replace(/<keyword>/g, function() {
+    return t.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 t.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: t, 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 r;
+  }) + ")"), 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"]);
+}(o), o.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: /[{}[\];(),.:]/ }, o.languages.python["string-interpolation"].inside.interpolation.inside.rest = o.languages.python, o.languages.py = o.languages.python;
+var ae = {};
+Ze(ae, {
+  dracula: () => Ve,
+  duotoneDark: () => Xe,
+  duotoneLight: () => Je,
+  github: () => tt,
+  jettwaveDark: () => xt,
+  jettwaveLight: () => At,
+  nightOwl: () => nt,
+  nightOwlLight: () => ot,
+  oceanicNext: () => it,
+  okaidia: () => ut,
+  oneDark: () => _t,
+  oneLight: () => Tt,
+  palenight: () => pt,
+  shadesOfPurple: () => gt,
+  synthwave84: () => ft,
+  ultramin: () => mt,
+  vsDark: () => we,
+  vsLight: () => kt
+});
+var Ye = {
+  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)"
+      }
+    }
+  ]
+}, Ve = Ye, Ke = {
+  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"
+      }
+    }
+  ]
+}, Xe = Ke, Qe = {
+  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"
+      }
+    }
+  ]
+}, Je = Qe, et = {
+  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"
+      }
+    }
+  ]
+}, tt = et, rt = {
+  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)"
+      }
+    }
+  ]
+}, nt = rt, at = {
+  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)"
+      }
+    }
+  ]
+}, ot = at, R = {
+  char: "#D8DEE9",
+  comment: "#999999",
+  keyword: "#c5a5c5",
+  primitive: "#5a9bcf",
+  string: "#8dc891",
+  variable: "#d7deea",
+  boolean: "#ff8b50",
+  punctuation: "#5FB3B3",
+  tag: "#fc929e",
+  function: "#79b6f2",
+  className: "#FAC863",
+  method: "#6699CC",
+  operator: "#fc929e"
+}, st = {
+  plain: {
+    backgroundColor: "#282c34",
+    color: "#ffffff"
+  },
+  styles: [
+    {
+      types: ["attr-name"],
+      style: {
+        color: R.keyword
+      }
+    },
+    {
+      types: ["attr-value"],
+      style: {
+        color: R.string
+      }
+    },
+    {
+      types: [
+        "comment",
+        "block-comment",
+        "prolog",
+        "doctype",
+        "cdata",
+        "shebang"
+      ],
+      style: {
+        color: R.comment
+      }
+    },
+    {
+      types: [
+        "property",
+        "number",
+        "function-name",
+        "constant",
+        "symbol",
+        "deleted"
+      ],
+      style: {
+        color: R.primitive
+      }
+    },
+    {
+      types: ["boolean"],
+      style: {
+        color: R.boolean
+      }
+    },
+    {
+      types: ["tag"],
+      style: {
+        color: R.tag
+      }
+    },
+    {
+      types: ["string"],
+      style: {
+        color: R.string
+      }
+    },
+    {
+      types: ["punctuation"],
+      style: {
+        color: R.string
+      }
+    },
+    {
+      types: ["selector", "char", "builtin", "inserted"],
+      style: {
+        color: R.char
+      }
+    },
+    {
+      types: ["function"],
+      style: {
+        color: R.function
+      }
+    },
+    {
+      types: ["operator", "entity", "url", "variable"],
+      style: {
+        color: R.variable
+      }
+    },
+    {
+      types: ["keyword"],
+      style: {
+        color: R.keyword
+      }
+    },
+    {
+      types: ["atrule", "class-name"],
+      style: {
+        color: R.className
+      }
+    },
+    {
+      types: ["important"],
+      style: {
+        fontWeight: "400"
+      }
+    },
+    {
+      types: ["bold"],
+      style: {
+        fontWeight: "bold"
+      }
+    },
+    {
+      types: ["italic"],
+      style: {
+        fontStyle: "italic"
+      }
+    },
+    {
+      types: ["namespace"],
+      style: {
+        opacity: 0.7
+      }
+    }
+  ]
+}, it = st, lt = {
+  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"
+      }
+    }
+  ]
+}, ut = lt, ct = {
+  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)"
+      }
+    }
+  ]
+}, pt = ct, dt = {
+  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)"
+      }
+    }
+  ]
+}, gt = dt, yt = {
+  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"
+      }
+    }
+  ]
+}, ft = yt, bt = {
+  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)"
+      }
+    }
+  ]
+}, mt = bt, ht = {
+  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)"
+      }
+    }
+  ]
+}, we = ht, vt = {
+  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)"
+      }
+    }
+  ]
+}, kt = vt, wt = {
+  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"
+      }
+    }
+  ]
+}, xt = wt, Et = {
+  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"
+      }
+    }
+  ]
+}, At = Et, St = {
+  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%)"
+      }
+    }
+  ]
+}, _t = St, Ft = {
+  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%)"
+      }
+    }
+  ]
+}, Tt = Ft, Rt = (e, t) => {
+  const { plain: r } = e, i = e.styles.reduce((l, b) => {
+    const { languages: c, style: d } = b;
+    return c && !c.includes(t) || b.types.forEach((p) => {
+      const y = O(O({}, l[p]), d);
+      l[p] = y;
+    }), l;
+  }, {});
+  return i.root = r, i.plain = J(O({}, r), { backgroundColor: void 0 }), i;
+}, ce = Rt, It = (e, t) => {
+  const [r, i] = X(
+    ce(t, e)
+  ), l = M(), b = M();
+  return G(() => {
+    (t !== l.current || e !== b.current) && (l.current = t, b.current = e, i(ce(t, e)));
+  }, [e, t]), r;
+}, Lt = (e) => Z(
+  (t) => {
+    var r = t, { className: i, style: l, line: b } = r, c = ke(r, ["className", "style", "line"]);
+    const d = J(O({}, c), {
+      className: be("token-line", i)
+    });
+    return typeof e == "object" && "plain" in e && (d.style = e.plain), typeof l == "object" && (d.style = O(O({}, d.style || {}), l)), d;
+  },
+  [e]
+), Ct = (e) => {
+  const t = Z(
+    ({ types: r, empty: i }) => {
+      if (e != null) {
+        {
+          if (r.length === 1 && r[0] === "plain")
+            return i != null ? { display: "inline-block" } : void 0;
+          if (r.length === 1 && i != null)
+            return e[r[0]];
+        }
+        return Object.assign(
+          i != null ? { display: "inline-block" } : {},
+          ...r.map((l) => e[l])
+        );
+      }
+    },
+    [e]
+  );
+  return Z(
+    (r) => {
+      var i = r, { token: l, className: b, style: c } = i, d = ke(i, ["token", "className", "style"]);
+      const p = J(O({}, d), {
+        className: be("token", ...l.types, b),
+        children: l.content,
+        style: t(l)
+      });
+      return c != null && (p.style = O(O({}, p.style || {}), c)), p;
+    },
+    [t]
+  );
+}, Ot = /\r\n|\r|\n/, pe = (e) => {
+  e.length === 0 ? e.push({
+    types: ["plain"],
+    content: `
+`,
+    empty: !0
+  }) : e.length === 1 && e[0].content === "" && (e[0].content = `
+`, e[0].empty = !0);
+}, de = (e, t) => {
+  const r = e.length;
+  return r > 0 && e[r - 1] === t ? e : e.concat(t);
+}, Nt = (e) => {
+  const t = [[]], r = [e], i = [0], l = [e.length];
+  let b = 0, c = 0, d = [];
+  const p = [d];
+  for (; c > -1; ) {
+    for (; (b = i[c]++) < l[c]; ) {
+      let y, h = t[c];
+      const v = r[c][b];
+      if (typeof v == "string" ? (h = c > 0 ? h : ["plain"], y = v) : (h = de(h, v.type), v.alias && (h = de(h, v.alias)), y = v.content), typeof y != "string") {
+        c++, t.push(h), r.push(y), i.push(0), l.push(y.length);
+        continue;
+      }
+      const x = y.split(Ot), a = x.length;
+      d.push({
+        types: h,
+        content: x[0]
+      });
+      for (let n = 1; n < a; n++)
+        pe(d), p.push(d = []), d.push({
+          types: h,
+          content: x[n]
+        });
+    }
+    c--, t.pop(), r.pop(), i.pop(), l.pop();
+  }
+  return pe(d), p;
+}, ge = Nt, Dt = ({ prism: e, code: t, grammar: r, language: i }) => {
+  const l = M(e);
+  return ne(() => {
+    if (r == null)
+      return ge([t]);
+    const b = {
+      code: t,
+      grammar: r,
+      language: i,
+      tokens: []
+    };
+    return l.current.hooks.run("before-tokenize", b), b.tokens = l.current.tokenize(t, r), l.current.hooks.run("after-tokenize", b), ge(b.tokens);
+  }, [t, r, i]);
+}, Bt = ({
+  children: e,
+  language: t,
+  code: r,
+  theme: i,
+  prism: l
+}) => {
+  const b = t.toLowerCase(), c = It(b, i), d = Lt(c), p = Ct(c), y = l.languages[b], h = Dt({ prism: l, language: b, code: r, grammar: y });
+  return e({
+    tokens: h,
+    className: `prism-code language-${b}`,
+    style: c != null ? c.root : {},
+    getLineProps: d,
+    getTokenProps: p
+  });
+}, jt = (e) => Te(Bt, J(O({}, e), {
+  prism: e.prism || o,
+  theme: e.theme || we,
+  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
+   *)
+*/
+const xe = ye([
+  !1,
+  () => {
+  }
+]), $t = () => {
+  const e = fe(xe);
+  if (!e)
+    throw new Error("useTheme must be used within a ThemeProvider");
+  return e;
+}, qt = (e) => {
+  const [t, r] = X(!1);
+  G(() => {
+    const b = localStorage.getItem("theme"), c = window.matchMedia("(prefers-color-scheme: dark)"), d = b === "dark" || !b && c.matches;
+    r(d);
+  }, [t]);
+  const i = Z(() => {
+    const b = !t;
+    document.documentElement.classList.toggle("dark", b), localStorage.setItem("theme", b ? "dark" : "light"), r(b);
+  }, [t]), l = [t, i];
+  return /* @__PURE__ */ k.jsx(xe.Provider, { value: l, ...e });
+};
+globalThis.Prism = o, import("./prism-bash.min-DadFsM4Z.js"), import("./prism-ruby.min-C7LwcKyz.js"), import("./prism-markup-templating-DZrrEs0A.js"), import("./prism-php.min-o7FpoMP_.js"), import("./prism-json.min-B1GJqK1k.js"), import("./prism-java.min-d5iT_mOd.js"), import("./prism-csharp.min-Yizuc34Y.js"), import("./prism-objectivec.min-BXSWqpJJ.js");
+const Pt = ({
+  copyable: e = !0,
+  ...t
+}) => {
+  const [r] = $t(), [i, l] = X(!1);
+  return t.code ? /* @__PURE__ */ k.jsx(jt, { theme: r ? ae.vsDark : ae.github, ...t, children: ({ className: b, style: c, tokens: d, getLineProps: p, getTokenProps: y }) => /* @__PURE__ */ k.jsxs(
+    "pre",
+    {
+      className: z(
+        "group relative",
+        b,
+        t.className,
+        t.noBackground && "!bg-transparent",
+        t.wrapLines && "whitespace-pre-wrap break-words"
+      ),
+      style: c,
+      children: [
+        e && /* @__PURE__ */ k.jsx(
+          "button",
+          {
+            type: "button",
+            "aria-label": "Copy code",
+            className: "absolute top-1.5 right-3 p-3 opacity-0 group-hover:opacity-100 transition hover:bg-zinc-500/10 hover:dark:bg-zinc-700/25 rounded-lg text-sm text-gray-400 hover:text-gray-600 dark:text-gray-500 dark:hover:text-gray-400",
+            disabled: i,
+            onClick: () => {
+              l(!0), navigator.clipboard.writeText(
+                d.map((h) => h.map(({ content: g }) => g).join("")).join(`
+`)
+              ), setTimeout(() => l(!1), 2e3);
+            },
+            children: i ? /* @__PURE__ */ k.jsx(_e, { className: "text-emerald-600", size: 18 }) : /* @__PURE__ */ k.jsx(Re, { size: 18 })
+          }
+        ),
+        t.showLanguageIndicator && /* @__PURE__ */ k.jsx("span", { className: "absolute top-1.5 right-3 text-[11px] font-mono text-muted-foreground transition group-hover:opacity-0", children: t.language }),
+        d.map((h, g) => /* @__PURE__ */ k.jsx("div", { ...p({ line: h }), children: h.map((v, x) => /* @__PURE__ */ k.jsx("span", { ...y({ token: v }) }, x)) }, g))
+      ]
+    }
+  ) }) : null;
+}, Ht = {
+  img: (e) => /\.(mp4|webm|mov|avi)$/.test(e.src ?? "") ? /* @__PURE__ */ k.jsx("video", { src: e.src, controls: !0, playsInline: !0, autoPlay: !0, loop: !0 }) : /* @__PURE__ */ k.jsx("img", { ...e, className: "rounded-md" }),
+  h1: ({ children: e, id: t }) => /* @__PURE__ */ k.jsx(P, { level: 1, id: t, children: e }),
+  h2: ({ children: e, id: t }) => /* @__PURE__ */ k.jsx(P, { level: 2, id: t, children: e }),
+  h3: ({ children: e, id: t }) => /* @__PURE__ */ k.jsx(P, { level: 3, id: t, children: e }),
+  h4: ({ children: e, id: t }) => /* @__PURE__ */ k.jsx(P, { level: 4, id: t, children: e }),
+  h5: ({ children: e, id: t }) => /* @__PURE__ */ k.jsx(P, { level: 5, id: t, children: e }),
+  h6: ({ children: e, id: t }) => /* @__PURE__ */ k.jsx(P, { level: 6, id: t, children: e }),
+  a: ({ href: e, ...t }) => e && !e.startsWith("http") ? /* @__PURE__ */ k.jsx(Fe, { to: e, relative: "path", ...t }) : /* @__PURE__ */ k.jsx("a", { href: e, target: "_blank", ...t, rel: "noreferrer" }),
+  Callout: j,
+  tip: (e) => /* @__PURE__ */ k.jsx(j, { type: "tip", ...e }),
+  info: (e) => /* @__PURE__ */ k.jsx(j, { type: "info", ...e }),
+  note: (e) => /* @__PURE__ */ k.jsx(j, { type: "note", ...e }),
+  caution: (e) => /* @__PURE__ */ k.jsx(j, { type: "caution", ...e }),
+  warning: (e) => /* @__PURE__ */ k.jsx(j, { type: "caution", ...e }),
+  danger: (e) => /* @__PURE__ */ k.jsx(j, { type: "danger", ...e }),
+  pre: ({ children: e }) => /* @__PURE__ */ k.jsx(k.Fragment, { children: e }),
+  code: ({ className: e, children: t, ...r }) => {
+    if (!r.inline) {
+      const l = e == null ? void 0 : e.match(/language?-(\w+)/);
+      return /* @__PURE__ */ k.jsx(
+        Pt,
+        {
+          language: (l == null ? void 0 : l[1]) ?? "markup",
+          className: "rounded-xl overflow-x-auto p-4 border border-border dark:!bg-foreground/10 dark:border-transparent",
+          showLanguageIndicator: !0,
+          code: String(t).trim()
+        }
+      );
+    }
+    return /* @__PURE__ */ k.jsx(
+      "code",
+      {
+        className: z(
+          e,
+          "font-mono border border-border p-1 py-0.5 rounded bg-border/50 dark:bg-border/70 whitespace-nowrap"
+        ),
+        children: t
+      }
+    );
+  }
+};
+export {
+  j as C,
+  P as H,
+  Ht as M,
+  Pt as S,
+  qt as T,
+  Zt as V,
+  Ne as a,
+  Ce as b,
+  $t as u
+};
+//# sourceMappingURL=MdxComponents-C0R6zobS.js.map