@kong-ui-public/document-viewer 2.6.5 → 2.6.7-pr.4063.bf809a10e.0

package/dist/prism-bash.min-BSY2OtLX.js

@@ -0,0 +1,174 @@
+// ../../../node_modules/.pnpm/prismjs@1.30.0/node_modules/prismjs/components/prism-bash.min.js
+(function(e) {
+	var t = "\\b(?:BASH|BASHOPTS|BASH_ALIASES|BASH_ARGC|BASH_ARGV|BASH_CMDS|BASH_COMPLETION_COMPAT_DIR|BASH_LINENO|BASH_REMATCH|BASH_SOURCE|BASH_VERSINFO|BASH_VERSION|COLORTERM|COLUMNS|COMP_WORDBREAKS|DBUS_SESSION_BUS_ADDRESS|DEFAULTS_PATH|DESKTOP_SESSION|DIRSTACK|DISPLAY|EUID|GDMSESSION|GDM_LANG|GNOME_KEYRING_CONTROL|GNOME_KEYRING_PID|GPG_AGENT_INFO|GROUPS|HISTCONTROL|HISTFILE|HISTFILESIZE|HISTSIZE|HOME|HOSTNAME|HOSTTYPE|IFS|INSTANCE|JOB|LANG|LANGUAGE|LC_ADDRESS|LC_ALL|LC_IDENTIFICATION|LC_MEASUREMENT|LC_MONETARY|LC_NAME|LC_NUMERIC|LC_PAPER|LC_TELEPHONE|LC_TIME|LESSCLOSE|LESSOPEN|LINES|LOGNAME|LS_COLORS|MACHTYPE|MAILCHECK|MANDATORY_PATH|NO_AT_BRIDGE|OLDPWD|OPTERR|OPTIND|ORBIT_SOCKETDIR|OSTYPE|PAPERSIZE|PATH|PIPESTATUS|PPID|PS1|PS2|PS3|PS4|PWD|RANDOM|REPLY|SECONDS|SELINUX_INIT|SESSION|SESSIONTYPE|SESSION_MANAGER|SHELL|SHELLOPTS|SHLVL|SSH_AUTH_SOCK|TERM|UID|UPSTART_EVENTS|UPSTART_INSTANCE|UPSTART_JOB|UPSTART_SESSION|USER|WINDOWID|XAUTHORITY|XDG_CONFIG_DIRS|XDG_CURRENT_DESKTOP|XDG_DATA_DIRS|XDG_GREETER_DATA_DIR|XDG_MENU_PREFIX|XDG_RUNTIME_DIR|XDG_SEAT|XDG_SEAT_PATH|XDG_SESSION_DESKTOP|XDG_SESSION_ID|XDG_SESSION_PATH|XDG_SESSION_TYPE|XDG_VTNR|XMODIFIERS)\\b", n = {
+		pattern: /(^(["']?)\w+\2)[ \t]+\S.*/,
+		lookbehind: !0,
+		alias: "punctuation",
+		inside: null
+	}, r = {
+		bash: n,
+		environment: {
+			pattern: RegExp("\\$" + t),
+			alias: "constant"
+		},
+		variable: [
+			{
+				pattern: /\$?\(\([\s\S]+?\)\)/,
+				greedy: !0,
+				inside: {
+					variable: [{
+						pattern: /(^\$\(\([\s\S]+)\)\)/,
+						lookbehind: !0
+					}, /^\$\(\(/],
+					number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee]-?\d+)?/,
+					operator: /--|\+\+|\*\*=?|<<=?|>>=?|&&|\|\||[=!+\-*/%<>^&|]=?|[?~:]/,
+					punctuation: /\(\(?|\)\)?|,|;/
+				}
+			},
+			{
+				pattern: /\$\((?:\([^)]+\)|[^()])+\)|`[^`]+`/,
+				greedy: !0,
+				inside: { variable: /^\$\(|^`|\)$|`$/ }
+			},
+			{
+				pattern: /\$\{[^}]+\}/,
+				greedy: !0,
+				inside: {
+					operator: /:[-=?+]?|[!\/]|##?|%%?|\^\^?|,,?/,
+					punctuation: /[\[\]]/,
+					environment: {
+						pattern: RegExp("(\\{)" + t),
+						lookbehind: !0,
+						alias: "constant"
+					}
+				}
+			},
+			/\$(?:\w+|[#?*!@$])/
+		],
+		entity: /\\(?:[abceEfnrtv\\"]|O?[0-7]{1,3}|U[0-9a-fA-F]{8}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{1,2})/
+	};
+	e.languages.bash = {
+		shebang: {
+			pattern: /^#!\s*\/.*/,
+			alias: "important"
+		},
+		comment: {
+			pattern: /(^|[^"{\\$])#.*/,
+			lookbehind: !0
+		},
+		"function-name": [{
+			pattern: /(\bfunction\s+)[\w-]+(?=(?:\s*\(?:\s*\))?\s*\{)/,
+			lookbehind: !0,
+			alias: "function"
+		}, {
+			pattern: /\b[\w-]+(?=\s*\(\s*\)\s*\{)/,
+			alias: "function"
+		}],
+		"for-or-select": {
+			pattern: /(\b(?:for|select)\s+)\w+(?=\s+in\s)/,
+			alias: "variable",
+			lookbehind: !0
+		},
+		"assign-left": {
+			pattern: /(^|[\s;|&]|[<>]\()\w+(?:\.\w+)*(?=\+?=)/,
+			inside: { environment: {
+				pattern: RegExp("(^|[\\s;|&]|[<>]\\()" + t),
+				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: r
+			},
+			{
+				pattern: /((?:^|[^<])<<-?\s*)(["'])(\w+)\2\s[\s\S]*?(?:\r?\n|\r)\3/,
+				lookbehind: !0,
+				greedy: !0,
+				inside: { bash: n }
+			},
+			{
+				pattern: /(^|[^\\](?:\\\\)*)"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/,
+				lookbehind: !0,
+				greedy: !0,
+				inside: r
+			},
+			{
+				pattern: /(^|[^$\\])'[^']*'/,
+				lookbehind: !0,
+				greedy: !0
+			},
+			{
+				pattern: /\$'(?:[^'\\]|\\[\s\S])*'/,
+				greedy: !0,
+				inside: { entity: r.entity }
+			}
+		],
+		environment: {
+			pattern: RegExp("\\$?" + t),
+			alias: "constant"
+		},
+		variable: r.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
+		}
+	}, n.inside = e.languages.bash;
+	for (var i = [
+		"comment",
+		"function-name",
+		"for-or-select",
+		"assign-left",
+		"parameter",
+		"string",
+		"environment",
+		"function",
+		"keyword",
+		"builtin",
+		"boolean",
+		"file-descriptor",
+		"operator",
+		"punctuation",
+		"number"
+	], a = r.variable[1].inside, o = 0; o < i.length; o++) a[i[o]] = e.languages.bash[i[o]];
+	e.languages.sh = e.languages.bash, e.languages.shell = e.languages.bash;
+})(Prism);

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

@@ -0,0 +1,54 @@
+// ../../../node_modules/.pnpm/prismjs@1.30.0/node_modules/prismjs/components/prism-css.min.js
+(function(e) {
+	var t = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
+	e.languages.css = {
+		comment: /\/\*[\s\S]*?\*\//,
+		atrule: {
+			pattern: RegExp("@[\\w-](?:[^;{\\s\"']|\\s+(?!\\s)|" + t.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\\((?:" + t.source + "|(?:[^\\\\\r\n()\"']|\\\\[^])*)\\)", "i"),
+			greedy: !0,
+			inside: {
+				function: /^url/i,
+				punctuation: /^\(|\)$/,
+				string: {
+					pattern: RegExp("^" + t.source + "$"),
+					alias: "url"
+				}
+			}
+		},
+		selector: {
+			pattern: RegExp("(^|[{}\\s])[^{}\\s](?:[^{};\"'\\s]|\\s+(?![\\s{])|" + t.source + ")*(?=\\s*\\{)"),
+			lookbehind: !0
+		},
+		string: {
+			pattern: t,
+			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: /[(){};:,]/
+	}, e.languages.css.atrule.inside.rest = e.languages.css;
+	var n = e.languages.markup;
+	n && (n.tag.addInlined("style", "css"), n.tag.addAttribute("style", "css"));
+})(Prism);

package/dist/prism-docker.min-Ch3_J8xI.js

@@ -0,0 +1,74 @@
+// ../../../node_modules/.pnpm/prismjs@1.30.0/node_modules/prismjs/components/prism-docker.min.js
+(function(e) {
+	var t = "(?:[ 	]+(?![ 	])(?:<SP_BS>)?|<SP_BS>)".replace(/<SP_BS>/g, (function() {
+		return "\\\\[\r\n](?:\\s|\\\\[\r\n]|#.*(?!.))*(?![\\s#]|\\\\[\r\n])";
+	})), n = "\"(?:[^\"\\\\\r\n]|\\\\(?:\r\n|[^]))*\"|'(?:[^'\\\\\r\n]|\\\\(?:\r\n|[^]))*'", r = "--[\\w-]+=(?:<STR>|(?![\"'])(?:[^\\s\\\\]|\\\\.)+)".replace(/<STR>/g, (function() {
+		return n;
+	})), i = {
+		pattern: RegExp(n),
+		greedy: !0
+	}, a = {
+		pattern: /(^[ \t]*)#.*/m,
+		lookbehind: !0,
+		greedy: !0
+	};
+	function o(e, n) {
+		return e = e.replace(/<OPT>/g, (function() {
+			return r;
+		})).replace(/<SP>/g, (function() {
+			return t;
+		})), RegExp(e, n);
+	}
+	e.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: o("(^(?:ONBUILD<SP>)?\\w+<SP>)<OPT>(?:<SP><OPT>)*", "i"),
+					lookbehind: !0,
+					greedy: !0,
+					inside: {
+						property: {
+							pattern: /(^|\s)--[\w-]+/,
+							lookbehind: !0
+						},
+						string: [i, {
+							pattern: /(=)(?!["'])(?:[^\s\\]|\\.)+/,
+							lookbehind: !0
+						}],
+						operator: /\\$/m,
+						punctuation: /=/
+					}
+				},
+				keyword: [
+					{
+						pattern: o("(^(?:ONBUILD<SP>)?HEALTHCHECK<SP>(?:<OPT><SP>)*)(?:CMD|NONE)\\b", "i"),
+						lookbehind: !0,
+						greedy: !0
+					},
+					{
+						pattern: o("(^(?:ONBUILD<SP>)?FROM<SP>(?:<OPT><SP>)*(?!--)[^ 	\\\\]+<SP>)AS", "i"),
+						lookbehind: !0,
+						greedy: !0
+					},
+					{
+						pattern: o("(^ONBUILD<SP>)\\w+", "i"),
+						lookbehind: !0,
+						greedy: !0
+					},
+					{
+						pattern: /^\w+/,
+						greedy: !0
+					}
+				],
+				comment: a,
+				string: i,
+				variable: /\$(?:\w+|\{[^{}"'\\]*\})/,
+				operator: /\\$/m
+			}
+		},
+		comment: a
+	}, e.languages.dockerfile = e.languages.docker;
+})(Prism);

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

@@ -0,0 +1,20 @@
+// ../../../node_modules/.pnpm/prismjs@1.30.0/node_modules/prismjs/components/prism-go.min.js
+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-BDgs53mG.js

@@ -0,0 +1,107 @@
+// ../../../node_modules/.pnpm/prismjs@1.30.0/node_modules/prismjs/components/prism-http.min.js
+(function(e) {
+	function t(e) {
+		return RegExp("(^(?:" + e + "):[ 	]*(?![ 	]))[^]+", "i");
+	}
+	e.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: e.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: t("Content-Security-Policy"),
+						lookbehind: !0,
+						alias: ["csp", "languages-csp"],
+						inside: e.languages.csp
+					},
+					{
+						pattern: t("Public-Key-Pins(?:-Report-Only)?"),
+						lookbehind: !0,
+						alias: ["hpkp", "languages-hpkp"],
+						inside: e.languages.hpkp
+					},
+					{
+						pattern: t("Strict-Transport-Security"),
+						lookbehind: !0,
+						alias: ["hsts", "languages-hsts"],
+						inside: e.languages.hsts
+					},
+					{
+						pattern: t("[^:]+"),
+						lookbehind: !0
+					}
+				],
+				"header-name": {
+					pattern: /^[^:]+/,
+					alias: "keyword"
+				},
+				punctuation: /^:/
+			}
+		}
+	};
+	var n, r = e.languages, i = {
+		"application/javascript": r.javascript,
+		"application/json": r.json || r.javascript,
+		"application/xml": r.xml,
+		"text/xml": r.xml,
+		"text/html": r.html,
+		"text/css": r.css,
+		"text/plain": r.plain
+	}, a = {
+		"application/json": !0,
+		"application/xml": !0
+	};
+	function o(e) {
+		var t = e.replace(/^[a-z]+\//, "");
+		return "(?:" + e + "|\\w+/(?:[\\w.-]+\\+)+" + t + "(?![+\\w.-]))";
+	}
+	for (var s in i) if (i[s]) {
+		n ||= {};
+		var c = a[s] ? o(s) : s;
+		n[s.replace(/\//g, "-")] = {
+			pattern: RegExp("(content-type:\\s*" + c + "(?:(?:\r\n?|\n)[\\w-].*)*(?:\r(?:\n|(?!\n))|\n))[^ 	\\w-][^]*", "i"),
+			lookbehind: !0,
+			inside: i[s]
+		};
+	}
+	n && e.languages.insertBefore("http", "header", n);
+})(Prism);

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

@@ -0,0 +1,101 @@
+// ../../../node_modules/.pnpm/prismjs@1.30.0/node_modules/prismjs/components/prism-javascript.min.js
+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\n]|\\\\.)*\\]|\\\\.|[^/\\\\\\[\r\n])+/[dgimyus]{0,7}|(?:\\[(?:[^[\\]\\\\\r\n]|\\\\.|\\[(?:[^[\\]\\\\\r\n]|\\\\.|\\[(?:[^[\\]\\\\\r\n]|\\\\.)*\\])*\\])*\\]|\\\\.|[^/\\\\\\[\r\n])+/[dgimyus]{0,7}v[dgimyus]{0,7})(?=(?:\\s|/\\*(?:[^*]|\\*(?!/))*\\*/)*(?:$|[\r\n,.;:})\\]]|//))"),
+		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-wjT5eiX4.js

@@ -0,0 +1,57 @@
+// ../../../node_modules/.pnpm/prismjs@1.30.0/node_modules/prismjs/components/prism-jq.min.js
+(function(e) {
+	var t = "\\\\\\((?:[^()]|\\([^()]*\\))*\\)", n = RegExp("(^|[^\\\\])\"(?:[^\"\r\n\\\\]|\\\\[^\r\n(]|__)*\"".replace(/__/g, (function() {
+		return t;
+	}))), r = { interpolation: {
+		pattern: RegExp("((?:^|[^\\\\])(?:\\\\{2})*)" + t),
+		lookbehind: !0,
+		inside: {
+			content: {
+				pattern: /^(\\\()[\s\S]+(?=\)$)/,
+				lookbehind: !0,
+				inside: null
+			},
+			punctuation: /^\\\(|\)$/
+		}
+	} }, i = e.languages.jq = {
+		comment: /#.*/,
+		property: {
+			pattern: RegExp(n.source + "(?=\\s*:(?!:))"),
+			lookbehind: !0,
+			greedy: !0,
+			inside: r
+		},
+		string: {
+			pattern: n,
+			lookbehind: !0,
+			greedy: !0,
+			inside: r
+		},
+		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"
+		}
+	};
+	r.interpolation.inside.content.inside = i;
+})(Prism);

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

@@ -0,0 +1,25 @@
+// ../../../node_modules/.pnpm/prismjs@1.30.0/node_modules/prismjs/components/prism-json.min.js
+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;