@webskill/chatbot 0.0.1

package/dist/uri-M2gkNRgb.js

@@ -0,0 +1,82 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/uri.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+uri.displayName = "uri";
+uri.aliases = ["url"];
+/** @param {Refractor} Prism */
+function uri(Prism) {
+	Prism.languages.uri = {
+		scheme: {
+			pattern: /^[a-z][a-z0-9+.-]*:/im,
+			greedy: true,
+			inside: { "scheme-delimiter": /:$/ }
+		},
+		fragment: {
+			pattern: /#[\w\-.~!$&'()*+,;=%:@/?]*/,
+			inside: { "fragment-delimiter": /^#/ }
+		},
+		query: {
+			pattern: /\?[\w\-.~!$&'()*+,;=%:@/?]*/,
+			inside: {
+				"query-delimiter": {
+					pattern: /^\?/,
+					greedy: true
+				},
+				"pair-delimiter": /[&;]/,
+				pair: {
+					pattern: /^[^=][\s\S]*/,
+					inside: {
+						key: /^[^=]+/,
+						value: {
+							pattern: /(^=)[\s\S]+/,
+							lookbehind: true
+						}
+					}
+				}
+			}
+		},
+		authority: {
+			pattern: RegExp(/^\/\//.source + /(?:[\w\-.~!$&'()*+,;=%:]*@)?/.source + ("(?:" + /\[(?:[0-9a-fA-F:.]{2,48}|v[0-9a-fA-F]+\.[\w\-.~!$&'()*+,;=]+)\]/.source + "|" + /[\w\-.~!$&'()*+,;=%]*/.source + ")") + /(?::\d*)?/.source, "m"),
+			inside: {
+				"authority-delimiter": /^\/\//,
+				"user-info-segment": {
+					pattern: /^[\w\-.~!$&'()*+,;=%:]*@/,
+					inside: {
+						"user-info-delimiter": /@$/,
+						"user-info": /^[\w\-.~!$&'()*+,;=%:]+/
+					}
+				},
+				"port-segment": {
+					pattern: /:\d*$/,
+					inside: {
+						"port-delimiter": /^:/,
+						port: /^\d+/
+					}
+				},
+				host: {
+					pattern: /[\s\S]+/,
+					inside: {
+						"ip-literal": {
+							pattern: /^\[[\s\S]+\]$/,
+							inside: {
+								"ip-literal-delimiter": /^\[|\]$/,
+								"ipv-future": /^v[\s\S]+/,
+								"ipv6-address": /^[\s\S]+/
+							}
+						},
+						"ipv4-address": /^(?:(?:[03-9]\d?|[12]\d{0,2})\.){3}(?:[03-9]\d?|[12]\d{0,2})$/
+					}
+				}
+			}
+		},
+		path: {
+			pattern: /^[\w\-.~!$&'()*+,;=%:@/]+/m,
+			inside: { "path-separator": /\// }
+		}
+	};
+	Prism.languages.url = Prism.languages.uri;
+}
+
+//#endregion
+export { uri as default };

package/dist/v-Ba5p0lq0.js

@@ -0,0 +1,84 @@
+import { t as clike } from "./clike-BvmU1AL7.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/v.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+v.displayName = "v";
+v.aliases = [];
+/** @param {Refractor} Prism */
+function v(Prism) {
+	Prism.register(clike);
+	(function(Prism) {
+		var interpolationExpr = {
+			pattern: /[\s\S]+/,
+			inside: null
+		};
+		Prism.languages.v = Prism.languages.extend("clike", {
+			string: {
+				pattern: /r?(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+				alias: "quoted-string",
+				greedy: true,
+				inside: { interpolation: {
+					pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:\{[^{}]*\}|\w+(?:\.\w+(?:\([^\(\)]*\))?|\[[^\[\]]+\])*)/,
+					lookbehind: true,
+					inside: {
+						"interpolation-variable": {
+							pattern: /^\$\w[\s\S]*$/,
+							alias: "variable"
+						},
+						"interpolation-punctuation": {
+							pattern: /^\$\{|\}$/,
+							alias: "punctuation"
+						},
+						"interpolation-expression": interpolationExpr
+					}
+				} }
+			},
+			"class-name": {
+				pattern: /(\b(?:enum|interface|struct|type)\s+)(?:C\.)?\w+/,
+				lookbehind: true
+			},
+			keyword: /(?:\b(?:__global|as|asm|assert|atomic|break|chan|const|continue|defer|else|embed|enum|fn|for|go(?:to)?|if|import|in|interface|is|lock|match|module|mut|none|or|pub|return|rlock|select|shared|sizeof|static|struct|type(?:of)?|union|unsafe)|\$(?:else|for|if)|#(?:flag|include))\b/,
+			number: /\b(?:0x[a-f\d]+(?:_[a-f\d]+)*|0b[01]+(?:_[01]+)*|0o[0-7]+(?:_[0-7]+)*|\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?)\b/i,
+			operator: /~|\?|[*\/%^!=]=?|\+[=+]?|-[=-]?|\|[=|]?|&(?:=|&|\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\.\.\.?/,
+			builtin: /\b(?:any(?:_float|_int)?|bool|byte(?:ptr)?|charptr|f(?:32|64)|i(?:8|16|64|128|nt)|rune|size_t|string|u(?:16|32|64|128)|voidptr)\b/
+		});
+		interpolationExpr.inside = Prism.languages.v;
+		Prism.languages.insertBefore("v", "string", { char: {
+			pattern: /`(?:\\`|\\?[^`]{1,2})`/,
+			alias: "rune"
+		} });
+		Prism.languages.insertBefore("v", "operator", {
+			attribute: {
+				pattern: /(^[\t ]*)\[(?:deprecated|direct_array_access|flag|inline|live|ref_only|typedef|unsafe_fn|windows_stdcall)\]/m,
+				lookbehind: true,
+				alias: "annotation",
+				inside: {
+					punctuation: /[\[\]]/,
+					keyword: /\w+/
+				}
+			},
+			generic: {
+				pattern: /<\w+>(?=\s*[\)\{])/,
+				inside: {
+					punctuation: /[<>]/,
+					"class-name": /\w+/
+				}
+			}
+		});
+		Prism.languages.insertBefore("v", "function", { "generic-function": {
+			pattern: /\b\w+\s*<\w+>(?=\()/,
+			inside: {
+				function: /^\w+/,
+				generic: {
+					pattern: /<\w+>/,
+					inside: Prism.languages.v.generic.inside
+				}
+			}
+		} });
+	})(Prism);
+}
+
+//#endregion
+export { v as default };

package/dist/vala-D3hq3MeR.js

@@ -0,0 +1,46 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/vala.js
+var require_vala = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function vala(hljs) {
+		return {
+			name: "Vala",
+			keywords: {
+				keyword: "char uchar unichar int uint long ulong short ushort int8 int16 int32 int64 uint8 uint16 uint32 uint64 float double bool struct enum string void weak unowned owned async signal static abstract interface override virtual delegate if while do for foreach else switch case break default return try catch public private protected internal using new this get set const stdout stdin stderr var",
+				built_in: "DBus GLib CCode Gee Object Gtk Posix",
+				literal: "false true null"
+			},
+			contains: [
+				{
+					className: "class",
+					beginKeywords: "class interface namespace",
+					end: /\{/,
+					excludeEnd: true,
+					illegal: "[^,:\\n\\s\\.]",
+					contains: [hljs.UNDERSCORE_TITLE_MODE]
+				},
+				hljs.C_LINE_COMMENT_MODE,
+				hljs.C_BLOCK_COMMENT_MODE,
+				{
+					className: "string",
+					begin: "\"\"\"",
+					end: "\"\"\"",
+					relevance: 5
+				},
+				hljs.APOS_STRING_MODE,
+				hljs.QUOTE_STRING_MODE,
+				hljs.C_NUMBER_MODE,
+				{
+					className: "meta",
+					begin: "^#",
+					end: "$",
+					relevance: 2
+				}
+			]
+		};
+	}
+	module.exports = vala;
+}));
+
+//#endregion
+export default require_vala();

package/dist/vala-DxoZQIIV.js

@@ -0,0 +1,82 @@
+import { t as clike } from "./clike-BvmU1AL7.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/vala.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+vala.displayName = "vala";
+vala.aliases = [];
+/** @param {Refractor} Prism */
+function vala(Prism) {
+	Prism.register(clike);
+	Prism.languages.vala = Prism.languages.extend("clike", {
+		"class-name": [
+			{
+				pattern: /\b[A-Z]\w*(?:\.\w+)*\b(?=(?:\?\s+|\*?\s+\*?)\w)/,
+				inside: { punctuation: /\./ }
+			},
+			{
+				pattern: /(\[)[A-Z]\w*(?:\.\w+)*\b/,
+				lookbehind: true,
+				inside: { punctuation: /\./ }
+			},
+			{
+				pattern: /(\b(?:class|interface)\s+[A-Z]\w*(?:\.\w+)*\s*:\s*)[A-Z]\w*(?:\.\w+)*\b/,
+				lookbehind: true,
+				inside: { punctuation: /\./ }
+			},
+			{
+				pattern: /((?:\b(?:class|enum|interface|new|struct)\s+)|(?:catch\s+\())[A-Z]\w*(?:\.\w+)*\b/,
+				lookbehind: true,
+				inside: { punctuation: /\./ }
+			}
+		],
+		keyword: /\b(?:abstract|as|assert|async|base|bool|break|case|catch|char|class|const|construct|continue|default|delegate|delete|do|double|dynamic|else|ensures|enum|errordomain|extern|finally|float|for|foreach|get|if|in|inline|int|int16|int32|int64|int8|interface|internal|is|lock|long|namespace|new|null|out|override|owned|params|private|protected|public|ref|requires|return|set|short|signal|sizeof|size_t|ssize_t|static|string|struct|switch|this|throw|throws|try|typeof|uchar|uint|uint16|uint32|uint64|uint8|ulong|unichar|unowned|ushort|using|value|var|virtual|void|volatile|weak|while|yield)\b/i,
+		function: /\b\w+(?=\s*\()/,
+		number: /(?:\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)(?:f|u?l?)?/i,
+		operator: /\+\+|--|&&|\|\||<<=?|>>=?|=>|->|~|[+\-*\/%&^|=!<>]=?|\?\??|\.\.\./,
+		punctuation: /[{}[\];(),.:]/,
+		constant: /\b[A-Z0-9_]+\b/
+	});
+	Prism.languages.insertBefore("vala", "string", {
+		"raw-string": {
+			pattern: /"""[\s\S]*?"""/,
+			greedy: true,
+			alias: "string"
+		},
+		"template-string": {
+			pattern: /@"[\s\S]*?"/,
+			greedy: true,
+			inside: {
+				interpolation: {
+					pattern: /\$(?:\([^)]*\)|[a-zA-Z]\w*)/,
+					inside: {
+						delimiter: {
+							pattern: /^\$\(?|\)$/,
+							alias: "punctuation"
+						},
+						rest: Prism.languages.vala
+					}
+				},
+				string: /[\s\S]+/
+			}
+		}
+	});
+	Prism.languages.insertBefore("vala", "keyword", { regex: {
+		pattern: /\/(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[imsx]{0,4}(?=\s*(?:$|[\r\n,.;})\]]))/,
+		greedy: true,
+		inside: {
+			"regex-source": {
+				pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
+				lookbehind: true,
+				alias: "language-regex",
+				inside: Prism.languages.regex
+			},
+			"regex-delimiter": /^\//,
+			"regex-flags": /^[a-z]+$/
+		}
+	} });
+}
+
+//#endregion
+export { vala as default };

package/dist/vbnet-MuzuuWpL.js

@@ -0,0 +1,32 @@
+import { t as basic } from "./basic-DLk7zVoz.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/vbnet.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+vbnet.displayName = "vbnet";
+vbnet.aliases = [];
+/** @param {Refractor} Prism */
+function vbnet(Prism) {
+	Prism.register(basic);
+	Prism.languages.vbnet = Prism.languages.extend("basic", {
+		comment: [{
+			pattern: /(?:!|REM\b).+/i,
+			inside: { keyword: /^REM/i }
+		}, {
+			pattern: /(^|[^\\:])'.*/,
+			lookbehind: true,
+			greedy: true
+		}],
+		string: {
+			pattern: /(^|[^"])"(?:""|[^"])*"(?!")/,
+			lookbehind: true,
+			greedy: true
+		},
+		keyword: /(?:\b(?:ADDHANDLER|ADDRESSOF|ALIAS|AND|ANDALSO|AS|BEEP|BLOAD|BOOLEAN|BSAVE|BYREF|BYTE|BYVAL|CALL(?: ABSOLUTE)?|CASE|CATCH|CBOOL|CBYTE|CCHAR|CDATE|CDBL|CDEC|CHAIN|CHAR|CHDIR|CINT|CLASS|CLEAR|CLNG|CLOSE|CLS|COBJ|COM|COMMON|CONST|CONTINUE|CSBYTE|CSHORT|CSNG|CSTR|CTYPE|CUINT|CULNG|CUSHORT|DATA|DATE|DECIMAL|DECLARE|DEF(?: FN| SEG|DBL|INT|LNG|SNG|STR)|DEFAULT|DELEGATE|DIM|DIRECTCAST|DO|DOUBLE|ELSE|ELSEIF|END|ENUM|ENVIRON|ERASE|ERROR|EVENT|EXIT|FALSE|FIELD|FILES|FINALLY|FOR(?: EACH)?|FRIEND|FUNCTION|GET|GETTYPE|GETXMLNAMESPACE|GLOBAL|GOSUB|GOTO|HANDLES|IF|IMPLEMENTS|IMPORTS|IN|INHERITS|INPUT|INTEGER|INTERFACE|IOCTL|IS|ISNOT|KEY|KILL|LET|LIB|LIKE|LINE INPUT|LOCATE|LOCK|LONG|LOOP|LSET|ME|MKDIR|MOD|MODULE|MUSTINHERIT|MUSTOVERRIDE|MYBASE|MYCLASS|NAME|NAMESPACE|NARROWING|NEW|NEXT|NOT|NOTHING|NOTINHERITABLE|NOTOVERRIDABLE|OBJECT|OF|OFF|ON(?: COM| ERROR| KEY| TIMER)?|OPEN|OPERATOR|OPTION(?: BASE)?|OPTIONAL|OR|ORELSE|OUT|OVERLOADS|OVERRIDABLE|OVERRIDES|PARAMARRAY|PARTIAL|POKE|PRIVATE|PROPERTY|PROTECTED|PUBLIC|PUT|RAISEEVENT|READ|READONLY|REDIM|REM|REMOVEHANDLER|RESTORE|RESUME|RETURN|RMDIR|RSET|RUN|SBYTE|SELECT(?: CASE)?|SET|SHADOWS|SHARED|SHELL|SHORT|SINGLE|SLEEP|STATIC|STEP|STOP|STRING|STRUCTURE|SUB|SWAP|SYNCLOCK|SYSTEM|THEN|THROW|TIMER|TO|TROFF|TRON|TRUE|TRY|TRYCAST|TYPE|TYPEOF|UINTEGER|ULONG|UNLOCK|UNTIL|USHORT|USING|VIEW PRINT|WAIT|WEND|WHEN|WHILE|WIDENING|WITH|WITHEVENTS|WRITE|WRITEONLY|XOR)|\B(?:#CONST|#ELSE|#ELSEIF|#END|#IF))(?:\$|\b)/i,
+		punctuation: /[,;:(){}]/
+	});
+}
+
+//#endregion
+export { vbnet as default };

package/dist/vbnet-Rq0E4ZR6.js

@@ -0,0 +1,121 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/vbnet.js
+var require_vbnet = /* @__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) } args
+	* @returns {string}
+	*/
+	function concat(...args) {
+		return args.map((x) => source(x)).join("");
+	}
+	/**
+	* Any of the passed expresssions may match
+	*
+	* Creates a huge this | this | that | that match
+	* @param {(RegExp | string)[] } args
+	* @returns {string}
+	*/
+	function either(...args) {
+		return "(" + args.map((x) => source(x)).join("|") + ")";
+	}
+	/** @type LanguageFn */
+	function vbnet(hljs) {
+		/**
+		* Character Literal
+		* Either a single character ("a"C) or an escaped double quote (""""C).
+		*/
+		const CHARACTER = {
+			className: "string",
+			begin: /"(""|[^/n])"C\b/
+		};
+		const STRING = {
+			className: "string",
+			begin: /"/,
+			end: /"/,
+			illegal: /\n/,
+			contains: [{ begin: /""/ }]
+		};
+		/** Date Literals consist of a date, a time, or both separated by whitespace, surrounded by # */
+		const MM_DD_YYYY = /\d{1,2}\/\d{1,2}\/\d{4}/;
+		const YYYY_MM_DD = /\d{4}-\d{1,2}-\d{1,2}/;
+		const TIME_12H = /(\d|1[012])(:\d+){0,2} *(AM|PM)/;
+		const TIME_24H = /\d{1,2}(:\d{1,2}){1,2}/;
+		const DATE = {
+			className: "literal",
+			variants: [
+				{ begin: concat(/# */, either(YYYY_MM_DD, MM_DD_YYYY), / *#/) },
+				{ begin: concat(/# */, TIME_24H, / *#/) },
+				{ begin: concat(/# */, TIME_12H, / *#/) },
+				{ begin: concat(/# */, either(YYYY_MM_DD, MM_DD_YYYY), / +/, either(TIME_12H, TIME_24H), / *#/) }
+			]
+		};
+		const NUMBER = {
+			className: "number",
+			relevance: 0,
+			variants: [
+				{ begin: /\b\d[\d_]*((\.[\d_]+(E[+-]?[\d_]+)?)|(E[+-]?[\d_]+))[RFD@!#]?/ },
+				{ begin: /\b\d[\d_]*((U?[SIL])|[%&])?/ },
+				{ begin: /&H[\dA-F_]+((U?[SIL])|[%&])?/ },
+				{ begin: /&O[0-7_]+((U?[SIL])|[%&])?/ },
+				{ begin: /&B[01_]+((U?[SIL])|[%&])?/ }
+			]
+		};
+		const LABEL = {
+			className: "label",
+			begin: /^\w+:/
+		};
+		const DOC_COMMENT = hljs.COMMENT(/'''/, /$/, { contains: [{
+			className: "doctag",
+			begin: /<\/?/,
+			end: />/
+		}] });
+		const COMMENT = hljs.COMMENT(null, /$/, { variants: [{ begin: /'/ }, { begin: /([\t ]|^)REM(?=\s)/ }] });
+		return {
+			name: "Visual Basic .NET",
+			aliases: ["vb"],
+			case_insensitive: true,
+			classNameAliases: { label: "symbol" },
+			keywords: {
+				keyword: "addhandler alias aggregate ansi as async assembly auto binary by byref byval call case catch class compare const continue custom declare default delegate dim distinct do each equals else elseif end enum erase error event exit explicit finally for friend from function get global goto group handles if implements imports in inherits interface into iterator join key let lib loop me mid module mustinherit mustoverride mybase myclass namespace narrowing new next notinheritable notoverridable of off on operator option optional order overloads overridable overrides paramarray partial preserve private property protected public raiseevent readonly redim removehandler resume return select set shadows shared skip static step stop structure strict sub synclock take text then throw to try unicode until using when where while widening with withevents writeonly yield",
+				built_in: "addressof and andalso await directcast gettype getxmlnamespace is isfalse isnot istrue like mod nameof new not or orelse trycast typeof xor cbool cbyte cchar cdate cdbl cdec cint clng cobj csbyte cshort csng cstr cuint culng cushort",
+				type: "boolean byte char date decimal double integer long object sbyte short single string uinteger ulong ushort",
+				literal: "true false nothing"
+			},
+			illegal: "//|\\{|\\}|endif|gosub|variant|wend|^\\$ ",
+			contains: [
+				CHARACTER,
+				STRING,
+				DATE,
+				NUMBER,
+				LABEL,
+				DOC_COMMENT,
+				COMMENT,
+				{
+					className: "meta",
+					begin: /[\t ]*#(const|disable|else|elseif|enable|end|externalsource|if|region)\b/,
+					end: /$/,
+					keywords: { "meta-keyword": "const disable else elseif enable end externalsource if region then" },
+					contains: [COMMENT]
+				}
+			]
+		};
+	}
+	module.exports = vbnet;
+}));
+
+//#endregion
+export default require_vbnet();

package/dist/vbscript-B7FWGi6x.js

@@ -0,0 +1,74 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/vbscript.js
+var require_vbscript = /* @__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) } args
+	* @returns {string}
+	*/
+	function concat(...args) {
+		return args.map((x) => source(x)).join("");
+	}
+	/**
+	* Any of the passed expresssions may match
+	*
+	* Creates a huge this | this | that | that match
+	* @param {(RegExp | string)[] } args
+	* @returns {string}
+	*/
+	function either(...args) {
+		return "(" + args.map((x) => source(x)).join("|") + ")";
+	}
+	/** @type LanguageFn */
+	function vbscript(hljs) {
+		const BUILT_IN_FUNCTIONS = "lcase month vartype instrrev ubound setlocale getobject rgb getref string weekdayname rnd dateadd monthname now day minute isarray cbool round formatcurrency conversions csng timevalue second year space abs clng timeserial fixs len asc isempty maths dateserial atn timer isobject filter weekday datevalue ccur isdate instr datediff formatdatetime replace isnull right sgn array snumeric log cdbl hex chr lbound msgbox ucase getlocale cos cdate cbyte rtrim join hour oct typename trim strcomp int createobject loadpicture tan formatnumber mid split  cint sin datepart ltrim sqr time derived eval date formatpercent exp inputbox left ascw chrw regexp cstr err".split(" ");
+		const BUILT_IN_OBJECTS = [
+			"server",
+			"response",
+			"request",
+			"scriptengine",
+			"scriptenginebuildversion",
+			"scriptengineminorversion",
+			"scriptenginemajorversion"
+		];
+		const BUILT_IN_CALL = {
+			begin: concat(either(...BUILT_IN_FUNCTIONS), "\\s*\\("),
+			relevance: 0,
+			keywords: { built_in: BUILT_IN_FUNCTIONS }
+		};
+		return {
+			name: "VBScript",
+			aliases: ["vbs"],
+			case_insensitive: true,
+			keywords: {
+				keyword: "call class const dim do loop erase execute executeglobal exit for each next function if then else on error option explicit new private property let get public randomize redim rem select case set stop sub while wend with end to elseif is or xor and not class_initialize class_terminate default preserve in me byval byref step resume goto",
+				built_in: BUILT_IN_OBJECTS,
+				literal: "true false null nothing empty"
+			},
+			illegal: "//",
+			contains: [
+				BUILT_IN_CALL,
+				hljs.inherit(hljs.QUOTE_STRING_MODE, { contains: [{ begin: "\"\"" }] }),
+				hljs.COMMENT(/'/, /$/, { relevance: 0 }),
+				hljs.C_NUMBER_MODE
+			]
+		};
+	}
+	module.exports = vbscript;
+}));
+
+//#endregion
+export default require_vbscript();

package/dist/vbscript-html-I7g2pYpY.js

@@ -0,0 +1,20 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/vbscript-html.js
+var require_vbscript_html = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function vbscriptHtml(hljs) {
+		return {
+			name: "VBScript in HTML",
+			subLanguage: "xml",
+			contains: [{
+				begin: "<%",
+				end: "%>",
+				subLanguage: "vbscript"
+			}]
+		};
+	}
+	module.exports = vbscriptHtml;
+}));
+
+//#endregion
+export default require_vbscript_html();

package/dist/velocity-BZ2VAtwT.js

@@ -0,0 +1,75 @@
+import { t as markup } from "./markup-D2NSmoAx.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/velocity.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+velocity.displayName = "velocity";
+velocity.aliases = [];
+/** @param {Refractor} Prism */
+function velocity(Prism) {
+	Prism.register(markup);
+	(function(Prism) {
+		Prism.languages.velocity = Prism.languages.extend("markup", {});
+		var velocity = {
+			variable: {
+				pattern: /(^|[^\\](?:\\\\)*)\$!?(?:[a-z][\w-]*(?:\([^)]*\))?(?:\.[a-z][\w-]*(?:\([^)]*\))?|\[[^\]]+\])*|\{[^}]+\})/i,
+				lookbehind: true,
+				inside: {}
+			},
+			string: {
+				pattern: /"[^"]*"|'[^']*'/,
+				greedy: true
+			},
+			number: /\b\d+\b/,
+			boolean: /\b(?:false|true)\b/,
+			operator: /[=!<>]=?|[+*/%-]|&&|\|\||\.\.|\b(?:eq|g[et]|l[et]|n(?:e|ot))\b/,
+			punctuation: /[(){}[\]:,.]/
+		};
+		velocity.variable.inside = {
+			string: velocity["string"],
+			function: {
+				pattern: /([^\w-])[a-z][\w-]*(?=\()/,
+				lookbehind: true
+			},
+			number: velocity["number"],
+			boolean: velocity["boolean"],
+			punctuation: velocity["punctuation"]
+		};
+		Prism.languages.insertBefore("velocity", "comment", {
+			unparsed: {
+				pattern: /(^|[^\\])#\[\[[\s\S]*?\]\]#/,
+				lookbehind: true,
+				greedy: true,
+				inside: { punctuation: /^#\[\[|\]\]#$/ }
+			},
+			"velocity-comment": [{
+				pattern: /(^|[^\\])#\*[\s\S]*?\*#/,
+				lookbehind: true,
+				greedy: true,
+				alias: "comment"
+			}, {
+				pattern: /(^|[^\\])##.*/,
+				lookbehind: true,
+				greedy: true,
+				alias: "comment"
+			}],
+			directive: {
+				pattern: /(^|[^\\](?:\\\\)*)#@?(?:[a-z][\w-]*|\{[a-z][\w-]*\})(?:\s*\((?:[^()]|\([^()]*\))*\))?/i,
+				lookbehind: true,
+				inside: {
+					keyword: {
+						pattern: /^#@?(?:[a-z][\w-]*|\{[a-z][\w-]*\})|\bin\b/,
+						inside: { punctuation: /[{}]/ }
+					},
+					rest: velocity
+				}
+			},
+			variable: velocity["variable"]
+		});
+		Prism.languages.velocity["tag"].inside["attr-value"].inside.rest = Prism.languages.velocity;
+	})(Prism);
+}
+
+//#endregion
+export { velocity as default };

package/dist/verilog-DEPPw4lO.js

@@ -0,0 +1,33 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/verilog.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+verilog.displayName = "verilog";
+verilog.aliases = [];
+/** @param {Refractor} Prism */
+function verilog(Prism) {
+	Prism.languages.verilog = {
+		comment: {
+			pattern: /\/\/.*|\/\*[\s\S]*?\*\//,
+			greedy: true
+		},
+		string: {
+			pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
+			greedy: true
+		},
+		"kernel-function": {
+			pattern: /\B\$\w+\b/,
+			alias: "property"
+		},
+		constant: /\B`\w+\b/,
+		function: /\b\w+(?=\()/,
+		keyword: /\b(?:alias|and|assert|assign|assume|automatic|before|begin|bind|bins|binsof|bit|break|buf|bufif0|bufif1|byte|case|casex|casez|cell|chandle|class|clocking|cmos|config|const|constraint|context|continue|cover|covergroup|coverpoint|cross|deassign|default|defparam|design|disable|dist|do|edge|else|end|endcase|endclass|endclocking|endconfig|endfunction|endgenerate|endgroup|endinterface|endmodule|endpackage|endprimitive|endprogram|endproperty|endsequence|endspecify|endtable|endtask|enum|event|expect|export|extends|extern|final|first_match|for|force|foreach|forever|fork|forkjoin|function|generate|genvar|highz0|highz1|if|iff|ifnone|ignore_bins|illegal_bins|import|incdir|include|initial|inout|input|inside|instance|int|integer|interface|intersect|join|join_any|join_none|large|liblist|library|local|localparam|logic|longint|macromodule|matches|medium|modport|module|nand|negedge|new|nmos|nor|noshowcancelled|not|notif0|notif1|null|or|output|package|packed|parameter|pmos|posedge|primitive|priority|program|property|protected|pull0|pull1|pulldown|pullup|pulsestyle_ondetect|pulsestyle_onevent|pure|rand|randc|randcase|randsequence|rcmos|real|realtime|ref|reg|release|repeat|return|rnmos|rpmos|rtran|rtranif0|rtranif1|scalared|sequence|shortint|shortreal|showcancelled|signed|small|solve|specify|specparam|static|string|strong0|strong1|struct|super|supply0|supply1|table|tagged|task|this|throughout|time|timeprecision|timeunit|tran|tranif0|tranif1|tri|tri0|tri1|triand|trior|trireg|type|typedef|union|unique|unsigned|use|uwire|var|vectored|virtual|void|wait|wait_order|wand|weak0|weak1|while|wildcard|wire|with|within|wor|xnor|xor)\b/,
+		important: /\b(?:always|always_comb|always_ff|always_latch)\b(?: *@)?/,
+		number: /\B##?\d+|(?:\b\d+)?'[odbh] ?[\da-fzx_?]+|\b(?:\d*[._])?\d+(?:e[-+]?\d+)?/i,
+		operator: /[-+{}^~%*\/?=!<>&|]+/,
+		punctuation: /[[\];(),.:]/
+	};
+}
+
+//#endregion
+export { verilog as default };