@webskill/chatbot 0.0.1

package/dist/http-BqI_d45x.js

@@ -0,0 +1,102 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/http.js
+var require_http = /* @__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("");
+	}
+	function http(hljs) {
+		const VERSION = "HTTP/(2|1\\.[01])";
+		const HEADER = {
+			className: "attribute",
+			begin: concat("^", /[A-Za-z][A-Za-z0-9-]*/, "(?=\\:\\s)"),
+			starts: { contains: [{
+				className: "punctuation",
+				begin: /: /,
+				relevance: 0,
+				starts: {
+					end: "$",
+					relevance: 0
+				}
+			}] }
+		};
+		const HEADERS_AND_BODY = [HEADER, {
+			begin: "\\n\\n",
+			starts: {
+				subLanguage: [],
+				endsWithParent: true
+			}
+		}];
+		return {
+			name: "HTTP",
+			aliases: ["https"],
+			illegal: /\S/,
+			contains: [
+				{
+					begin: "^(?=HTTP/(2|1\\.[01]) \\d{3})",
+					end: /$/,
+					contains: [{
+						className: "meta",
+						begin: VERSION
+					}, {
+						className: "number",
+						begin: "\\b\\d{3}\\b"
+					}],
+					starts: {
+						end: /\b\B/,
+						illegal: /\S/,
+						contains: HEADERS_AND_BODY
+					}
+				},
+				{
+					begin: "(?=^[A-Z]+ (.*?) HTTP/(2|1\\.[01])$)",
+					end: /$/,
+					contains: [
+						{
+							className: "string",
+							begin: " ",
+							end: " ",
+							excludeBegin: true,
+							excludeEnd: true
+						},
+						{
+							className: "meta",
+							begin: VERSION
+						},
+						{
+							className: "keyword",
+							begin: "[A-Z]+"
+						}
+					],
+					starts: {
+						end: /\b\B/,
+						illegal: /\S/,
+						contains: HEADERS_AND_BODY
+					}
+				},
+				hljs.inherit(HEADER, { relevance: 0 })
+			]
+		};
+	}
+	module.exports = http;
+}));
+
+//#endregion
+export default require_http();

package/dist/http-Cx72__Yy.js

