@webskill/chatbot 0.0.1

package/dist/typescript-VRQ57_wQ.js

@@ -0,0 +1,543 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/typescript.js
+var require_typescript = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const IDENT_RE = "[A-Za-z$_][0-9A-Za-z$_]*";
+	const KEYWORDS = [
+		"as",
+		"in",
+		"of",
+		"if",
+		"for",
+		"while",
+		"finally",
+		"var",
+		"new",
+		"function",
+		"do",
+		"return",
+		"void",
+		"else",
+		"break",
+		"catch",
+		"instanceof",
+		"with",
+		"throw",
+		"case",
+		"default",
+		"try",
+		"switch",
+		"continue",
+		"typeof",
+		"delete",
+		"let",
+		"yield",
+		"const",
+		"class",
+		"debugger",
+		"async",
+		"await",
+		"static",
+		"import",
+		"from",
+		"export",
+		"extends"
+	];
+	const LITERALS = [
+		"true",
+		"false",
+		"null",
+		"undefined",
+		"NaN",
+		"Infinity"
+	];
+	const BUILT_INS = [].concat([
+		"setInterval",
+		"setTimeout",
+		"clearInterval",
+		"clearTimeout",
+		"require",
+		"exports",
+		"eval",
+		"isFinite",
+		"isNaN",
+		"parseFloat",
+		"parseInt",
+		"decodeURI",
+		"decodeURIComponent",
+		"encodeURI",
+		"encodeURIComponent",
+		"escape",
+		"unescape"
+	], [
+		"arguments",
+		"this",
+		"super",
+		"console",
+		"window",
+		"document",
+		"localStorage",
+		"module",
+		"global"
+	], [
+		"Intl",
+		"DataView",
+		"Number",
+		"Math",
+		"Date",
+		"String",
+		"RegExp",
+		"Object",
+		"Function",
+		"Boolean",
+		"Error",
+		"Symbol",
+		"Set",
+		"Map",
+		"WeakSet",
+		"WeakMap",
+		"Proxy",
+		"Reflect",
+		"JSON",
+		"Promise",
+		"Float64Array",
+		"Int16Array",
+		"Int32Array",
+		"Int8Array",
+		"Uint16Array",
+		"Uint32Array",
+		"Float32Array",
+		"Array",
+		"Uint8Array",
+		"Uint8ClampedArray",
+		"ArrayBuffer",
+		"BigInt64Array",
+		"BigUint64Array",
+		"BigInt"
+	], [
+		"EvalError",
+		"InternalError",
+		"RangeError",
+		"ReferenceError",
+		"SyntaxError",
+		"TypeError",
+		"URIError"
+	]);
+	/**
+	* @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 lookahead(re) {
+		return concat("(?=", re, ")");
+	}
+	/**
+	* @param {...(RegExp | string) } args
+	* @returns {string}
+	*/
+	function concat(...args) {
+		return args.map((x) => source(x)).join("");
+	}
+	/** @type LanguageFn */
+	function javascript(hljs) {
+		/**
+		* Takes a string like "<Booger" and checks to see
+		* if we can find a matching "</Booger" later in the
+		* content.
+		* @param {RegExpMatchArray} match
+		* @param {{after:number}} param1
+		*/
+		const hasClosingTag = (match, { after }) => {
+			const tag = "</" + match[0].slice(1);
+			return match.input.indexOf(tag, after) !== -1;
+		};
+		const IDENT_RE$1 = IDENT_RE;
+		const FRAGMENT = {
+			begin: "<>",
+			end: "</>"
+		};
+		const XML_TAG = {
+			begin: /<[A-Za-z0-9\\._:-]+/,
+			end: /\/[A-Za-z0-9\\._:-]+>|\/>/,
+			/**
+			* @param {RegExpMatchArray} match
+			* @param {CallbackResponse} response
+			*/
+			isTrulyOpeningTag: (match, response) => {
+				const afterMatchIndex = match[0].length + match.index;
+				const nextChar = match.input[afterMatchIndex];
+				if (nextChar === "<") {
+					response.ignoreMatch();
+					return;
+				}
+				if (nextChar === ">") {
+					if (!hasClosingTag(match, { after: afterMatchIndex })) response.ignoreMatch();
+				}
+			}
+		};
+		const KEYWORDS$1 = {
+			$pattern: IDENT_RE,
+			keyword: KEYWORDS,
+			literal: LITERALS,
+			built_in: BUILT_INS
+		};
+		const decimalDigits = "[0-9](_?[0-9])*";
+		const frac = `\\.(${decimalDigits})`;
+		const decimalInteger = `0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*`;
+		const NUMBER = {
+			className: "number",
+			variants: [
+				{ begin: `(\\b(${decimalInteger})((${frac})|\\.)?|(${frac}))[eE][+-]?(${decimalDigits})\\b` },
+				{ begin: `\\b(${decimalInteger})\\b((${frac})\\b|\\.)?|(${frac})\\b` },
+				{ begin: `\\b(0|[1-9](_?[0-9])*)n\\b` },
+				{ begin: "\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*n?\\b" },
+				{ begin: "\\b0[bB][0-1](_?[0-1])*n?\\b" },
+				{ begin: "\\b0[oO][0-7](_?[0-7])*n?\\b" },
+				{ begin: "\\b0[0-7]+n?\\b" }
+			],
+			relevance: 0
+		};
+		const SUBST = {
+			className: "subst",
+			begin: "\\$\\{",
+			end: "\\}",
+			keywords: KEYWORDS$1,
+			contains: []
+		};
+		const HTML_TEMPLATE = {
+			begin: "html`",
+			end: "",
+			starts: {
+				end: "`",
+				returnEnd: false,
+				contains: [hljs.BACKSLASH_ESCAPE, SUBST],
+				subLanguage: "xml"
+			}
+		};
+		const CSS_TEMPLATE = {
+			begin: "css`",
+			end: "",
+			starts: {
+				end: "`",
+				returnEnd: false,
+				contains: [hljs.BACKSLASH_ESCAPE, SUBST],
+				subLanguage: "css"
+			}
+		};
+		const TEMPLATE_STRING = {
+			className: "string",
+			begin: "`",
+			end: "`",
+			contains: [hljs.BACKSLASH_ESCAPE, SUBST]
+		};
+		const COMMENT = {
+			className: "comment",
+			variants: [
+				hljs.COMMENT(/\/\*\*(?!\/)/, "\\*/", {
+					relevance: 0,
+					contains: [{
+						className: "doctag",
+						begin: "@[A-Za-z]+",
+						contains: [
+							{
+								className: "type",
+								begin: "\\{",
+								end: "\\}",
+								relevance: 0
+							},
+							{
+								className: "variable",
+								begin: "[A-Za-z$_][0-9A-Za-z$_]*(?=\\s*(-)|$)",
+								endsParent: true,
+								relevance: 0
+							},
+							{
+								begin: /(?=[^\n])\s/,
+								relevance: 0
+							}
+						]
+					}]
+				}),
+				hljs.C_BLOCK_COMMENT_MODE,
+				hljs.C_LINE_COMMENT_MODE
+			]
+		};
+		const SUBST_INTERNALS = [
+			hljs.APOS_STRING_MODE,
+			hljs.QUOTE_STRING_MODE,
+			HTML_TEMPLATE,
+			CSS_TEMPLATE,
+			TEMPLATE_STRING,
+			NUMBER,
+			hljs.REGEXP_MODE
+		];
+		SUBST.contains = SUBST_INTERNALS.concat({
+			begin: /\{/,
+			end: /\}/,
+			keywords: KEYWORDS$1,
+			contains: ["self"].concat(SUBST_INTERNALS)
+		});
+		const SUBST_AND_COMMENTS = [].concat(COMMENT, SUBST.contains);
+		const PARAMS_CONTAINS = SUBST_AND_COMMENTS.concat([{
+			begin: /\(/,
+			end: /\)/,
+			keywords: KEYWORDS$1,
+			contains: ["self"].concat(SUBST_AND_COMMENTS)
+		}]);
+		const PARAMS = {
+			className: "params",
+			begin: /\(/,
+			end: /\)/,
+			excludeBegin: true,
+			excludeEnd: true,
+			keywords: KEYWORDS$1,
+			contains: PARAMS_CONTAINS
+		};
+		return {
+			name: "Javascript",
+			aliases: [
+				"js",
+				"jsx",
+				"mjs",
+				"cjs"
+			],
+			keywords: KEYWORDS$1,
+			exports: { PARAMS_CONTAINS },
+			illegal: /#(?![$_A-z])/,
+			contains: [
+				hljs.SHEBANG({
+					label: "shebang",
+					binary: "node",
+					relevance: 5
+				}),
+				{
+					label: "use_strict",
+					className: "meta",
+					relevance: 10,
+					begin: /^\s*['"]use (strict|asm)['"]/
+				},
+				hljs.APOS_STRING_MODE,
+				hljs.QUOTE_STRING_MODE,
+				HTML_TEMPLATE,
+				CSS_TEMPLATE,
+				TEMPLATE_STRING,
+				COMMENT,
+				NUMBER,
+				{
+					begin: concat(/[{,\n]\s*/, lookahead(concat(/(((\/\/.*$)|(\/\*(\*[^/]|[^*])*\*\/))\s*)*/, "[A-Za-z$_][0-9A-Za-z$_]*\\s*:"))),
+					relevance: 0,
+					contains: [{
+						className: "attr",
+						begin: IDENT_RE$1 + lookahead("\\s*:"),
+						relevance: 0
+					}]
+				},
+				{
+					begin: "(" + hljs.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
+					keywords: "return throw case",
+					contains: [
+						COMMENT,
+						hljs.REGEXP_MODE,
+						{
+							className: "function",
+							begin: "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + hljs.UNDERSCORE_IDENT_RE + ")\\s*=>",
+							returnBegin: true,
+							end: "\\s*=>",
+							contains: [{
+								className: "params",
+								variants: [
+									{
+										begin: hljs.UNDERSCORE_IDENT_RE,
+										relevance: 0
+									},
+									{
+										className: null,
+										begin: /\(\s*\)/,
+										skip: true
+									},
+									{
+										begin: /\(/,
+										end: /\)/,
+										excludeBegin: true,
+										excludeEnd: true,
+										keywords: KEYWORDS$1,
+										contains: PARAMS_CONTAINS
+									}
+								]
+							}]
+						},
+						{
+							begin: /,/,
+							relevance: 0
+						},
+						{
+							className: "",
+							begin: /\s/,
+							end: /\s*/,
+							skip: true
+						},
+						{
+							variants: [{
+								begin: FRAGMENT.begin,
+								end: FRAGMENT.end
+							}, {
+								begin: XML_TAG.begin,
+								"on:begin": XML_TAG.isTrulyOpeningTag,
+								end: XML_TAG.end
+							}],
+							subLanguage: "xml",
+							contains: [{
+								begin: XML_TAG.begin,
+								end: XML_TAG.end,
+								skip: true,
+								contains: ["self"]
+							}]
+						}
+					],
+					relevance: 0
+				},
+				{
+					className: "function",
+					beginKeywords: "function",
+					end: /[{;]/,
+					excludeEnd: true,
+					keywords: KEYWORDS$1,
+					contains: [
+						"self",
+						hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1 }),
+						PARAMS
+					],
+					illegal: /%/
+				},
+				{ beginKeywords: "while if switch catch for" },
+				{
+					className: "function",
+					begin: hljs.UNDERSCORE_IDENT_RE + "\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",
+					returnBegin: true,
+					contains: [PARAMS, hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1 })]
+				},
+				{
+					variants: [{ begin: "\\.[A-Za-z$_][0-9A-Za-z$_]*" }, { begin: "\\$[A-Za-z$_][0-9A-Za-z$_]*" }],
+					relevance: 0
+				},
+				{
+					className: "class",
+					beginKeywords: "class",
+					end: /[{;=]/,
+					excludeEnd: true,
+					illegal: /[:"[\]]/,
+					contains: [{ beginKeywords: "extends" }, hljs.UNDERSCORE_TITLE_MODE]
+				},
+				{
+					begin: /\b(?=constructor)/,
+					end: /[{;]/,
+					excludeEnd: true,
+					contains: [
+						hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1 }),
+						"self",
+						PARAMS
+					]
+				},
+				{
+					begin: "(get|set)\\s+(?=[A-Za-z$_][0-9A-Za-z$_]*\\()",
+					end: /\{/,
+					keywords: "get set",
+					contains: [
+						hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1 }),
+						{ begin: /\(\)/ },
+						PARAMS
+					]
+				},
+				{ begin: /\$[(.]/ }
+			]
+		};
+	}
+	/** @type LanguageFn */
+	function typescript(hljs) {
+		const NAMESPACE = {
+			beginKeywords: "namespace",
+			end: /\{/,
+			excludeEnd: true
+		};
+		const INTERFACE = {
+			beginKeywords: "interface",
+			end: /\{/,
+			excludeEnd: true,
+			keywords: "interface extends"
+		};
+		const USE_STRICT = {
+			className: "meta",
+			relevance: 10,
+			begin: /^\s*['"]use strict['"]/
+		};
+		const KEYWORDS$1 = {
+			$pattern: IDENT_RE,
+			keyword: KEYWORDS.concat([
+				"type",
+				"namespace",
+				"typedef",
+				"interface",
+				"public",
+				"private",
+				"protected",
+				"implements",
+				"declare",
+				"abstract",
+				"readonly"
+			]),
+			literal: LITERALS,
+			built_in: BUILT_INS.concat([
+				"any",
+				"void",
+				"number",
+				"boolean",
+				"string",
+				"object",
+				"never",
+				"enum"
+			])
+		};
+		const DECORATOR = {
+			className: "meta",
+			begin: "@[A-Za-z$_][0-9A-Za-z$_]*"
+		};
+		const swapMode = (mode, label, replacement) => {
+			const indx = mode.contains.findIndex((m) => m.label === label);
+			if (indx === -1) throw new Error("can not find mode to replace");
+			mode.contains.splice(indx, 1, replacement);
+		};
+		const tsLanguage = javascript(hljs);
+		Object.assign(tsLanguage.keywords, KEYWORDS$1);
+		tsLanguage.exports.PARAMS_CONTAINS.push(DECORATOR);
+		tsLanguage.contains = tsLanguage.contains.concat([
+			DECORATOR,
+			NAMESPACE,
+			INTERFACE
+		]);
+		swapMode(tsLanguage, "shebang", hljs.SHEBANG());
+		swapMode(tsLanguage, "use_strict", USE_STRICT);
+		const functionDeclaration = tsLanguage.contains.find((m) => m.className === "function");
+		functionDeclaration.relevance = 0;
+		Object.assign(tsLanguage, {
+			name: "TypeScript",
+			aliases: ["ts", "tsx"]
+		});
+		return tsLanguage;
+	}
+	module.exports = typescript;
+}));
+
+//#endregion
+export default require_typescript();

