@kong-ui-public/documentation 0.3.42 → 0.4.0

package/dist/yaml-PGla5xPP-HJurM_FJ.js

@@ -0,0 +1,206 @@
+const e = Object.freeze({ displayName: "YAML", name: "yaml", patterns: [{ include: "#comment" }, { include: "#property" }, { include: "#directive" }, { match: "^---", name: "entity.other.document.begin.yaml" }, { match: "^\\.{3}", name: "entity.other.document.end.yaml" }, { include: "#node" }], repository: { "block-collection": { patterns: [{ include: "#block-sequence" }, { include: "#block-mapping" }] }, "block-mapping": { patterns: [{ include: "#block-pair" }] }, "block-node": { patterns: [{ include: "#prototype" }, { include: "#block-scalar" }, { include: "#block-collection" }, { include: "#flow-scalar-plain-out" }, { include: "#flow-node" }] }, "block-pair": { patterns: [{ begin: "\\?", beginCaptures: { 1: { name: "punctuation.definition.key-value.begin.yaml" } }, end: "(?=\\?)|^ *(:)|(:)", endCaptures: { 1: { name: "punctuation.separator.key-value.mapping.yaml" }, 2: { name: "invalid.illegal.expected-newline.yaml" } }, name: "meta.block-mapping.yaml", patterns: [{ include: "#block-node" }] }, { begin: `(?x)
+(?=
+(?x:
+[^\\s[-?:,\\[\\]{}#&*!|>'"%@\`]]
+| [?:-] \\S
+)
+(
+[^\\s:]
+| : \\S
+| \\s+ (?![#\\s])
+)*
+\\s*
+:
+(\\s|$)
+)
+`, end: `(?x)
+(?=
+\\s* $
+| \\s+ \\#
+| \\s* : (\\s|$)
+)
+`, patterns: [{ include: "#flow-scalar-plain-out-implicit-type" }, { begin: `(?x)
+[^\\s[-?:,\\[\\]{}#&*!|>'"%@\`]]
+| [?:-] \\S
+`, beginCaptures: { 0: { name: "entity.name.tag.yaml" } }, contentName: "entity.name.tag.yaml", end: `(?x)
+(?=
+\\s* $
+| \\s+ \\#
+| \\s* : (\\s|$)
+)
+`, name: "string.unquoted.plain.out.yaml" }] }, { match: ":(?=\\s|$)", name: "punctuation.separator.key-value.mapping.yaml" }] }, "block-scalar": { begin: "(?:(\\|)|(>))([1-9])?([-+])?(.*\\n?)", beginCaptures: { 1: { name: "keyword.control.flow.block-scalar.literal.yaml" }, 2: { name: "keyword.control.flow.block-scalar.folded.yaml" }, 3: { name: "constant.numeric.indentation-indicator.yaml" }, 4: { name: "storage.modifier.chomping-indicator.yaml" }, 5: { patterns: [{ include: "#comment" }, { match: ".+", name: "invalid.illegal.expected-comment-or-newline.yaml" }] } }, end: "^(?=\\S)|(?!\\G)", patterns: [{ begin: "^([ ]+)(?! )", end: "^(?!\\1|\\s*$)", name: "string.unquoted.block.yaml" }] }, "block-sequence": { match: "(-)(?!\\S)", name: "punctuation.definition.block.sequence.item.yaml" }, comment: { begin: "(?:(^[ \\t]*)|[ \\t]+)(?=#\\p{Print}*$)", beginCaptures: { 1: { name: "punctuation.whitespace.comment.leading.yaml" } }, end: "(?!\\G)", patterns: [{ begin: "#", beginCaptures: { 0: { name: "punctuation.definition.comment.yaml" } }, end: "\\n", name: "comment.line.number-sign.yaml" }] }, directive: { begin: "^%", beginCaptures: { 0: { name: "punctuation.definition.directive.begin.yaml" } }, end: "(?=$|[ \\t]+($|#))", name: "meta.directive.yaml", patterns: [{ captures: { 1: { name: "keyword.other.directive.yaml.yaml" }, 2: { name: "constant.numeric.yaml-version.yaml" } }, match: "\\G(YAML)[ \\t]+(\\d+\\.\\d+)" }, { captures: { 1: { name: "keyword.other.directive.tag.yaml" }, 2: { name: "storage.type.tag-handle.yaml" }, 3: { name: "support.type.tag-prefix.yaml" } }, match: `(?x)
+\\G
+(TAG)
+(?:[ \\t]+
+((?:!(?:[0-9A-Za-z\\-]*!)?))
+(?:[ \\t]+ (
+!              (?x: %[0-9A-Fa-f]{2} | [0-9A-Za-z\\-#;/?:@&=+$,_.!~*'()\\[\\]] )*
+| (?![,!\\[\\]{}]) (?x: %[0-9A-Fa-f]{2} | [0-9A-Za-z\\-#;/?:@&=+$,_.!~*'()\\[\\]] )+
+)
+)?
+)?
+` }, { captures: { 1: { name: "support.other.directive.reserved.yaml" }, 2: { name: "string.unquoted.directive-name.yaml" }, 3: { name: "string.unquoted.directive-parameter.yaml" } }, match: "(?x) \\G (\\w+) (?:[ \\t]+ (\\w+) (?:[ \\t]+ (\\w+))? )?" }, { match: "\\S+", name: "invalid.illegal.unrecognized.yaml" }] }, "flow-alias": { captures: { 1: { name: "keyword.control.flow.alias.yaml" }, 2: { name: "punctuation.definition.alias.yaml" }, 3: { name: "variable.other.alias.yaml" }, 4: { name: "invalid.illegal.character.anchor.yaml" } }, match: "((\\*))([^\\s\\[\\]/{/},]+)([^\\s\\]},]\\S*)?" }, "flow-collection": { patterns: [{ include: "#flow-sequence" }, { include: "#flow-mapping" }] }, "flow-mapping": { begin: "\\{", beginCaptures: { 0: { name: "punctuation.definition.mapping.begin.yaml" } }, end: "\\}", endCaptures: { 0: { name: "punctuation.definition.mapping.end.yaml" } }, name: "meta.flow-mapping.yaml", patterns: [{ include: "#prototype" }, { match: ",", name: "punctuation.separator.mapping.yaml" }, { include: "#flow-pair" }] }, "flow-node": { patterns: [{ include: "#prototype" }, { include: "#flow-alias" }, { include: "#flow-collection" }, { include: "#flow-scalar" }] }, "flow-pair": { patterns: [{ begin: "\\?", beginCaptures: { 0: { name: "punctuation.definition.key-value.begin.yaml" } }, end: "(?=[},\\]])", name: "meta.flow-pair.explicit.yaml", patterns: [{ include: "#prototype" }, { include: "#flow-pair" }, { include: "#flow-node" }, { begin: ":(?=\\s|$|[\\[\\]{},])", beginCaptures: { 0: { name: "punctuation.separator.key-value.mapping.yaml" } }, end: "(?=[},\\]])", patterns: [{ include: "#flow-value" }] }] }, { begin: `(?x)
+(?=
+(?:
+[^\\s[-?:,\\[\\]{}#&*!|>'"%@\`]]
+| [?:-] [^\\s[\\[\\]{},]]
+)
+(
+[^\\s:[\\[\\]{},]]
+| : [^\\s[\\[\\]{},]]
+| \\s+ (?![#\\s])
+)*
+\\s*
+:
+(\\s|$)
+)
+`, end: `(?x)
+(?=
+\\s* $
+| \\s+ \\#
+| \\s* : (\\s|$)
+| \\s* : [\\[\\]{},]
+| \\s* [\\[\\]{},]
+)
+`, name: "meta.flow-pair.key.yaml", patterns: [{ include: "#flow-scalar-plain-in-implicit-type" }, { begin: `(?x)
+[^\\s[-?:,\\[\\]{}#&*!|>'"%@\`]]
+| [?:-] [^\\s[\\[\\]{},]]
+`, beginCaptures: { 0: { name: "entity.name.tag.yaml" } }, contentName: "entity.name.tag.yaml", end: `(?x)
+(?=
+\\s* $
+| \\s+ \\#
+| \\s* : (\\s|$)
+| \\s* : [\\[\\]{},]
+| \\s* [\\[\\]{},]
+)
+`, name: "string.unquoted.plain.in.yaml" }] }, { include: "#flow-node" }, { begin: ":(?=\\s|$|[\\[\\]{},])", captures: { 0: { name: "punctuation.separator.key-value.mapping.yaml" } }, end: "(?=[},\\]])", name: "meta.flow-pair.yaml", patterns: [{ include: "#flow-value" }] }] }, "flow-scalar": { patterns: [{ include: "#flow-scalar-double-quoted" }, { include: "#flow-scalar-single-quoted" }, { include: "#flow-scalar-plain-in" }] }, "flow-scalar-double-quoted": { begin: '"', beginCaptures: { 0: { name: "punctuation.definition.string.begin.yaml" } }, end: '"', endCaptures: { 0: { name: "punctuation.definition.string.end.yaml" } }, name: "string.quoted.double.yaml", patterns: [{ match: '\\\\([0abtnvfre "/\\\\N_Lp]|x\\d\\d|u\\d{4}|U\\d{8})', name: "constant.character.escape.yaml" }, { match: "\\\\\\n", name: "constant.character.escape.double-quoted.newline.yaml" }] }, "flow-scalar-plain-in": { patterns: [{ include: "#flow-scalar-plain-in-implicit-type" }, { begin: `(?x)
+[^\\s[-?:,\\[\\]{}#&*!|>'"%@\`]]
+| [?:-] [^\\s[\\[\\]{},]]
+`, end: `(?x)
+(?=
+\\s* $
+| \\s+ \\#
+| \\s* : (\\s|$)
+| \\s* : [\\[\\]{},]
+| \\s* [\\[\\]{},]
+)
+`, name: "string.unquoted.plain.in.yaml" }] }, "flow-scalar-plain-in-implicit-type": { patterns: [{ captures: { 1: { name: "constant.language.null.yaml" }, 2: { name: "constant.language.boolean.yaml" }, 3: { name: "constant.numeric.integer.yaml" }, 4: { name: "constant.numeric.float.yaml" }, 5: { name: "constant.other.timestamp.yaml" }, 6: { name: "constant.language.value.yaml" }, 7: { name: "constant.language.merge.yaml" } }, match: `(?x)
+(?x:
+(null|Null|NULL|~)
+| (y|Y|yes|Yes|YES|n|N|no|No|NO|true|True|TRUE|false|False|FALSE|on|On|ON|off|Off|OFF)
+| (
+(?:
+[-+]? 0b [0-1_]+
+| [-+]? 0  [0-7_]+
+| [-+]? (?: 0|[1-9][0-9_]*)
+| [-+]? 0x [0-9a-fA-F_]+
+| [-+]? [1-9] [0-9_]* (?: :[0-5]?[0-9])+
+)
+)
+| (
+(?x:
+[-+]? (?: [0-9] [0-9_]*)? \\. [0-9.]* (?: [eE] [-+] [0-9]+)?
+| [-+]? [0-9] [0-9_]* (?: :[0-5]?[0-9])+ \\. [0-9_]*
+| [-+]? \\. (?: inf|Inf|INF)
+|       \\. (?: nan|NaN|NAN)
+)
+)
+| (
+(?x:
+\\d{4} - \\d{2} - \\d{2}
+| \\d{4}
+- \\d{1,2}
+- \\d{1,2}
+(?: [Tt] | [ \\t]+) \\d{1,2}
+: \\d{2}
+: \\d{2}
+(?: \\.\\d*)?
+(?:
+(?:[ \\t]*) Z
+| [-+] \\d{1,2} (?: :\\d{1,2})?
+)?
+)
+)
+| (=)
+| (<<)
+)
+(?:
+(?=
+\\s* $
+| \\s+ \\#
+| \\s* : (\\s|$)
+| \\s* : [\\[\\]{},]
+| \\s* [\\[\\]{},]
+)
+)
+` }] }, "flow-scalar-plain-out": { patterns: [{ include: "#flow-scalar-plain-out-implicit-type" }, { begin: `(?x)
+[^\\s[-?:,\\[\\]{}#&*!|>'"%@\`]]
+| [?:-] \\S
+`, end: `(?x)
+(?=
+\\s* $
+| \\s+ \\#
+| \\s* : (\\s|$)
+)
+`, name: "string.unquoted.plain.out.yaml" }] }, "flow-scalar-plain-out-implicit-type": { patterns: [{ captures: { 1: { name: "constant.language.null.yaml" }, 2: { name: "constant.language.boolean.yaml" }, 3: { name: "constant.numeric.integer.yaml" }, 4: { name: "constant.numeric.float.yaml" }, 5: { name: "constant.other.timestamp.yaml" }, 6: { name: "constant.language.value.yaml" }, 7: { name: "constant.language.merge.yaml" } }, match: `(?x)
+(?x:
+(null|Null|NULL|~)
+| (y|Y|yes|Yes|YES|n|N|no|No|NO|true|True|TRUE|false|False|FALSE|on|On|ON|off|Off|OFF)
+| (
+(?:
+[-+]? 0b [0-1_]+
+| [-+]? 0  [0-7_]+
+| [-+]? (?: 0|[1-9][0-9_]*)
+| [-+]? 0x [0-9a-fA-F_]+
+| [-+]? [1-9] [0-9_]* (?: :[0-5]?[0-9])+
+)
+)
+| (
+(?x:
+[-+]? (?: [0-9] [0-9_]*)? \\. [0-9.]* (?: [eE] [-+] [0-9]+)?
+| [-+]? [0-9] [0-9_]* (?: :[0-5]?[0-9])+ \\. [0-9_]*
+| [-+]? \\. (?: inf|Inf|INF)
+|       \\. (?: nan|NaN|NAN)
+)
+)
+| (
+(?x:
+\\d{4} - \\d{2} - \\d{2}
+| \\d{4}
+- \\d{1,2}
+- \\d{1,2}
+(?: [Tt] | [ \\t]+) \\d{1,2}
+: \\d{2}
+: \\d{2}
+(?: \\.\\d*)?
+(?:
+(?:[ \\t]*) Z
+| [-+] \\d{1,2} (?: :\\d{1,2})?
+)?
+)
+)
+| (=)
+| (<<)
+)
+(?x:
+(?=
+\\s* $
+| \\s+ \\#
+| \\s* : (\\s|$)
+)
+)
+` }] }, "flow-scalar-single-quoted": { begin: "'", beginCaptures: { 0: { name: "punctuation.definition.string.begin.yaml" } }, end: "'(?!')", endCaptures: { 0: { name: "punctuation.definition.string.end.yaml" } }, name: "string.quoted.single.yaml", patterns: [{ match: "''", name: "constant.character.escape.single-quoted.yaml" }] }, "flow-sequence": { begin: "\\[", beginCaptures: { 0: { name: "punctuation.definition.sequence.begin.yaml" } }, end: "\\]", endCaptures: { 0: { name: "punctuation.definition.sequence.end.yaml" } }, name: "meta.flow-sequence.yaml", patterns: [{ include: "#prototype" }, { match: ",", name: "punctuation.separator.sequence.yaml" }, { include: "#flow-pair" }, { include: "#flow-node" }] }, "flow-value": { patterns: [{ begin: "\\G(?![},\\]])", end: "(?=[},\\]])", name: "meta.flow-pair.value.yaml", patterns: [{ include: "#flow-node" }] }] }, node: { patterns: [{ include: "#block-node" }] }, property: { begin: "(?=!|&)", end: "(?!\\G)", name: "meta.property.yaml", patterns: [{ captures: { 1: { name: "keyword.control.property.anchor.yaml" }, 2: { name: "punctuation.definition.anchor.yaml" }, 3: { name: "entity.name.type.anchor.yaml" }, 4: { name: "invalid.illegal.character.anchor.yaml" } }, match: "\\G((&))([^\\s\\[\\]/{/},]+)(\\S+)?" }, { match: `(?x)
+\\G
+(?:
+! < (?: %[0-9A-Fa-f]{2} | [0-9A-Za-z\\-#;/?:@&=+$,_.!~*'()\\[\\]] )+ >
+| (?:!(?:[0-9A-Za-z\\-]*!)?) (?: %[0-9A-Fa-f]{2} | [0-9A-Za-z\\-#;/?:@&=+$_.~*'()] )+
+| !
+)
+(?=\\ |\\t|$)
+`, name: "storage.type.tag-handle.yaml" }, { match: "\\S+", name: "invalid.illegal.tag-handle.yaml" }] }, prototype: { patterns: [{ include: "#comment" }, { include: "#property" }] } }, scopeName: "source.yaml", aliases: ["yml"] });
+var n = [
+  e
+];
+export {
+  n as default
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kong-ui-public/documentation",
-  "version": "0.3.42",
+  "version": "0.4.0",
   "type": "module",
   "main": "./dist/documentation.umd.js",
   "module": "./dist/documentation.es.js",
@@ -20,6 +20,16 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@kong/icons": "^1.8.14",
+    "@kong/markdown": "1.3.3",
+    "@kong-ui-public/entities-shared": "^3.0.0"
+  },
+  "peerDependencies": {
+    "@kong/kongponents": "9.0.0-alpha.124",
+    "vue": "^3.4.21",
+    "@kong-ui-public/i18n": "^2.1.4"
+  },
   "devDependencies": {
     "@kong/design-tokens": "1.12.10",
     "@kong/kongponents": "9.0.0-alpha.124",
@@ -42,18 +52,8 @@
     "extends": "../../../package.json"
   },
   "distSizeChecker": {
-    "errorLimit": "500KB",
-    "warningLimit": "450KB"
-  },
-  "peerDependencies": {
-    "@kong/kongponents": "9.0.0-alpha.124",
-    "vue": "^3.4.21",
-    "@kong-ui-public/i18n": "^2.1.4"
-  },
-  "dependencies": {
-    "@kong/icons": "^1.8.15",
-    "@kong-ui-public/document-viewer": "^2.0.47",
-    "@kong-ui-public/entities-shared": "^3.0.0"
+    "errorLimit": "30MB",
+    "warningLimit": "25MB"
   },
   "scripts": {
     "dev": "cross-env USE_SANDBOX=true vite",

package/dist/prism-bash.min-DDo5CyRs-DihCfXgx.js

@@ -1,7 +0,0 @@
-(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"], i = t.variable[1].inside, n = 0; n < o.length; n++)
-    i[o[n]] = e.languages.bash[o[n]];
-  e.languages.sh = e.languages.bash, e.languages.shell = e.languages.bash;
-})(Prism);