@@ -0,0 +1,131 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/http.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+http.displayName = "http";
+http.aliases = [];
+/** @param {Refractor} Prism */
+function http(Prism) {
+	(function(Prism) {
+		/**
+		* @param {string} name
+		* @returns {RegExp}
+		*/
+		function headerValueOf(name) {
+			return RegExp("(^(?:" + name + "):[ 	]*(?![ 	]))[^]+", "i");
+		}
+		Prism.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: true,
+						alias: "url",
+						inside: Prism.languages.uri
+					},
+					"http-version": {
+						pattern: /^(\s)HTTP\/[\d.]+/,
+						lookbehind: true,
+						alias: "property"
+					}
+				}
+			},
+			"response-status": {
+				pattern: /^HTTP\/[\d.]+ \d+ .+/m,
+				inside: {
+					"http-version": {
+						pattern: /^HTTP\/[\d.]+/,
+						alias: "property"
+					},
+					"status-code": {
+						pattern: /^(\s)\d+(?=\s)/,
+						lookbehind: true,
+						alias: "number"
+					},
+					"reason-phrase": {
+						pattern: /^(\s).+/,
+						lookbehind: true,
+						alias: "string"
+					}
+				}
+			},
+			header: {
+				pattern: /^[\w-]+:.+(?:(?:\r\n?|\n)[ \t].+)*/m,
+				inside: {
+					"header-value": [
+						{
+							pattern: headerValueOf(/Content-Security-Policy/.source),
+							lookbehind: true,
+							alias: ["csp", "languages-csp"],
+							inside: Prism.languages.csp
+						},
+						{
+							pattern: headerValueOf(/Public-Key-Pins(?:-Report-Only)?/.source),
+							lookbehind: true,
+							alias: ["hpkp", "languages-hpkp"],
+							inside: Prism.languages.hpkp
+						},
+						{
+							pattern: headerValueOf(/Strict-Transport-Security/.source),
+							lookbehind: true,
+							alias: ["hsts", "languages-hsts"],
+							inside: Prism.languages.hsts
+						},
+						{
+							pattern: headerValueOf(/[^:]+/.source),
+							lookbehind: true
+						}
+					],
+					"header-name": {
+						pattern: /^[^:]+/,
+						alias: "keyword"
+					},
+					punctuation: /^:/
+				}
+			}
+		};
+		var langs = Prism.languages;
+		var httpLanguages = {
+			"application/javascript": langs.javascript,
+			"application/json": langs.json || langs.javascript,
+			"application/xml": langs.xml,
+			"text/xml": langs.xml,
+			"text/html": langs.html,
+			"text/css": langs.css,
+			"text/plain": langs.plain
+		};
+		var suffixTypes = {
+			"application/json": true,
+			"application/xml": true
+		};
+		/**
+		* Returns a pattern for the given content type which matches it and any type which has it as a suffix.
+		*
+		* @param {string} contentType
+		* @returns {string}
+		*/
+		function getSuffixPattern(contentType) {
+			var suffixPattern = "\\w+/(?:[\\w.-]+\\+)+" + contentType.replace(/^[a-z]+\//, "") + "(?![+\\w.-])";
+			return "(?:" + contentType + "|" + suffixPattern + ")";
+		}
+		var options;
+		for (var contentType in httpLanguages) if (httpLanguages[contentType]) {
+			options = options || {};
+			var pattern = suffixTypes[contentType] ? getSuffixPattern(contentType) : contentType;
+			options[contentType.replace(/\//g, "-")] = {
+				pattern: RegExp("(" + /content-type:\s*/.source + pattern + /(?:(?:\r\n?|\n)[\w-].*)*(?:\r(?:\n|(?!\n))|\n)/.source + ")" + /[^ \t\w-][\s\S]*/.source, "i"),
+				lookbehind: true,
+				inside: httpLanguages[contentType]
+			};
+		}
+		if (options) Prism.languages.insertBefore("http", "header", options);
+	})(Prism);
+}
+
+//#endregion
+export { http as default };

package/dist/hy-QLZU_M0S.js

