@webskill/chatbot 0.0.1

package/dist/systemd-7dRag1wn.js

@@ -0,0 +1,58 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/systemd.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+systemd.displayName = "systemd";
+systemd.aliases = [];
+/** @param {Refractor} Prism */
+function systemd(Prism) {
+	(function(Prism) {
+		var comment = {
+			pattern: /^[;#].*/m,
+			greedy: true
+		};
+		var quotesSource = /"(?:[^\r\n"\\]|\\(?:[^\r]|\r\n?))*"(?!\S)/.source;
+		Prism.languages.systemd = {
+			comment,
+			section: {
+				pattern: /^\[[^\n\r\[\]]*\](?=[ \t]*$)/m,
+				greedy: true,
+				inside: {
+					punctuation: /^\[|\]$/,
+					"section-name": {
+						pattern: /[\s\S]+/,
+						alias: "selector"
+					}
+				}
+			},
+			key: {
+				pattern: /^[^\s=]+(?=[ \t]*=)/m,
+				greedy: true,
+				alias: "attr-name"
+			},
+			value: {
+				pattern: RegExp(/(=[ \t]*(?!\s))/.source + "(?:" + quotesSource + "|(?=[^\"\r\n]))(?:" + (/[^\s\\]/.source + "|[ 	]+(?:(?![ 	\"])|" + quotesSource + ")|" + /\\[\r\n]+(?:[#;].*[\r\n]+)*(?![#;])/.source) + ")*"),
+				lookbehind: true,
+				greedy: true,
+				alias: "attr-value",
+				inside: {
+					comment,
+					quoted: {
+						pattern: RegExp(/(^|\s)/.source + quotesSource),
+						lookbehind: true,
+						greedy: true
+					},
+					punctuation: /\\$/m,
+					boolean: {
+						pattern: /^(?:false|no|off|on|true|yes)$/,
+						greedy: true
+					}
+				}
+			},
+			punctuation: /=/
+		};
+	})(Prism);
+}
+
+//#endregion
+export { systemd as default };

package/dist/t4-cs-CZCr77ej.js

@@ -0,0 +1,18 @@
+import csharp from "./csharp-iSWtQEXl.js";
+import t4Templating from "./t4-templating-8CSCnuNF.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/t4-cs.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+t4Cs.displayName = "t4-cs";
+t4Cs.aliases = ["t4"];
+/** @param {Refractor} Prism */
+function t4Cs(Prism) {
+	Prism.register(csharp);
+	Prism.register(t4Templating);
+	Prism.languages.t4 = Prism.languages["t4-cs"] = Prism.languages["t4-templating"].createT4("csharp");
+}
+
+//#endregion
+export { t4Cs as default };

package/dist/t4-templating-8CSCnuNF.js

@@ -0,0 +1,52 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/t4-templating.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+t4Templating.displayName = "t4-templating";
+t4Templating.aliases = [];
+/** @param {Refractor} Prism */
+function t4Templating(Prism) {
+	(function(Prism) {
+		function createBlock(prefix, inside, contentAlias) {
+			return {
+				pattern: RegExp("<#" + prefix + "[\\s\\S]*?#>"),
+				alias: "block",
+				inside: {
+					delimiter: {
+						pattern: RegExp("^<#" + prefix + "|#>$"),
+						alias: "important"
+					},
+					content: {
+						pattern: /[\s\S]+/,
+						inside,
+						alias: contentAlias
+					}
+				}
+			};
+		}
+		function createT4(insideLang) {
+			var grammar = Prism.languages[insideLang];
+			var className = "language-" + insideLang;
+			return { block: {
+				pattern: /<#[\s\S]+?#>/,
+				inside: {
+					directive: createBlock("@", {
+						"attr-value": {
+							pattern: /=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+)/,
+							inside: { punctuation: /^=|^["']|["']$/ }
+						},
+						keyword: /\b\w+(?=\s)/,
+						"attr-name": /\b\w+/
+					}),
+					expression: createBlock("=", grammar, className),
+					"class-feature": createBlock("\\+", grammar, className),
+					standard: createBlock("", grammar, className)
+				}
+			} };
+		}
+		Prism.languages["t4-templating"] = Object.defineProperty({}, "createT4", { value: createT4 });
+	})(Prism);
+}
+
+//#endregion
+export { t4Templating as default };

package/dist/t4-vb-DJLoxP6-.js

@@ -0,0 +1,18 @@
+import t4Templating from "./t4-templating-8CSCnuNF.js";
+import vbnet from "./vbnet-MuzuuWpL.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/t4-vb.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+t4Vb.displayName = "t4-vb";
+t4Vb.aliases = [];
+/** @param {Refractor} Prism */
+function t4Vb(Prism) {
+	Prism.register(t4Templating);
+	Prism.register(vbnet);
+	Prism.languages["t4-vb"] = Prism.languages["t4-templating"].createT4("vbnet");
+}
+
+//#endregion
+export { t4Vb as default };

package/dist/taggerscript-DUgIsxmY.js

@@ -0,0 +1,42 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/taggerscript.js
+var require_taggerscript = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function taggerscript(hljs) {
+		return {
+			name: "Tagger Script",
+			contains: [
+				{
+					className: "comment",
+					begin: /\$noop\(/,
+					end: /\)/,
+					contains: [{
+						begin: /\(/,
+						end: /\)/,
+						contains: ["self", { begin: /\\./ }]
+					}],
+					relevance: 10
+				},
+				{
+					className: "keyword",
+					begin: /\$(?!noop)[a-zA-Z][_a-zA-Z0-9]*/,
+					end: /\(/,
+					excludeEnd: true
+				},
+				{
+					className: "variable",
+					begin: /%[_a-zA-Z0-9:]*/,
+					end: "%"
+				},
+				{
+					className: "symbol",
+					begin: /\\./
+				}
+			]
+		};
+	}
+	module.exports = taggerscript;
+}));
+
+//#endregion
+export default require_taggerscript();

package/dist/tap-BrbYnFCE.js

@@ -0,0 +1,36 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/tap.js
+var require_tap = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function tap(hljs) {
+		return {
+			name: "Test Anything Protocol",
+			case_insensitive: true,
+			contains: [
+				hljs.HASH_COMMENT_MODE,
+				{
+					className: "meta",
+					variants: [{ begin: "^TAP version (\\d+)$" }, { begin: "^1\\.\\.(\\d+)$" }]
+				},
+				{
+					begin: /---$/,
+					end: "\\.\\.\\.$",
+					subLanguage: "yaml",
+					relevance: 0
+				},
+				{
+					className: "number",
+					begin: " (\\d+) "
+				},
+				{
+					className: "symbol",
+					variants: [{ begin: "^ok" }, { begin: "^not ok" }]
+				}
+			]
+		};
+	}
+	module.exports = tap;
+}));
+
+//#endregion
+export default require_tap();