package/dist/typoscript-DHP8Z-kM.js

@@ -0,0 +1,68 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/typoscript.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+typoscript.displayName = "typoscript";
+typoscript.aliases = ["tsconfig"];
+/** @param {Refractor} Prism */
+function typoscript(Prism) {
+	(function(Prism) {
+		var keywords = /\b(?:ACT|ACTIFSUB|CARRAY|CASE|CLEARGIF|COA|COA_INT|CONSTANTS|CONTENT|CUR|EDITPANEL|EFFECT|EXT|FILE|FLUIDTEMPLATE|FORM|FRAME|FRAMESET|GIFBUILDER|GMENU|GMENU_FOLDOUT|GMENU_LAYERS|GP|HMENU|HRULER|HTML|IENV|IFSUB|IMAGE|IMGMENU|IMGMENUITEM|IMGTEXT|IMG_RESOURCE|INCLUDE_TYPOSCRIPT|JSMENU|JSMENUITEM|LLL|LOAD_REGISTER|NO|PAGE|RECORDS|RESTORE_REGISTER|TEMPLATE|TEXT|TMENU|TMENUITEM|TMENU_LAYERS|USER|USER_INT|_GIFBUILDER|global|globalString|globalVar)\b/;
+		Prism.languages.typoscript = {
+			comment: [
+				{
+					pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+					lookbehind: true
+				},
+				{
+					pattern: /(^|[^\\:= \t]|(?:^|[^= \t])[ \t]+)\/\/.*/,
+					lookbehind: true,
+					greedy: true
+				},
+				{
+					pattern: /(^|[^"'])#.*/,
+					lookbehind: true,
+					greedy: true
+				}
+			],
+			function: [{
+				pattern: /<INCLUDE_TYPOSCRIPT:\s*source\s*=\s*(?:"[^"\r\n]*"|'[^'\r\n]*')\s*>/,
+				inside: {
+					string: {
+						pattern: /"[^"\r\n]*"|'[^'\r\n]*'/,
+						inside: { keyword: keywords }
+					},
+					keyword: { pattern: /INCLUDE_TYPOSCRIPT/ }
+				}
+			}, {
+				pattern: /@import\s*(?:"[^"\r\n]*"|'[^'\r\n]*')/,
+				inside: { string: /"[^"\r\n]*"|'[^'\r\n]*'/ }
+			}],
+			string: {
+				pattern: /^([^=]*=[< ]?)(?:(?!\]\n).)*/,
+				lookbehind: true,
+				inside: {
+					function: /\{\$.*\}/,
+					keyword: keywords,
+					number: /^\d+$/,
+					punctuation: /[,|:]/
+				}
+			},
+			keyword: keywords,
+			number: {
+				pattern: /\b\d+\s*[.{=]/,
+				inside: { operator: /[.{=]/ }
+			},
+			tag: {
+				pattern: /\.?[-\w\\]+\.?/,
+				inside: { punctuation: /\./ }
+			},
+			punctuation: /[{}[\];(),.:|]/,
+			operator: /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/
+		};
+		Prism.languages.tsconfig = Prism.languages.typoscript;
+	})(Prism);
+}
+
+//#endregion
+export { typoscript as default };

package/dist/unrealscript-BpMIC14v.js

@@ -0,0 +1,50 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/unrealscript.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+unrealscript.displayName = "unrealscript";
+unrealscript.aliases = ["uc", "uscript"];
+/** @param {Refractor} Prism */
+function unrealscript(Prism) {
+	Prism.languages.unrealscript = {
+		comment: /\/\/.*|\/\*[\s\S]*?\*\//,
+		string: {
+			pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+			greedy: true
+		},
+		category: {
+			pattern: /(\b(?:(?:autoexpand|hide|show)categories|var)\s*\()[^()]+(?=\))/,
+			lookbehind: true,
+			greedy: true,
+			alias: "property"
+		},
+		metadata: {
+			pattern: /(\w\s*)<\s*\w+\s*=[^<>|=\r\n]+(?:\|\s*\w+\s*=[^<>|=\r\n]+)*>/,
+			lookbehind: true,
+			greedy: true,
+			inside: {
+				property: /\b\w+(?=\s*=)/,
+				operator: /=/,
+				punctuation: /[<>|]/
+			}
+		},
+		macro: {
+			pattern: /`\w+/,
+			alias: "property"
+		},
+		"class-name": {
+			pattern: /(\b(?:class|enum|extends|interface|state(?:\(\))?|struct|within)\s+)\w+/,
+			lookbehind: true
+		},
+		keyword: /\b(?:abstract|actor|array|auto|autoexpandcategories|bool|break|byte|case|class|classgroup|client|coerce|collapsecategories|config|const|continue|default|defaultproperties|delegate|dependson|deprecated|do|dontcollapsecategories|editconst|editinlinenew|else|enum|event|exec|export|extends|final|float|for|forcescriptorder|foreach|function|goto|guid|hidecategories|hidedropdown|if|ignores|implements|inherits|input|int|interface|iterator|latent|local|material|name|native|nativereplication|noexport|nontransient|noteditinlinenew|notplaceable|operator|optional|out|pawn|perobjectconfig|perobjectlocalized|placeable|postoperator|preoperator|private|protected|reliable|replication|return|server|showcategories|simulated|singular|state|static|string|struct|structdefault|structdefaultproperties|switch|texture|transient|travel|unreliable|until|var|vector|while|within)\b/,
+		function: /\b[a-z_]\w*(?=\s*\()/i,
+		boolean: /\b(?:false|true)\b/,
+		number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
+		operator: />>|<<|--|\+\+|\*\*|[-+*/~!=<>$@]=?|&&?|\|\|?|\^\^?|[?:%]|\b(?:ClockwiseFrom|Cross|Dot)\b/,
+		punctuation: /[()[\]{};,.]/
+	};
+	Prism.languages.uc = Prism.languages.uscript = Prism.languages.unrealscript;
+}
+
+//#endregion
+export { unrealscript as default };

package/dist/uorazor-BCojFkBB.js

@@ -0,0 +1,55 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/uorazor.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+uorazor.displayName = "uorazor";
+uorazor.aliases = [];
+/** @param {Refractor} Prism */
+function uorazor(Prism) {
+	Prism.languages.uorazor = {
+		"comment-hash": {
+			pattern: /#.*/,
+			alias: "comment",
+			greedy: true
+		},
+		"comment-slash": {
+			pattern: /\/\/.*/,
+			alias: "comment",
+			greedy: true
+		},
+		string: {
+			pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+			inside: { punctuation: /^['"]|['"]$/ },
+			greedy: true
+		},
+		"source-layers": {
+			pattern: /\b(?:arms|backpack|blue|bracelet|cancel|clear|cloak|criminal|earrings|enemy|facialhair|friend|friendly|gloves|gray|grey|ground|hair|head|innerlegs|innertorso|innocent|lefthand|middletorso|murderer|neck|nonfriendly|onehandedsecondary|outerlegs|outertorso|pants|red|righthand|ring|self|shirt|shoes|talisman|waist)\b/i,
+			alias: "function"
+		},
+		"source-commands": {
+			pattern: /\b(?:alliance|attack|cast|clearall|clearignore|clearjournal|clearlist|clearsysmsg|createlist|createtimer|dclick|dclicktype|dclickvar|dress|dressconfig|drop|droprelloc|emote|getlabel|guild|gumpclose|gumpresponse|hotkey|ignore|lasttarget|lift|lifttype|menu|menuresponse|msg|org|organize|organizer|overhead|pause|poplist|potion|promptresponse|pushlist|removelist|removetimer|rename|restock|say|scav|scavenger|script|setability|setlasttarget|setskill|settimer|setvar|sysmsg|target|targetloc|targetrelloc|targettype|undress|unignore|unsetvar|useobject|useonce|useskill|usetype|virtue|wait|waitforgump|waitformenu|waitforprompt|waitforstat|waitforsysmsg|waitfortarget|walk|wfsysmsg|wft|whisper|yell)\b/,
+			alias: "function"
+		},
+		"tag-name": {
+			pattern: /(^\{%-?\s*)\w+/,
+			lookbehind: true,
+			alias: "keyword"
+		},
+		delimiter: {
+			pattern: /^\{[{%]-?|-?[%}]\}$/,
+			alias: "punctuation"
+		},
+		function: /\b(?:atlist|close|closest|count|counter|counttype|dead|dex|diffhits|diffmana|diffstam|diffweight|find|findbuff|finddebuff|findlayer|findtype|findtypelist|followers|gumpexists|hidden|hits|hp|hue|human|humanoid|ingump|inlist|insysmessage|insysmsg|int|invul|lhandempty|list|listexists|mana|maxhits|maxhp|maxmana|maxstam|maxweight|monster|mounted|name|next|noto|paralyzed|poisoned|position|prev|previous|queued|rand|random|rhandempty|skill|stam|str|targetexists|timer|timerexists|varexist|warmode|weight)\b/,
+		keyword: /\b(?:and|as|break|continue|else|elseif|endfor|endif|endwhile|for|if|loop|not|or|replay|stop|while)\b/,
+		boolean: /\b(?:false|null|true)\b/,
+		number: /\b0x[\dA-Fa-f]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee][-+]?\d+)?/,
+		operator: [{
+			pattern: /(\s)(?:and|b-and|b-or|b-xor|ends with|in|is|matches|not|or|same as|starts with)(?=\s)/,
+			lookbehind: true
+		}, /[=<>]=?|!=|\*\*?|\/\/?|\?:?|[-+~%|]/],
+		punctuation: /[()\[\]{}:.,]/
+	};
+}
+
+//#endregion
+export { uorazor as default };