package/dist/prism-css.min-BrrzZC7b-BrrzZC7b.js

@@ -1,7 +0,0 @@
-(function(s) {
-  var e = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
-  s.languages.css = { comment: /\/\*[\s\S]*?\*\//, atrule: { pattern: RegExp(`@[\\w-](?:[^;{\\s"']|\\s+(?!\\s)|` + e.source + ")*?(?:;|(?=\\s*\\{))"), inside: { rule: /^@[\w-]+/, "selector-function-argument": { pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/, lookbehind: !0, alias: "selector" }, keyword: { pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/, lookbehind: !0 } } }, url: { pattern: RegExp("\\burl\\((?:" + e.source + `|(?:[^\\\\\r
-()"']|\\\\[^])*)\\)`, "i"), greedy: !0, inside: { function: /^url/i, punctuation: /^\(|\)$/, string: { pattern: RegExp("^" + e.source + "$"), alias: "url" } } }, selector: { pattern: RegExp(`(^|[{}\\s])[^{}\\s](?:[^{};"'\\s]|\\s+(?![\\s{])|` + e.source + ")*(?=\\s*\\{)"), lookbehind: !0 }, string: { pattern: e, 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: /[(){};:,]/ }, s.languages.css.atrule.inside.rest = s.languages.css;
-  var t = s.languages.markup;
-  t && (t.tag.addInlined("style", "css"), t.tag.addAttribute("style", "css"));
-})(Prism);

package/dist/prism-docker.min-DnIEokC3-D0v8IWN_.js

@@ -1,22 +0,0 @@
-(function(r) {
-  var a = "(?:[ 	]+(?![ 	])(?:<SP_BS>)?|<SP_BS>)".replace(/<SP_BS>/g, function() {
-    return `\\\\[\r
-](?:\\s|\\\\[\r
-]|#.*(?!.))*(?![\\s#]|\\\\[\r
-])`;
-  }), t = `"(?:[^"\\\\\r
-]|\\\\(?:\r
-|[^]))*"|'(?:[^'\\\\\r
-]|\\\\(?:\r
-|[^]))*'`, S = `--[\\w-]+=(?:<STR>|(?!["'])(?:[^\\s\\\\]|\\\\.)+)`.replace(/<STR>/g, function() {
-    return t;
-  }), o = { pattern: RegExp(t), greedy: !0 }, i = { pattern: /(^[ \t]*)#.*/m, lookbehind: !0, greedy: !0 };
-  function e(n, P) {
-    return n = n.replace(/<OPT>/g, function() {
-      return S;
-    }).replace(/<SP>/g, function() {
-      return a;
-    }), RegExp(n, P);
-  }
-  r.languages.docker = { instruction: { pattern: /(^[ \t]*)(?:ADD|ARG|CMD|COPY|ENTRYPOINT|ENV|EXPOSE|FROM|HEALTHCHECK|LABEL|MAINTAINER|ONBUILD|RUN|SHELL|STOPSIGNAL|USER|VOLUME|WORKDIR)(?=\s)(?:\\.|[^\r\n\\])*(?:\\$(?:\s|#.*$)*(?![\s#])(?:\\.|[^\r\n\\])*)*/im, lookbehind: !0, greedy: !0, inside: { options: { pattern: e("(^(?:ONBUILD<SP>)?\\w+<SP>)<OPT>(?:<SP><OPT>)*", "i"), lookbehind: !0, greedy: !0, inside: { property: { pattern: /(^|\s)--[\w-]+/, lookbehind: !0 }, string: [o, { pattern: /(=)(?!["'])(?:[^\s\\]|\\.)+/, lookbehind: !0 }], operator: /\\$/m, punctuation: /=/ } }, keyword: [{ pattern: e("(^(?:ONBUILD<SP>)?HEALTHCHECK<SP>(?:<OPT><SP>)*)(?:CMD|NONE)\\b", "i"), lookbehind: !0, greedy: !0 }, { pattern: e("(^(?:ONBUILD<SP>)?FROM<SP>(?:<OPT><SP>)*(?!--)[^ 	\\\\]+<SP>)AS", "i"), lookbehind: !0, greedy: !0 }, { pattern: e("(^ONBUILD<SP>)\\w+", "i"), lookbehind: !0, greedy: !0 }, { pattern: /^\w+/, greedy: !0 }], comment: i, string: o, variable: /\$(?:\w+|\{[^{}"'\\]*\})/, operator: /\\$/m } }, comment: i }, r.languages.dockerfile = r.languages.docker;
-})(Prism);

package/dist/prism-go.min-C7UmK6TW-C7UmK6TW.js

@@ -1 +0,0 @@
-Prism.languages.go = Prism.languages.extend("clike", { string: { pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"|`[^`]*`/, lookbehind: !0, greedy: !0 }, keyword: /\b(?:break|case|chan|const|continue|default|defer|else|fallthrough|for|func|go(?:to)?|if|import|interface|map|package|range|return|select|struct|switch|type|var)\b/, boolean: /\b(?:_|false|iota|nil|true)\b/, number: [/\b0(?:b[01_]+|o[0-7_]+)i?\b/i, /\b0x(?:[a-f\d_]+(?:\.[a-f\d_]*)?|\.[a-f\d_]+)(?:p[+-]?\d+(?:_\d+)*)?i?(?!\w)/i, /(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?[\d_]+)?i?(?!\w)/i], operator: /[*\/%^!=]=?|\+[=+]?|-[=-]?|\|[=|]?|&(?:=|&|\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\.\.\./, builtin: /\b(?:append|bool|byte|cap|close|complex|complex(?:64|128)|copy|delete|error|float(?:32|64)|u?int(?:8|16|32|64)?|imag|len|make|new|panic|print(?:ln)?|real|recover|rune|string|uintptr)\b/ }), Prism.languages.insertBefore("go", "string", { char: { pattern: /'(?:\\.|[^'\\\r\n]){0,10}'/, greedy: !0 } }), delete Prism.languages.go["class-name"];

package/dist/prism-http.min-CsU3-jB8-CQ8PCDXl.js

@@ -1,23 +0,0 @@
-(function(t) {
-  function s(i) {
-    return RegExp("(^(?:" + i + "):[ 	]*(?![ 	]))[^]+", "i");
-  }
-  t.languages.http = { "request-line": { pattern: /^(?:CONNECT|DELETE|GET|HEAD|OPTIONS|PATCH|POST|PRI|PUT|SEARCH|TRACE)\s(?:https?:\/\/|\/)\S*\sHTTP\/[\d.]+/m, inside: { method: { pattern: /^[A-Z]+\b/, alias: "property" }, "request-target": { pattern: /^(\s)(?:https?:\/\/|\/)\S*(?=\s)/, lookbehind: !0, alias: "url", inside: t.languages.uri }, "http-version": { pattern: /^(\s)HTTP\/[\d.]+/, lookbehind: !0, alias: "property" } } }, "response-status": { pattern: /^HTTP\/[\d.]+ \d+ .+/m, inside: { "http-version": { pattern: /^HTTP\/[\d.]+/, alias: "property" }, "status-code": { pattern: /^(\s)\d+(?=\s)/, lookbehind: !0, alias: "number" }, "reason-phrase": { pattern: /^(\s).+/, lookbehind: !0, alias: "string" } } }, header: { pattern: /^[\w-]+:.+(?:(?:\r\n?|\n)[ \t].+)*/m, inside: { "header-value": [{ pattern: s("Content-Security-Policy"), lookbehind: !0, alias: ["csp", "languages-csp"], inside: t.languages.csp }, { pattern: s("Public-Key-Pins(?:-Report-Only)?"), lookbehind: !0, alias: ["hpkp", "languages-hpkp"], inside: t.languages.hpkp }, { pattern: s("Strict-Transport-Security"), lookbehind: !0, alias: ["hsts", "languages-hsts"], inside: t.languages.hsts }, { pattern: s("[^:]+"), lookbehind: !0 }], "header-name": { pattern: /^[^:]+/, alias: "keyword" }, punctuation: /^:/ } } };
-  var n, a = t.languages, r = { "application/javascript": a.javascript, "application/json": a.json || a.javascript, "application/xml": a.xml, "text/xml": a.xml, "text/html": a.html, "text/css": a.css, "text/plain": a.plain }, p = { "application/json": !0, "application/xml": !0 };
-  function l(i) {
-    var d = i.replace(/^[a-z]+\//, "");
-    return "(?:" + i + "|\\w+/(?:[\\w.-]+\\+)+" + d + "(?![+\\w.-]))";
-  }
-  for (var e in r)
-    if (r[e]) {
-      n = n || {};
-      var o = p[e] ? l(e) : e;
-      n[e.replace(/\//g, "-")] = { pattern: RegExp("(content-type:\\s*" + o + `(?:(?:\r
-?|
-)[\\w-].*)*(?:\r(?:
-|(?!
-))|
-))[^ 	\\w-][^]*`, "i"), lookbehind: !0, inside: r[e] };
-    }
-  n && t.languages.insertBefore("http", "header", n);
-})(Prism);

package/dist/prism-javascript.min-CEqHqgbm-CEqHqgbm.js

@@ -1,8 +0,0 @@
-Prism.languages.javascript = Prism.languages.extend("clike", { "class-name": [Prism.languages.clike["class-name"], { pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/, lookbehind: !0 }], keyword: [{ pattern: /((?:^|\})\s*)catch\b/, lookbehind: !0 }, { pattern: /(^|[^.]|\.\.\.\s*)\b(?:as|assert(?=\s*\{)|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally(?=\s*(?:\{|$))|for|from(?=\s*(?:['"]|$))|function|(?:get|set)(?=\s*(?:[#\[$\w\xA0-\uFFFF]|$))|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/, lookbehind: !0 }], function: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/, number: { pattern: RegExp("(^|[^\\w$])(?:NaN|Infinity|0[bB][01]+(?:_[01]+)*n?|0[oO][0-7]+(?:_[0-7]+)*n?|0[xX][\\dA-Fa-f]+(?:_[\\dA-Fa-f]+)*n?|\\d+(?:_\\d+)*n|(?:\\d+(?:_\\d+)*(?:\\.(?:\\d+(?:_\\d+)*)?)?|\\.\\d+(?:_\\d+)*)(?:[Ee][+-]?\\d+(?:_\\d+)*)?)(?![\\w$])"), lookbehind: !0 }, operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/ }), Prism.languages.javascript["class-name"][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/, Prism.languages.insertBefore("javascript", "keyword", { regex: { pattern: RegExp(`((?:^|[^$\\w\\xA0-\\uFFFF."'\\])\\s]|\\b(?:return|yield))\\s*)/(?:(?:\\[(?:[^\\]\\\\\r
-]|\\\\.)*\\]|\\\\.|[^/\\\\\\[\r
-])+/[dgimyus]{0,7}|(?:\\[(?:[^[\\]\\\\\r
-]|\\\\.|\\[(?:[^[\\]\\\\\r
-]|\\\\.|\\[(?:[^[\\]\\\\\r
-]|\\\\.)*\\])*\\])*\\]|\\\\.|[^/\\\\\\[\r
-])+/[dgimyus]{0,7}v[dgimyus]{0,7})(?=(?:\\s|/\\*(?:[^*]|\\*(?!/))*\\*/)*(?:$|[\r
-,.;:})\\]]|//))`), lookbehind: !0, greedy: !0, inside: { "regex-source": { pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/, lookbehind: !0, alias: "language-regex", inside: Prism.languages.regex }, "regex-delimiter": /^\/|\/$/, "regex-flags": /^[a-z]+$/ } }, "function-variable": { pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/, alias: "function" }, parameter: [{ pattern: /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/, lookbehind: !0, inside: Prism.languages.javascript }, { pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i, lookbehind: !0, inside: Prism.languages.javascript }, { pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/, lookbehind: !0, inside: Prism.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: Prism.languages.javascript }], constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/ }), Prism.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: Prism.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" } }), Prism.languages.insertBefore("javascript", "operator", { "literal-property": { pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m, lookbehind: !0, alias: "property" } }), Prism.languages.markup && (Prism.languages.markup.tag.addInlined("script", "javascript"), Prism.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)", "javascript")), Prism.languages.js = Prism.languages.javascript;

package/dist/prism-jq.min-Q555vXZm-Q555vXZm.js

@@ -1,8 +0,0 @@
-(function(i) {
-  var n = "\\\\\\((?:[^()]|\\([^()]*\\))*\\)", t = RegExp(`(^|[^\\\\])"(?:[^"\r
-\\\\]|\\\\[^\r
-(]|__)*"`.replace(/__/g, function() {
-    return n;
-  })), e = { interpolation: { pattern: RegExp("((?:^|[^\\\\])(?:\\\\{2})*)" + n), lookbehind: !0, inside: { content: { pattern: /^(\\\()[\s\S]+(?=\)$)/, lookbehind: !0, inside: null }, punctuation: /^\\\(|\)$/ } } }, a = i.languages.jq = { comment: /#.*/, property: { pattern: RegExp(t.source + "(?=\\s*:(?!:))"), lookbehind: !0, greedy: !0, inside: e }, string: { pattern: t, lookbehind: !0, greedy: !0, inside: e }, function: { pattern: /(\bdef\s+)[a-z_]\w+/i, lookbehind: !0 }, variable: /\B\$\w+/, "property-literal": { pattern: /\b[a-z_]\w*(?=\s*:(?!:))/i, alias: "property" }, keyword: /\b(?:as|break|catch|def|elif|else|end|foreach|if|import|include|label|module|modulemeta|null|reduce|then|try|while)\b/, boolean: /\b(?:false|true)\b/, number: /(?:\b\d+\.|\B\.)?\b\d+(?:[eE][+-]?\d+)?\b/, operator: [{ pattern: /\|=?/, alias: "pipe" }, /\.\.|[!=<>]?=|\?\/\/|\/\/=?|[-+*/%]=?|[<>?]|\b(?:and|not|or)\b/], "c-style-function": { pattern: /\b[a-z_]\w*(?=\s*\()/i, alias: "function" }, punctuation: /::|[()\[\]{},:;]|\.(?=\s*[\[\w$])/, dot: { pattern: /\./, alias: "important" } };
-  e.interpolation.inside.content.inside = a;
-})(Prism);

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

@@ -1 +0,0 @@
-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/dist/prism-log.min-SDopTpKN-SDopTpKN.js

@@ -1 +0,0 @@
-Prism.languages.log = { string: { pattern: /"(?:[^"\\\r\n]|\\.)*"|'(?![st] | \w)(?:[^'\\\r\n]|\\.)*'/, greedy: !0 }, exception: { pattern: /(^|[^\w.])[a-z][\w.]*(?:Error|Exception):.*(?:(?:\r\n?|\n)[ \t]*(?:at[ \t].+|\.{3}.*|Caused by:.*))+(?:(?:\r\n?|\n)[ \t]*\.\.\. .*)?/, lookbehind: !0, greedy: !0, alias: ["javastacktrace", "language-javastacktrace"], inside: Prism.languages.javastacktrace || { keyword: /\bat\b/, function: /[a-z_][\w$]*(?=\()/, punctuation: /[.:()]/ } }, level: [{ pattern: /\b(?:ALERT|CRIT|CRITICAL|EMERG|EMERGENCY|ERR|ERROR|FAILURE|FATAL|SEVERE)\b/, alias: ["error", "important"] }, { pattern: /\b(?:WARN|WARNING|WRN)\b/, alias: ["warning", "important"] }, { pattern: /\b(?:DISPLAY|INF|INFO|NOTICE|STATUS)\b/, alias: ["info", "keyword"] }, { pattern: /\b(?:DBG|DEBUG|FINE)\b/, alias: ["debug", "keyword"] }, { pattern: /\b(?:FINER|FINEST|TRACE|TRC|VERBOSE|VRB)\b/, alias: ["trace", "comment"] }], property: { pattern: /((?:^|[\]|])[ \t]*)[a-z_](?:[\w-]|\b\/\b)*(?:[. ]\(?\w(?:[\w-]|\b\/\b)*\)?)*:(?=\s)/im, lookbehind: !0 }, separator: { pattern: /(^|[^-+])-{3,}|={3,}|\*{3,}|- - /m, lookbehind: !0, alias: "comment" }, url: /\b(?:file|ftp|https?):\/\/[^\s|,;'"]*[^\s|,;'">.]/, email: { pattern: /(^|\s)[-\w+.]+@[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)+(?=\s)/, lookbehind: !0, alias: "url" }, "ip-address": { pattern: /\b(?:\d{1,3}(?:\.\d{1,3}){3})\b/, alias: "constant" }, "mac-address": { pattern: /\b[a-f0-9]{2}(?::[a-f0-9]{2}){5}\b/i, alias: "constant" }, domain: { pattern: /(^|\s)[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)*\.[a-z][a-z0-9-]+(?=\s)/, lookbehind: !0, alias: "constant" }, uuid: { pattern: /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/i, alias: "constant" }, hash: { pattern: /\b(?:[a-f0-9]{32}){1,2}\b/i, alias: "constant" }, "file-path": { pattern: /\b[a-z]:[\\/][^\s|,;:(){}\[\]"']+|(^|[\s:\[\](>|])\.{0,2}\/\w[^\s|,;:(){}\[\]"']*/i, lookbehind: !0, greedy: !0, alias: "string" }, date: { pattern: RegExp("\\b\\d{4}[-/]\\d{2}[-/]\\d{2}(?:T(?=\\d{1,2}:)|(?=\\s\\d{1,2}:))|\\b\\d{1,4}[-/ ](?:\\d{1,2}|Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep)[-/ ]\\d{2,4}T?\\b|\\b(?:(?:Fri|Mon|Sat|Sun|Thu|Tue|Wed)(?:\\s{1,2}(?:Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep))?|Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep)\\s{1,2}\\d{1,2}\\b", "i"), alias: "number" }, time: { pattern: /\b\d{1,2}:\d{1,2}:\d{1,2}(?:[.,:]\d+)?(?:\s?[+-]\d{2}:?\d{2}|Z)?\b/, alias: "number" }, boolean: /\b(?:false|null|true)\b/i, number: { pattern: /(^|[^.\w])(?:0x[a-f0-9]+|0o[0-7]+|0b[01]+|v?\d[\da-f]*(?:\.\d+)*(?:e[+-]?\d+)?[a-z]{0,3}\b)\b(?!\.\w)/i, lookbehind: !0 }, operator: /[;:?<=>~/@!$%&+\-|^(){}*#]/, punctuation: /[\[\].,]/ };

package/dist/prism-lua.min-DwRnUVfS-DwRnUVfS.js

@@ -1 +0,0 @@
-Prism.languages.lua = { comment: /^#!.+|--(?:\[(=*)\[[\s\S]*?\]\1\]|.*)/m, string: { pattern: /(["'])(?:(?!\1)[^\\\r\n]|\\z(?:\r\n|\s)|\\(?:\r\n|[^z]))*\1|\[(=*)\[[\s\S]*?\]\2\]/, greedy: !0 }, number: /\b0x[a-f\d]+(?:\.[a-f\d]*)?(?:p[+-]?\d+)?\b|\b\d+(?:\.\B|(?:\.\d*)?(?:e[+-]?\d+)?\b)|\B\.\d+(?:e[+-]?\d+)?\b/i, keyword: /\b(?:and|break|do|else|elseif|end|false|for|function|goto|if|in|local|nil|not|or|repeat|return|then|true|until|while)\b/, function: /(?!\d)\w+(?=\s*(?:[({]))/, operator: [/[-+*%^&|#]|\/\/?|<[<=]?|>[>=]?|[=~]=?/, { pattern: /(^|[^.])\.\.(?!\.)/, lookbehind: !0 }], punctuation: /[\[\](){},;]|\.+|:+/ };

package/dist/prism-makefile.min-DyutknhE-DyutknhE.js

@@ -1 +0,0 @@
-Prism.languages.makefile = { comment: { pattern: /(^|[^\\])#(?:\\(?:\r\n|[\s\S])|[^\\\r\n])*/, lookbehind: !0 }, string: { pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/, greedy: !0 }, "builtin-target": { pattern: /\.[A-Z][^:#=\s]+(?=\s*:(?!=))/, alias: "builtin" }, target: { pattern: /^(?:[^:=\s]|[ \t]+(?![\s:]))+(?=\s*:(?!=))/m, alias: "symbol", inside: { variable: /\$+(?:(?!\$)[^(){}:#=\s]+|(?=[({]))/ } }, variable: /\$+(?:(?!\$)[^(){}:#=\s]+|\([@*%<^+?][DF]\)|(?=[({]))/, keyword: /-include\b|\b(?:define|else|endef|endif|export|ifn?def|ifn?eq|include|override|private|sinclude|undefine|unexport|vpath)\b/, function: { pattern: /(\()(?:abspath|addsuffix|and|basename|call|dir|error|eval|file|filter(?:-out)?|findstring|firstword|flavor|foreach|guile|if|info|join|lastword|load|notdir|or|origin|patsubst|realpath|shell|sort|strip|subst|suffix|value|warning|wildcard|word(?:list|s)?)(?=[ \t])/, lookbehind: !0 }, operator: /(?:::|[?:+!])?=|[|@]/, punctuation: /[:;(){}]/ };

package/dist/prism-markdown.min-B7US-xc7-DB9aF_ZA.js

@@ -1,63 +0,0 @@
-(function(n) {
-  function u(e) {
-    return e = e.replace(/<inner>/g, function() {
-      return `(?:\\\\.|[^\\\\
-\r]|(?:
-|\r
-?)(?![\r
-]))`;
-    }), RegExp("((?:^|[^\\\\])(?:\\\\{2})*)(?:" + e + ")");
-  }
-  var g = "(?:\\\\.|``(?:[^`\r\n]|`(?!`))+``|`[^`\r\n]+`|[^\\\\|\r\n`])+", s = `\\|?__(?:\\|__)+\\|?(?:(?:
-|\r
-?)|(?![^]))`.replace(/__/g, function() {
-    return g;
-  }), c = `\\|?[ 	]*:?-{3,}:?[ 	]*(?:\\|[ 	]*:?-{3,}:?[ 	]*)+\\|?(?:
-|\r
-?)`;
-  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("^" + s + c + "(?:" + s + ")*", "m"), inside: { "table-data-rows": { pattern: RegExp("^(" + s + c + ")(?:" + s + ")*$"), lookbehind: !0, inside: { "table-data": { pattern: RegExp(g), inside: n.languages.markdown }, punctuation: /\|/ } }, "table-line": { pattern: RegExp("^(" + s + ")" + c + "$"), lookbehind: !0, inside: { punctuation: /\||:?-{3,}:?/ } }, "table-header-row": { pattern: RegExp("^" + s + "$"), inside: { "table-header": { pattern: RegExp(g), alias: "important", inside: n.languages.markdown }, punctuation: /\|/ } } } }, code: [{ pattern: /((?:^|\n)[ \t]*\n|(?:^|\r\n?)[ \t]*\r\n?)(?: {4}|\t).+(?:(?:\n|\r\n?)(?: {4}|\t).+)*/, lookbehind: !0, alias: "keyword" }, { pattern: /^```[\s\S]*?^```$/m, greedy: !0, inside: { "code-block": { pattern: /^(```.*(?:\n|\r\n?))[\s\S]+?(?=(?:\n|\r\n?)^```$)/m, lookbehind: !0 }, "code-language": { pattern: /^(```).+/, lookbehind: !0 }, punctuation: /```/ } }], title: [{ pattern: /\S.*(?:\n|\r\n?)(?:==+|--+)(?=[ \t]*$)/m, alias: "important", inside: { punctuation: /==+$|--+$/ } }, { pattern: /(^\s*)#.+/m, lookbehind: !0, alias: "important", inside: { punctuation: /^#+|#+$/ } }], hr: { pattern: /(^\s*)([*-])(?:[\t ]*\2){2,}(?=\s*$)/m, lookbehind: !0, alias: "punctuation" }, list: { pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m, lookbehind: !0, alias: "punctuation" }, "url-reference": { pattern: /!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/, inside: { variable: { pattern: /^(!?\[)[^\]]+/, lookbehind: !0 }, string: /(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/, punctuation: /^[\[\]!:]|[<>]/ }, alias: "url" }, bold: { pattern: u("\\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\\b|\\*\\*(?:(?!\\*)<inner>|\\*(?:(?!\\*)<inner>)+\\*)+\\*\\*"), lookbehind: !0, greedy: !0, inside: { content: { pattern: /(^..)[\s\S]+(?=..$)/, lookbehind: !0, inside: {} }, punctuation: /\*\*|__/ } }, italic: { pattern: u("\\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\\b|\\*(?:(?!\\*)<inner>|\\*\\*(?:(?!\\*)<inner>)+\\*\\*)+\\*"), lookbehind: !0, greedy: !0, inside: { content: { pattern: /(^.)[\s\S]+(?=.$)/, lookbehind: !0, inside: {} }, punctuation: /[*_]/ } }, strike: { pattern: u("(~~?)(?:(?!~)<inner>)+\\2"), lookbehind: !0, greedy: !0, inside: { content: { pattern: /(^~~?)[\s\S]+(?=\1$)/, lookbehind: !0, inside: {} }, punctuation: /~~?/ } }, "code-snippet": { pattern: /(^|[^\\`])(?:``[^`\r\n]+(?:`[^`\r\n]+)*``(?!`)|`[^`\r\n]+`(?!`))/, lookbehind: !0, greedy: !0, alias: ["code", "keyword"] }, url: { pattern: u('!?\\[(?:(?!\\])<inner>)+\\](?:\\([^\\s)]+(?:[	 ]+"(?:\\\\.|[^"\\\\])*")?\\)|[ 	]?\\[(?:(?!\\])<inner>)+\\])'), lookbehind: !0, greedy: !0, inside: { operator: /^!/, content: { pattern: /(^\[)[^\]]+(?=\])/, lookbehind: !0, inside: {} }, variable: { pattern: /(^\][ \t]?\[)[^\]]+(?=\]$)/, lookbehind: !0 }, url: { pattern: /(^\]\()[^\s)]+/, lookbehind: !0 }, string: { pattern: /(^[ \t]+)"(?:\\.|[^"\\])*"(?=\)$)/, lookbehind: !0 } } } }), ["url", "bold", "italic", "strike"].forEach(function(e) {
-    ["url", "bold", "italic", "strike", "code-snippet"].forEach(function(t) {
-      e !== t && (n.languages.markdown[e].inside.content.inside[t] = n.languages.markdown[t]);
-    });
-  }), n.hooks.add("after-tokenize", function(e) {
-    e.language !== "markdown" && e.language !== "md" || function t(r) {
-      if (r && typeof r != "string")
-        for (var p = 0, k = r.length; p < k; p++) {
-          var l = r[p];
-          if (l.type === "code") {
-            var d = l.content[1], a = l.content[3];
-            if (d && a && d.type === "code-language" && a.type === "code-block" && typeof d.content == "string") {
-              var o = d.content.replace(/\b#/g, "sharp").replace(/\b\+\+/g, "pp"), i = "language-" + (o = (/[a-z][\w-]*/i.exec(o) || [""])[0].toLowerCase());
-              a.alias ? typeof a.alias == "string" ? a.alias = [a.alias, i] : a.alias.push(i) : a.alias = [i];
-            }
-          } else
-            t(l.content);
-        }
-    }(e.tokens);
-  }), n.hooks.add("wrap", function(e) {
-    if (e.type === "code-block") {
-      for (var t = "", r = 0, p = e.classes.length; r < p; r++) {
-        var k = e.classes[r], l = /language-(.+)/.exec(k);
-        if (l) {
-          t = l[1];
-          break;
-        }
-      }
-      var d = n.languages[t];
-      if (d)
-        e.content = n.highlight(e.content.replace(h, "").replace(/&(\w{1,8}|#x?[\da-f]{1,8});/gi, function(o, i) {
-          var b;
-          return (i = i.toLowerCase())[0] === "#" ? (b = i[1] === "x" ? parseInt(i.slice(2), 16) : Number(i.slice(1)), f(b)) : m[i] || o;
-        }), d, t);
-      else if (t && t !== "none" && n.plugins.autoloader) {
-        var a = "md-" + (/* @__PURE__ */ new Date()).valueOf() + "-" + Math.floor(1e16 * Math.random());
-        e.attributes.id = a, n.plugins.autoloader.loadLanguages(t, function() {
-          var o = document.getElementById(a);
-          o && (o.innerHTML = n.highlight(o.textContent, n.languages[t], t));
-        });
-      }
-    }
-  });
-  var h = RegExp(n.languages.markup.tag.pattern.source, "gi"), m = { amp: "&", lt: "<", gt: ">", quot: '"' }, f = String.fromCodePoint || String.fromCharCode;
-  n.languages.md = n.languages.markdown;
-})(Prism);

package/dist/prism-python.min-BIfpAh5K-BIfpAh5K.js

@@ -1 +0,0 @@
-Prism.languages.python = { comment: { pattern: /(^|[^\\])#.*/, lookbehind: !0, greedy: !0 }, "string-interpolation": { pattern: /(?:f|fr|rf)(?:("""|''')[\s\S]*?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i, greedy: !0, inside: { interpolation: { pattern: /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}])+\})+\})+\}/, lookbehind: !0, inside: { "format-spec": { pattern: /(:)[^:(){}]+(?=\}$)/, lookbehind: !0 }, "conversion-option": { pattern: /![sra](?=[:}]$)/, alias: "punctuation" }, rest: null } }, string: /[\s\S]+/ } }, "triple-quoted-string": { pattern: /(?:[rub]|br|rb)?("""|''')[\s\S]*?\1/i, greedy: !0, alias: "string" }, string: { pattern: /(?:[rub]|br|rb)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i, greedy: !0 }, function: { pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g, lookbehind: !0 }, "class-name": { pattern: /(\bclass\s+)\w+/i, lookbehind: !0 }, decorator: { pattern: /(^[\t ]*)@\w+(?:\.\w+)*/m, lookbehind: !0, alias: ["annotation", "punctuation"], inside: { punctuation: /\./ } }, keyword: /\b(?:_(?=\s*:)|and|as|assert|async|await|break|case|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\b/, builtin: /\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\b/, boolean: /\b(?:False|None|True)\b/, number: /\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f0-9])+)\b|(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:e[+-]?\d+(?:_\d+)*)?j?(?!\w)/i, operator: /[-+%=]=?|!=|:=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/, punctuation: /[{}[\];(),.:]/ }, Prism.languages.python["string-interpolation"].inside.interpolation.inside.rest = Prism.languages.python, Prism.languages.py = Prism.languages.python;

package/dist/prism-regex.min-f8DNqi8X-f8DNqi8X.js

@@ -1,4 +0,0 @@
-(function(s) {
-  var e = { pattern: /\\[\\(){}[\]^$+*?|.]/, alias: "escape" }, a = /\\(?:x[\da-fA-F]{2}|u[\da-fA-F]{4}|u\{[\da-fA-F]+\}|0[0-7]{0,2}|[123][0-7]{2}|c[a-zA-Z]|.)/, n = "(?:[^\\\\-]|" + a.source + ")", i = RegExp(n + "-" + n), t = { pattern: /(<|')[^<>']+(?=[>']$)/, lookbehind: !0, alias: "variable" };
-  s.languages.regex = { "char-class": { pattern: /((?:^|[^\\])(?:\\\\)*)\[(?:[^\\\]]|\\[\s\S])*\]/, lookbehind: !0, inside: { "char-class-negation": { pattern: /(^\[)\^/, lookbehind: !0, alias: "operator" }, "char-class-punctuation": { pattern: /^\[|\]$/, alias: "punctuation" }, range: { pattern: i, inside: { escape: a, "range-punctuation": { pattern: /-/, alias: "operator" } } }, "special-escape": e, "char-set": { pattern: /\\[wsd]|\\p\{[^{}]+\}/i, alias: "class-name" }, escape: a } }, "special-escape": e, "char-set": { pattern: /\.|\\[wsd]|\\p\{[^{}]+\}/i, alias: "class-name" }, backreference: [{ pattern: /\\(?![123][0-7]{2})[1-9]/, alias: "keyword" }, { pattern: /\\k<[^<>']+>/, alias: "keyword", inside: { "group-name": t } }], anchor: { pattern: /[$^]|\\[ABbGZz]/, alias: "function" }, escape: a, group: [{ pattern: /\((?:\?(?:<[^<>']+>|'[^<>']+'|[>:]|<?[=!]|[idmnsuxU]+(?:-[idmnsuxU]+)?:?))?/, alias: "punctuation", inside: { "group-name": t } }, { pattern: /\)/, alias: "punctuation" }], quantifier: { pattern: /(?:[+*?]|\{\d+(?:,\d*)?\})[?+]?/, alias: "number" }, alternation: { pattern: /\|/, alias: "keyword" } };
-})(Prism);

package/dist/prism-rest.min-B6veHRJF-B6veHRJF.js

@@ -1 +0,0 @@
-Prism.languages.rest = { table: [{ pattern: /(^[\t ]*)(?:\+[=-]+)+\+(?:\r?\n|\r)(?:\1[+|].+[+|](?:\r?\n|\r))+\1(?:\+[=-]+)+\+/m, lookbehind: !0, inside: { punctuation: /\||(?:\+[=-]+)+\+/ } }, { pattern: /(^[\t ]*)=+ [ =]*=(?:(?:\r?\n|\r)\1.+)+(?:\r?\n|\r)\1=+ [ =]*=(?=(?:\r?\n|\r){2}|\s*$)/m, lookbehind: !0, inside: { punctuation: /[=-]+/ } }], "substitution-def": { pattern: /(^[\t ]*\.\. )\|(?:[^|\s](?:[^|]*[^|\s])?)\| [^:]+::/m, lookbehind: !0, inside: { substitution: { pattern: /^\|(?:[^|\s]|[^|\s][^|]*[^|\s])\|/, alias: "attr-value", inside: { punctuation: /^\||\|$/ } }, directive: { pattern: /( )(?! )[^:]+::/, lookbehind: !0, alias: "function", inside: { punctuation: /::$/ } } } }, "link-target": [{ pattern: /(^[\t ]*\.\. )\[[^\]]+\]/m, lookbehind: !0, alias: "string", inside: { punctuation: /^\[|\]$/ } }, { pattern: /(^[\t ]*\.\. )_(?:`[^`]+`|(?:[^:\\]|\\.)+):/m, lookbehind: !0, alias: "string", inside: { punctuation: /^_|:$/ } }], directive: { pattern: /(^[\t ]*\.\. )[^:]+::/m, lookbehind: !0, alias: "function", inside: { punctuation: /::$/ } }, comment: { pattern: /(^[\t ]*\.\.)(?:(?: .+)?(?:(?:\r?\n|\r).+)+| .+)(?=(?:\r?\n|\r){2}|$)/m, lookbehind: !0 }, title: [{ pattern: /^(([!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~])\2+)(?:\r?\n|\r).+(?:\r?\n|\r)\1$/m, inside: { punctuation: /^[!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~]+|[!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~]+$/, important: /.+/ } }, { pattern: /(^|(?:\r?\n|\r){2}).+(?:\r?\n|\r)([!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~])\2+(?=\r?\n|\r|$)/, lookbehind: !0, inside: { punctuation: /[!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~]+$/, important: /.+/ } }], hr: { pattern: /((?:\r?\n|\r){2})([!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~])\2{3,}(?=(?:\r?\n|\r){2})/, lookbehind: !0, alias: "punctuation" }, field: { pattern: /(^[\t ]*):[^:\r\n]+:(?= )/m, lookbehind: !0, alias: "attr-name" }, "command-line-option": { pattern: /(^[\t ]*)(?:[+-][a-z\d]|(?:--|\/)[a-z\d-]+)(?:[ =](?:[a-z][\w-]*|<[^<>]+>))?(?:, (?:[+-][a-z\d]|(?:--|\/)[a-z\d-]+)(?:[ =](?:[a-z][\w-]*|<[^<>]+>))?)*(?=(?:\r?\n|\r)? {2,}\S)/im, lookbehind: !0, alias: "symbol" }, "literal-block": { pattern: /::(?:\r?\n|\r){2}([ \t]+)(?![ \t]).+(?:(?:\r?\n|\r)\1.+)*/, inside: { "literal-block-punctuation": { pattern: /^::/, alias: "punctuation" } } }, "quoted-literal-block": { pattern: /::(?:\r?\n|\r){2}([!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~]).*(?:(?:\r?\n|\r)\1.*)*/, inside: { "literal-block-punctuation": { pattern: /^(?:::|([!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~])\1*)/m, alias: "punctuation" } } }, "list-bullet": { pattern: /(^[\t ]*)(?:[*+\-•‣⁃]|\(?(?:\d+|[a-z]|[ivxdclm]+)\)|(?:\d+|[a-z]|[ivxdclm]+)\.)(?= )/im, lookbehind: !0, alias: "punctuation" }, "doctest-block": { pattern: /(^[\t ]*)>>> .+(?:(?:\r?\n|\r).+)*/m, lookbehind: !0, inside: { punctuation: /^>>>/ } }, inline: [{ pattern: /(^|[\s\-:\/'"<(\[{])(?::[^:]+:`.*?`|`.*?`:[^:]+:|(\*\*?|``?|\|)(?!\s)(?:(?!\2).)*\S\2(?=[\s\-.,:;!?\\\/'")\]}]|$))/m, lookbehind: !0, inside: { bold: { pattern: /(^\*\*).+(?=\*\*$)/, lookbehind: !0 }, italic: { pattern: /(^\*).+(?=\*$)/, lookbehind: !0 }, "inline-literal": { pattern: /(^``).+(?=``$)/, lookbehind: !0, alias: "symbol" }, role: { pattern: /^:[^:]+:|:[^:]+:$/, alias: "function", inside: { punctuation: /^:|:$/ } }, "interpreted-text": { pattern: /(^`).+(?=`$)/, lookbehind: !0, alias: "attr-value" }, substitution: { pattern: /(^\|).+(?=\|$)/, lookbehind: !0, alias: "attr-value" }, punctuation: /\*\*?|``?|\|/ } }], link: [{ pattern: /\[[^\[\]]+\]_(?=[\s\-.,:;!?\\\/'")\]}]|$)/, alias: "string", inside: { punctuation: /^\[|\]_$/ } }, { pattern: /(?:\b[a-z\d]+(?:[_.:+][a-z\d]+)*_?_|`[^`]+`_?_|_`[^`]+`)(?=[\s\-.,:;!?\\\/'")\]}]|$)/i, alias: "string", inside: { punctuation: /^_?`|`$|`?_?_$/ } }], punctuation: { pattern: /(^[\t ]*)(?:\|(?= |$)|(?:---?|—|\.\.|__)(?= )|\.\.$)/m, lookbehind: !0 } };

package/dist/prism-rust.min-Cb-Mi-h0-Cb-Mi-h0.js

@@ -1,9 +0,0 @@
-(function(a) {
-  for (var e = "/\\*(?:[^*/]|\\*(?!/)|/(?!\\*)|<self>)*\\*/", t = 0; t < 2; t++)
-    e = e.replace(/<self>/g, function() {
-      return e;
-    });
-  e = e.replace(/<self>/g, function() {
-    return "[^\\s\\S]";
-  }), a.languages.rust = { comment: [{ pattern: RegExp("(^|[^\\\\])" + e), lookbehind: !0, greedy: !0 }, { pattern: /(^|[^\\:])\/\/.*/, lookbehind: !0, greedy: !0 }], string: { pattern: /b?"(?:\\[\s\S]|[^\\"])*"|b?r(#*)"(?:[^"]|"(?!\1))*"\1/, greedy: !0 }, char: { pattern: /b?'(?:\\(?:x[0-7][\da-fA-F]|u\{(?:[\da-fA-F]_*){1,6}\}|.)|[^\\\r\n\t'])'/, greedy: !0 }, attribute: { pattern: /#!?\[(?:[^\[\]"]|"(?:\\[\s\S]|[^\\"])*")*\]/, greedy: !0, alias: "attr-name", inside: { string: null } }, "closure-params": { pattern: /([=(,:]\s*|\bmove\s*)\|[^|]*\||\|[^|]*\|(?=\s*(?:\{|->))/, lookbehind: !0, greedy: !0, inside: { "closure-punctuation": { pattern: /^\||\|$/, alias: "punctuation" }, rest: null } }, "lifetime-annotation": { pattern: /'\w+/, alias: "symbol" }, "fragment-specifier": { pattern: /(\$\w+:)[a-z]+/, lookbehind: !0, alias: "punctuation" }, variable: /\$\w+/, "function-definition": { pattern: /(\bfn\s+)\w+/, lookbehind: !0, alias: "function" }, "type-definition": { pattern: /(\b(?:enum|struct|trait|type|union)\s+)\w+/, lookbehind: !0, alias: "class-name" }, "module-declaration": [{ pattern: /(\b(?:crate|mod)\s+)[a-z][a-z_\d]*/, lookbehind: !0, alias: "namespace" }, { pattern: /(\b(?:crate|self|super)\s*)::\s*[a-z][a-z_\d]*\b(?:\s*::(?:\s*[a-z][a-z_\d]*\s*::)*)?/, lookbehind: !0, alias: "namespace", inside: { punctuation: /::/ } }], keyword: [/\b(?:Self|abstract|as|async|await|become|box|break|const|continue|crate|do|dyn|else|enum|extern|final|fn|for|if|impl|in|let|loop|macro|match|mod|move|mut|override|priv|pub|ref|return|self|static|struct|super|trait|try|type|typeof|union|unsafe|unsized|use|virtual|where|while|yield)\b/, /\b(?:bool|char|f(?:32|64)|[ui](?:8|16|32|64|128|size)|str)\b/], function: /\b[a-z_]\w*(?=\s*(?:::\s*<|\())/, macro: { pattern: /\b\w+!/, alias: "property" }, constant: /\b[A-Z_][A-Z_\d]+\b/, "class-name": /\b[A-Z]\w*\b/, namespace: { pattern: /(?:\b[a-z][a-z_\d]*\s*::\s*)*\b[a-z][a-z_\d]*\s*::(?!\s*<)/, inside: { punctuation: /::/ } }, number: /\b(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*|(?:(?:\d(?:_?\d)*)?\.)?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)(?:_?(?:f32|f64|[iu](?:8|16|32|64|size)?))?\b/, boolean: /\b(?:false|true)\b/, punctuation: /->|\.\.=|\.{1,3}|::|[{}[\];(),:]/, operator: /[-+*\/%!^]=?|=[=>]?|&[&=]?|\|[|=]?|<<?=?|>>?=?|[@?]/ }, a.languages.rust["closure-params"].inside.rest = a.languages.rust, a.languages.rust.attribute.inside.string = a.languages.rust.string;
-})(Prism);

package/dist/prism-scss.min-B0csyGJo-B0csyGJo.js

@@ -1 +0,0 @@
-Prism.languages.scss = Prism.languages.extend("css", { comment: { pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/, lookbehind: !0 }, atrule: { pattern: /@[\w-](?:\([^()]+\)|[^()\s]|\s+(?!\s))*?(?=\s+[{;])/, inside: { rule: /@[\w-]+/ } }, url: /(?:[-a-z]+-)?url(?=\()/i, selector: { pattern: /(?=\S)[^@;{}()]?(?:[^@;{}()\s]|\s+(?!\s)|#\{\$[-\w]+\})+(?=\s*\{(?:\}|\s|[^}][^:{}]*[:{][^}]))/, inside: { parent: { pattern: /&/, alias: "important" }, placeholder: /%[-\w]+/, variable: /\$[-\w]+|#\{\$[-\w]+\}/ } }, property: { pattern: /(?:[-\w]|\$[-\w]|#\{\$[-\w]+\})+(?=\s*:)/, inside: { variable: /\$[-\w]+|#\{\$[-\w]+\}/ } } }), Prism.languages.insertBefore("scss", "atrule", { keyword: [/@(?:content|debug|each|else(?: if)?|extend|for|forward|function|if|import|include|mixin|return|use|warn|while)\b/i, { pattern: /( )(?:from|through)(?= )/, lookbehind: !0 }] }), Prism.languages.insertBefore("scss", "important", { variable: /\$[-\w]+|#\{\$[-\w]+\}/ }), Prism.languages.insertBefore("scss", "function", { "module-modifier": { pattern: /\b(?:as|hide|show|with)\b/i, alias: "keyword" }, placeholder: { pattern: /%[-\w]+/, alias: "selector" }, statement: { pattern: /\B!(?:default|optional)\b/i, alias: "keyword" }, boolean: /\b(?:false|true)\b/, null: { pattern: /\bnull\b/, alias: "keyword" }, operator: { pattern: /(\s)(?:[-+*\/%]|[=!]=|<=?|>=?|and|not|or)(?=\s)/, lookbehind: !0 } }), Prism.languages.scss.atrule.inside.rest = Prism.languages.scss;

package/dist/prism-sql.min-BHXzX-c_-BHXzX-c_.js

@@ -1 +0,0 @@
-Prism.languages.sql = { comment: { pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/|#).*)/, lookbehind: !0 }, variable: [{ pattern: /@(["'`])(?:\\[\s\S]|(?!\1)[^\\])+\1/, greedy: !0 }, /@[\w.$]+/], string: { pattern: /(^|[^@\\])("|')(?:\\[\s\S]|(?!\2)[^\\]|\2\2)*\2/, greedy: !0, lookbehind: !0 }, identifier: { pattern: /(^|[^@\\])`(?:\\[\s\S]|[^`\\]|``)*`/, greedy: !0, lookbehind: !0, inside: { punctuation: /^`|`$/ } }, function: /\b(?:AVG|COUNT|FIRST|FORMAT|LAST|LCASE|LEN|MAX|MID|MIN|MOD|NOW|ROUND|SUM|UCASE)(?=\s*\()/i, keyword: /\b(?:ACTION|ADD|AFTER|ALGORITHM|ALL|ALTER|ANALYZE|ANY|APPLY|AS|ASC|AUTHORIZATION|AUTO_INCREMENT|BACKUP|BDB|BEGIN|BERKELEYDB|BIGINT|BINARY|BIT|BLOB|BOOL|BOOLEAN|BREAK|BROWSE|BTREE|BULK|BY|CALL|CASCADED?|CASE|CHAIN|CHAR(?:ACTER|SET)?|CHECK(?:POINT)?|CLOSE|CLUSTERED|COALESCE|COLLATE|COLUMNS?|COMMENT|COMMIT(?:TED)?|COMPUTE|CONNECT|CONSISTENT|CONSTRAINT|CONTAINS(?:TABLE)?|CONTINUE|CONVERT|CREATE|CROSS|CURRENT(?:_DATE|_TIME|_TIMESTAMP|_USER)?|CURSOR|CYCLE|DATA(?:BASES?)?|DATE(?:TIME)?|DAY|DBCC|DEALLOCATE|DEC|DECIMAL|DECLARE|DEFAULT|DEFINER|DELAYED|DELETE|DELIMITERS?|DENY|DESC|DESCRIBE|DETERMINISTIC|DISABLE|DISCARD|DISK|DISTINCT|DISTINCTROW|DISTRIBUTED|DO|DOUBLE|DROP|DUMMY|DUMP(?:FILE)?|DUPLICATE|ELSE(?:IF)?|ENABLE|ENCLOSED|END|ENGINE|ENUM|ERRLVL|ERRORS|ESCAPED?|EXCEPT|EXEC(?:UTE)?|EXISTS|EXIT|EXPLAIN|EXTENDED|FETCH|FIELDS|FILE|FILLFACTOR|FIRST|FIXED|FLOAT|FOLLOWING|FOR(?: EACH ROW)?|FORCE|FOREIGN|FREETEXT(?:TABLE)?|FROM|FULL|FUNCTION|GEOMETRY(?:COLLECTION)?|GLOBAL|GOTO|GRANT|GROUP|HANDLER|HASH|HAVING|HOLDLOCK|HOUR|IDENTITY(?:COL|_INSERT)?|IF|IGNORE|IMPORT|INDEX|INFILE|INNER|INNODB|INOUT|INSERT|INT|INTEGER|INTERSECT|INTERVAL|INTO|INVOKER|ISOLATION|ITERATE|JOIN|KEYS?|KILL|LANGUAGE|LAST|LEAVE|LEFT|LEVEL|LIMIT|LINENO|LINES|LINESTRING|LOAD|LOCAL|LOCK|LONG(?:BLOB|TEXT)|LOOP|MATCH(?:ED)?|MEDIUM(?:BLOB|INT|TEXT)|MERGE|MIDDLEINT|MINUTE|MODE|MODIFIES|MODIFY|MONTH|MULTI(?:LINESTRING|POINT|POLYGON)|NATIONAL|NATURAL|NCHAR|NEXT|NO|NONCLUSTERED|NULLIF|NUMERIC|OFF?|OFFSETS?|ON|OPEN(?:DATASOURCE|QUERY|ROWSET)?|OPTIMIZE|OPTION(?:ALLY)?|ORDER|OUT(?:ER|FILE)?|OVER|PARTIAL|PARTITION|PERCENT|PIVOT|PLAN|POINT|POLYGON|PRECEDING|PRECISION|PREPARE|PREV|PRIMARY|PRINT|PRIVILEGES|PROC(?:EDURE)?|PUBLIC|PURGE|QUICK|RAISERROR|READS?|REAL|RECONFIGURE|REFERENCES|RELEASE|RENAME|REPEAT(?:ABLE)?|REPLACE|REPLICATION|REQUIRE|RESIGNAL|RESTORE|RESTRICT|RETURN(?:ING|S)?|REVOKE|RIGHT|ROLLBACK|ROUTINE|ROW(?:COUNT|GUIDCOL|S)?|RTREE|RULE|SAVE(?:POINT)?|SCHEMA|SECOND|SELECT|SERIAL(?:IZABLE)?|SESSION(?:_USER)?|SET(?:USER)?|SHARE|SHOW|SHUTDOWN|SIMPLE|SMALLINT|SNAPSHOT|SOME|SONAME|SQL|START(?:ING)?|STATISTICS|STATUS|STRIPED|SYSTEM_USER|TABLES?|TABLESPACE|TEMP(?:ORARY|TABLE)?|TERMINATED|TEXT(?:SIZE)?|THEN|TIME(?:STAMP)?|TINY(?:BLOB|INT|TEXT)|TOP?|TRAN(?:SACTIONS?)?|TRIGGER|TRUNCATE|TSEQUAL|TYPES?|UNBOUNDED|UNCOMMITTED|UNDEFINED|UNION|UNIQUE|UNLOCK|UNPIVOT|UNSIGNED|UPDATE(?:TEXT)?|USAGE|USE|USER|USING|VALUES?|VAR(?:BINARY|CHAR|CHARACTER|YING)|VIEW|WAITFOR|WARNINGS|WHEN|WHERE|WHILE|WITH(?: ROLLUP|IN)?|WORK|WRITE(?:TEXT)?|YEAR)\b/i, boolean: /\b(?:FALSE|NULL|TRUE)\b/i, number: /\b0x[\da-f]+\b|\b\d+(?:\.\d*)?|\B\.\d+\b/i, operator: /[-+*\/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?|\b(?:AND|BETWEEN|DIV|ILIKE|IN|IS|LIKE|NOT|OR|REGEXP|RLIKE|SOUNDS LIKE|XOR)\b/i, punctuation: /[;[\]()`,.]/ };

package/dist/prism-typescript.min-oSVeWCAd-oSVeWCAd.js

@@ -1,5 +0,0 @@
-(function(e) {
-  e.languages.typescript = e.languages.extend("javascript", { "class-name": { pattern: /(\b(?:class|extends|implements|instanceof|interface|new|type)\s+)(?!keyof\b)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?:\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/, lookbehind: !0, greedy: !0, inside: null }, builtin: /\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\b/ }), e.languages.typescript.keyword.push(/\b(?:abstract|declare|is|keyof|readonly|require)\b/, /\b(?:asserts|infer|interface|module|namespace|type)\b(?=\s*(?:[{_$a-zA-Z\xA0-\uFFFF]|$))/, /\btype\b(?=\s*(?:[\{*]|$))/), delete e.languages.typescript.parameter, delete e.languages.typescript["literal-property"];
-  var s = e.languages.extend("typescript", {});
-  delete s["class-name"], e.languages.typescript["class-name"].inside = s, e.languages.insertBefore("typescript", "function", { decorator: { pattern: /@[$\w\xA0-\uFFFF]+/, inside: { at: { pattern: /^@/, alias: "operator" }, function: /^[\s\S]+/ } }, "generic-function": { pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\s*\()/, greedy: !0, inside: { function: /^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/, generic: { pattern: /<[\s\S]+/, alias: "class-name", inside: s } } } }), e.languages.ts = e.languages.typescript;
-})(Prism);

package/dist/prism-xml-doc.min-yj0YzRGe-KgTQx-dc.js

@@ -1,7 +0,0 @@
-(function(a) {
-  function n(r, g) {
-    a.languages[r] && a.languages.insertBefore(r, "comment", { "doc-comment": g });
-  }
-  var e = a.languages.markup.tag, t = { pattern: /\/\/\/.*/, greedy: !0, alias: "comment", inside: { tag: e } }, s = { pattern: /'''.*/, greedy: !0, alias: "comment", inside: { tag: e } };
-  n("csharp", t), n("fsharp", t), n("vbnet", s);
-})(Prism);

package/dist/prism-yaml.min-CTetcdKA-C1YzP_OY.js

@@ -1,28 +0,0 @@
-(function(r) {
-  var n = /[*&][^\s[\]{},]+/, a = /!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/, t = "(?:" + a.source + "(?:[ 	]+" + n.source + ")?|" + n.source + "(?:[ 	]+" + a.source + ")?)", u = "(?:[^\\s\\x00-\\x08\\x0e-\\x1f!\"#%&'*,\\-:>?@[\\]`{|}\\x7f-\\x84\\x86-\\x9f\\ud800-\\udfff\\ufffe\\uffff]|[?:-]<PLAIN>)(?:[ 	]*(?:(?![#:])<PLAIN>|:<PLAIN>))*".replace(/<PLAIN>/g, function() {
-    return "[^\\s\\x00-\\x08\\x0e-\\x1f,[\\]{}\\x7f-\\x84\\x86-\\x9f\\ud800-\\udfff\\ufffe\\uffff]";
-  }), d = `"(?:[^"\\\\\r
-]|\\\\.)*"|'(?:[^'\\\\\r
-]|\\\\.)*'`;
-  function e(i, o) {
-    o = (o || "").replace(/m/g, "") + "m";
-    var f = `([:\\-,[{]\\s*(?:\\s<<prop>>[ 	]+)?)(?:<<value>>)(?=[ 	]*(?:$|,|\\]|\\}|(?:[\r
-]\\s*)?#))`.replace(/<<prop>>/g, function() {
-      return t;
-    }).replace(/<<value>>/g, function() {
-      return i;
-    });
-    return RegExp(f, o);
-  }
-  r.languages.yaml = { scalar: { pattern: RegExp(`([\\-:]\\s*(?:\\s<<prop>>[ 	]+)?[|>])[ 	]*(?:((?:\r?
-|\r)[ 	]+)\\S[^\r
-]*(?:\\2[^\r
-]+)*)`.replace(/<<prop>>/g, function() {
-    return t;
-  })), lookbehind: !0, alias: "string" }, comment: /#.*/, key: { pattern: RegExp(`((?:^|[:\\-,[{\r
-?])[ 	]*(?:<<prop>>[ 	]+)?)<<key>>(?=\\s*:\\s)`.replace(/<<prop>>/g, function() {
-    return t;
-  }).replace(/<<key>>/g, function() {
-    return "(?:" + u + "|" + d + ")";
-  })), lookbehind: !0, greedy: !0, alias: "atrule" }, directive: { pattern: /(^[ \t]*)%.+/m, lookbehind: !0, alias: "important" }, datetime: { pattern: e("\\d{4}-\\d\\d?-\\d\\d?(?:[tT]|[ 	]+)\\d\\d?:\\d{2}:\\d{2}(?:\\.\\d*)?(?:[ 	]*(?:Z|[-+]\\d\\d?(?::\\d{2})?))?|\\d{4}-\\d{2}-\\d{2}|\\d\\d?:\\d{2}(?::\\d{2}(?:\\.\\d*)?)?"), lookbehind: !0, alias: "number" }, boolean: { pattern: e("false|true", "i"), lookbehind: !0, alias: "important" }, null: { pattern: e("null|~", "i"), lookbehind: !0, alias: "important" }, string: { pattern: e(d), lookbehind: !0, greedy: !0 }, number: { pattern: e("[+-]?(?:0x[\\da-f]+|0o[0-7]+|(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?|\\.inf|\\.nan)", "i"), lookbehind: !0 }, tag: a, important: n, punctuation: /---|[:[\]{}\-,|>?]|\.\.\./ }, r.languages.yml = r.languages.yaml;
-})(Prism);