@tcn/ui 0.3.0 → 0.3.1

package/dist/syntaxhighlighter-IQDEPFLK-BX_eF8__.js

@@ -0,0 +1,3777 @@
+import { c as mt, _ as Z, i as ht, s as yt, j as bt, e as Ae, A as xt, f as F, b as vt, S as St, r as wt } from "./showcase-WfP6kBEb.js";
+import G, { useState as We, useEffect as _t, useCallback as At } from "react";
+function xe(e) {
+  "@babel/helpers - typeof";
+  return xe = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(r) {
+    return typeof r;
+  } : function(r) {
+    return r && typeof Symbol == "function" && r.constructor === Symbol && r !== Symbol.prototype ? "symbol" : typeof r;
+  }, xe(e);
+}
+function Et(e, r) {
+  if (xe(e) != "object" || !e) return e;
+  var t = e[Symbol.toPrimitive];
+  if (t !== void 0) {
+    var a = t.call(e, r);
+    if (xe(a) != "object") return a;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (r === "string" ? String : Number)(e);
+}
+function kt(e) {
+  var r = Et(e, "string");
+  return xe(r) == "symbol" ? r : r + "";
+}
+function Ye(e, r, t) {
+  return (r = kt(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e;
+}
+function Ct(e, r) {
+  if (e == null) return {};
+  var t, a, n = mt(e, r);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    for (a = 0; a < o.length; a++) t = o[a], r.indexOf(t) === -1 && {}.propertyIsEnumerable.call(e, t) && (n[t] = e[t]);
+  }
+  return n;
+}
+var Ft = F({
+  "../node_modules/refractor/lang/bash.js"(e, r) {
+    r.exports = t, t.displayName = "bash", t.aliases = ["shell"];
+    function t(a) {
+      (function(n) {
+        var o = "\\b(?:BASH|BASHOPTS|BASH_ALIASES|BASH_ARGC|BASH_ARGV|BASH_CMDS|BASH_COMPLETION_COMPAT_DIR|BASH_LINENO|BASH_REMATCH|BASH_SOURCE|BASH_VERSINFO|BASH_VERSION|COLORTERM|COLUMNS|COMP_WORDBREAKS|DBUS_SESSION_BUS_ADDRESS|DEFAULTS_PATH|DESKTOP_SESSION|DIRSTACK|DISPLAY|EUID|GDMSESSION|GDM_LANG|GNOME_KEYRING_CONTROL|GNOME_KEYRING_PID|GPG_AGENT_INFO|GROUPS|HISTCONTROL|HISTFILE|HISTFILESIZE|HISTSIZE|HOME|HOSTNAME|HOSTTYPE|IFS|INSTANCE|JOB|LANG|LANGUAGE|LC_ADDRESS|LC_ALL|LC_IDENTIFICATION|LC_MEASUREMENT|LC_MONETARY|LC_NAME|LC_NUMERIC|LC_PAPER|LC_TELEPHONE|LC_TIME|LESSCLOSE|LESSOPEN|LINES|LOGNAME|LS_COLORS|MACHTYPE|MAILCHECK|MANDATORY_PATH|NO_AT_BRIDGE|OLDPWD|OPTERR|OPTIND|ORBIT_SOCKETDIR|OSTYPE|PAPERSIZE|PATH|PIPESTATUS|PPID|PS1|PS2|PS3|PS4|PWD|RANDOM|REPLY|SECONDS|SELINUX_INIT|SESSION|SESSIONTYPE|SESSION_MANAGER|SHELL|SHELLOPTS|SHLVL|SSH_AUTH_SOCK|TERM|UID|UPSTART_EVENTS|UPSTART_INSTANCE|UPSTART_JOB|UPSTART_SESSION|USER|WINDOWID|XAUTHORITY|XDG_CONFIG_DIRS|XDG_CURRENT_DESKTOP|XDG_DATA_DIRS|XDG_GREETER_DATA_DIR|XDG_MENU_PREFIX|XDG_RUNTIME_DIR|XDG_SEAT|XDG_SEAT_PATH|XDG_SESSION_DESKTOP|XDG_SESSION_ID|XDG_SESSION_PATH|XDG_SESSION_TYPE|XDG_VTNR|XMODIFIERS)\\b", u = {
+          pattern: /(^(["']?)\w+\2)[ \t]+\S.*/,
+          lookbehind: !0,
+          alias: "punctuation",
+          // this looks reasonably well in all themes
+          inside: null
+          // see below
+        }, d = {
+          bash: u,
+          environment: {
+            pattern: RegExp("\\$" + o),
+            alias: "constant"
+          },
+          variable: [
+            // [0]: Arithmetic Environment
+            {
+              pattern: /\$?\(\([\s\S]+?\)\)/,
+              greedy: !0,
+              inside: {
+                // If there is a $ sign at the beginning highlight $(( and )) as variable
+                variable: [
+                  {
+                    pattern: /(^\$\(\([\s\S]+)\)\)/,
+                    lookbehind: !0
+                  },
+                  /^\$\(\(/
+                ],
+                number: /\b0x[\dA-Fa-f]+\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: /\$\((?:\([^)]+\)|[^()])+\)|`[^`]+`/,
+              greedy: !0,
+              inside: {
+                variable: /^\$\(|^`|\)$|`$/
+              }
+            },
+            // [2]: Brace expansion
+            {
+              pattern: /\$\{[^}]+\}/,
+              greedy: !0,
+              inside: {
+                operator: /:[-=?+]?|[!\/]|##?|%%?|\^\^?|,,?/,
+                punctuation: /[\[\]]/,
+                environment: {
+                  pattern: RegExp("(\\{)" + o),
+                  lookbehind: !0,
+                  alias: "constant"
+                }
+              }
+            },
+            /\$(?:\w+|[#?*!@$])/
+          ],
+          // Escape sequences from echo and printf's manuals, and escaped quotes.
+          entity: /\\(?:[abceEfnrtv\\"]|O?[0-7]{1,3}|U[0-9a-fA-F]{8}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{1,2})/
+        };
+        n.languages.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)/,
+            alias: "variable",
+            lookbehind: !0
+          },
+          // Highlight variable names as variables in the left-hand part
+          // of assignments (“=” and “+=”).
+          "assign-left": {
+            pattern: /(^|[\s;|&]|[<>]\()\w+(?=\+?=)/,
+            inside: {
+              environment: {
+                pattern: RegExp("(^|[\\s;|&]|[<>]\\()" + o),
+                lookbehind: !0,
+                alias: "constant"
+              }
+            },
+            alias: "variable",
+            lookbehind: !0
+          },
+          string: [
+            // Support for Here-documents https://en.wikipedia.org/wiki/Here_document
+            {
+              pattern: /((?:^|[^<])<<-?\s*)(\w+)\s[\s\S]*?(?:\r?\n|\r)\2/,
+              lookbehind: !0,
+              greedy: !0,
+              inside: d
+            },
+            // Here-document with quotes around the tag
+            // → No expansion (so no “inside”).
+            {
+              pattern: /((?:^|[^<])<<-?\s*)(["'])(\w+)\2\s[\s\S]*?(?:\r?\n|\r)\3/,
+              lookbehind: !0,
+              greedy: !0,
+              inside: {
+                bash: u
+              }
+            },
+            // “Normal” string
+            {
+              // https://www.gnu.org/software/bash/manual/html_node/Double-Quotes.html
+              pattern: /(^|[^\\](?:\\\\)*)"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/,
+              lookbehind: !0,
+              greedy: !0,
+              inside: d
+            },
+            {
+              // https://www.gnu.org/software/bash/manual/html_node/Single-Quotes.html
+              pattern: /(^|[^$\\])'[^']*'/,
+              lookbehind: !0,
+              greedy: !0
+            },
+            {
+              // https://www.gnu.org/software/bash/manual/html_node/ANSI_002dC-Quoting.html
+              pattern: /\$'(?:[^'\\]|\\[\s\S])*'/,
+              greedy: !0,
+              inside: {
+                entity: d.entity
+              }
+            }
+          ],
+          environment: {
+            pattern: RegExp("\\$?" + o),
+            alias: "constant"
+          },
+          variable: d.variable,
+          function: {
+            pattern: /(^|[\s;|&]|[<>]\()(?:add|apropos|apt|apt-cache|apt-get|aptitude|aspell|automysqlbackup|awk|basename|bash|bc|bconsole|bg|bzip2|cal|cat|cfdisk|chgrp|chkconfig|chmod|chown|chroot|cksum|clear|cmp|column|comm|composer|cp|cron|crontab|csplit|curl|cut|date|dc|dd|ddrescue|debootstrap|df|diff|diff3|dig|dir|dircolors|dirname|dirs|dmesg|docker|docker-compose|du|egrep|eject|env|ethtool|expand|expect|expr|fdformat|fdisk|fg|fgrep|file|find|fmt|fold|format|free|fsck|ftp|fuser|gawk|git|gparted|grep|groupadd|groupdel|groupmod|groups|grub-mkconfig|gzip|halt|head|hg|history|host|hostname|htop|iconv|id|ifconfig|ifdown|ifup|import|install|ip|jobs|join|kill|killall|less|link|ln|locate|logname|logrotate|look|lpc|lpr|lprint|lprintd|lprintq|lprm|ls|lsof|lynx|make|man|mc|mdadm|mkconfig|mkdir|mke2fs|mkfifo|mkfs|mkisofs|mknod|mkswap|mmv|more|most|mount|mtools|mtr|mutt|mv|nano|nc|netstat|nice|nl|node|nohup|notify-send|npm|nslookup|op|open|parted|passwd|paste|pathchk|ping|pkill|pnpm|podman|podman-compose|popd|pr|printcap|printenv|ps|pushd|pv|quota|quotacheck|quotactl|ram|rar|rcp|reboot|remsync|rename|renice|rev|rm|rmdir|rpm|rsync|scp|screen|sdiff|sed|sendmail|seq|service|sftp|sh|shellcheck|shuf|shutdown|sleep|slocate|sort|split|ssh|stat|strace|su|sudo|sum|suspend|swapon|sync|tac|tail|tar|tee|time|timeout|top|touch|tr|traceroute|tsort|tty|umount|uname|unexpand|uniq|units|unrar|unshar|unzip|update-grub|uptime|useradd|userdel|usermod|users|uudecode|uuencode|v|vcpkg|vdir|vi|vim|virsh|vmstat|wait|watch|wc|wget|whereis|which|who|whoami|write|xargs|xdg-open|yarn|yes|zenity|zip|zsh|zypper)(?=$|[)\s;|&])/,
+            lookbehind: !0
+          },
+          keyword: {
+            pattern: /(^|[\s;|&]|[<>]\()(?:case|do|done|elif|else|esac|fi|for|function|if|in|select|then|until|while)(?=$|[)\s;|&])/,
+            lookbehind: !0
+          },
+          // 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|let|local|logout|mapfile|printf|pwd|read|readarray|readonly|return|set|shift|shopt|source|test|times|trap|type|typeset|ulimit|umask|unalias|unset)(?=$|[)\s;|&])/,
+            lookbehind: !0,
+            // Alias 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
+          }
+        }, u.inside = n.languages.bash;
+        for (var l = [
+          "comment",
+          "function-name",
+          "for-or-select",
+          "assign-left",
+          "string",
+          "environment",
+          "function",
+          "keyword",
+          "builtin",
+          "boolean",
+          "file-descriptor",
+          "operator",
+          "punctuation",
+          "number"
+        ], f = d.variable[1].inside, h = 0; h < l.length; h++)
+          f[l[h]] = n.languages.bash[l[h]];
+        n.languages.shell = n.languages.bash;
+      })(a);
+    }
+  }
+}), Je = F({
+  "../node_modules/refractor/lang/css.js"(e, r) {
+    r.exports = t, t.displayName = "css", t.aliases = [];
+    function t(a) {
+      (function(n) {
+        var o = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
+        n.languages.css = {
+          comment: /\/\*[\s\S]*?\*\//,
+          atrule: {
+            pattern: /@[\w-](?:[^;{\s]|\s+(?![\s{]))*(?:;|(?=\s*\{))/,
+            inside: {
+              rule: /^@[\w-]+/,
+              "selector-function-argument": {
+                pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
+                lookbehind: !0,
+                alias: "selector"
+              },
+              keyword: {
+                pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
+                lookbehind: !0
+              }
+              // See rest below
+            }
+          },
+          url: {
+            // https://drafts.csswg.org/css-values-3/#urls
+            pattern: RegExp(
+              "\\burl\\((?:" + o.source + "|" + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ")\\)",
+              "i"
+            ),
+            greedy: !0,
+            inside: {
+              function: /^url/i,
+              punctuation: /^\(|\)$/,
+              string: {
+                pattern: RegExp("^" + o.source + "$"),
+                alias: "url"
+              }
+            }
+          },
+          selector: {
+            pattern: RegExp(
+              `(^|[{}\\s])[^{}\\s](?:[^{};"'\\s]|\\s+(?![\\s{])|` + o.source + ")*(?=\\s*\\{)"
+            ),
+            lookbehind: !0
+          },
+          string: {
+            pattern: o,
+            greedy: !0
+          },
+          property: {
+            pattern: /(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,
+            lookbehind: !0
+          },
+          important: /!important\b/i,
+          function: {
+            pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i,
+            lookbehind: !0
+          },
+          punctuation: /[(){};:,]/
+        }, n.languages.css.atrule.inside.rest = n.languages.css;
+        var u = n.languages.markup;
+        u && (u.tag.addInlined("style", "css"), u.tag.addAttribute("style", "css"));
+      })(a);
+    }
+  }
+}), jt = F({
+  "../node_modules/refractor/lang/graphql.js"(e, r) {
+    r.exports = t, t.displayName = "graphql", t.aliases = [];
+    function t(a) {
+      a.languages.graphql = {
+        comment: /#.*/,
+        description: {
+          pattern: /(?:"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*")(?=\s*[a-z_])/i,
+          greedy: !0,
+          alias: "string",
+          inside: {
+            "language-markdown": {
+              pattern: /(^"(?:"")?)(?!\1)[\s\S]+(?=\1$)/,
+              lookbehind: !0,
+              inside: a.languages.markdown
+            }
+          }
+        },
+        string: {
+          pattern: /"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*"/,
+          greedy: !0
+        },
+        number: /(?:\B-|\b)\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+        boolean: /\b(?:false|true)\b/,
+        variable: /\$[a-z_]\w*/i,
+        directive: {
+          pattern: /@[a-z_]\w*/i,
+          alias: "function"
+        },
+        "attr-name": {
+          pattern: /\b[a-z_]\w*(?=\s*(?:\((?:[^()"]|"(?:\\.|[^\\"\r\n])*")*\))?:)/i,
+          greedy: !0
+        },
+        "atom-input": {
+          pattern: /\b[A-Z]\w*Input\b/,
+          alias: "class-name"
+        },
+        scalar: /\b(?:Boolean|Float|ID|Int|String)\b/,
+        constant: /\b[A-Z][A-Z_\d]*\b/,
+        "class-name": {
+          pattern: /(\b(?:enum|implements|interface|on|scalar|type|union)\s+|&\s*|:\s*|\[)[A-Z_]\w*/,
+          lookbehind: !0
+        },
+        fragment: {
+          pattern: /(\bfragment\s+|\.{3}\s*(?!on\b))[a-zA-Z_]\w*/,
+          lookbehind: !0,
+          alias: "function"
+        },
+        "definition-mutation": {
+          pattern: /(\bmutation\s+)[a-zA-Z_]\w*/,
+          lookbehind: !0,
+          alias: "function"
+        },
+        "definition-query": {
+          pattern: /(\bquery\s+)[a-zA-Z_]\w*/,
+          lookbehind: !0,
+          alias: "function"
+        },
+        keyword: /\b(?:directive|enum|extend|fragment|implements|input|interface|mutation|on|query|repeatable|scalar|schema|subscription|type|union)\b/,
+        operator: /[!=|&]|\.{3}/,
+        "property-query": /\w+(?=\s*\()/,
+        object: /\w+(?=\s*\{)/,
+        punctuation: /[!(){}\[\]:=,]/,
+        property: /\w+/
+      }, a.hooks.add("after-tokenize", function(n) {
+        if (n.language !== "graphql")
+          return;
+        var o = n.tokens.filter(function(A) {
+          return typeof A != "string" && A.type !== "comment" && A.type !== "scalar";
+        }), u = 0;
+        function d(A) {
+          return o[u + A];
+        }
+        function l(A, i) {
+          i = i || 0;
+          for (var s = 0; s < A.length; s++) {
+            var p = d(s + i);
+            if (!p || p.type !== A[s])
+              return !1;
+          }
+          return !0;
+        }
+        function f(A, i) {
+          for (var s = 1, p = u; p < o.length; p++) {
+            var g = o[p], m = g.content;
+            if (g.type === "punctuation" && typeof m == "string") {
+              if (A.test(m))
+                s++;
+              else if (i.test(m) && (s--, s === 0))
+                return p;
+            }
+          }
+          return -1;
+        }
+        function h(A, i) {
+          var s = A.alias;
+          s ? Array.isArray(s) || (A.alias = s = [s]) : A.alias = s = [], s.push(i);
+        }
+        for (; u < o.length; ) {
+          var C = o[u++];
+          if (C.type === "keyword" && C.content === "mutation") {
+            var x = [];
+            if (l(["definition-mutation", "punctuation"]) && d(1).content === "(") {
+              u += 2;
+              var b = f(/^\($/, /^\)$/);
+              if (b === -1)
+                continue;
+              for (; u < b; u++) {
+                var y = d(0);
+                y.type === "variable" && (h(y, "variable-input"), x.push(y.content));
+              }
+              u = b + 1;
+            }
+            if (l(["punctuation", "property-query"]) && d(0).content === "{" && (u++, h(d(0), "property-mutation"), x.length > 0)) {
+              var S = f(/^\{$/, /^\}$/);
+              if (S === -1)
+                continue;
+              for (var E = u; E < S; E++) {
+                var w = o[E];
+                w.type === "variable" && x.indexOf(w.content) >= 0 && h(w, "variable-input");
+              }
+            }
+          }
+        }
+      });
+    }
+  }
+}), Nt = F({
+  "../node_modules/refractor/lang/js-extras.js"(e, r) {
+    r.exports = t, t.displayName = "jsExtras", t.aliases = [];
+    function t(a) {
+      (function(n) {
+        n.languages.insertBefore("javascript", "function-variable", {
+          "method-variable": {
+            pattern: RegExp(
+              "(\\.\\s*)" + n.languages.javascript["function-variable"].pattern.source
+            ),
+            lookbehind: !0,
+            alias: ["function-variable", "method", "function", "property-access"]
+          }
+        }), n.languages.insertBefore("javascript", "function", {
+          method: {
+            pattern: RegExp(
+              "(\\.\\s*)" + n.languages.javascript.function.source
+            ),
+            lookbehind: !0,
+            alias: ["function", "property-access"]
+          }
+        }), n.languages.insertBefore("javascript", "constant", {
+          "known-class-name": [
+            {
+              // standard built-ins
+              // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects
+              pattern: /\b(?:(?:Float(?:32|64)|(?:Int|Uint)(?:8|16|32)|Uint8Clamped)?Array|ArrayBuffer|BigInt|Boolean|DataView|Date|Error|Function|Intl|JSON|(?:Weak)?(?:Map|Set)|Math|Number|Object|Promise|Proxy|Reflect|RegExp|String|Symbol|WebAssembly)\b/,
+              alias: "class-name"
+            },
+            {
+              // errors
+              pattern: /\b(?:[A-Z]\w*)Error\b/,
+              alias: "class-name"
+            }
+          ]
+        });
+        function o(C, x) {
+          return RegExp(
+            C.replace(/<ID>/g, function() {
+              return /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/.source;
+            }),
+            x
+          );
+        }
+        n.languages.insertBefore("javascript", "keyword", {
+          imports: {
+            // https://tc39.es/ecma262/#sec-imports
+            pattern: o(
+              /(\bimport\b\s*)(?:<ID>(?:\s*,\s*(?:\*\s*as\s+<ID>|\{[^{}]*\}))?|\*\s*as\s+<ID>|\{[^{}]*\})(?=\s*\bfrom\b)/.source
+            ),
+            lookbehind: !0,
+            inside: n.languages.javascript
+          },
+          exports: {
+            // https://tc39.es/ecma262/#sec-exports
+            pattern: o(
+              /(\bexport\b\s*)(?:\*(?:\s*as\s+<ID>)?(?=\s*\bfrom\b)|\{[^{}]*\})/.source
+            ),
+            lookbehind: !0,
+            inside: n.languages.javascript
+          }
+        }), n.languages.javascript.keyword.unshift(
+          {
+            pattern: /\b(?:as|default|export|from|import)\b/,
+            alias: "module"
+          },
+          {
+            pattern: /\b(?:await|break|catch|continue|do|else|finally|for|if|return|switch|throw|try|while|yield)\b/,
+            alias: "control-flow"
+          },
+          {
+            pattern: /\bnull\b/,
+            alias: ["null", "nil"]
+          },
+          {
+            pattern: /\bundefined\b/,
+            alias: "nil"
+          }
+        ), n.languages.insertBefore("javascript", "operator", {
+          spread: {
+            pattern: /\.{3}/,
+            alias: "operator"
+          },
+          arrow: {
+            pattern: /=>/,
+            alias: "operator"
+          }
+        }), n.languages.insertBefore("javascript", "punctuation", {
+          "property-access": {
+            pattern: o(/(\.\s*)#?<ID>/.source),
+            lookbehind: !0
+          },
+          "maybe-class-name": {
+            pattern: /(^|[^$\w\xA0-\uFFFF])[A-Z][$\w\xA0-\uFFFF]+/,
+            lookbehind: !0
+          },
+          dom: {
+            // this contains only a few commonly used DOM variables
+            pattern: /\b(?:document|(?:local|session)Storage|location|navigator|performance|window)\b/,
+            alias: "variable"
+          },
+          console: {
+            pattern: /\bconsole(?=\s*\.)/,
+            alias: "class-name"
+          }
+        });
+        for (var u = [
+          "function",
+          "function-variable",
+          "method",
+          "method-variable",
+          "property-access"
+        ], d = 0; d < u.length; d++) {
+          var l = u[d], f = n.languages.javascript[l];
+          n.util.type(f) === "RegExp" && (f = n.languages.javascript[l] = {
+            pattern: f
+          });
+          var h = f.inside || {};
+          f.inside = h, h["maybe-class-name"] = /^[A-Z][\s\S]*/;
+        }
+      })(a);
+    }
+  }
+}), $t = F({
+  "../node_modules/refractor/lang/json.js"(e, r) {
+    r.exports = t, t.displayName = "json", t.aliases = ["webmanifest"];
+    function t(a) {
+      a.languages.json = {
+        property: {
+          pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?=\s*:)/,
+          lookbehind: !0,
+          greedy: !0
+        },
+        string: {
+          pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?!\s*:)/,
+          lookbehind: !0,
+          greedy: !0
+        },
+        comment: {
+          pattern: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
+          greedy: !0
+        },
+        number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+        punctuation: /[{}[\],]/,
+        operator: /:/,
+        boolean: /\b(?:false|true)\b/,
+        null: {
+          pattern: /\bnull\b/,
+          alias: "keyword"
+        }
+      }, a.languages.webmanifest = a.languages.json;
+    }
+  }
+}), Qe = F({
+  "../node_modules/refractor/lang/jsx.js"(e, r) {
+    r.exports = t, t.displayName = "jsx", t.aliases = [];
+    function t(a) {
+      (function(n) {
+        var o = n.util.clone(n.languages.javascript), u = /(?:\s|\/\/.*(?!.)|\/\*(?:[^*]|\*(?!\/))\*\/)/.source, d = /(?:\{(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])*\})/.source, l = /(?:\{<S>*\.{3}(?:[^{}]|<BRACES>)*\})/.source;
+        function f(x, b) {
+          return x = x.replace(/<S>/g, function() {
+            return u;
+          }).replace(/<BRACES>/g, function() {
+            return d;
+          }).replace(/<SPREAD>/g, function() {
+            return l;
+          }), RegExp(x, b);
+        }
+        l = f(l).source, n.languages.jsx = n.languages.extend("markup", o), n.languages.jsx.tag.pattern = f(
+          /<\/?(?:[\w.:-]+(?:<S>+(?:[\w.:$-]+(?:=(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s{'"/>=]+|<BRACES>))?|<SPREAD>))*<S>*\/?)?>/.source
+        ), n.languages.jsx.tag.inside.tag.pattern = /^<\/?[^\s>\/]*/, n.languages.jsx.tag.inside["attr-value"].pattern = /=(?!\{)(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s'">]+)/, n.languages.jsx.tag.inside.tag.inside["class-name"] = /^[A-Z]\w*(?:\.[A-Z]\w*)*$/, n.languages.jsx.tag.inside.comment = o.comment, n.languages.insertBefore(
+          "inside",
+          "attr-name",
+          {
+            spread: {
+              pattern: f(/<SPREAD>/.source),
+              inside: n.languages.jsx
+            }
+          },
+          n.languages.jsx.tag
+        ), n.languages.insertBefore(
+          "inside",
+          "special-attr",
+          {
+            script: {
+              // Allow for two levels of nesting
+              pattern: f(/=<BRACES>/.source),
+              alias: "language-javascript",
+              inside: {
+                "script-punctuation": {
+                  pattern: /^=(?=\{)/,
+                  alias: "punctuation"
+                },
+                rest: n.languages.jsx
+              }
+            }
+          },
+          n.languages.jsx.tag
+        );
+        var h = function(x) {
+          return x ? typeof x == "string" ? x : typeof x.content == "string" ? x.content : x.content.map(h).join("") : "";
+        }, C = function(x) {
+          for (var b = [], y = 0; y < x.length; y++) {
+            var S = x[y], E = !1;
+            if (typeof S != "string" && (S.type === "tag" && S.content[0] && S.content[0].type === "tag" ? S.content[0].content[0].content === "</" ? b.length > 0 && b[b.length - 1].tagName === h(S.content[0].content[1]) && b.pop() : S.content[S.content.length - 1].content === "/>" || b.push({
+              tagName: h(S.content[0].content[1]),
+              openedBraces: 0
+            }) : b.length > 0 && S.type === "punctuation" && S.content === "{" ? b[b.length - 1].openedBraces++ : b.length > 0 && b[b.length - 1].openedBraces > 0 && S.type === "punctuation" && S.content === "}" ? b[b.length - 1].openedBraces-- : E = !0), (E || typeof S == "string") && b.length > 0 && b[b.length - 1].openedBraces === 0) {
+              var w = h(S);
+              y < x.length - 1 && (typeof x[y + 1] == "string" || x[y + 1].type === "plain-text") && (w += h(x[y + 1]), x.splice(y + 1, 1)), y > 0 && (typeof x[y - 1] == "string" || x[y - 1].type === "plain-text") && (w = h(x[y - 1]) + w, x.splice(y - 1, 1), y--), x[y] = new n.Token(
+                "plain-text",
+                w,
+                null,
+                w
+              );
+            }
+            S.content && typeof S.content != "string" && C(S.content);
+          }
+        };
+        n.hooks.add("after-tokenize", function(x) {
+          x.language !== "jsx" && x.language !== "tsx" || C(x.tokens);
+        });
+      })(a);
+    }
+  }
+}), Ot = F({
+  "../node_modules/refractor/lang/markdown.js"(e, r) {
+    r.exports = t, t.displayName = "markdown", t.aliases = ["md"];
+    function t(a) {
+      (function(n) {
+        var o = /(?:\\.|[^\\\n\r]|(?:\n|\r\n?)(?![\r\n]))/.source;
+        function u(y) {
+          return y = y.replace(/<inner>/g, function() {
+            return o;
+          }), RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + "(?:" + y + ")");
+        }
+        var d = /(?:\\.|``(?:[^`\r\n]|`(?!`))+``|`[^`\r\n]+`|[^\\|\r\n`])+/.source, l = /\|?__(?:\|__)+\|?(?:(?:\n|\r\n?)|(?![\s\S]))/.source.replace(
+          /__/g,
+          function() {
+            return d;
+          }
+        ), f = /\|?[ \t]*:?-{3,}:?[ \t]*(?:\|[ \t]*:?-{3,}:?[ \t]*)+\|?(?:\n|\r\n?)/.source;
+        n.languages.markdown = n.languages.extend("markup", {}), n.languages.insertBefore("markdown", "prolog", {
+          "front-matter-block": {
+            pattern: /(^(?:\s*[\r\n])?)---(?!.)[\s\S]*?[\r\n]---(?!.)/,
+            lookbehind: !0,
+            greedy: !0,
+            inside: {
+              punctuation: /^---|---$/,
+              "front-matter": {
+                pattern: /\S+(?:\s+\S+)*/,
+                alias: ["yaml", "language-yaml"],
+                inside: n.languages.yaml
+              }
+            }
+          },
+          blockquote: {
+            // > ...
+            pattern: /^>(?:[\t ]*>)*/m,
+            alias: "punctuation"
+          },
+          table: {
+            pattern: RegExp(
+              "^" + l + f + "(?:" + l + ")*",
+              "m"
+            ),
+            inside: {
+              "table-data-rows": {
+                pattern: RegExp(
+                  "^(" + l + f + ")(?:" + l + ")*$"
+                ),
+                lookbehind: !0,
+                inside: {
+                  "table-data": {
+                    pattern: RegExp(d),
+                    inside: n.languages.markdown
+                  },
+                  punctuation: /\|/
+                }
+              },
+              "table-line": {
+                pattern: RegExp("^(" + l + ")" + f + "$"),
+                lookbehind: !0,
+                inside: {
+                  punctuation: /\||:?-{3,}:?/
+                }
+              },
+              "table-header-row": {
+                pattern: RegExp("^" + l + "$"),
+                inside: {
+                  "table-header": {
+                    pattern: RegExp(d),
+                    alias: "important",
+                    inside: n.languages.markdown
+                  },
+                  punctuation: /\|/
+                }
+              }
+            }
+          },
+          code: [
+            {
+              // Prefixed by 4 spaces or 1 tab and preceded by an empty line
+              pattern: /((?:^|\n)[ \t]*\n|(?:^|\r\n?)[ \t]*\r\n?)(?: {4}|\t).+(?:(?:\n|\r\n?)(?: {4}|\t).+)*/,
+              lookbehind: !0,
+              alias: "keyword"
+            },
+            {
+              // ```optional language
+              // code block
+              // ```
+              pattern: /^```[\s\S]*?^```$/m,
+              greedy: !0,
+              inside: {
+                "code-block": {
+                  pattern: /^(```.*(?:\n|\r\n?))[\s\S]+?(?=(?:\n|\r\n?)^```$)/m,
+                  lookbehind: !0
+                },
+                "code-language": {
+                  pattern: /^(```).+/,
+                  lookbehind: !0
+                },
+                punctuation: /```/
+              }
+            }
+          ],
+          title: [
+            {
+              // title 1
+              // =======
+              // title 2
+              // -------
+              pattern: /\S.*(?:\n|\r\n?)(?:==+|--+)(?=[ \t]*$)/m,
+              alias: "important",
+              inside: {
+                punctuation: /==+$|--+$/
+              }
+            },
+            {
+              // # title 1
+              // ###### title 6
+              pattern: /(^\s*)#.+/m,
+              lookbehind: !0,
+              alias: "important",
+              inside: {
+                punctuation: /^#+|#+$/
+              }
+            }
+          ],
+          hr: {
+            // ***
+            // ---
+            // * * *
+            // -----------
+            pattern: /(^\s*)([*-])(?:[\t ]*\2){2,}(?=\s*$)/m,
+            lookbehind: !0,
+            alias: "punctuation"
+          },
+          list: {
+            // * item
+            // + item
+            // - item
+            // 1. item
+            pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m,
+            lookbehind: !0,
+            alias: "punctuation"
+          },
+          "url-reference": {
+            // [id]: http://example.com "Optional title"
+            // [id]: http://example.com 'Optional title'
+            // [id]: http://example.com (Optional title)
+            // [id]: <http://example.com> "Optional title"
+            pattern: /!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/,
+            inside: {
+              variable: {
+                pattern: /^(!?\[)[^\]]+/,
+                lookbehind: !0
+              },
+              string: /(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/,
+              punctuation: /^[\[\]!:]|[<>]/
+            },
+            alias: "url"
+          },
+          bold: {
+            // **strong**
+            // __strong__
+            // allow one nested instance of italic text using the same delimiter
+            pattern: u(
+              /\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\b|\*\*(?:(?!\*)<inner>|\*(?:(?!\*)<inner>)+\*)+\*\*/.source
+            ),
+            lookbehind: !0,
+            greedy: !0,
+            inside: {
+              content: {
+                pattern: /(^..)[\s\S]+(?=..$)/,
+                lookbehind: !0,
+                inside: {}
+                // see below
+              },
+              punctuation: /\*\*|__/
+            }
+          },
+          italic: {
+            // *em*
+            // _em_
+            // allow one nested instance of bold text using the same delimiter
+            pattern: u(
+              /\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\b|\*(?:(?!\*)<inner>|\*\*(?:(?!\*)<inner>)+\*\*)+\*/.source
+            ),
+            lookbehind: !0,
+            greedy: !0,
+            inside: {
+              content: {
+                pattern: /(^.)[\s\S]+(?=.$)/,
+                lookbehind: !0,
+                inside: {}
+                // see below
+              },
+              punctuation: /[*_]/
+            }
+          },
+          strike: {
+            // ~~strike through~~
+            // ~strike~
+            // eslint-disable-next-line regexp/strict
+            pattern: u(/(~~?)(?:(?!~)<inner>)+\2/.source),
+            lookbehind: !0,
+            greedy: !0,
+            inside: {
+              content: {
+                pattern: /(^~~?)[\s\S]+(?=\1$)/,
+                lookbehind: !0,
+                inside: {}
+                // see below
+              },
+              punctuation: /~~?/
+            }
+          },
+          "code-snippet": {
+            // `code`
+            // ``code``
+            pattern: /(^|[^\\`])(?:``[^`\r\n]+(?:`[^`\r\n]+)*``(?!`)|`[^`\r\n]+`(?!`))/,
+            lookbehind: !0,
+            greedy: !0,
+            alias: ["code", "keyword"]
+          },
+          url: {
+            // [example](http://example.com "Optional title")
+            // [example][id]
+            // [example] [id]
+            pattern: u(
+              /!?\[(?:(?!\])<inner>)+\](?:\([^\s)]+(?:[\t ]+"(?:\\.|[^"\\])*")?\)|[ \t]?\[(?:(?!\])<inner>)+\])/.source
+            ),
+            lookbehind: !0,
+            greedy: !0,
+            inside: {
+              operator: /^!/,
+              content: {
+                pattern: /(^\[)[^\]]+(?=\])/,
+                lookbehind: !0,
+                inside: {}
+                // see below
+              },
+              variable: {
+                pattern: /(^\][ \t]?\[)[^\]]+(?=\]$)/,
+                lookbehind: !0
+              },
+              url: {
+                pattern: /(^\]\()[^\s)]+/,
+                lookbehind: !0
+              },
+              string: {
+                pattern: /(^[ \t]+)"(?:\\.|[^"\\])*"(?=\)$)/,
+                lookbehind: !0
+              }
+            }
+          }
+        }), ["url", "bold", "italic", "strike"].forEach(function(y) {
+          ["url", "bold", "italic", "strike", "code-snippet"].forEach(function(S) {
+            y !== S && (n.languages.markdown[y].inside.content.inside[S] = n.languages.markdown[S]);
+          });
+        }), n.hooks.add("after-tokenize", function(y) {
+          if (y.language !== "markdown" && y.language !== "md")
+            return;
+          function S(E) {
+            if (!(!E || typeof E == "string"))
+              for (var w = 0, A = E.length; w < A; w++) {
+                var i = E[w];
+                if (i.type !== "code") {
+                  S(i.content);
+                  continue;
+                }
+                var s = i.content[1], p = i.content[3];
+                if (s && p && s.type === "code-language" && p.type === "code-block" && typeof s.content == "string") {
+                  var g = s.content.replace(/\b#/g, "sharp").replace(/\b\+\+/g, "pp");
+                  g = (/[a-z][\w-]*/i.exec(g) || [""])[0].toLowerCase();
+                  var m = "language-" + g;
+                  p.alias ? typeof p.alias == "string" ? p.alias = [p.alias, m] : p.alias.push(m) : p.alias = [m];
+                }
+              }
+          }
+          S(y.tokens);
+        }), n.hooks.add("wrap", function(y) {
+          if (y.type === "code-block") {
+            for (var S = "", E = 0, w = y.classes.length; E < w; E++) {
+              var A = y.classes[E], i = /language-(.+)/.exec(A);
+              if (i) {
+                S = i[1];
+                break;
+              }
+            }
+            var s = n.languages[S];
+            if (s)
+              y.content = n.highlight(
+                b(y.content.value),
+                s,
+                S
+              );
+            else if (S && S !== "none" && n.plugins.autoloader) {
+              var p = "md-" + (/* @__PURE__ */ new Date()).valueOf() + "-" + Math.floor(Math.random() * 1e16);
+              y.attributes.id = p, n.plugins.autoloader.loadLanguages(S, function() {
+                var g = document.getElementById(p);
+                g && (g.innerHTML = n.highlight(
+                  g.textContent,
+                  n.languages[S],
+                  S
+                ));
+              });
+            }
+          }
+        });
+        var h = RegExp(n.languages.markup.tag.pattern.source, "gi"), C = {
+          amp: "&",
+          lt: "<",
+          gt: ">",
+          quot: '"'
+        }, x = String.fromCodePoint || String.fromCharCode;
+        function b(y) {
+          var S = y.replace(h, "");
+          return S = S.replace(/&(\w{1,8}|#x?[\da-f]{1,8});/gi, function(E, w) {
+            if (w = w.toLowerCase(), w[0] === "#") {
+              var A;
+              return w[1] === "x" ? A = parseInt(w.slice(2), 16) : A = Number(w.slice(1)), x(A);
+            } else {
+              var i = C[w];
+              return i || E;
+            }
+          }), S;
+        }
+        n.languages.md = n.languages.markdown;
+      })(a);
+    }
+  }
+}), et = F({
+  "../node_modules/refractor/lang/markup.js"(e, r) {
+    r.exports = t, t.displayName = "markup", t.aliases = ["html", "mathml", "svg", "xml", "ssml", "atom", "rss"];
+    function t(a) {
+      a.languages.markup = {
+        comment: {
+          pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
+          greedy: !0
+        },
+        prolog: {
+          pattern: /<\?[\s\S]+?\?>/,
+          greedy: !0
+        },
+        doctype: {
+          // https://www.w3.org/TR/xml/#NT-doctypedecl
+          pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
+          greedy: !0,
+          inside: {
+            "internal-subset": {
+              pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
+              lookbehind: !0,
+              greedy: !0,
+              inside: null
+              // see below
+            },
+            string: {
+              pattern: /"[^"]*"|'[^']*'/,
+              greedy: !0
+            },
+            punctuation: /^<!|>$|[[\]]/,
+            "doctype-tag": /^DOCTYPE/i,
+            name: /[^\s<>'"]+/
+          }
+        },
+        cdata: {
+          pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+          greedy: !0
+        },
+        tag: {
+          pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
+          greedy: !0,
+          inside: {
+            tag: {
+              pattern: /^<\/?[^\s>\/]+/,
+              inside: {
+                punctuation: /^<\/?/,
+                namespace: /^[^\s>\/:]+:/
+              }
+            },
+            "special-attr": [],
+            "attr-value": {
+              pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
+              inside: {
+                punctuation: [
+                  {
+                    pattern: /^=/,
+                    alias: "attr-equals"
+                  },
+                  /"|'/
+                ]
+              }
+            },
+            punctuation: /\/?>/,
+            "attr-name": {
+              pattern: /[^\s>\/]+/,
+              inside: {
+                namespace: /^[^\s>\/:]+:/
+              }
+            }
+          }
+        },
+        entity: [
+          {
+            pattern: /&[\da-z]{1,8};/i,
+            alias: "named-entity"
+          },
+          /&#x?[\da-f]{1,8};/i
+        ]
+      }, a.languages.markup.tag.inside["attr-value"].inside.entity = a.languages.markup.entity, a.languages.markup.doctype.inside["internal-subset"].inside = a.languages.markup, a.hooks.add("wrap", function(n) {
+        n.type === "entity" && (n.attributes.title = n.content.value.replace(/&amp;/, "&"));
+      }), Object.defineProperty(a.languages.markup.tag, "addInlined", {
+        /**
+         * Adds an inlined language to markup.
+         *
+         * An example of an inlined language is CSS with `<style>` tags.
+         *
+         * @param {string} tagName The name of the tag that contains the inlined language. This name will be treated as
+         * case insensitive.
+         * @param {string} lang The language key.
+         * @example
+         * addInlined('style', 'css');
+         */
+        value: function(n, o) {
+          var u = {};
+          u["language-" + o] = {
+            pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
+            lookbehind: !0,
+            inside: a.languages[o]
+          }, u.cdata = /^<!\[CDATA\[|\]\]>$/i;
+          var d = {
+            "included-cdata": {
+              pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+              inside: u
+            }
+          };
+          d["language-" + o] = {
+            pattern: /[\s\S]+/,
+            inside: a.languages[o]
+          };
+          var l = {};
+          l[n] = {
+            pattern: RegExp(
+              /(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(
+                /__/g,
+                function() {
+                  return n;
+                }
+              ),
+              "i"
+            ),
+            lookbehind: !0,
+            greedy: !0,
+            inside: d
+          }, a.languages.insertBefore("markup", "cdata", l);
+        }
+      }), Object.defineProperty(a.languages.markup.tag, "addAttribute", {
+        /**
+         * Adds an pattern to highlight languages embedded in HTML attributes.
+         *
+         * An example of an inlined language is CSS with `style` attributes.
+         *
+         * @param {string} attrName The name of the tag that contains the inlined language. This name will be treated as
+         * case insensitive.
+         * @param {string} lang The language key.
+         * @example
+         * addAttribute('style', 'css');
+         */
+        value: function(n, o) {
+          a.languages.markup.tag.inside["special-attr"].push({
+            pattern: RegExp(
+              /(^|["'\s])/.source + "(?:" + n + ")" + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source,
+              "i"
+            ),
+            lookbehind: !0,
+            inside: {
+              "attr-name": /^[^\s=]+/,
+              "attr-value": {
+                pattern: /=[\s\S]+/,
+                inside: {
+                  value: {
+                    pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
+                    lookbehind: !0,
+                    alias: [o, "language-" + o],
+                    inside: a.languages[o]
+                  },
+                  punctuation: [
+                    {
+                      pattern: /^=/,
+                      alias: "attr-equals"
+                    },
+                    /"|'/
+                  ]
+                }
+              }
+            }
+          });
+        }
+      }), a.languages.html = a.languages.markup, a.languages.mathml = a.languages.markup, a.languages.svg = a.languages.markup, a.languages.xml = a.languages.extend("markup", {}), a.languages.ssml = a.languages.xml, a.languages.atom = a.languages.xml, a.languages.rss = a.languages.xml;
+    }
+  }
+}), tt = F({
+  "../node_modules/refractor/lang/typescript.js"(e, r) {
+    r.exports = t, t.displayName = "typescript", t.aliases = ["ts"];
+    function t(a) {
+      (function(n) {
+        n.languages.typescript = n.languages.extend("javascript", {
+          "class-name": {
+            pattern: /(\b(?:class|extends|implements|instanceof|interface|new|type)\s+)(?!keyof\b)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?:\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/,
+            lookbehind: !0,
+            greedy: !0,
+            inside: null
+            // see below
+          },
+          builtin: /\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\b/
+        }), n.languages.typescript.keyword.push(
+          /\b(?:abstract|declare|is|keyof|readonly|require)\b/,
+          // keywords that have to be followed by an identifier
+          /\b(?:asserts|infer|interface|module|namespace|type)\b(?=\s*(?:[{_$a-zA-Z\xA0-\uFFFF]|$))/,
+          // This is for `import type *, {}`
+          /\btype\b(?=\s*(?:[\{*]|$))/
+        ), delete n.languages.typescript.parameter, delete n.languages.typescript["literal-property"];
+        var o = n.languages.extend("typescript", {});
+        delete o["class-name"], n.languages.typescript["class-name"].inside = o, n.languages.insertBefore("typescript", "function", {
+          decorator: {
+            pattern: /@[$\w\xA0-\uFFFF]+/,
+            inside: {
+              at: {
+                pattern: /^@/,
+                alias: "operator"
+              },
+              function: /^[\s\S]+/
+            }
+          },
+          "generic-function": {
+            // e.g. foo<T extends "bar" | "baz">( ...
+            pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\s*\()/,
+            greedy: !0,
+            inside: {
+              function: /^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/,
+              generic: {
+                pattern: /<[\s\S]+/,
+                // everything after the first <
+                alias: "class-name",
+                inside: o
+              }
+            }
+          }
+        }), n.languages.ts = n.languages.typescript;
+      })(a);
+    }
+  }
+}), Lt = F({
+  "../node_modules/refractor/lang/tsx.js"(e, r) {
+    var t = Qe(), a = tt();
+    r.exports = n, n.displayName = "tsx", n.aliases = [];
+    function n(o) {
+      o.register(t), o.register(a), (function(u) {
+        var d = u.util.clone(u.languages.typescript);
+        u.languages.tsx = u.languages.extend("jsx", d), delete u.languages.tsx.parameter, delete u.languages.tsx["literal-property"];
+        var l = u.languages.tsx.tag;
+        l.pattern = RegExp(
+          /(^|[^\w$]|(?=<\/))/.source + "(?:" + l.pattern.source + ")",
+          l.pattern.flags
+        ), l.lookbehind = !0;
+      })(o);
+    }
+  }
+}), It = F({
+  "../node_modules/refractor/lang/yaml.js"(e, r) {
+    r.exports = t, t.displayName = "yaml", t.aliases = ["yml"];
+    function t(a) {
+      (function(n) {
+        var o = /[*&][^\s[\]{},]+/, u = /!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/, d = "(?:" + u.source + "(?:[ 	]+" + o.source + ")?|" + o.source + "(?:[ 	]+" + u.source + ")?)", l = /(?:[^\s\x00-\x08\x0e-\x1f!"#%&'*,\-:>?@[\]`{|}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]|[?:-]<PLAIN>)(?:[ \t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*/.source.replace(
+          /<PLAIN>/g,
+          function() {
+            return /[^\s\x00-\x08\x0e-\x1f,[\]{}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]/.source;
+          }
+        ), f = /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/.source;
+        function h(C, x) {
+          x = (x || "").replace(/m/g, "") + "m";
+          var b = /([:\-,[{]\s*(?:\s<<prop>>[ \t]+)?)(?:<<value>>)(?=[ \t]*(?:$|,|\]|\}|(?:[\r\n]\s*)?#))/.source.replace(/<<prop>>/g, function() {
+            return d;
+          }).replace(/<<value>>/g, function() {
+            return C;
+          });
+          return RegExp(b, x);
+        }
+        n.languages.yaml = {
+          scalar: {
+            pattern: RegExp(
+              /([\-:]\s*(?:\s<<prop>>[ \t]+)?[|>])[ \t]*(?:((?:\r?\n|\r)[ \t]+)\S[^\r\n]*(?:\2[^\r\n]+)*)/.source.replace(
+                /<<prop>>/g,
+                function() {
+                  return d;
+                }
+              )
+            ),
+            lookbehind: !0,
+            alias: "string"
+          },
+          comment: /#.*/,
+          key: {
+            pattern: RegExp(
+              /((?:^|[:\-,[{\r\n?])[ \t]*(?:<<prop>>[ \t]+)?)<<key>>(?=\s*:\s)/.source.replace(/<<prop>>/g, function() {
+                return d;
+              }).replace(/<<key>>/g, function() {
+                return "(?:" + l + "|" + f + ")";
+              })
+            ),
+            lookbehind: !0,
+            greedy: !0,
+            alias: "atrule"
+          },
+          directive: {
+            pattern: /(^[ \t]*)%.+/m,
+            lookbehind: !0,
+            alias: "important"
+          },
+          datetime: {
+            pattern: h(
+              /\d{4}-\d\d?-\d\d?(?:[tT]|[ \t]+)\d\d?:\d{2}:\d{2}(?:\.\d*)?(?:[ \t]*(?:Z|[-+]\d\d?(?::\d{2})?))?|\d{4}-\d{2}-\d{2}|\d\d?:\d{2}(?::\d{2}(?:\.\d*)?)?/.source
+            ),
+            lookbehind: !0,
+            alias: "number"
+          },
+          boolean: {
+            pattern: h(/false|true/.source, "i"),
+            lookbehind: !0,
+            alias: "important"
+          },
+          null: {
+            pattern: h(/null|~/.source, "i"),
+            lookbehind: !0,
+            alias: "important"
+          },
+          string: {
+            pattern: h(f),
+            lookbehind: !0,
+            greedy: !0
+          },
+          number: {
+            pattern: h(
+              /[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|\.inf|\.nan)/.source,
+              "i"
+            ),
+            lookbehind: !0
+          },
+          tag: u,
+          important: o,
+          punctuation: /---|[:[\]{}\-,|>?]|\.\.\./
+        }, n.languages.yml = n.languages.yaml;
+      })(a);
+    }
+  }
+}), Tt = F({
+  "../node_modules/xtend/immutable.js"(e, r) {
+    r.exports = a;
+    var t = Object.prototype.hasOwnProperty;
+    function a() {
+      for (var n = {}, o = 0; o < arguments.length; o++) {
+        var u = arguments[o];
+        for (var d in u)
+          t.call(u, d) && (n[d] = u[d]);
+      }
+      return n;
+    }
+  }
+}), nt = F({
+  "../node_modules/hastscript/node_modules/property-information/lib/util/schema.js"(e, r) {
+    r.exports = a;
+    var t = a.prototype;
+    t.space = null, t.normal = {}, t.property = {};
+    function a(n, o, u) {
+      this.property = n, this.normal = o, u && (this.space = u);
+    }
+  }
+}), Dt = F({
+  "../node_modules/hastscript/node_modules/property-information/lib/util/merge.js"(e, r) {
+    var t = Tt(), a = nt();
+    r.exports = n;
+    function n(o) {
+      for (var u = o.length, d = [], l = [], f = -1, h, C; ++f < u; )
+        h = o[f], d.push(h.property), l.push(h.normal), C = h.space;
+      return new a(
+        t.apply(null, d),
+        t.apply(null, l),
+        C
+      );
+    }
+  }
+}), Te = F({
+  "../node_modules/hastscript/node_modules/property-information/normalize.js"(e, r) {
+    r.exports = t;
+    function t(a) {
+      return a.toLowerCase();
+    }
+  }
+}), at = F({
+  "../node_modules/hastscript/node_modules/property-information/lib/util/info.js"(e, r) {
+    r.exports = a;
+    var t = a.prototype;
+    t.space = null, t.attribute = null, t.property = null, t.boolean = !1, t.booleanish = !1, t.overloadedBoolean = !1, t.number = !1, t.commaSeparated = !1, t.spaceSeparated = !1, t.commaOrSpaceSeparated = !1, t.mustUseProperty = !1, t.defined = !1;
+    function a(n, o) {
+      this.property = n, this.attribute = o;
+    }
+  }
+}), De = F({
+  "../node_modules/hastscript/node_modules/property-information/lib/util/types.js"(e) {
+    var r = 0;
+    e.boolean = t(), e.booleanish = t(), e.overloadedBoolean = t(), e.number = t(), e.spaceSeparated = t(), e.commaSeparated = t(), e.commaOrSpaceSeparated = t();
+    function t() {
+      return Math.pow(2, ++r);
+    }
+  }
+}), rt = F({
+  "../node_modules/hastscript/node_modules/property-information/lib/util/defined-info.js"(e, r) {
+    var t = at(), a = De();
+    r.exports = u, u.prototype = new t(), u.prototype.defined = !0;
+    var n = [
+      "boolean",
+      "booleanish",
+      "overloadedBoolean",
+      "number",
+      "commaSeparated",
+      "spaceSeparated",
+      "commaOrSpaceSeparated"
+    ], o = n.length;
+    function u(l, f, h, C) {
+      var x = -1, b;
+      for (d(this, "space", C), t.call(this, l, f); ++x < o; )
+        b = n[x], d(this, b, (h & a[b]) === a[b]);
+    }
+    function d(l, f, h) {
+      h && (l[f] = h);
+    }
+  }
+}), ve = F({
+  "../node_modules/hastscript/node_modules/property-information/lib/util/create.js"(e, r) {
+    var t = Te(), a = nt(), n = rt();
+    r.exports = o;
+    function o(u) {
+      var d = u.space, l = u.mustUseProperty || [], f = u.attributes || {}, h = u.properties, C = u.transform, x = {}, b = {}, y, S;
+      for (y in h)
+        S = new n(
+          y,
+          C(f, y),
+          h[y],
+          d
+        ), l.indexOf(y) !== -1 && (S.mustUseProperty = !0), x[y] = S, b[t(y)] = y, b[t(S.attribute)] = y;
+      return new a(x, b, d);
+    }
+  }
+}), Rt = F({
+  "../node_modules/hastscript/node_modules/property-information/lib/xlink.js"(e, r) {
+    var t = ve();
+    r.exports = t({
+      space: "xlink",
+      transform: a,
+      properties: {
+        xLinkActuate: null,
+        xLinkArcRole: null,
+        xLinkHref: null,
+        xLinkRole: null,
+        xLinkShow: null,
+        xLinkTitle: null,
+        xLinkType: null
+      }
+    });
+    function a(n, o) {
+      return "xlink:" + o.slice(5).toLowerCase();
+    }
+  }
+}), qt = F({
+  "../node_modules/hastscript/node_modules/property-information/lib/xml.js"(e, r) {
+    var t = ve();
+    r.exports = t({
+      space: "xml",
+      transform: a,
+      properties: {
+        xmlLang: null,
+        xmlBase: null,
+        xmlSpace: null
+      }
+    });
+    function a(n, o) {
+      return "xml:" + o.slice(3).toLowerCase();
+    }
+  }
+}), Bt = F({
+  "../node_modules/hastscript/node_modules/property-information/lib/util/case-sensitive-transform.js"(e, r) {
+    r.exports = t;
+    function t(a, n) {
+      return n in a ? a[n] : n;
+    }
+  }
+}), ot = F({
+  "../node_modules/hastscript/node_modules/property-information/lib/util/case-insensitive-transform.js"(e, r) {
+    var t = Bt();
+    r.exports = a;
+    function a(n, o) {
+      return t(n, o.toLowerCase());
+    }
+  }
+}), Mt = F({
+  "../node_modules/hastscript/node_modules/property-information/lib/xmlns.js"(e, r) {
+    var t = ve(), a = ot();
+    r.exports = t({
+      space: "xmlns",
+      attributes: {
+        xmlnsxlink: "xmlns:xlink"
+      },
+      transform: a,
+      properties: {
+        xmlns: null,
+        xmlnsXLink: null
+      }
+    });
+  }
+}), zt = F({
+  "../node_modules/hastscript/node_modules/property-information/lib/aria.js"(e, r) {
+    var t = De(), a = ve(), n = t.booleanish, o = t.number, u = t.spaceSeparated;
+    r.exports = a({
+      transform: d,
+      properties: {
+        ariaActiveDescendant: null,
+        ariaAtomic: n,
+        ariaAutoComplete: null,
+        ariaBusy: n,
+        ariaChecked: n,
+        ariaColCount: o,
+        ariaColIndex: o,
+        ariaColSpan: o,
+        ariaControls: u,
+        ariaCurrent: null,
+        ariaDescribedBy: u,
+        ariaDetails: null,
+        ariaDisabled: n,
+        ariaDropEffect: u,
+        ariaErrorMessage: null,
+        ariaExpanded: n,
+        ariaFlowTo: u,
+        ariaGrabbed: n,
+        ariaHasPopup: null,
+        ariaHidden: n,
+        ariaInvalid: null,
+        ariaKeyShortcuts: null,
+        ariaLabel: null,
+        ariaLabelledBy: u,
+        ariaLevel: o,
+        ariaLive: null,
+        ariaModal: n,
+        ariaMultiLine: n,
+        ariaMultiSelectable: n,
+        ariaOrientation: null,
+        ariaOwns: u,
+        ariaPlaceholder: null,
+        ariaPosInSet: o,
+        ariaPressed: n,
+        ariaReadOnly: n,
+        ariaRelevant: null,
+        ariaRequired: n,
+        ariaRoleDescription: u,
+        ariaRowCount: o,
+        ariaRowIndex: o,
+        ariaRowSpan: o,
+        ariaSelected: n,
+        ariaSetSize: o,
+        ariaSort: null,
+        ariaValueMax: o,
+        ariaValueMin: o,
+        ariaValueNow: o,
+        ariaValueText: null,
+        role: null
+      }
+    });
+    function d(l, f) {
+      return f === "role" ? f : "aria-" + f.slice(4).toLowerCase();
+    }
+  }
+}), Ht = F({
+  "../node_modules/hastscript/node_modules/property-information/lib/html.js"(e, r) {
+    var t = De(), a = ve(), n = ot(), o = t.boolean, u = t.overloadedBoolean, d = t.booleanish, l = t.number, f = t.spaceSeparated, h = t.commaSeparated;
+    r.exports = a({
+      space: "html",
+      attributes: {
+        acceptcharset: "accept-charset",
+        classname: "class",
+        htmlfor: "for",
+        httpequiv: "http-equiv"
+      },
+      transform: n,
+      mustUseProperty: ["checked", "multiple", "muted", "selected"],
+      properties: {
+        // Standard Properties.
+        abbr: null,
+        accept: h,
+        acceptCharset: f,
+        accessKey: f,
+        action: null,
+        allow: null,
+        allowFullScreen: o,
+        allowPaymentRequest: o,
+        allowUserMedia: o,
+        alt: null,
+        as: null,
+        async: o,
+        autoCapitalize: null,
+        autoComplete: f,
+        autoFocus: o,
+        autoPlay: o,
+        capture: o,
+        charSet: null,
+        checked: o,
+        cite: null,
+        className: f,
+        cols: l,
+        colSpan: null,
+        content: null,
+        contentEditable: d,
+        controls: o,
+        controlsList: f,
+        coords: l | h,
+        crossOrigin: null,
+        data: null,
+        dateTime: null,
+        decoding: null,
+        default: o,
+        defer: o,
+        dir: null,
+        dirName: null,
+        disabled: o,
+        download: u,
+        draggable: d,
+        encType: null,
+        enterKeyHint: null,
+        form: null,
+        formAction: null,
+        formEncType: null,
+        formMethod: null,
+        formNoValidate: o,
+        formTarget: null,
+        headers: f,
+        height: l,
+        hidden: o,
+        high: l,
+        href: null,
+        hrefLang: null,
+        htmlFor: f,
+        httpEquiv: f,
+        id: null,
+        imageSizes: null,
+        imageSrcSet: h,
+        inputMode: null,
+        integrity: null,
+        is: null,
+        isMap: o,
+        itemId: null,
+        itemProp: f,
+        itemRef: f,
+        itemScope: o,
+        itemType: f,
+        kind: null,
+        label: null,
+        lang: null,
+        language: null,
+        list: null,
+        loading: null,
+        loop: o,
+        low: l,
+        manifest: null,
+        max: null,
+        maxLength: l,
+        media: null,
+        method: null,
+        min: null,
+        minLength: l,
+        multiple: o,
+        muted: o,
+        name: null,
+        nonce: null,
+        noModule: o,
+        noValidate: o,
+        onAbort: null,
+        onAfterPrint: null,
+        onAuxClick: null,
+        onBeforePrint: null,
+        onBeforeUnload: null,
+        onBlur: null,
+        onCancel: null,
+        onCanPlay: null,
+        onCanPlayThrough: null,
+        onChange: null,
+        onClick: null,
+        onClose: null,
+        onContextMenu: null,
+        onCopy: null,
+        onCueChange: null,
+        onCut: null,
+        onDblClick: null,
+        onDrag: null,
+        onDragEnd: null,
+        onDragEnter: null,
+        onDragExit: null,
+        onDragLeave: null,
+        onDragOver: null,
+        onDragStart: null,
+        onDrop: null,
+        onDurationChange: null,
+        onEmptied: null,
+        onEnded: null,
+        onError: null,
+        onFocus: null,
+        onFormData: null,
+        onHashChange: null,
+        onInput: null,
+        onInvalid: null,
+        onKeyDown: null,
+        onKeyPress: null,
+        onKeyUp: null,
+        onLanguageChange: null,
+        onLoad: null,
+        onLoadedData: null,
+        onLoadedMetadata: null,
+        onLoadEnd: null,
+        onLoadStart: null,
+        onMessage: null,
+        onMessageError: null,
+        onMouseDown: null,
+        onMouseEnter: null,
+        onMouseLeave: null,
+        onMouseMove: null,
+        onMouseOut: null,
+        onMouseOver: null,
+        onMouseUp: null,
+        onOffline: null,
+        onOnline: null,
+        onPageHide: null,
+        onPageShow: null,
+        onPaste: null,
+        onPause: null,
+        onPlay: null,
+        onPlaying: null,
+        onPopState: null,
+        onProgress: null,
+        onRateChange: null,
+        onRejectionHandled: null,
+        onReset: null,
+        onResize: null,
+        onScroll: null,
+        onSecurityPolicyViolation: null,
+        onSeeked: null,
+        onSeeking: null,
+        onSelect: null,
+        onSlotChange: null,
+        onStalled: null,
+        onStorage: null,
+        onSubmit: null,
+        onSuspend: null,
+        onTimeUpdate: null,
+        onToggle: null,
+        onUnhandledRejection: null,
+        onUnload: null,
+        onVolumeChange: null,
+        onWaiting: null,
+        onWheel: null,
+        open: o,
+        optimum: l,
+        pattern: null,
+        ping: f,
+        placeholder: null,
+        playsInline: o,
+        poster: null,
+        preload: null,
+        readOnly: o,
+        referrerPolicy: null,
+        rel: f,
+        required: o,
+        reversed: o,
+        rows: l,
+        rowSpan: l,
+        sandbox: f,
+        scope: null,
+        scoped: o,
+        seamless: o,
+        selected: o,
+        shape: null,
+        size: l,
+        sizes: null,
+        slot: null,
+        span: l,
+        spellCheck: d,
+        src: null,
+        srcDoc: null,
+        srcLang: null,
+        srcSet: h,
+        start: l,
+        step: null,
+        style: null,
+        tabIndex: l,
+        target: null,
+        title: null,
+        translate: null,
+        type: null,
+        typeMustMatch: o,
+        useMap: null,
+        value: d,
+        width: l,
+        wrap: null,
+        // Legacy.
+        // See: https://html.spec.whatwg.org/#other-elements,-attributes-and-apis
+        align: null,
+        // Several. Use CSS `text-align` instead,
+        aLink: null,
+        // `<body>`. Use CSS `a:active {color}` instead
+        archive: f,
+        // `<object>`. List of URIs to archives
+        axis: null,
+        // `<td>` and `<th>`. Use `scope` on `<th>`
+        background: null,
+        // `<body>`. Use CSS `background-image` instead
+        bgColor: null,
+        // `<body>` and table elements. Use CSS `background-color` instead
+        border: l,
+        // `<table>`. Use CSS `border-width` instead,
+        borderColor: null,
+        // `<table>`. Use CSS `border-color` instead,
+        bottomMargin: l,
+        // `<body>`
+        cellPadding: null,
+        // `<table>`
+        cellSpacing: null,
+        // `<table>`
+        char: null,
+        // Several table elements. When `align=char`, sets the character to align on
+        charOff: null,
+        // Several table elements. When `char`, offsets the alignment
+        classId: null,
+        // `<object>`
+        clear: null,
+        // `<br>`. Use CSS `clear` instead
+        code: null,
+        // `<object>`
+        codeBase: null,
+        // `<object>`
+        codeType: null,
+        // `<object>`
+        color: null,
+        // `<font>` and `<hr>`. Use CSS instead
+        compact: o,
+        // Lists. Use CSS to reduce space between items instead
+        declare: o,
+        // `<object>`
+        event: null,
+        // `<script>`
+        face: null,
+        // `<font>`. Use CSS instead
+        frame: null,
+        // `<table>`
+        frameBorder: null,
+        // `<iframe>`. Use CSS `border` instead
+        hSpace: l,
+        // `<img>` and `<object>`
+        leftMargin: l,
+        // `<body>`
+        link: null,
+        // `<body>`. Use CSS `a:link {color: *}` instead
+        longDesc: null,
+        // `<frame>`, `<iframe>`, and `<img>`. Use an `<a>`
+        lowSrc: null,
+        // `<img>`. Use a `<picture>`
+        marginHeight: l,
+        // `<body>`
+        marginWidth: l,
+        // `<body>`
+        noResize: o,
+        // `<frame>`
+        noHref: o,
+        // `<area>`. Use no href instead of an explicit `nohref`
+        noShade: o,
+        // `<hr>`. Use background-color and height instead of borders
+        noWrap: o,
+        // `<td>` and `<th>`
+        object: null,
+        // `<applet>`
+        profile: null,
+        // `<head>`
+        prompt: null,
+        // `<isindex>`
+        rev: null,
+        // `<link>`
+        rightMargin: l,
+        // `<body>`
+        rules: null,
+        // `<table>`
+        scheme: null,
+        // `<meta>`
+        scrolling: d,
+        // `<frame>`. Use overflow in the child context
+        standby: null,
+        // `<object>`
+        summary: null,
+        // `<table>`
+        text: null,
+        // `<body>`. Use CSS `color` instead
+        topMargin: l,
+        // `<body>`
+        valueType: null,
+        // `<param>`
+        version: null,
+        // `<html>`. Use a doctype.
+        vAlign: null,
+        // Several. Use CSS `vertical-align` instead
+        vLink: null,
+        // `<body>`. Use CSS `a:visited {color}` instead
+        vSpace: l,
+        // `<img>` and `<object>`
+        // Non-standard Properties.
+        allowTransparency: null,
+        autoCorrect: null,
+        autoSave: null,
+        disablePictureInPicture: o,
+        disableRemotePlayback: o,
+        prefix: null,
+        property: null,
+        results: l,
+        security: null,
+        unselectable: null
+      }
+    });
+  }
+}), Pt = F({
+  "../node_modules/hastscript/node_modules/property-information/html.js"(e, r) {
+    var t = Dt(), a = Rt(), n = qt(), o = Mt(), u = zt(), d = Ht();
+    r.exports = t([n, a, o, u, d]);
+  }
+}), Ut = F({
+  "../node_modules/hastscript/node_modules/property-information/find.js"(e, r) {
+    var t = Te(), a = rt(), n = at(), o = "data";
+    r.exports = f;
+    var u = /^data[-\w.:]+$/i, d = /-[a-z]/g, l = /[A-Z]/g;
+    function f(y, S) {
+      var E = t(S), w = S, A = n;
+      return E in y.normal ? y.property[y.normal[E]] : (E.length > 4 && E.slice(0, 4) === o && u.test(S) && (S.charAt(4) === "-" ? w = h(S) : S = C(S), A = a), new A(w, S));
+    }
+    function h(y) {
+      var S = y.slice(5).replace(d, b);
+      return o + S.charAt(0).toUpperCase() + S.slice(1);
+    }
+    function C(y) {
+      var S = y.slice(4);
+      return d.test(S) ? y : (S = S.replace(l, x), S.charAt(0) !== "-" && (S = "-" + S), o + S);
+    }
+    function x(y) {
+      return "-" + y.toLowerCase();
+    }
+    function b(y) {
+      return y.charAt(1).toUpperCase();
+    }
+  }
+}), Gt = F({
+  "../node_modules/hast-util-parse-selector/index.js"(e, r) {
+    r.exports = a;
+    var t = /[#.]/g;
+    function a(n, o) {
+      for (var u = n || "", d = o || "div", l = {}, f = 0, h, C, x; f < u.length; )
+        t.lastIndex = f, x = t.exec(u), h = u.slice(f, x ? x.index : u.length), h && (C ? C === "#" ? l.id = h : l.className ? l.className.push(h) : l.className = [h] : d = h, f += h.length), x && (C = x[0], f++);
+      return { type: "element", tagName: d, properties: l, children: [] };
+    }
+  }
+}), Zt = F({
+  "../node_modules/hastscript/node_modules/space-separated-tokens/index.js"(e) {
+    e.parse = n, e.stringify = o;
+    var r = "", t = " ", a = /[ \t\n\r\f]+/g;
+    function n(u) {
+      var d = String(u || r).trim();
+      return d === r ? [] : d.split(a);
+    }
+    function o(u) {
+      return u.join(t).trim();
+    }
+  }
+}), Wt = F({
+  "../node_modules/hastscript/node_modules/comma-separated-tokens/index.js"(e) {
+    e.parse = n, e.stringify = o;
+    var r = ",", t = " ", a = "";
+    function n(u) {
+      for (var d = [], l = String(u || a), f = l.indexOf(r), h = 0, C = !1, x; !C; )
+        f === -1 && (f = l.length, C = !0), x = l.slice(h, f).trim(), (x || !C) && d.push(x), h = f + 1, f = l.indexOf(r, h);
+      return d;
+    }
+    function o(u, d) {
+      var l = d || {}, f = l.padLeft === !1 ? a : t, h = l.padRight ? t : a;
+      return u[u.length - 1] === a && (u = u.concat(a)), u.join(h + r + f).trim();
+    }
+  }
+}), Kt = F({
+  "../node_modules/hastscript/factory.js"(e, r) {
+    var t = Ut(), a = Te(), n = Gt(), o = Zt().parse, u = Wt().parse;
+    r.exports = l;
+    var d = {}.hasOwnProperty;
+    function l(E, w, A) {
+      var i = A ? S(A) : null;
+      return s;
+      function s(g, m) {
+        var c = n(g, w), _ = Array.prototype.slice.call(arguments, 2), v = c.tagName.toLowerCase(), k;
+        if (c.tagName = i && d.call(i, v) ? i[v] : v, m && f(m, c) && (_.unshift(m), m = null), m)
+          for (k in m)
+            p(c.properties, k, m[k]);
+        return C(c.children, _), c.tagName === "template" && (c.content = { type: "root", children: c.children }, c.children = []), c;
+      }
+      function p(g, m, c) {
+        var _, v, k;
+        c == null || c !== c || (_ = t(E, m), v = _.property, k = c, typeof k == "string" && (_.spaceSeparated ? k = o(k) : _.commaSeparated ? k = u(k) : _.commaOrSpaceSeparated && (k = o(u(k).join(" ")))), v === "style" && typeof c != "string" && (k = y(k)), v === "className" && g.className && (k = g.className.concat(k)), g[v] = x(_, v, k));
+      }
+    }
+    function f(E, w) {
+      return typeof E == "string" || "length" in E || h(w.tagName, E);
+    }
+    function h(E, w) {
+      var A = w.type;
+      return E === "input" || !A || typeof A != "string" ? !1 : typeof w.children == "object" && "length" in w.children ? !0 : (A = A.toLowerCase(), E === "button" ? A !== "menu" && A !== "submit" && A !== "reset" && A !== "button" : "value" in w);
+    }
+    function C(E, w) {
+      var A, i;
+      if (typeof w == "string" || typeof w == "number") {
+        E.push({ type: "text", value: String(w) });
+        return;
+      }
+      if (typeof w == "object" && "length" in w) {
+        for (A = -1, i = w.length; ++A < i; )
+          C(E, w[A]);
+        return;
+      }
+      if (typeof w != "object" || !("type" in w))
+        throw new Error("Expected node, nodes, or string, got `" + w + "`");
+      E.push(w);
+    }
+    function x(E, w, A) {
+      var i, s, p;
+      if (typeof A != "object" || !("length" in A))
+        return b(E, w, A);
+      for (s = A.length, i = -1, p = []; ++i < s; )
+        p[i] = b(E, w, A[i]);
+      return p;
+    }
+    function b(E, w, A) {
+      var i = A;
+      return E.number || E.positiveNumber ? !isNaN(i) && i !== "" && (i = Number(i)) : (E.boolean || E.overloadedBoolean) && typeof i == "string" && (i === "" || a(A) === a(w)) && (i = !0), i;
+    }
+    function y(E) {
+      var w = [], A;
+      for (A in E)
+        w.push([A, E[A]].join(": "));
+      return w.join("; ");
+    }
+    function S(E) {
+      for (var w = E.length, A = -1, i = {}, s; ++A < w; )
+        s = E[A], i[s.toLowerCase()] = s;
+      return i;
+    }
+  }
+}), Xt = F({
+  "../node_modules/hastscript/html.js"(e, r) {
+    var t = Pt(), a = Kt(), n = a(t, "div");
+    n.displayName = "html", r.exports = n;
+  }
+}), Vt = F({
+  "../node_modules/hastscript/index.js"(e, r) {
+    r.exports = Xt();
+  }
+}), Yt = F({
+  "../node_modules/refractor/node_modules/character-entities-legacy/index.json"(e, r) {
+    r.exports = {
+      AElig: "Æ",
+      AMP: "&",
+      Aacute: "Á",
+      Acirc: "Â",
+      Agrave: "À",
+      Aring: "Å",
+      Atilde: "Ã",
+      Auml: "Ä",
+      COPY: "©",
+      Ccedil: "Ç",
+      ETH: "Ð",
+      Eacute: "É",
+      Ecirc: "Ê",
+      Egrave: "È",
+      Euml: "Ë",
+      GT: ">",
+      Iacute: "Í",
+      Icirc: "Î",
+      Igrave: "Ì",
+      Iuml: "Ï",
+      LT: "<",
+      Ntilde: "Ñ",
+      Oacute: "Ó",
+      Ocirc: "Ô",
+      Ograve: "Ò",
+      Oslash: "Ø",
+      Otilde: "Õ",
+      Ouml: "Ö",
+      QUOT: '"',
+      REG: "®",
+      THORN: "Þ",
+      Uacute: "Ú",
+      Ucirc: "Û",
+      Ugrave: "Ù",
+      Uuml: "Ü",
+      Yacute: "Ý",
+      aacute: "á",
+      acirc: "â",
+      acute: "´",
+      aelig: "æ",
+      agrave: "à",
+      amp: "&",
+      aring: "å",
+      atilde: "ã",
+      auml: "ä",
+      brvbar: "¦",
+      ccedil: "ç",
+      cedil: "¸",
+      cent: "¢",
+      copy: "©",
+      curren: "¤",
+      deg: "°",
+      divide: "÷",
+      eacute: "é",
+      ecirc: "ê",
+      egrave: "è",
+      eth: "ð",
+      euml: "ë",
+      frac12: "½",
+      frac14: "¼",
+      frac34: "¾",
+      gt: ">",
+      iacute: "í",
+      icirc: "î",
+      iexcl: "¡",
+      igrave: "ì",
+      iquest: "¿",
+      iuml: "ï",
+      laquo: "«",
+      lt: "<",
+      macr: "¯",
+      micro: "µ",
+      middot: "·",
+      nbsp: " ",
+      not: "¬",
+      ntilde: "ñ",
+      oacute: "ó",
+      ocirc: "ô",
+      ograve: "ò",
+      ordf: "ª",
+      ordm: "º",
+      oslash: "ø",
+      otilde: "õ",
+      ouml: "ö",
+      para: "¶",
+      plusmn: "±",
+      pound: "£",
+      quot: '"',
+      raquo: "»",
+      reg: "®",
+      sect: "§",
+      shy: "­",
+      sup1: "¹",
+      sup2: "²",
+      sup3: "³",
+      szlig: "ß",
+      thorn: "þ",
+      times: "×",
+      uacute: "ú",
+      ucirc: "û",
+      ugrave: "ù",
+      uml: "¨",
+      uuml: "ü",
+      yacute: "ý",
+      yen: "¥",
+      yuml: "ÿ"
+    };
+  }
+}), Jt = F({
+  "../node_modules/refractor/node_modules/character-reference-invalid/index.json"(e, r) {
+    r.exports = {
+      0: "�",
+      128: "€",
+      130: "‚",
+      131: "ƒ",
+      132: "„",
+      133: "…",
+      134: "†",
+      135: "‡",
+      136: "ˆ",
+      137: "‰",
+      138: "Š",
+      139: "‹",
+      140: "Œ",
+      142: "Ž",
+      145: "‘",
+      146: "’",
+      147: "“",
+      148: "”",
+      149: "•",
+      150: "–",
+      151: "—",
+      152: "˜",
+      153: "™",
+      154: "š",
+      155: "›",
+      156: "œ",
+      158: "ž",
+      159: "Ÿ"
+    };
+  }
+}), lt = F({
+  "../node_modules/refractor/node_modules/is-decimal/index.js"(e, r) {
+    r.exports = t;
+    function t(a) {
+      var n = typeof a == "string" ? a.charCodeAt(0) : a;
+      return n >= 48 && n <= 57;
+    }
+  }
+}), Qt = F({
+  "../node_modules/refractor/node_modules/is-hexadecimal/index.js"(e, r) {
+    r.exports = t;
+    function t(a) {
+      var n = typeof a == "string" ? a.charCodeAt(0) : a;
+      return n >= 97 && n <= 102 || n >= 65 && n <= 70 || n >= 48 && n <= 57;
+    }
+  }
+}), en = F({
+  "../node_modules/refractor/node_modules/is-alphabetical/index.js"(e, r) {
+    r.exports = t;
+    function t(a) {
+      var n = typeof a == "string" ? a.charCodeAt(0) : a;
+      return n >= 97 && n <= 122 || n >= 65 && n <= 90;
+    }
+  }
+}), tn = F({
+  "../node_modules/refractor/node_modules/is-alphanumerical/index.js"(e, r) {
+    var t = en(), a = lt();
+    r.exports = n;
+    function n(o) {
+      return t(o) || a(o);
+    }
+  }
+}), nn = F({
+  "../node_modules/refractor/node_modules/parse-entities/decode-entity.browser.js"(e, r) {
+    var t, a = 59;
+    r.exports = n;
+    function n(o) {
+      var u = "&" + o + ";", d;
+      return t = t || document.createElement("i"), t.innerHTML = u, d = t.textContent, d.charCodeAt(d.length - 1) === a && o !== "semi" || d === u ? !1 : d;
+    }
+  }
+}), an = F({
+  "../node_modules/refractor/node_modules/parse-entities/index.js"(e, r) {
+    var t = Yt(), a = Jt(), n = lt(), o = Qt(), u = tn(), d = nn();
+    r.exports = B;
+    var l = {}.hasOwnProperty, f = String.fromCharCode, h = Function.prototype, C = {
+      warning: null,
+      reference: null,
+      text: null,
+      warningContext: null,
+      referenceContext: null,
+      textContext: null,
+      position: {},
+      additional: null,
+      attribute: !1,
+      nonTerminated: !0
+    }, x = 9, b = 10, y = 12, S = 32, E = 38, w = 59, A = 60, i = 61, s = 35, p = 88, g = 120, m = 65533, c = "named", _ = "hexadecimal", v = "decimal", k = {};
+    k[_] = 16, k[v] = 10;
+    var N = {};
+    N[c] = u, N[v] = n, N[_] = o;
+    var $ = 1, H = 2, z = 3, X = 4, J = 5, W = 6, O = 7, L = {};
+    L[$] = "Named character references must be terminated by a semicolon", L[H] = "Numeric character references must be terminated by a semicolon", L[z] = "Named character references cannot be empty", L[X] = "Numeric character references cannot be empty", L[J] = "Named character references must be known", L[W] = "Numeric character references cannot be disallowed", L[O] = "Numeric character references cannot be outside the permissible Unicode range";
+    function B(j, I) {
+      var T = {}, K, P;
+      I || (I = {});
+      for (P in C)
+        K = I[P], T[P] = K ?? C[P];
+      return (T.position.indent || T.position.start) && (T.indent = T.position.indent || [], T.position = T.position.start), Q(j, T);
+    }
+    function Q(j, I) {
+      var T = I.additional, K = I.nonTerminated, P = I.text, re = I.reference, pe = I.warning, de = I.textContext, Ee = I.referenceContext, me = I.warningContext, ke = I.position, gt = I.indent || [], Ce = j.length, te = 0, ze = -1, oe = ke.column || 1, He = ke.line || 1, le = "", Fe = [], ge, je, ie, U, ne, R, D, V, Se, Ne, se, he, ue, ee, Pe, ye, we, Y, q;
+      for (typeof T == "string" && (T = T.charCodeAt(0)), ye = be(), V = pe ? ft : h, te--, Ce++; ++te < Ce; )
+        if (ne === b && (oe = gt[ze] || 1), ne = j.charCodeAt(te), ne === E) {
+          if (D = j.charCodeAt(te + 1), D === x || D === b || D === y || D === S || D === E || D === A || D !== D || T && D === T) {
+            le += f(ne), oe++;
+            continue;
+          }
+          for (ue = te + 1, he = ue, q = ue, D === s ? (q = ++he, D = j.charCodeAt(q), D === p || D === g ? (ee = _, q = ++he) : ee = v) : ee = c, ge = "", se = "", U = "", Pe = N[ee], q--; ++q < Ce && (D = j.charCodeAt(q), !!Pe(D)); )
+            U += f(D), ee === c && l.call(t, U) && (ge = U, se = t[U]);
+          ie = j.charCodeAt(q) === w, ie && (q++, je = ee === c ? d(U) : !1, je && (ge = U, se = je)), Y = 1 + q - ue, !ie && !K || (U ? ee === c ? (ie && !se ? V(J, 1) : (ge !== U && (q = he + ge.length, Y = 1 + q - he, ie = !1), ie || (Se = ge ? $ : z, I.attribute ? (D = j.charCodeAt(q), D === i ? (V(Se, Y), se = null) : u(D) ? se = null : V(Se, Y)) : V(Se, Y))), R = se) : (ie || V(H, Y), R = parseInt(U, k[ee]), M(R) ? (V(O, Y), R = f(m)) : R in a ? (V(W, Y), R = a[R]) : (Ne = "", ce(R) && V(W, Y), R > 65535 && (R -= 65536, Ne += f(R >>> 10 | 55296), R = 56320 | R & 1023), R = Ne + f(R))) : ee !== c && V(X, Y)), R ? (Ue(), ye = be(), te = q - 1, oe += q - ue + 1, Fe.push(R), we = be(), we.offset++, re && re.call(
+            Ee,
+            R,
+            { start: ye, end: we },
+            j.slice(ue - 1, q)
+          ), ye = we) : (U = j.slice(ue - 1, q), le += U, oe += U.length, te = q - 1);
+        } else
+          ne === 10 && (He++, ze++, oe = 0), ne === ne ? (le += f(ne), oe++) : Ue();
+      return Fe.join("");
+      function be() {
+        return {
+          line: He,
+          column: oe,
+          offset: te + (ke.offset || 0)
+        };
+      }
+      function ft(Ge, Ze) {
+        var $e = be();
+        $e.column += Ze, $e.offset += Ze, pe.call(me, L[Ge], $e, Ge);
+      }
+      function Ue() {
+        le && (Fe.push(le), P && P.call(de, le, { start: ye, end: be() }), le = "");
+      }
+    }
+    function M(j) {
+      return j >= 55296 && j <= 57343 || j > 1114111;
+    }
+    function ce(j) {
+      return j >= 1 && j <= 8 || j === 11 || j >= 13 && j <= 31 || j >= 127 && j <= 159 || j >= 64976 && j <= 65007 || (j & 65535) === 65535 || (j & 65535) === 65534;
+    }
+  }
+}), rn = F({
+  "../node_modules/refractor/node_modules/prismjs/components/prism-core.js"(e, r) {
+    var t = typeof window < "u" ? window : typeof WorkerGlobalScope < "u" && self instanceof WorkerGlobalScope ? self : {}, a = (function(n) {
+      var o = /(?:^|\s)lang(?:uage)?-([\w-]+)(?=\s|$)/i, u = 0, d = {}, l = {
+        /**
+         * By default, Prism will attempt to highlight all code elements (by calling {@link Prism.highlightAll}) on the
+         * current page after the page finished loading. This might be a problem if e.g. you wanted to asynchronously load
+         * additional languages or plugins yourself.
+         *
+         * By setting this value to `true`, Prism will not automatically highlight all code elements on the page.
+         *
+         * You obviously have to change this value before the automatic highlighting started. To do this, you can add an
+         * empty Prism object into the global scope before loading the Prism script like this:
+         *
+         * ```js
+         * window.Prism = window.Prism || {};
+         * Prism.manual = true;
+         * // add a new <script> to load Prism's script
+         * ```
+         *
+         * @default false
+         * @type {boolean}
+         * @memberof Prism
+         * @public
+         */
+        manual: n.Prism && n.Prism.manual,
+        /**
+         * By default, if Prism is in a web worker, it assumes that it is in a worker it created itself, so it uses
+         * `addEventListener` to communicate with its parent instance. However, if you're using Prism manually in your
+         * own worker, you don't want it to do this.
+         *
+         * By setting this value to `true`, Prism will not add its own listeners to the worker.
+         *
+         * You obviously have to change this value before Prism executes. To do this, you can add an
+         * empty Prism object into the global scope before loading the Prism script like this:
+         *
+         * ```js
+         * window.Prism = window.Prism || {};
+         * Prism.disableWorkerMessageHandler = true;
+         * // Load Prism's script
+         * ```
+         *
+         * @default false
+         * @type {boolean}
+         * @memberof Prism
+         * @public
+         */
+        disableWorkerMessageHandler: n.Prism && n.Prism.disableWorkerMessageHandler,
+        /**
+         * A namespace for utility methods.
+         *
+         * All function in this namespace that are not explicitly marked as _public_ are for __internal use only__ and may
+         * change or disappear at any time.
+         *
+         * @namespace
+         * @memberof Prism
+         */
+        util: {
+          encode: function i(s) {
+            return s instanceof f ? new f(s.type, i(s.content), s.alias) : Array.isArray(s) ? s.map(i) : s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/\u00a0/g, " ");
+          },
+          /**
+           * Returns the name of the type of the given value.
+           *
+           * @param {any} o
+           * @returns {string}
+           * @example
+           * type(null)      === 'Null'
+           * type(undefined) === 'Undefined'
+           * type(123)       === 'Number'
+           * type('foo')     === 'String'
+           * type(true)      === 'Boolean'
+           * type([1, 2])    === 'Array'
+           * type({})        === 'Object'
+           * type(String)    === 'Function'
+           * type(/abc+/)    === 'RegExp'
+           */
+          type: function(i) {
+            return Object.prototype.toString.call(i).slice(8, -1);
+          },
+          /**
+           * Returns a unique number for the given object. Later calls will still return the same number.
+           *
+           * @param {Object} obj
+           * @returns {number}
+           */
+          objId: function(i) {
+            return i.__id || Object.defineProperty(i, "__id", { value: ++u }), i.__id;
+          },
+          /**
+           * Creates a deep clone of the given object.
+           *
+           * The main intended use of this function is to clone language definitions.
+           *
+           * @param {T} o
+           * @param {Record<number, any>} [visited]
+           * @returns {T}
+           * @template T
+           */
+          clone: function i(s, p) {
+            p = p || {};
+            var g, m;
+            switch (l.util.type(s)) {
+              case "Object":
+                if (m = l.util.objId(s), p[m])
+                  return p[m];
+                g = /** @type {Record<string, any>} */
+                {}, p[m] = g;
+                for (var c in s)
+                  s.hasOwnProperty(c) && (g[c] = i(s[c], p));
+                return (
+                  /** @type {any} */
+                  g
+                );
+              case "Array":
+                return m = l.util.objId(s), p[m] ? p[m] : (g = [], p[m] = g, /** @type {Array} */
+                /** @type {any} */
+                s.forEach(function(_, v) {
+                  g[v] = i(_, p);
+                }), /** @type {any} */
+                g);
+              default:
+                return s;
+            }
+          },
+          /**
+           * Returns the Prism language of the given element set by a `language-xxxx` or `lang-xxxx` class.
+           *
+           * If no language is set for the element or the element is `null` or `undefined`, `none` will be returned.
+           *
+           * @param {Element} element
+           * @returns {string}
+           */
+          getLanguage: function(i) {
+            for (; i; ) {
+              var s = o.exec(i.className);
+              if (s)
+                return s[1].toLowerCase();
+              i = i.parentElement;
+            }
+            return "none";
+          },
+          /**
+           * Sets the Prism `language-xxxx` class of the given element.
+           *
+           * @param {Element} element
+           * @param {string} language
+           * @returns {void}
+           */
+          setLanguage: function(i, s) {
+            i.className = i.className.replace(RegExp(o, "gi"), ""), i.classList.add("language-" + s);
+          },
+          /**
+           * Returns the script element that is currently executing.
+           *
+           * This does __not__ work for line script element.
+           *
+           * @returns {HTMLScriptElement | null}
+           */
+          currentScript: function() {
+            if (typeof document > "u")
+              return null;
+            if ("currentScript" in document)
+              return (
+                /** @type {any} */
+                document.currentScript
+              );
+            try {
+              throw new Error();
+            } catch (g) {
+              var i = (/at [^(\r\n]*\((.*):[^:]+:[^:]+\)$/i.exec(g.stack) || [])[1];
+              if (i) {
+                var s = document.getElementsByTagName("script");
+                for (var p in s)
+                  if (s[p].src == i)
+                    return s[p];
+              }
+              return null;
+            }
+          },
+          /**
+           * Returns whether a given class is active for `element`.
+           *
+           * The class can be activated if `element` or one of its ancestors has the given class and it can be deactivated
+           * if `element` or one of its ancestors has the negated version of the given class. The _negated version_ of the
+           * given class is just the given class with a `no-` prefix.
+           *
+           * Whether the class is active is determined by the closest ancestor of `element` (where `element` itself is
+           * closest ancestor) that has the given class or the negated version of it. If neither `element` nor any of its
+           * ancestors have the given class or the negated version of it, then the default activation will be returned.
+           *
+           * In the paradoxical situation where the closest ancestor contains __both__ the given class and the negated
+           * version of it, the class is considered active.
+           *
+           * @param {Element} element
+           * @param {string} className
+           * @param {boolean} [defaultActivation=false]
+           * @returns {boolean}
+           */
+          isActive: function(i, s, p) {
+            for (var g = "no-" + s; i; ) {
+              var m = i.classList;
+              if (m.contains(s))
+                return !0;
+              if (m.contains(g))
+                return !1;
+              i = i.parentElement;
+            }
+            return !!p;
+          }
+        },
+        /**
+         * This namespace contains all currently loaded languages and the some helper functions to create and modify languages.
+         *
+         * @namespace
+         * @memberof Prism
+         * @public
+         */
+        languages: {
+          /**
+           * The grammar for plain, unformatted text.
+           */
+          plain: d,
+          plaintext: d,
+          text: d,
+          txt: d,
+          /**
+           * Creates a deep copy of the language with the given id and appends the given tokens.
+           *
+           * If a token in `redef` also appears in the copied language, then the existing token in the copied language
+           * will be overwritten at its original position.
+           *
+           * ## Best practices
+           *
+           * Since the position of overwriting tokens (token in `redef` that overwrite tokens in the copied language)
+           * doesn't matter, they can technically be in any order. However, this can be confusing to others that trying to
+           * understand the language definition because, normally, the order of tokens matters in Prism grammars.
+           *
+           * Therefore, it is encouraged to order overwriting tokens according to the positions of the overwritten tokens.
+           * Furthermore, all non-overwriting tokens should be placed after the overwriting ones.
+           *
+           * @param {string} id The id of the language to extend. This has to be a key in `Prism.languages`.
+           * @param {Grammar} redef The new tokens to append.
+           * @returns {Grammar} The new language created.
+           * @public
+           * @example
+           * Prism.languages['css-with-colors'] = Prism.languages.extend('css', {
+           *     // Prism.languages.css already has a 'comment' token, so this token will overwrite CSS' 'comment' token
+           *     // at its original position
+           *     'comment': { ... },
+           *     // CSS doesn't have a 'color' token, so this token will be appended
+           *     'color': /\b(?:red|green|blue)\b/
+           * });
+           */
+          extend: function(i, s) {
+            var p = l.util.clone(l.languages[i]);
+            for (var g in s)
+              p[g] = s[g];
+            return p;
+          },
+          /**
+           * Inserts tokens _before_ another token in a language definition or any other grammar.
+           *
+           * ## Usage
+           *
+           * This helper method makes it easy to modify existing languages. For example, the CSS language definition
+           * not only defines CSS highlighting for CSS documents, but also needs to define highlighting for CSS embedded
+           * in HTML through `<style>` elements. To do this, it needs to modify `Prism.languages.markup` and add the
+           * appropriate tokens. However, `Prism.languages.markup` is a regular JavaScript object literal, so if you do
+           * this:
+           *
+           * ```js
+           * Prism.languages.markup.style = {
+           *     // token
+           * };
+           * ```
+           *
+           * then the `style` token will be added (and processed) at the end. `insertBefore` allows you to insert tokens
+           * before existing tokens. For the CSS example above, you would use it like this:
+           *
+           * ```js
+           * Prism.languages.insertBefore('markup', 'cdata', {
+           *     'style': {
+           *         // token
+           *     }
+           * });
+           * ```
+           *
+           * ## Special cases
+           *
+           * If the grammars of `inside` and `insert` have tokens with the same name, the tokens in `inside`'s grammar
+           * will be ignored.
+           *
+           * This behavior can be used to insert tokens after `before`:
+           *
+           * ```js
+           * Prism.languages.insertBefore('markup', 'comment', {
+           *     'comment': Prism.languages.markup.comment,
+           *     // tokens after 'comment'
+           * });
+           * ```
+           *
+           * ## Limitations
+           *
+           * The main problem `insertBefore` has to solve is iteration order. Since ES2015, the iteration order for object
+           * properties is guaranteed to be the insertion order (except for integer keys) but some browsers behave
+           * differently when keys are deleted and re-inserted. So `insertBefore` can't be implemented by temporarily
+           * deleting properties which is necessary to insert at arbitrary positions.
+           *
+           * To solve this problem, `insertBefore` doesn't actually insert the given tokens into the target object.
+           * Instead, it will create a new object and replace all references to the target object with the new one. This
+           * can be done without temporarily deleting properties, so the iteration order is well-defined.
+           *
+           * However, only references that can be reached from `Prism.languages` or `insert` will be replaced. I.e. if
+           * you hold the target object in a variable, then the value of the variable will not change.
+           *
+           * ```js
+           * var oldMarkup = Prism.languages.markup;
+           * var newMarkup = Prism.languages.insertBefore('markup', 'comment', { ... });
+           *
+           * assert(oldMarkup !== Prism.languages.markup);
+           * assert(newMarkup === Prism.languages.markup);
+           * ```
+           *
+           * @param {string} inside The property of `root` (e.g. a language id in `Prism.languages`) that contains the
+           * object to be modified.
+           * @param {string} before The key to insert before.
+           * @param {Grammar} insert An object containing the key-value pairs to be inserted.
+           * @param {Object<string, any>} [root] The object containing `inside`, i.e. the object that contains the
+           * object to be modified.
+           *
+           * Defaults to `Prism.languages`.
+           * @returns {Grammar} The new grammar object.
+           * @public
+           */
+          insertBefore: function(i, s, p, g) {
+            g = g || /** @type {any} */
+            l.languages;
+            var m = g[i], c = {};
+            for (var _ in m)
+              if (m.hasOwnProperty(_)) {
+                if (_ == s)
+                  for (var v in p)
+                    p.hasOwnProperty(v) && (c[v] = p[v]);
+                p.hasOwnProperty(_) || (c[_] = m[_]);
+              }
+            var k = g[i];
+            return g[i] = c, l.languages.DFS(l.languages, function(N, $) {
+              $ === k && N != i && (this[N] = c);
+            }), c;
+          },
+          // Traverse a language definition with Depth First Search
+          DFS: function i(s, p, g, m) {
+            m = m || {};
+            var c = l.util.objId;
+            for (var _ in s)
+              if (s.hasOwnProperty(_)) {
+                p.call(s, _, s[_], g || _);
+                var v = s[_], k = l.util.type(v);
+                k === "Object" && !m[c(v)] ? (m[c(v)] = !0, i(v, p, null, m)) : k === "Array" && !m[c(v)] && (m[c(v)] = !0, i(v, p, _, m));
+              }
+          }
+        },
+        plugins: {},
+        /**
+         * This is the most high-level function in Prism’s API.
+         * It fetches all the elements that have a `.language-xxxx` class and then calls {@link Prism.highlightElement} on
+         * each one of them.
+         *
+         * This is equivalent to `Prism.highlightAllUnder(document, async, callback)`.
+         *
+         * @param {boolean} [async=false] Same as in {@link Prism.highlightAllUnder}.
+         * @param {HighlightCallback} [callback] Same as in {@link Prism.highlightAllUnder}.
+         * @memberof Prism
+         * @public
+         */
+        highlightAll: function(i, s) {
+          l.highlightAllUnder(document, i, s);
+        },
+        /**
+         * Fetches all the descendants of `container` that have a `.language-xxxx` class and then calls
+         * {@link Prism.highlightElement} on each one of them.
+         *
+         * The following hooks will be run:
+         * 1. `before-highlightall`
+         * 2. `before-all-elements-highlight`
+         * 3. All hooks of {@link Prism.highlightElement} for each element.
+         *
+         * @param {ParentNode} container The root element, whose descendants that have a `.language-xxxx` class will be highlighted.
+         * @param {boolean} [async=false] Whether each element is to be highlighted asynchronously using Web Workers.
+         * @param {HighlightCallback} [callback] An optional callback to be invoked on each element after its highlighting is done.
+         * @memberof Prism
+         * @public
+         */
+        highlightAllUnder: function(i, s, p) {
+          var g = {
+            callback: p,
+            container: i,
+            selector: 'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'
+          };
+          l.hooks.run("before-highlightall", g), g.elements = Array.prototype.slice.apply(g.container.querySelectorAll(g.selector)), l.hooks.run("before-all-elements-highlight", g);
+          for (var m = 0, c; c = g.elements[m++]; )
+            l.highlightElement(c, s === !0, g.callback);
+        },
+        /**
+         * Highlights the code inside a single element.
+         *
+         * The following hooks will be run:
+         * 1. `before-sanity-check`
+         * 2. `before-highlight`
+         * 3. All hooks of {@link Prism.highlight}. These hooks will be run by an asynchronous worker if `async` is `true`.
+         * 4. `before-insert`
+         * 5. `after-highlight`
+         * 6. `complete`
+         *
+         * Some the above hooks will be skipped if the element doesn't contain any text or there is no grammar loaded for
+         * the element's language.
+         *
+         * @param {Element} element The element containing the code.
+         * It must have a class of `language-xxxx` to be processed, where `xxxx` is a valid language identifier.
+         * @param {boolean} [async=false] Whether the element is to be highlighted asynchronously using Web Workers
+         * to improve performance and avoid blocking the UI when highlighting very large chunks of code. This option is
+         * [disabled by default](https://prismjs.com/faq.html#why-is-asynchronous-highlighting-disabled-by-default).
+         *
+         * Note: All language definitions required to highlight the code must be included in the main `prism.js` file for
+         * asynchronous highlighting to work. You can build your own bundle on the
+         * [Download page](https://prismjs.com/download.html).
+         * @param {HighlightCallback} [callback] An optional callback to be invoked after the highlighting is done.
+         * Mostly useful when `async` is `true`, since in that case, the highlighting is done asynchronously.
+         * @memberof Prism
+         * @public
+         */
+        highlightElement: function(i, s, p) {
+          var g = l.util.getLanguage(i), m = l.languages[g];
+          l.util.setLanguage(i, g);
+          var c = i.parentElement;
+          c && c.nodeName.toLowerCase() === "pre" && l.util.setLanguage(c, g);
+          var _ = i.textContent, v = {
+            element: i,
+            language: g,
+            grammar: m,
+            code: _
+          };
+          function k($) {
+            v.highlightedCode = $, l.hooks.run("before-insert", v), v.element.innerHTML = v.highlightedCode, l.hooks.run("after-highlight", v), l.hooks.run("complete", v), p && p.call(v.element);
+          }
+          if (l.hooks.run("before-sanity-check", v), c = v.element.parentElement, c && c.nodeName.toLowerCase() === "pre" && !c.hasAttribute("tabindex") && c.setAttribute("tabindex", "0"), !v.code) {
+            l.hooks.run("complete", v), p && p.call(v.element);
+            return;
+          }
+          if (l.hooks.run("before-highlight", v), !v.grammar) {
+            k(l.util.encode(v.code));
+            return;
+          }
+          if (s && n.Worker) {
+            var N = new Worker(l.filename);
+            N.onmessage = function($) {
+              k($.data);
+            }, N.postMessage(JSON.stringify({
+              language: v.language,
+              code: v.code,
+              immediateClose: !0
+            }));
+          } else
+            k(l.highlight(v.code, v.grammar, v.language));
+        },
+        /**
+         * Low-level function, only use if you know what you’re doing. It accepts a string of text as input
+         * and the language definitions to use, and returns a string with the HTML produced.
+         *
+         * The following hooks will be run:
+         * 1. `before-tokenize`
+         * 2. `after-tokenize`
+         * 3. `wrap`: On each {@link Token}.
+         *
+         * @param {string} text A string with the code to be highlighted.
+         * @param {Grammar} grammar An object containing the tokens to use.
+         *
+         * Usually a language definition like `Prism.languages.markup`.
+         * @param {string} language The name of the language definition passed to `grammar`.
+         * @returns {string} The highlighted HTML.
+         * @memberof Prism
+         * @public
+         * @example
+         * Prism.highlight('var foo = true;', Prism.languages.javascript, 'javascript');
+         */
+        highlight: function(i, s, p) {
+          var g = {
+            code: i,
+            grammar: s,
+            language: p
+          };
+          if (l.hooks.run("before-tokenize", g), !g.grammar)
+            throw new Error('The language "' + g.language + '" has no grammar.');
+          return g.tokens = l.tokenize(g.code, g.grammar), l.hooks.run("after-tokenize", g), f.stringify(l.util.encode(g.tokens), g.language);
+        },
+        /**
+         * This is the heart of Prism, and the most low-level function you can use. It accepts a string of text as input
+         * and the language definitions to use, and returns an array with the tokenized code.
+         *
+         * When the language definition includes nested tokens, the function is called recursively on each of these tokens.
+         *
+         * This method could be useful in other contexts as well, as a very crude parser.
+         *
+         * @param {string} text A string with the code to be highlighted.
+         * @param {Grammar} grammar An object containing the tokens to use.
+         *
+         * Usually a language definition like `Prism.languages.markup`.
+         * @returns {TokenStream} An array of strings and tokens, a token stream.
+         * @memberof Prism
+         * @public
+         * @example
+         * let code = `var foo = 0;`;
+         * let tokens = Prism.tokenize(code, Prism.languages.javascript);
+         * tokens.forEach(token => {
+         *     if (token instanceof Prism.Token && token.type === 'number') {
+         *         console.log(`Found numeric literal: ${token.content}`);
+         *     }
+         * });
+         */
+        tokenize: function(i, s) {
+          var p = s.rest;
+          if (p) {
+            for (var g in p)
+              s[g] = p[g];
+            delete s.rest;
+          }
+          var m = new x();
+          return b(m, m.head, i), C(i, m, s, m.head, 0), S(m);
+        },
+        /**
+         * @namespace
+         * @memberof Prism
+         * @public
+         */
+        hooks: {
+          all: {},
+          /**
+           * Adds the given callback to the list of callbacks for the given hook.
+           *
+           * The callback will be invoked when the hook it is registered for is run.
+           * Hooks are usually directly run by a highlight function but you can also run hooks yourself.
+           *
+           * One callback function can be registered to multiple hooks and the same hook multiple times.
+           *
+           * @param {string} name The name of the hook.
+           * @param {HookCallback} callback The callback function which is given environment variables.
+           * @public
+           */
+          add: function(i, s) {
+            var p = l.hooks.all;
+            p[i] = p[i] || [], p[i].push(s);
+          },
+          /**
+           * Runs a hook invoking all registered callbacks with the given environment variables.
+           *
+           * Callbacks will be invoked synchronously and in the order in which they were registered.
+           *
+           * @param {string} name The name of the hook.
+           * @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.
+           * @public
+           */
+          run: function(i, s) {
+            var p = l.hooks.all[i];
+            if (!(!p || !p.length))
+              for (var g = 0, m; m = p[g++]; )
+                m(s);
+          }
+        },
+        Token: f
+      };
+      n.Prism = l;
+      function f(i, s, p, g) {
+        this.type = i, this.content = s, this.alias = p, this.length = (g || "").length | 0;
+      }
+      f.stringify = function i(s, p) {
+        if (typeof s == "string")
+          return s;
+        if (Array.isArray(s)) {
+          var g = "";
+          return s.forEach(function(k) {
+            g += i(k, p);
+          }), g;
+        }
+        var m = {
+          type: s.type,
+          content: i(s.content, p),
+          tag: "span",
+          classes: ["token", s.type],
+          attributes: {},
+          language: p
+        }, c = s.alias;
+        c && (Array.isArray(c) ? Array.prototype.push.apply(m.classes, c) : m.classes.push(c)), l.hooks.run("wrap", m);
+        var _ = "";
+        for (var v in m.attributes)
+          _ += " " + v + '="' + (m.attributes[v] || "").replace(/"/g, "&quot;") + '"';
+        return "<" + m.tag + ' class="' + m.classes.join(" ") + '"' + _ + ">" + m.content + "</" + m.tag + ">";
+      };
+      function h(i, s, p, g) {
+        i.lastIndex = s;
+        var m = i.exec(p);
+        if (m && g && m[1]) {
+          var c = m[1].length;
+          m.index += c, m[0] = m[0].slice(c);
+        }
+        return m;
+      }
+      function C(i, s, p, g, m, c) {
+        for (var _ in p)
+          if (!(!p.hasOwnProperty(_) || !p[_])) {
+            var v = p[_];
+            v = Array.isArray(v) ? v : [v];
+            for (var k = 0; k < v.length; ++k) {
+              if (c && c.cause == _ + "," + k)
+                return;
+              var N = v[k], $ = N.inside, H = !!N.lookbehind, z = !!N.greedy, X = N.alias;
+              if (z && !N.pattern.global) {
+                var J = N.pattern.toString().match(/[imsuy]*$/)[0];
+                N.pattern = RegExp(N.pattern.source, J + "g");
+              }
+              for (var W = N.pattern || N, O = g.next, L = m; O !== s.tail && !(c && L >= c.reach); L += O.value.length, O = O.next) {
+                var B = O.value;
+                if (s.length > i.length)
+                  return;
+                if (!(B instanceof f)) {
+                  var Q = 1, M;
+                  if (z) {
+                    if (M = h(W, L, i, H), !M || M.index >= i.length)
+                      break;
+                    var T = M.index, ce = M.index + M[0].length, j = L;
+                    for (j += O.value.length; T >= j; )
+                      O = O.next, j += O.value.length;
+                    if (j -= O.value.length, L = j, O.value instanceof f)
+                      continue;
+                    for (var I = O; I !== s.tail && (j < ce || typeof I.value == "string"); I = I.next)
+                      Q++, j += I.value.length;
+                    Q--, B = i.slice(L, j), M.index -= L;
+                  } else if (M = h(W, 0, B, H), !M)
+                    continue;
+                  var T = M.index, K = M[0], P = B.slice(0, T), re = B.slice(T + K.length), pe = L + B.length;
+                  c && pe > c.reach && (c.reach = pe);
+                  var de = O.prev;
+                  P && (de = b(s, de, P), L += P.length), y(s, de, Q);
+                  var Ee = new f(_, $ ? l.tokenize(K, $) : K, X, K);
+                  if (O = b(s, de, Ee), re && b(s, O, re), Q > 1) {
+                    var me = {
+                      cause: _ + "," + k,
+                      reach: pe
+                    };
+                    C(i, s, p, O.prev, L, me), c && me.reach > c.reach && (c.reach = me.reach);
+                  }
+                }
+              }
+            }
+          }
+      }
+      function x() {
+        var i = { value: null, prev: null, next: null }, s = { value: null, prev: i, next: null };
+        i.next = s, this.head = i, this.tail = s, this.length = 0;
+      }
+      function b(i, s, p) {
+        var g = s.next, m = { value: p, prev: s, next: g };
+        return s.next = m, g.prev = m, i.length++, m;
+      }
+      function y(i, s, p) {
+        for (var g = s.next, m = 0; m < p && g !== i.tail; m++)
+          g = g.next;
+        s.next = g, g.prev = s, i.length -= m;
+      }
+      function S(i) {
+        for (var s = [], p = i.head.next; p !== i.tail; )
+          s.push(p.value), p = p.next;
+        return s;
+      }
+      if (!n.document)
+        return n.addEventListener && (l.disableWorkerMessageHandler || n.addEventListener("message", function(i) {
+          var s = JSON.parse(i.data), p = s.language, g = s.code, m = s.immediateClose;
+          n.postMessage(l.highlight(g, l.languages[p], p)), m && n.close();
+        }, !1)), l;
+      var E = l.util.currentScript();
+      E && (l.filename = E.src, E.hasAttribute("data-manual") && (l.manual = !0));
+      function w() {
+        l.manual || l.highlightAll();
+      }
+      if (!l.manual) {
+        var A = document.readyState;
+        A === "loading" || A === "interactive" && E && E.defer ? document.addEventListener("DOMContentLoaded", w) : window.requestAnimationFrame ? window.requestAnimationFrame(w) : window.setTimeout(w, 16);
+      }
+      return l;
+    })(t);
+    typeof r < "u" && r.exports && (r.exports = a), typeof global < "u" && (global.Prism = a);
+  }
+}), on = F({
+  "../node_modules/refractor/lang/clike.js"(e, r) {
+    r.exports = t, t.displayName = "clike", t.aliases = [];
+    function t(a) {
+      a.languages.clike = {
+        comment: [
+          {
+            pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+            lookbehind: !0,
+            greedy: !0
+          },
+          {
+            pattern: /(^|[^\\:])\/\/.*/,
+            lookbehind: !0,
+            greedy: !0
+          }
+        ],
+        string: {
+          pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+          greedy: !0
+        },
+        "class-name": {
+          pattern: /(\b(?:class|extends|implements|instanceof|interface|new|trait)\s+|\bcatch\s+\()[\w.\\]+/i,
+          lookbehind: !0,
+          inside: {
+            punctuation: /[.\\]/
+          }
+        },
+        keyword: /\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\b/,
+        boolean: /\b(?:false|true)\b/,
+        function: /\b\w+(?=\()/,
+        number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
+        operator: /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/,
+        punctuation: /[{}[\];(),.:]/
+      };
+    }
+  }
+}), ln = F({
+  "../node_modules/refractor/lang/javascript.js"(e, r) {
+    r.exports = t, t.displayName = "javascript", t.aliases = ["js"];
+    function t(a) {
+      a.languages.javascript = a.languages.extend("clike", {
+        "class-name": [
+          a.languages.clike["class-name"],
+          {
+            pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,
+            lookbehind: !0
+          }
+        ],
+        keyword: [
+          {
+            pattern: /((?:^|\})\s*)catch\b/,
+            lookbehind: !0
+          },
+          {
+            pattern: /(^|[^.]|\.\.\.\s*)\b(?:as|assert(?=\s*\{)|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally(?=\s*(?:\{|$))|for|from(?=\s*(?:['"]|$))|function|(?:get|set)(?=\s*(?:[#\[$\w\xA0-\uFFFF]|$))|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/,
+            lookbehind: !0
+          }
+        ],
+        // Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)
+        function: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
+        number: {
+          pattern: RegExp(
+            /(^|[^\w$])/.source + "(?:" + // constant
+            (/NaN|Infinity/.source + "|" + // binary integer
+            /0[bB][01]+(?:_[01]+)*n?/.source + "|" + // octal integer
+            /0[oO][0-7]+(?:_[0-7]+)*n?/.source + "|" + // hexadecimal integer
+            /0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source + "|" + // decimal bigint
+            /\d+(?:_\d+)*n/.source + "|" + // decimal number (integer or float) but no bigint
+            /(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/.source) + ")" + /(?![\w$])/.source
+          ),
+          lookbehind: !0
+        },
+        operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/
+      }), a.languages.javascript["class-name"][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/, a.languages.insertBefore("javascript", "keyword", {
+        regex: {
+          // eslint-disable-next-line regexp/no-dupe-characters-character-class
+          pattern: /((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)\/(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/,
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            "regex-source": {
+              pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
+              lookbehind: !0,
+              alias: "language-regex",
+              inside: a.languages.regex
+            },
+            "regex-delimiter": /^\/|\/$/,
+            "regex-flags": /^[a-z]+$/
+          }
+        },
+        // This must be declared before keyword because we use "function" inside the look-forward
+        "function-variable": {
+          pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,
+          alias: "function"
+        },
+        parameter: [
+          {
+            pattern: /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,
+            lookbehind: !0,
+            inside: a.languages.javascript
+          },
+          {
+            pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
+            lookbehind: !0,
+            inside: a.languages.javascript
+          },
+          {
+            pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
+            lookbehind: !0,
+            inside: a.languages.javascript
+          },
+          {
+            pattern: /((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/,
+            lookbehind: !0,
+            inside: a.languages.javascript
+          }
+        ],
+        constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/
+      }), a.languages.insertBefore("javascript", "string", {
+        hashbang: {
+          pattern: /^#!.*/,
+          greedy: !0,
+          alias: "comment"
+        },
+        "template-string": {
+          pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
+          greedy: !0,
+          inside: {
+            "template-punctuation": {
+              pattern: /^`|`$/,
+              alias: "string"
+            },
+            interpolation: {
+              pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
+              lookbehind: !0,
+              inside: {
+                "interpolation-punctuation": {
+                  pattern: /^\$\{|\}$/,
+                  alias: "punctuation"
+                },
+                rest: a.languages.javascript
+              }
+            },
+            string: /[\s\S]+/
+          }
+        },
+        "string-property": {
+          pattern: /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m,
+          lookbehind: !0,
+          greedy: !0,
+          alias: "property"
+        }
+      }), a.languages.insertBefore("javascript", "operator", {
+        "literal-property": {
+          pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
+          lookbehind: !0,
+          alias: "property"
+        }
+      }), a.languages.markup && (a.languages.markup.tag.addInlined("script", "javascript"), a.languages.markup.tag.addAttribute(
+        /on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)/.source,
+        "javascript"
+      )), a.languages.js = a.languages.javascript;
+    }
+  }
+}), sn = F({
+  "../node_modules/refractor/core.js"(e, r) {
+    var t = typeof globalThis == "object" ? globalThis : typeof self == "object" ? self : typeof window == "object" ? window : typeof global == "object" ? global : {}, a = m();
+    t.Prism = { manual: !0, disableWorkerMessageHandler: !0 };
+    var n = Vt(), o = an(), u = rn(), d = et(), l = Je(), f = on(), h = ln();
+    a();
+    var C = {}.hasOwnProperty;
+    function x() {
+    }
+    x.prototype = u;
+    var b = new x();
+    r.exports = b, b.highlight = E, b.register = y, b.alias = S, b.registered = w, b.listLanguages = A, y(d), y(l), y(f), y(h), b.util.encode = p, b.Token.stringify = i;
+    function y(c) {
+      if (typeof c != "function" || !c.displayName)
+        throw new Error("Expected `function` for `grammar`, got `" + c + "`");
+      b.languages[c.displayName] === void 0 && c(b);
+    }
+    function S(c, _) {
+      var v = b.languages, k = c, N, $, H, z;
+      _ && (k = {}, k[c] = _);
+      for (N in k)
+        for ($ = k[N], $ = typeof $ == "string" ? [$] : $, H = $.length, z = -1; ++z < H; )
+          v[$[z]] = v[N];
+    }
+    function E(c, _) {
+      var v = u.highlight, k;
+      if (typeof c != "string")
+        throw new Error("Expected `string` for `value`, got `" + c + "`");
+      if (b.util.type(_) === "Object")
+        k = _, _ = null;
+      else {
+        if (typeof _ != "string")
+          throw new Error("Expected `string` for `name`, got `" + _ + "`");
+        if (C.call(b.languages, _))
+          k = b.languages[_];
+        else
+          throw new Error("Unknown language: `" + _ + "` is not registered");
+      }
+      return v.call(this, c, k, _);
+    }
+    function w(c) {
+      if (typeof c != "string")
+        throw new Error("Expected `string` for `language`, got `" + c + "`");
+      return C.call(b.languages, c);
+    }
+    function A() {
+      var c = b.languages, _ = [], v;
+      for (v in c)
+        C.call(c, v) && typeof c[v] == "object" && _.push(v);
+      return _;
+    }
+    function i(c, _, v) {
+      var k;
+      return typeof c == "string" ? { type: "text", value: c } : b.util.type(c) === "Array" ? s(c, _) : (k = {
+        type: c.type,
+        content: b.Token.stringify(c.content, _, v),
+        tag: "span",
+        classes: ["token", c.type],
+        attributes: {},
+        language: _,
+        parent: v
+      }, c.alias && (k.classes = k.classes.concat(c.alias)), b.hooks.run("wrap", k), n(
+        k.tag + "." + k.classes.join("."),
+        g(k.attributes),
+        k.content
+      ));
+    }
+    function s(c, _) {
+      for (var v = [], k = c.length, N = -1, $; ++N < k; )
+        $ = c[N], $ !== "" && $ !== null && $ !== void 0 && v.push($);
+      for (N = -1, k = v.length; ++N < k; )
+        $ = v[N], v[N] = b.Token.stringify($, _, v);
+      return v;
+    }
+    function p(c) {
+      return c;
+    }
+    function g(c) {
+      var _;
+      for (_ in c)
+        c[_] = o(c[_]);
+      return c;
+    }
+    function m() {
+      var c = "Prism" in t, _ = c ? t.Prism : void 0;
+      return v;
+      function v() {
+        c ? t.Prism = _ : delete t.Prism, c = void 0, _ = void 0;
+      }
+    }
+  }
+}), un = Z(wt(), 1);
+function Ke(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var a = Object.getOwnPropertySymbols(e);
+    r && (a = a.filter(function(n) {
+      return Object.getOwnPropertyDescriptor(e, n).enumerable;
+    })), t.push.apply(t, a);
+  }
+  return t;
+}
+function fe(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = arguments[r] != null ? arguments[r] : {};
+    r % 2 ? Ke(Object(t), !0).forEach(function(a) {
+      Ye(e, a, t[a]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : Ke(Object(t)).forEach(function(a) {
+      Object.defineProperty(e, a, Object.getOwnPropertyDescriptor(t, a));
+    });
+  }
+  return e;
+}
+function cn(e) {
+  var r = e.length;
+  if (r === 0 || r === 1) return e;
+  if (r === 2)
+    return [e[0], e[1], "".concat(e[0], ".").concat(e[1]), "".concat(e[1], ".").concat(e[0])];
+  if (r === 3)
+    return [e[0], e[1], e[2], "".concat(e[0], ".").concat(e[1]), "".concat(e[0], ".").concat(e[2]), "".concat(e[1], ".").concat(e[0]), "".concat(e[1], ".").concat(e[2]), "".concat(e[2], ".").concat(e[0]), "".concat(e[2], ".").concat(e[1]), "".concat(e[0], ".").concat(e[1], ".").concat(e[2]), "".concat(e[0], ".").concat(e[2], ".").concat(e[1]), "".concat(e[1], ".").concat(e[0], ".").concat(e[2]), "".concat(e[1], ".").concat(e[2], ".").concat(e[0]), "".concat(e[2], ".").concat(e[0], ".").concat(e[1]), "".concat(e[2], ".").concat(e[1], ".").concat(e[0])];
+  if (r >= 4)
+    return [e[0], e[1], e[2], e[3], "".concat(e[0], ".").concat(e[1]), "".concat(e[0], ".").concat(e[2]), "".concat(e[0], ".").concat(e[3]), "".concat(e[1], ".").concat(e[0]), "".concat(e[1], ".").concat(e[2]), "".concat(e[1], ".").concat(e[3]), "".concat(e[2], ".").concat(e[0]), "".concat(e[2], ".").concat(e[1]), "".concat(e[2], ".").concat(e[3]), "".concat(e[3], ".").concat(e[0]), "".concat(e[3], ".").concat(e[1]), "".concat(e[3], ".").concat(e[2]), "".concat(e[0], ".").concat(e[1], ".").concat(e[2]), "".concat(e[0], ".").concat(e[1], ".").concat(e[3]), "".concat(e[0], ".").concat(e[2], ".").concat(e[1]), "".concat(e[0], ".").concat(e[2], ".").concat(e[3]), "".concat(e[0], ".").concat(e[3], ".").concat(e[1]), "".concat(e[0], ".").concat(e[3], ".").concat(e[2]), "".concat(e[1], ".").concat(e[0], ".").concat(e[2]), "".concat(e[1], ".").concat(e[0], ".").concat(e[3]), "".concat(e[1], ".").concat(e[2], ".").concat(e[0]), "".concat(e[1], ".").concat(e[2], ".").concat(e[3]), "".concat(e[1], ".").concat(e[3], ".").concat(e[0]), "".concat(e[1], ".").concat(e[3], ".").concat(e[2]), "".concat(e[2], ".").concat(e[0], ".").concat(e[1]), "".concat(e[2], ".").concat(e[0], ".").concat(e[3]), "".concat(e[2], ".").concat(e[1], ".").concat(e[0]), "".concat(e[2], ".").concat(e[1], ".").concat(e[3]), "".concat(e[2], ".").concat(e[3], ".").concat(e[0]), "".concat(e[2], ".").concat(e[3], ".").concat(e[1]), "".concat(e[3], ".").concat(e[0], ".").concat(e[1]), "".concat(e[3], ".").concat(e[0], ".").concat(e[2]), "".concat(e[3], ".").concat(e[1], ".").concat(e[0]), "".concat(e[3], ".").concat(e[1], ".").concat(e[2]), "".concat(e[3], ".").concat(e[2], ".").concat(e[0]), "".concat(e[3], ".").concat(e[2], ".").concat(e[1]), "".concat(e[0], ".").concat(e[1], ".").concat(e[2], ".").concat(e[3]), "".concat(e[0], ".").concat(e[1], ".").concat(e[3], ".").concat(e[2]), "".concat(e[0], ".").concat(e[2], ".").concat(e[1], ".").concat(e[3]), "".concat(e[0], ".").concat(e[2], ".").concat(e[3], ".").concat(e[1]), "".concat(e[0], ".").concat(e[3], ".").concat(e[1], ".").concat(e[2]), "".concat(e[0], ".").concat(e[3], ".").concat(e[2], ".").concat(e[1]), "".concat(e[1], ".").concat(e[0], ".").concat(e[2], ".").concat(e[3]), "".concat(e[1], ".").concat(e[0], ".").concat(e[3], ".").concat(e[2]), "".concat(e[1], ".").concat(e[2], ".").concat(e[0], ".").concat(e[3]), "".concat(e[1], ".").concat(e[2], ".").concat(e[3], ".").concat(e[0]), "".concat(e[1], ".").concat(e[3], ".").concat(e[0], ".").concat(e[2]), "".concat(e[1], ".").concat(e[3], ".").concat(e[2], ".").concat(e[0]), "".concat(e[2], ".").concat(e[0], ".").concat(e[1], ".").concat(e[3]), "".concat(e[2], ".").concat(e[0], ".").concat(e[3], ".").concat(e[1]), "".concat(e[2], ".").concat(e[1], ".").concat(e[0], ".").concat(e[3]), "".concat(e[2], ".").concat(e[1], ".").concat(e[3], ".").concat(e[0]), "".concat(e[2], ".").concat(e[3], ".").concat(e[0], ".").concat(e[1]), "".concat(e[2], ".").concat(e[3], ".").concat(e[1], ".").concat(e[0]), "".concat(e[3], ".").concat(e[0], ".").concat(e[1], ".").concat(e[2]), "".concat(e[3], ".").concat(e[0], ".").concat(e[2], ".").concat(e[1]), "".concat(e[3], ".").concat(e[1], ".").concat(e[0], ".").concat(e[2]), "".concat(e[3], ".").concat(e[1], ".").concat(e[2], ".").concat(e[0]), "".concat(e[3], ".").concat(e[2], ".").concat(e[0], ".").concat(e[1]), "".concat(e[3], ".").concat(e[2], ".").concat(e[1], ".").concat(e[0])];
+}
+var Oe = {};
+function pn(e) {
+  if (e.length === 0 || e.length === 1) return e;
+  var r = e.join(".");
+  return Oe[r] || (Oe[r] = cn(e)), Oe[r];
+}
+function dn(e) {
+  var r = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, t = arguments.length > 2 ? arguments[2] : void 0, a = e.filter(function(o) {
+    return o !== "token";
+  }), n = pn(a);
+  return n.reduce(function(o, u) {
+    return fe(fe({}, o), t[u]);
+  }, r);
+}
+function Xe(e) {
+  return e.join(" ");
+}
+function gn(e, r) {
+  var t = 0;
+  return function(a) {
+    return t += 1, a.map(function(n, o) {
+      return Re({
+        node: n,
+        stylesheet: e,
+        useInlineStyles: r,
+        key: "code-segment-".concat(t, "-").concat(o)
+      });
+    });
+  };
+}
+function Re(e) {
+  var r = e.node, t = e.stylesheet, a = e.style, n = a === void 0 ? {} : a, o = e.useInlineStyles, u = e.key, d = r.properties, l = r.type, f = r.tagName, h = r.value;
+  if (l === "text")
+    return h;
+  if (f) {
+    var C = gn(t, o), x;
+    if (!o)
+      x = fe(fe({}, d), {}, {
+        className: Xe(d.className)
+      });
+    else {
+      var b = Object.keys(t).reduce(function(w, A) {
+        return A.split(".").forEach(function(i) {
+          w.includes(i) || w.push(i);
+        }), w;
+      }, []), y = d.className && d.className.includes("token") ? ["token"] : [], S = d.className && y.concat(d.className.filter(function(w) {
+        return !b.includes(w);
+      }));
+      x = fe(fe({}, d), {}, {
+        className: Xe(S) || void 0,
+        style: dn(d.className, Object.assign({}, d.style, n), t)
+      });
+    }
+    var E = C(r.children);
+    return G.createElement(f, vt({
+      key: u
+    }, x), E);
+  }
+}
+var fn = Z(Ft()), mn = fn.default, hn = Z(Je()), yn = hn.default, bn = Z(jt()), xn = bn.default, vn = Z(Nt()), Sn = vn.default, wn = Z($t()), _n = wn.default, An = Z(Qe()), En = An.default, kn = Z(Ot()), Cn = kn.default, Fn = Z(et()), jn = Fn.default, Nn = Z(Lt()), $n = Nn.default, On = Z(tt()), Ln = On.default, In = Z(It()), Tn = In.default;
+function Le(e, r) {
+  (r == null || r > e.length) && (r = e.length);
+  for (var t = 0, a = Array(r); t < r; t++) a[t] = e[t];
+  return a;
+}
+function Dn(e) {
+  if (Array.isArray(e)) return Le(e);
+}
+function Rn(e) {
+  if (typeof Symbol < "u" && e[Symbol.iterator] != null || e["@@iterator"] != null) return Array.from(e);
+}
+function qn(e, r) {
+  if (e) {
+    if (typeof e == "string") return Le(e, r);
+    var t = {}.toString.call(e).slice(8, -1);
+    return t === "Object" && e.constructor && (t = e.constructor.name), t === "Map" || t === "Set" ? Array.from(e) : t === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? Le(e, r) : void 0;
+  }
+}
+function Bn() {
+  throw new TypeError(`Invalid attempt to spread non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function Ie(e) {
+  return Dn(e) || Rn(e) || qn(e) || Bn();
+}
+var Mn = (function(e, r) {
+  var t = e.listLanguages();
+  return t.indexOf(r) !== -1;
+}), zn = ["language", "children", "style", "customStyle", "codeTagProps", "useInlineStyles", "showLineNumbers", "showInlineLineNumbers", "startingLineNumber", "lineNumberContainerStyle", "lineNumberStyle", "wrapLines", "wrapLongLines", "lineProps", "renderer", "PreTag", "CodeTag", "code", "astGenerator"];
+function Ve(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var a = Object.getOwnPropertySymbols(e);
+    r && (a = a.filter(function(n) {
+      return Object.getOwnPropertyDescriptor(e, n).enumerable;
+    })), t.push.apply(t, a);
+  }
+  return t;
+}
+function ae(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = arguments[r] != null ? arguments[r] : {};
+    r % 2 ? Ve(Object(t), !0).forEach(function(a) {
+      Ye(e, a, t[a]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : Ve(Object(t)).forEach(function(a) {
+      Object.defineProperty(e, a, Object.getOwnPropertyDescriptor(t, a));
+    });
+  }
+  return e;
+}
+var Hn = /\n/g;
+function Pn(e) {
+  return e.match(Hn);
+}
+function Un(e) {
+  var r = e.lines, t = e.startingLineNumber, a = e.style;
+  return r.map(function(n, o) {
+    var u = o + t;
+    return G.createElement("span", {
+      key: "line-".concat(o),
+      className: "react-syntax-highlighter-line-number",
+      style: typeof a == "function" ? a(u) : a
+    }, "".concat(u, `
+`));
+  });
+}
+function Gn(e) {
+  var r = e.codeString, t = e.codeStyle, a = e.containerStyle, n = a === void 0 ? {
+    float: "left",
+    paddingRight: "10px"
+  } : a, o = e.numberStyle, u = o === void 0 ? {} : o, d = e.startingLineNumber;
+  return G.createElement("code", {
+    style: Object.assign({}, t, n)
+  }, Un({
+    lines: r.replace(/\n$/, "").split(`
+`),
+    style: u,
+    startingLineNumber: d
+  }));
+}
+function Zn(e) {
+  return "".concat(e.toString().length, ".25em");
+}
+function it(e, r) {
+  return {
+    type: "element",
+    tagName: "span",
+    properties: {
+      key: "line-number--".concat(e),
+      className: ["comment", "linenumber", "react-syntax-highlighter-line-number"],
+      style: r
+    },
+    children: [{
+      type: "text",
+      value: e
+    }]
+  };
+}
+function st(e, r, t) {
+  var a = {
+    display: "inline-block",
+    minWidth: Zn(t),
+    paddingRight: "1em",
+    textAlign: "right",
+    userSelect: "none"
+  }, n = typeof e == "function" ? e(r) : e, o = ae(ae({}, a), n);
+  return o;
+}
+function _e(e) {
+  var r = e.children, t = e.lineNumber, a = e.lineNumberStyle, n = e.largestLineNumber, o = e.showInlineLineNumbers, u = e.lineProps, d = u === void 0 ? {} : u, l = e.className, f = l === void 0 ? [] : l, h = e.showLineNumbers, C = e.wrapLongLines, x = e.wrapLines, b = x === void 0 ? !1 : x, y = b ? ae({}, typeof d == "function" ? d(t) : d) : {};
+  if (y.className = y.className ? [].concat(Ie(y.className.trim().split(/\s+/)), Ie(f)) : f, t && o) {
+    var S = st(a, t, n);
+    r.unshift(it(t, S));
+  }
+  return C & h && (y.style = ae({
+    display: "flex"
+  }, y.style)), {
+    type: "element",
+    tagName: "span",
+    properties: y,
+    children: r
+  };
+}
+function ut(e) {
+  for (var r = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [], t = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : [], a = 0; a < e.length; a++) {
+    var n = e[a];
+    if (n.type === "text")
+      t.push(_e({
+        children: [n],
+        className: Ie(new Set(r))
+      }));
+    else if (n.children) {
+      var o = r.concat(n.properties.className);
+      ut(n.children, o).forEach(function(u) {
+        return t.push(u);
+      });
+    }
+  }
+  return t;
+}
+function Wn(e, r, t, a, n, o, u, d, l) {
+  var f, h = ut(e.value), C = [], x = -1, b = 0;
+  function y(p, g) {
+    var m = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : [];
+    return _e({
+      children: p,
+      lineNumber: g,
+      lineNumberStyle: d,
+      largestLineNumber: u,
+      showInlineLineNumbers: n,
+      lineProps: t,
+      className: m,
+      showLineNumbers: a,
+      wrapLongLines: l,
+      wrapLines: r
+    });
+  }
+  function S(p, g) {
+    if (a && g && n) {
+      var m = st(d, g, u);
+      p.unshift(it(g, m));
+    }
+    return p;
+  }
+  function E(p, g) {
+    var m = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : [];
+    return r || m.length > 0 ? y(p, g, m) : S(p, g);
+  }
+  for (var w = function() {
+    var p = h[b], g = p.children[0].value, m = Pn(g);
+    if (m) {
+      var c = g.split(`
+`);
+      c.forEach(function(_, v) {
+        var k = a && C.length + o, N = {
+          type: "text",
+          value: "".concat(_, `
+`)
+        };
+        if (v === 0) {
+          var $ = h.slice(x + 1, b).concat(_e({
+            children: [N],
+            className: p.properties.className
+          })), H = E($, k);
+          C.push(H);
+        } else if (v === c.length - 1) {
+          var z = h[b + 1] && h[b + 1].children && h[b + 1].children[0], X = {
+            type: "text",
+            value: "".concat(_)
+          };
+          if (z) {
+            var J = _e({
+              children: [X],
+              className: p.properties.className
+            });
+            h.splice(b + 1, 0, J);
+          } else {
+            var W = [X], O = E(W, k, p.properties.className);
+            C.push(O);
+          }
+        } else {
+          var L = [N], B = E(L, k, p.properties.className);
+          C.push(B);
+        }
+      }), x = b;
+    }
+    b++;
+  }; b < h.length; )
+    w();
+  if (x !== h.length - 1) {
+    var A = h.slice(x + 1, h.length);
+    if (A && A.length) {
+      var i = a && C.length + o, s = E(A, i);
+      C.push(s);
+    }
+  }
+  return r ? C : (f = []).concat.apply(f, C);
+}
+function Kn(e) {
+  var r = e.rows, t = e.stylesheet, a = e.useInlineStyles;
+  return r.map(function(n, o) {
+    return Re({
+      node: n,
+      stylesheet: t,
+      useInlineStyles: a,
+      key: "code-segment-".concat(o)
+    });
+  });
+}
+function ct(e) {
+  return e && typeof e.highlightAuto < "u";
+}
+function Xn(e) {
+  var r = e.astGenerator, t = e.language, a = e.code, n = e.defaultCodeValue;
+  if (ct(r)) {
+    var o = Mn(r, t);
+    return t === "text" ? {
+      value: n,
+      language: "text"
+    } : o ? r.highlight(t, a) : r.highlightAuto(a);
+  }
+  try {
+    return t && t !== "text" ? {
+      value: r.highlight(a, t)
+    } : {
+      value: n
+    };
+  } catch {
+    return {
+      value: n
+    };
+  }
+}
+function Vn(e, r) {
+  return function(t) {
+    var a, n, o = t.language, u = t.children, d = t.style, l = d === void 0 ? r : d, f = t.customStyle, h = f === void 0 ? {} : f, C = t.codeTagProps, x = C === void 0 ? {
+      className: o ? "language-".concat(o) : void 0,
+      style: ae(ae({}, l['code[class*="language-"]']), l['code[class*="language-'.concat(o, '"]')])
+    } : C, b = t.useInlineStyles, y = b === void 0 ? !0 : b, S = t.showLineNumbers, E = S === void 0 ? !1 : S, w = t.showInlineLineNumbers, A = w === void 0 ? !0 : w, i = t.startingLineNumber, s = i === void 0 ? 1 : i, p = t.lineNumberContainerStyle, g = t.lineNumberStyle, m = g === void 0 ? {} : g, c = t.wrapLines, _ = t.wrapLongLines, v = _ === void 0 ? !1 : _, k = t.lineProps, N = k === void 0 ? {} : k, $ = t.renderer, H = t.PreTag, z = H === void 0 ? "pre" : H, X = t.CodeTag, J = X === void 0 ? "code" : X, W = t.code, O = W === void 0 ? (Array.isArray(u) ? u[0] : u) || "" : W, L = t.astGenerator, B = Ct(t, zn);
+    L = L || e;
+    var Q = E ? G.createElement(Gn, {
+      containerStyle: p,
+      codeStyle: x.style || {},
+      numberStyle: m,
+      startingLineNumber: s,
+      codeString: O
+    }) : null, M = l.hljs || l['pre[class*="language-"]'] || {
+      backgroundColor: "#fff"
+    }, ce = ct(L) ? "hljs" : "prismjs", j = y ? Object.assign({}, B, {
+      style: Object.assign({}, M, h)
+    }) : Object.assign({}, B, {
+      className: B.className ? "".concat(ce, " ").concat(B.className) : ce,
+      style: Object.assign({}, h)
+    });
+    if (v ? x.style = ae({
+      whiteSpace: "pre-wrap"
+    }, x.style) : x.style = ae({
+      whiteSpace: "pre"
+    }, x.style), !L)
+      return G.createElement(z, j, Q, G.createElement(J, x, O));
+    (c === void 0 && $ || v) && (c = !0), $ = $ || Kn;
+    var I = [{
+      type: "text",
+      value: O
+    }], T = Xn({
+      astGenerator: L,
+      language: o,
+      code: O,
+      defaultCodeValue: I
+    });
+    T.language === null && (T.value = I);
+    var K = (a = (n = O.match(/\n/g)) === null || n === void 0 ? void 0 : n.length) !== null && a !== void 0 ? a : 0, P = s + K, re = Wn(T, c, N, E, A, s, P, m, v);
+    return G.createElement(z, j, G.createElement(J, x, !A && Q, $({
+      rows: re,
+      stylesheet: l,
+      useInlineStyles: y
+    })));
+  };
+}
+var qe = Z(sn()), Be = Vn(qe.default, {});
+Be.registerLanguage = function(e, r) {
+  return qe.default.register(r);
+};
+Be.alias = function(e, r) {
+  return qe.default.alias(e, r);
+};
+var Me = Be, { window: Yn } = yt, Jn = {
+  jsextra: Sn,
+  jsx: En,
+  json: _n,
+  yml: Tn,
+  md: Cn,
+  bash: mn,
+  css: yn,
+  html: jn,
+  tsx: $n,
+  typescript: Ln,
+  graphql: xn
+};
+Object.entries(Jn).forEach(([e, r]) => {
+  Me.registerLanguage(e, r);
+});
+var Qn = (0, un.default)(2)(
+  (e) => Object.entries(e.code || {}).reduce((r, [t, a]) => ({ ...r, [`* .${t}`]: a }), {})
+), ea = ht(), ta = Ae.div(
+  ({ theme: e }) => ({
+    position: "relative",
+    overflow: "hidden",
+    color: e.color.defaultText
+  }),
+  ({ theme: e, bordered: r }) => r ? {
+    border: `1px solid ${e.appBorderColor}`,
+    borderRadius: e.borderRadius,
+    background: e.background.content
+  } : {},
+  ({ showLineNumbers: e }) => e ? {
+    // use the before pseudo element to display line numbers
+    ".react-syntax-highlighter-line-number::before": {
+      content: "attr(data-line-number)"
+    }
+  } : {}
+), na = ({ children: e, className: r }) => G.createElement(St, { horizontal: !0, vertical: !0, className: r }, e), aa = Ae(na)(
+  {
+    position: "relative"
+  },
+  ({ theme: e }) => Qn(e)
+), ra = Ae.pre(({ theme: e, padded: r }) => ({
+  display: "flex",
+  justifyContent: "flex-start",
+  margin: 0,
+  padding: r ? e.layoutMargin : 0
+})), oa = Ae.div(({ theme: e }) => ({
+  flex: 1,
+  paddingLeft: 2,
+  // TODO: To match theming/global.ts for now
+  paddingRight: e.layoutMargin,
+  opacity: 1,
+  fontFamily: e.typography.fonts.mono
+})), pt = (e) => {
+  let r = [...e.children], t = r[0], a = t.children[0].value, n = {
+    ...t,
+    // empty the line-number element
+    children: [],
+    properties: {
+      ...t.properties,
+      // add a data-line-number attribute to line-number element, so we can access the line number with `content: attr(data-line-number)`
+      "data-line-number": a,
+      // remove the 'userSelect: none' style, which will produce extra empty lines when copy-pasting in firefox
+      style: { ...t.properties.style, userSelect: "auto" }
+    }
+  };
+  return r[0] = n, { ...e, children: r };
+}, la = ({ rows: e, stylesheet: r, useInlineStyles: t }) => e.map((a, n) => Re({
+  node: pt(a),
+  stylesheet: r,
+  useInlineStyles: t,
+  key: `code-segement${n}`
+})), ia = (e, r) => r ? e ? ({ rows: t, ...a }) => e({ rows: t.map((n) => pt(n)), ...a }) : la : e, dt = ({
+  children: e,
+  language: r = "jsx",
+  copyable: t = !1,
+  bordered: a = !1,
+  padded: n = !1,
+  format: o = !0,
+  formatter: u = void 0,
+  className: d = void 0,
+  showLineNumbers: l = !1,
+  ...f
+}) => {
+  if (typeof e != "string" || !e.trim())
+    return null;
+  let [h, C] = We("");
+  _t(() => {
+    u ? u(o, e).then(C) : C(e.trim());
+  }, [e, o, u]);
+  let [x, b] = We(!1), y = At(
+    (E) => {
+      E.preventDefault(), ea(h).then(() => {
+        b(!0), Yn.setTimeout(() => b(!1), 1500);
+      }).catch(bt.error);
+    },
+    [h]
+  ), S = ia(f.renderer, l);
+  return G.createElement(
+    ta,
+    {
+      bordered: a,
+      padded: n,
+      showLineNumbers: l,
+      className: d
+    },
+    G.createElement(aa, null, G.createElement(
+      Me,
+      {
+        padded: n || a,
+        language: r,
+        showLineNumbers: l,
+        showInlineLineNumbers: l,
+        useInlineStyles: !1,
+        PreTag: ra,
+        CodeTag: oa,
+        lineNumberContainerStyle: {},
+        ...f,
+        renderer: S
+      },
+      h
+    )),
+    t ? G.createElement(xt, { actionItems: [{ title: x ? "Copied" : "Copy", onClick: y }] }) : null
+  );
+};
+dt.registerLanguage = (...e) => Me.registerLanguage(...e);
+var ca = dt;
+export {
+  dt as SyntaxHighlighter,
+  ca as default,
+  Jn as supportedLanguages
+};
+//# sourceMappingURL=syntaxhighlighter-IQDEPFLK-BX_eF8__.js.map