zudoku 0.1.1-dev.9 → 0.3.0-dev.11

package/lib/loglevel-CoH7VSwE.js

@@ -0,0 +1,152 @@
+import { a as N, g as _ } from "./state-2Hu1renZ.js";
+var I = { exports: {} };
+(function(w) {
+  (function(g, i) {
+    w.exports ? w.exports = i() : g.log = i();
+  })(N, function() {
+    var g = function() {
+    }, i = "undefined", C = typeof window !== i && typeof window.navigator !== i && /Trident\/|MSIE /.test(window.navigator.userAgent), p = [
+      "trace",
+      "debug",
+      "info",
+      "warn",
+      "error"
+    ], a = {}, l = null;
+    function h(o, t) {
+      var e = o[t];
+      if (typeof e.bind == "function")
+        return e.bind(o);
+      try {
+        return Function.prototype.bind.call(e, o);
+      } catch {
+        return function() {
+          return Function.prototype.apply.apply(e, [o, arguments]);
+        };
+      }
+    }
+    function T() {
+      console.log && (console.log.apply ? console.log.apply(console, arguments) : Function.prototype.apply.apply(console.log, [console, arguments])), console.trace && console.trace();
+    }
+    function x(o) {
+      return o === "debug" && (o = "log"), typeof console === i ? !1 : o === "trace" && C ? T : console[o] !== void 0 ? h(console, o) : console.log !== void 0 ? h(console, "log") : g;
+    }
+    function u() {
+      for (var o = this.getLevel(), t = 0; t < p.length; t++) {
+        var e = p[t];
+        this[e] = t < o ? g : this.methodFactory(e, o, this.name);
+      }
+      if (this.log = this.debug, typeof console === i && o < this.levels.SILENT)
+        return "No console available for logging";
+    }
+    function F(o) {
+      return function() {
+        typeof console !== i && (u.call(this), this[o].apply(this, arguments));
+      };
+    }
+    function R(o, t, e) {
+      return x(o) || F.apply(this, arguments);
+    }
+    function L(o, t) {
+      var e = this, v, y, f, s = "loglevel";
+      typeof o == "string" ? s += ":" + o : typeof o == "symbol" && (s = void 0);
+      function S(n) {
+        var r = (p[n] || "silent").toUpperCase();
+        if (!(typeof window === i || !s)) {
+          try {
+            window.localStorage[s] = r;
+            return;
+          } catch {
+          }
+          try {
+            window.document.cookie = encodeURIComponent(s) + "=" + r + ";";
+          } catch {
+          }
+        }
+      }
+      function b() {
+        var n;
+        if (!(typeof window === i || !s)) {
+          try {
+            n = window.localStorage[s];
+          } catch {
+          }
+          if (typeof n === i)
+            try {
+              var r = window.document.cookie, d = encodeURIComponent(s), m = r.indexOf(d + "=");
+              m !== -1 && (n = /^([^;]+)/.exec(
+                r.slice(m + d.length + 1)
+              )[1]);
+            } catch {
+            }
+          return e.levels[n] === void 0 && (n = void 0), n;
+        }
+      }
+      function U() {
+        if (!(typeof window === i || !s)) {
+          try {
+            window.localStorage.removeItem(s);
+          } catch {
+          }
+          try {
+            window.document.cookie = encodeURIComponent(s) + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC";
+          } catch {
+          }
+        }
+      }
+      function c(n) {
+        var r = n;
+        if (typeof r == "string" && e.levels[r.toUpperCase()] !== void 0 && (r = e.levels[r.toUpperCase()]), typeof r == "number" && r >= 0 && r <= e.levels.SILENT)
+          return r;
+        throw new TypeError("log.setLevel() called with invalid level: " + n);
+      }
+      e.name = o, e.levels = {
+        TRACE: 0,
+        DEBUG: 1,
+        INFO: 2,
+        WARN: 3,
+        ERROR: 4,
+        SILENT: 5
+      }, e.methodFactory = t || R, e.getLevel = function() {
+        return f ?? y ?? v;
+      }, e.setLevel = function(n, r) {
+        return f = c(n), r !== !1 && S(f), u.call(e);
+      }, e.setDefaultLevel = function(n) {
+        y = c(n), b() || e.setLevel(n, !1);
+      }, e.resetLevel = function() {
+        f = null, U(), u.call(e);
+      }, e.enableAll = function(n) {
+        e.setLevel(e.levels.TRACE, n);
+      }, e.disableAll = function(n) {
+        e.setLevel(e.levels.SILENT, n);
+      }, e.rebuild = function() {
+        if (l !== e && (v = c(l.getLevel())), u.call(e), l === e)
+          for (var n in a)
+            a[n].rebuild();
+      }, v = c(
+        l ? l.getLevel() : "WARN"
+      );
+      var E = b();
+      E != null && (f = c(E)), u.call(e);
+    }
+    l = new L(), l.getLogger = function(t) {
+      if (typeof t != "symbol" && typeof t != "string" || t === "")
+        throw new TypeError("You must supply a name when creating a logger.");
+      var e = a[t];
+      return e || (e = a[t] = new L(
+        t,
+        l.methodFactory
+      )), e;
+    };
+    var A = typeof window !== i ? window.log : void 0;
+    return l.noConflict = function() {
+      return typeof window !== i && window.log === l && (window.log = A), l;
+    }, l.getLoggers = function() {
+      return a;
+    }, l.default = l, l;
+  });
+})(I);
+var D = I.exports;
+const P = /* @__PURE__ */ _(D);
+export {
+  P as l
+};

package/lib/prism-bash.min-DadFsM4Z.js