@@ -0,0 +1,97 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/hy.js
+var require_hy = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function hy(hljs) {
+		var SYMBOLSTART = "a-zA-Z_\\-!.?+*=<>&#'";
+		var SYMBOL_RE = "[" + SYMBOLSTART + "][" + SYMBOLSTART + "0-9/;:]*";
+		var keywords = {
+			$pattern: SYMBOL_RE,
+			"builtin-name": "!= % %= & &= * ** **= *= *map + += , --build-class-- --import-- -= . / // //= /= < << <<= <= = > >= >> >>= @ @= ^ ^= abs accumulate all and any ap-compose ap-dotimes ap-each ap-each-while ap-filter ap-first ap-if ap-last ap-map ap-map-when ap-pipe ap-reduce ap-reject apply as-> ascii assert assoc bin break butlast callable calling-module-name car case cdr chain chr coll? combinations compile compress cond cons cons? continue count curry cut cycle dec def default-method defclass defmacro defmacro-alias defmacro/g! defmain defmethod defmulti defn defn-alias defnc defnr defreader defseq del delattr delete-route dict-comp dir disassemble dispatch-reader-macro distinct divmod do doto drop drop-last drop-while empty? end-sequence eval eval-and-compile eval-when-compile even? every? except exec filter first flatten float? fn fnc fnr for for* format fraction genexpr gensym get getattr global globals group-by hasattr hash hex id identity if if* if-not if-python2 import in inc input instance? integer integer-char? integer? interleave interpose is is-coll is-cons is-empty is-even is-every is-float is-instance is-integer is-integer-char is-iterable is-iterator is-keyword is-neg is-none is-not is-numeric is-odd is-pos is-string is-symbol is-zero isinstance islice issubclass iter iterable? iterate iterator? keyword keyword? lambda last len let lif lif-not list* list-comp locals loop macro-error macroexpand macroexpand-1 macroexpand-all map max merge-with method-decorator min multi-decorator multicombinations name neg? next none? nonlocal not not-in not? nth numeric? oct odd? open or ord partition permutations pos? post-route postwalk pow prewalk print product profile/calls profile/cpu put-route quasiquote quote raise range read read-str recursive-replace reduce remove repeat repeatedly repr require rest round route route-with-methods rwm second seq set-comp setattr setv some sorted string string? sum switch symbol? take take-nth take-while tee try unless unquote unquote-splicing vars walk when while with with* with-decorator with-gensyms xi xor yield yield-from zero? zip zip-longest | |= ~"
+		};
+		var SIMPLE_NUMBER_RE = "[-+]?\\d+(\\.\\d+)?";
+		var SYMBOL = {
+			begin: SYMBOL_RE,
+			relevance: 0
+		};
+		var NUMBER = {
+			className: "number",
+			begin: SIMPLE_NUMBER_RE,
+			relevance: 0
+		};
+		var STRING = hljs.inherit(hljs.QUOTE_STRING_MODE, { illegal: null });
+		var COMMENT = hljs.COMMENT(";", "$", { relevance: 0 });
+		var LITERAL = {
+			className: "literal",
+			begin: /\b([Tt]rue|[Ff]alse|nil|None)\b/
+		};
+		var COLLECTION = {
+			begin: "[\\[\\{]",
+			end: "[\\]\\}]"
+		};
+		var HINT = {
+			className: "comment",
+			begin: "\\^" + SYMBOL_RE
+		};
+		var HINT_COL = hljs.COMMENT("\\^\\{", "\\}");
+		var KEY = {
+			className: "symbol",
+			begin: "[:]{1,2}" + SYMBOL_RE
+		};
+		var LIST = {
+			begin: "\\(",
+			end: "\\)"
+		};
+		var BODY = {
+			endsWithParent: true,
+			relevance: 0
+		};
+		var NAME = {
+			className: "name",
+			relevance: 0,
+			keywords,
+			begin: SYMBOL_RE,
+			starts: BODY
+		};
+		var DEFAULT_CONTAINS = [
+			LIST,
+			STRING,
+			HINT,
+			HINT_COL,
+			COMMENT,
+			KEY,
+			COLLECTION,
+			NUMBER,
+			LITERAL,
+			SYMBOL
+		];
+		LIST.contains = [
+			hljs.COMMENT("comment", ""),
+			NAME,
+			BODY
+		];
+		BODY.contains = DEFAULT_CONTAINS;
+		COLLECTION.contains = DEFAULT_CONTAINS;
+		return {
+			name: "Hy",
+			aliases: ["hylang"],
+			illegal: /\S/,
+			contains: [
+				hljs.SHEBANG(),
+				LIST,
+				STRING,
+				HINT,
+				HINT_COL,
+				COMMENT,
+				KEY,
+				COLLECTION,
+				NUMBER,
+				LITERAL
+			]
+		};
+	}
+	module.exports = hy;
+}));
+
+//#endregion
+export default require_hy();

package/dist/ichigojam-BOGB8zsN.js