package/dist/tap-CKwf9TXR.js

@@ -0,0 +1,35 @@
+import { t as yaml } from "./yaml-C888tCbJ.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/tap.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+tap.displayName = "tap";
+tap.aliases = [];
+/** @param {Refractor} Prism */
+function tap(Prism) {
+	Prism.register(yaml);
+	Prism.languages.tap = {
+		fail: /not ok[^#{\n\r]*/,
+		pass: /ok[^#{\n\r]*/,
+		pragma: /pragma [+-][a-z]+/,
+		bailout: /bail out!.*/i,
+		version: /TAP version \d+/i,
+		plan: /\b\d+\.\.\d+(?: +#.*)?/,
+		subtest: {
+			pattern: /# Subtest(?:: .*)?/,
+			greedy: true
+		},
+		punctuation: /[{}]/,
+		directive: /#.*/,
+		yamlish: {
+			pattern: /(^[ \t]*)---[\s\S]*?[\r\n][ \t]*\.\.\.$/m,
+			lookbehind: true,
+			inside: Prism.languages.yaml,
+			alias: "language-yaml"
+		}
+	};
+}
+
+//#endregion
+export { tap as default };

package/dist/tcl-Bu0LzhCS.js

@@ -0,0 +1,78 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/tcl.js
+var require_tcl = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* @param {string} value
+	* @returns {RegExp}
+	* */
+	/**
+	* @param {RegExp | string } re
+	* @returns {string}
+	*/
+	function source(re) {
+		if (!re) return null;
+		if (typeof re === "string") return re;
+		return re.source;
+	}
+	/**
+	* @param {RegExp | string } re
+	* @returns {string}
+	*/
+	function optional(re) {
+		return concat("(", re, ")?");
+	}
+	/**
+	* @param {...(RegExp | string) } args
+	* @returns {string}
+	*/
+	function concat(...args) {
+		return args.map((x) => source(x)).join("");
+	}
+	function tcl(hljs) {
+		const TCL_IDENT = /[a-zA-Z_][a-zA-Z0-9_]*/;
+		const NUMBER = {
+			className: "number",
+			variants: [hljs.BINARY_NUMBER_MODE, hljs.C_NUMBER_MODE]
+		};
+		return {
+			name: "Tcl",
+			aliases: ["tk"],
+			keywords: "after append apply array auto_execok auto_import auto_load auto_mkindex auto_mkindex_old auto_qualify auto_reset bgerror binary break catch cd chan clock close concat continue dde dict encoding eof error eval exec exit expr fblocked fconfigure fcopy file fileevent filename flush for foreach format gets glob global history http if incr info interp join lappend|10 lassign|10 lindex|10 linsert|10 list llength|10 load lrange|10 lrepeat|10 lreplace|10 lreverse|10 lsearch|10 lset|10 lsort|10 mathfunc mathop memory msgcat namespace open package parray pid pkg::create pkg_mkIndex platform platform::shell proc puts pwd read refchan regexp registry regsub|10 rename return safe scan seek set socket source split string subst switch tcl_endOfWord tcl_findLibrary tcl_startOfNextWord tcl_startOfPreviousWord tcl_wordBreakAfter tcl_wordBreakBefore tcltest tclvars tell time tm trace unknown unload unset update uplevel upvar variable vwait while",
+			contains: [
+				hljs.COMMENT(";[ \\t]*#", "$"),
+				hljs.COMMENT("^[ \\t]*#", "$"),
+				{
+					beginKeywords: "proc",
+					end: "[\\{]",
+					excludeEnd: true,
+					contains: [{
+						className: "title",
+						begin: "[ \\t\\n\\r]+(::)?[a-zA-Z_]((::)?[a-zA-Z0-9_])*",
+						end: "[ \\t\\n\\r]",
+						endsWithParent: true,
+						excludeEnd: true
+					}]
+				},
+				{
+					className: "variable",
+					variants: [{ begin: concat(/\$/, optional(/::/), TCL_IDENT, "(::", TCL_IDENT, ")*") }, {
+						begin: "\\$\\{(::)?[a-zA-Z_]((::)?[a-zA-Z0-9_])*",
+						end: "\\}",
+						contains: [NUMBER]
+					}]
+				},
+				{
+					className: "string",
+					contains: [hljs.BACKSLASH_ESCAPE],
+					variants: [hljs.inherit(hljs.QUOTE_STRING_MODE, { illegal: null })]
+				},
+				NUMBER
+			]
+		};
+	}
+	module.exports = tcl;
+}));
+
+//#endregion
+export default require_tcl();

