react-email 1.0.8 → 1.0.9

package/preview/.next/static/chunks/727-0b09744222e89df8.js

@@ -0,0 +1,4402 @@
+(self.webpackChunk_N_E = self.webpackChunk_N_E || []).push([
+  [727],
+  {
+    6652: function (e, t, n) {
+      'use strict';
+      function a(e, t, { checkForDefaultPrevented: n = !0 } = {}) {
+        return function (a) {
+          if ((null == e || e(a), !1 === n || !a.defaultPrevented))
+            return null == t ? void 0 : t(a);
+        };
+      }
+      n.d(t, {
+        M: function () {
+          return a;
+        },
+      });
+    },
+    6413: function (e, t, n) {
+      'use strict';
+      n.d(t, {
+        VY: function () {
+          return I;
+        },
+        fC: function () {
+          return T;
+        },
+        xz: function () {
+          return R;
+        },
+      });
+      var a = n(7462),
+        r = n(7294),
+        o = n(6652),
+        i = n(2707),
+        s = n(9920),
+        l = n(9563),
+        u = n(7255),
+        c = n(192),
+        d = n(3935);
+      let p = (e) => {
+        let { present: t, children: n } = e,
+          a = (function (e) {
+            var t;
+            let [n, a] = (0, r.useState)(),
+              o = (0, r.useRef)({}),
+              i = (0, r.useRef)(e),
+              s = (0, r.useRef)('none'),
+              [u, c] =
+                ((t = {
+                  mounted: {
+                    UNMOUNT: 'unmounted',
+                    ANIMATION_OUT: 'unmountSuspended',
+                  },
+                  unmountSuspended: {
+                    MOUNT: 'mounted',
+                    ANIMATION_END: 'unmounted',
+                  },
+                  unmounted: { MOUNT: 'mounted' },
+                }),
+                (0, r.useReducer)(
+                  (e, n) => {
+                    let a = t[e][n];
+                    return null != a ? a : e;
+                  },
+                  e ? 'mounted' : 'unmounted',
+                ));
+            return (
+              (0, r.useEffect)(() => {
+                let e = g(o.current);
+                s.current = 'mounted' === u ? e : 'none';
+              }, [u]),
+              (0, l.b)(() => {
+                let t = o.current,
+                  n = i.current;
+                if (n !== e) {
+                  let a = s.current,
+                    r = g(t);
+                  e
+                    ? c('MOUNT')
+                    : 'none' === r ||
+                      (null == t ? void 0 : t.display) === 'none'
+                    ? c('UNMOUNT')
+                    : n && a !== r
+                    ? c('ANIMATION_OUT')
+                    : c('UNMOUNT'),
+                    (i.current = e);
+                }
+              }, [e, c]),
+              (0, l.b)(() => {
+                if (n) {
+                  let e = (e) => {
+                      let t = g(o.current),
+                        a = t.includes(e.animationName);
+                      e.target === n &&
+                        a &&
+                        (0, d.flushSync)(() => c('ANIMATION_END'));
+                    },
+                    t = (e) => {
+                      e.target === n && (s.current = g(o.current));
+                    };
+                  return (
+                    n.addEventListener('animationstart', t),
+                    n.addEventListener('animationcancel', e),
+                    n.addEventListener('animationend', e),
+                    () => {
+                      n.removeEventListener('animationstart', t),
+                        n.removeEventListener('animationcancel', e),
+                        n.removeEventListener('animationend', e);
+                    }
+                  );
+                }
+                c('ANIMATION_END');
+              }, [n, c]),
+              {
+                isPresent: ['mounted', 'unmountSuspended'].includes(u),
+                ref: (0, r.useCallback)((e) => {
+                  e && (o.current = getComputedStyle(e)), a(e);
+                }, []),
+              }
+            );
+          })(t),
+          o =
+            'function' == typeof n
+              ? n({ present: a.isPresent })
+              : r.Children.only(n),
+          i = (0, u.e)(a.ref, o.ref);
+        return 'function' == typeof n || a.isPresent
+          ? (0, r.cloneElement)(o, { ref: i })
+          : null;
+      };
+      function g(e) {
+        return (null == e ? void 0 : e.animationName) || 'none';
+      }
+      p.displayName = 'Presence';
+      var f = n(6195);
+      let m = 'Collapsible',
+        [b, h] = (0, i.b)(m),
+        [y, v] = b(m),
+        E = (0, r.forwardRef)((e, t) => {
+          let {
+              __scopeCollapsible: n,
+              open: o,
+              defaultOpen: i,
+              disabled: l,
+              onOpenChange: u,
+              ...d
+            } = e,
+            [p = !1, g] = (0, s.T)({ prop: o, defaultProp: i, onChange: u });
+          return (0, r.createElement)(
+            y,
+            {
+              scope: n,
+              disabled: l,
+              contentId: (0, f.M)(),
+              open: p,
+              onOpenToggle: (0, r.useCallback)(() => g((e) => !e), [g]),
+            },
+            (0, r.createElement)(
+              c.WV.div,
+              (0, a.Z)(
+                { 'data-state': _(p), 'data-disabled': l ? '' : void 0 },
+                d,
+                { ref: t },
+              ),
+            ),
+          );
+        }),
+        k = (0, r.forwardRef)((e, t) => {
+          let { __scopeCollapsible: n, ...i } = e,
+            s = v('CollapsibleTrigger', n);
+          return (0, r.createElement)(
+            c.WV.button,
+            (0, a.Z)(
+              {
+                'type': 'button',
+                'aria-controls': s.contentId,
+                'aria-expanded': s.open || !1,
+                'data-state': _(s.open),
+                'data-disabled': s.disabled ? '' : void 0,
+                'disabled': s.disabled,
+              },
+              i,
+              { ref: t, onClick: (0, o.M)(e.onClick, s.onOpenToggle) },
+            ),
+          );
+        }),
+        S = 'CollapsibleContent',
+        w = (0, r.forwardRef)((e, t) => {
+          let { forceMount: n, ...o } = e,
+            i = v(S, e.__scopeCollapsible);
+          return (0, r.createElement)(
+            p,
+            { present: n || i.open },
+            ({ present: e }) =>
+              (0, r.createElement)(A, (0, a.Z)({}, o, { ref: t, present: e })),
+          );
+        }),
+        A = (0, r.forwardRef)((e, t) => {
+          let { __scopeCollapsible: n, present: o, children: i, ...s } = e,
+            d = v(S, n),
+            [p, g] = (0, r.useState)(o),
+            f = (0, r.useRef)(null),
+            m = (0, u.e)(t, f),
+            b = (0, r.useRef)(0),
+            h = b.current,
+            y = (0, r.useRef)(0),
+            E = y.current,
+            k = d.open || p,
+            w = (0, r.useRef)(k),
+            A = (0, r.useRef)();
+          return (
+            (0, r.useEffect)(() => {
+              let e = requestAnimationFrame(() => (w.current = !1));
+              return () => cancelAnimationFrame(e);
+            }, []),
+            (0, l.b)(() => {
+              let e = f.current;
+              if (e) {
+                (A.current = A.current || {
+                  transitionDuration: e.style.transitionDuration,
+                  animationName: e.style.animationName,
+                }),
+                  (e.style.transitionDuration = '0s'),
+                  (e.style.animationName = 'none');
+                let t = e.getBoundingClientRect();
+                (b.current = t.height),
+                  (y.current = t.width),
+                  w.current ||
+                    ((e.style.transitionDuration =
+                      A.current.transitionDuration),
+                    (e.style.animationName = A.current.animationName)),
+                  g(o);
+              }
+            }, [d.open, o]),
+            (0, r.createElement)(
+              c.WV.div,
+              (0, a.Z)(
+                {
+                  'data-state': _(d.open),
+                  'data-disabled': d.disabled ? '' : void 0,
+                  'id': d.contentId,
+                  'hidden': !k,
+                },
+                s,
+                {
+                  ref: m,
+                  style: {
+                    '--radix-collapsible-content-height': h ? `${h}px` : void 0,
+                    '--radix-collapsible-content-width': E ? `${E}px` : void 0,
+                    ...e.style,
+                  },
+                },
+              ),
+              k && i,
+            )
+          );
+        });
+      function _(e) {
+        return e ? 'open' : 'closed';
+      }
+      let T = E,
+        R = k,
+        I = w;
+    },
+    7255: function (e, t, n) {
+      'use strict';
+      n.d(t, {
+        F: function () {
+          return r;
+        },
+        e: function () {
+          return o;
+        },
+      });
+      var a = n(7294);
+      function r(...e) {
+        return (t) =>
+          e.forEach((e) => {
+            var n;
+            'function' == typeof (n = e) ? n(t) : null != n && (n.current = t);
+          });
+      }
+      function o(...e) {
+        return (0, a.useCallback)(r(...e), e);
+      }
+    },
+    2707: function (e, t, n) {
+      'use strict';
+      n.d(t, {
+        b: function () {
+          return r;
+        },
+      });
+      var a = n(7294);
+      function r(e, t = []) {
+        let n = [],
+          r = () => {
+            let t = n.map((e) => (0, a.createContext)(e));
+            return function (n) {
+              let r = (null == n ? void 0 : n[e]) || t;
+              return (0, a.useMemo)(
+                () => ({ [`__scope${e}`]: { ...n, [e]: r } }),
+                [n, r],
+              );
+            };
+          };
+        return (
+          (r.scopeName = e),
+          [
+            function (t, r) {
+              let o = (0, a.createContext)(r),
+                i = n.length;
+              function s(t) {
+                let { scope: n, children: r, ...s } = t,
+                  l = (null == n ? void 0 : n[e][i]) || o,
+                  u = (0, a.useMemo)(() => s, Object.values(s));
+                return (0, a.createElement)(l.Provider, { value: u }, r);
+              }
+              return (
+                (n = [...n, r]),
+                (s.displayName = t + 'Provider'),
+                [
+                  s,
+                  function (n, s) {
+                    let l = (null == s ? void 0 : s[e][i]) || o,
+                      u = (0, a.useContext)(l);
+                    if (u) return u;
+                    if (void 0 !== r) return r;
+                    throw Error(`\`${n}\` must be used within \`${t}\``);
+                  },
+                ]
+              );
+            },
+            (function (...e) {
+              let t = e[0];
+              if (1 === e.length) return t;
+              let n = () => {
+                let n = e.map((e) => ({
+                  useScope: e(),
+                  scopeName: e.scopeName,
+                }));
+                return function (e) {
+                  let r = n.reduce((t, { useScope: n, scopeName: a }) => {
+                    let r = n(e),
+                      o = r[`__scope${a}`];
+                    return { ...t, ...o };
+                  }, {});
+                  return (0, a.useMemo)(
+                    () => ({ [`__scope${t.scopeName}`]: r }),
+                    [r],
+                  );
+                };
+              };
+              return (n.scopeName = t.scopeName), n;
+            })(r, ...t),
+          ]
+        );
+      }
+    },
+    6195: function (e, t, n) {
+      'use strict';
+      n.d(t, {
+        M: function () {
+          return l;
+        },
+      });
+      var a,
+        r = n(7294),
+        o = n(9563);
+      let i = (a || (a = n.t(r, 2)))['useId'.toString()] || (() => void 0),
+        s = 0;
+      function l(e) {
+        let [t, n] = r.useState(i());
+        return (
+          (0, o.b)(() => {
+            e || n((e) => (null != e ? e : String(s++)));
+          }, [e]),
+          e || (t ? `radix-${t}` : '')
+        );
+      }
+    },
+    192: function (e, t, n) {
+      'use strict';
+      n.d(t, {
+        WV: function () {
+          return i;
+        },
+      });
+      var a = n(7462),
+        r = n(7294);
+      n(3935);
+      var o = n(8820);
+      let i = [
+        'a',
+        'button',
+        'div',
+        'h2',
+        'h3',
+        'img',
+        'label',
+        'li',
+        'nav',
+        'ol',
+        'p',
+        'span',
+        'svg',
+        'ul',
+      ].reduce((e, t) => {
+        let n = (0, r.forwardRef)((e, n) => {
+          let { asChild: i, ...s } = e,
+            l = i ? o.g7 : t;
+          return (
+            (0, r.useEffect)(() => {
+              window[Symbol.for('radix-ui')] = !0;
+            }, []),
+            (0, r.createElement)(l, (0, a.Z)({}, s, { ref: n }))
+          );
+        });
+        return (n.displayName = `Primitive.${t}`), { ...e, [t]: n };
+      }, {});
+    },
+    8820: function (e, t, n) {
+      'use strict';
+      n.d(t, {
+        A4: function () {
+          return l;
+        },
+        g7: function () {
+          return i;
+        },
+      });
+      var a = n(7462),
+        r = n(7294),
+        o = n(7255);
+      let i = (0, r.forwardRef)((e, t) => {
+        let { children: n, ...o } = e,
+          i = r.Children.toArray(n),
+          l = i.find(u);
+        if (l) {
+          let c = l.props.children,
+            d = i.map((e) =>
+              e !== l
+                ? e
+                : r.Children.count(c) > 1
+                ? r.Children.only(null)
+                : (0, r.isValidElement)(c)
+                ? c.props.children
+                : null,
+            );
+          return (0, r.createElement)(
+            s,
+            (0, a.Z)({}, o, { ref: t }),
+            (0, r.isValidElement)(c) ? (0, r.cloneElement)(c, void 0, d) : null,
+          );
+        }
+        return (0, r.createElement)(s, (0, a.Z)({}, o, { ref: t }), n);
+      });
+      i.displayName = 'Slot';
+      let s = (0, r.forwardRef)((e, t) => {
+        let { children: n, ...a } = e;
+        return (0, r.isValidElement)(n)
+          ? (0, r.cloneElement)(n, {
+              ...(function (e, t) {
+                let n = { ...t };
+                for (let a in t) {
+                  let r = e[a],
+                    o = t[a],
+                    i = /^on[A-Z]/.test(a);
+                  i
+                    ? r && o
+                      ? (n[a] = (...e) => {
+                          o(...e), r(...e);
+                        })
+                      : r && (n[a] = r)
+                    : 'style' === a
+                    ? (n[a] = { ...r, ...o })
+                    : 'className' === a &&
+                      (n[a] = [r, o].filter(Boolean).join(' '));
+                }
+                return { ...e, ...n };
+              })(a, n.props),
+              ref: (0, o.F)(t, n.ref),
+            })
+          : r.Children.count(n) > 1
+          ? r.Children.only(null)
+          : null;
+      });
+      s.displayName = 'SlotClone';
+      let l = ({ children: e }) => (0, r.createElement)(r.Fragment, null, e);
+      function u(e) {
+        return (0, r.isValidElement)(e) && e.type === l;
+      }
+    },
+    3273: function (e, t, n) {
+      'use strict';
+      n.d(t, {
+        ck: function () {
+          return q;
+        },
+        fC: function () {
+          return W;
+        },
+      });
+      var a = n(7462),
+        r = n(7294),
+        o = n(2707),
+        i = n(192),
+        s = n(6652),
+        l = n(7255),
+        u = n(8820),
+        c = n(6195),
+        d = n(5355),
+        p = n(9920);
+      let g = (0, r.createContext)(void 0);
+      function f(e) {
+        let t = (0, r.useContext)(g);
+        return e || t || 'ltr';
+      }
+      let m = 'rovingFocusGroup.onEntryFocus',
+        b = { bubbles: !1, cancelable: !0 },
+        h = 'RovingFocusGroup',
+        [y, v, E] = (function (e) {
+          let t = e + 'CollectionProvider',
+            [n, a] = (0, o.b)(t),
+            [i, s] = n(t, {
+              collectionRef: { current: null },
+              itemMap: new Map(),
+            }),
+            c = (e) => {
+              let { scope: t, children: n } = e,
+                a = r.useRef(null),
+                o = r.useRef(new Map()).current;
+              return r.createElement(
+                i,
+                { scope: t, itemMap: o, collectionRef: a },
+                n,
+              );
+            },
+            d = e + 'CollectionSlot',
+            p = r.forwardRef((e, t) => {
+              let { scope: n, children: a } = e,
+                o = s(d, n),
+                i = (0, l.e)(t, o.collectionRef);
+              return r.createElement(u.g7, { ref: i }, a);
+            }),
+            g = e + 'CollectionItemSlot',
+            f = 'data-radix-collection-item',
+            m = r.forwardRef((e, t) => {
+              let { scope: n, children: a, ...o } = e,
+                i = r.useRef(null),
+                c = (0, l.e)(t, i),
+                d = s(g, n);
+              return (
+                r.useEffect(
+                  () => (
+                    d.itemMap.set(i, { ref: i, ...o }),
+                    () => void d.itemMap.delete(i)
+                  ),
+                ),
+                r.createElement(u.g7, { [f]: '', ref: c }, a)
+              );
+            });
+          return [
+            { Provider: c, Slot: p, ItemSlot: m },
+            function (t) {
+              let n = s(e + 'CollectionConsumer', t),
+                a = r.useCallback(() => {
+                  let e = n.collectionRef.current;
+                  if (!e) return [];
+                  let t = Array.from(e.querySelectorAll(`[${f}]`)),
+                    a = Array.from(n.itemMap.values()),
+                    r = a.sort(
+                      (e, n) =>
+                        t.indexOf(e.ref.current) - t.indexOf(n.ref.current),
+                    );
+                  return r;
+                }, [n.collectionRef, n.itemMap]);
+              return a;
+            },
+            a,
+          ];
+        })(h),
+        [k, S] = (0, o.b)(h, [E]),
+        [w, A] = k(h),
+        _ = (0, r.forwardRef)((e, t) =>
+          (0, r.createElement)(
+            y.Provider,
+            { scope: e.__scopeRovingFocusGroup },
+            (0, r.createElement)(
+              y.Slot,
+              { scope: e.__scopeRovingFocusGroup },
+              (0, r.createElement)(T, (0, a.Z)({}, e, { ref: t })),
+            ),
+          ),
+        ),
+        T = (0, r.forwardRef)((e, t) => {
+          let {
+              __scopeRovingFocusGroup: n,
+              orientation: o,
+              loop: u = !1,
+              dir: c,
+              currentTabStopId: g,
+              defaultCurrentTabStopId: h,
+              onCurrentTabStopIdChange: y,
+              onEntryFocus: E,
+              ...k
+            } = e,
+            S = (0, r.useRef)(null),
+            A = (0, l.e)(t, S),
+            _ = f(c),
+            [T = null, R] = (0, p.T)({ prop: g, defaultProp: h, onChange: y }),
+            [I, O] = (0, r.useState)(!1),
+            N = (0, d.W)(E),
+            F = v(n),
+            C = (0, r.useRef)(!1),
+            [L, D] = (0, r.useState)(0);
+          return (
+            (0, r.useEffect)(() => {
+              let e = S.current;
+              if (e)
+                return (
+                  e.addEventListener(m, N), () => e.removeEventListener(m, N)
+                );
+            }, [N]),
+            (0, r.createElement)(
+              w,
+              {
+                scope: n,
+                orientation: o,
+                dir: _,
+                loop: u,
+                currentTabStopId: T,
+                onItemFocus: (0, r.useCallback)((e) => R(e), [R]),
+                onItemShiftTab: (0, r.useCallback)(() => O(!0), []),
+                onFocusableItemAdd: (0, r.useCallback)(
+                  () => D((e) => e + 1),
+                  [],
+                ),
+                onFocusableItemRemove: (0, r.useCallback)(
+                  () => D((e) => e - 1),
+                  [],
+                ),
+              },
+              (0, r.createElement)(
+                i.WV.div,
+                (0, a.Z)(
+                  { 'tabIndex': I || 0 === L ? -1 : 0, 'data-orientation': o },
+                  k,
+                  {
+                    ref: A,
+                    style: { outline: 'none', ...e.style },
+                    onMouseDown: (0, s.M)(e.onMouseDown, () => {
+                      C.current = !0;
+                    }),
+                    onFocus: (0, s.M)(e.onFocus, (e) => {
+                      let t = !C.current;
+                      if (e.target === e.currentTarget && t && !I) {
+                        let n = new CustomEvent(m, b);
+                        if (
+                          (e.currentTarget.dispatchEvent(n),
+                          !n.defaultPrevented)
+                        ) {
+                          let a = F().filter((e) => e.focusable),
+                            r = a.find((e) => e.active),
+                            o = a.find((e) => e.id === T),
+                            i = [r, o, ...a].filter(Boolean),
+                            s = i.map((e) => e.ref.current);
+                          x(s);
+                        }
+                      }
+                      C.current = !1;
+                    }),
+                    onBlur: (0, s.M)(e.onBlur, () => O(!1)),
+                  },
+                ),
+              ),
+            )
+          );
+        }),
+        R = (0, r.forwardRef)((e, t) => {
+          let {
+              __scopeRovingFocusGroup: n,
+              focusable: o = !0,
+              active: l = !1,
+              ...u
+            } = e,
+            d = (0, c.M)(),
+            p = A('RovingFocusGroupItem', n),
+            g = p.currentTabStopId === d,
+            f = v(n),
+            { onFocusableItemAdd: m, onFocusableItemRemove: b } = p;
+          return (
+            (0, r.useEffect)(() => {
+              if (o) return m(), () => b();
+            }, [o, m, b]),
+            (0, r.createElement)(
+              y.ItemSlot,
+              { scope: n, id: d, focusable: o, active: l },
+              (0, r.createElement)(
+                i.WV.span,
+                (0, a.Z)(
+                  { 'tabIndex': g ? 0 : -1, 'data-orientation': p.orientation },
+                  u,
+                  {
+                    ref: t,
+                    onMouseDown: (0, s.M)(e.onMouseDown, (e) => {
+                      o ? p.onItemFocus(d) : e.preventDefault();
+                    }),
+                    onFocus: (0, s.M)(e.onFocus, () => p.onItemFocus(d)),
+                    onKeyDown: (0, s.M)(e.onKeyDown, (e) => {
+                      if ('Tab' === e.key && e.shiftKey) {
+                        p.onItemShiftTab();
+                        return;
+                      }
+                      if (e.target !== e.currentTarget) return;
+                      let t = (function (e, t, n) {
+                        var a;
+                        let r =
+                          ((a = e.key),
+                          'rtl' !== n
+                            ? a
+                            : 'ArrowLeft' === a
+                            ? 'ArrowRight'
+                            : 'ArrowRight' === a
+                            ? 'ArrowLeft'
+                            : a);
+                        if (
+                          !(
+                            'vertical' === t &&
+                            ['ArrowLeft', 'ArrowRight'].includes(r)
+                          ) &&
+                          !(
+                            'horizontal' === t &&
+                            ['ArrowUp', 'ArrowDown'].includes(r)
+                          )
+                        )
+                          return I[r];
+                      })(e, p.orientation, p.dir);
+                      if (void 0 !== t) {
+                        e.preventDefault();
+                        let n = f().filter((e) => e.focusable),
+                          a = n.map((e) => e.ref.current);
+                        if ('last' === t) a.reverse();
+                        else if ('prev' === t || 'next' === t) {
+                          var r, o;
+                          'prev' === t && a.reverse();
+                          let i = a.indexOf(e.currentTarget);
+                          a = p.loop
+                            ? ((r = a),
+                              (o = i + 1),
+                              r.map((e, t) => r[(o + t) % r.length]))
+                            : a.slice(i + 1);
+                        }
+                        setTimeout(() => x(a));
+                      }
+                    }),
+                  },
+                ),
+              ),
+            )
+          );
+        }),
+        I = {
+          ArrowLeft: 'prev',
+          ArrowUp: 'prev',
+          ArrowRight: 'next',
+          ArrowDown: 'next',
+          PageUp: 'first',
+          Home: 'first',
+          PageDown: 'last',
+          End: 'last',
+        };
+      function x(e) {
+        let t = document.activeElement;
+        for (let n of e)
+          if (n === t || (n.focus(), document.activeElement !== t)) return;
+      }
+      let O = (0, r.forwardRef)((e, t) => {
+          let {
+              pressed: n,
+              defaultPressed: o = !1,
+              onPressedChange: l,
+              ...u
+            } = e,
+            [c = !1, d] = (0, p.T)({ prop: n, onChange: l, defaultProp: o });
+          return (0, r.createElement)(
+            i.WV.button,
+            (0, a.Z)(
+              {
+                'type': 'button',
+                'aria-pressed': c,
+                'data-state': c ? 'on' : 'off',
+                'data-disabled': e.disabled ? '' : void 0,
+              },
+              u,
+              {
+                ref: t,
+                onClick: (0, s.M)(e.onClick, () => {
+                  e.disabled || d(!c);
+                }),
+              },
+            ),
+          );
+        }),
+        N = 'ToggleGroup',
+        [F, C] = (0, o.b)(N, [S]),
+        L = S(),
+        D = r.forwardRef((e, t) => {
+          let { type: n, ...o } = e;
+          if ('single' === n)
+            return r.createElement(M, (0, a.Z)({}, o, { ref: t }));
+          if ('multiple' === n)
+            return r.createElement($, (0, a.Z)({}, o, { ref: t }));
+          throw Error(`Missing prop \`type\` expected on \`${N}\``);
+        }),
+        [P, B] = F(N),
+        M = r.forwardRef((e, t) => {
+          let {
+              value: n,
+              defaultValue: o,
+              onValueChange: i = () => {},
+              ...s
+            } = e,
+            [l, u] = (0, p.T)({ prop: n, defaultProp: o, onChange: i });
+          return r.createElement(
+            P,
+            {
+              scope: e.__scopeToggleGroup,
+              type: 'single',
+              value: l ? [l] : [],
+              onItemActivate: u,
+              onItemDeactivate: r.useCallback(() => u(''), [u]),
+            },
+            r.createElement(j, (0, a.Z)({}, s, { ref: t })),
+          );
+        }),
+        $ = r.forwardRef((e, t) => {
+          let {
+              value: n,
+              defaultValue: o,
+              onValueChange: i = () => {},
+              ...s
+            } = e,
+            [l = [], u] = (0, p.T)({ prop: n, defaultProp: o, onChange: i }),
+            c = r.useCallback((e) => u((t = []) => [...t, e]), [u]),
+            d = r.useCallback(
+              (e) => u((t = []) => t.filter((t) => t !== e)),
+              [u],
+            );
+          return r.createElement(
+            P,
+            {
+              scope: e.__scopeToggleGroup,
+              type: 'multiple',
+              value: l,
+              onItemActivate: c,
+              onItemDeactivate: d,
+            },
+            r.createElement(j, (0, a.Z)({}, s, { ref: t })),
+          );
+        }),
+        [G, U] = F(N),
+        j = r.forwardRef((e, t) => {
+          let {
+              __scopeToggleGroup: n,
+              disabled: o = !1,
+              rovingFocus: s = !0,
+              orientation: l,
+              dir: u,
+              loop: c = !0,
+              ...d
+            } = e,
+            p = L(n),
+            g = f(u),
+            m = { role: 'group', dir: g, ...d };
+          return r.createElement(
+            G,
+            { scope: n, rovingFocus: s, disabled: o },
+            s
+              ? r.createElement(
+                  _,
+                  (0, a.Z)({ asChild: !0 }, p, {
+                    orientation: l,
+                    dir: g,
+                    loop: c,
+                  }),
+                  r.createElement(i.WV.div, (0, a.Z)({}, m, { ref: t })),
+                )
+              : r.createElement(i.WV.div, (0, a.Z)({}, m, { ref: t })),
+          );
+        }),
+        z = 'ToggleGroupItem',
+        H = r.forwardRef((e, t) => {
+          let n = B(z, e.__scopeToggleGroup),
+            o = U(z, e.__scopeToggleGroup),
+            i = L(e.__scopeToggleGroup),
+            s = n.value.includes(e.value),
+            l = o.disabled || e.disabled,
+            u = { ...e, pressed: s, disabled: l },
+            c = r.useRef(null);
+          return o.rovingFocus
+            ? r.createElement(
+                R,
+                (0, a.Z)({ asChild: !0 }, i, {
+                  focusable: !l,
+                  active: s,
+                  ref: c,
+                }),
+                r.createElement(Z, (0, a.Z)({}, u, { ref: t })),
+              )
+            : r.createElement(Z, (0, a.Z)({}, u, { ref: t }));
+        }),
+        Z = r.forwardRef((e, t) => {
+          let { __scopeToggleGroup: n, value: o, ...i } = e,
+            s = B(z, n),
+            l = {
+              'role': 'radio',
+              'aria-checked': e.pressed,
+              'aria-pressed': void 0,
+            },
+            u = 'single' === s.type ? l : void 0;
+          return r.createElement(
+            O,
+            (0, a.Z)({}, u, i, {
+              ref: t,
+              onPressedChange(e) {
+                e ? s.onItemActivate(o) : s.onItemDeactivate(o);
+              },
+            }),
+          );
+        }),
+        W = D,
+        q = H;
+    },
+    5355: function (e, t, n) {
+      'use strict';
+      n.d(t, {
+        W: function () {
+          return r;
+        },
+      });
+      var a = n(7294);
+      function r(e) {
+        let t = (0, a.useRef)(e);
+        return (
+          (0, a.useEffect)(() => {
+            t.current = e;
+          }),
+          (0, a.useMemo)(
+            () =>
+              (...e) => {
+                var n;
+                return null === (n = t.current) || void 0 === n
+                  ? void 0
+                  : n.call(t, ...e);
+              },
+            [],
+          )
+        );
+      }
+    },
+    9920: function (e, t, n) {
+      'use strict';
+      n.d(t, {
+        T: function () {
+          return o;
+        },
+      });
+      var a = n(7294),
+        r = n(5355);
+      function o({ prop: e, defaultProp: t, onChange: n = () => {} }) {
+        let [o, i] = (function ({ defaultProp: e, onChange: t }) {
+            let n = (0, a.useState)(e),
+              [o] = n,
+              i = (0, a.useRef)(o),
+              s = (0, r.W)(t);
+            return (
+              (0, a.useEffect)(() => {
+                i.current !== o && (s(o), (i.current = o));
+              }, [o, i, s]),
+              n
+            );
+          })({ defaultProp: t, onChange: n }),
+          s = void 0 !== e,
+          l = (0, r.W)(n),
+          u = (0, a.useCallback)(
+            (t) => {
+              if (s) {
+                let n = 'function' == typeof t ? t(e) : t;
+                n !== e && l(n);
+              } else i(t);
+            },
+            [s, e, i, l],
+          );
+        return [s ? e : o, u];
+      }
+    },
+    9563: function (e, t, n) {
+      'use strict';
+      n.d(t, {
+        b: function () {
+          return r;
+        },
+      });
+      var a = n(7294);
+      let r = Boolean(null == globalThis ? void 0 : globalThis.document)
+        ? a.useLayoutEffect
+        : () => {};
+    },
+    227: function (e, t) {
+      'use strict';
+      Object.defineProperty(t, '__esModule', { value: !0 }),
+        (t.getDomainLocale = function (e, t, n, a) {
+          return !1;
+        }),
+        ('function' == typeof t.default ||
+          ('object' == typeof t.default && null !== t.default)) &&
+          void 0 === t.default.__esModule &&
+          (Object.defineProperty(t.default, '__esModule', { value: !0 }),
+          Object.assign(t.default, t),
+          (e.exports = t.default));
+    },
+    1551: function (e, t, n) {
+      'use strict';
+      Object.defineProperty(t, '__esModule', { value: !0 }),
+        (t.default = void 0);
+      var a = n(2648).Z,
+        r = n(7273).Z,
+        o = a(n(7294)),
+        i = n(1003),
+        s = n(7795),
+        l = n(4465),
+        u = n(2692),
+        c = n(8245),
+        d = n(9246),
+        p = n(227),
+        g = n(3468);
+      let f = new Set();
+      function m(e, t, n, a) {
+        if (i.isLocalURL(t)) {
+          if (!a.bypassPrefetchedCheck) {
+            let r =
+                void 0 !== a.locale
+                  ? a.locale
+                  : 'locale' in e
+                  ? e.locale
+                  : void 0,
+              o = t + '%' + n + '%' + r;
+            if (f.has(o)) return;
+            f.add(o);
+          }
+          Promise.resolve(e.prefetch(t, n, a)).catch((e) => {});
+        }
+      }
+      function b(e) {
+        return 'string' == typeof e ? e : s.formatUrl(e);
+      }
+      let h = o.default.forwardRef(function (e, t) {
+        let n, a;
+        let {
+            href: s,
+            as: f,
+            children: h,
+            prefetch: y,
+            passHref: v,
+            replace: E,
+            shallow: k,
+            scroll: S,
+            locale: w,
+            onClick: A,
+            onMouseEnter: _,
+            onTouchStart: T,
+            legacyBehavior: R = !0 !== Boolean(!0),
+          } = e,
+          I = r(e, [
+            'href',
+            'as',
+            'children',
+            'prefetch',
+            'passHref',
+            'replace',
+            'shallow',
+            'scroll',
+            'locale',
+            'onClick',
+            'onMouseEnter',
+            'onTouchStart',
+            'legacyBehavior',
+          ]);
+        (n = h),
+          R &&
+            ('string' == typeof n || 'number' == typeof n) &&
+            (n = o.default.createElement('a', null, n));
+        let x = !1 !== y,
+          O = o.default.useContext(u.RouterContext),
+          N = o.default.useContext(c.AppRouterContext),
+          F = null != O ? O : N,
+          C = !O,
+          { href: L, as: D } = o.default.useMemo(() => {
+            if (!O) {
+              let e = b(s);
+              return { href: e, as: f ? b(f) : e };
+            }
+            let [t, n] = i.resolveHref(O, s, !0);
+            return { href: t, as: f ? i.resolveHref(O, f) : n || t };
+          }, [O, s, f]),
+          P = o.default.useRef(L),
+          B = o.default.useRef(D);
+        R && (a = o.default.Children.only(n));
+        let M = R ? a && 'object' == typeof a && a.ref : t,
+          [$, G, U] = d.useIntersection({ rootMargin: '200px' }),
+          j = o.default.useCallback(
+            (e) => {
+              (B.current !== D || P.current !== L) &&
+                (U(), (B.current = D), (P.current = L)),
+                $(e),
+                M &&
+                  ('function' == typeof M
+                    ? M(e)
+                    : 'object' == typeof M && (M.current = e));
+            },
+            [D, M, L, U, $],
+          );
+        o.default.useEffect(() => {
+          F && G && x && m(F, L, D, { locale: w });
+        }, [D, L, G, w, x, null == O ? void 0 : O.locale, F]);
+        let z = {
+          ref: j,
+          onClick(e) {
+            R || 'function' != typeof A || A(e),
+              R &&
+                a.props &&
+                'function' == typeof a.props.onClick &&
+                a.props.onClick(e),
+              F &&
+                !e.defaultPrevented &&
+                (function (e, t, n, a, r, s, l, u, c, d) {
+                  let { nodeName: p } = e.currentTarget,
+                    g = 'A' === p.toUpperCase();
+                  if (
+                    g &&
+                    ((function (e) {
+                      let { target: t } = e.currentTarget;
+                      return (
+                        (t && '_self' !== t) ||
+                        e.metaKey ||
+                        e.ctrlKey ||
+                        e.shiftKey ||
+                        e.altKey ||
+                        (e.nativeEvent && 2 === e.nativeEvent.which)
+                      );
+                    })(e) ||
+                      !i.isLocalURL(n))
+                  )
+                    return;
+                  e.preventDefault();
+                  let f = () => {
+                    'beforePopState' in t
+                      ? t[r ? 'replace' : 'push'](n, a, {
+                          shallow: s,
+                          locale: u,
+                          scroll: l,
+                        })
+                      : t[r ? 'replace' : 'push'](a || n, {
+                          forceOptimisticNavigation: !d,
+                        });
+                  };
+                  c ? o.default.startTransition(f) : f();
+                })(e, F, L, D, E, k, S, w, C, x);
+          },
+          onMouseEnter(e) {
+            R || 'function' != typeof _ || _(e),
+              R &&
+                a.props &&
+                'function' == typeof a.props.onMouseEnter &&
+                a.props.onMouseEnter(e),
+              F &&
+                (x || !C) &&
+                m(F, L, D, {
+                  locale: w,
+                  priority: !0,
+                  bypassPrefetchedCheck: !0,
+                });
+          },
+          onTouchStart(e) {
+            R || 'function' != typeof T || T(e),
+              R &&
+                a.props &&
+                'function' == typeof a.props.onTouchStart &&
+                a.props.onTouchStart(e),
+              F &&
+                (x || !C) &&
+                m(F, L, D, {
+                  locale: w,
+                  priority: !0,
+                  bypassPrefetchedCheck: !0,
+                });
+          },
+        };
+        if (!R || v || ('a' === a.type && !('href' in a.props))) {
+          let H = void 0 !== w ? w : null == O ? void 0 : O.locale,
+            Z =
+              (null == O ? void 0 : O.isLocaleDomain) &&
+              p.getDomainLocale(
+                D,
+                H,
+                null == O ? void 0 : O.locales,
+                null == O ? void 0 : O.domainLocales,
+              );
+          z.href =
+            Z ||
+            g.addBasePath(
+              l.addLocale(D, H, null == O ? void 0 : O.defaultLocale),
+            );
+        }
+        return R
+          ? o.default.cloneElement(a, z)
+          : o.default.createElement('a', Object.assign({}, I, z), n);
+      });
+      (t.default = h),
+        ('function' == typeof t.default ||
+          ('object' == typeof t.default && null !== t.default)) &&
+          void 0 === t.default.__esModule &&
+          (Object.defineProperty(t.default, '__esModule', { value: !0 }),
+          Object.assign(t.default, t),
+          (e.exports = t.default));
+    },
+    9246: function (e, t, n) {
+      'use strict';
+      Object.defineProperty(t, '__esModule', { value: !0 }),
+        (t.useIntersection = function (e) {
+          let { rootRef: t, rootMargin: n, disabled: l } = e,
+            u = l || !o,
+            [c, d] = a.useState(!1),
+            [p, g] = a.useState(null);
+          a.useEffect(() => {
+            if (o) {
+              if (!u && !c && p && p.tagName) {
+                let e = (function (e, t, n) {
+                  let {
+                    id: a,
+                    observer: r,
+                    elements: o,
+                  } = (function (e) {
+                    let t;
+                    let n = {
+                        root: e.root || null,
+                        margin: e.rootMargin || '',
+                      },
+                      a = s.find(
+                        (e) => e.root === n.root && e.margin === n.margin,
+                      );
+                    if (a && (t = i.get(a))) return t;
+                    let r = new Map(),
+                      o = new IntersectionObserver((e) => {
+                        e.forEach((e) => {
+                          let t = r.get(e.target),
+                            n = e.isIntersecting || e.intersectionRatio > 0;
+                          t && n && t(n);
+                        });
+                      }, e);
+                    return (
+                      (t = { id: n, observer: o, elements: r }),
+                      s.push(n),
+                      i.set(n, t),
+                      t
+                    );
+                  })(n);
+                  return (
+                    o.set(e, t),
+                    r.observe(e),
+                    function () {
+                      if ((o.delete(e), r.unobserve(e), 0 === o.size)) {
+                        r.disconnect(), i.delete(a);
+                        let t = s.findIndex(
+                          (e) => e.root === a.root && e.margin === a.margin,
+                        );
+                        t > -1 && s.splice(t, 1);
+                      }
+                    }
+                  );
+                })(p, (e) => e && d(e), {
+                  root: null == t ? void 0 : t.current,
+                  rootMargin: n,
+                });
+                return e;
+              }
+            } else if (!c) {
+              let a = r.requestIdleCallback(() => d(!0));
+              return () => r.cancelIdleCallback(a);
+            }
+          }, [p, u, n, t, c]);
+          let f = a.useCallback(() => {
+            d(!1);
+          }, []);
+          return [g, c, f];
+        });
+      var a = n(7294),
+        r = n(4686);
+      let o = 'function' == typeof IntersectionObserver,
+        i = new Map(),
+        s = [];
+      ('function' == typeof t.default ||
+        ('object' == typeof t.default && null !== t.default)) &&
+        void 0 === t.default.__esModule &&
+        (Object.defineProperty(t.default, '__esModule', { value: !0 }),
+        Object.assign(t.default, t),
+        (e.exports = t.default));
+    },
+    1664: function (e, t, n) {
+      e.exports = n(1551);
+    },
+    1163: function (e, t, n) {
+      e.exports = n(880);
+    },
+    7087: function (e, t, n) {
+      'use strict';
+      n.d(t, {
+        ZP: function () {
+          return $;
+        },
+        lG: function () {
+          return O;
+        },
+      });
+      /**
+       * Prism: Lightweight, robust, elegant syntax highlighting
+       *
+       * @license MIT <https://opensource.org/licenses/MIT>
+       * @author Lea Verou <https://lea.verou.me>
+       * @namespace
+       * @public
+       */ var a,
+        r,
+        o,
+        i,
+        s,
+        l,
+        u,
+        c,
+        d,
+        p,
+        g,
+        f,
+        m,
+        b,
+        h,
+        y,
+        v,
+        E,
+        k,
+        S,
+        w,
+        A,
+        _,
+        T,
+        R = (function () {
+          var e = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i,
+            t = 0,
+            n = {},
+            a = {
+              util: {
+                encode: function e(t) {
+                  return t instanceof r
+                    ? new r(t.type, e(t.content), t.alias)
+                    : Array.isArray(t)
+                    ? t.map(e)
+                    : t
+                        .replace(/&/g, '&amp;')
+                        .replace(/</g, '&lt;')
+                        .replace(/\u00a0/g, ' ');
+                },
+                type: function (e) {
+                  return Object.prototype.toString.call(e).slice(8, -1);
+                },
+                objId: function (e) {
+                  return (
+                    e.__id || Object.defineProperty(e, '__id', { value: ++t }),
+                    e.__id
+                  );
+                },
+                clone: function e(t, n) {
+                  var r, o;
+                  switch (((n = n || {}), a.util.type(t))) {
+                    case 'Object':
+                      if (n[(o = a.util.objId(t))]) return n[o];
+                      for (var i in ((r = {}), (n[o] = r), t))
+                        t.hasOwnProperty(i) && (r[i] = e(t[i], n));
+                      return r;
+                    case 'Array':
+                      if (n[(o = a.util.objId(t))]) return n[o];
+                      return (
+                        (r = []),
+                        (n[o] = r),
+                        t.forEach(function (t, a) {
+                          r[a] = e(t, n);
+                        }),
+                        r
+                      );
+                    default:
+                      return t;
+                  }
+                },
+                getLanguage: function (t) {
+                  for (; t; ) {
+                    var n = e.exec(t.className);
+                    if (n) return n[1].toLowerCase();
+                    t = t.parentElement;
+                  }
+                  return 'none';
+                },
+                setLanguage: function (t, n) {
+                  (t.className = t.className.replace(RegExp(e, 'gi'), '')),
+                    t.classList.add('language-' + n);
+                },
+                isActive: function (e, t, n) {
+                  for (var a = 'no-' + t; e; ) {
+                    var r = e.classList;
+                    if (r.contains(t)) return !0;
+                    if (r.contains(a)) return !1;
+                    e = e.parentElement;
+                  }
+                  return !!n;
+                },
+              },
+              languages: {
+                plain: n,
+                plaintext: n,
+                text: n,
+                txt: n,
+                extend: function (e, t) {
+                  var n = a.util.clone(a.languages[e]);
+                  for (var r in t) n[r] = t[r];
+                  return n;
+                },
+                insertBefore: function (e, t, n, r) {
+                  var o = (r = r || a.languages)[e],
+                    i = {};
+                  for (var s in o)
+                    if (o.hasOwnProperty(s)) {
+                      if (s == t)
+                        for (var l in n) n.hasOwnProperty(l) && (i[l] = n[l]);
+                      n.hasOwnProperty(s) || (i[s] = o[s]);
+                    }
+                  var u = r[e];
+                  return (
+                    (r[e] = i),
+                    a.languages.DFS(a.languages, function (t, n) {
+                      n === u && t != e && (this[t] = i);
+                    }),
+                    i
+                  );
+                },
+                DFS: function e(t, n, r, o) {
+                  o = o || {};
+                  var i = a.util.objId;
+                  for (var s in t)
+                    if (t.hasOwnProperty(s)) {
+                      n.call(t, s, t[s], r || s);
+                      var l = t[s],
+                        u = a.util.type(l);
+                      'Object' !== u || o[i(l)]
+                        ? 'Array' !== u ||
+                          o[i(l)] ||
+                          ((o[i(l)] = !0), e(l, n, s, o))
+                        : ((o[i(l)] = !0), e(l, n, null, o));
+                    }
+                },
+              },
+              plugins: {},
+              highlight: function (e, t, n) {
+                var o = { code: e, grammar: t, language: n };
+                return (
+                  a.hooks.run('before-tokenize', o),
+                  (o.tokens = a.tokenize(o.code, o.grammar)),
+                  a.hooks.run('after-tokenize', o),
+                  r.stringify(a.util.encode(o.tokens), o.language)
+                );
+              },
+              tokenize: function (e, t) {
+                var n = t.rest;
+                if (n) {
+                  for (var l in n) t[l] = n[l];
+                  delete t.rest;
+                }
+                var u = new i();
+                return (
+                  s(u, u.head, e),
+                  (function e(t, n, i, l, u, c) {
+                    for (var d in i)
+                      if (i.hasOwnProperty(d) && i[d]) {
+                        var p = i[d];
+                        p = Array.isArray(p) ? p : [p];
+                        for (var g = 0; g < p.length; ++g) {
+                          if (c && c.cause == d + ',' + g) return;
+                          var f = p[g],
+                            m = f.inside,
+                            b = !!f.lookbehind,
+                            h = !!f.greedy,
+                            y = f.alias;
+                          if (h && !f.pattern.global) {
+                            var v = f.pattern.toString().match(/[imsuy]*$/)[0];
+                            f.pattern = RegExp(f.pattern.source, v + 'g');
+                          }
+                          for (
+                            var E = f.pattern || f, k = l.next, S = u;
+                            k !== n.tail && (!c || !(S >= c.reach));
+                            S += k.value.length, k = k.next
+                          ) {
+                            var w,
+                              A = k.value;
+                            if (n.length > t.length) return;
+                            if (!(A instanceof r)) {
+                              var _ = 1;
+                              if (h) {
+                                if (!(w = o(E, S, t, b)) || w.index >= t.length)
+                                  break;
+                                var T = w.index,
+                                  R = w.index + w[0].length,
+                                  I = S;
+                                for (I += k.value.length; T >= I; )
+                                  I += (k = k.next).value.length;
+                                if (
+                                  ((I -= k.value.length),
+                                  (S = I),
+                                  k.value instanceof r)
+                                )
+                                  continue;
+                                for (
+                                  var x = k;
+                                  x !== n.tail &&
+                                  (I < R || 'string' == typeof x.value);
+                                  x = x.next
+                                )
+                                  _++, (I += x.value.length);
+                                _--, (A = t.slice(S, I)), (w.index -= S);
+                              } else if (!(w = o(E, 0, A, b))) continue;
+                              var T = w.index,
+                                O = w[0],
+                                N = A.slice(0, T),
+                                F = A.slice(T + O.length),
+                                C = S + A.length;
+                              c && C > c.reach && (c.reach = C);
+                              var L = k.prev;
+                              N && ((L = s(n, L, N)), (S += N.length)),
+                                (function (e, t, n) {
+                                  for (
+                                    var a = t.next, r = 0;
+                                    r < n && a !== e.tail;
+                                    r++
+                                  )
+                                    a = a.next;
+                                  (t.next = a), (a.prev = t), (e.length -= r);
+                                })(n, L, _);
+                              var D = new r(d, m ? a.tokenize(O, m) : O, y, O);
+                              if (((k = s(n, L, D)), F && s(n, k, F), _ > 1)) {
+                                var P = { cause: d + ',' + g, reach: C };
+                                e(t, n, i, k.prev, S, P),
+                                  c && P.reach > c.reach && (c.reach = P.reach);
+                              }
+                            }
+                          }
+                        }
+                      }
+                  })(e, u, t, u.head, 0),
+                  (function (e) {
+                    for (var t = [], n = e.head.next; n !== e.tail; )
+                      t.push(n.value), (n = n.next);
+                    return t;
+                  })(u)
+                );
+              },
+              hooks: {
+                all: {},
+                add: function (e, t) {
+                  var n = a.hooks.all;
+                  (n[e] = n[e] || []), n[e].push(t);
+                },
+                run: function (e, t) {
+                  var n = a.hooks.all[e];
+                  if (n && n.length) for (var r, o = 0; (r = n[o++]); ) r(t);
+                },
+              },
+              Token: r,
+            };
+          function r(e, t, n, a) {
+            (this.type = e),
+              (this.content = t),
+              (this.alias = n),
+              (this.length = 0 | (a || '').length);
+          }
+          function o(e, t, n, a) {
+            e.lastIndex = t;
+            var r = e.exec(n);
+            if (r && a && r[1]) {
+              var o = r[1].length;
+              (r.index += o), (r[0] = r[0].slice(o));
+            }
+            return r;
+          }
+          function i() {
+            var e = { value: null, prev: null, next: null },
+              t = { value: null, prev: e, next: null };
+            (e.next = t), (this.head = e), (this.tail = t), (this.length = 0);
+          }
+          function s(e, t, n) {
+            var a = t.next,
+              r = { value: n, prev: t, next: a };
+            return (t.next = r), (a.prev = r), e.length++, r;
+          }
+          return (
+            (r.stringify = function e(t, n) {
+              if ('string' == typeof t) return t;
+              if (Array.isArray(t)) {
+                var r = '';
+                return (
+                  t.forEach(function (t) {
+                    r += e(t, n);
+                  }),
+                  r
+                );
+              }
+              var o = {
+                  type: t.type,
+                  content: e(t.content, n),
+                  tag: 'span',
+                  classes: ['token', t.type],
+                  attributes: {},
+                  language: n,
+                },
+                i = t.alias;
+              i &&
+                (Array.isArray(i)
+                  ? Array.prototype.push.apply(o.classes, i)
+                  : o.classes.push(i)),
+                a.hooks.run('wrap', o);
+              var s = '';
+              for (var l in o.attributes)
+                s +=
+                  ' ' +
+                  l +
+                  '="' +
+                  (o.attributes[l] || '').replace(/"/g, '&quot;') +
+                  '"';
+              return (
+                '<' +
+                o.tag +
+                ' class="' +
+                o.classes.join(' ') +
+                '"' +
+                s +
+                '>' +
+                o.content +
+                '</' +
+                o.tag +
+                '>'
+              );
+            }),
+            a
+          );
+        })(),
+        I = R;
+      (R.default = R),
+        (I.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' }, /"|'/],
+                },
+              },
+              'punctuation': /\/?>/,
+              'attr-name': {
+                pattern: /[^\s>\/]+/,
+                inside: { namespace: /^[^\s>\/:]+:/ },
+              },
+            },
+          },
+          entity: [
+            { pattern: /&[\da-z]{1,8};/i, alias: 'named-entity' },
+            /&#x?[\da-f]{1,8};/i,
+          ],
+        }),
+        (I.languages.markup.tag.inside['attr-value'].inside.entity =
+          I.languages.markup.entity),
+        (I.languages.markup.doctype.inside['internal-subset'].inside =
+          I.languages.markup),
+        I.hooks.add('wrap', function (e) {
+          'entity' === e.type &&
+            (e.attributes.title = e.content.replace(/&amp;/, '&'));
+        }),
+        Object.defineProperty(I.languages.markup.tag, 'addInlined', {
+          value: function (e, t) {
+            var n = {};
+            (n['language-' + t] = {
+              pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
+              lookbehind: !0,
+              inside: I.languages[t],
+            }),
+              (n.cdata = /^<!\[CDATA\[|\]\]>$/i);
+            var a = {
+              'included-cdata': {
+                pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+                inside: n,
+              },
+            };
+            a['language-' + t] = { pattern: /[\s\S]+/, inside: I.languages[t] };
+            var r = {};
+            (r[e] = {
+              pattern: RegExp(
+                /(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(
+                  /__/g,
+                  function () {
+                    return e;
+                  },
+                ),
+                'i',
+              ),
+              lookbehind: !0,
+              greedy: !0,
+              inside: a,
+            }),
+              I.languages.insertBefore('markup', 'cdata', r);
+          },
+        }),
+        Object.defineProperty(I.languages.markup.tag, 'addAttribute', {
+          value: function (e, t) {
+            I.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: I.languages[t],
+                    },
+                    punctuation: [
+                      { pattern: /^=/, alias: 'attr-equals' },
+                      /"|'/,
+                    ],
+                  },
+                },
+              },
+            });
+          },
+        }),
+        (I.languages.html = I.languages.markup),
+        (I.languages.mathml = I.languages.markup),
+        (I.languages.svg = I.languages.markup),
+        (I.languages.xml = I.languages.extend('markup', {})),
+        (I.languages.ssml = I.languages.xml),
+        (I.languages.atom = I.languages.xml),
+        (I.languages.rss = I.languages.xml),
+        (function (e) {
+          var t =
+              '\\b(?:BASH|BASHOPTS|BASH_ALIASES|BASH_ARGC|BASH_ARGV|BASH_CMDS|BASH_COMPLETION_COMPAT_DIR|BASH_LINENO|BASH_REMATCH|BASH_SOURCE|BASH_VERSINFO|BASH_VERSION|COLORTERM|COLUMNS|COMP_WORDBREAKS|DBUS_SESSION_BUS_ADDRESS|DEFAULTS_PATH|DESKTOP_SESSION|DIRSTACK|DISPLAY|EUID|GDMSESSION|GDM_LANG|GNOME_KEYRING_CONTROL|GNOME_KEYRING_PID|GPG_AGENT_INFO|GROUPS|HISTCONTROL|HISTFILE|HISTFILESIZE|HISTSIZE|HOME|HOSTNAME|HOSTTYPE|IFS|INSTANCE|JOB|LANG|LANGUAGE|LC_ADDRESS|LC_ALL|LC_IDENTIFICATION|LC_MEASUREMENT|LC_MONETARY|LC_NAME|LC_NUMERIC|LC_PAPER|LC_TELEPHONE|LC_TIME|LESSCLOSE|LESSOPEN|LINES|LOGNAME|LS_COLORS|MACHTYPE|MAILCHECK|MANDATORY_PATH|NO_AT_BRIDGE|OLDPWD|OPTERR|OPTIND|ORBIT_SOCKETDIR|OSTYPE|PAPERSIZE|PATH|PIPESTATUS|PPID|PS1|PS2|PS3|PS4|PWD|RANDOM|REPLY|SECONDS|SELINUX_INIT|SESSION|SESSIONTYPE|SESSION_MANAGER|SHELL|SHELLOPTS|SHLVL|SSH_AUTH_SOCK|TERM|UID|UPSTART_EVENTS|UPSTART_INSTANCE|UPSTART_JOB|UPSTART_SESSION|USER|WINDOWID|XAUTHORITY|XDG_CONFIG_DIRS|XDG_CURRENT_DESKTOP|XDG_DATA_DIRS|XDG_GREETER_DATA_DIR|XDG_MENU_PREFIX|XDG_RUNTIME_DIR|XDG_SEAT|XDG_SEAT_PATH|XDG_SESSION_DESKTOP|XDG_SESSION_ID|XDG_SESSION_PATH|XDG_SESSION_TYPE|XDG_VTNR|XMODIFIERS)\\b',
+            n = {
+              pattern: /(^(["']?)\w+\2)[ \t]+\S.*/,
+              lookbehind: !0,
+              alias: 'punctuation',
+              inside: null,
+            },
+            a = {
+              bash: n,
+              environment: { pattern: RegExp('\\$' + t), alias: 'constant' },
+              variable: [
+                {
+                  pattern: /\$?\(\([\s\S]+?\)\)/,
+                  greedy: !0,
+                  inside: {
+                    variable: [
+                      { pattern: /(^\$\(\([\s\S]+)\)\)/, lookbehind: !0 },
+                      /^\$\(\(/,
+                    ],
+                    number:
+                      /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee]-?\d+)?/,
+                    operator:
+                      /--|\+\+|\*\*=?|<<=?|>>=?|&&|\|\||[=!+\-*/%<>^&|]=?|[?~:]/,
+                    punctuation: /\(\(?|\)\)?|,|;/,
+                  },
+                },
+                {
+                  pattern: /\$\((?:\([^)]+\)|[^()])+\)|`[^`]+`/,
+                  greedy: !0,
+                  inside: { variable: /^\$\(|^`|\)$|`$/ },
+                },
+                {
+                  pattern: /\$\{[^}]+\}/,
+                  greedy: !0,
+                  inside: {
+                    operator: /:[-=?+]?|[!\/]|##?|%%?|\^\^?|,,?/,
+                    punctuation: /[\[\]]/,
+                    environment: {
+                      pattern: RegExp('(\\{)' + t),
+                      lookbehind: !0,
+                      alias: 'constant',
+                    },
+                  },
+                },
+                /\$(?:\w+|[#?*!@$])/,
+              ],
+              entity:
+                /\\(?:[abceEfnrtv\\"]|O?[0-7]{1,3}|U[0-9a-fA-F]{8}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{1,2})/,
+            };
+          (e.languages.bash = {
+            'shebang': { pattern: /^#!\s*\/.*/, alias: 'important' },
+            'comment': { pattern: /(^|[^"{\\$])#.*/, lookbehind: !0 },
+            'function-name': [
+              {
+                pattern: /(\bfunction\s+)[\w-]+(?=(?:\s*\(?:\s*\))?\s*\{)/,
+                lookbehind: !0,
+                alias: 'function',
+              },
+              { pattern: /\b[\w-]+(?=\s*\(\s*\)\s*\{)/, alias: 'function' },
+            ],
+            'for-or-select': {
+              pattern: /(\b(?:for|select)\s+)\w+(?=\s+in\s)/,
+              alias: 'variable',
+              lookbehind: !0,
+            },
+            'assign-left': {
+              pattern: /(^|[\s;|&]|[<>]\()\w+(?=\+?=)/,
+              inside: {
+                environment: {
+                  pattern: RegExp('(^|[\\s;|&]|[<>]\\()' + t),
+                  lookbehind: !0,
+                  alias: 'constant',
+                },
+              },
+              alias: 'variable',
+              lookbehind: !0,
+            },
+            'string': [
+              {
+                pattern: /((?:^|[^<])<<-?\s*)(\w+)\s[\s\S]*?(?:\r?\n|\r)\2/,
+                lookbehind: !0,
+                greedy: !0,
+                inside: a,
+              },
+              {
+                pattern:
+                  /((?:^|[^<])<<-?\s*)(["'])(\w+)\2\s[\s\S]*?(?:\r?\n|\r)\3/,
+                lookbehind: !0,
+                greedy: !0,
+                inside: { bash: n },
+              },
+              {
+                pattern:
+                  /(^|[^\\](?:\\\\)*)"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/,
+                lookbehind: !0,
+                greedy: !0,
+                inside: a,
+              },
+              { pattern: /(^|[^$\\])'[^']*'/, lookbehind: !0, greedy: !0 },
+              {
+                pattern: /\$'(?:[^'\\]|\\[\s\S])*'/,
+                greedy: !0,
+                inside: { entity: a.entity },
+              },
+            ],
+            'environment': { pattern: RegExp('\\$?' + t), alias: 'constant' },
+            'variable': a.variable,
+            'function': {
+              pattern:
+                /(^|[\s;|&]|[<>]\()(?:add|apropos|apt|apt-cache|apt-get|aptitude|aspell|automysqlbackup|awk|basename|bash|bc|bconsole|bg|bzip2|cal|cat|cfdisk|chgrp|chkconfig|chmod|chown|chroot|cksum|clear|cmp|column|comm|composer|cp|cron|crontab|csplit|curl|cut|date|dc|dd|ddrescue|debootstrap|df|diff|diff3|dig|dir|dircolors|dirname|dirs|dmesg|docker|docker-compose|du|egrep|eject|env|ethtool|expand|expect|expr|fdformat|fdisk|fg|fgrep|file|find|fmt|fold|format|free|fsck|ftp|fuser|gawk|git|gparted|grep|groupadd|groupdel|groupmod|groups|grub-mkconfig|gzip|halt|head|hg|history|host|hostname|htop|iconv|id|ifconfig|ifdown|ifup|import|install|ip|jobs|join|kill|killall|less|link|ln|locate|logname|logrotate|look|lpc|lpr|lprint|lprintd|lprintq|lprm|ls|lsof|lynx|make|man|mc|mdadm|mkconfig|mkdir|mke2fs|mkfifo|mkfs|mkisofs|mknod|mkswap|mmv|more|most|mount|mtools|mtr|mutt|mv|nano|nc|netstat|nice|nl|node|nohup|notify-send|npm|nslookup|op|open|parted|passwd|paste|pathchk|ping|pkill|pnpm|podman|podman-compose|popd|pr|printcap|printenv|ps|pushd|pv|quota|quotacheck|quotactl|ram|rar|rcp|reboot|remsync|rename|renice|rev|rm|rmdir|rpm|rsync|scp|screen|sdiff|sed|sendmail|seq|service|sftp|sh|shellcheck|shuf|shutdown|sleep|slocate|sort|split|ssh|stat|strace|su|sudo|sum|suspend|swapon|sync|tac|tail|tar|tee|time|timeout|top|touch|tr|traceroute|tsort|tty|umount|uname|unexpand|uniq|units|unrar|unshar|unzip|update-grub|uptime|useradd|userdel|usermod|users|uudecode|uuencode|v|vcpkg|vdir|vi|vim|virsh|vmstat|wait|watch|wc|wget|whereis|which|who|whoami|write|xargs|xdg-open|yarn|yes|zenity|zip|zsh|zypper)(?=$|[)\s;|&])/,
+              lookbehind: !0,
+            },
+            'keyword': {
+              pattern:
+                /(^|[\s;|&]|[<>]\()(?:case|do|done|elif|else|esac|fi|for|function|if|in|select|then|until|while)(?=$|[)\s;|&])/,
+              lookbehind: !0,
+            },
+            'builtin': {
+              pattern:
+                /(^|[\s;|&]|[<>]\()(?:\.|:|alias|bind|break|builtin|caller|cd|command|continue|declare|echo|enable|eval|exec|exit|export|getopts|hash|help|let|local|logout|mapfile|printf|pwd|read|readarray|readonly|return|set|shift|shopt|source|test|times|trap|type|typeset|ulimit|umask|unalias|unset)(?=$|[)\s;|&])/,
+              lookbehind: !0,
+              alias: 'class-name',
+            },
+            'boolean': {
+              pattern: /(^|[\s;|&]|[<>]\()(?:false|true)(?=$|[)\s;|&])/,
+              lookbehind: !0,
+            },
+            'file-descriptor': { pattern: /\B&\d\b/, alias: 'important' },
+            'operator': {
+              pattern:
+                /\d?<>|>\||\+=|=[=~]?|!=?|<<[<-]?|[&\d]?>>|\d[<>]&?|[<>][&=]?|&[>&]?|\|[&|]?/,
+              inside: {
+                'file-descriptor': { pattern: /^\d/, alias: 'important' },
+              },
+            },
+            'punctuation': /\$?\(\(?|\)\)?|\.\.|[{}[\];\\]/,
+            'number': {
+              pattern: /(^|\s)(?:[1-9]\d*|0)(?:[.,]\d+)?\b/,
+              lookbehind: !0,
+            },
+          }),
+            (n.inside = e.languages.bash);
+          for (
+            var r = [
+                'comment',
+                'function-name',
+                'for-or-select',
+                'assign-left',
+                'string',
+                'environment',
+                'function',
+                'keyword',
+                'builtin',
+                'boolean',
+                'file-descriptor',
+                'operator',
+                'punctuation',
+                'number',
+              ],
+              o = a.variable[1].inside,
+              i = 0;
+            i < r.length;
+            i++
+          )
+            o[r[i]] = e.languages.bash[r[i]];
+          e.languages.shell = e.languages.bash;
+        })(I),
+        (I.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': /[{}[\];(),.:]/,
+        }),
+        (I.languages.c = I.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|[?:~]|[-+*/%&|^!=<>]=?/,
+        })),
+        I.languages.insertBefore('c', 'string', {
+          char: {
+            pattern: /'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n]){0,32}'/,
+            greedy: !0,
+          },
+        }),
+        I.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 },
+                I.languages.c.string,
+              ],
+              'char': I.languages.c.char,
+              'comment': I.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: I.languages.c },
+            },
+          },
+        }),
+        I.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 I.languages.c.boolean,
+        (a = I),
+        (r =
+          /\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/),
+        (o = /\b(?!<keyword>)\w+(?:\s*\.\s*\w+)*\b/.source.replace(
+          /<keyword>/g,
+          function () {
+            return r.source;
+          },
+        )),
+        (a.languages.cpp = a.languages.extend('c', {
+          'class-name': [
+            {
+              pattern: RegExp(
+                /(\b(?:class|concept|enum|struct|typename)\s+)(?!<keyword>)\w+/.source.replace(
+                  /<keyword>/g,
+                  function () {
+                    return r.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': r,
+          '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/,
+        })),
+        a.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 o;
+                  },
+                ) +
+                ')',
+            ),
+            lookbehind: !0,
+            greedy: !0,
+            inside: {
+              string: /^[<"][\s\S]+/,
+              operator: /:/,
+              punctuation: /\./,
+            },
+          },
+          'raw-string': {
+            pattern: /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/,
+            alias: 'string',
+            greedy: !0,
+          },
+        }),
+        a.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: a.languages.cpp,
+              },
+            },
+          },
+        }),
+        a.languages.insertBefore('cpp', 'operator', {
+          'double-colon': { pattern: /::/, alias: 'punctuation' },
+        }),
+        a.languages.insertBefore('cpp', 'class-name', {
+          'base-clause': {
+            pattern:
+              /(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/,
+            lookbehind: !0,
+            greedy: !0,
+            inside: a.languages.extend('cpp', {}),
+          },
+        }),
+        a.languages.insertBefore(
+          'inside',
+          'double-colon',
+          { 'class-name': /\b[a-z_]\w*\b(?!\s*::)/i },
+          a.languages.cpp['base-clause'],
+        ),
+        (s =
+          /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/),
+        ((i = I).languages.css = {
+          comment: /\/\*[\s\S]*?\*\//,
+          atrule: {
+            pattern: /@[\w-](?:[^;{\s]|\s+(?![\s{]))*(?:;|(?=\s*\{))/,
+            inside: {
+              'rule': /^@[\w-]+/,
+              'selector-function-argument': {
+                pattern:
+                  /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
+                lookbehind: !0,
+                alias: 'selector',
+              },
+              'keyword': {
+                pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
+                lookbehind: !0,
+              },
+            },
+          },
+          url: {
+            pattern: RegExp(
+              '\\burl\\((?:' +
+                s.source +
+                '|' +
+                /(?:[^\\\r\n()"']|\\[\s\S])*/.source +
+                ')\\)',
+              'i',
+            ),
+            greedy: !0,
+            inside: {
+              function: /^url/i,
+              punctuation: /^\(|\)$/,
+              string: { pattern: RegExp('^' + s.source + '$'), alias: 'url' },
+            },
+          },
+          selector: {
+            pattern: RegExp(
+              '(^|[{}\\s])[^{}\\s](?:[^{};"\'\\s]|\\s+(?![\\s{])|' +
+                s.source +
+                ')*(?=\\s*\\{)',
+            ),
+            lookbehind: !0,
+          },
+          string: { pattern: s, 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: /[(){};:,]/,
+        }),
+        (i.languages.css.atrule.inside.rest = i.languages.css),
+        (l = i.languages.markup) &&
+          (l.tag.addInlined('style', 'css'),
+          l.tag.addAttribute('style', 'css')),
+        (function (e) {
+          var t,
+            n = /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/;
+          (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('\\[(?:[^[\\]"\']|' + n.source + ')*\\]'),
+                greedy: !0,
+                inside: {
+                  'punctuation': /^\[|\]$/,
+                  'case-sensitivity': {
+                    pattern: /(\s)[si]$/i,
+                    lookbehind: !0,
+                    alias: 'keyword',
+                  },
+                  'namespace': {
+                    pattern: /^(\s*)(?:(?!\s)[-*\w\xA0-\uFFFF])*\|(?!=)/,
+                    lookbehind: !0,
+                    inside: { punctuation: /\|$/ },
+                  },
+                  'attr-name': {
+                    pattern: /^(\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+/,
+                    lookbehind: !0,
+                  },
+                  'attr-value': [
+                    n,
+                    {
+                      pattern: /(=\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+(?=\s*$)/,
+                      lookbehind: !0,
+                    },
+                  ],
+                  'operator': /[|~*^$]?=/,
+                },
+              },
+              'n-th': [
+                {
+                  pattern: /(\(\s*)[+-]?\d*[\dn](?:\s*[+-]\s*\d+)?(?=\s*\))/,
+                  lookbehind: !0,
+                  inside: { number: /[\dn]+/, operator: /[+-]/ },
+                },
+                { pattern: /(\(\s*)(?:even|odd)(?=\s*\))/i, lookbehind: !0 },
+              ],
+              'combinator': />|\+|~|\|\|/,
+              'punctuation': /[(),]/,
+            }),
+          }),
+            (e.languages.css.atrule.inside[
+              'selector-function-argument'
+            ].inside = t),
+            e.languages.insertBefore('css', 'property', {
+              variable: {
+                pattern:
+                  /(^|[^-\w\xA0-\uFFFF])--(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*/i,
+                lookbehind: !0,
+              },
+            });
+          var a = { 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|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: a,
+                  number: r,
+                  function: /[\w-]+(?=\()/,
+                  punctuation: /[(),]/,
+                },
+              },
+            ],
+            entity: /\\[\da-f]{1,8}/i,
+            unit: a,
+            number: r,
+          });
+        })(I),
+        (I.languages.javascript = I.languages.extend('clike', {
+          'class-name': [
+            I.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}|\?\?=?|\?\.?|[~:]/,
+        })),
+        (I.languages.javascript['class-name'][0].pattern =
+          /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/),
+        I.languages.insertBefore('javascript', 'keyword', {
+          'regex': {
+            pattern:
+              /((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)\/(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/,
+            lookbehind: !0,
+            greedy: !0,
+            inside: {
+              'regex-source': {
+                pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
+                lookbehind: !0,
+                alias: 'language-regex',
+                inside: I.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: I.languages.javascript,
+            },
+            {
+              pattern:
+                /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
+              lookbehind: !0,
+              inside: I.languages.javascript,
+            },
+            {
+              pattern:
+                /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
+              lookbehind: !0,
+              inside: I.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: I.languages.javascript,
+            },
+          ],
+          'constant': /\b[A-Z](?:[A-Z_]|\dx?)*\b/,
+        }),
+        I.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': I.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',
+          },
+        }),
+        I.languages.insertBefore('javascript', 'operator', {
+          'literal-property': {
+            pattern:
+              /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
+            lookbehind: !0,
+            alias: 'property',
+          },
+        }),
+        I.languages.markup &&
+          (I.languages.markup.tag.addInlined('script', 'javascript'),
+          I.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',
+          )),
+        (I.languages.js = I.languages.javascript),
+        (c = /#(?!\{).+/),
+        (d = { pattern: /#\{[^}]+\}/, alias: 'variable' }),
+        ((u = I).languages.coffeescript = u.languages.extend('javascript', {
+          'comment': c,
+          'string': [
+            { pattern: /'(?:\\[\s\S]|[^\\'])*'/, greedy: !0 },
+            {
+              pattern: /"(?:\\[\s\S]|[^\\"])*"/,
+              greedy: !0,
+              inside: { interpolation: d },
+            },
+          ],
+          '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' },
+        })),
+        u.languages.insertBefore('coffeescript', 'comment', {
+          'multiline-comment': { pattern: /###[\s\S]+?###/, alias: 'comment' },
+          'block-regex': {
+            pattern: /\/{3}[\s\S]*?\/{3}/,
+            alias: 'regex',
+            inside: { comment: c, interpolation: d },
+          },
+        }),
+        u.languages.insertBefore('coffeescript', 'string', {
+          'inline-javascript': {
+            pattern: /`(?:\\[\s\S]|[^\\`])*`/,
+            inside: {
+              delimiter: { pattern: /^`|`$/, alias: 'punctuation' },
+              script: {
+                pattern: /[\s\S]+/,
+                alias: 'language-javascript',
+                inside: u.languages.javascript,
+              },
+            },
+          },
+          'multiline-string': [
+            { pattern: /'''[\s\S]*?'''/, greedy: !0, alias: 'string' },
+            {
+              pattern: /"""[\s\S]*?"""/,
+              greedy: !0,
+              alias: 'string',
+              inside: { interpolation: d },
+            },
+          ],
+        }),
+        u.languages.insertBefore('coffeescript', 'keyword', {
+          property: /(?!\d)\w+(?=\s*:(?!:))/,
+        }),
+        delete u.languages.coffeescript['template-string'],
+        (u.languages.coffee = u.languages.coffeescript),
+        (function (e) {
+          var t = /[*&][^\s[\]{},]+/,
+            n =
+              /!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/,
+            a =
+              '(?:' +
+              n.source +
+              '(?:[ 	]+' +
+              t.source +
+              ')?|' +
+              t.source +
+              '(?:[ 	]+' +
+              n.source +
+              ')?)',
+            r =
+              /(?:[^\s\x00-\x08\x0e-\x1f!"#%&'*,\-:>?@[\]`{|}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]|[?:-]<PLAIN>)(?:[ \t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*/.source.replace(
+                /<PLAIN>/g,
+                function () {
+                  return /[^\s\x00-\x08\x0e-\x1f,[\]{}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]/
+                    .source;
+                },
+              ),
+            o = /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/.source;
+          function i(e, t) {
+            return (
+              (t = (t || '').replace(/m/g, '') + 'm'),
+              RegExp(
+                /([:\-,[{]\s*(?:\s<<prop>>[ \t]+)?)(?:<<value>>)(?=[ \t]*(?:$|,|\]|\}|(?:[\r\n]\s*)?#))/.source
+                  .replace(/<<prop>>/g, function () {
+                    return a;
+                  })
+                  .replace(/<<value>>/g, function () {
+                    return e;
+                  }),
+                t,
+              )
+            );
+          }
+          (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 a;
+                  },
+                ),
+              ),
+              lookbehind: !0,
+              alias: 'string',
+            },
+            comment: /#.*/,
+            key: {
+              pattern: RegExp(
+                /((?:^|[:\-,[{\r\n?])[ \t]*(?:<<prop>>[ \t]+)?)<<key>>(?=\s*:\s)/.source
+                  .replace(/<<prop>>/g, function () {
+                    return a;
+                  })
+                  .replace(/<<key>>/g, function () {
+                    return '(?:' + r + '|' + o + ')';
+                  }),
+              ),
+              lookbehind: !0,
+              greedy: !0,
+              alias: 'atrule',
+            },
+            directive: {
+              pattern: /(^[ \t]*)%.+/m,
+              lookbehind: !0,
+              alias: 'important',
+            },
+            datetime: {
+              pattern: i(
+                /\d{4}-\d\d?-\d\d?(?:[tT]|[ \t]+)\d\d?:\d{2}:\d{2}(?:\.\d*)?(?:[ \t]*(?:Z|[-+]\d\d?(?::\d{2})?))?|\d{4}-\d{2}-\d{2}|\d\d?:\d{2}(?::\d{2}(?:\.\d*)?)?/
+                  .source,
+              ),
+              lookbehind: !0,
+              alias: 'number',
+            },
+            boolean: {
+              pattern: i(/false|true/.source, 'i'),
+              lookbehind: !0,
+              alias: 'important',
+            },
+            null: {
+              pattern: i(/null|~/.source, 'i'),
+              lookbehind: !0,
+              alias: 'important',
+            },
+            string: { pattern: i(o), lookbehind: !0, greedy: !0 },
+            number: {
+              pattern: i(
+                /[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|\.inf|\.nan)/
+                  .source,
+                'i',
+              ),
+              lookbehind: !0,
+            },
+            tag: n,
+            important: t,
+            punctuation: /---|[:[\]{}\-,|>?]|\.\.\./,
+          }),
+            (e.languages.yml = e.languages.yaml);
+        })(I),
+        (function (e) {
+          var t = /(?:\\.|[^\\\n\r]|(?:\n|\r\n?)(?![\r\n]))/.source;
+          function n(e) {
+            return (
+              (e = e.replace(/<inner>/g, function () {
+                return t;
+              })),
+              RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + '(?:' + e + ')')
+            );
+          }
+          var a = /(?:\\.|``(?:[^`\r\n]|`(?!`))+``|`[^`\r\n]+`|[^\\|\r\n`])+/
+              .source,
+            r = /\|?__(?:\|__)+\|?(?:(?:\n|\r\n?)|(?![\s\S]))/.source.replace(
+              /__/g,
+              function () {
+                return a;
+              },
+            ),
+            o =
+              /\|?[ \t]*:?-{3,}:?[ \t]*(?:\|[ \t]*:?-{3,}:?[ \t]*)+\|?(?:\n|\r\n?)/
+                .source;
+          (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('^' + r + o + '(?:' + r + ')*', 'm'),
+                inside: {
+                  'table-data-rows': {
+                    pattern: RegExp('^(' + r + o + ')(?:' + r + ')*$'),
+                    lookbehind: !0,
+                    inside: {
+                      'table-data': {
+                        pattern: RegExp(a),
+                        inside: e.languages.markdown,
+                      },
+                      'punctuation': /\|/,
+                    },
+                  },
+                  'table-line': {
+                    pattern: RegExp('^(' + r + ')' + o + '$'),
+                    lookbehind: !0,
+                    inside: { punctuation: /\||:?-{3,}:?/ },
+                  },
+                  'table-header-row': {
+                    pattern: RegExp('^' + r + '$'),
+                    inside: {
+                      'table-header': {
+                        pattern: RegExp(a),
+                        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: n(
+                  /\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\b|\*\*(?:(?!\*)<inner>|\*(?:(?!\*)<inner>)+\*)+\*\*/
+                    .source,
+                ),
+                lookbehind: !0,
+                greedy: !0,
+                inside: {
+                  content: {
+                    pattern: /(^..)[\s\S]+(?=..$)/,
+                    lookbehind: !0,
+                    inside: {},
+                  },
+                  punctuation: /\*\*|__/,
+                },
+              },
+              'italic': {
+                pattern: n(
+                  /\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\b|\*(?:(?!\*)<inner>|\*\*(?:(?!\*)<inner>)+\*\*)+\*/
+                    .source,
+                ),
+                lookbehind: !0,
+                greedy: !0,
+                inside: {
+                  content: {
+                    pattern: /(^.)[\s\S]+(?=.$)/,
+                    lookbehind: !0,
+                    inside: {},
+                  },
+                  punctuation: /[*_]/,
+                },
+              },
+              'strike': {
+                pattern: n(/(~~?)(?:(?!~)<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: n(
+                  /!?\[(?:(?!\])<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 (t) {
+              ['url', 'bold', 'italic', 'strike', 'code-snippet'].forEach(
+                function (n) {
+                  t !== n &&
+                    (e.languages.markdown[t].inside.content.inside[n] =
+                      e.languages.markdown[n]);
+                },
+              );
+            }),
+            e.hooks.add('after-tokenize', function (e) {
+              ('markdown' === e.language || 'md' === e.language) &&
+                (function e(t) {
+                  if (t && 'string' != typeof t)
+                    for (var n = 0, a = t.length; n < a; n++) {
+                      var r = t[n];
+                      if ('code' !== r.type) {
+                        e(r.content);
+                        continue;
+                      }
+                      var o = r.content[1],
+                        i = r.content[3];
+                      if (
+                        o &&
+                        i &&
+                        'code-language' === o.type &&
+                        'code-block' === i.type &&
+                        'string' == typeof o.content
+                      ) {
+                        var s = o.content
+                            .replace(/\b#/g, 'sharp')
+                            .replace(/\b\+\+/g, 'pp'),
+                          l =
+                            'language-' +
+                            (s = (/[a-z][\w-]*/i.exec(s) || [
+                              '',
+                            ])[0].toLowerCase());
+                        i.alias
+                          ? 'string' == typeof i.alias
+                            ? (i.alias = [i.alias, l])
+                            : i.alias.push(l)
+                          : (i.alias = [l]);
+                      }
+                    }
+                })(e.tokens);
+            }),
+            e.hooks.add('wrap', function (t) {
+              if ('code-block' === t.type) {
+                for (var n, a = '', r = 0, o = t.classes.length; r < o; r++) {
+                  var u = t.classes[r],
+                    c = /language-(.+)/.exec(u);
+                  if (c) {
+                    a = c[1];
+                    break;
+                  }
+                }
+                var d = e.languages[a];
+                if (d)
+                  t.content = e.highlight(
+                    t.content
+                      .replace(i, '')
+                      .replace(
+                        /&(\w{1,8}|#x?[\da-f]{1,8});/gi,
+                        function (e, t) {
+                          return '#' === (t = t.toLowerCase())[0]
+                            ? l(
+                                'x' === t[1]
+                                  ? parseInt(t.slice(2), 16)
+                                  : Number(t.slice(1)),
+                              )
+                            : s[t] || e;
+                        },
+                      ),
+                    d,
+                    a,
+                  );
+                else if (a && 'none' !== a && e.plugins.autoloader) {
+                  var p =
+                    'md-' +
+                    new Date().valueOf() +
+                    '-' +
+                    Math.floor(1e16 * Math.random());
+                  (t.attributes.id = p),
+                    e.plugins.autoloader.loadLanguages(a, function () {
+                      var t = document.getElementById(p);
+                      t &&
+                        (t.innerHTML = e.highlight(
+                          t.textContent,
+                          e.languages[a],
+                          a,
+                        ));
+                    });
+                }
+              }
+            });
+          var i = RegExp(e.languages.markup.tag.pattern.source, 'gi'),
+            s = { amp: '&', lt: '<', gt: '>', quot: '"' },
+            l = String.fromCodePoint || String.fromCharCode;
+          e.languages.md = e.languages.markdown;
+        })(I),
+        (I.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: I.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+/,
+        }),
+        I.hooks.add('after-tokenize', function (e) {
+          if ('graphql' === e.language)
+            for (
+              var t = e.tokens.filter(function (e) {
+                  return (
+                    'string' != typeof e &&
+                    'comment' !== e.type &&
+                    'scalar' !== e.type
+                  );
+                }),
+                n = 0;
+              n < t.length;
+
+            ) {
+              var a = t[n++];
+              if ('keyword' === a.type && 'mutation' === a.content) {
+                var r = [];
+                if (
+                  c(['definition-mutation', 'punctuation']) &&
+                  '(' === t[n + 1].content
+                ) {
+                  n += 2;
+                  var o = d(/^\($/, /^\)$/);
+                  if (-1 === o) continue;
+                  for (; n < o; n++) {
+                    var i = t[n + 0];
+                    'variable' === i.type &&
+                      (p(i, 'variable-input'), r.push(i.content));
+                  }
+                  n = o + 1;
+                }
+                if (
+                  c(['punctuation', 'property-query']) &&
+                  '{' === t[n + 0].content &&
+                  (p(t[++n + 0], 'property-mutation'), r.length > 0)
+                ) {
+                  var s = d(/^\{$/, /^\}$/);
+                  if (-1 === s) continue;
+                  for (var l = n; l < s; l++) {
+                    var u = t[l];
+                    'variable' === u.type &&
+                      r.indexOf(u.content) >= 0 &&
+                      p(u, 'variable-input');
+                  }
+                }
+              }
+            }
+          function c(e, a) {
+            a = a || 0;
+            for (var r = 0; r < e.length; r++) {
+              var o = t[n + (r + a)];
+              if (!o || o.type !== e[r]) return !1;
+            }
+            return !0;
+          }
+          function d(e, a) {
+            for (var r = 1, o = n; o < t.length; o++) {
+              var i = t[o],
+                s = i.content;
+              if ('punctuation' === i.type && 'string' == typeof s) {
+                if (e.test(s)) r++;
+                else if (a.test(s) && 0 == --r) return o;
+              }
+            }
+            return -1;
+          }
+          function p(e, t) {
+            var n = e.alias;
+            n ? Array.isArray(n) || (e.alias = n = [n]) : (e.alias = n = []),
+              n.push(t);
+          }
+        }),
+        (I.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'],
+            n = t.pattern.source,
+            a = t.inside.interpolation,
+            r = a.inside['interpolation-punctuation'],
+            o = a.pattern.source;
+          function i(t, a) {
+            if (e.languages[t])
+              return {
+                pattern: RegExp('((?:' + a + ')\\s*)' + n),
+                lookbehind: !0,
+                greedy: !0,
+                inside: {
+                  'template-punctuation': { pattern: /^`|`$/, alias: 'string' },
+                  'embedded-code': { pattern: /[\s\S]+/, alias: t },
+                },
+              };
+          }
+          function s(t, n, a) {
+            var r = { code: t, grammar: n, language: a };
+            return (
+              e.hooks.run('before-tokenize', r),
+              (r.tokens = e.tokenize(r.code, r.grammar)),
+              e.hooks.run('after-tokenize', r),
+              r.tokens
+            );
+          }
+          e.languages.javascript['template-string'] = [
+            i(
+              'css',
+              /\b(?:styled(?:\([^)]*\))?(?:\s*\.\s*\w+(?:\([^)]*\))*)*|css(?:\s*\.\s*(?:global|resolve))?|createGlobalStyle|keyframes)/
+                .source,
+            ),
+            i('html', /\bhtml|\.\s*(?:inner|outer)HTML\s*\+?=/.source),
+            i('svg', /\bsvg/.source),
+            i('markdown', /\b(?:markdown|md)/.source),
+            i('graphql', /\b(?:gql|graphql(?:\s*\.\s*experimental)?)/.source),
+            i('sql', /\bsql/.source),
+            t,
+          ].filter(Boolean);
+          var l = {
+            javascript: !0,
+            js: !0,
+            typescript: !0,
+            ts: !0,
+            jsx: !0,
+            tsx: !0,
+          };
+          e.hooks.add('after-tokenize', function (t) {
+            t.language in l &&
+              (function t(n) {
+                for (var i = 0, l = n.length; i < l; i++) {
+                  var u = n[i];
+                  if ('string' != typeof u) {
+                    var c = u.content;
+                    if (!Array.isArray(c)) {
+                      'string' != typeof c && t([c]);
+                      continue;
+                    }
+                    if ('template-string' === u.type) {
+                      var d = c[1];
+                      if (
+                        3 === c.length &&
+                        'string' != typeof d &&
+                        'embedded-code' === d.type
+                      ) {
+                        var p = (function e(t) {
+                            return 'string' == typeof t
+                              ? t
+                              : Array.isArray(t)
+                              ? t.map(e).join('')
+                              : e(t.content);
+                          })(d),
+                          g = d.alias,
+                          f = Array.isArray(g) ? g[0] : g,
+                          m = e.languages[f];
+                        if (!m) continue;
+                        c[1] = (function (t, n, i) {
+                          var l = e.tokenize(t, {
+                              interpolation: {
+                                pattern: RegExp(o),
+                                lookbehind: !0,
+                              },
+                            }),
+                            u = 0,
+                            c = {},
+                            d = s(
+                              l
+                                .map(function (e) {
+                                  if ('string' == typeof e) return e;
+                                  for (
+                                    var n, a, r = e.content;
+                                    -1 !==
+                                    t.indexOf(
+                                      ((n = u++),
+                                      (a =
+                                        '___' +
+                                        i.toUpperCase() +
+                                        '_' +
+                                        n +
+                                        '___')),
+                                    );
+
+                                  );
+                                  return (c[a] = r), a;
+                                })
+                                .join(''),
+                              n,
+                              i,
+                            ),
+                            p = Object.keys(c);
+                          return (
+                            (u = 0),
+                            (function t(n) {
+                              for (var o = 0; o < n.length; o++) {
+                                if (u >= p.length) return;
+                                var i = n[o];
+                                if (
+                                  'string' == typeof i ||
+                                  'string' == typeof i.content
+                                ) {
+                                  var l = p[u],
+                                    d = 'string' == typeof i ? i : i.content,
+                                    g = d.indexOf(l);
+                                  if (-1 !== g) {
+                                    ++u;
+                                    var f = d.substring(0, g),
+                                      m = (function (t) {
+                                        var n = {};
+                                        n['interpolation-punctuation'] = r;
+                                        var o = e.tokenize(t, n);
+                                        if (3 === o.length) {
+                                          var i = [1, 1];
+                                          i.push.apply(
+                                            i,
+                                            s(
+                                              o[1],
+                                              e.languages.javascript,
+                                              'javascript',
+                                            ),
+                                          ),
+                                            o.splice.apply(o, i);
+                                        }
+                                        return new e.Token(
+                                          'interpolation',
+                                          o,
+                                          a.alias,
+                                          t,
+                                        );
+                                      })(c[l]),
+                                      b = d.substring(g + l.length),
+                                      h = [];
+                                    if ((f && h.push(f), h.push(m), b)) {
+                                      var y = [b];
+                                      t(y), h.push.apply(h, y);
+                                    }
+                                    'string' == typeof i
+                                      ? (n.splice.apply(n, [o, 1].concat(h)),
+                                        (o += h.length - 1))
+                                      : (i.content = h);
+                                  }
+                                } else {
+                                  var v = i.content;
+                                  Array.isArray(v) ? t(v) : t([v]);
+                                }
+                              }
+                            })(d),
+                            new e.Token(i, d, 'language-' + i, t)
+                          );
+                        })(p, m, f);
+                      }
+                    } else t(c);
+                  }
+                }
+              })(t.tokens);
+          });
+        })(I),
+        ((p = I).languages.typescript = p.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/,
+        })),
+        p.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 p.languages.typescript.parameter,
+        delete p.languages.typescript['literal-property'],
+        delete (g = p.languages.extend('typescript', {}))['class-name'],
+        (p.languages.typescript['class-name'].inside = g),
+        p.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: g },
+            },
+          },
+        }),
+        (p.languages.ts = p.languages.typescript),
+        (function (e) {
+          function t(e, t) {
+            return RegExp(
+              e.replace(/<ID>/g, function () {
+                return /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/
+                  .source;
+              }),
+              t,
+            );
+          }
+          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 n = [
+                'function',
+                'function-variable',
+                'method',
+                'method-variable',
+                'property-access',
+              ],
+              a = 0;
+            a < n.length;
+            a++
+          ) {
+            var r = n[a],
+              o = e.languages.javascript[r];
+            'RegExp' === e.util.type(o) &&
+              (o = e.languages.javascript[r] = { pattern: o });
+            var i = o.inside || {};
+            (o.inside = i), (i['maybe-class-name'] = /^[A-Z][\s\S]*/);
+          }
+        })(I),
+        (function (e) {
+          var t = e.util.clone(e.languages.javascript),
+            n = /(?:\s|\/\/.*(?!.)|\/\*(?:[^*]|\*(?!\/))\*\/)/.source,
+            a = /(?:\{(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])*\})/.source,
+            r = /(?:\{<S>*\.{3}(?:[^{}]|<BRACES>)*\})/.source;
+          function o(e, t) {
+            return RegExp(
+              (e = e
+                .replace(/<S>/g, function () {
+                  return n;
+                })
+                .replace(/<BRACES>/g, function () {
+                  return a;
+                })
+                .replace(/<SPREAD>/g, function () {
+                  return r;
+                })),
+              t,
+            );
+          }
+          (r = o(r).source),
+            (e.languages.jsx = e.languages.extend('markup', t)),
+            (e.languages.jsx.tag.pattern = o(
+              /<\/?(?:[\w.:-]+(?:<S>+(?:[\w.:$-]+(?:=(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s{'"/>=]+|<BRACES>))?|<SPREAD>))*<S>*\/?)?>/
+                .source,
+            )),
+            (e.languages.jsx.tag.inside.tag.pattern = /^<\/?[^\s>\/]*/),
+            (e.languages.jsx.tag.inside['attr-value'].pattern =
+              /=(?!\{)(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s'">]+)/),
+            (e.languages.jsx.tag.inside.tag.inside['class-name'] =
+              /^[A-Z]\w*(?:\.[A-Z]\w*)*$/),
+            (e.languages.jsx.tag.inside.comment = t.comment),
+            e.languages.insertBefore(
+              'inside',
+              'attr-name',
+              {
+                spread: {
+                  pattern: o(/<SPREAD>/.source),
+                  inside: e.languages.jsx,
+                },
+              },
+              e.languages.jsx.tag,
+            ),
+            e.languages.insertBefore(
+              'inside',
+              'special-attr',
+              {
+                script: {
+                  pattern: o(/=<BRACES>/.source),
+                  alias: 'language-javascript',
+                  inside: {
+                    'script-punctuation': {
+                      pattern: /^=(?=\{)/,
+                      alias: 'punctuation',
+                    },
+                    'rest': e.languages.jsx,
+                  },
+                },
+              },
+              e.languages.jsx.tag,
+            );
+          var i = function (e) {
+              return e
+                ? 'string' == typeof e
+                  ? e
+                  : 'string' == typeof e.content
+                  ? e.content
+                  : e.content.map(i).join('')
+                : '';
+            },
+            s = function (t) {
+              for (var n = [], a = 0; a < t.length; a++) {
+                var r = t[a],
+                  o = !1;
+                if (
+                  ('string' != typeof r &&
+                    ('tag' === r.type &&
+                    r.content[0] &&
+                    'tag' === r.content[0].type
+                      ? '</' === r.content[0].content[0].content
+                        ? n.length > 0 &&
+                          n[n.length - 1].tagName ===
+                            i(r.content[0].content[1]) &&
+                          n.pop()
+                        : '/>' === r.content[r.content.length - 1].content ||
+                          n.push({
+                            tagName: i(r.content[0].content[1]),
+                            openedBraces: 0,
+                          })
+                      : n.length > 0 &&
+                        'punctuation' === r.type &&
+                        '{' === r.content
+                      ? n[n.length - 1].openedBraces++
+                      : n.length > 0 &&
+                        n[n.length - 1].openedBraces > 0 &&
+                        'punctuation' === r.type &&
+                        '}' === r.content
+                      ? n[n.length - 1].openedBraces--
+                      : (o = !0)),
+                  (o || 'string' == typeof r) &&
+                    n.length > 0 &&
+                    0 === n[n.length - 1].openedBraces)
+                ) {
+                  var l = i(r);
+                  a < t.length - 1 &&
+                    ('string' == typeof t[a + 1] ||
+                      'plain-text' === t[a + 1].type) &&
+                    ((l += i(t[a + 1])), t.splice(a + 1, 1)),
+                    a > 0 &&
+                      ('string' == typeof t[a - 1] ||
+                        'plain-text' === t[a - 1].type) &&
+                      ((l = i(t[a - 1]) + l), t.splice(a - 1, 1), a--),
+                    (t[a] = new e.Token('plain-text', l, null, l));
+                }
+                r.content && 'string' != typeof r.content && s(r.content);
+              }
+            };
+          e.hooks.add('after-tokenize', function (e) {
+            ('jsx' === e.language || 'tsx' === e.language) && s(e.tokens);
+          });
+        })(I),
+        ((f = I).languages.diff = {
+          coord: [/^(?:\*{3}|-{3}|\+{3}).*$/m, /^@@.*@@$/m, /^\d.*$/m],
+        }),
+        Object.keys(
+          (m = {
+            'deleted-sign': '-',
+            'deleted-arrow': '<',
+            'inserted-sign': '+',
+            'inserted-arrow': '>',
+            'unchanged': ' ',
+            'diff': '!',
+          }),
+        ).forEach(function (e) {
+          var t = m[e],
+            n = [];
+          /^\w+$/.test(e) || n.push(/\w+/.exec(e)[0]),
+            'diff' === e && n.push('bold'),
+            (f.languages.diff[e] = {
+              pattern: RegExp(
+                '^(?:[' + t + '].*(?:\r\n?|\n|(?![\\s\\S])))+',
+                'm',
+              ),
+              alias: n,
+              inside: {
+                line: {
+                  pattern: /(.)(?=[\s\S]).*(?:\r\n?|\n)?/,
+                  lookbehind: !0,
+                },
+                prefix: { pattern: /[\s\S]/, alias: /\w+/.exec(e)[0] },
+              },
+            });
+        }),
+        Object.defineProperty(f.languages.diff, 'PREFIXES', { value: m }),
+        (I.languages.git = {
+          'comment': /^#.*/m,
+          'deleted': /^[-–].*/m,
+          'inserted': /^\+.*/m,
+          'string': /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+          'command': {
+            pattern: /^.*\$ git .*$/m,
+            inside: { parameter: /\s--?\w+/ },
+          },
+          'coord': /^@@.*@@$/m,
+          'commit-sha1': /^commit \w{40}$/m,
+        }),
+        (I.languages.go = I.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/,
+        })),
+        I.languages.insertBefore('go', 'string', {
+          char: { pattern: /'(?:\\.|[^'\\\r\n]){0,10}'/, greedy: !0 },
+        }),
+        delete I.languages.go['class-name'],
+        (function (e) {
+          function t(e, t) {
+            return '___' + e.toUpperCase() + t + '___';
+          }
+          Object.defineProperties((e.languages['markup-templating'] = {}), {
+            buildPlaceholders: {
+              value: function (n, a, r, o) {
+                if (n.language === a) {
+                  var i = (n.tokenStack = []);
+                  (n.code = n.code.replace(r, function (e) {
+                    if ('function' == typeof o && !o(e)) return e;
+                    for (
+                      var r, s = i.length;
+                      -1 !== n.code.indexOf((r = t(a, s)));
+
+                    )
+                      ++s;
+                    return (i[s] = e), r;
+                  })),
+                    (n.grammar = e.languages.markup);
+                }
+              },
+            },
+            tokenizePlaceholders: {
+              value: function (n, a) {
+                if (n.language === a && n.tokenStack) {
+                  n.grammar = e.languages[a];
+                  var r = 0,
+                    o = Object.keys(n.tokenStack);
+                  !(function i(s) {
+                    for (var l = 0; l < s.length && !(r >= o.length); l++) {
+                      var u = s[l];
+                      if (
+                        'string' == typeof u ||
+                        (u.content && 'string' == typeof u.content)
+                      ) {
+                        var c = o[r],
+                          d = n.tokenStack[c],
+                          p = 'string' == typeof u ? u : u.content,
+                          g = t(a, c),
+                          f = p.indexOf(g);
+                        if (f > -1) {
+                          ++r;
+                          var m = p.substring(0, f),
+                            b = new e.Token(
+                              a,
+                              e.tokenize(d, n.grammar),
+                              'language-' + a,
+                              d,
+                            ),
+                            h = p.substring(f + g.length),
+                            y = [];
+                          m && y.push.apply(y, i([m])),
+                            y.push(b),
+                            h && y.push.apply(y, i([h])),
+                            'string' == typeof u
+                              ? s.splice.apply(s, [l, 1].concat(y))
+                              : (u.content = y);
+                        }
+                      } else u.content && i(u.content);
+                    }
+                    return s;
+                  })(n.tokens);
+                }
+              },
+            },
+          });
+        })(I),
+        ((b = I).languages.handlebars = {
+          comment: /\{\{![\s\S]*?\}\}/,
+          delimiter: { pattern: /^\{\{\{?|\}\}\}?$/, alias: 'punctuation' },
+          string: /(["'])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+          number:
+            /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee][+-]?\d+)?/,
+          boolean: /\b(?:false|true)\b/,
+          block: {
+            pattern: /^(\s*(?:~\s*)?)[#\/]\S+?(?=\s*(?:~\s*)?$|\s)/,
+            lookbehind: !0,
+            alias: 'keyword',
+          },
+          brackets: {
+            pattern: /\[[^\]]+\]/,
+            inside: { punctuation: /\[|\]/, variable: /[\s\S]+/ },
+          },
+          punctuation: /[!"#%&':()*+,.\/;<=>@\[\\\]^`{|}~]/,
+          variable: /[^!"#%&'()*+,\/;<=>@\[\\\]^`{|}~\s]+/,
+        }),
+        b.hooks.add('before-tokenize', function (e) {
+          b.languages['markup-templating'].buildPlaceholders(
+            e,
+            'handlebars',
+            /\{\{\{[\s\S]+?\}\}\}|\{\{[\s\S]+?\}\}/g,
+          );
+        }),
+        b.hooks.add('after-tokenize', function (e) {
+          b.languages['markup-templating'].tokenizePlaceholders(
+            e,
+            'handlebars',
+          );
+        }),
+        (b.languages.hbs = b.languages.handlebars),
+        (I.languages.json = {
+          property: {
+            pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?=\s*:)/,
+            lookbehind: !0,
+            greedy: !0,
+          },
+          string: {
+            pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?!\s*:)/,
+            lookbehind: !0,
+            greedy: !0,
+          },
+          comment: { pattern: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/, greedy: !0 },
+          number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+          punctuation: /[{}[\],]/,
+          operator: /:/,
+          boolean: /\b(?:false|true)\b/,
+          null: { pattern: /\bnull\b/, alias: 'keyword' },
+        }),
+        (I.languages.webmanifest = I.languages.json),
+        (I.languages.less = I.languages.extend('css', {
+          comment: [
+            /\/\*[\s\S]*?\*\//,
+            { pattern: /(^|[^\\])\/\/.*/, lookbehind: !0 },
+          ],
+          atrule: {
+            pattern:
+              /@[\w-](?:\((?:[^(){}]|\([^(){}]*\))*\)|[^(){};\s]|\s+(?!\s))*?(?=\s*\{)/,
+            inside: { punctuation: /[:()]/ },
+          },
+          selector: {
+            pattern:
+              /(?:@\{[\w-]+\}|[^{};\s@])(?:@\{[\w-]+\}|\((?:[^(){}]|\([^(){}]*\))*\)|[^(){};@\s]|\s+(?!\s))*?(?=\s*\{)/,
+            inside: { variable: /@+[\w-]+/ },
+          },
+          property: /(?:@\{[\w-]+\}|[\w-])+(?:\+_?)?(?=\s*:)/,
+          operator: /[+\-*\/]/,
+        })),
+        I.languages.insertBefore('less', 'property', {
+          'variable': [
+            { pattern: /@[\w-]+\s*:/, inside: { punctuation: /:/ } },
+            /@@?[\w-]+/,
+          ],
+          'mixin-usage': {
+            pattern: /([{;]\s*)[.#](?!\d)[\w-].*?(?=[(;])/,
+            lookbehind: !0,
+            alias: 'function',
+          },
+        }),
+        (I.languages.makefile = {
+          'comment': {
+            pattern: /(^|[^\\])#(?:\\(?:\r\n|[\s\S])|[^\\\r\n])*/,
+            lookbehind: !0,
+          },
+          'string': {
+            pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+            greedy: !0,
+          },
+          'builtin-target': {
+            pattern: /\.[A-Z][^:#=\s]+(?=\s*:(?!=))/,
+            alias: 'builtin',
+          },
+          'target': {
+            pattern: /^(?:[^:=\s]|[ \t]+(?![\s:]))+(?=\s*:(?!=))/m,
+            alias: 'symbol',
+            inside: { variable: /\$+(?:(?!\$)[^(){}:#=\s]+|(?=[({]))/ },
+          },
+          'variable': /\$+(?:(?!\$)[^(){}:#=\s]+|\([@*%<^+?][DF]\)|(?=[({]))/,
+          'keyword':
+            /-include\b|\b(?:define|else|endef|endif|export|ifn?def|ifn?eq|include|override|private|sinclude|undefine|unexport|vpath)\b/,
+          'function': {
+            pattern:
+              /(\()(?:abspath|addsuffix|and|basename|call|dir|error|eval|file|filter(?:-out)?|findstring|firstword|flavor|foreach|guile|if|info|join|lastword|load|notdir|or|origin|patsubst|realpath|shell|sort|strip|subst|suffix|value|warning|wildcard|word(?:list|s)?)(?=[ \t])/,
+            lookbehind: !0,
+          },
+          'operator': /(?:::|[?:+!])?=|[|@]/,
+          'punctuation': /[:;(){}]/,
+        }),
+        (I.languages.objectivec = I.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 I.languages.objectivec['class-name'],
+        (I.languages.objc = I.languages.objectivec),
+        (I.languages.ocaml = {
+          'comment': { pattern: /\(\*[\s\S]*?\*\)/, greedy: !0 },
+          'char': {
+            pattern: /'(?:[^\\\r\n']|\\(?:.|[ox]?[0-9a-f]{1,3}))'/i,
+            greedy: !0,
+          },
+          'string': [
+            { pattern: /"(?:\\(?:[\s\S]|\r\n)|[^\\\r\n"])*"/, greedy: !0 },
+            { pattern: /\{([a-z_]*)\|[\s\S]*?\|\1\}/, greedy: !0 },
+          ],
+          'number': [
+            /\b(?:0b[01][01_]*|0o[0-7][0-7_]*)\b/i,
+            /\b0x[a-f0-9][a-f0-9_]*(?:\.[a-f0-9_]*)?(?:p[+-]?\d[\d_]*)?(?!\w)/i,
+            /\b\d[\d_]*(?:\.[\d_]*)?(?:e[+-]?\d[\d_]*)?(?!\w)/i,
+          ],
+          'directive': { pattern: /\B#\w+/, alias: 'property' },
+          'label': { pattern: /\B~\w+/, alias: 'property' },
+          'type-variable': { pattern: /\B'\w+/, alias: 'function' },
+          'variant': { pattern: /`\w+/, alias: 'symbol' },
+          'keyword':
+            /\b(?:as|assert|begin|class|constraint|do|done|downto|else|end|exception|external|for|fun|function|functor|if|in|include|inherit|initializer|lazy|let|match|method|module|mutable|new|nonrec|object|of|open|private|rec|sig|struct|then|to|try|type|val|value|virtual|when|where|while|with)\b/,
+          'boolean': /\b(?:false|true)\b/,
+          'operator-like-punctuation': {
+            pattern: /\[[<>|]|[>|]\]|\{<|>\}/,
+            alias: 'punctuation',
+          },
+          'operator':
+            /\.[.~]|:[=>]|[=<>@^|&+\-*\/$%!?~][!$%&*+\-.\/:<=>?@^|~]*|\b(?:and|asr|land|lor|lsl|lsr|lxor|mod|or)\b/,
+          'punctuation': /;;|::|[(){}\[\].,:;#]|\b_\b/,
+        }),
+        (I.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': /[{}[\];(),.:]/,
+        }),
+        (I.languages.python[
+          'string-interpolation'
+        ].inside.interpolation.inside.rest = I.languages.python),
+        (I.languages.py = I.languages.python),
+        (I.languages.reason = I.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/,
+        })),
+        I.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 I.languages.reason.function,
+        ((h = I).languages.sass = h.languages.extend('css', {
+          comment: {
+            pattern: /^([ \t]*)\/[\/*].*(?:(?:\r?\n|\r)\1[ \t].+)*/m,
+            lookbehind: !0,
+            greedy: !0,
+          },
+        })),
+        h.languages.insertBefore('sass', 'atrule', {
+          'atrule-line': {
+            pattern: /^(?:[ \t]*)[@+=].+/m,
+            greedy: !0,
+            inside: { atrule: /(?:@[\w-]+|[+=])/ },
+          },
+        }),
+        delete h.languages.sass.atrule,
+        (y = /\$[-\w]+|#\{\$[-\w]+\}/),
+        (v = [
+          /[+*\/%]|[=!]=|<=?|>=?|\b(?:and|not|or)\b/,
+          { pattern: /(\s)-(?=\s)/, lookbehind: !0 },
+        ]),
+        h.languages.insertBefore('sass', 'property', {
+          'variable-line': {
+            pattern: /^[ \t]*\$.+/m,
+            greedy: !0,
+            inside: { punctuation: /:/, variable: y, operator: v },
+          },
+          'property-line': {
+            pattern: /^[ \t]*(?:[^:\s]+ *:.*|:[^:\s].*)/m,
+            greedy: !0,
+            inside: {
+              property: [
+                /[^:\s]+(?=\s*:)/,
+                { pattern: /(:)[^:\s]+/, lookbehind: !0 },
+              ],
+              punctuation: /:/,
+              variable: y,
+              operator: v,
+              important: h.languages.sass.important,
+            },
+          },
+        }),
+        delete h.languages.sass.property,
+        delete h.languages.sass.important,
+        h.languages.insertBefore('sass', 'punctuation', {
+          selector: {
+            pattern:
+              /^([ \t]*)\S(?:,[^,\r\n]+|[^,\r\n]*)(?:,[^,\r\n]+)*(?:,(?:\r?\n|\r)\1[ \t]+\S(?:,[^,\r\n]+|[^,\r\n]*)(?:,[^,\r\n]+)*)*/m,
+            lookbehind: !0,
+            greedy: !0,
+          },
+        }),
+        (I.languages.scss = I.languages.extend('css', {
+          comment: {
+            pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
+            lookbehind: !0,
+          },
+          atrule: {
+            pattern: /@[\w-](?:\([^()]+\)|[^()\s]|\s+(?!\s))*?(?=\s+[{;])/,
+            inside: { rule: /@[\w-]+/ },
+          },
+          url: /(?:[-a-z]+-)?url(?=\()/i,
+          selector: {
+            pattern:
+              /(?=\S)[^@;{}()]?(?:[^@;{}()\s]|\s+(?!\s)|#\{\$[-\w]+\})+(?=\s*\{(?:\}|\s|[^}][^:{}]*[:{][^}]))/,
+            inside: {
+              parent: { pattern: /&/, alias: 'important' },
+              placeholder: /%[-\w]+/,
+              variable: /\$[-\w]+|#\{\$[-\w]+\}/,
+            },
+          },
+          property: {
+            pattern: /(?:[-\w]|\$[-\w]|#\{\$[-\w]+\})+(?=\s*:)/,
+            inside: { variable: /\$[-\w]+|#\{\$[-\w]+\}/ },
+          },
+        })),
+        I.languages.insertBefore('scss', 'atrule', {
+          keyword: [
+            /@(?:content|debug|each|else(?: if)?|extend|for|forward|function|if|import|include|mixin|return|use|warn|while)\b/i,
+            { pattern: /( )(?:from|through)(?= )/, lookbehind: !0 },
+          ],
+        }),
+        I.languages.insertBefore('scss', 'important', {
+          variable: /\$[-\w]+|#\{\$[-\w]+\}/,
+        }),
+        I.languages.insertBefore('scss', 'function', {
+          'module-modifier': {
+            pattern: /\b(?:as|hide|show|with)\b/i,
+            alias: 'keyword',
+          },
+          'placeholder': { pattern: /%[-\w]+/, alias: 'selector' },
+          'statement': {
+            pattern: /\B!(?:default|optional)\b/i,
+            alias: 'keyword',
+          },
+          'boolean': /\b(?:false|true)\b/,
+          'null': { pattern: /\bnull\b/, alias: 'keyword' },
+          'operator': {
+            pattern: /(\s)(?:[-+*\/%]|[=!]=|<=?|>=?|and|not|or)(?=\s)/,
+            lookbehind: !0,
+          },
+        }),
+        (I.languages.scss.atrule.inside.rest = I.languages.scss),
+        (E = I),
+        ((w = {
+          comment: {
+            pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
+            lookbehind: !0,
+          },
+          url: { pattern: /\burl\((["']?).*?\1\)/i, greedy: !0 },
+          string: {
+            pattern: /("|')(?:(?!\1)[^\\\r\n]|\\(?:\r\n|[\s\S]))*\1/,
+            greedy: !0,
+          },
+          interpolation: null,
+          func: null,
+          important: /\B!(?:important|optional)\b/i,
+          keyword: {
+            pattern: /(^|\s+)(?:(?:else|for|if|return|unless)(?=\s|$)|@[\w-]+)/,
+            lookbehind: !0,
+          },
+          hexcode: /#[\da-f]{3,6}/i,
+          color: [
+            /\b(?: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|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)\b/i,
+            {
+              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: (k = { pattern: /(\b\d+)(?:%|[a-z]+)/, lookbehind: !0 }),
+                number: (S = {
+                  pattern: /(^|[^\w.-])-?(?:\d+(?:\.\d+)?|\.\d+)/,
+                  lookbehind: !0,
+                }),
+                function: /[\w-]+(?=\()/,
+                punctuation: /[(),]/,
+              },
+            },
+          ],
+          entity: /\\[\da-f]{1,8}/i,
+          unit: k,
+          boolean: /\b(?:false|true)\b/,
+          operator: [
+            /~|[+!\/%<>?=]=?|[-:]=|\*[*=]?|\.{2,3}|&&|\|\||\B-\B|\b(?:and|in|is(?: a| defined| not|nt)?|not|or)\b/,
+          ],
+          number: S,
+          punctuation: /[{}()\[\];:,]/,
+        }).interpolation = {
+          pattern: /\{[^\r\n}:]+\}/,
+          alias: 'variable',
+          inside: {
+            delimiter: { pattern: /^\{|\}$/, alias: 'punctuation' },
+            rest: w,
+          },
+        }),
+        (w.func = {
+          pattern: /[\w-]+\([^)]*\).*/,
+          inside: { function: /^[^(]+/, rest: w },
+        }),
+        (E.languages.stylus = {
+          'atrule-declaration': {
+            pattern: /(^[ \t]*)@.+/m,
+            lookbehind: !0,
+            inside: { atrule: /^@[\w-]+/, rest: w },
+          },
+          'variable-declaration': {
+            pattern: /(^[ \t]*)[\w$-]+\s*.?=[ \t]*(?:\{[^{}]*\}|\S.*|$)/m,
+            lookbehind: !0,
+            inside: { variable: /^\S+/, rest: w },
+          },
+          'statement': {
+            pattern: /(^[ \t]*)(?:else|for|if|return|unless)[ \t].+/m,
+            lookbehind: !0,
+            inside: { keyword: /^\S+/, rest: w },
+          },
+          'property-declaration': {
+            pattern:
+              /((?:^|\{)([ \t]*))(?:[\w-]|\{[^}\r\n]+\})+(?:\s*:\s*|[ \t]+)(?!\s)[^{\r\n]*(?:;|[^{\r\n,]$(?!(?:\r?\n|\r)(?:\{|\2[ \t])))/m,
+            lookbehind: !0,
+            inside: {
+              property: {
+                pattern: /^[^\s:]+/,
+                inside: { interpolation: w.interpolation },
+              },
+              rest: w,
+            },
+          },
+          'selector': {
+            pattern:
+              /(^[ \t]*)(?:(?=\S)(?:[^{}\r\n:()]|::?[\w-]+(?:\([^)\r\n]*\)|(?![\w-]))|\{[^}\r\n]+\})+)(?:(?:\r?\n|\r)(?:\1(?:(?=\S)(?:[^{}\r\n:()]|::?[\w-]+(?:\([^)\r\n]*\)|(?![\w-]))|\{[^}\r\n]+\})+)))*(?:,$|\{|(?=(?:\r?\n|\r)(?:\{|\1[ \t])))/m,
+            lookbehind: !0,
+            inside: {
+              interpolation: w.interpolation,
+              comment: w.comment,
+              punctuation: /[{},]/,
+            },
+          },
+          'func': w.func,
+          'string': w.string,
+          'comment': {
+            pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
+            lookbehind: !0,
+            greedy: !0,
+          },
+          'interpolation': w.interpolation,
+          'punctuation': /[{}()\[\];:.]/,
+        }),
+        (_ = (A = I).util.clone(A.languages.typescript)),
+        (A.languages.tsx = A.languages.extend('jsx', _)),
+        delete A.languages.tsx.parameter,
+        delete A.languages.tsx['literal-property'],
+        ((T = A.languages.tsx.tag).pattern = RegExp(
+          /(^|[^\w$]|(?=<\/))/.source + '(?:' + T.pattern.source + ')',
+          T.pattern.flags,
+        )),
+        (T.lookbehind = !0),
+        (I.languages.wasm = {
+          comment: [/\(;[\s\S]*?;\)/, { pattern: /;;.*/, greedy: !0 }],
+          string: { pattern: /"(?:\\[\s\S]|[^"\\])*"/, greedy: !0 },
+          keyword: [
+            { pattern: /\b(?:align|offset)=/, inside: { operator: /=/ } },
+            {
+              pattern:
+                /\b(?:(?:f32|f64|i32|i64)(?:\.(?:abs|add|and|ceil|clz|const|convert_[su]\/i(?:32|64)|copysign|ctz|demote\/f64|div(?:_[su])?|eqz?|extend_[su]\/i32|floor|ge(?:_[su])?|gt(?:_[su])?|le(?:_[su])?|load(?:(?:8|16|32)_[su])?|lt(?:_[su])?|max|min|mul|neg?|nearest|or|popcnt|promote\/f32|reinterpret\/[fi](?:32|64)|rem_[su]|rot[lr]|shl|shr_[su]|sqrt|store(?:8|16|32)?|sub|trunc(?:_[su]\/f(?:32|64))?|wrap\/i64|xor))?|memory\.(?:grow|size))\b/,
+              inside: { punctuation: /\./ },
+            },
+            /\b(?:anyfunc|block|br(?:_if|_table)?|call(?:_indirect)?|data|drop|elem|else|end|export|func|get_(?:global|local)|global|if|import|local|loop|memory|module|mut|nop|offset|param|result|return|select|set_(?:global|local)|start|table|tee_local|then|type|unreachable)\b/,
+          ],
+          variable: /\$[\w!#$%&'*+\-./:<=>?@\\^`|~]+/,
+          number:
+            /[+-]?\b(?:\d(?:_?\d)*(?:\.\d(?:_?\d)*)?(?:[eE][+-]?\d(?:_?\d)*)?|0x[\da-fA-F](?:_?[\da-fA-F])*(?:\.[\da-fA-F](?:_?[\da-fA-D])*)?(?:[pP][+-]?\d(?:_?\d)*)?)\b|\binf\b|\bnan(?::0x[\da-fA-F](?:_?[\da-fA-D])*)?\b/,
+          punctuation: /[()]/,
+        });
+      var x = n(7294),
+        O = {
+          Prism: I,
+          theme: {
+            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' } },
+            ],
+          },
+        };
+      function N(e, t, n) {
+        return (
+          t in e
+            ? Object.defineProperty(e, t, {
+                value: n,
+                enumerable: !0,
+                configurable: !0,
+                writable: !0,
+              })
+            : (e[t] = n),
+          e
+        );
+      }
+      function F() {
+        return (F =
+          Object.assign ||
+          function (e) {
+            for (var t = 1; t < arguments.length; t++) {
+              var n = arguments[t];
+              for (var a in n)
+                Object.prototype.hasOwnProperty.call(n, a) && (e[a] = n[a]);
+            }
+            return e;
+          }).apply(this, arguments);
+      }
+      var C = /\r\n|\r|\n/,
+        L = function (e) {
+          0 === e.length
+            ? e.push({ types: ['plain'], content: '\n', empty: !0 })
+            : 1 === e.length &&
+              '' === e[0].content &&
+              ((e[0].content = '\n'), (e[0].empty = !0));
+        },
+        D = function (e, t) {
+          var n = e.length;
+          return n > 0 && e[n - 1] === t ? e : e.concat(t);
+        },
+        P = function (e) {
+          for (
+            var t = [[]],
+              n = [e],
+              a = [0],
+              r = [e.length],
+              o = 0,
+              i = 0,
+              s = [],
+              l = [s];
+            i > -1;
+
+          ) {
+            for (; (o = a[i]++) < r[i]; ) {
+              var u = void 0,
+                c = t[i],
+                d = n[i][o];
+              if (
+                ('string' == typeof d
+                  ? ((c = i > 0 ? c : ['plain']), (u = d))
+                  : ((c = D(c, d.type)),
+                    d.alias && (c = D(c, d.alias)),
+                    (u = d.content)),
+                'string' != typeof u)
+              ) {
+                i++, t.push(c), n.push(u), a.push(0), r.push(u.length);
+                continue;
+              }
+              var p = u.split(C),
+                g = p.length;
+              s.push({ types: c, content: p[0] });
+              for (var f = 1; f < g; f++)
+                L(s), l.push((s = [])), s.push({ types: c, content: p[f] });
+            }
+            i--, t.pop(), n.pop(), a.pop(), r.pop();
+          }
+          return L(s), l;
+        },
+        B = function (e, t) {
+          var n = e.plain,
+            a = Object.create(null),
+            r = e.styles.reduce(function (e, n) {
+              var a = n.languages,
+                r = n.style;
+              return (
+                (a && !a.includes(t)) ||
+                  n.types.forEach(function (t) {
+                    var n = F({}, e[t], r);
+                    e[t] = n;
+                  }),
+                e
+              );
+            }, a);
+          return (
+            (r.root = n), (r.plain = F({}, n, { backgroundColor: null })), r
+          );
+        };
+      function M(e, t) {
+        var n = {};
+        for (var a in e)
+          Object.prototype.hasOwnProperty.call(e, a) &&
+            -1 === t.indexOf(a) &&
+            (n[a] = e[a]);
+        return n;
+      }
+      var $ = (function (e) {
+        function t() {
+          for (var t = this, n = [], a = arguments.length; a--; )
+            n[a] = arguments[a];
+          e.apply(this, n),
+            N(this, 'getThemeDict', function (e) {
+              if (
+                void 0 !== t.themeDict &&
+                e.theme === t.prevTheme &&
+                e.language === t.prevLanguage
+              )
+                return t.themeDict;
+              (t.prevTheme = e.theme), (t.prevLanguage = e.language);
+              var n = e.theme ? B(e.theme, e.language) : void 0;
+              return (t.themeDict = n);
+            }),
+            N(this, 'getLineProps', function (e) {
+              var n = e.key,
+                a = e.className,
+                r = e.style,
+                o = F({}, M(e, ['key', 'className', 'style', 'line']), {
+                  className: 'token-line',
+                  style: void 0,
+                  key: void 0,
+                }),
+                i = t.getThemeDict(t.props);
+              return (
+                void 0 !== i && (o.style = i.plain),
+                void 0 !== r &&
+                  (o.style = void 0 !== o.style ? F({}, o.style, r) : r),
+                void 0 !== n && (o.key = n),
+                a && (o.className += ' ' + a),
+                o
+              );
+            }),
+            N(this, 'getStyleForToken', function (e) {
+              var n = e.types,
+                a = e.empty,
+                r = n.length,
+                o = t.getThemeDict(t.props);
+              if (void 0 !== o) {
+                if (1 === r && 'plain' === n[0])
+                  return a ? { display: 'inline-block' } : void 0;
+                if (1 === r && !a) return o[n[0]];
+                var i = n.map(function (e) {
+                  return o[e];
+                });
+                return Object.assign.apply(
+                  Object,
+                  [a ? { display: 'inline-block' } : {}].concat(i),
+                );
+              }
+            }),
+            N(this, 'getTokenProps', function (e) {
+              var n = e.key,
+                a = e.className,
+                r = e.style,
+                o = e.token,
+                i = F({}, M(e, ['key', 'className', 'style', 'token']), {
+                  className: 'token ' + o.types.join(' '),
+                  children: o.content,
+                  style: t.getStyleForToken(o),
+                  key: void 0,
+                });
+              return (
+                void 0 !== r &&
+                  (i.style = void 0 !== i.style ? F({}, i.style, r) : r),
+                void 0 !== n && (i.key = n),
+                a && (i.className += ' ' + a),
+                i
+              );
+            }),
+            N(this, 'tokenize', function (e, t, n, a) {
+              var r = { code: t, grammar: n, language: a, tokens: [] };
+              e.hooks.run('before-tokenize', r);
+              var o = (r.tokens = e.tokenize(r.code, r.grammar, r.language));
+              return e.hooks.run('after-tokenize', r), o;
+            });
+        }
+        return (
+          e && (t.__proto__ = e),
+          (t.prototype = Object.create(e && e.prototype)),
+          (t.prototype.constructor = t),
+          (t.prototype.render = function () {
+            var e = this.props,
+              t = e.Prism,
+              n = e.language,
+              a = e.code,
+              r = e.children,
+              o = this.getThemeDict(this.props),
+              i = t.languages[n];
+            return r({
+              tokens: P(void 0 !== i ? this.tokenize(t, a, i, n) : [a]),
+              className: 'prism-code language-' + n,
+              style: void 0 !== o ? o.root : {},
+              getLineProps: this.getLineProps,
+              getTokenProps: this.getTokenProps,
+            });
+          }),
+          t
+        );
+      })(x.Component);
+    },
+    7462: function (e, t, n) {
+      'use strict';
+      function a() {
+        return (a = Object.assign
+          ? Object.assign.bind()
+          : function (e) {
+              for (var t = 1; t < arguments.length; t++) {
+                var n = arguments[t];
+                for (var a in n)
+                  Object.prototype.hasOwnProperty.call(n, a) && (e[a] = n[a]);
+              }
+              return e;
+            }).apply(this, arguments);
+      }
+      n.d(t, {
+        Z: function () {
+          return a;
+        },
+      });
+    },
+  },
+]);