@@ -0,0 +1,25 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/ichigojam.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+ichigojam.displayName = "ichigojam";
+ichigojam.aliases = [];
+/** @param {Refractor} Prism */
+function ichigojam(Prism) {
+	Prism.languages.ichigojam = {
+		comment: /(?:\B'|REM)(?:[^\n\r]*)/i,
+		string: {
+			pattern: /"(?:""|[!#$%&'()*,\/:;<=>?^\w +\-.])*"/,
+			greedy: true
+		},
+		number: /\B#[0-9A-F]+|\B`[01]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i,
+		keyword: /\b(?:BEEP|BPS|CASE|CLEAR|CLK|CLO|CLP|CLS|CLT|CLV|CONT|COPY|ELSE|END|FILE|FILES|FOR|GOSUB|GOTO|GSB|IF|INPUT|KBD|LED|LET|LIST|LOAD|LOCATE|LRUN|NEW|NEXT|OUT|PLAY|POKE|PRINT|PWM|REM|RENUM|RESET|RETURN|RIGHT|RTN|RUN|SAVE|SCROLL|SLEEP|SRND|STEP|STOP|SUB|TEMPO|THEN|TO|UART|VIDEO|WAIT)(?:\$|\b)/i,
+		function: /\b(?:ABS|ANA|ASC|BIN|BTN|DEC|END|FREE|HELP|HEX|I2CR|I2CW|IN|INKEY|LEN|LINE|PEEK|RND|SCR|SOUND|STR|TICK|USR|VER|VPEEK|ZER)(?:\$|\b)/i,
+		label: /(?:\B@\S+)/,
+		operator: /<[=>]?|>=?|\|\||&&|[+\-*\/=|&^~!]|\b(?:AND|NOT|OR)\b/i,
+		punctuation: /[\[,;:()\]]/
+	};
+}
+
+//#endregion
+export { ichigojam as default };

package/dist/icon-JYljK4QF.js

@@ -0,0 +1,32 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/icon.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+icon.displayName = "icon";
+icon.aliases = [];
+/** @param {Refractor} Prism */
+function icon(Prism) {
+	Prism.languages.icon = {
+		comment: /#.*/,
+		string: {
+			pattern: /(["'])(?:(?!\1)[^\\\r\n_]|\\.|_(?!\1)(?:\r\n|[\s\S]))*\1/,
+			greedy: true
+		},
+		number: /\b(?:\d+r[a-z\d]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b|\.\d+\b/i,
+		"builtin-keyword": {
+			pattern: /&(?:allocated|ascii|clock|collections|cset|current|date|dateline|digits|dump|e|error(?:number|text|value)?|errout|fail|features|file|host|input|lcase|letters|level|line|main|null|output|phi|pi|pos|progname|random|regions|source|storage|subject|time|trace|ucase|version)\b/,
+			alias: "variable"
+		},
+		directive: {
+			pattern: /\$\w+/,
+			alias: "builtin"
+		},
+		keyword: /\b(?:break|by|case|create|default|do|else|end|every|fail|global|if|initial|invocable|link|local|next|not|of|procedure|record|repeat|return|static|suspend|then|to|until|while)\b/,
+		function: /\b(?!\d)\w+(?=\s*[({]|\s*!\s*\[)/,
+		operator: /[+-]:(?!=)|(?:[\/?@^%&]|\+\+?|--?|==?=?|~==?=?|\*\*?|\|\|\|?|<(?:->?|<?=?)|>>?=?)(?::=)?|:(?:=:?)?|[!.\\|~]/,
+		punctuation: /[\[\](){},;]/
+	};
+}
+
+//#endregion
+export { icon as default };

package/dist/icu-message-format-CpcYbRvH.js

@@ -0,0 +1,137 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/icu-message-format.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+icuMessageFormat.displayName = "icu-message-format";
+icuMessageFormat.aliases = [];
+/** @param {Refractor} Prism */
+function icuMessageFormat(Prism) {
+	(function(Prism) {
+		/**
+		* @param {string} source
+		* @param {number} level
+		* @returns {string}
+		*/
+		function nested(source, level) {
+			if (level <= 0) return /[]/.source;
+			else return source.replace(/<SELF>/g, function() {
+				return nested(source, level - 1);
+			});
+		}
+		var stringPattern = /'[{}:=,](?:[^']|'')*'(?!')/;
+		var escape = {
+			pattern: /''/,
+			greedy: true,
+			alias: "operator"
+		};
+		var string = {
+			pattern: stringPattern,
+			greedy: true,
+			inside: { escape }
+		};
+		var argumentSource = nested(/\{(?:[^{}']|'(?![{},'])|''|<STR>|<SELF>)*\}/.source.replace(/<STR>/g, function() {
+			return stringPattern.source;
+		}), 8);
+		var nestedMessage = {
+			pattern: RegExp(argumentSource),
+			inside: {
+				message: {
+					pattern: /^(\{)[\s\S]+(?=\}$)/,
+					lookbehind: true,
+					inside: null
+				},
+				"message-delimiter": {
+					pattern: /./,
+					alias: "punctuation"
+				}
+			}
+		};
+		Prism.languages["icu-message-format"] = {
+			argument: {
+				pattern: RegExp(argumentSource),
+				greedy: true,
+				inside: {
+					content: {
+						pattern: /^(\{)[\s\S]+(?=\}$)/,
+						lookbehind: true,
+						inside: {
+							"argument-name": {
+								pattern: /^(\s*)[^{}:=,\s]+/,
+								lookbehind: true
+							},
+							"choice-style": {
+								pattern: /^(\s*,\s*choice\s*,\s*)\S(?:[\s\S]*\S)?/,
+								lookbehind: true,
+								inside: {
+									punctuation: /\|/,
+									range: {
+										pattern: /^(\s*)[+-]?(?:\d+(?:\.\d*)?|\u221e)\s*[<#\u2264]/,
+										lookbehind: true,
+										inside: {
+											operator: /[<#\u2264]/,
+											number: /\S+/
+										}
+									},
+									rest: null
+								}
+							},
+							"plural-style": {
+								pattern: /^(\s*,\s*(?:plural|selectordinal)\s*,\s*)\S(?:[\s\S]*\S)?/,
+								lookbehind: true,
+								inside: {
+									offset: /^offset:\s*\d+/,
+									"nested-message": nestedMessage,
+									selector: {
+										pattern: /=\d+|[^{}:=,\s]+/,
+										inside: { keyword: /^(?:few|many|one|other|two|zero)$/ }
+									}
+								}
+							},
+							"select-style": {
+								pattern: /^(\s*,\s*select\s*,\s*)\S(?:[\s\S]*\S)?/,
+								lookbehind: true,
+								inside: {
+									"nested-message": nestedMessage,
+									selector: {
+										pattern: /[^{}:=,\s]+/,
+										inside: { keyword: /^other$/ }
+									}
+								}
+							},
+							keyword: /\b(?:choice|plural|select|selectordinal)\b/,
+							"arg-type": {
+								pattern: /\b(?:date|duration|number|ordinal|spellout|time)\b/,
+								alias: "keyword"
+							},
+							"arg-skeleton": {
+								pattern: /(,\s*)::[^{}:=,\s]+/,
+								lookbehind: true
+							},
+							"arg-style": {
+								pattern: /(,\s*)(?:currency|full|integer|long|medium|percent|short)(?=\s*$)/,
+								lookbehind: true
+							},
+							"arg-style-text": {
+								pattern: RegExp(/(^\s*,\s*(?=\S))/.source + nested(/(?:[^{}']|'[^']*'|\{(?:<SELF>)?\})+/.source, 8) + "$"),
+								lookbehind: true,
+								alias: "string"
+							},
+							punctuation: /,/
+						}
+					},
+					"argument-delimiter": {
+						pattern: /./,
+						alias: "operator"
+					}
+				}
+			},
+			escape,
+			string
+		};
+		nestedMessage.inside.message.inside = Prism.languages["icu-message-format"];
+		Prism.languages["icu-message-format"].argument.inside.content.inside["choice-style"].inside.rest = Prism.languages["icu-message-format"];
+	})(Prism);
+}
+
+//#endregion
+export { icuMessageFormat as default };

package/dist/idris-BJ4tgRDj.js

@@ -0,0 +1,26 @@
+import haskell from "./haskell-DDqg24-B.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/idris.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+idris.displayName = "idris";
+idris.aliases = ["idr"];
+/** @param {Refractor} Prism */
+function idris(Prism) {
+	Prism.register(haskell);
+	Prism.languages.idris = Prism.languages.extend("haskell", {
+		comment: { pattern: /(?:(?:--|\|\|\|).*$|\{-[\s\S]*?-\})/m },
+		keyword: /\b(?:Type|case|class|codata|constructor|corecord|data|do|dsl|else|export|if|implementation|implicit|import|impossible|in|infix|infixl|infixr|instance|interface|let|module|mutual|namespace|of|parameters|partial|postulate|private|proof|public|quoteGoal|record|rewrite|syntax|then|total|using|where|with)\b/,
+		builtin: void 0
+	});
+	Prism.languages.insertBefore("idris", "keyword", { "import-statement": {
+		pattern: /(^\s*import\s+)(?:[A-Z][\w']*)(?:\.[A-Z][\w']*)*/m,
+		lookbehind: true,
+		inside: { punctuation: /\./ }
+	} });
+	Prism.languages.idr = Prism.languages.idris;
+}
+
+//#endregion
+export { idris as default };

package/dist/iecst-xg-F-Ri2.js

@@ -0,0 +1,38 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/iecst.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+iecst.displayName = "iecst";
+iecst.aliases = [];
+/** @param {Refractor} Prism */
+function iecst(Prism) {
+	Prism.languages.iecst = {
+		comment: [{
+			pattern: /(^|[^\\])(?:\/\*[\s\S]*?(?:\*\/|$)|\(\*[\s\S]*?(?:\*\)|$)|\{[\s\S]*?(?:\}|$))/,
+			lookbehind: true,
+			greedy: true
+		}, {
+			pattern: /(^|[^\\:])\/\/.*/,
+			lookbehind: true,
+			greedy: true
+		}],
+		string: {
+			pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+			greedy: true
+		},
+		keyword: [/\b(?:END_)?(?:PROGRAM|CONFIGURATION|INTERFACE|FUNCTION_BLOCK|FUNCTION|ACTION|TRANSITION|TYPE|STRUCT|(?:INITIAL_)?STEP|NAMESPACE|LIBRARY|CHANNEL|FOLDER|RESOURCE|VAR_(?:ACCESS|CONFIG|EXTERNAL|GLOBAL|INPUT|IN_OUT|OUTPUT|TEMP)|VAR|METHOD|PROPERTY)\b/i, /\b(?:AT|BY|(?:END_)?(?:CASE|FOR|IF|REPEAT|WHILE)|CONSTANT|CONTINUE|DO|ELSE|ELSIF|EXIT|EXTENDS|FROM|GET|GOTO|IMPLEMENTS|JMP|NON_RETAIN|OF|PRIVATE|PROTECTED|PUBLIC|RETAIN|RETURN|SET|TASK|THEN|TO|UNTIL|USING|WITH|__CATCH|__ENDTRY|__FINALLY|__TRY)\b/],
+		"class-name": /\b(?:ANY|ARRAY|BOOL|BYTE|U?(?:D|L|S)?INT|(?:D|L)?WORD|DATE(?:_AND_TIME)?|DT|L?REAL|POINTER|STRING|TIME(?:_OF_DAY)?|TOD)\b/,
+		address: {
+			pattern: /%[IQM][XBWDL][\d.]*|%[IQ][\d.]*/,
+			alias: "symbol"
+		},
+		number: /\b(?:16#[\da-f]+|2#[01_]+|0x[\da-f]+)\b|\b(?:D|DT|T|TOD)#[\d_shmd:]*|\b[A-Z]*#[\d.,_]*|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
+		boolean: /\b(?:FALSE|NULL|TRUE)\b/,
+		operator: /S?R?:?=>?|&&?|\*\*?|<[=>]?|>=?|[-:^/+#]|\b(?:AND|EQ|EXPT|GE|GT|LE|LT|MOD|NE|NOT|OR|XOR)\b/,
+		function: /\b[a-z_]\w*(?=\s*\()/i,
+		punctuation: /[()[\].,;]/
+	};
+}
+
+//#endregion
+export { iecst as default };

package/dist/ignore-CsQzbDOY.js

@@ -0,0 +1,36 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/ignore.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+ignore.displayName = "ignore";
+ignore.aliases = [
+	"gitignore",
+	"hgignore",
+	"npmignore"
+];
+/** @param {Refractor} Prism */
+function ignore(Prism) {
+	(function(Prism) {
+		Prism.languages.ignore = {
+			comment: /^#.*/m,
+			entry: {
+				pattern: /\S(?:.*(?:(?:\\ )|\S))?/,
+				alias: "string",
+				inside: {
+					operator: /^!|\*\*?|\?/,
+					regex: {
+						pattern: /(^|[^\\])\[[^\[\]]*\]/,
+						lookbehind: true
+					},
+					punctuation: /\//
+				}
+			}
+		};
+		Prism.languages.gitignore = Prism.languages.ignore;
+		Prism.languages.hgignore = Prism.languages.ignore;
+		Prism.languages.npmignore = Prism.languages.ignore;
+	})(Prism);
+}
+
+//#endregion
+export { ignore as default };