package/dist/tcl-CLjFvMbO.js

@@ -0,0 +1,55 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/tcl.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+tcl.displayName = "tcl";
+tcl.aliases = [];
+/** @param {Refractor} Prism */
+function tcl(Prism) {
+	Prism.languages.tcl = {
+		comment: {
+			pattern: /(^|[^\\])#.*/,
+			lookbehind: true
+		},
+		string: {
+			pattern: /"(?:[^"\\\r\n]|\\(?:\r\n|[\s\S]))*"/,
+			greedy: true
+		},
+		variable: [
+			{
+				pattern: /(\$)(?:::)?(?:[a-zA-Z0-9]+::)*\w+/,
+				lookbehind: true
+			},
+			{
+				pattern: /(\$)\{[^}]+\}/,
+				lookbehind: true
+			},
+			{
+				pattern: /(^[\t ]*set[ \t]+)(?:::)?(?:[a-zA-Z0-9]+::)*\w+/m,
+				lookbehind: true
+			}
+		],
+		function: {
+			pattern: /(^[\t ]*proc[ \t]+)\S+/m,
+			lookbehind: true
+		},
+		builtin: [{
+			pattern: /(^[\t ]*)(?:break|class|continue|error|eval|exit|for|foreach|if|proc|return|switch|while)\b/m,
+			lookbehind: true
+		}, /\b(?:else|elseif)\b/],
+		scope: {
+			pattern: /(^[\t ]*)(?:global|upvar|variable)\b/m,
+			lookbehind: true,
+			alias: "constant"
+		},
+		keyword: {
+			pattern: /(^[\t ]*|\[)(?:Safe_Base|Tcl|after|append|apply|array|auto_(?:execok|import|load|mkindex|qualify|reset)|automkindex_old|bgerror|binary|catch|cd|chan|clock|close|concat|dde|dict|encoding|eof|exec|expr|fblocked|fconfigure|fcopy|file(?:event|name)?|flush|gets|glob|history|http|incr|info|interp|join|lappend|lassign|lindex|linsert|list|llength|load|lrange|lrepeat|lreplace|lreverse|lsearch|lset|lsort|math(?:func|op)|memory|msgcat|namespace|open|package|parray|pid|pkg_mkIndex|platform|puts|pwd|re_syntax|read|refchan|regexp|registry|regsub|rename|scan|seek|set|socket|source|split|string|subst|tcl(?:_endOfWord|_findLibrary|startOf(?:Next|Previous)Word|test|vars|wordBreak(?:After|Before))|tell|time|tm|trace|unknown|unload|unset|update|uplevel|vwait)\b/m,
+			lookbehind: true
+		},
+		operator: /!=?|\*\*?|==|&&?|\|\|?|<[=<]?|>[=>]?|[-+~\/%?^]|\b(?:eq|in|ne|ni)\b/,
+		punctuation: /[{}()\[\]]/
+	};
+}
+
+//#endregion
+export { tcl as default };