@@ -0,0 +1,6 @@
+(function(e) {
+  var a = "\\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", s = { pattern: /(^(["']?)\w+\2)[ \t]+\S.*/, lookbehind: !0, alias: "punctuation", inside: null }, t = { bash: s, environment: { pattern: RegExp("\\$" + a), alias: "constant" }, variable: [{ pattern: /\$?\(\([\s\S]+?\)\)/, greedy: !0, inside: { variable: [{ pattern: /(^\$\(\([\s\S]+)\)\)/, lookbehind: !0 }, /^\$\(\(/], number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee]-?\d+)?/, operator: /--|\+\+|\*\*=?|<<=?|>>=?|&&|\|\||[=!+\-*/%<>^&|]=?|[?~:]/, punctuation: /\(\(?|\)\)?|,|;/ } }, { pattern: /\$\((?:\([^)]+\)|[^()])+\)|`[^`]+`/, greedy: !0, inside: { variable: /^\$\(|^`|\)$|`$/ } }, { pattern: /\$\{[^}]+\}/, greedy: !0, inside: { operator: /:[-=?+]?|[!\/]|##?|%%?|\^\^?|,,?/, punctuation: /[\[\]]/, environment: { pattern: RegExp("(\\{)" + a), lookbehind: !0, alias: "constant" } } }, /\$(?:\w+|[#?*!@$])/], entity: /\\(?:[abceEfnrtv\\"]|O?[0-7]{1,3}|U[0-9a-fA-F]{8}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{1,2})/ };
+  e.languages.bash = { shebang: { pattern: /^#!\s*\/.*/, alias: "important" }, comment: { pattern: /(^|[^"{\\$])#.*/, lookbehind: !0 }, "function-name": [{ pattern: /(\bfunction\s+)[\w-]+(?=(?:\s*\(?:\s*\))?\s*\{)/, lookbehind: !0, alias: "function" }, { pattern: /\b[\w-]+(?=\s*\(\s*\)\s*\{)/, alias: "function" }], "for-or-select": { pattern: /(\b(?:for|select)\s+)\w+(?=\s+in\s)/, alias: "variable", lookbehind: !0 }, "assign-left": { pattern: /(^|[\s;|&]|[<>]\()\w+(?:\.\w+)*(?=\+?=)/, inside: { environment: { pattern: RegExp("(^|[\\s;|&]|[<>]\\()" + a), lookbehind: !0, alias: "constant" } }, alias: "variable", lookbehind: !0 }, parameter: { pattern: /(^|\s)-{1,2}(?:\w+:[+-]?)?\w+(?:\.\w+)*(?=[=\s]|$)/, alias: "variable", lookbehind: !0 }, string: [{ pattern: /((?:^|[^<])<<-?\s*)(\w+)\s[\s\S]*?(?:\r?\n|\r)\2/, lookbehind: !0, greedy: !0, inside: t }, { pattern: /((?:^|[^<])<<-?\s*)(["'])(\w+)\2\s[\s\S]*?(?:\r?\n|\r)\3/, lookbehind: !0, greedy: !0, inside: { bash: s } }, { pattern: /(^|[^\\](?:\\\\)*)"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/, lookbehind: !0, greedy: !0, inside: t }, { pattern: /(^|[^$\\])'[^']*'/, lookbehind: !0, greedy: !0 }, { pattern: /\$'(?:[^'\\]|\\[\s\S])*'/, greedy: !0, inside: { entity: t.entity } }], environment: { pattern: RegExp("\\$?" + a), alias: "constant" }, variable: t.variable, function: { pattern: /(^|[\s;|&]|[<>]\()(?:add|apropos|apt|apt-cache|apt-get|aptitude|aspell|automysqlbackup|awk|basename|bash|bc|bconsole|bg|bzip2|cal|cargo|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|java|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|sysctl|tac|tail|tar|tee|time|timeout|top|touch|tr|traceroute|tsort|tty|umount|uname|unexpand|uniq|units|unrar|unshar|unzip|update-grub|uptime|useradd|userdel|usermod|users|uudecode|uuencode|v|vcpkg|vdir|vi|vim|virsh|vmstat|wait|watch|wc|wget|whereis|which|who|whoami|write|xargs|xdg-open|yarn|yes|zenity|zip|zsh|zypper)(?=$|[)\s;|&])/, lookbehind: !0 }, keyword: { pattern: /(^|[\s;|&]|[<>]\()(?:case|do|done|elif|else|esac|fi|for|function|if|in|select|then|until|while)(?=$|[)\s;|&])/, lookbehind: !0 }, builtin: { pattern: /(^|[\s;|&]|[<>]\()(?:\.|:|alias|bind|break|builtin|caller|cd|command|continue|declare|echo|enable|eval|exec|exit|export|getopts|hash|help|let|local|logout|mapfile|printf|pwd|read|readarray|readonly|return|set|shift|shopt|source|test|times|trap|type|typeset|ulimit|umask|unalias|unset)(?=$|[)\s;|&])/, lookbehind: !0, alias: "class-name" }, boolean: { pattern: /(^|[\s;|&]|[<>]\()(?:false|true)(?=$|[)\s;|&])/, lookbehind: !0 }, "file-descriptor": { pattern: /\B&\d\b/, alias: "important" }, operator: { pattern: /\d?<>|>\||\+=|=[=~]?|!=?|<<[<-]?|[&\d]?>>|\d[<>]&?|[<>][&=]?|&[>&]?|\|[&|]?/, inside: { "file-descriptor": { pattern: /^\d/, alias: "important" } } }, punctuation: /\$?\(\(?|\)\)?|\.\.|[{}[\];\\]/, number: { pattern: /(^|\s)(?:[1-9]\d*|0)(?:[.,]\d+)?\b/, lookbehind: !0 } }, s.inside = e.languages.bash;
+  for (var o = ["comment", "function-name", "for-or-select", "assign-left", "parameter", "string", "environment", "function", "keyword", "builtin", "boolean", "file-descriptor", "operator", "punctuation", "number"], r = t.variable[1].inside, n = 0; n < o.length; n++) r[o[n]] = e.languages.bash[o[n]];
+  e.languages.sh = e.languages.bash, e.languages.shell = e.languages.bash;
+})(Prism);

package/lib/prism-csharp.min-Yizuc34Y.js

@@ -0,0 +1,34 @@
+(function(s) {
+  function n(a, o) {
+    return a.replace(/<<(\d+)>>/g, function(f, H) {
+      return "(?:" + o[+H] + ")";
+    });
+  }
+  function e(a, o, f) {
+    return RegExp(n(a, o), "");
+  }
+  function d(a, o) {
+    for (var f = 0; f < o; f++) a = a.replace(/<<self>>/g, function() {
+      return "(?:" + a + ")";
+    });
+    return a.replace(/<<self>>/g, "[^\\s\\S]");
+  }
+  var w = "bool byte char decimal double dynamic float int long object sbyte short string uint ulong ushort var void", p = "class enum interface record struct", v = "add alias and ascending async await by descending from(?=\\s*(?:\\w|$)) get global group into init(?=\\s*;) join let nameof not notnull on or orderby partial remove select set unmanaged value when where with(?=\\s*{)", m = "abstract as base break case catch checked const continue default delegate do else event explicit extern finally fixed for foreach goto if implicit in internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static switch this throw try typeof unchecked unsafe using virtual volatile while yield";
+  function c(a) {
+    return "\\b(?:" + a.trim().replace(/ /g, "|") + ")\\b";
+  }
+  var x = c(p), u = RegExp(c(w + " " + p + " " + v + " " + m)), U = c(p + " " + v + " " + m), Z = c(w + " " + p + " " + m), g = d("<(?:[^<>;=+\\-*/%&|^]|<<self>>)*>", 2), b = d("\\((?:[^()]|<<self>>)*\\)", 2), r = "@?\\b[A-Za-z_]\\w*\\b", h = n("<<0>>(?:\\s*<<1>>)?", [r, g]), i = n("(?!<<0>>)<<1>>(?:\\s*\\.\\s*<<1>>)*", [U, h]), k = "\\[\\s*(?:,\\s*)*\\]", q = n("<<0>>(?:\\s*(?:\\?\\s*)?<<1>>)*(?:\\s*\\?)?", [i, k]), C = n("[^,()<>[\\];=+\\-*/%&|^]|<<0>>|<<1>>|<<2>>", [g, b, k]), D = n("\\(<<0>>+(?:,<<0>>+)+\\)", [C]), l = n("(?:<<0>>|<<1>>)(?:\\s*(?:\\?\\s*)?<<2>>)*(?:\\s*\\?)?", [D, i, k]), t = { keyword: u, punctuation: /[<>()?,.:[\]]/ }, $ = `'(?:[^\r
+'\\\\]|\\\\.|\\\\[Uux][\\da-fA-F]{1,8})'`, _ = `"(?:\\\\.|[^\\\\"\r
+])*"`;
+  s.languages.csharp = s.languages.extend("clike", { string: [{ pattern: e("(^|[^$\\\\])<<0>>", ['@"(?:""|\\\\[^]|[^\\\\"])*"(?!")']), lookbehind: !0, greedy: !0 }, { pattern: e("(^|[^@$\\\\])<<0>>", [_]), lookbehind: !0, greedy: !0 }], "class-name": [{ pattern: e("(\\busing\\s+static\\s+)<<0>>(?=\\s*;)", [i]), lookbehind: !0, inside: t }, { pattern: e("(\\busing\\s+<<0>>\\s*=\\s*)<<1>>(?=\\s*;)", [r, l]), lookbehind: !0, inside: t }, { pattern: e("(\\busing\\s+)<<0>>(?=\\s*=)", [r]), lookbehind: !0 }, { pattern: e("(\\b<<0>>\\s+)<<1>>", [x, h]), lookbehind: !0, inside: t }, { pattern: e("(\\bcatch\\s*\\(\\s*)<<0>>", [i]), lookbehind: !0, inside: t }, { pattern: e("(\\bwhere\\s+)<<0>>", [r]), lookbehind: !0 }, { pattern: e("(\\b(?:is(?:\\s+not)?|as)\\s+)<<0>>", [q]), lookbehind: !0, inside: t }, { pattern: e("\\b<<0>>(?=\\s+(?!<<1>>|with\\s*\\{)<<2>>(?:\\s*[=,;:{)\\]]|\\s+(?:in|when)\\b))", [l, Z, r]), inside: t }], keyword: u, number: /(?:\b0(?:x[\da-f_]*[\da-f]|b[01_]*[01])|(?:\B\.\d+(?:_+\d+)*|\b\d+(?:_+\d+)*(?:\.\d+(?:_+\d+)*)?)(?:e[-+]?\d+(?:_+\d+)*)?)(?:[dflmu]|lu|ul)?\b/i, operator: />>=?|<<=?|[-=]>|([-+&|])\1|~|\?\?=?|[-+*/%&|^!=<>]=?/, punctuation: /\?\.?|::|[{}[\];(),.:]/ }), s.languages.insertBefore("csharp", "number", { range: { pattern: /\.\./, alias: "operator" } }), s.languages.insertBefore("csharp", "punctuation", { "named-parameter": { pattern: e("([(,]\\s*)<<0>>(?=\\s*:)", [r]), lookbehind: !0, alias: "punctuation" } }), s.languages.insertBefore("csharp", "class-name", { namespace: { pattern: e("(\\b(?:namespace|using)\\s+)<<0>>(?:\\s*\\.\\s*<<0>>)*(?=\\s*[;{])", [r]), lookbehind: !0, inside: { punctuation: /\./ } }, "type-expression": { pattern: e("(\\b(?:default|sizeof|typeof)\\s*\\(\\s*(?!\\s))(?:[^()\\s]|\\s(?!\\s)|<<0>>)*(?=\\s*\\))", [b]), lookbehind: !0, alias: "class-name", inside: t }, "return-type": { pattern: e("<<0>>(?=\\s+(?:<<1>>\\s*(?:=>|[({]|\\.\\s*this\\s*\\[)|this\\s*\\[))", [l, i]), inside: t, alias: "class-name" }, "constructor-invocation": { pattern: e("(\\bnew\\s+)<<0>>(?=\\s*[[({])", [l]), lookbehind: !0, inside: t, alias: "class-name" }, "generic-method": { pattern: e("<<0>>\\s*<<1>>(?=\\s*\\()", [r, g]), inside: { function: e("^<<0>>", [r]), generic: { pattern: RegExp(g), alias: "class-name", inside: t } } }, "type-list": { pattern: e("\\b((?:<<0>>\\s+<<1>>|record\\s+<<1>>\\s*<<5>>|where\\s+<<2>>)\\s*:\\s*)(?:<<3>>|<<4>>|<<1>>\\s*<<5>>|<<6>>)(?:\\s*,\\s*(?:<<3>>|<<4>>|<<6>>))*(?=\\s*(?:where|[{;]|=>|$))", [x, h, r, l, u.source, b, "\\bnew\\s*\\(\\s*\\)"]), lookbehind: !0, inside: { "record-arguments": { pattern: e("(^(?!new\\s*\\()<<0>>\\s*)<<1>>", [h, b]), lookbehind: !0, greedy: !0, inside: s.languages.csharp }, keyword: u, "class-name": { pattern: RegExp(l), greedy: !0, inside: t }, punctuation: /[,()]/ } }, preprocessor: { pattern: /(^[\t ]*)#.*/m, lookbehind: !0, alias: "property", inside: { directive: { pattern: /(#)\b(?:define|elif|else|endif|endregion|error|if|line|nullable|pragma|region|undef|warning)\b/, lookbehind: !0, alias: "keyword" } } } });
+  var B = _ + "|" + $, E = n(`/(?![*/])|//[^\r
+]*[\r
+]|/\\*(?:[^*]|\\*(?!/))*\\*/|<<0>>`, [B]), R = d(n(`[^"'/()]|<<0>>|\\(<<self>>*\\)`, [E]), 2), z = "\\b(?:assembly|event|field|method|module|param|property|return|type)\\b", G = n("<<0>>(?:\\s*\\(<<1>>*\\))?", [i, R]);
+  s.languages.insertBefore("csharp", "class-name", { attribute: { pattern: e("((?:^|[^\\s\\w>)?])\\s*\\[\\s*)(?:<<0>>\\s*:\\s*)?<<1>>(?:\\s*,\\s*<<1>>)*(?=\\s*\\])", [z, G]), lookbehind: !0, greedy: !0, inside: { target: { pattern: e("^<<0>>(?=\\s*:)", [z]), alias: "keyword" }, "attribute-arguments": { pattern: e("\\(<<0>>*\\)", [R]), inside: s.languages.csharp }, "class-name": { pattern: RegExp(i), inside: { punctuation: /\./ } }, punctuation: /[:,]/ } } });
+  var y = `:[^}\r
+]+`, S = d(n(`[^"'/()]|<<0>>|\\(<<self>>*\\)`, [E]), 2), j = n("\\{(?!\\{)(?:(?![}:])<<0>>)*<<1>>?\\}", [S, y]), A = d(n(`[^"'/()]|/(?!\\*)|/\\*(?:[^*]|\\*(?!/))*\\*/|<<0>>|\\(<<self>>*\\)`, [B]), 2), F = n("\\{(?!\\{)(?:(?![}:])<<0>>)*<<1>>?\\}", [A, y]);
+  function P(a, o) {
+    return { interpolation: { pattern: e("((?:^|[^{])(?:\\{\\{)*)<<0>>", [a]), lookbehind: !0, inside: { "format-string": { pattern: e("(^\\{(?:(?![}:])<<0>>)*)<<1>>(?=\\}$)", [o, y]), lookbehind: !0, inside: { punctuation: /^:/ } }, punctuation: /^\{|\}$/, expression: { pattern: /[\s\S]+/, alias: "language-csharp", inside: s.languages.csharp } } }, string: /[\s\S]+/ };
+  }
+  s.languages.insertBefore("csharp", "string", { "interpolation-string": [{ pattern: e('(^|[^\\\\])(?:\\$@|@\\$)"(?:""|\\\\[^]|\\{\\{|<<0>>|[^\\\\{"])*"', [j]), lookbehind: !0, greedy: !0, inside: P(j, S) }, { pattern: e('(^|[^@\\\\])\\$"(?:\\\\.|\\{\\{|<<0>>|[^\\\\"{])*"', [F]), lookbehind: !0, greedy: !0, inside: P(F, A) }], char: { pattern: RegExp($), greedy: !0 } }), s.languages.dotnet = s.languages.cs = s.languages.csharp;
+})(Prism);

package/lib/prism-java.min-d5iT_mOd.js

@@ -0,0 +1,6 @@
+(function(n) {
+  var s = /\b(?:abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|exports|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|module|native|new|non-sealed|null|open|opens|package|permits|private|protected|provides|public|record(?!\s*[(){}[\]<>=%~.:,;?+\-*/&|^])|requires|return|sealed|short|static|strictfp|super|switch|synchronized|this|throw|throws|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\b/, t = "(?:[a-z]\\w*\\s*\\.\\s*)*(?:[A-Z]\\w*\\s*\\.\\s*)*", e = { pattern: RegExp("(^|[^\\w.])" + t + "[A-Z](?:[\\d_A-Z]*[a-z]\\w*)?\\b"), lookbehind: !0, inside: { namespace: { pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/, inside: { punctuation: /\./ } }, punctuation: /\./ } };
+  n.languages.java = n.languages.extend("clike", { string: { pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"/, lookbehind: !0, greedy: !0 }, "class-name": [e, { pattern: RegExp("(^|[^\\w.])" + t + "[A-Z]\\w*(?=\\s+\\w+\\s*[;,=()]|\\s*(?:\\[[\\s,]*\\]\\s*)?::\\s*new\\b)"), lookbehind: !0, inside: e.inside }, { pattern: RegExp("(\\b(?:class|enum|extends|implements|instanceof|interface|new|record|throws)\\s+)" + t + "[A-Z]\\w*\\b"), lookbehind: !0, inside: e.inside }], keyword: s, function: [n.languages.clike.function, { pattern: /(::\s*)[a-z_]\w*/, lookbehind: !0 }], number: /\b0b[01][01_]*L?\b|\b0x(?:\.[\da-f_p+-]+|[\da-f_]+(?:\.[\da-f_p+-]+)?)\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfl]?/i, operator: { pattern: /(^|[^.])(?:<<=?|>>>?=?|->|--|\+\+|&&|\|\||::|[?:~]|[-+*/%&|^!=<>]=?)/m, lookbehind: !0 }, constant: /\b[A-Z][A-Z_\d]+\b/ }), n.languages.insertBefore("java", "string", { "triple-quoted-string": { pattern: /"""[ \t]*[\r\n](?:(?:"|"")?(?:\\.|[^"\\]))*"""/, greedy: !0, alias: "string" }, char: { pattern: /'(?:\\.|[^'\\\r\n]){1,6}'/, greedy: !0 } }), n.languages.insertBefore("java", "class-name", { annotation: { pattern: /(^|[^.])@\w+(?:\s*\.\s*\w+)*/, lookbehind: !0, alias: "punctuation" }, generics: { pattern: /<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&))*>)*>)*>)*>/, inside: { "class-name": e, keyword: s, punctuation: /[<>(),.:]/, operator: /[?&|]/ } }, import: [{ pattern: RegExp("(\\bimport\\s+)" + t + "(?:[A-Z]\\w*|\\*)(?=\\s*;)"), lookbehind: !0, inside: { namespace: e.inside.namespace, punctuation: /\./, operator: /\*/, "class-name": /\w+/ } }, { pattern: RegExp("(\\bimport\\s+static\\s+)" + t + "(?:\\w+|\\*)(?=\\s*;)"), lookbehind: !0, alias: "static", inside: { namespace: e.inside.namespace, static: /\b\w+$/, punctuation: /\./, operator: /\*/, "class-name": /\w+/ } }], namespace: { pattern: RegExp("(\\b(?:exports|import(?:\\s+static)?|module|open|opens|package|provides|requires|to|transitive|uses|with)\\s+)(?!<keyword>)[a-z]\\w*(?:\\.[a-z]\\w*)*\\.?".replace(/<keyword>/g, function() {
+    return s.source;
+  })), lookbehind: !0, inside: { punctuation: /\./ } } });
+})(Prism);

package/lib/prism-json.min-B1GJqK1k.js

@@ -0,0 +1 @@
+Prism.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" } }, Prism.languages.webmanifest = Prism.languages.json;

package/lib/prism-markup-templating-DZrrEs0A.js

@@ -0,0 +1,61 @@
+(function(u) {
+  function s(r, a) {
+    return "___" + r.toUpperCase() + a + "___";
+  }
+  Object.defineProperties(u.languages["markup-templating"] = {}, {
+    buildPlaceholders: {
+      /**
+       * Tokenize all inline templating expressions matching `placeholderPattern`.
+       *
+       * If `replaceFilter` is provided, only matches of `placeholderPattern` for which `replaceFilter` returns
+       * `true` will be replaced.
+       *
+       * @param {object} env The environment of the `before-tokenize` hook.
+       * @param {string} language The language id.
+       * @param {RegExp} placeholderPattern The matches of this pattern will be replaced by placeholders.
+       * @param {(match: string) => boolean} [replaceFilter]
+       */
+      value: function(r, a, c, e) {
+        if (r.language === a) {
+          var f = r.tokenStack = [];
+          r.code = r.code.replace(c, function(n) {
+            if (typeof e == "function" && !e(n))
+              return n;
+            for (var i = f.length, t; r.code.indexOf(t = s(a, i)) !== -1; )
+              ++i;
+            return f[i] = n, t;
+          }), r.grammar = u.languages.markup;
+        }
+      }
+    },
+    tokenizePlaceholders: {
+      /**
+       * Replace placeholders with proper tokens after tokenizing.
+       *
+       * @param {object} env The environment of the `after-tokenize` hook.
+       * @param {string} language The language id.
+       */
+      value: function(r, a) {
+        if (r.language !== a || !r.tokenStack)
+          return;
+        r.grammar = u.languages[a];
+        var c = 0, e = Object.keys(r.tokenStack);
+        function f(n) {
+          for (var i = 0; i < n.length && !(c >= e.length); i++) {
+            var t = n[i];
+            if (typeof t == "string" || t.content && typeof t.content == "string") {
+              var p = e[c], y = r.tokenStack[p], g = typeof t == "string" ? t : t.content, h = s(a, p), l = g.indexOf(h);
+              if (l > -1) {
+                ++c;
+                var d = g.substring(0, l), v = new u.Token(a, u.tokenize(y, r.grammar), "language-" + a, y), k = g.substring(l + h.length), o = [];
+                d && o.push.apply(o, f([d])), o.push(v), k && o.push.apply(o, f([k])), typeof t == "string" ? n.splice.apply(n, [i, 1].concat(o)) : t.content = o;
+              }
+            } else t.content && f(t.content);
+          }
+          return n;
+        }
+        f(r.tokens);
+      }
+    }
+  });
+})(Prism);

package/lib/prism-objectivec.min-BXSWqpJJ.js

@@ -0,0 +1 @@
+Prism.languages.objectivec = Prism.languages.extend("c", { string: { pattern: /@?"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/, greedy: !0 }, keyword: /\b(?:asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|in|inline|int|long|register|return|self|short|signed|sizeof|static|struct|super|switch|typedef|typeof|union|unsigned|void|volatile|while)\b|(?:@interface|@end|@implementation|@protocol|@class|@public|@protected|@private|@property|@try|@catch|@finally|@throw|@synthesize|@dynamic|@selector)\b/, operator: /-[->]?|\+\+?|!=?|<<?=?|>>?=?|==?|&&?|\|\|?|[~^%?*\/@]/ }), delete Prism.languages.objectivec["class-name"], Prism.languages.objc = Prism.languages.objectivec;

package/lib/prism-php.min-o7FpoMP_.js

@@ -0,0 +1,10 @@
+(function(e) {
+  var t = /\/\*[\s\S]*?\*\/|\/\/.*|#(?!\[).*/, i = [{ pattern: /\b(?:false|true)\b/i, alias: "boolean" }, { pattern: /(::\s*)\b[a-z_]\w*\b(?!\s*\()/i, greedy: !0, lookbehind: !0 }, { pattern: /(\b(?:case|const)\s+)\b[a-z_]\w*(?=\s*[;=])/i, greedy: !0, lookbehind: !0 }, /\b(?:null)\b/i, /\b[A-Z_][A-Z0-9_]*\b(?!\s*\()/], n = /\b0b[01]+(?:_[01]+)*\b|\b0o[0-7]+(?:_[0-7]+)*\b|\b0x[\da-f]+(?:_[\da-f]+)*\b|(?:\b\d+(?:_\d+)*\.?(?:\d+(?:_\d+)*)?|\B\.\d+)(?:e[+-]?\d+)?/i, s = /<?=>|\?\?=?|\.{3}|\??->|[!=]=?=?|::|\*\*=?|--|\+\+|&&|\|\||<<|>>|[?~]|[/^|%*&<>.+-]=?/, l = /[{}\[\](),:;]/;
+  e.languages.php = { delimiter: { pattern: /\?>$|^<\?(?:php(?=\s)|=)?/i, alias: "important" }, comment: t, variable: /\$+(?:\w+\b|(?=\{))/, package: { pattern: /(namespace\s+|use\s+(?:function\s+)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i, lookbehind: !0, inside: { punctuation: /\\/ } }, "class-name-definition": { pattern: /(\b(?:class|enum|interface|trait)\s+)\b[a-z_]\w*(?!\\)\b/i, lookbehind: !0, alias: "class-name" }, "function-definition": { pattern: /(\bfunction\s+)[a-z_]\w*(?=\s*\()/i, lookbehind: !0, alias: "function" }, keyword: [{ pattern: /(\(\s*)\b(?:array|bool|boolean|float|int|integer|object|string)\b(?=\s*\))/i, alias: "type-casting", greedy: !0, lookbehind: !0 }, { pattern: /([(,?]\s*)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|object|self|static|string)\b(?=\s*\$)/i, alias: "type-hint", greedy: !0, lookbehind: !0 }, { pattern: /(\)\s*:\s*(?:\?\s*)?)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|never|object|self|static|string|void)\b/i, alias: "return-type", greedy: !0, lookbehind: !0 }, { pattern: /\b(?:array(?!\s*\()|bool|float|int|iterable|mixed|object|string|void)\b/i, alias: "type-declaration", greedy: !0 }, { pattern: /(\|\s*)(?:false|null)\b|\b(?:false|null)(?=\s*\|)/i, alias: "type-declaration", greedy: !0, lookbehind: !0 }, { pattern: /\b(?:parent|self|static)(?=\s*::)/i, alias: "static-context", greedy: !0 }, { pattern: /(\byield\s+)from\b/i, lookbehind: !0 }, /\bclass\b/i, { pattern: /((?:^|[^\s>:]|(?:^|[^-])>|(?:^|[^:]):)\s*)\b(?:abstract|and|array|as|break|callable|case|catch|clone|const|continue|declare|default|die|do|echo|else|elseif|empty|enddeclare|endfor|endforeach|endif|endswitch|endwhile|enum|eval|exit|extends|final|finally|fn|for|foreach|function|global|goto|if|implements|include|include_once|instanceof|insteadof|interface|isset|list|match|namespace|never|new|or|parent|print|private|protected|public|readonly|require|require_once|return|self|static|switch|throw|trait|try|unset|use|var|while|xor|yield|__halt_compiler)\b/i, lookbehind: !0 }], "argument-name": { pattern: /([(,]\s*)\b[a-z_]\w*(?=\s*:(?!:))/i, lookbehind: !0 }, "class-name": [{ pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self|\s+static))\s+|\bcatch\s*\()\b[a-z_]\w*(?!\\)\b/i, greedy: !0, lookbehind: !0 }, { pattern: /(\|\s*)\b[a-z_]\w*(?!\\)\b/i, greedy: !0, lookbehind: !0 }, { pattern: /\b[a-z_]\w*(?!\\)\b(?=\s*\|)/i, greedy: !0 }, { pattern: /(\|\s*)(?:\\?\b[a-z_]\w*)+\b/i, alias: "class-name-fully-qualified", greedy: !0, lookbehind: !0, inside: { punctuation: /\\/ } }, { pattern: /(?:\\?\b[a-z_]\w*)+\b(?=\s*\|)/i, alias: "class-name-fully-qualified", greedy: !0, inside: { punctuation: /\\/ } }, { pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self\b|\s+static\b))\s+|\bcatch\s*\()(?:\\?\b[a-z_]\w*)+\b(?!\\)/i, alias: "class-name-fully-qualified", greedy: !0, lookbehind: !0, inside: { punctuation: /\\/ } }, { pattern: /\b[a-z_]\w*(?=\s*\$)/i, alias: "type-declaration", greedy: !0 }, { pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i, alias: ["class-name-fully-qualified", "type-declaration"], greedy: !0, inside: { punctuation: /\\/ } }, { pattern: /\b[a-z_]\w*(?=\s*::)/i, alias: "static-context", greedy: !0 }, { pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*::)/i, alias: ["class-name-fully-qualified", "static-context"], greedy: !0, inside: { punctuation: /\\/ } }, { pattern: /([(,?]\s*)[a-z_]\w*(?=\s*\$)/i, alias: "type-hint", greedy: !0, lookbehind: !0 }, { pattern: /([(,?]\s*)(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i, alias: ["class-name-fully-qualified", "type-hint"], greedy: !0, lookbehind: !0, inside: { punctuation: /\\/ } }, { pattern: /(\)\s*:\s*(?:\?\s*)?)\b[a-z_]\w*(?!\\)\b/i, alias: "return-type", greedy: !0, lookbehind: !0 }, { pattern: /(\)\s*:\s*(?:\?\s*)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i, alias: ["class-name-fully-qualified", "return-type"], greedy: !0, lookbehind: !0, inside: { punctuation: /\\/ } }], constant: i, function: { pattern: /(^|[^\\\w])\\?[a-z_](?:[\w\\]*\w)?(?=\s*\()/i, lookbehind: !0, inside: { punctuation: /\\/ } }, property: { pattern: /(->\s*)\w+/, lookbehind: !0 }, number: n, operator: s, punctuation: l };
+  var r = { pattern: /\{\$(?:\{(?:\{[^{}]+\}|[^{}]+)\}|[^{}])+\}|(^|[^\\{])\$+(?:\w+(?:\[[^\r\n\[\]]+\]|->\w+)?)/, lookbehind: !0, inside: e.languages.php }, o = [{ pattern: /<<<'([^']+)'[\r\n](?:.*[\r\n])*?\1;/, alias: "nowdoc-string", greedy: !0, inside: { delimiter: { pattern: /^<<<'[^']+'|[a-z_]\w*;$/i, alias: "symbol", inside: { punctuation: /^<<<'?|[';]$/ } } } }, { pattern: /<<<(?:"([^"]+)"[\r\n](?:.*[\r\n])*?\1;|([a-z_]\w*)[\r\n](?:.*[\r\n])*?\2;)/i, alias: "heredoc-string", greedy: !0, inside: { delimiter: { pattern: /^<<<(?:"[^"]+"|[a-z_]\w*)|[a-z_]\w*;$/i, alias: "symbol", inside: { punctuation: /^<<<"?|[";]$/ } }, interpolation: r } }, { pattern: /`(?:\\[\s\S]|[^\\`])*`/, alias: "backtick-quoted-string", greedy: !0 }, { pattern: /'(?:\\[\s\S]|[^\\'])*'/, alias: "single-quoted-string", greedy: !0 }, { pattern: /"(?:\\[\s\S]|[^\\"])*"/, alias: "double-quoted-string", greedy: !0, inside: { interpolation: r } }];
+  e.languages.insertBefore("php", "variable", { string: o, attribute: { pattern: /#\[(?:[^"'\/#]|\/(?![*/])|\/\/.*$|#(?!\[).*$|\/\*(?:[^*]|\*(?!\/))*\*\/|"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*')+\](?=\s*[a-z$#])/im, greedy: !0, inside: { "attribute-content": { pattern: /^(#\[)[\s\S]+(?=\]$)/, lookbehind: !0, inside: { comment: t, string: o, "attribute-class-name": [{ pattern: /([^:]|^)\b[a-z_]\w*(?!\\)\b/i, alias: "class-name", greedy: !0, lookbehind: !0 }, { pattern: /([^:]|^)(?:\\?\b[a-z_]\w*)+/i, alias: ["class-name", "class-name-fully-qualified"], greedy: !0, lookbehind: !0, inside: { punctuation: /\\/ } }], constant: i, number: n, operator: s, punctuation: l } }, delimiter: { pattern: /^#\[|\]$/, alias: "punctuation" } } } }), e.hooks.add("before-tokenize", function(a) {
+    /<\?/.test(a.code) && e.languages["markup-templating"].buildPlaceholders(a, "php", /<\?(?:[^"'/#]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|(?:\/\/|#(?!\[))(?:[^?\n\r]|\?(?!>))*(?=$|\?>|[\r\n])|#\[|\/\*(?:[^*]|\*(?!\/))*(?:\*\/|$))*?(?:\?>|$)/g);
+  }), e.hooks.add("after-tokenize", function(a) {
+    e.languages["markup-templating"].tokenizePlaceholders(a, "php");
+  });
+})(Prism);

package/lib/prism-ruby.min-C7LwcKyz.js

@@ -0,0 +1,9 @@
+(function(e) {
+  e.languages.ruby = e.languages.extend("clike", { comment: { pattern: /#.*|^=begin\s[\s\S]*?^=end/m, greedy: !0 }, "class-name": { pattern: /(\b(?:class|module)\s+|\bcatch\s+\()[\w.\\]+|\b[A-Z_]\w*(?=\s*\.\s*new\b)/, lookbehind: !0, inside: { punctuation: /[.\\]/ } }, keyword: /\b(?:BEGIN|END|alias|and|begin|break|case|class|def|define_method|defined|do|each|else|elsif|end|ensure|extend|for|if|in|include|module|new|next|nil|not|or|prepend|private|protected|public|raise|redo|require|rescue|retry|return|self|super|then|throw|undef|unless|until|when|while|yield)\b/, operator: /\.{2,3}|&\.|===|<?=>|[!=]?~|(?:&&|\|\||<<|>>|\*\*|[+\-*/%<>!^&|=])=?|[?:]/, punctuation: /[(){}[\].,;]/ }), e.languages.insertBefore("ruby", "operator", { "double-colon": { pattern: /::/, alias: "punctuation" } });
+  var n = { pattern: /((?:^|[^\\])(?:\\{2})*)#\{(?:[^{}]|\{[^{}]*\})*\}/, lookbehind: !0, inside: { content: { pattern: /^(#\{)[\s\S]+(?=\}$)/, lookbehind: !0, inside: e.languages.ruby }, delimiter: { pattern: /^#\{|\}$/, alias: "punctuation" } } };
+  delete e.languages.ruby.function;
+  var t = "(?:" + ["([^a-zA-Z0-9\\s{(\\[<=])(?:(?!\\1)[^\\\\]|\\\\[^])*\\1", "\\((?:[^()\\\\]|\\\\[^]|\\((?:[^()\\\\]|\\\\[^])*\\))*\\)", "\\{(?:[^{}\\\\]|\\\\[^]|\\{(?:[^{}\\\\]|\\\\[^])*\\})*\\}", "\\[(?:[^\\[\\]\\\\]|\\\\[^]|\\[(?:[^\\[\\]\\\\]|\\\\[^])*\\])*\\]", "<(?:[^<>\\\\]|\\\\[^]|<(?:[^<>\\\\]|\\\\[^])*>)*>"].join("|") + ")", i = `(?:"(?:\\\\.|[^"\\\\\r
+])*"|(?:\\b[a-zA-Z_]\\w*|[^\\s\0-\\x7F]+)[?!]?|\\$.)`;
+  e.languages.insertBefore("ruby", "keyword", { "regex-literal": [{ pattern: RegExp("%r" + t + "[egimnosux]{0,6}"), greedy: !0, inside: { interpolation: n, regex: /[\s\S]+/ } }, { pattern: /(^|[^/])\/(?!\/)(?:\[[^\r\n\]]+\]|\\.|[^[/\\\r\n])+\/[egimnosux]{0,6}(?=\s*(?:$|[\r\n,.;})#]))/, lookbehind: !0, greedy: !0, inside: { interpolation: n, regex: /[\s\S]+/ } }], variable: /[@$]+[a-zA-Z_]\w*(?:[?!]|\b)/, symbol: [{ pattern: RegExp("(^|[^:]):" + i), lookbehind: !0, greedy: !0 }, { pattern: RegExp(`([\r
+{(,][ 	]*)` + i + "(?=:(?!:))"), lookbehind: !0, greedy: !0 }], "method-definition": { pattern: /(\bdef\s+)\w+(?:\s*\.\s*\w+)?/, lookbehind: !0, inside: { function: /\b\w+$/, keyword: /^self\b/, "class-name": /^\w+/, punctuation: /\./ } } }), e.languages.insertBefore("ruby", "string", { "string-literal": [{ pattern: RegExp("%[qQiIwWs]?" + t), greedy: !0, inside: { interpolation: n, string: /[\s\S]+/ } }, { pattern: /("|')(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|(?!\1)[^\\#\r\n])*\1/, greedy: !0, inside: { interpolation: n, string: /[\s\S]+/ } }, { pattern: /<<[-~]?([a-z_]\w*)[\r\n](?:.*[\r\n])*?[\t ]*\1/i, alias: "heredoc-string", greedy: !0, inside: { delimiter: { pattern: /^<<[-~]?[a-z_]\w*|\b[a-z_]\w*$/i, inside: { symbol: /\b\w+/, punctuation: /^<<[-~]?/ } }, interpolation: n, string: /[\s\S]+/ } }, { pattern: /<<[-~]?'([a-z_]\w*)'[\r\n](?:.*[\r\n])*?[\t ]*\1/i, alias: "heredoc-string", greedy: !0, inside: { delimiter: { pattern: /^<<[-~]?'[a-z_]\w*'|\b[a-z_]\w*$/i, inside: { symbol: /\b\w+/, punctuation: /^<<[-~]?'|'$/ } }, string: /[\s\S]+/ } }], "command-literal": [{ pattern: RegExp("%x" + t), greedy: !0, inside: { interpolation: n, command: { pattern: /[\s\S]+/, alias: "string" } } }, { pattern: /`(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|[^\\`#\r\n])*`/, greedy: !0, inside: { interpolation: n, command: { pattern: /[\s\S]+/, alias: "string" } } }] }), delete e.languages.ruby.string, e.languages.insertBefore("ruby", "number", { builtin: /\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Fixnum|Float|Hash|IO|Integer|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|Stat|String|Struct|Symbol|TMS|Thread|ThreadGroup|Time|TrueClass)\b/, constant: /\b[A-Z][A-Z0-9_]*(?:[?!]|\b)/ }), e.languages.rb = e.languages.ruby;
+})(Prism);

package/lib/state-2Hu1renZ.js

@@ -0,0 +1,313 @@
+import A from "react";
+var de = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function Q(e) {
+  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+}
+function Se(e) {
+  if (e.__esModule) return e;
+  var i = e.default;
+  if (typeof i == "function") {
+    var a = function f() {
+      return this instanceof f ? Reflect.construct(i, arguments, this.constructor) : i.apply(this, arguments);
+    };
+    a.prototype = i.prototype;
+  } else a = {};
+  return Object.defineProperty(a, "__esModule", { value: !0 }), Object.keys(e).forEach(function(f) {
+    var p = Object.getOwnPropertyDescriptor(e, f);
+    Object.defineProperty(a, f, p.get ? p : {
+      enumerable: !0,
+      get: function() {
+        return e[f];
+      }
+    });
+  }), a;
+}
+var X = { BASE_URL: "/", MODE: "production", DEV: !1, PROD: !0, SSR: !1 };
+const H = (e) => {
+  let i;
+  const a = /* @__PURE__ */ new Set(), f = (u, t) => {
+    const r = typeof u == "function" ? u(i) : u;
+    if (!Object.is(r, i)) {
+      const s = i;
+      i = t ?? (typeof r != "object" || r === null) ? r : Object.assign({}, i, r), a.forEach((d) => d(i, s));
+    }
+  }, p = () => i, h = { setState: f, getState: p, getInitialState: () => E, subscribe: (u) => (a.add(u), () => a.delete(u)), destroy: () => {
+    (X ? "production" : void 0) !== "production" && console.warn(
+      "[DEPRECATED] The `destroy` method will be unsupported in a future version. Instead use unsubscribe function returned by subscribe. Everything will be garbage-collected if store is garbage-collected."
+    ), a.clear();
+  } }, E = i = e(f, p, h);
+  return h;
+}, Z = (e) => e ? H(e) : H;
+var U = { exports: {} }, M = {}, T = { exports: {} }, W = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var K;
+function ee() {
+  if (K) return W;
+  K = 1;
+  var e = A;
+  function i(t, r) {
+    return t === r && (t !== 0 || 1 / t === 1 / r) || t !== t && r !== r;
+  }
+  var a = typeof Object.is == "function" ? Object.is : i, f = e.useState, p = e.useEffect, y = e.useLayoutEffect, g = e.useDebugValue;
+  function L(t, r) {
+    var s = r(), d = f({ inst: { value: s, getSnapshot: r } }), l = d[0].inst, S = d[1];
+    return y(function() {
+      l.value = s, l.getSnapshot = r, h(l) && S({ inst: l });
+    }, [t, s, r]), p(function() {
+      return h(l) && S({ inst: l }), t(function() {
+        h(l) && S({ inst: l });
+      });
+    }, [t]), g(s), s;
+  }
+  function h(t) {
+    var r = t.getSnapshot;
+    t = t.value;
+    try {
+      var s = r();
+      return !a(t, s);
+    } catch {
+      return !0;
+    }
+  }
+  function E(t, r) {
+    return r();
+  }
+  var u = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? E : L;
+  return W.useSyncExternalStore = e.useSyncExternalStore !== void 0 ? e.useSyncExternalStore : u, W;
+}
+var B = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var N;
+function te() {
+  return N || (N = 1, process.env.NODE_ENV !== "production" && function() {
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
+    var e = A, i = e.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function a(c) {
+      {
+        for (var n = arguments.length, v = new Array(n > 1 ? n - 1 : 0), o = 1; o < n; o++)
+          v[o - 1] = arguments[o];
+        f("error", c, v);
+      }
+    }
+    function f(c, n, v) {
+      {
+        var o = i.ReactDebugCurrentFrame, _ = o.getStackAddendum();
+        _ !== "" && (n += "%s", v = v.concat([_]));
+        var m = v.map(function(O) {
+          return String(O);
+        });
+        m.unshift("Warning: " + n), Function.prototype.apply.call(console[c], console, m);
+      }
+    }
+    function p(c, n) {
+      return c === n && (c !== 0 || 1 / c === 1 / n) || c !== c && n !== n;
+    }
+    var y = typeof Object.is == "function" ? Object.is : p, g = e.useState, L = e.useEffect, h = e.useLayoutEffect, E = e.useDebugValue, u = !1, t = !1;
+    function r(c, n, v) {
+      u || e.startTransition !== void 0 && (u = !0, a("You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."));
+      var o = n();
+      if (!t) {
+        var _ = n();
+        y(o, _) || (a("The result of getSnapshot should be cached to avoid an infinite loop"), t = !0);
+      }
+      var m = g({
+        inst: {
+          value: o,
+          getSnapshot: n
+        }
+      }), O = m[0].inst, b = m[1];
+      return h(function() {
+        O.value = o, O.getSnapshot = n, s(O) && b({
+          inst: O
+        });
+      }, [c, o, n]), L(function() {
+        s(O) && b({
+          inst: O
+        });
+        var V = function() {
+          s(O) && b({
+            inst: O
+          });
+        };
+        return c(V);
+      }, [c]), E(o), o;
+    }
+    function s(c) {
+      var n = c.getSnapshot, v = c.value;
+      try {
+        var o = n();
+        return !y(v, o);
+      } catch {
+        return !0;
+      }
+    }
+    function d(c, n, v) {
+      return n();
+    }
+    var l = typeof window < "u" && typeof window.document < "u" && typeof window.document.createElement < "u", S = !l, D = S ? d : r, R = e.useSyncExternalStore !== void 0 ? e.useSyncExternalStore : D;
+    B.useSyncExternalStore = R, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+  }()), B;
+}
+var P;
+function Y() {
+  return P || (P = 1, process.env.NODE_ENV === "production" ? T.exports = ee() : T.exports = te()), T.exports;
+}
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var q;
+function ne() {
+  if (q) return M;
+  q = 1;
+  var e = A, i = Y();
+  function a(E, u) {
+    return E === u && (E !== 0 || 1 / E === 1 / u) || E !== E && u !== u;
+  }
+  var f = typeof Object.is == "function" ? Object.is : a, p = i.useSyncExternalStore, y = e.useRef, g = e.useEffect, L = e.useMemo, h = e.useDebugValue;
+  return M.useSyncExternalStoreWithSelector = function(E, u, t, r, s) {
+    var d = y(null);
+    if (d.current === null) {
+      var l = { hasValue: !1, value: null };
+      d.current = l;
+    } else l = d.current;
+    d = L(function() {
+      function D(o) {
+        if (!R) {
+          if (R = !0, c = o, o = r(o), s !== void 0 && l.hasValue) {
+            var _ = l.value;
+            if (s(_, o)) return n = _;
+          }
+          return n = o;
+        }
+        if (_ = n, f(c, o)) return _;
+        var m = r(o);
+        return s !== void 0 && s(_, m) ? _ : (c = o, n = m);
+      }
+      var R = !1, c, n, v = t === void 0 ? null : t;
+      return [function() {
+        return D(u());
+      }, v === null ? void 0 : function() {
+        return D(v());
+      }];
+    }, [u, t, r, s]);
+    var S = p(E, d[0], d[1]);
+    return g(function() {
+      l.hasValue = !0, l.value = S;
+    }, [S]), h(S), S;
+  }, M;
+}
+var G = {};
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var z;
+function re() {
+  return z || (z = 1, process.env.NODE_ENV !== "production" && function() {
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
+    var e = A, i = Y();
+    function a(u, t) {
+      return u === t && (u !== 0 || 1 / u === 1 / t) || u !== u && t !== t;
+    }
+    var f = typeof Object.is == "function" ? Object.is : a, p = i.useSyncExternalStore, y = e.useRef, g = e.useEffect, L = e.useMemo, h = e.useDebugValue;
+    function E(u, t, r, s, d) {
+      var l = y(null), S;
+      l.current === null ? (S = {
+        hasValue: !1,
+        value: null
+      }, l.current = S) : S = l.current;
+      var D = L(function() {
+        var v = !1, o, _, m = function(w) {
+          if (!v) {
+            v = !0, o = w;
+            var x = s(w);
+            if (d !== void 0 && S.hasValue) {
+              var I = S.value;
+              if (d(I, x))
+                return _ = I, I;
+            }
+            return _ = x, x;
+          }
+          var J = o, j = _;
+          if (f(J, w))
+            return j;
+          var C = s(w);
+          return d !== void 0 && d(j, C) ? j : (o = w, _ = C, C);
+        }, O = r === void 0 ? null : r, b = function() {
+          return m(t());
+        }, V = O === null ? void 0 : function() {
+          return m(O());
+        };
+        return [b, V];
+      }, [t, r, s, d]), R = D[0], c = D[1], n = p(u, R, c);
+      return g(function() {
+        S.hasValue = !0, S.value = n;
+      }, [n]), h(n), n;
+    }
+    G.useSyncExternalStoreWithSelector = E, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+  }()), G;
+}
+process.env.NODE_ENV === "production" ? U.exports = ne() : U.exports = re();
+var oe = U.exports;
+const ue = /* @__PURE__ */ Q(oe);
+var k = { BASE_URL: "/", MODE: "production", DEV: !1, PROD: !0, SSR: !1 };
+const { useDebugValue: ie } = A, { useSyncExternalStoreWithSelector: ae } = ue;
+let F = !1;
+const se = (e) => e;
+function ce(e, i = se, a) {
+  (k ? "production" : void 0) !== "production" && a && !F && (console.warn(
+    "[DEPRECATED] Use `createWithEqualityFn` instead of `create` or use `useStoreWithEqualityFn` instead of `useStore`. They can be imported from 'zustand/traditional'. https://github.com/pmndrs/zustand/discussions/1937"
+  ), F = !0);
+  const f = ae(
+    e.subscribe,
+    e.getState,
+    e.getServerState || e.getInitialState,
+    i,
+    a
+  );
+  return ie(f), f;
+}
+const $ = (e) => {
+  (k ? "production" : void 0) !== "production" && typeof e != "function" && console.warn(
+    "[DEPRECATED] Passing a vanilla store will be unsupported in a future version. Instead use `import { useStore } from 'zustand'`."
+  );
+  const i = typeof e == "function" ? Z(e) : e, a = (f, p) => ce(i, f, p);
+  return Object.assign(a, i), a;
+}, fe = (e) => e ? $(e) : $, _e = fe(() => ({
+  isPending: !0,
+  isAuthenticated: !1
+}));
+export {
+  de as a,
+  Se as b,
+  fe as c,
+  Q as g,
+  _e as u
+};