reactjs-tiptap-editor 0.2.29 → 0.3.0

package/lib/CodeBlock.js

@@ -0,0 +1,3639 @@
+import { N as Wn, t as Dt, m as qn } from "./index-Drmyqk9P.js";
+import { N as jn, c as Ne, R as Yn } from "./dom-dataset-CJ7GyQ2E.js";
+import { jsxs as me, jsx as T } from "react/jsx-runtime";
+import { d as te, A as Xn, _ as Qn, a5 as Jn, k as we } from "./RichTextEditor-Cy9XKEI5.js";
+import * as de from "react";
+import { useRef as $t, useCallback as ea, useEffect as Ft } from "react";
+import * as F from "@radix-ui/react-select";
+import { ChevronDown as En, ChevronUp as ta, Check as na } from "lucide-react";
+const Ut = F.Root, aa = F.Value, dt = de.forwardRef(({ className: e, children: t, ...n }, s) => /* @__PURE__ */ me(
+  F.Trigger,
+  {
+    ref: s,
+    className: te(
+      "richtext-flex richtext-h-10 richtext-w-full richtext-items-center richtext-justify-between richtext-rounded-md richtext-border richtext-border-input richtext-bg-background richtext-px-3 richtext-py-2 richtext-text-sm richtext-ring-offset-background placeholder:richtext-text-muted-foreground focus:richtext-outline-none focus:richtext-ring-2 focus:richtext-ring-ring focus:richtext-ring-offset-2 disabled:richtext-cursor-not-allowed disabled:richtext-opacity-50 [&>span]:richtext-line-clamp-1",
+      e
+    ),
+    ...n,
+    children: [
+      t,
+      /* @__PURE__ */ T(F.Icon, { asChild: !0, children: /* @__PURE__ */ T(En, { className: "richtext-h-4 richtext-w-4 richtext-opacity-50" }) })
+    ]
+  }
+));
+dt.displayName = F.Trigger.displayName;
+const _n = de.forwardRef(({ className: e, ...t }, n) => /* @__PURE__ */ T(
+  F.ScrollUpButton,
+  {
+    ref: n,
+    className: te(
+      "richtext-flex richtext-cursor-default richtext-items-center richtext-justify-center richtext-py-1",
+      e
+    ),
+    ...t,
+    children: /* @__PURE__ */ T(ta, { className: "richtext-h-4 richtext-w-4" })
+  }
+));
+_n.displayName = F.ScrollUpButton.displayName;
+const yn = de.forwardRef(({ className: e, ...t }, n) => /* @__PURE__ */ T(
+  F.ScrollDownButton,
+  {
+    ref: n,
+    className: te(
+      "richtext-flex richtext-cursor-default richtext-items-center richtext-justify-center richtext-py-1",
+      e
+    ),
+    ...t,
+    children: /* @__PURE__ */ T(En, { className: "richtext-h-4 richtext-w-4" })
+  }
+));
+yn.displayName = F.ScrollDownButton.displayName;
+const ut = de.forwardRef(({ className: e, children: t, position: n = "popper", ...s }, d) => /* @__PURE__ */ T(F.Portal, { children: /* @__PURE__ */ me(
+  F.Content,
+  {
+    ref: d,
+    className: te(
+      "richtext-relative richtext-z-50 richtext-max-h-60 richtext-overflow-y-auto richtext-min-w-[8rem] richtext-overflow-hidden richtext-rounded-md richtext-border richtext-bg-popover richtext-text-popover-foreground richtext-shadow-md data-[state=open]:richtext-animate-in data-[state=closed]:richtext-animate-out data-[state=closed]:richtext-fade-out-0 data-[state=open]:richtext-fade-in-0 data-[state=closed]:richtext-zoom-out-95 data-[state=open]:richtext-zoom-in-95 data-[side=bottom]:richtext-slide-in-from-top-2 data-[side=left]:richtext-slide-in-from-right-2 data-[side=right]:richtext-slide-in-from-left-2 data-[side=top]:richtext-slide-in-from-bottom-2",
+      n === "popper" && "data-[side=bottom]:richtext-translate-y-1 data-[side=left]:richtext--translate-x-1 data-[side=right]:richtext-translate-x-1 data-[side=top]:richtext--translate-y-1",
+      e
+    ),
+    position: n,
+    ...s,
+    children: [
+      /* @__PURE__ */ T(_n, {}),
+      /* @__PURE__ */ T(
+        F.Viewport,
+        {
+          className: te(
+            "richtext-p-1",
+            n === "popper" && "richtext-h-[var(--radix-select-trigger-height)] richtext-w-full richtext-min-w-[var(--radix-select-trigger-width)]"
+          ),
+          children: t
+        }
+      ),
+      /* @__PURE__ */ T(yn, {})
+    ]
+  }
+) }));
+ut.displayName = F.Content.displayName;
+const ra = de.forwardRef(({ className: e, ...t }, n) => /* @__PURE__ */ T(
+  F.Label,
+  {
+    ref: n,
+    className: te("richtext-py-1.5 richtext-pl-8 richtext-pr-2 richtext-text-sm richtext-font-semibold", e),
+    ...t
+  }
+));
+ra.displayName = F.Label.displayName;
+const pt = de.forwardRef(({ className: e, children: t, ...n }, s) => /* @__PURE__ */ me(
+  F.Item,
+  {
+    ref: s,
+    className: te(
+      "richtext-relative richtext-flex richtext-w-full richtext-cursor-default richtext-select-none richtext-items-center richtext-rounded-sm richtext-py-1.5 richtext-pl-8 richtext-pr-2 richtext-text-sm richtext-outline-none focus:richtext-bg-accent focus:richtext-text-accent-foreground data-[disabled]:richtext-pointer-events-none data-[disabled]:richtext-opacity-50",
+      e
+    ),
+    ...n,
+    children: [
+      /* @__PURE__ */ T("span", { className: "richtext-absolute richtext-left-2 richtext-flex richtext-h-3.5 richtext-w-3.5 richtext-items-center richtext-justify-center", children: /* @__PURE__ */ T(F.ItemIndicator, { children: /* @__PURE__ */ T(na, { className: "richtext-h-4 richtext-w-4" }) }) }),
+      /* @__PURE__ */ T(F.ItemText, { children: t })
+    ]
+  }
+));
+pt.displayName = F.Item.displayName;
+const ia = de.forwardRef(({ className: e, ...t }, n) => /* @__PURE__ */ T(
+  F.Separator,
+  {
+    ref: n,
+    className: te("richtext--mx-1 richtext-my-1 richtext-h-px richtext-bg-muted", e),
+    ...t
+  }
+));
+ia.displayName = F.Separator.displayName;
+function sa({ action: e, ...t }) {
+  return /* @__PURE__ */ T(
+    Xn,
+    {
+      action: e,
+      disabled: t == null ? void 0 : t.disabled,
+      icon: t == null ? void 0 : t.icon,
+      tooltip: t == null ? void 0 : t.tooltip
+    }
+  );
+}
+var ke = {}, Y = Symbol(), le = Symbol(), Rt = (e) => typeof e == "string" ? E[e] : e, E = {
+  plain: ke,
+  plaintext: ke,
+  text: ke,
+  txt: ke
+}, St = (e, t) => (t[le] || Ye)(e, t), Ye = (e, t) => {
+  for (var n = [e], s, d = [], p = 0; s = Rt(t[Y]); )
+    delete t[Y], Object.assign(t, s);
+  for (xn(e, t, n, 0); d[p++] = n[0], n = n[1]; ) ;
+  return d;
+}, Bt = "</span>", Oe = "", xe = "", vn = (e) => {
+  for (var t = "", n = e.length, s = 0; s < n; ) t += wn(e[s++]);
+  return t;
+}, wn = (e) => {
+  if (e instanceof fe) {
+    var { type: t, alias: n, content: s } = e, d = Oe, p = xe, b = `<span class="token ${t + (n ? " " + n : "") + (t == "keyword" && typeof s == "string" ? " keyword-" + s : "")}">`;
+    xe += Bt, Oe += b;
+    var m = wn(s);
+    return Oe = d, xe = p, b + m + Bt;
+  }
+  return typeof e != "string" ? vn(e) : (e = e.replace(/&/g, "&amp;").replace(/</g, "&lt;"), xe && e.includes(`
+`) ? e.replace(/\n/g, xe + `
+` + Oe) : e);
+}, xn = (e, t, n, s, d) => {
+  for (var p in t)
+    if (t[p]) for (var b = 0, m = t[p], _ = Array.isArray(m) ? m : [m]; b < _.length; ++b) {
+      if (d && d[0] == p && d[1] == b)
+        return;
+      for (var y = _[b], l = y.pattern || y, c = Rt(y.inside), w = y.lookbehind, g = y.greedy && l.global, h = y.alias, a = n, r = s; a && (!d || r < d[2]); r += a[0].length, a = a[1]) {
+        var u = a[0], o = 0, i, f;
+        if (!(u instanceof fe)) {
+          if (l.lastIndex = g ? r : 0, i = l.exec(g ? e : u), i && w && i[1] && (f = i[1].length, i.index += f, i[0] = i[0].slice(f)), g) {
+            if (!i)
+              break;
+            if (i[0]) {
+              for (var S = i.index, R = S + i[0].length, A; S >= r + (A = a[0].length); a = a[1], r += A) ;
+              if (a[0] instanceof fe)
+                continue;
+              for (var v = a, m = r; (m += v[0].length) < R; v = v[1], o++) ;
+              u = e.slice(r, m), i.index -= r;
+            }
+          }
+          if (i && i[0]) {
+            for (var S = i.index, k = i[0], N = u.slice(S + k.length), L = r + u.length, P = new fe(p, c ? St(k, c) : k, k, h), M = a, Z = 0, H; M = M[1], Z++ < o; ) ;
+            N && (!M || M[0] instanceof fe ? M = [N, M] : M[0] = N + M[0]), r += S, a[0] = S ? u.slice(0, S) : P, S ? a = a[1] = [P, M] : a[1] = M, o && (xn(e, t, a, r, H = [p, b, L]), L = H[2]), d && L > d[2] && (d[2] = L);
+          }
+        }
+      }
+    }
+};
+function fe(e, t, n, s) {
+  this.type = e, this.content = t, this.alias = s, this.length = n.length;
+}
+var Ge = "\\b(?:BASH(?:OPTS|_ALIASES|_ARG[CV]|_CMDS|_COMPLETION_COMPAT_DIR|_LINENO|_REMATCH|_SOURCE|_VERSINFO|_VERSION)?|COLORTERM|COLUMNS|COMP_WORDBREAKS|DBUS_SESSION_BUS_ADDRESS|DEFAULTS_PATH|DESKTOP_SESSION|DIRSTACK|DISPLAY|E?UID|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|ALL|IDENTIFICATION|MEASUREMENT|MONETARY|NAME|NUMERIC|PAPER|TELEPHONE|TIME)|LESSCLOSE|LESSOPEN|LINES|LOGNAME|LS_COLORS|MACHTYPE|MAILCHECK|MANDATORY_PATH|NO_AT_BRIDGE|OLDPWD|OPTERR|OPTIND|ORBIT_SOCKETDIR|OSTYPE|PAPERSIZE|PATH|PIPESTATUS|PPID|PS[1-4]|PWD|RANDOM|REPLY|SECONDS|SELINUX_INIT|SESSION|SESSIONTYPE|SESSION_MANAGER|SHELL|SHELLOPTS|SHLVL|SSH_AUTH_SOCK|TERM|UPSTART_EVENTS|UPSTART_INSTANCE|UPSTART_JOB|UPSTART_SESSION|USER|WINDOWID|XAUTHORITY|XDG_(?:CONFIG_DIRS|CURRENT_DESKTOP|DATA_DIRS|GREETER_DATA_DIR|MENU_PREFIX|RUNTIME_DIR|SEAT|SEAT_PATH|SESSION_DESKTOP|SESSION_ID|SESSION_PATH|SESSION_TYPE|VTNR)|XMODIFIERS)\\b", ft = {
+  pattern: /(^(["']?)\w+\2)[ 	]+\S.*/,
+  lookbehind: !0,
+  alias: "punctuation"
+  // this looks reasonably well in all themes
+}, An = {
+  variable: /^\$\(|^`|\)$|`$/
+}, Le = {
+  bash: ft,
+  environment: {
+    pattern: RegExp("\\$" + Ge),
+    alias: "constant"
+  },
+  variable: [
+    // [0]: Arithmetic Environment
+    {
+      pattern: /\$?\(\([^]*?\)\)/g,
+      greedy: !0,
+      inside: {
+        // If there is a $ sign at the beginning highlight $(( and )) as variable
+        variable: [
+          {
+            pattern: /(^\$[^]+)../,
+            lookbehind: !0
+          },
+          /^\$\(\(/
+        ],
+        number: /\b0x[a-fA-F\d]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee]-?\d+)?/,
+        // Operators according to https://www.gnu.org/software/bash/manual/bashref.html#Shell-Arithmetic
+        operator: /--|\+\+|&&|\|\||(?:\*\*|<<|>>|[%&|^!=<>/*+-])=?|[?:~]/,
+        // If there is no $ sign at the beginning highlight (( and )) as punctuation
+        punctuation: /\(\(?|\)\)?|,|;/
+      }
+    },
+    // [1]: Command Substitution
+    {
+      pattern: /\$\((?:[^()]|\([^)]*\))*\)|`[^`]+`/g,
+      greedy: !0,
+      inside: An
+    },
+    // [2]: Brace expansion
+    {
+      pattern: /\$\{[^}]*\}/g,
+      greedy: !0,
+      inside: {
+        operator: /:[?=+-]?|[!/]|##?|%%?|\^\^?|,,?/,
+        punctuation: /[[\]]/,
+        environment: {
+          pattern: RegExp("(\\{)" + Ge),
+          lookbehind: !0,
+          alias: "constant"
+        }
+      }
+    },
+    /\$(?:\w+|[#?*!@$])/
+  ],
+  // Escape sequences from echo and printf's manuals, and escaped quotes.
+  entity: /\\(?:[abceEfnrtv\\"]|O?[0-7]{1,3}|U[a-fA-F\d]{8}|u[a-fA-F\d]{4}|x[a-fA-F\d]{1,2})/
+}, oa = ft.inside = E.sh = E.shell = E.bash = {
+  shebang: {
+    pattern: /^#!\s*\/.*/,
+    alias: "important"
+  },
+  comment: {
+    pattern: /(^|[^"{\\$])#.*/,
+    lookbehind: !0
+  },
+  "function-name": [
+    // a) function foo {
+    // b) foo() {
+    // c) function foo() {
+    // but not “foo {”
+    {
+      // a) and c)
+      pattern: /(\bfunction\s+)[\w-]+(?=(?:\s*\(?:\s*\))?\s*\{)/,
+      lookbehind: !0,
+      alias: "function"
+    },
+    {
+      // b)
+      pattern: /\b[\w-]+(?=\s*\(\s*\)\s*\{)/,
+      alias: "function"
+    }
+  ],
+  // Highlight variable names as variables in for and select beginnings.
+  "for-or-select": {
+    pattern: /(\b(?:for|select)\s+)\w+(?=\s+in\s)/,
+    lookbehind: !0,
+    alias: "variable"
+  },
+  // Highlight variable names as variables in the left-hand part
+  // of assignments (“=” and “+=”).
+  "assign-left": {
+    pattern: /(^|[\s;|&]|[<>]\()\w+(?:\.\w+)*(?=\+?=)/,
+    lookbehind: !0,
+    alias: "variable",
+    inside: {
+      environment: {
+        pattern: RegExp("(^|[\\s;|&]|[<>]\\()" + Ge),
+        lookbehind: !0,
+        alias: "constant"
+      }
+    }
+  },
+  // Highlight parameter names as variables
+  parameter: {
+    pattern: /(^|\s)-{1,2}(?:\w+:[+-]?)?\w+(?:\.\w+)*(?![^\s=])/,
+    lookbehind: !0,
+    alias: "variable"
+  },
+  string: [
+    // Support for Here-documents https://en.wikipedia.org/wiki/Here_document
+    {
+      pattern: /((?:^|[^<])<<-?\s*)(\w+)\s[^]*?\n\2/g,
+      lookbehind: !0,
+      greedy: !0,
+      inside: Le
+    },
+    // Here-document with quotes around the tag
+    // → No expansion (so no “inside”).
+    {
+      pattern: /((?:^|[^<])<<-?\s*)(["'])(\w+)\2\s[^]*?\n\3/g,
+      lookbehind: !0,
+      greedy: !0,
+      inside: {
+        bash: ft
+      }
+    },
+    // “Normal” string
+    {
+      // https://www.gnu.org/software/bash/manual/html_node/Double-Quotes.html
+      pattern: /(^|[^\\](?:\\\\)*)"(?:\\[^]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^\\"`$])*"/g,
+      lookbehind: !0,
+      greedy: !0,
+      inside: Le
+    },
+    {
+      // https://www.gnu.org/software/bash/manual/html_node/Single-Quotes.html
+      pattern: /(^|[^$\\])'[^']*'/g,
+      lookbehind: !0,
+      greedy: !0
+    },
+    {
+      // https://www.gnu.org/software/bash/manual/html_node/ANSI_002dC-Quoting.html
+      pattern: /\$'(?:\\[^]|[^\\'])*'/g,
+      greedy: !0,
+      inside: {
+        entity: Le.entity
+      }
+    }
+  ],
+  environment: {
+    pattern: RegExp("\\$?" + Ge),
+    alias: "constant"
+  },
+  variable: Le.variable,
+  function: {
+    pattern: /(^|[\s;|&]|[<>]\()(?:add|apropos|apt|apt-cache|apt-get|aptitude|aspell|automysqlbackup|basename|bash|bc|bconsole|bg|bzip2|cal|cargo|cat|c?fdisk|chgrp|chkconfig|chmod|chown|chroot|cksum|clear|cmp|column|comm|composer|cron|crontab|c?split|curl|cut|date|dc|dd|ddrescue|debootstrap|df|diff3?|dig|dircolors|dirname|dirs?|dmesg|docker|docker-compose|du|[ef]?grep|eject|env|ethtool|expand|expect|expr|fdformat|fg|file|find|fmt|fold|format|free|fsck|fuser|g?awk|git|g?parted|groupadd|groupdel|groupmod|groups|grub-mkconfig|halt|head|hg|history|host|hostname|iconv|id|ifconfig|ifdown|ifup|import|install|ip|java|jobs|join|killall|less|link|ln|logname|logrotate|look|lpc|lprint[dq]?|lprm?|ls|lsof|lynx|make|man|mc|mdadm|mkconfig|mkdir|mke2fs|mkfifo|mkfs|mkisofs|mknod|mkswap|mm?v|more|most|mtools|m?tr|mutt|nano|nc|netstat|nice|nl|node|nohup|notify-send|nslookup|op|open|passwd|paste|pathchk|ping|p?kill|p?npm|podman|podman-compose|popd|pr|printcap|printenv|ps|pushd|pv|quota|quotacheck|quotactl|ra[mr]|reboot|remsync|rename|renice|rev|rmdir|rp?m|r?sync|[sr]?cp|screen|sdiff|se[dq]|sendmail|service|s?ftp|shellcheck|shuf|shutdown|sleep|s?locate|[sz]?sh|stat|strace|sudo|sum?|suspend|swapon|sysctl|tac|tail|tar|tee|time|timeout|h?top|touch|traceroute|t?sort|tty|u?mount|uname|unexpand|uniq|units|unrar|unshar|unzip|update-grub|uptime|useradd|userdel|usermod|users|uudecode|uuencode|v|vcpkg|vdir|vim?|virsh|vmstat|wait|watch|wc|wget|whereis|which|who|whoami|write|xargs|xdg-open|yarn|yes|zenity|g?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
+  },
+  // https://www.gnu.org/software/bash/manual/html_node/Shell-Builtin-Commands.html
+  builtin: {
+    pattern: /(^|[\s;|&]|[<>]\()(?:\.|:|alias|bind|break|builtin|caller|cd|command|continue|declare|echo|enable|eval|exec|exit|export|getopts|hash|help|[ls]et|local|logout|mapfile|printf|pwd|read|readarray|readonly|return|shift|shopt|source|test|times|trap|type|typeset|ulimit|umask|unalias|unset)(?=$|[)\s;|&])/,
+    lookbehind: !0,
+    // Alias added to make those easier to distinguish from strings.
+    alias: "class-name"
+  },
+  boolean: {
+    pattern: /(^|[\s;|&]|[<>]\()(?:false|true)(?=$|[)\s;|&])/,
+    lookbehind: !0
+  },
+  "file-descriptor": {
+    pattern: /\B&\d\b/,
+    alias: "important"
+  },
+  operator: {
+    // Lots of redirections here, but not just that.
+    pattern: /\d?<>|>\||\+=|=[=~]?|!=?|<<[<-]?|[&\d]?>>|\d[<>]&?|[<>][&=]?|&[>&]?|\|[&|]?/,
+    inside: {
+      "file-descriptor": {
+        pattern: /^\d/,
+        alias: "important"
+      }
+    }
+  },
+  punctuation: /\$?\(\(?|\)\)?|\.\.|[[\]{};\\]/,
+  number: {
+    pattern: /(^|\s)(?:[1-9]\d*|0)(?:[.,]\d+)?\b/,
+    lookbehind: !0
+  }
+};
+[
+  "comment",
+  "function-name",
+  "for-or-select",
+  "assign-left",
+  "parameter",
+  "string",
+  "environment",
+  "function",
+  "keyword",
+  "builtin",
+  "boolean",
+  "file-descriptor",
+  "operator",
+  "punctuation",
+  "number"
+].forEach((e) => An[e] = oa[e]);
+var In = /(?:"(?:\\[^]|[^\\\n"])*"|'(?:\\[^]|[^\\\n'])*')/g, Ce = In.source, Gt = {
+  rule: /^@[\w-]+/,
+  "selector-function-argument": {
+    pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^)]*\))*\))+(?=\s*\))/,
+    lookbehind: !0,
+    alias: "selector"
+  },
+  keyword: {
+    pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
+    lookbehind: !0
+  }
+  // See rest below
+};
+Gt[Y] = E.css = {
+  comment: /\/\*[^]*?\*\//,
+  atrule: {
+    pattern: RegExp(`@[\\w-](?:[^;{\\s"']|\\s+(?!\\s)|${Ce})*?(?:;|(?=\\s*\\{))`),
+    inside: Gt
+  },
+  url: {
+    // https://drafts.csswg.org/css-values-3/#urls
+    pattern: RegExp(`\\burl\\((?:${Ce}|(?:[^\\\\
+"')=]|\\\\[^])*)\\)`, "gi"),
+    greedy: !0,
+    inside: {
+      function: /^url/i,
+      punctuation: /^\(|\)$/,
+      string: {
+        pattern: RegExp("^" + Ce + "$"),
+        alias: "url"
+      }
+    }
+  },
+  selector: {
+    pattern: RegExp(`(^|[{}\\s])[^{}\\s](?:[^{};"'\\s]|\\s+(?![\\s{])|${Ce})*(?=\\s*\\{)`),
+    lookbehind: !0
+  },
+  string: {
+    pattern: In,
+    greedy: !0
+  },
+  property: {
+    pattern: /(^|[^-\w\xa0-\uffff])(?!\d)(?:(?!\s)[-\w\xa0-\uffff])+(?=\s*:)/i,
+    lookbehind: !0
+  },
+  important: /!important\b/i,
+  function: {
+    pattern: /(^|[^-a-z\d])[-a-z\d]+(?=\()/i,
+    lookbehind: !0
+  },
+  punctuation: /[(){},:;]/
+};
+var De = (e, t) => {
+  if (t.has(e)) return t.get(e);
+  var n = e, s = la.call(e).slice(8, -1);
+  if (s == "Object") {
+    t.set(e, n = {});
+    for (var d in e)
+      n[d] = De(e[d], t);
+    e[Y] && (n[Y] = De(e[Y], t)), e[le] && (n[le] = e[le]);
+  } else if (s == "Array") {
+    t.set(e, n = []);
+    for (var p = 0, b = e.length; p < b; p++)
+      n[p] = De(e[p], t);
+  }
+  return n;
+}, Tt = (e) => De(e, /* @__PURE__ */ new Map()), ae = (e, t) => Object.assign(Tt(E[e]), t), D = (e, t, n) => {
+  var s = {};
+  for (var d in e)
+    s[d] = e[d], delete e[d];
+  for (var d in s)
+    d == t && Object.assign(e, n), n.hasOwnProperty(d) || (e[d] = s[d]);
+}, la = {}.toString, ze = E.css, zt = {
+  pattern: /(\b\d+)(?:%|[a-z]+(?![\w-]))/,
+  lookbehind: !0
+}, Ht = {
+  pattern: /(^|[^\w.-])-?(?:\d+(?:\.\d+)?|\.\d+)/,
+  lookbehind: !0
+};
+ze.selector.inside = ze.atrule.inside["selector-function-argument"].inside = {
+  "pseudo-element": /:(?:after|before|first-letter|first-line|selection)|::[-\w]+/,
+  "pseudo-class": /:[-\w]+/,
+  class: /\.[-\w]+/,
+  id: /#[-\w]+/,
+  attribute: {
+    pattern: /\[(?:[^[\]"']|(["'])(?:\\[^]|(?!\1)[^\\\n])*\1)*\]/g,
+    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": {
+        pattern: /(=\s*)(?:(?!\s)[-\w\xa0-\uffff])+(?=\s*$)|(["'])(?:\\[^]|(?!\2)[^\\\n])*\2/,
+        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: />|\+|~|\|\|/,
+  // the `tag` token has been existed and removed.
+  // because we can't find a perfect tokenize to match it.
+  // if you want to add it, please read https://github.com/PrismJS/prism/pull/2373 first.
+  punctuation: /[(),]/
+};
+D(ze, "property", {
+  variable: {
+    pattern: /(^|[^-\w\xa0-\uffff])--(?!\d)(?:(?!\s)[-\w\xa0-\uffff])*/i,
+    lookbehind: !0
+  }
+});
+D(ze, "function", {
+  operator: {
+    pattern: /(\s)[/*+-](?!\S)/,
+    lookbehind: !0
+  },
+  // CAREFUL!
+  // Previewers and Inline color use hexcode and color.
+  hexcode: {
+    pattern: /\B#[a-f\d]{3,8}\b/i,
+    alias: "color"
+  },
+  color: [
+    {
+      pattern: /(^|[^\w-])(?:(?:alice|cadet|cornflower|deepsky|dodger|midnight|powder|royal|sky|steel)blue|antiquewhite|aqua|aquamarine|azure|beige|bisque|black|blanchedalmond|blueviolet|brown|burlywood|chartreuse|chocolate|coral|cornsilk|crimson|(?:dark)?(?:blue|cyan|goldenrod|gr[ae]y|green|khaki|magenta|olivegreen|orange|orchid|red|salmon|seagreen|slateblue|slategr[ae]y|turquoise|violet)|deeppink|dimgr[ae]y|firebrick|floralwhite|(?:forest|lawn|lime|pale|spring)green|fuchsia|gainsboro|ghostwhite|gold|greenyellow|honeydew|hotpink|indianred|indigo|ivory|lavender|lavenderblush|lemonchiffon|light(?:blue|coral|cyan|goldenrodyellow|gr[ae]y|green|pink|salmon|seagreen|skyblue|slategr[ae]y|steelblue|yellow)|lime|linen|maroon|medium(?:aquamarine|blue|orchid|purple|seagreen|slateblue|springgreen|turquoise|violetred)|mintcream|mistyrose|moccasin|navajowhite|navy|oldlace|olive|olivedrab|orangered|palegoldenrod|paleturquoise|palevioletred|papayawhip|peachpuff|peru|pink|plum|purple|rebeccapurple|rosybrown|saddlebrown|sandybrown|seashell|sienna|silver|snow|tan|teal|thistle|tomato|transparent|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: {
+        function: /^[^(]+/,
+        unit: zt,
+        number: Ht,
+        punctuation: /[(),]/
+      }
+    }
+  ],
+  // it's important that there is no boundary assertion after the hex digits
+  entity: /\\[a-f\d]{1,8}/i,
+  unit: zt,
+  number: Ht
+});
+E.ini = {
+  /**
+   * The component mimics the behavior of the Win32 API parser.
+   *
+   * @see {@link https://github.com/PrismJS/prism/issues/2775#issuecomment-787477723}
+   */
+  comment: {
+    pattern: /(^[ \f	\v]*)[#;].*/m,
+    lookbehind: !0
+  },
+  section: {
+    pattern: /(^[ \f	\v]*)\[[^\n\]]*\]?/m,
+    lookbehind: !0,
+    inside: {
+      "section-name": {
+        pattern: /(^\[[ \f	\v]*)[^ \f	\v\]]+(?:[ \f	\v]+[^ \f	\v\]]+)*/,
+        lookbehind: !0,
+        alias: "selector"
+      },
+      punctuation: /[[\]]/
+    }
+  },
+  key: {
+    pattern: /(^[ \f	\v]*)[^ \f\n	\v=]+(?:[ \f	\v]+[^ \f\n	\v=]+)*(?=[ \f	\v]*=)/m,
+    lookbehind: !0,
+    alias: "attr-name"
+  },
+  value: {
+    pattern: /(=[ \f	\v]*)[^ \f\n	\v]+(?:[ \f	\v]+[^ \f\n	\v]+)*/,
+    lookbehind: !0,
+    alias: "attr-value",
+    inside: {
+      "inner-value": {
+        pattern: /^(["']).+(?=\1$)/,
+        lookbehind: !0
+      }
+    }
+  },
+  punctuation: /=/
+};
+var re = () => ({
+  pattern: /\/\/.*|\/\*[^]*?(?:\*\/|$)/g,
+  greedy: !0
+}), Nt = () => ({
+  pattern: /(["'])(?:\\[^]|(?!\1)[^\\\n])*\1/g,
+  greedy: !0
+}), Rn = /\b0x[a-f\d]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i, Ee = /[()[\]{}.,:;]/, W = /\b(?:false|true)\b/, tt = {
+  "interpolation-punctuation": {
+    pattern: /^\$\{?|\}$/,
+    alias: "punctuation"
+  },
+  expression: {
+    pattern: /[^]+/
+  }
+};
+tt.expression.inside = E.kts = E.kt = E.kotlin = {
+  // https://kotlinlang.org/spec/expressions.html#string-interpolation-expressions
+  "string-literal": [
+    {
+      pattern: /"""(?:[^$]|\$(?:(?!\{)|\{[^{}]*\}))*?"""/,
+      alias: "multiline",
+      inside: {
+        interpolation: {
+          pattern: /\$(?:[a-z_]\w*|\{[^{}]*\})/i,
+          inside: tt
+        },
+        string: /[^]+/
+      }
+    },
+    {
+      pattern: /"(?:\\.|[^\\\n"$]|\$(?:(?!\{)|\{[^{}]*\}))*"/,
+      alias: "singleline",
+      inside: {
+        interpolation: {
+          pattern: /((?:^|[^\\])(?:\\\\)*)\$(?:[a-z_]\w*|\{[^{}]*\})/i,
+          lookbehind: !0,
+          inside: tt
+        },
+        string: /[^]+/
+      }
+    }
+  ],
+  char: {
+    // https://kotlinlang.org/spec/expressions.html#character-literals
+    pattern: /'(?:[^\\\n']|\\(?:.|u[a-fA-F\d]{0,4}))'/g,
+    greedy: !0
+  },
+  comment: re(),
+  annotation: {
+    pattern: /\B@(?:\w+:)?(?:[A-Z]\w*|\[[^\]]+\])/,
+    alias: "builtin"
+  },
+  keyword: {
+    // The lookbehind prevents wrong highlighting of e.g. kotlin.properties.get
+    pattern: /(^|[^.])\b(?:abstract|actual|annotation|as|break|by|catch|class|companion|const|constructor|continue|crossinline|data|do|dynamic|else|enum|expect|external|final|finally|for|fun|get|if|import|in|infix|init|inline|inner|interface|internal|is|lateinit|noinline|null|object|open|operator|out|override|package|private|protected|public|reified|return|sealed|set|super|suspend|tailrec|this|throw|to|try|typealias|val|var|vararg|when|where|while)\b/,
+    lookbehind: !0
+  },
+  boolean: W,
+  label: {
+    pattern: /\b\w+@|@\w+/,
+    alias: "symbol"
+  },
+  function: {
+    pattern: /(?:`[^\n`]+`|\b\w+)(?=\s*\()|(\.)(?:`[^\n`]+`|\w+)(?=\s*\{)/g,
+    lookbehind: !0,
+    greedy: !0
+  },
+  number: /\b(?:0[xX][a-fA-F\d]+(?:_[a-fA-F\d]+)*|0[bB][01]+(?:_[01]+)*|\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?(?:[eE][+-]?\d+(?:_\d+)*)?[fFL]?)\b/,
+  operator: /--|\+\+|&&|\|\||->|[!=]==|!!|[%!=<>/*+-]=?|[?:]:?|\.\.|\b(?:and|inv|shl|u?shr|x?or)\b/,
+  punctuation: Ee
+};
+var Sn = [
+  {
+    pattern: /&[a-z\d]{1,8};/i,
+    alias: "named-entity"
+  },
+  /&#x?[a-f\d]{1,8};/i
+], ca = {
+  pattern: /<\/?(?!\d)[^\s/=>$<%]+(?:\s(?:\s*[^\s/=>]+(?:\s*=\s*(?!\s)(?:"[^"]*"|'[^']*'|[^\s"'=>]+(?=[\s>]))?|(?=[\s/>])))+)?\s*\/?>/g,
+  greedy: !0,
+  inside: {
+    punctuation: /^<\/?|\/?>$/,
+    tag: {
+      pattern: /^\S+/,
+      inside: {
+        namespace: /^[^:]+:/
+      }
+    },
+    "attr-value": [{
+      pattern: /(=\s*)(?:"[^"]*"|'[^']*'|[^\s"'=>]+)/g,
+      lookbehind: !0,
+      greedy: !0,
+      inside: {
+        punctuation: /^["']|["']$/,
+        entity: Sn
+      }
+    }],
+    "attr-equals": /=/,
+    "attr-name": {
+      pattern: /\S+/,
+      inside: {
+        namespace: /^[^:]+:/
+      }
+    }
+  }
+};
+E.rss = E.atom = E.ssml = E.xml = {
+  comment: {
+    pattern: /<!--(?:(?!<!--)[^])*?-->/g,
+    greedy: !0
+  },
+  prolog: {
+    pattern: /<\?[^]+?\?>/g,
+    greedy: !0
+  },
+  doctype: {
+    // https://www.w3.org/TR/xml/#NT-doctypedecl
+    pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/gi,
+    greedy: !0,
+    inside: {
+      "internal-subset": {
+        pattern: /(\[)[^]+(?=\]\s*>$)/,
+        lookbehind: !0,
+        inside: "xml"
+      },
+      string: /"[^"]*"|'[^']*'/,
+      punctuation: /^<!|[>[\]]/,
+      "doctype-tag": /^DOCTYPE/i,
+      name: /\S+/
+    }
+  },
+  cdata: {
+    pattern: /<!\[CDATA\[[^]*?\]\]>/gi,
+    greedy: !0
+  },
+  tag: ca,
+  entity: Sn,
+  "markup-bracket": {
+    pattern: /[()[\]{}]/,
+    alias: "punctuation"
+  }
+};
+var bt = (e, t) => (e["language-" + t] = {
+  pattern: /[^]+/,
+  inside: t
+}, e), Vt = (e, t) => ({
+  pattern: RegExp(`(<${e}[^>]*>)(?!</${e}>)(?:<!\\[CDATA\\[(?:[^\\]]|\\](?!\\]>))*\\]\\]>|(?!<!\\[CDATA\\[)[^])+?(?=</${e}>)`, "gi"),
+  lookbehind: !0,
+  greedy: !0,
+  inside: bt({
+    "included-cdata": {
+      pattern: /<!\[CDATA\[[^]*?\]\]>/i,
+      inside: bt({
+        cdata: /^<!\[CDATA\[|\]\]>$/i
+      }, t)
+    }
+  }, t)
+}), Zt = (e, t) => ({
+  pattern: RegExp(`((?:^|["'\\s])(?:${e})\\s*=\\s*)(?:"[^"]*"|'[^']*'|[^\\s"'=>]+)`, "gi"),
+  lookbehind: !0,
+  greedy: !0,
+  inside: bt({
+    punctuation: /^["']|["']$/
+  }, t)
+}), Tn = E.svg = E.mathml = E.html = E.markup = Tt(E.xml);
+Tn.tag.inside["attr-value"].unshift(
+  Zt("style", "css"),
+  Zt("on[a-z]+", "javascript")
+);
+D(Tn, "cdata", {
+  style: Vt("style", "css"),
+  script: Vt("script", "javascript")
+});
+E.r = {
+  comment: /#.*/,
+  string: {
+    pattern: /(["'])(?:\\.|(?!\1)[^\\\n])*\1/g,
+    greedy: !0
+  },
+  "percent-operator": {
+    // Includes user-defined operators
+    // and %%, %*%, %/%, %in%, %o%, %x%
+    pattern: /%[^%\s]*%/,
+    alias: "operator"
+  },
+  boolean: /\b(?:FALSE|TRUE)\b/,
+  ellipsis: /\.\.(?:\.|\d+)/,
+  number: [
+    /\b(?:Inf|NaN)\b/,
+    /(?:\b0x[a-fA-F\d]+(?:\.\d*)?|\b\d+(?:\.\d*)?|\B\.\d+)(?:[EePp][+-]?\d+)?[iL]?/
+  ],
+  keyword: /\b(?:NA|NA_character_|NA_complex_|NA_integer_|NA_real_|NULL|break|else|for|function|if|in|next|repeat|while)\b/,
+  operator: /->>?|<=|<<?-|[!=<>]=?|::?|&&?|\|\|?|[~^$@/*+-]/,
+  punctuation: /[()[\]{},;]/
+};
+E.basic = {
+  comment: {
+    pattern: /(?:!|rem\b).+/i,
+    inside: {
+      keyword: /^rem/i
+    }
+  },
+  string: {
+    pattern: /"(?:""|[#$%&'().,:;\w ?^!=<>/*+-])*"/g,
+    greedy: !0
+  },
+  number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
+  keyword: /\b(?:as|beep|bload|bsave|call absolute|call|case|chain|chdir|clear|close|cls|com|common|const|data|declare|def(?: fn| seg|dbl|int|[ls]ng|str)|dim|do|double|else|elseif|environ|erase|error|exit|field|files|for|function|get|gosub|goto|if|input|integer|ioctl|key|kill|line input|locate|lock|long|loop|[lr]set|mkdir|name|next|off|on(?: com| error| key| timer)?|open|option base|[op]ut|poke|read|redim|rem|restore|resume|return|rmdir|run|select case|shared|shell|single|sleep|static|step|stop|string|sub|swap|system|then|timer|to|troff|tron|type|unlock|until|using|view print|wait|w?end|while|write)(?:\$|\b)/i,
+  function: /\b(?:abs|access|a?cos|angle|area|arithmetic|array|a?sin|ask|atn?|base|begin|break|cause|ceil|chr|clip|collate|color|co[nst]|cosh|csc|date|datum|debug|decimal|de[fgt]|degrees|delete|device|display|dot|elapsed|eps|erasable|exline|exp|external|extype|filetype|fixed|fp|go|graph|handler|idn|image|int?|internal|ip|is|keyed|[lu]bound|[lu]case|left|le[nt]|length|lines?|log2?|log10|[lr]trim|margin|ma[tx]|maxnum|mi[dn]|missing|mod|native|nul|numeric|of|option|ord|organization|outin|output|pi|pointer|points?|pos|print|program|prompt|rad|radians|randomize|record|recsize|rectype|relative|remainder|repeat|rest|retry|rewrite|right|rnd|round|same|se[ct]|select|sequential|setter|sgn|sinh|size|skip|s[qt]r|standard|status|stream|style|tab|tanh?|template|text|there|time|timeout|trace|transform|truncate|use|val|variable|viewport|when|window|with|zer|zonewidth)(?:\$|\b)/i,
+  operator: /<=|<>|>=|[&^=<>/*+-]|\b(?:and|eqv|imp|not|x?or)\b/i,
+  punctuation: /[(),:;]/
+};
+E.vbnet = ae("basic", {
+  comment: {
+    pattern: /(?:!|'|rem\b).*/i,
+    inside: {
+      keyword: /^rem/i
+    }
+  },
+  string: {
+    pattern: /(^|[^"])"(?:""|[^"])*"(?!")/g,
+    lookbehind: !0,
+    greedy: !0
+  },
+  keyword: /(?:\b(?:addhandler|addressof|alias|and|andalso|as|beep|bload|boolean|bsave|byref|byval|call absolute|call|case|catch|cbool|c?byte|cc?har|c?date|cdbl|cdec|chain|chdir|cu?int|class|clear|close|cls|cobj|com|common|const|continue|c?sbyte|c?u?short|c?sng|cstr|c?type|cu?lng|data|decimal|declare|def(?: fn| seg|dbl|int|lng|sng|str)|default|delegate|dim|directcast|do|double|else|elseif|enum|environ|erase|error|event|exit|false|true|field|files|finally|for each|for|friend|function|[gls]et|gettype|getxmlnamespace|global|gosub|goto|handles|i[fns]|implements|imports|inherits|input|interface|ioctl|isnot|key|kill|lib|like|line input|locate|lock|loop|[lr]set|me|mkdir|mod|module|mustinherit|mustoverride|mybase|myclass|name|namespace|narrowing|new|next|not|nothing|notinheritable|notoverridable|object|off?|on (?:com|error|key|timer)|on|open|operator|option base|option|optional|orelse|out|overloads|overridable|overrides|paramarray|partial|poke|private|property|protected|public|put|raiseevent|read|readonly|redim|removehandler|restore|resume|return|rmdir|run|select case|select|shadows|shared|shell|single|sleep|static|step|stop|string|structure|sub|swap|synclock|system|[tw]hen|throw|timer|to|troff|tron|try|trycast|typeof|u?integer|u?long|unlock|until|using|view print|wait|w?end|while|widening|with|withevents|write|writeonly|x?or)|\B#(?:const|else|elseif|end|if))(?:\$|\b)/i,
+  punctuation: /[(){},:;]/
+});
+var Kt = {
+  // https://en.cppreference.com/w/c/language/character_constant
+  pattern: /'(?:\\[^]|[^\\\n']){0,32}'/g,
+  greedy: !0
+}, Wt = {
+  pattern: /\/\/(?:[^\\\n]|\\\n?)*|\/\*[^]*?(?:\*\/|$)/g,
+  greedy: !0
+}, qt = {
+  // https://en.cppreference.com/w/c/language/string_literal
+  pattern: /"(?:\\[^]|[^\\\n"])*"/g,
+  greedy: !0
+}, jt = {
+  pattern: /\S[^]*/
+};
+jt.inside = E.c = {
+  comment: Wt,
+  char: Kt,
+  macro: {
+    // allow for multiline macro definitions
+    // spaces after the # character compile fine with gcc
+    pattern: /(^[ 	]*)#\s*[a-z](?:[^\\\n/]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|\\[^])*/img,
+    lookbehind: !0,
+    greedy: !0,
+    alias: "property",
+    inside: {
+      string: [
+        {
+          // highlight the path of the include statement as a string
+          pattern: /^(#\s*include\s*)<[^>]+>/,
+          lookbehind: !0
+        },
+        qt
+      ],
+      char: Kt,
+      comment: Wt,
+      "macro-name": [
+        {
+          pattern: /(^#\s*define\s+)\w+\b(?!\()/i,
+          lookbehind: !0
+        },
+        {
+          pattern: /(^#\s*define\s+)\w+/i,
+          lookbehind: !0,
+          alias: "function"
+        }
+      ],
+      // highlight macro directives as keywords
+      directive: {
+        pattern: /^(#\s*)[a-z]+/,
+        lookbehind: !0,
+        alias: "keyword"
+      },
+      "directive-hash": /^#/,
+      punctuation: /##|\\(?=\n)/,
+      expression: jt
+    }
+  },
+  string: qt,
+  "class-name": {
+    pattern: /(\b(?:enum|struct)\s+(?:__attribute__\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/,
+  // highlight predefined macros as constants
+  constant: /\b(?:EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|__DATE__|__FILE__|__LINE__|__TIMESTAMP__|__TIME__|__func__|stderr|stdin|stdout)\b/,
+  function: /\b[a-z_]\w*(?=\s*\()/i,
+  number: /(?:\b0x(?:[a-f\d]+(?:\.[a-f\d]*)?|\.[a-f\d]+)(?:p[+-]?\d+)?|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ful]{0,4}/i,
+  operator: /->|([&|:+-])\1|[?:~]|>>=?|<<=?|[%&|^!=<>/*+-]=?/,
+  punctuation: Ee
+};
+D(
+  E.opencl = ae("c", {
+    // Extracted from the official specs (2.0) and http://streamcomputing.eu/downloads/?opencl.lang (opencl-keywords, opencl-types) and http://sourceforge.net/tracker/?func=detail&aid=2957794&group_id=95717&atid=612384 (Words2, partly Words3)
+    keyword: /\b(?:(?:__)?(?:constant|global|kernel|local|private|read_only|read_write|write_only)|__attribute__|auto|(?:bool|u?(?:char|int|long|short)|half|quad)(?:2|3|4|8|16)?|break|case|complex|const|continue|(?:double|float)(?:16(?:x(?:1|2|4|8|16))?|1x(?:1|2|4|8|16)|2(?:x(?:1|2|4|8|16))?|3|4(?:x(?:1|2|4|8|16))?|8(?:x(?:1|2|4|8|16))?)?|default|do|else|enum|extern|for|goto|if|imaginary|inline|packed|pipe|register|restrict|return|signed|sizeof|static|struct|switch|typedef|uniform|union|unsigned|void|volatile|while)\b/,
+    // Extracted from http://streamcomputing.eu/downloads/?opencl.lang (opencl-const)
+    // Math Constants: https://www.khronos.org/registry/OpenCL/sdk/2.1/docs/man/xhtml/mathConstants.html
+    // Macros and Limits: https://www.khronos.org/registry/OpenCL/sdk/2.1/docs/man/xhtml/macroLimits.html
+    number: /(?:\b0x(?:[a-f\d]+(?:\.[a-f\d]*)?|\.[a-f\d]+)(?:p[+-]?\d+)?|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[fuhl]{0,4}/i,
+    boolean: W,
+    "constant-opencl-kernel": {
+      pattern: /\b(?:CHAR_(?:BIT|MAX|MIN)|CLK_(?:ADDRESS_(?:CLAMP(?:_TO_EDGE)?|NONE|REPEAT)|FILTER_(?:LINEAR|NEAREST)|(?:GLOBAL|LOCAL)_MEM_FENCE|NORMALIZED_COORDS_(?:FALSE|TRUE))|CL_(?:BGRA|(?:HALF_)?FLOAT|INTENSITY|LUMINANCE|A?R?G?B?[Ax]?|(?:(?:UN)?SIGNED|[US]NORM)_(?:INT(?:8|16|32))|UNORM_(?:INT_101010|SHORT_(?:555|565)))|(?:DBL|FLT|HALF)_(?:DIG|EPSILON|(?:MAX|MIN)(?:(?:_10)?_EXP)?|MANT_DIG)|FLT_RADIX|HUGE_VALF?|(?:INT|LONG|SCHAR|SHRT)_(?:MAX|MIN)|INFINITY|MAXFLOAT|M_(?:[12]_PI|2_SQRTPI|E|LN2|LN10|LOG2E?|LOG10E?|PI(?:_[24])?|SQRT(?:1_2|2))(?:_F|_H)?|NAN|(?:UCHAR|UINT|ULONG|USHRT)_MAX)\b/,
+      alias: "constant"
+    }
+  }),
+  "class-name",
+  {
+    // https://www.khronos.org/registry/OpenCL/sdk/2.1/docs/man/xhtml/scalarDataTypes.html
+    // https://www.khronos.org/registry/OpenCL/sdk/2.1/docs/man/xhtml/otherDataTypes.html
+    "builtin-type": {
+      pattern: /\b(?:_cl_(?:command_queue|context|device_id|event|kernel|mem|platform_id|program|sampler)|cl_(?:image_format|mem_fence_flags)|clk_event_t|event_t|image(?:1d_(?:array_|buffer_)?t|2d_(?:array_(?:depth_|msaa_depth_|msaa_)?|depth_|msaa_depth_|msaa_)?t|3d_t)|ndrange_t|ptrdiff_t|queue_t|reserve_id_t|sampler_t|size_t|u?intptr_t)\b/,
+      alias: "keyword"
+    }
+  }
+);
+var gt = {
+  // Extracted from http://streamcomputing.eu/downloads/?opencl_host.lang (opencl-types and opencl-host)
+  "type-opencl-host": {
+    pattern: /\b(?:cl_(?:GLenum|GLint|GLuin|addressing_mode|bitfield|bool|buffer_create_type|build_status|channel_(?:order|type)|(?:u?(?:char|int|long|short)|double|float)(?:[2348]|16)?|command_(?:queue(?:_info|_properties)?|type)|context(?:_info|_properties)?|device_(?:exec_capabilities|fp_config|id|info|local_mem_type|mem_cache_type|type)|(?:event|sampler)(?:_info)?|filter_mode|half|image_info|kernel(?:_info|_work_group_info)?|map_flags|mem(?:_flags|_info|_object_type)?|platform_(?:id|info)|profiling_info|program(?:_build_info|_info)?))\b/,
+    alias: "keyword"
+  },
+  "boolean-opencl-host": {
+    pattern: /\bCL_(?:FALSE|TRUE)\b/,
+    alias: "boolean"
+  },
+  // Extracted from cl.h (2.0) and http://streamcomputing.eu/downloads/?opencl_host.lang (opencl-const)
+  "constant-opencl-host": {
+    pattern: /\bCL_(?:A|ABGR|ADDRESS_(?:CLAMP(?:_TO_EDGE)?|MIRRORED_REPEAT|NONE|REPEAT)|ARGB|BLOCKING|BUFFER_CREATE_TYPE_REGION|BUILD_(?:ERROR|IN_PROGRESS|NONE|PROGRAM_FAILURE|SUCCESS)|COMMAND_(?:ACQUIRE_GL_OBJECTS|BARRIER|COPY_(?:BUFFER(?:_RECT|_TO_IMAGE)?|IMAGE(?:_TO_BUFFER)?)|FILL_(?:BUFFER|IMAGE)|MAP(?:_BUFFER|_IMAGE)|MARKER|MIGRATE(?:_SVM)?_MEM_OBJECTS|NATIVE_KERNEL|NDRANGE_KERNEL|READ_(?:BUFFER(?:_RECT)?|IMAGE)|RELEASE_GL_OBJECTS|SVM_(?:FREE|MAP|MEMCPY|MEMFILL|UNMAP)|TASK|UNMAP_MEM_OBJECT|USER|WRITE_(?:BUFFER(?:_RECT)?|IMAGE))|COMPILER_NOT_AVAILABLE|COMPILE_PROGRAM_FAILURE|COMPLETE|CONTEXT_(?:DEVICES|INTEROP_USER_SYNC|NUM_DEVICES|PLATFORM|PROPERTIES|REFERENCE_COUNT)|DEPTH(?:_STENCIL)?|DEVICE_(?:ADDRESS_BITS|AFFINITY_DOMAIN_(?:L[1-4]_CACHE|NEXT_PARTITIONABLE|NUMA)|AVAILABLE|BUILT_IN_KERNELS|COMPILER_AVAILABLE|DOUBLE_FP_CONFIG|ENDIAN_LITTLE|ERROR_CORRECTION_SUPPORT|EXECUTION_CAPABILITIES|EXTENSIONS|GLOBAL_(?:MEM_(?:CACHELINE_SIZE|CACHE_SIZE|CACHE_TYPE|SIZE)|VARIABLE_PREFERRED_TOTAL_SIZE)|HOST_UNIFIED_MEMORY|IL_VERSION|IMAGE(?:2D_MAX_(?:HEIGHT|WIDTH)|3D_MAX_(?:DEPTH|HEIGHT|WIDTH)|_BASE_ADDRESS_ALIGNMENT|_MAX_ARRAY_SIZE|_MAX_BUFFER_SIZE|_PITCH_ALIGNMENT|_SUPPORT)|LINKER_AVAILABLE|LOCAL_MEM_SIZE|LOCAL_MEM_TYPE|MAX_(?:CLOCK_FREQUENCY|COMPUTE_UNITS|CONSTANT_ARGS|CONSTANT_BUFFER_SIZE|GLOBAL_VARIABLE_SIZE|MEM_ALLOC_SIZE|NUM_SUB_GROUPS|ON_DEVICE_(?:EVENTS|QUEUES)|PARAMETER_SIZE|PIPE_ARGS|READ_IMAGE_ARGS|READ_WRITE_IMAGE_ARGS|SAMPLERS|WORK_GROUP_SIZE|WORK_ITEM_DIMENSIONS|WORK_ITEM_SIZES|WRITE_IMAGE_ARGS)|MEM_BASE_ADDR_ALIGN|MIN_DATA_TYPE_ALIGN_SIZE|NAME|NATIVE_VECTOR_WIDTH_(?:CHAR|DOUBLE|FLOAT|HALF|INT|LONG|SHORT)|NOT_(?:AVAILABLE|FOUND)|OPENCL_C_VERSION|PARENT_DEVICE|PARTITION_(?:AFFINITY_DOMAIN|BY_AFFINITY_DOMAIN|BY_COUNTS|BY_COUNTS_LIST_END|EQUALLY|FAILED|MAX_SUB_DEVICES|PROPERTIES|TYPE)|PIPE_MAX_(?:ACTIVE_RESERVATIONS|PACKET_SIZE)|PLATFORM|PREFERRED_(?:GLOBAL_ATOMIC_ALIGNMENT|INTEROP_USER_SYNC|LOCAL_ATOMIC_ALIGNMENT|PLATFORM_ATOMIC_ALIGNMENT|VECTOR_WIDTH_(?:CHAR|DOUBLE|FLOAT|HALF|INT|LONG|SHORT))|PRINTF_BUFFER_SIZE|PROFILE|PROFILING_TIMER_RESOLUTION|QUEUE_(?:ON_(?:DEVICE_(?:MAX_SIZE|PREFERRED_SIZE|PROPERTIES)|HOST_PROPERTIES)|PROPERTIES)|REFERENCE_COUNT|SINGLE_FP_CONFIG|SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS|SVM_(?:ATOMICS|CAPABILITIES|COARSE_GRAIN_BUFFER|FINE_GRAIN_BUFFER|FINE_GRAIN_SYSTEM)|TYPE(?:_ACCELERATOR|_ALL|_CPU|_CUSTOM|_DEFAULT|_GPU)?|VENDOR(?:_ID)?|VERSION)|DRIVER_VERSION|EVENT_(?:COMMAND_(?:EXECUTION_STATUS|QUEUE|TYPE)|CONTEXT|REFERENCE_COUNT)|EXEC_(?:KERNEL|NATIVE_KERNEL|STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST)|FILTER_(?:LINEAR|NEAREST)|FLOAT|FP_(?:CORRECTLY_ROUNDED_DIVIDE_SQRT|DENORM|FMA|INF_NAN|ROUND_TO_INF|ROUND_TO_NEAREST|ROUND_TO_ZERO|SOFT_FLOAT)|GLOBAL|HALF_FLOAT|IMAGE_(?:ARRAY_SIZE|BUFFER|DEPTH|ELEMENT_SIZE|FORMAT|FORMAT_MISMATCH|FORMAT_NOT_SUPPORTED|HEIGHT|NUM_MIP_LEVELS|NUM_SAMPLES|ROW_PITCH|SLICE_PITCH|WIDTH)|INTENSITY|INVALID_(?:ARG_INDEX|ARG_SIZE|ARG_VALUE|BINARY|BUFFER_SIZE|BUILD_OPTIONS|COMMAND_QUEUE|COMPILER_OPTIONS|CONTEXT|DEVICE|DEVICE_PARTITION_COUNT|DEVICE_QUEUE|DEVICE_TYPE|EVENT|EVENT_WAIT_LIST|GLOBAL_OFFSET|GLOBAL_WORK_SIZE|GL_OBJECT|HOST_PTR|IMAGE_DESCRIPTOR|IMAGE_FORMAT_DESCRIPTOR|IMAGE_SIZE|KERNEL|KERNEL_ARGS|KERNEL_DEFINITION|KERNEL_NAME|LINKER_OPTIONS|MEM_OBJECT|MIP_LEVEL|OPERATION|PIPE_SIZE|PLATFORM|PROGRAM|PROGRAM_EXECUTABLE|PROPERTY|QUEUE_PROPERTIES|SAMPLER|VALUE|WORK_DIMENSION|WORK_GROUP_SIZE|WORK_ITEM_SIZE)|KERNEL_(?:ARG_(?:ACCESS_(?:NONE|QUALIFIER|READ_ONLY|READ_WRITE|WRITE_ONLY)|ADDRESS_(?:CONSTANT|GLOBAL|LOCAL|PRIVATE|QUALIFIER)|INFO_NOT_AVAILABLE|NAME|TYPE_(?:CONST|NAME|NONE|PIPE|QUALIFIER|RESTRICT|VOLATILE))|ATTRIBUTES|COMPILE_NUM_SUB_GROUPS|COMPILE_WORK_GROUP_SIZE|CONTEXT|EXEC_INFO_SVM_FINE_GRAIN_SYSTEM|EXEC_INFO_SVM_PTRS|FUNCTION_NAME|GLOBAL_WORK_SIZE|LOCAL_MEM_SIZE|LOCAL_SIZE_FOR_SUB_GROUP_COUNT|MAX_NUM_SUB_GROUPS|MAX_SUB_GROUP_SIZE_FOR_NDRANGE|NUM_ARGS|PREFERRED_WORK_GROUP_SIZE_MULTIPLE|PRIVATE_MEM_SIZE|PROGRAM|REFERENCE_COUNT|SUB_GROUP_COUNT_FOR_NDRANGE|WORK_GROUP_SIZE)|LINKER_NOT_AVAILABLE|LINK_PROGRAM_FAILURE|LOCAL|LUMINANCE|MAP_(?:FAILURE|READ|WRITE|WRITE_INVALIDATE_REGION)|MEM_(?:ALLOC_HOST_PTR|ASSOCIATED_MEMOBJECT|CONTEXT|COPY_HOST_PTR|COPY_OVERLAP|FLAGS|HOST_NO_ACCESS|HOST_PTR|HOST_READ_ONLY|HOST_WRITE_ONLY|KERNEL_READ_AND_WRITE|MAP_COUNT|OBJECT_(?:ALLOCATION_FAILURE|BUFFER|IMAGE1D|IMAGE1D_ARRAY|IMAGE1D_BUFFER|IMAGE2D|IMAGE2D_ARRAY|IMAGE3D|PIPE)|OFFSET|READ_ONLY|READ_WRITE|REFERENCE_COUNT|SIZE|SVM_ATOMICS|SVM_FINE_GRAIN_BUFFER|TYPE|USES_SVM_POINTER|USE_HOST_PTR|WRITE_ONLY)|MIGRATE_MEM_OBJECT_(?:CONTENT_UNDEFINED|HOST)|MISALIGNED_SUB_BUFFER_OFFSET|NONE|NON_BLOCKING|OUT_OF_(?:HOST_MEMORY|RESOURCES)|PIPE_(?:MAX_PACKETS|PACKET_SIZE)|PLATFORM_(?:EXTENSIONS|HOST_TIMER_RESOLUTION|NAME|PROFILE|VENDOR|VERSION)|PROFILING_(?:COMMAND_(?:COMPLETE|END|QUEUED|START|SUBMIT)|INFO_NOT_AVAILABLE)|PROGRAM_(?:BINARIES|BINARY_SIZES|BINARY_TYPE(?:_COMPILED_OBJECT|_EXECUTABLE|_LIBRARY|_NONE)?|BUILD_(?:GLOBAL_VARIABLE_TOTAL_SIZE|LOG|OPTIONS|STATUS)|CONTEXT|DEVICES|IL|KERNEL_NAMES|NUM_DEVICES|NUM_KERNELS|REFERENCE_COUNT|SOURCE)|QUEUED|QUEUE_(?:CONTEXT|DEVICE|DEVICE_DEFAULT|ON_DEVICE|ON_DEVICE_DEFAULT|OUT_OF_ORDER_EXEC_MODE_ENABLE|PROFILING_ENABLE|PROPERTIES|REFERENCE_COUNT|SIZE)|RA?|READ_(?:ONLY|WRITE)_CACHE|RG|RGB[Ax]?|RG?x|RUNNING|SAMPLER_(?:ADDRESSING_MODE|CONTEXT|FILTER_MODE|LOD_MAX|LOD_MIN|MIP_FILTER_MODE|NORMALIZED_COORDS|REFERENCE_COUNT)|(?:UN)?SIGNED_INT(?:8|16|32)|SNORM_INT(?:8|16)|SUBMITTED|SUCCESS|UNORM_INT(?:8|16|24|_101010|_101010_2)|UNORM_SHORT_5[56]5|VERSION_(?:1_[012]|2_[01])|s?BGRA|sRGB[Ax]?)\b/,
+    alias: "constant"
+  },
+  // Extracted from cl.h (2.0) and http://streamcomputing.eu/downloads/?opencl_host.lang (opencl-host)
+  "function-opencl-host": {
+    pattern: /\bcl(?:BuildProgram|CloneKernel|CompileProgram|Create(?:Buffer|CommandQueue(?:WithProperties)?|Context|ContextFromType|Image|Image[23]D|Kernel|KernelsInProgram|Pipe|ProgramWith(?:Binary|BuiltInKernels|IL|Source)|Sampler|SamplerWithProperties|SubBuffer|SubDevices|UserEvent)|Enqueue(?:(?:Barrier|Marker)(?:WithWaitList)?|Copy(?:Buffer(?:Rect|ToImage)?|Image(?:ToBuffer)?)|(?:Fill|Map)(?:Buffer|Image)|MigrateMemObjects|NDRangeKernel|NativeKernel|(?:Read|Write)(?:Buffer(?:Rect)?|Image)|SVM(?:Free|Map|MemFill|Memcpy|MigrateMem|Unmap)|Task|UnmapMemObject|WaitForEvents)|Finish|Flush|Get(?:CommandQueueInfo|ContextInfo|Device(?:AndHostTimer|IDs|Info)|Event(?:Profiling)?Info|ExtensionFunctionAddress(?:ForPlatform)?|HostTimer|ImageInfo|Kernel(?:ArgInfo|Info|SubGroupInfo|WorkGroupInfo)|MemObjectInfo|PipeInfo|Platform(?:IDs|Info)|Program(?:Build)?Info|SamplerInfo|SupportedImageFormats)|LinkProgram|(?:Release|Retain)(?:CommandQueue|Context|Device|Event|Kernel|MemObject|Program|Sampler)|SVM(?:Alloc|Free)|Set(?:CommandQueueProperty|DefaultDeviceCommandQueue|EventCallback|Kernel|Kernel(?:Arg(?:SVMPointer)?|ExecInfo)|MemObjectDestructorCallback|UserEventStatus)|Unload(?:Platform)?Compiler|WaitForEvents)\b/,
+    alias: "function"
+  }
+};
+D(E.c, "keyword", gt);
+E.cpp && (gt["type-opencl-host-cpp"] = {
+  pattern: /\b(?:Buffer|BufferGL|BufferRenderGL|CommandQueue|Context|Device|DeviceCommandQueue|EnqueueArgs|Event|Image(?:[123]D|[12]DArray|1DBuffer|[23]DGL|Format|GL)?|Kernel|KernelFunctor|LocalSpaceArg|Memory|NDRange|Pipe|Platform|Program|SVMAllocator|SVMTrait(?:Atomic|Coarse|Fine|ReadOnly|ReadWrite|WriteOnly)|Sampler|UserEvent)\b/,
+  alias: "keyword"
+}, D(E.cpp, "keyword", gt));
+var da = E.diff = {
+  // Match all kinds of coord lines (prefixed by "+++", "---" or "***").
+  // Match "@@ ... @@" coord lines in unified diff.
+  // Match coord lines in normal diff (starts with a number).
+  coord: /^(?:\*{3}|-{3}|\+{3}|\d).*$|^@@.*@@$/m
+  // deleted, inserted, unchanged, diff
+}, nt = {
+  "deleted-sign": "-",
+  "deleted-arrow": "<",
+  "inserted-sign": "+",
+  "inserted-arrow": ">",
+  unchanged: " ",
+  diff: "!"
+};
+for (var ue in nt) {
+  var at = ue.split("-")[0];
+  da[ue] = {
+    pattern: RegExp("^(?:[" + nt[ue] + `].*$
+?)+`, "m"),
+    alias: at != ue ? at : ue == "diff" ? "bold" : void 0,
+    inside: {
+      prefix: {
+        pattern: RegExp("^[" + nt[ue] + "]", "mg"),
+        greedy: !0,
+        alias: at
+      }
+    }
+  };
+}
+var rt = /\b(?:abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|exports|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|module|native|new|non-sealed|null|opens?|package|permits|private|protected|provides|public|record(?!\s*[()[\]{}%~.,:;?%&|^=<>/*+-])|requires|return|sealed|short|static|strictfp|super|switch|synchronized|this|throws?|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\b/, Re = "(?:[a-z]\\w*\\s*\\.\\s*)*(?:[A-Z]\\w*\\s*\\.\\s*)*", mt = {
+  pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,
+  inside: {
+    punctuation: /\./
+  }
+}, ht = {
+  namespace: mt,
+  punctuation: /\./
+}, Yt = {
+  pattern: RegExp(`(^|[^\\w.])${Re}[A-Z](?:[\\d_A-Z]*[a-z]\\w*)?\\b`),
+  lookbehind: !0,
+  inside: ht
+};
+E.java = {
+  "doc-comment": {
+    pattern: /\/\*\*(?!\/)[^]*?(?:\*\/|$)/g,
+    greedy: !0,
+    alias: "comment",
+    inside: "javadoc"
+  },
+  comment: re(),
+  "triple-quoted-string": {
+    // http://openjdk.java.net/jeps/355#Description
+    pattern: /"""[ 	]*\n(?:\\.|[^\\])*?"""/g,
+    greedy: !0,
+    alias: "string"
+  },
+  char: {
+    pattern: /'(?:\\.|[^\\\n']){1,6}'/g,
+    greedy: !0
+  },
+  string: {
+    pattern: /(^|[^\\])"(?:\\.|[^\\\n"])*"/g,
+    lookbehind: !0,
+    greedy: !0
+  },
+  annotation: {
+    pattern: /(^|[^.])@\w+(?:\s*\.\s*\w+)*/,
+    lookbehind: !0,
+    alias: "punctuation"
+  },
+  generics: {
+    pattern: /<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&))*>)*>)*>)*>/,
+    inside: {
+      "class-name": Yt,
+      keyword: rt,
+      punctuation: /[().,:<>]/,
+      operator: /[?&|]/
+    }
+  },
+  import: [
+    {
+      pattern: RegExp(`(\\bimport\\s+)${Re}(?:[A-Z]\\w*|\\*)(?=\\s*;)`),
+      lookbehind: !0,
+      inside: {
+        namespace: mt,
+        punctuation: /\./,
+        operator: /\*/,
+        "class-name": /\w+/
+      }
+    },
+    {
+      pattern: RegExp(`(\\bimport\\s+static\\s+)${Re}(?:\\w+|\\*)(?=\\s*;)`),
+      lookbehind: !0,
+      alias: "static",
+      inside: {
+        namespace: mt,
+        static: /\b\w+$/,
+        punctuation: /\./,
+        operator: /\*/,
+        "class-name": /\w+/
+      }
+    }
+  ],
+  namespace: {
+    pattern: RegExp(
+      `(\\b(?:exports|import(?:\\s+static)?|module|opens?|package|provides|requires|to|transitive|uses|with)\\s+)(?!${rt.source})[a-z]\\w*(?:\\.[a-z]\\w*)*\\.?`
+    ),
+    lookbehind: !0,
+    inside: {
+      punctuation: /\./
+    }
+  },
+  "class-name": [
+    Yt,
+    {
+      // variables, parameters, and constructor references
+      // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
+      pattern: RegExp(`(^|[^\\w.])${Re}[A-Z]\\w*(?=\\s+\\w+\\s*[;,=()]|\\s*(?:\\[[\\s,]*\\]\\s*)?::\\s*new\\b)`),
+      lookbehind: !0,
+      inside: ht
+    },
+    {
+      // class names based on keyword
+      // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
+      pattern: RegExp(`(\\b(?:class|enum|extends|implements|instanceof|interface|new|record|throws)\\s+)${Re}[A-Z]\\w*\\b`),
+      lookbehind: !0,
+      inside: ht
+    }
+  ],
+  keyword: rt,
+  boolean: W,
+  function: {
+    pattern: /\b\w+(?=\()|(::\s*)[a-z_]\w*/,
+    lookbehind: !0
+  },
+  number: /\b0b[01][01_]*l?\b|\b0x(?:\.[a-f\d_p+-]+|[a-f\d_]+(?:\.[a-f\d_p+-]+)?)\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfl]?/i,
+  constant: /\b[A-Z][A-Z_\d]+\b/,
+  operator: {
+    pattern: /(^|[^.])(?:<<=?|>>>?=?|->|--|\+\+|&&|\|\||::|[?:~]|[%&|^!=<>/*+-]=?)/m,
+    lookbehind: !0
+  },
+  punctuation: Ee
+};
+D(
+  E.less = ae("css", {
+    comment: re(),
+    atrule: {
+      pattern: /@[\w-](?:\((?:[^(){}]|\([^(){}]*\))*\)|[^(){};\s]|\s+(?!\s))*?(?=\s*\{)/,
+      inside: {
+        punctuation: /[():]/
+      }
+    },
+    // selectors and mixins are considered the same
+    selector: {
+      pattern: /(?:@\{[\w-]+\}|[^{};\s@])(?:@\{[\w-]+\}|\((?:[^(){}]|\([^(){}]*\))*\)|[^(){};@\s]|\s+(?!\s))*?(?=\s*\{)/,
+      inside: {
+        // mixin parameters
+        variable: /@+[\w-]+/
+      }
+    },
+    property: /(?:@\{[\w-]+\}|[\w-])+(?:\+_?)?(?=\s*:)/,
+    operator: /[/*+-]/
+  }),
+  "property",
+  {
+    variable: [
+      // Variable declaration (the colon must be consumed!)
+      {
+        pattern: /@[\w-]+\s*:/,
+        inside: {
+          punctuation: /:/
+        }
+      },
+      // Variable usage
+      /@@?[\w-]+/
+    ],
+    "mixin-usage": {
+      pattern: /([{;]\s*)[.#](?!\d)[\w-].*?(?=[(;])/,
+      lookbehind: !0,
+      alias: "function"
+    }
+  }
+);
+E.objc = E.objectivec = ae("c", {
+  string: {
+    pattern: /@?"(?:\\[^]|[^\\\n"])*"/g,
+    greedy: !0
+  },
+  keyword: /\b(?:asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|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 E.objc["class-name"];
+var Nn = {
+  pattern: /^(..)[^]+(?=.)/,
+  lookbehind: !0
+}, it = "(?:([^a-zA-Z\\d\\s{(\\[<=])(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])*\\1|\\((?:\\\\[\\s\\S]|[^\\\\()]|\\((?:\\\\[\\s\\S]|[^\\\\()])*\\))*\\)|\\{(?:\\\\[\\s\\S]|[^\\\\{}]|\\{(?:\\\\[\\s\\S]|[^\\\\{}])*\\})*\\}|\\[(?:\\\\[\\s\\S]|[^\\\\[\\]]|\\[(?:\\\\[\\s\\S]|[^\\\\[\\]])*\\])*\\]|<(?:\\\\[\\s\\S]|[^\\\\<>]|<(?:\\\\[\\s\\S]|[^\\\\<>])*>)*>)", Xt = `(?:"(?:\\\\.|[^\\\\
+"])*"|(?:\\b(?!\\d)\\w+|[^\\s\0-\\x7f]+)[?!]?|\\$.)`, ie = {
+  pattern: /((?:^|[^\\])(?:\\\\)*)#\{(?:[^{}]|\{[^}]*\})*\}/,
+  lookbehind: !0,
+  inside: {
+    content: Nn,
+    delimiter: {
+      pattern: /.+/,
+      alias: "punctuation"
+    }
+  }
+};
+Nn.inside = E.rb = E.ruby = {
+  comment: {
+    pattern: /#.*|^=begin\s[^]*?^=end/mg,
+    greedy: !0
+  },
+  "string-literal": [
+    {
+      pattern: RegExp("%[qQiIwWs]?" + it, "g"),
+      greedy: !0,
+      inside: {
+        interpolation: ie,
+        string: /[^]+/
+      }
+    },
+    {
+      pattern: /(["'])(?:#\{[^}]+\}|#(?!\{)|\\[^]|(?!\1)[^\\#\n])*\1/g,
+      greedy: !0,
+      inside: {
+        interpolation: ie,
+        string: /[^]+/
+      }
+    },
+    {
+      pattern: /<<[-~]?([a-z_]\w*)\n(?:.*\n)*?[ 	]*\1/gi,
+      alias: "heredoc-string",
+      greedy: !0,
+      inside: {
+        delimiter: {
+          pattern: /^<<[-~]?[a-z_]\w*|\b[a-z_]\w*$/i,
+          inside: {
+            symbol: /\w+/,
+            punctuation: /^<<[-~]?/
+          }
+        },
+        interpolation: ie,
+        string: /[^]+/
+      }
+    },
+    {
+      pattern: /<<[-~]?'([a-z_]\w*)'\n(?:.*\n)*?[ 	]*\1/gi,
+      alias: "heredoc-string",
+      greedy: !0,
+      inside: {
+        delimiter: {
+          pattern: /^<<[-~]?'[a-z_]\w*'|\b[a-z_]\w*$/i,
+          inside: {
+            symbol: /\w+/,
+            punctuation: /^<<[-~]?'|'$/
+          }
+        },
+        string: /[^]+/
+      }
+    }
+  ],
+  "command-literal": [
+    {
+      pattern: RegExp("%x" + it, "g"),
+      greedy: !0,
+      inside: {
+        interpolation: ie,
+        command: {
+          pattern: /[^]+/,
+          alias: "string"
+        }
+      }
+    },
+    {
+      pattern: /`(?:#\{[^}]+\}|#(?!\{)|\\[^]|[^\\`#\n])*`/g,
+      greedy: !0,
+      inside: {
+        interpolation: ie,
+        command: {
+          pattern: /[^]+/,
+          alias: "string"
+        }
+      }
+    }
+  ],
+  "class-name": {
+    pattern: /(\b(?:class|module)\s+|\bcatch\s+\()[\w.\\]+|\b[A-Z_]\w*(?=\s*\.\s*new\b)/,
+    lookbehind: !0,
+    inside: {
+      punctuation: /[.\\]/
+    }
+  },
+  "regex-literal": [
+    {
+      pattern: RegExp(`%r${it}[egimnosux]{0,6}`, "g"),
+      greedy: !0,
+      inside: {
+        interpolation: ie,
+        regex: /[^]+/
+      }
+    },
+    {
+      pattern: /(^|[^/])\/(?!\/)(?:\[[^\n\]]+\]|\\.|[^\\\n/[])+\/[egimnosux]{0,6}(?=\s*(?:$|[\n,.;})#]))/g,
+      lookbehind: !0,
+      greedy: !0,
+      inside: {
+        interpolation: ie,
+        regex: /[^]+/
+      }
+    }
+  ],
+  variable: /[@$]+(?!\d)\w+(?:[?!]|\b)/,
+  symbol: [
+    {
+      pattern: RegExp("(^|[^:]):" + Xt, "g"),
+      lookbehind: !0,
+      greedy: !0
+    },
+    {
+      pattern: RegExp(`([
+{(,][ 	]*)` + Xt + "(?=:(?!:))", "g"),
+      lookbehind: !0,
+      greedy: !0
+    }
+  ],
+  "method-definition": {
+    pattern: /(\bdef\s+)\w+(?:\s*\.\s*\w+)?/,
+    lookbehind: !0,
+    inside: {
+      function: /\b\w+$/,
+      keyword: /^self\b/,
+      "class-name": /^\w+/,
+      punctuation: /\./
+    }
+  },
+  keyword: /\b(?:BEGIN|END|alias|and|begin|break|case|class|def|define_method|defined|do|each|else|elsif|end|ensure|extend|f?or|if|in|include|module|new|next|nil|not|prepend|private|protected|public|raise|redo|require|rescue|retry|return|self|super|[tw]hen|throw|undef|unless|until|while|yield)\b/,
+  boolean: W,
+  builtin: /\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Fixnum|Float|Hash|IO|Integer|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|Stat|String|Struct|Symbol|TMS|Thread|ThreadGroup|Time|TrueClass)\b/,
+  constant: /\b[A-Z][A-Z\d_]*(?:[?!]|\b)/,
+  number: Rn,
+  "double-colon": {
+    pattern: /::/,
+    alias: "punctuation"
+  },
+  operator: /\.{2,3}|&\.|===|<?=>|[!=]?~|(?:&&|\|\||<<|>>|\*\*|[%&|^!=<>/*+-])=?|[?:]/,
+  punctuation: /[()[\]{}.,;]/
+};
+E.sql = {
+  comment: /\/\*[^]*?\*\/|(?:--|\/\/|#).*/,
+  variable: [
+    {
+      pattern: /@(["'`])(?:\\[^]|(?!\1)[^\\])+\1/g,
+      greedy: !0
+    },
+    /@[\w.$]+/
+  ],
+  string: {
+    pattern: /(^|[^@\\])(["'])(?:\\[^]|(?!\2)[^\\]|\2\2)*\2/g,
+    lookbehind: !0,
+    greedy: !0
+  },
+  identifier: {
+    pattern: /(^|[^@\\])`(?:\\[^]|[^\\`]|``)*`/g,
+    lookbehind: !0,
+    greedy: !0,
+    inside: {
+      punctuation: /^`|`$/
+    }
+  },
+  function: /\b(?:avg|count|first|format|last|[lu]case|len|max|mi[dn]|mod|now|round|sum)(?=\s*\()/i,
+  // Should we highlight user defined functions too?
+  keyword: /\b(?:action|add|after|algorithm|alter|analyze|any|apply|asc?|authorization|auto_increment|backup|bdb|begin|berkeleydb|bigint|binary|bit|blob|bool|boolean|break|browse|[br]tree|bulk|by|c?all|cascaded?|case|chain|character|charset|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|for|force|foreign|freetexttable|freetext|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|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|matched|match|(?:medium|tiny)(?:blob|int|text)|merge|middleint|minute|mode|modifies|modify|month|multi(?:linestring|point|polygon)|national|natural|n?char|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|returning|returns?|revoke|right|rollback|routine|row(?:count|guidcol|s)?|rule|savepoint|save|schema|second|select|serializable|serial|session_user|session|setuser|set|share|show|shutdown|simple|smallint|snapshot|some|soname|sql|start(?:ing)?|statistics|status|striped|system_user|tables?|tablespace|temp(?:orary|table)?|terminated|textsize|text|[tw]hen|timestamp|time|top?|transactions?|tran|trigger|truncate|tsequal|types?|unbounded|uncommitted|undefined|union|unique|unlock|unpivot|unsigned|updatetext|update|usage|user?|using|values?|var(?:binary|char|character|ying)|view|waitfor|warnings|where|while|with(?: rollup|in)?|work|writetext|write|year)\b/i,
+  boolean: /\b(?:false|true|null)\b/i,
+  number: /\b0x[a-f\d]+\b|\b\d+(?:\.\d*)?|\B\.\d+\b/i,
+  operator: /[=%~^/*+-]|&&?|\|\|?|!=?|<<|<=?>?|>[>=]?|\b(?:and|between|div|[ir]?like|in|is|not|x?or|regexp|sounds like)\b/i,
+  punctuation: /[()[\].,;`]/
+};
+E.wasm = {
+  comment: /\(;[^]*?;\)|;;.*/,
+  string: {
+    pattern: /"(?:\\[^]|[^\\"])*"/g,
+    greedy: !0
+  },
+  keyword: [
+    {
+      pattern: /\b(?:align|offset)=/,
+      inside: {
+        operator: /=/
+      }
+    },
+    {
+      pattern: /\b(?:(?:[fi]32|[fi]64)(?:\.(?:abs|a[dn]d|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|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|x?or))?|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[a-fA-F\d](?:_?[a-fA-F\d])*(?:\.[a-fA-F\d](?:_?[\da-fA-D])*)?(?:[pP][+-]?\d(?:_?\d)*)?)\b|\binf\b|\bnan(?::0x[a-fA-F\d](?:_?[\da-fA-D])*)?\b/,
+  punctuation: /[()]/
+};
+var _e = (e, t) => {
+  for (var n = 0; n < t; n++)
+    e = e.replace(/<self>/g, `(?:${e})`);
+  return e.replace(/<self>/g, "[]");
+}, B = (e, t) => e.replace(/<(\d+)>/g, (n, s) => `(?:${t[+s]})`), O = (e, t, n) => RegExp(B(e, t), n), Et = /\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/, he = E.cpp = ae("c", {
+  "class-name": [
+    {
+      pattern: RegExp(`(\\b(?:class|concept|enum|struct|typename)\\s+)(?!${Et.source})\\w+`),
+      lookbehind: !0
+    },
+    // This is intended to capture the class name of method implementations like:
+    //   void foo::bar() const {}
+    // However! The `foo` in the above example could also be a namespace, so we only capture the class name if
+    // it starts with an uppercase letter. This approximation should give decent results.
+    /\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/,
+    // This will capture the class name before destructors like:
+    //   Foo::~Foo() {}
+    /\b[a-z_]\w*(?=\s*::\s*~\w+\s*\()/i,
+    // This also intends to capture the class name of method implementations but here the class has template
+    // parameters, so it can't be a namespace (until C++ adds generic namespaces).
+    /\b\w+(?=\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\s*::\s*\w+\s*\()/
+  ],
+  keyword: Et,
+  number: {
+    pattern: /(?:\b0b[01']+|\b0x(?:[a-f\d']+(?:\.[a-f\d']*)?|\.[a-f\d']+)(?:p[+-]?[\d']+)?|(?:\b[\d']+(?:\.[\d']*)?|\B\.[\d']+)(?:e[+-]?[\d']+)?)[ful]{0,4}/gi,
+    greedy: !0
+  },
+  operator: /->|--|\+\+|&&|\|\||[?:~]|<=>|>>=?|<<=?|[%&|^!=<>/*+-]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|x?or|x?or_eq)\b/,
+  boolean: W
+});
+D(he, "string", {
+  module: {
+    // https://en.cppreference.com/w/cpp/language/modules
+    pattern: O(
+      `(\\b(?:import|module)\\s+)(?:"(?:\\\\[\\s\\S]|[^\\\\
+"])*"|<[^<>
+]*>|<0>(?:\\s*:\\s*<0>)?|:\\s*<0>)`,
+      [`\\b(?!${Et.source})\\w+(?:\\s*\\.\\s*\\w+)*\\b`],
+      "g"
+    ),
+    lookbehind: !0,
+    greedy: !0,
+    inside: {
+      string: /^[<"][^]+/,
+      operator: /:/,
+      punctuation: /\./
+    }
+  },
+  "raw-string": {
+    pattern: /R"([^()\\ ]{0,16})\([^]*?\)\1"/g,
+    greedy: !0,
+    alias: "string"
+  }
+});
+D(he, "keyword", {
+  "generic-function": {
+    pattern: /\b(?!operator\b)[a-z_]\w*\s*<(?:[^<>]|<[^<>]*>)*>(?=\s*\()/i,
+    inside: {
+      function: /^\w+/,
+      generic: {
+        pattern: /<[^]+/,
+        alias: "class-name",
+        inside: he
+      }
+    }
+  }
+});
+D(he, "operator", {
+  "double-colon": {
+    pattern: /::/,
+    alias: "punctuation"
+  }
+});
+var kn = Object.assign({}, he);
+D(he, "class-name", {
+  // the base clause is an optional list of parent classes
+  // https://en.cppreference.com/w/cpp/language/class
+  "base-clause": {
+    pattern: /(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/g,
+    lookbehind: !0,
+    greedy: !0,
+    inside: kn
+  }
+});
+D(kn, "double-colon", {
+  // All untokenized words that are not namespaces should be class names
+  "class-name": /\b[a-z_]\w*\b(?!\s*::)/i
+});
+E.go = {
+  comment: re(),
+  char: {
+    pattern: /'(?:\\.|[^\\\n']){0,10}'/g,
+    greedy: !0
+  },
+  string: {
+    pattern: /(^|[^\\])"(?:\\.|[^\\\n"])*"|`[^`]*`/g,
+    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|true|iota|nil)\b/,
+  function: /\b\w+(?=\()/,
+  number: [
+    // binary and octal integers
+    /\b0(?:b[01_]+|o[0-7_]+)i?\b/i,
+    // hexadecimal integers and floats
+    /\b0x(?:[a-f\d_]+(?:\.[a-f\d_]*)?|\.[a-f\d_]+)(?:p[+-]?\d+(?:_\d+)*)?i?(?!\w)/i,
+    // decimal integers and floats
+    /(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?[\d_]+)?i?(?!\w)/i
+  ],
+  operator: /--|\+\+|&&|\|\||&\^=?|<-|<<=?|>>=?|[%&|^!=<>/*+-]=?|:=|\.{3}/,
+  punctuation: Ee,
+  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/
+};
+var st = {};
+E.js = E.javascript = Object.assign(st, {
+  "doc-comment": {
+    pattern: /\/\*\*(?!\/)[^]*?(?:\*\/|$)/g,
+    greedy: !0,
+    alias: "comment",
+    inside: "jsdoc"
+  },
+  comment: re(),
+  hashbang: {
+    pattern: /^#!.*/g,
+    greedy: !0,
+    alias: "comment"
+  },
+  "template-string": {
+    pattern: /`(?:\\[^]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})*\}|(?!\$\{)[^\\`])*`/g,
+    greedy: !0,
+    inside: {
+      "template-punctuation": {
+        pattern: /^`|`$/,
+        alias: "string"
+      },
+      interpolation: {
+        pattern: /((?:^|[^\\])(?:\\\\)*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})*\}/,
+        lookbehind: !0,
+        inside: {
+          "interpolation-punctuation": {
+            pattern: /^\$\{|\}$/,
+            alias: "punctuation"
+          },
+          [Y]: st
+        }
+      },
+      string: /[^]+/
+    }
+  },
+  "string-property": {
+    pattern: /((?:^|[,{])[ 	]*)(["'])(?:\\[^]|(?!\2)[^\\\n])*\2(?=\s*:)/mg,
+    lookbehind: !0,
+    greedy: !0,
+    alias: "property"
+  },
+  string: Nt(),
+  regex: {
+    pattern: /((?:^|[^$\w\xa0-\uffff"'`.)\]\s]|\b(?:return|yield))\s*)\/(?:(?:\[(?:\\.|[^\\\n\]])*\]|\\.|[^\\\n/[])+\/[dgimyus]{0,7}|(?:\[(?:\\.|[^\\\n[\]]|\[(?:\\.|[^\\\n[\]]|\[(?:\\.|[^\\\n[\]])*\])*\])*\]|\\.|[^\\\n/[])+\/[dgimyus]{0,7}v[dgimyus]{0,7})(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?!\/\*|[^()[\]{}.,:;?`\n%&|^!=<>/*+-]))/g,
+    lookbehind: !0,
+    greedy: !0,
+    inside: {
+      "regex-flags": /\w+$/,
+      "regex-delimiter": /^\/|\/$/,
+      "regex-source": {
+        pattern: /.+/,
+        alias: "language-regex",
+        inside: "regex"
+      }
+    }
+  },
+  "class-name": [
+    {
+      pattern: /(\b(?:class|extends|implements|instanceof|interface|new)\s+)(?!\d)(?:(?!\s)[$\w.\xa0-\uffff])+/,
+      lookbehind: !0,
+      inside: {
+        punctuation: /\./
+      }
+    },
+    {
+      pattern: /(^|[^$\w\xa0-\uffff]|\s)(?![a-z\d])(?:(?!\s)[$\w\xa0-\uffff])+(?=\.(?:constructor|prototype)\b)/,
+      lookbehind: !0
+    }
+  ],
+  // This must be declared before keyword because we use "function" inside the look-forward
+  "function-variable": {
+    pattern: /#?(?!\d)(?:(?!\s)[$\w\xa0-\uffff])+(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^)]*\))*\)|(?!\d)(?:(?!\s)[$\w\xa0-\uffff])+)\s*=>))/,
+    alias: "function",
+    inside: {
+      "maybe-class-name": /^[A-Z].*/
+    }
+  },
+  parameter: [
+    /(function(?:\s+(?!\d)(?:(?!\s)[$\w\xa0-\uffff])+)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,
+    /(^|[^$\w\xa0-\uffff]|\s)(?!\d)(?:(?!\s)[$\w\xa0-\uffff])+(?=\s*=>)/,
+    /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
+    /((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|continue|default|do|else|finally|for|if|return|switch|throw|try|while|yield|class|const|debugger|delete|enum|extends|function|[gs]et|export|from|import|implements|in|instanceof|interface|let|new|null|of|package|private|protected|public|static|super|this|typeof|undefined|var|void|with)(?![$\w\xa0-\uffff]))(?:(?!\d)(?:(?!\s)[$\w\xa0-\uffff])+\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/
+  ].map((e) => ({
+    pattern: e,
+    lookbehind: !0,
+    inside: st
+  })),
+  constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/,
+  keyword: [
+    {
+      pattern: /(^|[^.]|\.{3}\s*)\b(?:as|assert(?=\s*\{)|export|from(?!\s*[^\s"'])|import)\b/,
+      alias: "module",
+      lookbehind: !0
+    },
+    {
+      pattern: /(^|[^.]|\.{3}\s*)\b(?:await|break|case|catch|continue|default|do|else|finally|for|if|return|switch|throw|try|while|yield)\b/,
+      alias: "control-flow",
+      lookbehind: !0
+    },
+    {
+      pattern: /(^|[^.]|\.{3}\s*)\b(?:async(?!\s*[^\s($\w\xa0-\uffff])|class|const|debugger|delete|enum|extends|function|[gs]et(?!\s*[^\s#[$\w\xa0-\uffff])|implements|in|instanceof|interface|let|new|null|of|package|private|protected|public|static|super|this|typeof|undefined|var|void|with)\b/,
+      lookbehind: !0
+    }
+  ],
+  boolean: W,
+  // Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)
+  function: {
+    pattern: /#?(?!\d)(?:(?!\s)[$\w\xa0-\uffff])+(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
+    inside: {
+      "maybe-class-name": /^[A-Z].*/
+    }
+  },
+  number: {
+    pattern: /(^|[^$\w])(?:NaN|Infinity|0[bB][01]+(?:_[01]+)*n?|0[oO][0-7]+(?:_[0-7]+)*n?|0[xX][a-fA-F\d]+(?:_[a-fA-F\d]+)*n?|\d+(?:_\d+)*n|(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?)(?![$\w])/,
+    lookbehind: !0
+  },
+  "literal-property": {
+    pattern: /([\n,{][ 	]*)(?!\d)(?:(?!\s)[$\w\xa0-\uffff])+(?=\s*:)/,
+    lookbehind: !0,
+    alias: "property"
+  },
+  operator: [
+    {
+      pattern: /=>/,
+      alias: "arrow"
+    },
+    /--|\+\+|(?:\*\*|&&|\|\||[!=]=|>>>?|<<|[%&|^!=<>/*+-]|\?\?)=?|\.{3}|\?(?!\.)|~|:/
+  ],
+  "property-access": {
+    pattern: /(\.\s*)#?(?!\d)(?:(?!\s)[$\w\xa0-\uffff])+/,
+    lookbehind: !0,
+    inside: {
+      "maybe-class-name": /^[A-Z].*/
+    }
+  },
+  "maybe-class-name": {
+    pattern: /(^|[^$\w\xa0-\uffff])[A-Z][$\w\xa0-\uffff]+/,
+    lookbehind: !0
+  },
+  punctuation: /\?\.|[()[\]{}.,:;]/
+});
+var ua = (e) => (t, n) => {
+  for (var s = Rt(e), d = "", p = [], b = 0, m = Ye(t, n), _ = 0, y = m.length, h = 0; _ < y; ) {
+    var l = m[_++], c = l.length, w = l.type;
+    w && w.slice(0, 6) != "ignore" ? (p[b++] = [h, l], d += " ".repeat(c)) : d += t.slice(h, h + c), h += c;
+  }
+  var g = 0, h = 0, a = (u) => {
+    for (var o = 0; g < b && o < u.length; o++) {
+      var i = u[o], f = i.content;
+      if (Array.isArray(f))
+        a(f);
+      else {
+        for (var R = i.length, A = [], v, S, k = 0, N = h; ([v, S] = p[g], v >= h && v < h + R) && (N < v && (A[k++] = d.slice(N, v)), N = v + S.length, A[k++] = S, ++g != b); )
+          ;
+        h += R, k && (N < h && (A[k++] = d.slice(N, h)), f ? i.content = A : (u.splice(o, 1, ...A), o += k - 1));
+      }
+    }
+  }, r = s ? St(d, s) : [d];
+  return a(r), r;
+}, On = E.js, kt = On["template-string"], pa = kt.pattern.source, fa = kt.inside.interpolation.pattern, pe = (e, t) => ({
+  pattern: RegExp("((?:" + t + ")\\s*)" + pa, "g"),
+  lookbehind: !0,
+  greedy: !0,
+  inside: {
+    "template-punctuation": {
+      pattern: /^`|`$/,
+      alias: "string"
+    },
+    ["language-" + e]: {
+      pattern: /[^]+/,
+      inside: {
+        interpolation: {
+          pattern: fa,
+          lookbehind: !0,
+          alias: "language-javascript",
+          inside: {
+            "interpolation-punctuation": {
+              pattern: /^\$\{|\}$/,
+              alias: "punctuation"
+            },
+            [Y]: "js"
+          }
+        },
+        [le]: ua(e)
+      }
+    }
+  }
+});
+On["template-string"] = [
+  // styled-jsx:
+  //   css`a { color: #25F; }`
+  // styled-components:
+  //   styled.h1`color: red;`
+  pe("css", "\\b(?:styled(?:\\([^)]*\\))?(?:\\s*\\.\\s*\\w+(?:\\([^)]*\\))*)*|css(?:\\s*\\.\\s*(?:global|resolve))?|createGlobalStyle|keyframes)"),
+  // html`<p></p>`
+  // div.innerHTML = `<p></p>`
+  pe("html", "\\bhtml|\\.\\s*(?:inner|outer)HTML\\s*\\+?="),
+  // svg`<path fill="#fff" d="M55.37 ..."/>`
+  pe("svg", "\\bsvg"),
+  // md`# h1`, markdown`## h2`
+  pe("markdown", "\\b(?:markdown|md)"),
+  // gql`...`, graphql`...`, graphql.experimental`...`
+  pe("graphql", "\\b(?:gql|graphql(?:\\s*\\.\\s*experimental)?)"),
+  // sql`...`
+  pe("sql", "\\bsql"),
+  // vanilla template string
+  kt
+];
+var $e = "\\s|//.*(?!.)|/\\*(?:[^*]|\\*(?!/))*\\*/", _t = "\\{(?:[^{}]|\\{(?:[^{}]|\\{[^}]*\\})*\\})*\\}", Qt = B("\\{<0>*\\.{3}(?:[^{}]|<1>)*\\}", [$e, _t]), Jt = (e) => e && (!e.type || e.type == "plain-text"), ba = (e, t, n) => {
+  for (var s = 0, d = [], p = 0; s < e.length; s++) {
+    var b = e[s], m = b.length, _ = b.type, y = !_, l, c, w, g, h;
+    _ && (h = b.content, _ == "tag" ? (w = h[0].length, c = h[2] ? t.substr(n + w, h[1].length) : "", w > 1 ? p && d[p - 1][0] == c && p-- : h[h.length - 1].length < 2 && (d[p++] = [c, 0])) : p && _ == "punctuation" ? (l = d[p - 1], h == "{" ? l[1]++ : l[1] && h == "}" ? l[1]-- : y = !"}()[]".includes(h)) : y = !0), y && p && !d[p - 1][1] && (w = n, Jt(e[s + 1]) && (m += e[s + 1].length, e.splice(s + 1, 1)), Jt(e[s - 1]) && (w -= e[--s].length, e.splice(s, 1)), g = t.slice(w, n + m), e[s] = new fe("plain-text", g, g)), n += m;
+  }
+  return e;
+}, Ln = (e, t) => {
+  D(E[t] = e = Tt(e), "regex", {
+    tag: {
+      pattern: O(
+        `</?(?:(?!\\d)[^\\s/=><%]+(?:<0>(?:<0>*(?:[^\\s<>/={*]+(?:<0>*=<0>*(?!\\s)(?:"[^"]*"|'[^']*'|<1>)?|(?=[\\s/>]))|<2>))+)?<0>*/?)?>`,
+        [$e, _t, Qt],
+        "g"
+      ),
+      greedy: !0,
+      inside: {
+        punctuation: /^<\/?|\/?>$/,
+        tag: {
+          pattern: /^[^\s/]+/,
+          inside: {
+            namespace: /^[^:]+:/,
+            "class-name": /^[A-Z]\w*(?:\.[A-Z]\w*)*$/
+          }
+        },
+        script: {
+          // Allow for two levels of nesting
+          pattern: O("(=<0>*)<1>", [$e, _t]),
+          lookbehind: !0,
+          alias: t = "language-" + t,
+          inside: e
+        },
+        spread: {
+          pattern: RegExp(Qt),
+          alias: t,
+          inside: e
+        },
+        "attr-value": {
+          pattern: O(`(=<0>*)(?:"[^"]*"|'[^']*')`, [$e]),
+          lookbehind: !0,
+          inside: {
+            punctuation: /^["']|["']$/
+          }
+        },
+        comment: e.comment,
+        "attr-equals": /=/,
+        "attr-name": {
+          pattern: /\S+/,
+          inside: {
+            namespace: /^[^:]+:/
+          }
+        }
+      }
+    }
+  }), e[le] = (n, s) => ba(Ye(n, s), n, 0);
+};
+Ln(E.js, "jsx");
+E.lua = {
+  comment: /^#!.+|--(?:\[(=*)\[[^]*?\]\1\]|.*)/m,
+  // \z may be used to skip the following space
+  string: {
+    pattern: /(["'])(?:(?!\1)[^\\\n]|\\z\s|\\[^z])*\1|\[(=*)\[[^]*?\]\2\]/g,
+    greedy: !0
+  },
+  number: /\b0x[a-f\d]+(?:\.[a-f\d]*)?(?:p[+-]?\d+)?\b|\b\d+(?:\.\B|(?:\.\d*)?(?:e[+-]?\d+)?\b)|\B\.\d+(?:e[+-]?\d+)?\b/i,
+  keyword: /\b(?:and|break|do|else|elseif|end|false|true|f?or|function|goto|if|in|local|nil|not|repeat|return|then|until|while)\b/,
+  function: /(?!\d)\w+(?=\s*(?:[({]))/,
+  // Match ".." but don't break "..."
+  operator: {
+    pattern: /[%&|^#*+-]|\/\/?|<[<=]?|>[>=]?|[=~]=?|(^|[^.])\.\.(?!\.)/,
+    lookbehind: !0
+  },
+  punctuation: /[()[\]{},;]|\.+|:+/
+};
+var Me = "(?:\\((?:\\\\[\\s\\S]|[^\\\\()])*\\)|\\{(?:\\\\[\\s\\S]|[^\\\\{}])*\\}|\\[(?:\\\\[\\s\\S]|[^\\\\[\\]])*\\]|<(?:\\\\[\\s\\S]|[^\\\\<>])*>)", en = "(?![a-zA-Zd])\\s*(?:([^a-zA-Zd\\s{([<])(?:\\\\[^]|(?!\\1)[^\\\\])*\\1|([a-zA-Zd])(?:\\\\[^]|(?!\\2)[^\\\\])*\\2";
+E.perl = {
+  comment: [
+    {
+      // POD
+      pattern: /(^\s*)=\w[^]*?=cut.*/mg,
+      lookbehind: !0,
+      greedy: !0
+    },
+    {
+      pattern: /(^|[^\\$])#.*/g,
+      lookbehind: !0,
+      greedy: !0
+    }
+  ],
+  // TODO Could be nice to handle Heredoc too.
+  string: {
+    pattern: RegExp(
+      `\\bq[qwx]?${en}|${Me})|("|\`)(?:\\\\[^]|(?!\\3)[^\\\\])*\\3|'(?:\\\\.|[^\\\\
+'])*'`,
+      "g"
+    ),
+    greedy: !0
+  },
+  regex: [
+    {
+      pattern: RegExp(
+        `\\b(?:m|qr)${en}|${Me})[msixpodualngc]*`,
+        "g"
+      ),
+      greedy: !0
+    },
+    // The lookbehinds prevent -s from breaking
+    {
+      pattern: RegExp(
+        `(^|[^-])\\b(?:s|tr|y)(?![a-zA-Zd])\\s*(?:([^a-zA-Zd\\s{([<])(?:\\\\[^]|(?!\\2)[^\\\\])*\\2(?:\\\\[^]|(?!\\2)[^\\\\])*\\2|([a-zA-Zd])(?:\\\\[^]|(?!\\3)[^\\\\])*\\3(?:\\\\[^]|(?!\\3)[^\\\\])*\\3|${Me}\\s*${Me})[msixpodualngcer]*`,
+        "g"
+      ),
+      lookbehind: !0,
+      greedy: !0
+    },
+    // /.../
+    // The look-ahead tries to prevent two divisions on
+    // the same line from being highlighted as regex.
+    // This does not support multi-line regex.
+    {
+      pattern: /\/(?:\\.|[^\\\n/])*\/[msixpodualngc]*(?=\s*(?:$|[\n,.;})&|*~<>!?^+-]|(?:and|cmp|eq|[gl][et]|ne|not|x|x?or)\b))/g,
+      greedy: !0
+    }
+  ],
+  // FIXME Not sure about the handling of ::, ', and #
+  variable: /[&*$@%](?:\{\^[A-Z]+\}|\^[A-Z_]|#?(?=\{)|#?(?:(?:::)*'?(?!\d)[$\w]+(?![$\w]))+(?:::)*|\d+)|(?!%=)[$@%][!"#$%&'*,./:;<=>?@()[\]{}||^_`|~+-]/,
+  filehandle: {
+    // <>, <FOO>, _
+    pattern: /<(?![<=])\S*?>|\b_\b/,
+    alias: "symbol"
+  },
+  "v-string": {
+    // v1.2, 1.2.3
+    pattern: /v\d+(?:\.\d+)*|\d+(?:\.\d+){2,}/,
+    alias: "string"
+  },
+  function: {
+    pattern: /(\bsub[ 	]+)\w+/,
+    lookbehind: !0
+  },
+  keyword: /\b(?:any|break|continue|default|delete|die|do|else|elsif|eval|for|foreach|given|goto|if|last|local|my|next|our|package|print|redo|require|return|say|state|sub|switch|undef|unless|until|use|when|while)\b/,
+  number: /\b(?:0x[a-fA-F\d](?:_?[a-fA-F\d])*|0b[01](?:_?[01])*|(?:(?:\d(?:_?\d)*)?\.)?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)\b/,
+  operator: /-[rwxoRWXOezsfdlpSbctugkTBMAC]\b|->|=>|=~|~~|<=>?|!~|--|\+\+|(?:\*\*|\/\/|&&|\|\||<<|>>|[~%&|^!=<>/*+-])=?|\.(?:=|\.\.?)?|[\\?]|\bx(?:=|\b)|\b(?:and|cmp|eq|[gl][et]|ne|not|x?or)\b/,
+  punctuation: /[()[\]{},:;]/
+};
+var tn = {
+  "format-spec": {
+    pattern: /(:)[^(){}:]+(?=\}$)/,
+    lookbehind: !0
+  },
+  "conversion-option": {
+    pattern: /![sra](?=[:}]$)/,
+    alias: "punctuation"
+  }
+};
+tn[Y] = E.py = E.python = {
+  comment: {
+    pattern: /#.*/g,
+    greedy: !0
+  },
+  "string-interpolation": {
+    pattern: /(?:fr?|rf)(?:("""|''')[^]*?\1|(["'])(?:\\[^]|(?!\2)[^\\\n])*\2)/gi,
+    greedy: !0,
+    inside: {
+      interpolation: {
+        // "{" <expression> <optional "!s", "!r", or "!a"> <optional ":" format specifier> "}"
+        pattern: /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})*\}/,
+        lookbehind: !0,
+        inside: tn
+      },
+      string: /[^]+/
+    }
+  },
+  "triple-quoted-string": {
+    pattern: /(?:br?|rb?|u)?("""|''')[^]*?\1/gi,
+    greedy: !0,
+    alias: "string"
+  },
+  string: {
+    pattern: /(?:br?|rb?|u)?(["'])(?:\\[^]|(?!\1)[^\\\n])*\1/gi,
+    greedy: !0
+  },
+  function: {
+    pattern: /((?:^|\s)def[ 	]+)(?!\d)\w+(?=\s*\()/,
+    lookbehind: !0
+  },
+  "class-name": {
+    pattern: /(\bclass\s+)\w+/i,
+    lookbehind: !0
+  },
+  decorator: {
+    pattern: /(^[ 	]*)@\w+(?:\.\w+)*/m,
+    lookbehind: !0,
+    alias: "annotation punctuation",
+    inside: {
+      punctuation: /\./
+    }
+  },
+  keyword: /\b(?:_(?=\s*:)|and|as|assert|async|await|break|case|class|continue|de[fl]|elif|else|except|exec|finally|f?or|from|global|i[fns]|import|lambda|match|nonlocal|not|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|ma[px]|memoryview|min|next|object|oct|open|ord|pow|property|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|x?range|zip)\b/,
+  boolean: /\b(?:False|True|None)\b/,
+  number: /\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f\d])+)\b|(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:e[+-]?\d+(?:_\d+)*)?j?(?!\w)/i,
+  operator: /!=|:=|\*\*=?|\/\/=?|<>|>>|<<|[%=<>/*+-]=?|[&|^~]/,
+  punctuation: Ee
+};
+var ga = _e("/\\*(?:[^*/]|\\*(?!/)|/(?!\\*)|<self>)*\\*/", 2), nn = {
+  pattern: /b?"(?:\\[^]|[^\\"])*"|b?r(#*)"(?:[^"]|"(?!\1))*"\1/g,
+  greedy: !0
+}, an = {
+  "closure-punctuation": {
+    pattern: /^\||\|$/,
+    alias: "punctuation"
+  }
+};
+an[Y] = E.rust = {
+  comment: {
+    pattern: RegExp("//.*|" + ga, "g"),
+    greedy: !0
+  },
+  string: nn,
+  char: {
+    pattern: /b?'(?:\\(?:x[0-7][a-fA-F\d]|u\{(?:[a-fA-F\d]_*){1,6}\}|.)|[^\\\n	'])'/g,
+    greedy: !0
+  },
+  attribute: {
+    pattern: /#!?\[(?:[^[\]"]|"(?:\\[^]|[^\\"])*")*\]/g,
+    greedy: !0,
+    alias: "attr-name",
+    inside: {
+      string: nn
+    }
+  },
+  // Closure params should not be confused with bitwise OR |
+  "closure-params": {
+    pattern: /([=(,:]\s*|\bmove\s*)\|[^|]*\||\|[^|]*\|(?=\s*(?:\{|->))/g,
+    lookbehind: !0,
+    greedy: !0,
+    inside: an
+  },
+  "lifetime-annotation": {
+    pattern: /'\w+/,
+    alias: "symbol"
+  },
+  "fragment-specifier": {
+    pattern: /(\$\w+:)[a-z]+/,
+    lookbehind: !0,
+    alias: "punctuation"
+  },
+  variable: /\$\w+/,
+  "function-definition": {
+    pattern: /(\bfn\s+)\w+/,
+    lookbehind: !0,
+    alias: "function"
+  },
+  "type-definition": {
+    pattern: /(\b(?:enum|struct|trait|type|union)\s+)\w+/,
+    lookbehind: !0,
+    alias: "class-name"
+  },
+  "module-declaration": [
+    {
+      pattern: /(\b(?:crate|mod)\s+)[a-z][a-z_\d]*/,
+      lookbehind: !0,
+      alias: "namespace"
+    },
+    {
+      pattern: /(\b(?:crate|self|super)\s*)::\s*[a-z][a-z_\d]*\b(?:\s*::(?:\s*[a-z][a-z_\d]*\s*::)*)?/,
+      lookbehind: !0,
+      alias: "namespace",
+      inside: {
+        punctuation: /::/
+      }
+    }
+  ],
+  // https://github.com/rust-lang/reference/blob/master/src/keywords.md
+  // primitives and str
+  // https://doc.rust-lang.org/stable/rust-by-example/primitives.html
+  keyword: /\b(?:Self|abstract|as|async|await|become|box|break|const|continue|crate|do|dyn|else|enum|extern|final|fn|for|if|impl|in|let|loop|macro|match|mod|move|mut|override|priv|pub|ref|return|self|static|struct|super|trait|try|type|typeof|union|unsafe|unsized|use|virtual|where|while|yield|bool|char|f(?:32|64)|[ui](?:8|16|32|64|128|size)|str)\b/,
+  // functions can technically start with an upper-case letter, but this will introduce a lot of false positives
+  // and Rust's naming conventions recommend snake_case anyway.
+  // https://doc.rust-lang.org/1.0.0/style/style/naming/README.html
+  function: /\b[a-z_]\w*(?=\s*(?:::\s*<|\())/,
+  macro: {
+    pattern: /\b\w+!/,
+    alias: "property"
+  },
+  constant: /\b[A-Z_][A-Z_\d]+\b/,
+  "class-name": /\b[A-Z]\w*\b/,
+  namespace: {
+    pattern: /(?:\b[a-z][a-z_\d]*\s*::\s*)*\b[a-z][a-z_\d]*\s*::(?!\s*<)/,
+    inside: {
+      punctuation: /::/
+    }
+  },
+  // Hex, oct, bin, dec numbers with visual separators and type suffix
+  number: /\b(?:0x[a-fA-F\d](?:_?[a-fA-F\d])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*|(?:(?:\d(?:_?\d)*)?\.)?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)(?:_?(?:f32|f64|[iu](?:8|16|32|64|size)?))?\b/,
+  boolean: W,
+  punctuation: /->|\.\.=|\.{1,3}|::|[()[\]{},:;]/,
+  operator: /&&|\|\||=>|>>=?|<<=?|[%&|^!=<>/*+-]=?|[@?]/
+};
+var rn = E.swift = {
+  comment: {
+    // Nested comments are supported up to 2 levels
+    pattern: /\/\/.*|\/\*(?:[^/*]|\/(?!\*)|\*(?!\/)|\/\*(?:[^*]|\*(?!\/))*\*\/)*\*\//g,
+    greedy: !0
+  },
+  "string-literal": [
+    // https://docs.swift.org/swift-book/LanguageGuide/StringsAndCharacters.html
+    {
+      pattern: /(^|[^"#])(?:"(?:\\(?:\((?:[^()]|\([^)]*\))*\)|[^(])|[^\\\n"])*"|"""(?:\\(?:\((?:[^()]|\([^)]*\))*\)|[^(])|[^\\"]|"(?!""))*""")(?!["#])/g,
+      lookbehind: !0,
+      greedy: !0,
+      inside: {
+        interpolation: {
+          pattern: /(\\\()(?:[^()]|\([^()]*\))+(?=\))/,
+          lookbehind: !0
+        },
+        "interpolation-punctuation": {
+          pattern: /^\)|\\\($/,
+          alias: "punctuation"
+        },
+        punctuation: /\\(?=\n)/,
+        string: /[^]+/
+      }
+    },
+    {
+      pattern: /(^|[^"#])(#+)(?:"(?:\\(?:#+\((?:[^()]|\([^)]*\))*\)|[^#])|[^\\\n])*?"|"""(?:\\(?:#+\((?:[^()]|\([^)]*\))*\)|[^#])|[^\\])*?""")\2/g,
+      lookbehind: !0,
+      greedy: !0,
+      inside: {
+        interpolation: {
+          pattern: /(\\#+\()(?:[^()]|\([^()]*\))+(?=\))/,
+          lookbehind: !0
+        },
+        "interpolation-punctuation": {
+          pattern: /^\)|\\#+\($/,
+          alias: "punctuation"
+        },
+        string: /[^]+/
+      }
+    }
+  ],
+  directive: {
+    // directives with conditions
+    pattern: /#(?:(?:elseif|if)\b(?:[ 	]*(?:![ 	]*)?(?:\b\w+\b(?:[ 	]*\((?:[^()]|\([^)]*\))*\))?|\((?:[^()]|\([^)]*\))*\))(?:[ 	]*(?:&&|\|\|))?)+|(?:else|endif)\b)/,
+    alias: "property",
+    inside: {
+      "directive-name": /^#\w+/,
+      boolean: W,
+      number: /\b\d+(?:\.\d+)*\b/,
+      operator: /!|&&|\|\||[<>]=?/,
+      punctuation: /[(),]/
+    }
+  },
+  literal: {
+    pattern: /#(?:colorLiteral|column|dsohandle|file(?:ID|Literal|Path)?|function|imageLiteral|line)\b/,
+    alias: "constant"
+  },
+  "other-directive": {
+    pattern: /#\w+/,
+    alias: "property"
+  },
+  attribute: {
+    pattern: /@\w+/,
+    alias: "atrule"
+  },
+  "function-definition": {
+    pattern: /(\bfunc\s+)\w+/,
+    lookbehind: !0,
+    alias: "function"
+  },
+  label: {
+    // https://docs.swift.org/swift-book/LanguageGuide/ControlFlow.html#ID141
+    pattern: /\b(break|continue)\s+\w+|\b(?!\d)\w+(?=\s*:\s*(?:for|repeat|while)\b)/,
+    lookbehind: !0,
+    alias: "important"
+  },
+  keyword: /\b(?:Any|[Pp]rotocol|[Ss]elf|Type|actor|as|assignment|associatedtype|associativity|async|await|break|case|catch|class|continue|convenience|default|defer|deinit|didSet|do|dynamic|else|enum|extension|fallthrough|fileprivate|final|for|func|[gs]et|guard|higherThan|i[fns]|import|indirect|infix|init|inout|internal|isolated|lazy|lef?t|lowerThan|mutating|none|nonisolated|nonmutating|open|operator|optional|override|postfix|precedencegroup|prefix|private|public|repeat|required|rethrows|return|right|safe|some|static|struct|subscript|super|switch|throws?|try|typealias|unowned|unsafe|var|weak|where|while|willSet)\b/,
+  boolean: W,
+  nil: {
+    pattern: /\bnil\b/,
+    alias: "constant"
+  },
+  "short-argument": /\$\d+\b/,
+  omit: {
+    pattern: /\b_\b/,
+    alias: "keyword"
+  },
+  number: /\b(?:[\d_]+(?:\.[\de_]+)?|0x[a-f\d_]+(?:\.[a-f\dp_]+)?|0b[01_]+|0o[0-7_]+)\b/i,
+  // A class name must start with an upper-case letter and be either 1 letter long or contain a lower-case letter.
+  "class-name": /\b[A-Z](?:[A-Z_\d]*[a-z]\w*)?\b/,
+  function: /\b[a-z_]\w*(?=\s*\()/i,
+  constant: /\b(?:[A-Z_]{2,}|k[A-Z][A-Za-z_]+)\b/,
+  // Operators are generic in Swift. Developers can even create new operators (e.g. +++).
+  // https://docs.swift.org/swift-book/ReferenceManual/zzSummaryOfTheGrammar.html#ID481
+  // This regex only supports ASCII operators.
+  operator: /[~?%&|^!=<>/*+-]+|\.[.~?%&|^!=<>/*+-]+/,
+  punctuation: /[()[\]{}.,:;\\]/
+};
+rn["string-literal"].forEach((e) => {
+  e.inside.interpolation.inside = rn;
+});
+E.clike = {
+  comment: re(),
+  string: Nt(),
+  "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: W,
+  function: /\b\w+(?=\()/,
+  number: Rn,
+  operator: /[!=]==|[!=<>]=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/,
+  punctuation: Ee
+};
+var Xe = (e) => `\\b(?:${e})\\b`, Cn = "bool|char|decimal|double|dynamic|float|object|s?byte|string|u?int|u?long|u?short|var|void", Qe = "class|enum|interface|record|struct", Mn = "add|alias|and|ascending|async|await|by|descending|from(?!\\s*[^\\s\\w])|[gls]et|global|group|into|init(?=\\s*;)|join|nameof|not|notnull|on|or|orderby|partial|remove|select|unmanaged|value|when|where|with(?=\\s*{)", Ot = "abstract|as|[bc]ase|break|catch|checked|const|continue|default|delegate|do|else|event|explicit|extern|finally|fixed|for|foreach|goto|i[fns]|implicit|internal|lock|namespace|new|null|operator|out|override|params|private|protected|public|readonly|ref|return|sealed|sizeof|stackalloc|static|switch|this|throw|try|typeof|unchecked|unsafe|using|virtual|volatile|while|yield", Pn = Xe(Qe), He = RegExp(Xe(Cn + "|" + Qe + "|" + Mn + "|" + Ot)), ma = Xe(Qe + "|" + Mn + "|" + Ot), ha = Xe(Cn + "|" + Qe + "|" + Ot), Ve = _e("<(?:[^<>;=*/%&|^+-]|<self>)*>", 2), Fe = _e("\\((?:[^()]|<self>)*\\)", 2), J = "@?\\b(?!\\d)\\w+\\b", Ze = B("<0>(?:\\s*<1>)?", [J, Ve]), ce = B("(?!<0>)<1>(?:\\s*\\.\\s*<1>)*", [ma, Ze]), Lt = "\\[\\s*(?:,\\s*)*\\]", Ea = B("<0>(?:\\s*(?:\\?\\s*)?<1>)*(?:\\s*\\?)?", [ce, Lt]), _a = B("[^()[\\],;%&|^=<>/*+-]|<0>|<1>|<2>", [Ve, Fe, Lt]), ya = B("\\(<0>+(?:,<0>+)+\\)", [_a]), be = B("(?:<0>|<1>)(?:\\s*(?:\\?\\s*)?<2>)*(?:\\s*\\?)?", [ya, ce, Lt]), j = {
+  keyword: He,
+  punctuation: /[()[\].,:<>?]/
+}, Dn = `'(?:\\\\.|[^
+'\\\\]|\\\\[Uux][a-fA-F\\d]{1,8})'`, $n = `"(?:\\\\.|[^\\\\
+"])*"`, va = '@"(?:""|\\\\[\\s\\S]|[^\\\\"])*"(?!")', ne = E.dotnet = E.cs = E.csharp = ae("clike", {
+  string: [
+    {
+      pattern: O("(^|[^$\\\\])<0>", [va], "g"),
+      lookbehind: !0,
+      greedy: !0
+    },
+    {
+      pattern: O("(^|[^@$\\\\])<0>", [$n], "g"),
+      lookbehind: !0,
+      greedy: !0
+    }
+  ],
+  "class-name": [
+    {
+      // Using static
+      // using static System.Math;
+      pattern: O("(\\busing\\s+static\\s+)<0>(?=\\s*;)", [ce]),
+      lookbehind: !0,
+      inside: j
+    },
+    {
+      // Using alias (type)
+      // using Project = PC.MyCompany.Project;
+      pattern: O("(\\busing\\s+<0>\\s*=\\s*)<1>(?=\\s*;)", [J, be]),
+      lookbehind: !0,
+      inside: j
+    },
+    {
+      // Using alias (alias)
+      // using Project = PC.MyCompany.Project;
+      pattern: O("(\\busing\\s+)<0>(?=\\s*=)", [J]),
+      lookbehind: !0
+    },
+    {
+      // Type declarations
+      // class Foo<A, B>
+      // interface Foo<out A, B>
+      pattern: O("(\\b<0>\\s+)<1>", [Pn, Ze]),
+      lookbehind: !0,
+      inside: j
+    },
+    {
+      // Single catch exception declaration
+      // catch(Foo)
+      // (things like catch(Foo e) is covered by variable declaration)
+      pattern: O("(\\bcatch\\s*\\(\\s*)<0>", [ce]),
+      lookbehind: !0,
+      inside: j
+    },
+    {
+      // Name of the type parameter of generic constraints
+      // where Foo : class
+      pattern: O("(\\bwhere\\s+)<0>", [J]),
+      lookbehind: !0
+    },
+    {
+      // Casts and checks via as and is.
+      // as Foo<A>, is Bar<B>
+      // (things like if(a is Foo b) is covered by variable declaration)
+      pattern: O("(\\b(?:is(?:\\s+not)?|as)\\s+)<0>", [Ea]),
+      lookbehind: !0,
+      inside: j
+    },
+    {
+      // Variable, field and parameter declaration
+      // (Foo bar, Bar baz, Foo[,,] bay, Foo<Bar, FooBar<Bar>> bax)
+      pattern: O("\\b<0>(?=\\s+(?!<1>|with\\s*\\{)<2>(?:\\s*[=,:;{)\\]]|\\s+(?:in|when)\\b))", [be, ha, J]),
+      inside: j
+    }
+  ],
+  keyword: He,
+  // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#literals
+  number: /(?:\b0(?:x[a-f\d_]*[a-f\d]|b[01_]*[01])|(?:\B\.\d+(?:_+\d+)*|\b\d+(?:_+\d+)*(?:\.\d+(?:_+\d+)*)?)(?:e[+-]?\d+(?:_+\d+)*)?)(?:[dflmu]|lu|ul)?\b/i,
+  operator: /[=-]>|([&|+-])\1|~|\?\?=?|>>=?|<<=?|[%&|^!=<>/*+-]=?/,
+  punctuation: /\?\.?|::|[()[\]{}.,:;]/
+});
+D(ne, "number", {
+  range: {
+    pattern: /\.\./,
+    alias: "operator"
+  }
+});
+D(ne, "punctuation", {
+  "named-parameter": {
+    pattern: O("([(,]\\s*)<0>(?=\\s*:)", [J]),
+    lookbehind: !0,
+    alias: "punctuation"
+  }
+});
+D(ne, "class-name", {
+  namespace: {
+    // namespace Foo.Bar {}
+    // using Foo.Bar;
+    pattern: O("(\\b(?:namespace|using)\\s+)<0>(?:\\s*\\.\\s*<0>)*(?=\\s*[;{])", [J]),
+    lookbehind: !0,
+    inside: {
+      punctuation: /\./
+    }
+  },
+  "type-expression": {
+    // default(Foo), typeof(Foo<Bar>), sizeof(int)
+    pattern: O("(\\b(?:default|sizeof|typeof)\\s*\\(\\s*(?!\\s))(?:[^()\\s]|\\s(?!\\s)|<0>)+(?=\\s*\\))", [Fe]),
+    lookbehind: !0,
+    alias: "class-name",
+    inside: j
+  },
+  "return-type": {
+    // Foo<Bar> ForBar(); Foo IFoo.Bar() => 0
+    // int this[int index] => 0; T IReadOnlyList<T>.this[int index] => this[index];
+    // int Foo => 0; int Foo { get; set } = 0;
+    pattern: O("<0>(?=\\s+(?:<1>\\s*(?:=>|[({]|\\.\\s*this\\s*\\[)|this\\s*\\[))", [be, ce]),
+    alias: "class-name",
+    inside: j
+  },
+  "constructor-invocation": {
+    // new List<Foo<Bar[]>> { }
+    pattern: O("(\\bnew\\s+)<0>(?=\\s*[[({])", [be]),
+    lookbehind: !0,
+    alias: "class-name",
+    inside: j
+  },
+  /*'explicit-implementation': {
+  	// int IFoo<Foo>.Bar => 0; void IFoo<Foo<Foo>>.Foo<T>();
+  	pattern: replace(/\b<0>(?=\.<1>)/, className, methodOrPropertyDeclaration),
+  	inside: classNameInside,
+  	alias: 'class-name'
+  },*/
+  "generic-method": {
+    // foo<Bar>()
+    pattern: O("<0>\\s*<1>(?=\\s*\\()", [J, Ve]),
+    inside: {
+      function: O("^<0>", [J]),
+      generic: {
+        pattern: RegExp(Ve),
+        alias: "class-name",
+        inside: j
+      }
+    }
+  },
+  "type-list": {
+    // The list of types inherited or of generic constraints
+    // class Foo<F> : Bar, IList<FooBar>
+    // where F : Bar, IList<int>
+    pattern: O(
+      "\\b((?:<0>\\s+<1>|record\\s+<1>\\s*<5>|where\\s+<2>)\\s*:\\s*)(?:<3>|<4>|<1>\\s*<5>|<6>)(?:\\s*,\\s*(?:<3>|<4>|<6>))*(?=\\s*(?:where|[{;]|=>|$))",
+      [Pn, Ze, J, be, He.source, Fe, "\\bnew\\s*\\(\\s*\\)"]
+    ),
+    lookbehind: !0,
+    inside: {
+      "record-arguments": {
+        pattern: O("(^(?!new\\s*\\()<0>\\s*)<1>", [Ze, Fe], "g"),
+        lookbehind: !0,
+        greedy: !0,
+        inside: ne
+      },
+      keyword: He,
+      "class-name": {
+        pattern: RegExp(be, "g"),
+        greedy: !0,
+        inside: j
+      },
+      punctuation: /[(),]/
+    }
+  },
+  preprocessor: {
+    pattern: /(^[ 	]*)#.*/m,
+    lookbehind: !0,
+    alias: "property",
+    inside: {
+      // highlight preprocessor directives as keywords
+      directive: {
+        pattern: /(#)\b(?:define|elif|else|endif|endregion|error|if|line|nullable|pragma|region|undef|warning)\b/,
+        lookbehind: !0,
+        alias: "keyword"
+      }
+    }
+  }
+});
+var Fn = $n + "|" + Dn, Un = B(`/(?![*/])|//[^
+]*
+|/\\*(?:[^*]|\\*(?!/))*\\*/|<0>`, [Fn]), Bn = _e(B(`[^()"'/]|<0>|\\(<self>*\\)`, [Un]), 2), sn = "\\b(?:assembly|event|field|method|module|param|property|return|type)\\b", wa = B("<0>(?:\\s*\\(<1>*\\))?", [ce, Bn]), Ct = `:[^
+}]+`, Gn = _e(B(`[^()"'/]|<0>|\\(<self>*\\)`, [Un]), 2), on = B("\\{(?!\\{)(?:(?![}:])<0>)*<1>?\\}", [Gn, Ct]), zn = _e(B(`[^()"'/]|/(?!\\*)|/\\*(?:[^*]|\\*(?!/))*\\*/|<0>|\\(<self>*\\)`, [Fn]), 2), ln = B("\\{(?!\\{)(?:(?![}:])<0>)*<1>?\\}", [zn, Ct]), cn = (e, t) => ({
+  interpolation: {
+    pattern: O("((?:^|[^{])(?:\\{\\{)*)<0>", [e]),
+    lookbehind: !0,
+    inside: {
+      "format-string": {
+        pattern: O("(^\\{(?:(?![}:])<0>)*)<1>(?=\\}$)", [t, Ct]),
+        lookbehind: !0,
+        inside: {
+          punctuation: /^:/
+        }
+      },
+      punctuation: /^\{|\}$/,
+      expression: {
+        pattern: /[^]+/,
+        alias: "language-csharp",
+        inside: ne
+      }
+    }
+  },
+  string: /[^]+/
+});
+D(ne, "class-name", {
+  attribute: {
+    // Attributes
+    // [Foo], [Foo(1), Bar(2, Prop = "foo")], [return: Foo(1), Bar(2)], [assembly: Foo(Bar)]
+    pattern: O("((?:^|[^\\s\\w>)?])\\s*\\[\\s*)(?:<0>\\s*:\\s*)?<1>(?:\\s*,\\s*<1>)*(?=\\s*\\])", [sn, wa], "g"),
+    lookbehind: !0,
+    greedy: !0,
+    inside: {
+      target: {
+        pattern: O("^<0>(?=\\s*:)", [sn]),
+        alias: "keyword"
+      },
+      "attribute-arguments": {
+        pattern: O("\\(<0>*\\)", [Bn]),
+        inside: ne
+      },
+      "class-name": {
+        pattern: RegExp(ce),
+        inside: {
+          punctuation: /\./
+        }
+      },
+      punctuation: /[,:]/
+    }
+  }
+});
+D(ne, "string", {
+  "interpolation-string": [
+    {
+      pattern: O('(^|[^\\\\])(?:\\$@|@\\$)"(?:""|\\\\[\\s\\S]|\\{\\{|<0>|[^\\\\{"])*"', [on], "g"),
+      lookbehind: !0,
+      greedy: !0,
+      inside: cn(on, Gn)
+    },
+    {
+      pattern: O('(^|[^@\\\\])\\$"(?:\\\\.|\\{\\{|<0>|[^\\\\"{])*"', [ln], "g"),
+      lookbehind: !0,
+      greedy: !0,
+      inside: cn(ln, zn)
+    }
+  ],
+  char: {
+    pattern: RegExp(Dn, "g"),
+    greedy: !0
+  }
+});
+E.graphql = {
+  comment: /#.*/,
+  description: {
+    pattern: /(?:"""(?:[^"]|"(?!""))*"""|"(?:\\.|[^\\\n"])*")(?=\s*[a-z_])/gi,
+    greedy: !0,
+    alias: "string",
+    inside: {
+      "language-markdown": {
+        pattern: /("(?!")|""")[^]+(?=\1)/,
+        lookbehind: !0,
+        inside: "md"
+      }
+    }
+  },
+  string: {
+    pattern: /"""[^]*?"""|"(?:\\.|[^\\\n"])*"/g,
+    greedy: !0
+  },
+  number: /(?:\B-|\b)\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+  boolean: W,
+  variable: /\$[a-z_]\w*/i,
+  directive: {
+    pattern: /@[a-z_]\w*/i,
+    alias: "function"
+  },
+  "attr-name": {
+    pattern: /\b[a-z_]\w*(?=\s*(?:\((?:[^()"]|"(?:\\.|[^\\\n"])*")*\))?:)/gi,
+    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))(?!\d)\w+/,
+    lookbehind: !0,
+    alias: "function"
+  },
+  "definition-mutation": {
+    pattern: /(\bmutation\s+)(?!\d)\w+/,
+    lookbehind: !0,
+    alias: "function"
+  },
+  "definition-query": {
+    pattern: /(\bquery\s+)(?!\d)\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+/,
+  [le](e, t) {
+    for (var n = Ye(e, t), s = n.filter(({ type: a }) => a && a != "comment" && a != "scalar"), d = s.length, p = 0, b = (a) => {
+      for (var r = 0; r < a.length; r++)
+        if (p + r == d || s[p + r].type != a[r])
+          return !0;
+    }, m = (a, r) => {
+      for (var u = 1, o = p; o < d; o++) {
+        var i = s[o], f = i.content;
+        if (i.type == "punctuation") {
+          if (a == f)
+            u++;
+          else if (r == f && !--u)
+            return o;
+        }
+      }
+    }; p < d; ) {
+      var _ = s[p++];
+      if (_.type == "keyword" && _.content == "mutation") {
+        var y = [];
+        if (!b(["definition-mutation", "punctuation"]) && s[p + 1].content == "(") {
+          p += 2;
+          var l = m("(", ")");
+          if (!l) continue;
+          for (; p < l; p++) {
+            var c = s[p];
+            c.type == "variable" && (c.alias = "variable-input", y.push(c.content));
+          }
+          p = l + 1;
+        }
+        if (!b(["punctuation", "property-query"]) && s[p].content == "{" && (s[++p].alias = "property-mutation", y[0])) {
+          var w = m("{", "}");
+          if (w) for (var g = p; g < w; g++) {
+            var h = s[g];
+            h.type == "variable" && y.indexOf(h.content) >= 0 && (h.alias = "variable-input");
+          }
+        }
+      }
+    }
+    return n;
+  }
+};
+E.webmanifest = E.json = {
+  property: {
+    pattern: /"(?:\\.|[^\\\n"])*"(?=\s*:)/g,
+    greedy: !0
+  },
+  string: {
+    pattern: /"(?:\\.|[^\\\n"])*"/g,
+    greedy: !0
+  },
+  comment: re(),
+  number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+  operator: /:/,
+  punctuation: /[[\]{},]/,
+  boolean: W,
+  null: {
+    pattern: /\bnull\b/,
+    alias: "keyword"
+  }
+};
+E.makefile = {
+  comment: /#(?:\\[^]|[^\\\n])*/,
+  string: Nt(),
+  "builtin-target": {
+    pattern: /\.[A-Z][^:#=\s]+(?=\s*:(?!=))/,
+    alias: "builtin"
+  },
+  target: {
+    pattern: /^(?:[^:=\s]|[ 	]+(?![\s:]))+(?=\s*:(?!=))/m,
+    alias: "symbol",
+    inside: {
+      variable: /\$+(?:(?!\$)[^(){}:#=\s]+|(?=[({]))/
+    }
+  },
+  variable: /\$+(?:(?!\$)[^(){}:#=\s]+|\([@*%<^+?][DF]\)|(?=[({]))/,
+  // Directives
+  keyword: /-include\b|\b(?:define|else|endef|endif|export|ifn?def|ifn?eq|override|private|s?include|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)?)(?=[ 	])/,
+    lookbehind: !0
+  },
+  operator: /(?:::|[?:+!])?=|[|@]/,
+  punctuation: /[:;(){}]/
+};
+var Mt = E.scss = ae("css", {
+  comment: re(),
+  atrule: {
+    pattern: /@[\w-](?:\([^()]+\)|[^()\s]|\s+(?!\s))*?(?=\s+[{;])/,
+    inside: {
+      rule: /@[\w-]+/,
+      [Y]: "scss"
+    }
+  },
+  // url, compassified
+  url: /(?:[-a-z]+-)?url(?=\()/i,
+  // CSS selector regex is not appropriate for Sass
+  // since there can be lot more things (var, @ directive, nesting..)
+  // a selector must start at the end of a property or after a brace (end of other rules or nesting)
+  // it can contain some characters that aren't used for defining rules or end of selector, & (parent selector), or interpolated variable
+  // the end of a selector is found when there is no rules in it ( {} or {\s}) or if there is a property (because an interpolated var
+  // can "pass" as a selector- e.g: proper#{$erty})
+  // this one was hard to do, so please be careful if you edit this one :)
+  selector: {
+    // Initial look-ahead is used to prevent matching of blank selectors
+    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]+\}/
+    }
+  }
+});
+D(Mt, "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
+    }
+  ]
+});
+D(Mt, "important", {
+  // var and interpolated vars
+  variable: /\$[-\w]+|#\{\$[-\w]+\}/
+});
+D(Mt, "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: W,
+  null: {
+    pattern: /\bnull\b/,
+    alias: "keyword"
+  },
+  operator: {
+    pattern: /(\s)(?:[%/*+-]|[!=]=|[<>]=?|and|not|or)(?!\S)/,
+    lookbehind: !0
+  }
+});
+var Hn = {
+  pattern: /(\b(?:class|extends|implements|instanceof|interface|new|type)\s+)(?!keyof\b)(?!\d)(?:(?!\s)[$\w\xa0-\uffff])+(?:\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/g,
+  lookbehind: !0,
+  greedy: !0
+}, ye = E.ts = E.typescript = ae("js", {
+  "class-name": Hn
+});
+D(ye, "operator", {
+  builtin: /\b(?:Array|Function|Promise|any|boolean|never|number|string|symbol|unknown)\b/
+});
+ye.keyword.push(
+  /\b(?:abstract|declare|is|keyof|readonly|require)\b|\b(?:asserts|infer|interface|module|namespace|type)\b(?!\s*[^\s{_$a-zA-Z\xa0-\uffff])|\btype(?=\s*\*)/
+);
+delete ye.parameter;
+delete ye["literal-property"];
+var Pt = Hn.inside = Object.assign({}, ye);
+delete Pt["class-name"];
+delete Pt["maybe-class-name"];
+D(ye, "function", {
+  decorator: {
+    pattern: /@[$\w\xa0-\uffff]+/,
+    inside: {
+      at: {
+        pattern: /^@/,
+        alias: "operator"
+      },
+      function: /.+/
+    }
+  },
+  "generic-function": {
+    // e.g. foo<T extends "bar" | "baz">( ...
+    pattern: /#?(?!\d)(?:(?!\s)[$\w\xa0-\uffff])+\s*<(?:[^<>=]|=[^<]|=?<(?:[^<>]|<[^<>]*>)*>)*>(?=\s*\()/g,
+    greedy: !0,
+    inside: {
+      generic: {
+        pattern: /<[^]+/,
+        // everything after the first <
+        alias: "class-name",
+        inside: Pt
+      },
+      function: /\S+/
+    }
+  }
+});
+Ln(E.ts, "tsx");
+var yt = E.tsx.tag, Vn = "(?:^|(";
+try {
+  RegExp("(?<=)"), Vn += "?<=";
+} catch {
+  yt.lookbehind = !0;
+}
+yt.pattern = RegExp(Vn + `[^\\w$])|(?=</))${yt.pattern.source}`, "g");
+var vt = /[*&][^\s[\]{},]+/, wt = /!(?:<[\w%#;/?:@&=$,.!~*'()[\]+-]+>|(?:[a-zA-Z\d-]*!)?[\w%#;/?:@&=$.~*'()+-]+)?/, xt = `(?:${wt.source}(?:[ 	]+${vt.source})?|${vt.source}(?:[ 	]+${wt.source})?)`, xa = B(
+  "(?:[^\\s\0-\\x08\\x0e-\\x1f!\"#%&'*,:>?@[\\]{}`|\\x7f-\\x84\\x86-\\x9f\\ud800-\\udfff\\ufffe\\uffff-]|[?:-]<0>)(?:[ 	]*(?:(?![#:])<0>|:<0>))*",
+  ["[^\\s\0-\\x08\\x0e-\\x1f,[\\]{}\\x7f-\\x84\\x86-\\x9f\\ud800-\\udfff\\ufffe\\uffff]"]
+), dn = `"(?:\\\\.|[^\\\\
+"])*"|'(?:\\\\.|[^\\\\
+'])*'`, Ae = (e, t) => O(
+  `([:,[{-]\\s*(?:\\s<0>[ 	]+)?)<1>(?=[ 	]*(?:$|,|\\]|\\}|(?:
+\\s*)?#))`,
+  [xt, e],
+  t
+);
+E.yml = E.yaml = {
+  scalar: {
+    pattern: O(`([:-]\\s*(?:\\s<0>[ 	]+)?[|>])[ 	]*(?:(
+[ 	]+)\\S.*(?:\\2.+)*)`, [xt]),
+    lookbehind: !0,
+    alias: "string"
+  },
+  comment: /#.*/,
+  key: {
+    pattern: O(
+      `((?:^|[:,[{
+?-])[ 	]*(?:<0>[ 	]+)?)<1>(?=\\s*:\\s)`,
+      [xt, "(?:" + xa + "|" + dn + ")"],
+      "g"
+    ),
+    lookbehind: !0,
+    greedy: !0,
+    alias: "atrule"
+  },
+  directive: {
+    pattern: /(^[ 	]*)%.+/m,
+    lookbehind: !0,
+    alias: "important"
+  },
+  datetime: {
+    pattern: Ae("\\d{4}-\\d\\d?-\\d\\d?(?:[tT]|[ 	]+)\\d\\d?:\\d\\d:\\d\\d(?:\\.\\d*)?(?:[ 	]*(?:Z|[+-]\\d\\d?(?::\\d\\d)?))?|\\d{4}-\\d\\d-\\d\\d|\\d\\d?:\\d\\d(?::\\d\\d(?:\\.\\d*)?)?", "m"),
+    lookbehind: !0,
+    alias: "number"
+  },
+  boolean: {
+    pattern: Ae("false|true", "im"),
+    lookbehind: !0,
+    alias: "important"
+  },
+  null: {
+    pattern: Ae("null|~", "im"),
+    lookbehind: !0,
+    alias: "important"
+  },
+  string: {
+    pattern: Ae(dn, "mg"),
+    lookbehind: !0,
+    greedy: !0
+  },
+  number: {
+    pattern: Ae("[+-]?(?:0x[a-f\\d]+|0o[0-7]+|(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?|\\.inf|\\.nan)", "im"),
+    lookbehind: !0
+  },
+  tag: wt,
+  important: vt,
+  punctuation: /---|[:[\]{},|>?-]|\.{3}/
+};
+var un = {
+  pattern: /\\[\\()[\]{}^$+*?|.]/,
+  alias: "escape"
+}, Ue = /\\(?:x[a-fA-F\d]{2}|u[a-fA-F\d]{4}|u\{[a-fA-F\d]+\}|0[0-7]{0,2}|[123][0-7]{2}|c[a-zA-Z]|.)/, Aa = {
+  pattern: /\.|\\[wsd]|\\p\{[^{}]+\}/i,
+  alias: "class-name"
+}, Ia = {
+  pattern: /\\[wsd]|\\p\{[^{}]+\}/i,
+  alias: "class-name"
+}, pn = "(?:[^\\\\-]|" + Ue.source + ")", Ra = RegExp(pn + "-" + pn), fn = {
+  pattern: /(<|')[^<>']+(?=[>']$)/,
+  lookbehind: !0,
+  alias: "variable"
+};
+E.regex = {
+  "char-class": {
+    pattern: /((?:^|[^\\])(?:\\\\)*)\[(?:\\[^]|[^\\\]])*\]/,
+    lookbehind: !0,
+    inside: {
+      "char-class-punctuation": {
+        pattern: /^.|.$/g,
+        greedy: !0,
+        alias: "punctuation"
+      },
+      "char-class-negation": {
+        pattern: /^\^/,
+        alias: "operator"
+      },
+      range: {
+        pattern: Ra,
+        inside: {
+          escape: Ue,
+          "range-punctuation": {
+            pattern: /-/,
+            alias: "operator"
+          }
+        }
+      },
+      "special-escape": un,
+      "char-set": Ia,
+      escape: Ue
+    }
+  },
+  "special-escape": un,
+  "char-set": Aa,
+  backreference: [
+    {
+      // a backreference which is not an octal escape
+      pattern: /\\(?![123][0-7]{2})[1-9]/,
+      alias: "keyword"
+    },
+    {
+      pattern: /\\k<[^<>']+>/,
+      alias: "keyword",
+      inside: {
+        "group-name": fn
+      }
+    }
+  ],
+  anchor: {
+    pattern: /[$^]|\\[ABbGZz]/,
+    alias: "function"
+  },
+  escape: Ue,
+  group: [
+    {
+      // https://docs.oracle.com/javase/10/docs/api/java/util/regex/Pattern.html
+      // https://docs.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-language-quick-reference?view=netframework-4.7.2#grouping-constructs
+      // (), (?<name>), (?'name'), (?>), (?:), (?=), (?!), (?<=), (?<!), (?is-m), (?i-m:)
+      pattern: /(\()\?(?:<[^<>']+>|'[^<>']+'|[>:]|<?[!=]|[idmnsuxU]+(?:-[idmnsuxU]+)?:?)/,
+      lookbehind: !0,
+      inside: {
+        "group-name": fn
+      }
+    },
+    {
+      pattern: /[()]/,
+      alias: "punctuation"
+    }
+  ],
+  quantifier: {
+    pattern: /(?:[+*?]|\{\d+(?:,\d*)?\})[?+]?/,
+    alias: "number"
+  },
+  alternation: {
+    pattern: /\|/,
+    alias: "keyword"
+  }
+};
+const Sa = (e, t, ...n) => {
+  var X;
+  let s, d, p = [], b, m = "", _, y = !1, l = !1, c = !0, w = [], g, h = 0;
+  const a = Na(), r = a.firstChild, u = r.children, o = u[0], i = o.firstChild, f = { language: "text", value: m }, R = new Set(n), A = {}, v = (x) => {
+    if (Object.assign(f, x), m = x.value ?? m, s = f.language, !E[s]) throw Error(`Language '${s}' has no grammar.`);
+    g = !!f.readOnly, a.style.tabSize = f.tabSize || 2, i.inputMode = g ? "none" : "", i.setAttribute("aria-readonly", g), N(), k(), (d != (d = E[s]) || m != i.value) && (Z(), i.value = m, i.selectionEnd = 0, S());
+  }, S = () => {
+    w = St(m = i.value, d), H("tokenize", w, s, m);
+    let x = vn(w).split(`
+`), I = 0, C = h, K = h = x.length;
+    for (; x[I] == p[I] && I < K; ) ++I;
+    for (; K && x[--K] == p[--C]; ) ;
+    if (I == K && I == C) u[I + 1].innerHTML = x[I] + `
+`;
+    else {
+      let Q = C < I ? C : I - 1, q = Q, ve = "";
+      for (; q < K; ) ve += `<div class=pce-line aria-hidden=true>${x[++q]}
+</div>`;
+      for (q = K < I ? K : I - 1; q < C; q++) u[I + 1].remove();
+      for (ve && u[Q + 1].insertAdjacentHTML("afterend", ve), q = Q + 1; q < h; ) u[++q].setAttribute("data-line", q);
+      a.style.setProperty(
+        "--number-width",
+        Math.ceil(Math.log10(h + 1)) + ".001ch"
+      );
+    }
+    H("update", m), U(!0), c && setTimeout(setTimeout, 0, () => c = !0), p = x, c = !1;
+  }, k = (x) => {
+    (x || R).forEach((I) => {
+      typeof I == "object" ? (I.update($, f), x && R.add(I)) : (I($, f), x || R.delete(I));
+    });
+  }, N = ([x, I] = L()) => {
+    a.className = `prism-code-editor language-${s}${f.lineNumbers == !1 ? "" : " show-line-numbers"} pce-${f.wordWrap ? "" : "no"}wrap${f.rtl ? " pce-rtl" : ""} pce-${x < I ? "has" : "no"}-selection${l ? " pce-focus" : ""}${g ? " pce-readonly" : ""}`;
+  }, L = () => [
+    i.selectionStart,
+    i.selectionEnd,
+    i.selectionDirection
+  ], P = {
+    Escape() {
+      i.blur();
+    }
+  }, M = {}, Z = () => Be && !l && z(
+    $,
+    "focus",
+    (x) => {
+      let I = x.relatedTarget;
+      I ? I.focus() : i.blur();
+    },
+    { once: !0 }
+  ), H = (x, ...I) => {
+    var C, K;
+    (C = A[x]) == null || C.forEach((Q) => Q.apply($, I)), (K = f["on" + x[0].toUpperCase() + x.slice(1)]) == null || K.apply($, I);
+  }, U = (x) => {
+    if (x || c) {
+      const I = L(), C = u[_ = Kn(m, 0, I[I[2] < "f" ? 0 : 1])];
+      C != b && (b == null || b.classList.remove("active-line"), C.classList.add("active-line"), b = C), N(I), H("selectionChange", I, m);
+    }
+  }, $ = {
+    scrollContainer: a,
+    wrapper: r,
+    overlays: o,
+    textarea: i,
+    get activeLine() {
+      return b;
+    },
+    get activeLineNumber() {
+      return _;
+    },
+    get value() {
+      return m;
+    },
+    options: f,
+    get focused() {
+      return l;
+    },
+    get removed() {
+      return y;
+    },
+    get tokens() {
+      return w;
+    },
+    inputCommandMap: M,
+    keyCommandMap: P,
+    extensions: {},
+    setOptions: v,
+    update: S,
+    getSelection: L,
+    setSelection(x, I = x, C) {
+      Z(), i.setSelectionRange(x, I, C), U(!0);
+    },
+    addExtensions(...x) {
+      k(x);
+    },
+    addListener(x, I) {
+      (A[x] || (A[x] = /* @__PURE__ */ new Set())).add(I);
+    },
+    removeListener(x, I) {
+      var C;
+      (C = A[x]) == null || C.delete(I);
+    },
+    remove() {
+      a.remove(), y = !0;
+    }
+  };
+  return z($, "keydown", (x) => {
+    var I;
+    (I = P[x.key]) != null && I.call(P, x, L(), m) && G(x);
+  }), z($, "beforeinput", (x) => {
+    var I;
+    (g || x.inputType == "insertText" && ((I = M[x.data]) != null && I.call(M, x, L(), m))) && G(x);
+  }), z($, "input", S), z($, "blur", () => {
+    Te = null, l = !1, N();
+  }), z($, "focus", () => {
+    Te = U, l = !0, N();
+  }), z($, "selectionchange", (x) => {
+    U(), G(x);
+  }), (X = Ta(e)) == null || X.append(a), t && v(t), $;
+}, bn = /* @__PURE__ */ document.createElement("div"), Je = (e) => {
+  bn.innerHTML = e;
+  const t = bn.firstChild;
+  return () => t.cloneNode(!0);
+}, z = (e, t, n, s) => e.textarea.addEventListener(t, n, s), Ta = (e) => typeof e == "string" ? document.querySelector(e) : e, Zn = navigator.userAgent, Ke = /Mac|iPhone|iPod|iPad/i.test(navigator.platform), We = /Chrome\//.test(Zn), Be = !We && /AppleWebKit\//.test(Zn), Kn = (e, t = 0, n = 1 / 0) => {
+  let s = 1;
+  for (; (t = e.indexOf(`
+`, t) + 1) && t <= n; s++) ;
+  return s;
+}, ot = {}, Na = /* @__PURE__ */ Je(
+  "<div><div class=pce-wrapper><div class=pce-overlays><textarea spellcheck=false autocapitalize=off autocomplete=off>"
+), G = (e) => {
+  e.preventDefault(), e.stopImmediatePropagation();
+};
+let Te;
+document.addEventListener("selectionchange", () => Te == null ? void 0 : Te());
+const ka = (e, t, n = 0) => {
+  const s = e.scrollContainer.style, d = document.documentElement.style;
+  s.scrollPaddingBlock = d.scrollPaddingBlock = `${n}px ${We && !t.textContent ? t.offsetHeight : 0}px`, t.scrollIntoView({ block: "nearest" }), s.scrollPaddingBlock = d.scrollPaddingBlock = "";
+}, qe = (e, t) => t ? e.lastIndexOf(`
+`, t - 1) + 1 : 0, et = (e, t) => (t = e.indexOf(`
+`, t)) + 1 ? t : e.length, Oa = (e, t, n) => (e.addListener(t, n), () => e.removeListener(t, n)), La = (e, t) => parseFloat(getComputedStyle(e)[t]);
+let ge;
+const Ie = (e) => e.replace(/[$+?|.^*()[\]{}\\]/g, "\\$&"), At = (e, t) => e.slice(qe(e, t), t), ee = (e, t, n = t) => [
+  e.slice(t = qe(e, t), n = et(e, n)).split(`
+`),
+  t,
+  n
+], je = (e, t, n = 0, s = n, d = e.getSelection()[0]) => {
+  var l;
+  const p = e.value, b = e.wrapper.children[Kn(p, 0, d)], m = document.createTreeWalker(b, 5);
+  let _ = m.lastChild(), y = et(p, d) + 1 - d - _.length;
+  for (; -y <= s && (_ = m.previousNode()); )
+    if (!_.lastChild && (y -= _.length || 0, y <= n)) {
+      for (; _ != b; _ = _.parentNode)
+        if ((l = _.matches) != null && l.call(_, t)) return _;
+    }
+}, lt = (e, t) => {
+  var n;
+  return ((n = je(e, '[class*="language-"]', 0, 0, t)) == null ? void 0 : n.className.match(
+    /language-(\S*)/
+  )[1]) || e.options.language;
+}, V = (e, t, n, s, d, p) => {
+  if (e.options.readOnly) return;
+  ge = e.getSelection(), s ?? (s = n);
+  let b = e.textarea, m = e.value, _ = We && !m[s ?? ge[1]] && /\n$/.test(t) && /^$|\n$/.test(m), y;
+  e.focused || b.focus(), n != null && b.setSelectionRange(n, s), d != null && (y = Oa(e, "update", () => {
+    b.setSelectionRange(
+      d,
+      p ?? d,
+      ge[2]
+    ), y();
+  })), Be || b.dispatchEvent(new InputEvent("beforeinput", { data: t })), We || Be ? (_ && (b.selectionEnd--, t = t.slice(0, -1)), Be && (t += `
+`), document.execCommand(
+    t ? "insertHTML" : "delete",
+    !1,
+    t.replace(/&/g, "&amp;").replace(/</g, "&lt;")
+  ), _ && b.selectionStart++) : document.execCommand(t ? "insertText" : "delete", !1, t), ge = 0;
+}, Se = (e) => e.altKey + e.ctrlKey * 2 + e.metaKey * 4 + e.shiftKey * 8;
+let It = !1;
+const gn = navigator.clipboard, oe = Ke ? 4 : 2, Ca = (e) => It = e, se = (e) => e.search(/\S|$/), Ma = (e = ['""', "''", "``", "()", "[]", "{}"], t = /([^$\w'"`]["'`]|.[[({])[.,:;\])}>\s]|.[[({]`/s) => (n, s) => {
+  let d;
+  const { keyCommandMap: p, inputCommandMap: b, getSelection: m, scrollContainer: _ } = n, y = ({ insertSpaces: a = !0, tabSize: r } = s) => [a ? " " : "	", a ? r || 2 : 1], l = () => {
+    var a;
+    return !s.readOnly && !((a = n.extensions.cursor) != null && a.scrollIntoView());
+  }, c = ([a, r], [u, o], i, f) => (a < r || !f && t.test((i[r - 1] || " ") + u + (i[r] || " "))) && !V(n, u + i.slice(a, r) + o, null, null, a + 1, r + 1), w = ([a, r], u, o) => a == r && o[r] == u && !n.setSelection(a + 1), g = (a, r, u, o, i, f) => {
+    let R = r.join(`
+`);
+    if (R != a.join(`
+`)) {
+      const A = a.length - 1, v = r[A], S = a[A], k = S.length - v.length, N = r[0].length - a[0].length, L = u + se((N < 0 ? r : a)[0]), P = o - S.length + se(k > 0 ? v : S), M = u - o + R.length + k, Z = L > i ? i : Math.max(L, i + N), H = f + u - o + R.length;
+      V(
+        n,
+        R,
+        u,
+        o,
+        Z,
+        f < P ? H + k : Math.max(P + M, H)
+      );
+    }
+  }, h = (a, r, u, o, i, f, R, A) => {
+    g(
+      r,
+      r.map(
+        a ? (v) => v.slice(se(v) ? A - se(v) % A : 0) : (v) => v && R.repeat(A - se(v) % A) + v
+      ),
+      u,
+      o,
+      i,
+      f
+    );
+  };
+  b["<"] = (a, r, u) => c(r, "<>", u, !0), e.forEach(([a, r]) => {
+    const u = a == r;
+    b[a] = (o, i, f) => (u && w(i, r, f) || c(i, a + r, f)) && l(), u || (b[r] = (o, i, f) => w(i, r, f) && l());
+  }), b[">"] = (a, r, u) => {
+    var i, f;
+    const o = (f = (i = ot[lt(n)]) == null ? void 0 : i.autoCloseTags) == null ? void 0 : f.call(i, r, u, n);
+    o && (V(n, ">" + o, null, null, r[0] + 1), G(a));
+  }, p.Tab = (a, [r, u], o) => {
+    if (It || s.readOnly || Se(a) & 6) return;
+    const [i, f] = y(s), R = a.shiftKey, [A, v, S] = ee(o, r, u);
+    return r < u || R ? h(R, A, v, S, r, u, i, f) : V(n, i.repeat(f - (r - v) % f)), l();
+  }, p.Enter = (a, r, u) => {
+    var i, f, R;
+    const o = Se(a) & 7;
+    if (!o || o == oe) {
+      o && (r[0] = r[1] = ee(u, r[1])[2]);
+      const [A, v] = y(), [S, k] = r, N = (i = ot[lt(n)]) == null ? void 0 : i.autoIndent, L = Math.floor(se(At(u, S)) / v) * v, P = (f = N == null ? void 0 : N[0]) != null && f.call(N, r, u, n) ? v : 0, M = (R = N == null ? void 0 : N[1]) == null ? void 0 : R.call(N, r, u, n), Z = `
+` + A.repeat(L + P) + (M ? `
+` + A.repeat(L) : "");
+      if (Z[1] || u[k])
+        return V(n, Z, S, k, S + L + P + 1), l();
+    }
+  }, p.Backspace = (a, [r, u], o) => {
+    if (r == u) {
+      const i = At(o, r), f = s.tabSize || 2, R = e.includes(o.slice(r - 1, r + 1)), A = /[^ ]/.test(i) ? 0 : (i.length - 1) % f + 1;
+      if (R || A > 1)
+        return V(n, "", r - (R ? 1 : A), r + R), l();
+    }
+  };
+  for (let a = 0; a < 2; a++)
+    p[a ? "ArrowDown" : "ArrowUp"] = (r, [u, o], i) => {
+      const f = Se(r);
+      if (f == 1) {
+        const R = a ? u : qe(i, u) - 1, A = a ? i.indexOf(`
+`, o) + 1 : o;
+        if (R > -1 && A > 0) {
+          const [v, S, k] = ee(i, R, A), N = v[a ? "pop" : "shift"](), L = (N.length + 1) * (a ? 1 : -1);
+          v[a ? "unshift" : "push"](N), V(n, v.join(`
+`), S, k, u + L, o + L);
+        }
+        return l();
+      } else if (f == 9) {
+        const [R, A, v] = ee(i, u, o), S = R.join(`
+`), k = a ? S.length + 1 : 0;
+        return V(n, S + `
+` + S, A, v, u + k, o + k), l();
+      } else if (f == 2 && !Ke)
+        return _.scrollBy(0, La(_, "lineHeight") * (a ? 1 : -1)), !0;
+    };
+  z(n, "keydown", (a) => {
+    var R;
+    const r = Se(a), u = a.keyCode, [o, i, f] = m();
+    if (r == oe && (u == 221 || u == 219))
+      h(u == 219, ...ee(n.value, o, i), o, i, ...y()), l(), G(a);
+    else if (r == (Ke ? 10 : 2) && u == 77)
+      Ca(!It), G(a);
+    else if (u == 191 && r == oe || u == 65 && r == 9) {
+      const A = n.value, v = r == 9, S = v ? o : qe(A, o), k = ot[lt(n, S)] || {}, { line: N, block: L } = ((R = k.getComments) == null ? void 0 : R.call(k, n, S, A)) || k.comments || {}, [P, M, Z] = ee(A, o, i), H = P.length - 1;
+      if (v) {
+        if (L) {
+          const [U, $] = L, X = A.slice(o, i), x = A.slice(0, o).search(Ie(U) + " ?$"), I = RegExp("^ ?" + Ie($)).test(A.slice(i));
+          x + 1 && I ? V(
+            n,
+            X,
+            x,
+            i + +(A[i] == " ") + $.length,
+            x,
+            x + i - o
+          ) : V(
+            n,
+            `${U} ${X} ${$}`,
+            o,
+            i,
+            o + U.length + 1,
+            i + U.length + 1
+          ), l(), G(a);
+        }
+      } else if (N) {
+        const U = Ie(N), $ = RegExp(`^\\s*(${U} ?|$)`), X = RegExp(U + " ?"), x = !/\S/.test(A.slice(M, Z)), I = P.map(
+          P.every((C) => $.test(C)) && !x ? (C) => C.replace(X, "") : (C) => x || /\S/.test(C) ? C.replace(/^\s*/, `$&${N} `) : C
+        );
+        g(P, I, M, Z, o, i), l(), G(a);
+      } else if (L) {
+        const [U, $] = L, X = se(P[0]), x = P[0].startsWith(U, X) && P[H].endsWith($), I = P.slice();
+        I[0] = P[0].replace(
+          x ? RegExp(Ie(U) + " ?") : /(?=\S)|$/,
+          x ? "" : U + " "
+        );
+        let C = I[0].length - P[0].length;
+        I[H] = x ? I[H].replace(RegExp(`( ?${Ie($)})?$`), "") : I[H] + " " + $;
+        let K = I.join(`
+`), Q = X + M, q = Q > o ? o : Math.max(o + C, Q), ve = Q > i - (o != i) ? i : Math.min(Math.max(Q, i + C), M + K.length);
+        V(n, K, M, Z, q, Math.max(q, ve)), l(), G(a);
+      }
+    } else if (r == 8 + oe && u == 75) {
+      const A = n.value, [v, S, k] = ee(A, o, i), N = f > "f" ? i - k + v.pop().length : o - S, L = et(A, k + 1) - k - 1;
+      V(
+        n,
+        "",
+        S - !!S,
+        k + !S,
+        S + Math.min(N, L)
+      ), l(), G(a);
+    }
+  }), ["copy", "cut", "paste"].forEach(
+    (a) => z(n, a, (r) => {
+      const [u, o] = m();
+      if (u == o && gn) {
+        const [[i], f, R] = ee(n.value, u, o);
+        a == "paste" ? r.clipboardData.getData("text/plain") == d && (V(n, d + `
+`, f, f, u + d.length + 1), l(), G(r)) : (gn.writeText(d = i), a == "cut" && (V(n, "", f, R + 1), l()), G(r));
+      }
+    })
+  );
+}, Pa = (e = 999) => {
+  let t = 0, n, s, d = !1, p, b, m, _, y, l;
+  const c = [], w = (a) => {
+    a >= e && (a--, c.shift()), c.splice(t = a, e, [n.value, l(), l()]);
+  }, g = (a) => {
+    var r;
+    c[a] && (y.value = c[a][0], y.setSelectionRange(...c[a][a < t ? 2 : 1]), n.update(), (r = n.extensions.cursor) == null || r.scrollIntoView(), t = a, s = !1);
+  }, h = (a, r) => {
+    a.extensions.history = h, n = a, l = a.getSelection, y || w(0), y = a.textarea, a.addListener("selectionChange", () => {
+      s = d, d = !1;
+    }), z(a, "beforeinput", (u) => {
+      let o = u.data, i = u.inputType, f = u.timeStamp;
+      /history/.test(i) ? (g(t + (i[7] == "U" ? -1 : 1)), G(u)) : (_ = s && (p == i || f - m < 99 && i.slice(-4) == "Drop") && !ge && (o != " " || b == o)) || (c[t][2] = ge || l()), d = !0, b = o, m = f, p = i;
+    }), z(a, "input", () => w(t + !_)), z(a, "keydown", (u) => {
+      if (!r.readOnly) {
+        const o = Se(u), i = u.keyCode, f = o == oe && i == 90, R = o == oe + 8 && i == 90 || !Ke && o == oe && i == 89;
+        f ? (g(t - 1), G(u)) : R && (g(t + 1), G(u));
+      }
+    });
+  };
+  return h.clear = () => {
+    w(0), s = !1;
+  }, h.has = (a) => t + a in c, h.go = (a) => g(t + a), h;
+}, Da = Je(
+  "<div style=position:absolute;top:0;opacity:0;padding:inherit> <span><span></span> "
+), $a = () => {
+  let e, t = " ", n = " ";
+  const s = Da(), [d, p] = s.childNodes, [b, m] = p.childNodes, _ = (c) => {
+    let { value: w, activeLine: g } = e, h = c[c[2] < "f" ? 0 : 1], a = At(w, h), r = w.slice(h, et(w, h));
+    !a && !r && (r = " "), t != a && (d.data = t = a), n != r && (m.data = n = r), s.parentNode != g && g.prepend(s);
+  }, y = () => ka(e, b), l = (c) => {
+    c.addListener("selectionChange", _), e = c, c.extensions.cursor = l, z(c, "input", (w) => {
+      /history/.test(w.inputType) && y();
+    }), c.activeLine && _(c.getSelection());
+  };
+  return l.getPosition = () => {
+    const c = b.getBoundingClientRect(), w = e.overlays.getBoundingClientRect();
+    return {
+      top: c.y - w.y,
+      bottom: w.bottom - c.bottom,
+      left: c.x - w.x,
+      right: w.right - c.x,
+      height: c.height
+    };
+  }, l.scrollIntoView = y, l.element = b, l;
+}, Fa = Je(
+  "<div class=guide-indents style=left:var(--padding-left);bottom:auto;right:auto> "
+), Ua = Je(
+  "<div style=width:1px;position:absolute;background:var(--bg-guide-indent)>"
+), Ba = () => {
+  let e, t = 0, n, s = -1, d;
+  const p = [], b = [], m = Fa(), _ = [], y = (g) => {
+    n = [];
+    const h = c(g.split(`
+`)), a = h.length;
+    for (let r = 0, u = [], o = h[0]; o; r++) {
+      const i = (p[r] || (p[r] = Ua())).style, [f, R, A] = o, v = b[r];
+      o = h[r + 1], f != (v == null ? void 0 : v[0]) && (i.top = f + "00%"), R != (v == null ? void 0 : v[1]) && (i.height = R + "00%"), A != (v == null ? void 0 : v[2]) && (i.left = A * 100 + "%");
+      const S = u[0] != f && (o == null ? void 0 : o[0]) != f, k = u[0] + u[1] != f + R && (o == null ? void 0 : o[0]) + (o == null ? void 0 : o[1]) != f + R;
+      for (let N = -S, L = R + k; N < L; N++)
+        n[N + f] = r;
+      u = b[r] = h[r];
+    }
+    for (let r = t; r > a; ) p[--r].remove();
+    m.append(...p.slice(t, t = a));
+  }, l = () => {
+    const g = n[d.activeLineNumber - 1] ?? -1;
+    g != s && (s > -1 && (p[s].className = ""), g > -1 && (p[g].className = "active")), s = g;
+  }, c = (g) => {
+    const h = g.length, a = [], r = [];
+    for (let u = 0, o = -1, i = 0, f = 0; ; i++) {
+      const R = i == h, A = R ? 0 : _[i] = w(g[i]);
+      if (A < 0)
+        o < 0 && (o = i);
+      else {
+        for (let v = A; v < u; v++)
+          a[v][1] = (o < 0 || v == A && !R ? i : o) - a[v][0];
+        for (let v = u; v < A; )
+          r[f++] = a[v] = [
+            o < 0 || v > u ? i : o,
+            0,
+            v++ * e
+          ];
+        o = -1, u = A;
+      }
+      if (R) break;
+    }
+    return _.length = h, r;
+  }, w = (g) => {
+    let h = g.search(/\S/), a = 0;
+    if (h < 0) return h;
+    for (let r = 0; r < h; )
+      a += g[r++] == "	" ? e - a % e : 1;
+    return Math.ceil(a / e);
+  };
+  return {
+    lines: m.children,
+    indentLevels: _,
+    update(g, h) {
+      d || (d = g, g.extensions.indentGuides = this, g.overlays.append(m), g.addListener("update", y), g.addListener("selectionChange", l)), m.style.display = h.wordWrap ? "none" : "", e != (e = h.tabSize || 2) && (y(g.value), l());
+    }
+  };
+}, Ga = () => (e) => {
+  let t, n, s, d = -1, p = [], b = () => {
+    n || (n = e.extensions.matchBrackets);
+    let [y, l] = e.getSelection(), c = y == l && e.focused && n && m(l) || -1;
+    if (c != d) {
+      if (_(), c + 1) {
+        let w = t[s[c]], g = t[c];
+        p = [w, g].map(
+          (h) => je(e, ".punctuation", 0, -1, h[1])
+        ), p[0] != p[1] && w[1] + w[3].length == g[1] && (p[0].textContent += p[1].textContent, p[1].textContent = "", p[1] = p[0]), _(!0);
+      } else p = [];
+      d = c;
+    }
+  }, m = (y) => {
+    var l;
+    ({ brackets: t, pairs: s } = n);
+    for (let c = 0, w; w = t[++c]; )
+      if (!w[4] && w[5] >= y && ((l = t[s[c]]) == null ? void 0 : l[1]) <= y)
+        return c;
+  }, _ = (y) => p.forEach((l) => l.classList.toggle("active-bracket", !!y));
+  z(e, "focus", b), z(e, "blur", b), e.addListener("selectionChange", b), e.addListener("update", () => {
+    _(), d = -1;
+  });
+}, za = (e = !0, t = "([{", n = ")]}") => {
+  let s, d;
+  const p = [], b = (c) => {
+    c.extensions.matchBrackets = b, c.addListener("tokenize", y), e && c.tokens[0] ? c.update() : y(c.tokens);
+  }, m = b.brackets = [], _ = b.pairs = [], y = (c) => {
+    if (_.length = m.length = d = s = 0, l(c, 0), e)
+      for (let w = 0, g; g = m[w]; ) {
+        let h = g[0].alias;
+        g[0].alias = (h ? h + " " : "") + `bracket-${w++ in _ ? "level-" + g[2] % 12 : "error"}`;
+      }
+  }, l = (c, w) => {
+    let g, h = 0;
+    for (; g = c[h++]; ) {
+      let a = g.length;
+      if (typeof g != "string") {
+        let r = g.content;
+        if (Array.isArray(r))
+          l(r, w);
+        else if ((g.alias || g.type) == "punctuation") {
+          let u = mn(r, t, a - 1), o = u || mn(r, n, a - 1);
+          if (o) {
+            if (m[s] = [g, w, 0, r, !!u, w + a], u) p[d++] = [s, u];
+            else
+              for (let i = d; i; ) {
+                let [f, R] = p[--i];
+                o == R && (_[_[s] = f] = s, m[s][2] = m[f][2] = d = i, i = 0);
+              }
+            s++;
+          }
+        }
+      }
+      w += a;
+    }
+  };
+  return b;
+}, mn = (e, t, n) => t.indexOf(e[0]) + 1 || n && t.indexOf(e[n]) + 1, Ha = "xml,rss,atom,jsx,tsx,xquery,actionscript".split(","), Va = /^(?:area|base|w?br|col|embed|hr|img|input|link|meta|source|track)$/i, Za = (e) => {
+  let t = [], n, s = [], d, p, b = [], m = (y, l, c) => {
+    n = c, s.length = t.length = d = p = 0, _(y, l, 0);
+  }, _ = (y, l, c) => {
+    let w = Ha.includes(l), g = 0, h = y.length;
+    for (; g < h; ) {
+      const a = y[g++], r = a.content, u = a.length;
+      if (Array.isArray(r))
+        if (a.type == "tag" && n[c] == "<") {
+          const o = r[0].length, i = r[2] ? n.substr(c + o, r[1].length) : "", f = r[r.length - 1].length < 2 && (w || !Va.test(i));
+          if (r[2] && w && _(r, l, c), f)
+            if (o > 1)
+              for (let R = p; R; )
+                i == b[--R][1] && (t[t[d] = b[p = R][0]] = d, R = 0);
+            else
+              b[p++] = [d, i];
+          s[d++] = [
+            a,
+            c,
+            c + u,
+            i,
+            o > 1,
+            f
+          ];
+        } else {
+          let o = a.alias || a.type;
+          _(
+            r,
+            o.slice(0, 9) == "language-" ? o.slice(9) : l,
+            c
+          );
+        }
+      c += u;
+    }
+  };
+  return e.addListener("tokenize", m), m(e.tokens, e.options.language, e.value), {
+    tags: s,
+    pairs: t
+  };
+}, Ka = (e, t) => {
+  for (let n = 0, s = t.length; n < s; n++) if (t[n][1] <= e && t[n][2] >= e) return n;
+}, Wa = () => (e) => {
+  var t;
+  let n, s;
+  const { tags: d, pairs: p } = (t = e.extensions).matchTags || (t.matchTags = Za(e)), b = (m) => [n, s].forEach((_) => {
+    _ && _.classList.toggle("active-tagname", !m);
+  });
+  e.addListener("selectionChange", ([m, _]) => {
+    let y, l, c;
+    m == _ && e.focused && (c = Ka(m, d), c + 1 && (c = p[c], c + 1 && (y = je(e, ".tag>.tag")) && (l = je(e, ".tag>.tag", 2, 0, d[c][1])))), n != y && (b(!0), n = y, s = l, b());
+  });
+}, qa = "_wrap_1x3wi_1", ja = "_blockInfoEditable_1x3wi_30", hn = {
+  wrap: qa,
+  blockInfoEditable: ja
+}, Pe = [
+  { value: "plaintext", label: "plaintext" },
+  { value: "javascript", label: "JavaScript" },
+  { value: "typescript", label: "TypeScript" },
+  { value: "html", label: "HTML" },
+  { value: "css", label: "CSS" },
+  { value: "python", label: "Python" },
+  { value: "java", label: "Java" },
+  { value: "cpp", label: "C++" },
+  { value: "go", label: "Go" },
+  { value: "rust", label: "Rust" },
+  { value: "sql", label: "SQL" },
+  { value: "json", label: "JSON" },
+  { value: "yaml", label: "YAML" },
+  { value: "markdown", label: "Markdown" },
+  { value: "bash", label: "Bash" },
+  { value: "php", label: "PHP" }
+], ct = [2, 4, 8];
+function Ya(e) {
+  const t = Qn(), n = $t(null), s = ea(() => Jn(Ja.name, e == null ? void 0 : e.editor), [e == null ? void 0 : e.editor]), d = $t(null), p = e.node.attrs.code || e.node.textContent || "", b = () => {
+    p && navigator.clipboard.writeText(p).then(() => {
+      console.log("Copy Success");
+    }).catch((l) => {
+      console.error("Error:", l);
+    });
+  }, m = () => {
+    e.updateAttributes({
+      lineNumbers: !e.node.attrs.lineNumbers
+    });
+  }, _ = () => {
+    e.updateAttributes({
+      wordWrap: !e.node.attrs.wordWrap
+    });
+  }, y = (l) => {
+    const c = { ...l };
+    return c.language && !Pe.some((w) => w.value === c.language) && (c.language = "plaintext", e.updateAttributes({
+      language: "plaintext"
+    })), c;
+  };
+  return Ft(() => {
+    if (n.current) {
+      const l = y(e.node.attrs);
+      d.current = Sa(n.current, {
+        readOnly: !e.editor.isEditable,
+        language: l.language || "plaintext",
+        tabSize: l.tabSize ?? 2,
+        lineNumbers: l.lineNumbers ?? !0,
+        wordWrap: l.wordWrap ?? !1,
+        value: p,
+        rtl: !1,
+        onUpdate(c) {
+          e.updateAttributes({ code: c });
+        }
+      }), d.current.addExtensions(
+        za(),
+        Wa(),
+        Ba(),
+        Ga(),
+        $a(),
+        Ma(),
+        Pa()
+      ), e.node.attrs.shouldFocus && setTimeout(() => {
+        var c;
+        (c = d.current) == null || c.textarea.focus(), e.updateAttributes({
+          shouldFocus: !1
+        });
+      }, 0);
+    }
+    return () => {
+      var l, c;
+      (l = d.current) != null && l.remove && ((c = d.current) == null || c.remove());
+    };
+  }, [n]), Ft(() => {
+    var l, c;
+    if ((l = d.current) != null && l.setOptions) {
+      const w = y(e.node.attrs);
+      (c = d.current) == null || c.setOptions(w);
+    }
+  }, [d, e.node.attrs]), /* @__PURE__ */ T(jn, { className: Ne(hn.wrap, "render-wrapper"), children: /* @__PURE__ */ T(
+    "div",
+    {
+      ref: n,
+      className: Ne("richtext-node-container richtext-hover-shadow richtext-select-outline richtext-node-code-block !richtext-my-[10px]", {
+        [hn.blockInfoEditable]: !t
+      }),
+      children: /* @__PURE__ */ me("div", { className: "richtext-code-block-toolbar", children: [
+        /* @__PURE__ */ T("div", { children: /* @__PURE__ */ me(
+          Ut,
+          {
+            defaultValue: e.node.attrs.language,
+            disabled: !t,
+            onValueChange: (l) => {
+              e.updateAttributes({
+                language: l
+              });
+            },
+            children: [
+              /* @__PURE__ */ T(dt, { className: "richtext-h-7 richtext-w-[160px] richtext-border-none richtext-text-sm richtext-outline-none hover:richtext-bg-[#5a5d5e4f]", children: /* @__PURE__ */ T(aa, { placeholder: "Select language" }) }),
+              /* @__PURE__ */ T(
+                ut,
+                {
+                  className: "richtext-border-[#3a3f4b] richtext-bg-[#21252b] richtext-text-[#ccc]",
+                  onCloseAutoFocus: (l) => l.preventDefault(),
+                  children: Pe == null ? void 0 : Pe.map(
+                    (l) => /* @__PURE__ */ T(
+                      pt,
+                      {
+                        value: l.value,
+                        children: l.label
+                      },
+                      l.value
+                    )
+                  )
+                }
+              )
+            ]
+          }
+        ) }),
+        /* @__PURE__ */ T("div", { className: "toolbar-divider" }),
+        /* @__PURE__ */ T(
+          "div",
+          {
+            className: "richtext-flex richtext-size-7 richtext-cursor-pointer richtext-items-center richtext-justify-center richtext-rounded-sm hover:richtext-bg-[#5a5d5e4f]",
+            onClick: b,
+            children: /* @__PURE__ */ T(
+              we,
+              {
+                className: "richtext-size-4",
+                name: "Copy"
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ T("div", { className: "toolbar-divider" }),
+        /* @__PURE__ */ T(
+          "div",
+          {
+            onClick: m,
+            className: Ne("richtext-flex richtext-size-7 richtext-cursor-pointer richtext-items-center richtext-justify-center richtext-rounded-sm hover:richtext-bg-[#5a5d5e4f]", {
+              "richtext-bg-[#5a5d5e4f]": e == null ? void 0 : e.node.attrs.lineNumbers
+            }),
+            children: /* @__PURE__ */ T(
+              we,
+              {
+                className: "richtext-size-4",
+                name: "List"
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ T("div", { className: "toolbar-divider" }),
+        /* @__PURE__ */ T(
+          "div",
+          {
+            onClick: _,
+            className: Ne("richtext-flex richtext-size-7 richtext-cursor-pointer richtext-items-center richtext-justify-center richtext-rounded-sm hover:richtext-bg-[#5a5d5e4f]", {
+              "richtext-bg-[#5a5d5e4f]": e == null ? void 0 : e.node.attrs.wordWrap
+            }),
+            children: /* @__PURE__ */ T(
+              we,
+              {
+                className: "richtext-size-4",
+                name: "WrapText"
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ T("div", { className: "toolbar-divider" }),
+        /* @__PURE__ */ T("div", { children: /* @__PURE__ */ me(
+          Ut,
+          {
+            defaultValue: e.node.attrs.tabSize,
+            disabled: !t,
+            onValueChange: (l) => {
+              e.updateAttributes({
+                tabSize: l
+              });
+            },
+            children: [
+              /* @__PURE__ */ T(dt, { className: "richtext-h-7 richtext-w-[60px] richtext-border-none richtext-text-sm richtext-outline-none hover:richtext-bg-[#5a5d5e4f]", children: /* @__PURE__ */ T(
+                we,
+                {
+                  className: "richtext-size-4",
+                  name: "IndentIncrease"
+                }
+              ) }),
+              /* @__PURE__ */ T(
+                ut,
+                {
+                  className: "richtext-border-[#3a3f4b] richtext-bg-[#21252b] richtext-text-[#ccc]",
+                  onCloseAutoFocus: (l) => l.preventDefault(),
+                  children: ct == null ? void 0 : ct.map((l) => /* @__PURE__ */ T(
+                    pt,
+                    {
+                      value: l,
+                      children: l
+                    },
+                    l
+                  ))
+                }
+              )
+            ]
+          }
+        ) }),
+        /* @__PURE__ */ T("div", { className: "toolbar-divider" }),
+        /* @__PURE__ */ T(
+          "div",
+          {
+            className: "richtext-flex richtext-size-7 richtext-cursor-pointer richtext-items-center richtext-justify-center richtext-rounded-sm hover:richtext-bg-[#5a5d5e4f]",
+            onClick: s,
+            children: /* @__PURE__ */ T(
+              we,
+              {
+                className: "richtext-size-4",
+                name: "Trash2"
+              }
+            )
+          }
+        )
+      ] })
+    }
+  ) });
+}
+const Xa = /^`{3}([a-z]+)?\s$/, Qa = /^~{3}([a-z]+)?\s$/, Ja = /* @__PURE__ */ Wn.create({
+  name: "codeBlock",
+  group: "block",
+  atom: !0,
+  content: "text*",
+  addOptions() {
+    var e;
+    return {
+      ...(e = this.parent) == null ? void 0 : e.call(this),
+      languages: [],
+      button: ({ editor: t, t: n }) => ({
+        component: sa,
+        componentProps: {
+          action: () => t.commands.setCodeBlock({}),
+          isActive: () => t.isActive("codeBlock") || !1,
+          disabled: !1,
+          icon: "Code2",
+          tooltip: n("editor.codeblock.tooltip")
+        }
+      })
+    };
+  },
+  addAttributes() {
+    return {
+      code: {
+        default: "",
+        parseHTML: (e) => e.textContent || ""
+      },
+      language: {
+        default: "plaintext"
+      },
+      lineNumbers: {
+        default: !0
+      },
+      wordWrap: {
+        default: !1
+      },
+      tabSize: {
+        default: 2
+      },
+      shouldFocus: {
+        default: !0,
+        parseHTML: () => !1,
+        renderHTML: !1
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "pre",
+        preserveWhitespace: "full",
+        getAttrs: (e) => ({
+          code: e.textContent || ""
+        })
+      },
+      {
+        tag: "pre code",
+        preserveWhitespace: "full",
+        getAttrs: (e) => ({
+          code: e.textContent || ""
+        })
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: e, node: t }) {
+    var s;
+    const n = t.attrs.code || ((s = t.content.firstChild) == null ? void 0 : s.text) || "";
+    return [
+      "pre",
+      qn(this.options.HTMLAttributes, e),
+      ["code", {}, n]
+    ];
+  },
+  addNodeView() {
+    return Yn(Ya);
+  },
+  addCommands() {
+    return {
+      setCodeBlock: (e) => ({ commands: t }) => t.insertContent({
+        type: this.name,
+        attrs: {
+          ...e,
+          shouldFocus: !0
+        }
+      })
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Alt-c": () => this.editor.commands.setCodeBlock({})
+    };
+  },
+  addInputRules() {
+    return [
+      Dt({
+        find: Xa,
+        type: this.type,
+        getAttributes: (e) => ({
+          language: e[1]
+        })
+      }),
+      Dt({
+        find: Qa,
+        type: this.type,
+        getAttributes: (e) => ({
+          language: e[1]
+        })
+      })
+    ];
+  }
+});
+export {
+  Ja as CodeBlock,
+  Xa as backtickInputRegex,
+  Qa as tildeInputRegex
+};