package/dist/textile-CVDmKYP-.js

@@ -0,0 +1,225 @@
+import { t as markup } from "./markup-D2NSmoAx.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/textile.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+textile.displayName = "textile";
+textile.aliases = [];
+/** @param {Refractor} Prism */
+function textile(Prism) {
+	Prism.register(markup);
+	(function(Prism) {
+		var modifierRegex = /\([^|()\n]+\)|\[[^\]\n]+\]|\{[^}\n]+\}/.source;
+		var parenthesesRegex = /\)|\((?![^|()\n]+\))/.source;
+		/**
+		* @param {string} source
+		* @param {string} [flags]
+		*/
+		function withModifier(source, flags) {
+			return RegExp(source.replace(/<MOD>/g, function() {
+				return "(?:" + modifierRegex + ")";
+			}).replace(/<PAR>/g, function() {
+				return "(?:" + parenthesesRegex + ")";
+			}), flags || "");
+		}
+		var modifierTokens = {
+			css: {
+				pattern: /\{[^{}]+\}/,
+				inside: { rest: Prism.languages.css }
+			},
+			"class-id": {
+				pattern: /(\()[^()]+(?=\))/,
+				lookbehind: true,
+				alias: "attr-value"
+			},
+			lang: {
+				pattern: /(\[)[^\[\]]+(?=\])/,
+				lookbehind: true,
+				alias: "attr-value"
+			},
+			punctuation: /[\\\/]\d+|\S/
+		};
+		var textile = Prism.languages.textile = Prism.languages.extend("markup", { phrase: {
+			pattern: /(^|\r|\n)\S[\s\S]*?(?=$|\r?\n\r?\n|\r\r)/,
+			lookbehind: true,
+			inside: {
+				"block-tag": {
+					pattern: withModifier(/^[a-z]\w*(?:<MOD>|<PAR>|[<>=])*\./.source),
+					inside: {
+						modifier: {
+							pattern: withModifier(/(^[a-z]\w*)(?:<MOD>|<PAR>|[<>=])+(?=\.)/.source),
+							lookbehind: true,
+							inside: modifierTokens
+						},
+						tag: /^[a-z]\w*/,
+						punctuation: /\.$/
+					}
+				},
+				list: {
+					pattern: withModifier(/^[*#]+<MOD>*\s+\S.*/.source, "m"),
+					inside: {
+						modifier: {
+							pattern: withModifier(/(^[*#]+)<MOD>+/.source),
+							lookbehind: true,
+							inside: modifierTokens
+						},
+						punctuation: /^[*#]+/
+					}
+				},
+				table: {
+					pattern: withModifier(/^(?:(?:<MOD>|<PAR>|[<>=^~])+\.\s*)?(?:\|(?:(?:<MOD>|<PAR>|[<>=^~_]|[\\/]\d+)+\.|(?!(?:<MOD>|<PAR>|[<>=^~_]|[\\/]\d+)+\.))[^|]*)+\|/.source, "m"),
+					inside: {
+						modifier: {
+							pattern: withModifier(/(^|\|(?:\r?\n|\r)?)(?:<MOD>|<PAR>|[<>=^~_]|[\\/]\d+)+(?=\.)/.source),
+							lookbehind: true,
+							inside: modifierTokens
+						},
+						punctuation: /\||^\./
+					}
+				},
+				inline: {
+					pattern: withModifier(/(^|[^a-zA-Z\d])(\*\*|__|\?\?|[*_%@+\-^~])<MOD>*.+?\2(?![a-zA-Z\d])/.source),
+					lookbehind: true,
+					inside: {
+						bold: {
+							pattern: withModifier(/(^(\*\*?)<MOD>*).+?(?=\2)/.source),
+							lookbehind: true
+						},
+						italic: {
+							pattern: withModifier(/(^(__?)<MOD>*).+?(?=\2)/.source),
+							lookbehind: true
+						},
+						cite: {
+							pattern: withModifier(/(^\?\?<MOD>*).+?(?=\?\?)/.source),
+							lookbehind: true,
+							alias: "string"
+						},
+						code: {
+							pattern: withModifier(/(^@<MOD>*).+?(?=@)/.source),
+							lookbehind: true,
+							alias: "keyword"
+						},
+						inserted: {
+							pattern: withModifier(/(^\+<MOD>*).+?(?=\+)/.source),
+							lookbehind: true
+						},
+						deleted: {
+							pattern: withModifier(/(^-<MOD>*).+?(?=-)/.source),
+							lookbehind: true
+						},
+						span: {
+							pattern: withModifier(/(^%<MOD>*).+?(?=%)/.source),
+							lookbehind: true
+						},
+						modifier: {
+							pattern: withModifier(/(^\*\*|__|\?\?|[*_%@+\-^~])<MOD>+/.source),
+							lookbehind: true,
+							inside: modifierTokens
+						},
+						punctuation: /[*_%?@+\-^~]+/
+					}
+				},
+				"link-ref": {
+					pattern: /^\[[^\]]+\]\S+$/m,
+					inside: {
+						string: {
+							pattern: /(^\[)[^\]]+(?=\])/,
+							lookbehind: true
+						},
+						url: {
+							pattern: /(^\])\S+$/,
+							lookbehind: true
+						},
+						punctuation: /[\[\]]/
+					}
+				},
+				link: {
+					pattern: withModifier(/"<MOD>*[^"]+":.+?(?=[^\w/]?(?:\s|$))/.source),
+					inside: {
+						text: {
+							pattern: withModifier(/(^"<MOD>*)[^"]+(?=")/.source),
+							lookbehind: true
+						},
+						modifier: {
+							pattern: withModifier(/(^")<MOD>+/.source),
+							lookbehind: true,
+							inside: modifierTokens
+						},
+						url: {
+							pattern: /(:).+/,
+							lookbehind: true
+						},
+						punctuation: /[":]/
+					}
+				},
+				image: {
+					pattern: withModifier(/!(?:<MOD>|<PAR>|[<>=])*(?![<>=])[^!\s()]+(?:\([^)]+\))?!(?::.+?(?=[^\w/]?(?:\s|$)))?/.source),
+					inside: {
+						source: {
+							pattern: withModifier(/(^!(?:<MOD>|<PAR>|[<>=])*)(?![<>=])[^!\s()]+(?:\([^)]+\))?(?=!)/.source),
+							lookbehind: true,
+							alias: "url"
+						},
+						modifier: {
+							pattern: withModifier(/(^!)(?:<MOD>|<PAR>|[<>=])+/.source),
+							lookbehind: true,
+							inside: modifierTokens
+						},
+						url: {
+							pattern: /(:).+/,
+							lookbehind: true
+						},
+						punctuation: /[!:]/
+					}
+				},
+				footnote: {
+					pattern: /\b\[\d+\]/,
+					alias: "comment",
+					inside: { punctuation: /\[|\]/ }
+				},
+				acronym: {
+					pattern: /\b[A-Z\d]+\([^)]+\)/,
+					inside: {
+						comment: {
+							pattern: /(\()[^()]+(?=\))/,
+							lookbehind: true
+						},
+						punctuation: /[()]/
+					}
+				},
+				mark: {
+					pattern: /\b\((?:C|R|TM)\)/,
+					alias: "comment",
+					inside: { punctuation: /[()]/ }
+				}
+			}
+		} });
+		var phraseInside = textile["phrase"].inside;
+		var nestedPatterns = {
+			inline: phraseInside["inline"],
+			link: phraseInside["link"],
+			image: phraseInside["image"],
+			footnote: phraseInside["footnote"],
+			acronym: phraseInside["acronym"],
+			mark: phraseInside["mark"]
+		};
+		textile.tag.pattern = /<\/?(?!\d)[a-z0-9]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+))?)*\s*\/?>/i;
+		var phraseInlineInside = phraseInside["inline"].inside;
+		phraseInlineInside["bold"].inside = nestedPatterns;
+		phraseInlineInside["italic"].inside = nestedPatterns;
+		phraseInlineInside["inserted"].inside = nestedPatterns;
+		phraseInlineInside["deleted"].inside = nestedPatterns;
+		phraseInlineInside["span"].inside = nestedPatterns;
+		var phraseTableInside = phraseInside["table"].inside;
+		phraseTableInside["inline"] = nestedPatterns["inline"];
+		phraseTableInside["link"] = nestedPatterns["link"];
+		phraseTableInside["image"] = nestedPatterns["image"];
+		phraseTableInside["footnote"] = nestedPatterns["footnote"];
+		phraseTableInside["acronym"] = nestedPatterns["acronym"];
+		phraseTableInside["mark"] = nestedPatterns["mark"];
+	})(Prism);
+}
+
+//#endregion
+export { textile as default };

