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

package/dist/prism-log.min-CcmZYCOq.js

@@ -0,0 +1,97 @@
+// ../../../node_modules/.pnpm/prismjs@1.30.0/node_modules/prismjs/components/prism-log.min.js
+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-CL-6tP_v.js

@@ -0,0 +1,16 @@
+// ../../../node_modules/.pnpm/prismjs@1.30.0/node_modules/prismjs/components/prism-lua.min.js
+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-CfFQPrwo.js

@@ -0,0 +1,28 @@
+// ../../../node_modules/.pnpm/prismjs@1.30.0/node_modules/prismjs/components/prism-makefile.min.js
+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-CHFT4_Ei.js

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

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

@@ -0,0 +1,59 @@
+// ../../../node_modules/.pnpm/prismjs@1.30.0/node_modules/prismjs/components/prism-python.min.js
+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-KRUvJnhz.js

@@ -0,0 +1,78 @@
+// ../../../node_modules/.pnpm/prismjs@1.30.0/node_modules/prismjs/components/prism-regex.min.js
+(function(e) {
+	var t = {
+		pattern: /\\[\\(){}[\]^$+*?|.]/,
+		alias: "escape"
+	}, n = /\\(?: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]|.)/, r = "(?:[^\\\\-]|" + n.source + ")", i = RegExp(r + "-" + r), a = {
+		pattern: /(<|')[^<>']+(?=[>']$)/,
+		lookbehind: !0,
+		alias: "variable"
+	};
+	e.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: n,
+						"range-punctuation": {
+							pattern: /-/,
+							alias: "operator"
+						}
+					}
+				},
+				"special-escape": t,
+				"char-set": {
+					pattern: /\\[wsd]|\\p\{[^{}]+\}/i,
+					alias: "class-name"
+				},
+				escape: n
+			}
+		},
+		"special-escape": t,
+		"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": a }
+		}],
+		anchor: {
+			pattern: /[$^]|\\[ABbGZz]/,
+			alias: "function"
+		},
+		escape: n,
+		group: [{
+			pattern: /\((?:\?(?:<[^<>']+>|'[^<>']+'|[>:]|<?[=!]|[idmnsuxU]+(?:-[idmnsuxU]+)?:?))?/,
+			alias: "punctuation",
+			inside: { "group-name": a }
+		}, {
+			pattern: /\)/,
+			alias: "punctuation"
+		}],
+		quantifier: {
+			pattern: /(?:[+*?]|\{\d+(?:,\d*)?\})[?+]?/,
+			alias: "number"
+		},
+		alternation: {
+			pattern: /\|/,
+			alias: "keyword"
+		}
+	};
+})(Prism);

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

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