package/dist/thrift-2RQozBtH.js

@@ -0,0 +1,42 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/thrift.js
+var require_thrift = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function thrift(hljs) {
+		const BUILT_IN_TYPES = "bool byte i16 i32 i64 double string binary";
+		return {
+			name: "Thrift",
+			keywords: {
+				keyword: "namespace const typedef struct enum service exception void oneway set list map required optional",
+				built_in: BUILT_IN_TYPES,
+				literal: "true false"
+			},
+			contains: [
+				hljs.QUOTE_STRING_MODE,
+				hljs.NUMBER_MODE,
+				hljs.C_LINE_COMMENT_MODE,
+				hljs.C_BLOCK_COMMENT_MODE,
+				{
+					className: "class",
+					beginKeywords: "struct enum service exception",
+					end: /\{/,
+					illegal: /\n/,
+					contains: [hljs.inherit(hljs.TITLE_MODE, { starts: {
+						endsWithParent: true,
+						excludeEnd: true
+					} })]
+				},
+				{
+					begin: "\\b(set|list|map)\\s*<",
+					end: ">",
+					keywords: BUILT_IN_TYPES,
+					contains: ["self"]
+				}
+			]
+		};
+	}
+	module.exports = thrift;
+}));
+
+//#endregion
+export default require_thrift();