@webskill/chatbot 0.0.1

package/dist/moonscript-w9bBVWSA.js

@@ -0,0 +1,108 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/moonscript.js
+var require_moonscript = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function moonscript(hljs) {
+		const KEYWORDS = {
+			keyword: "if then not for in while do return else elseif break continue switch and or unless when class extends super local import export from using",
+			literal: "true false nil",
+			built_in: "_G _VERSION assert collectgarbage dofile error getfenv getmetatable ipairs load loadfile loadstring module next pairs pcall print rawequal rawget rawset require select setfenv setmetatable tonumber tostring type unpack xpcall coroutine debug io math os package string table"
+		};
+		const JS_IDENT_RE = "[A-Za-z$_][0-9A-Za-z$_]*";
+		const SUBST = {
+			className: "subst",
+			begin: /#\{/,
+			end: /\}/,
+			keywords: KEYWORDS
+		};
+		const EXPRESSIONS = [
+			hljs.inherit(hljs.C_NUMBER_MODE, { starts: {
+				end: "(\\s*/)?",
+				relevance: 0
+			} }),
+			{
+				className: "string",
+				variants: [{
+					begin: /'/,
+					end: /'/,
+					contains: [hljs.BACKSLASH_ESCAPE]
+				}, {
+					begin: /"/,
+					end: /"/,
+					contains: [hljs.BACKSLASH_ESCAPE, SUBST]
+				}]
+			},
+			{
+				className: "built_in",
+				begin: "@__" + hljs.IDENT_RE
+			},
+			{ begin: "@" + hljs.IDENT_RE },
+			{ begin: hljs.IDENT_RE + "\\\\" + hljs.IDENT_RE }
+		];
+		SUBST.contains = EXPRESSIONS;
+		const TITLE = hljs.inherit(hljs.TITLE_MODE, { begin: JS_IDENT_RE });
+		const POSSIBLE_PARAMS_RE = "(\\(.*\\)\\s*)?\\B[-=]>";
+		const PARAMS = {
+			className: "params",
+			begin: "\\([^\\(]",
+			returnBegin: true,
+			contains: [{
+				begin: /\(/,
+				end: /\)/,
+				keywords: KEYWORDS,
+				contains: ["self"].concat(EXPRESSIONS)
+			}]
+		};
+		return {
+			name: "MoonScript",
+			aliases: ["moon"],
+			keywords: KEYWORDS,
+			illegal: /\/\*/,
+			contains: EXPRESSIONS.concat([
+				hljs.COMMENT("--", "$"),
+				{
+					className: "function",
+					begin: "^\\s*[A-Za-z$_][0-9A-Za-z$_]*\\s*=\\s*(\\(.*\\)\\s*)?\\B[-=]>",
+					end: "[-=]>",
+					returnBegin: true,
+					contains: [TITLE, PARAMS]
+				},
+				{
+					begin: /[\(,:=]\s*/,
+					relevance: 0,
+					contains: [{
+						className: "function",
+						begin: POSSIBLE_PARAMS_RE,
+						end: "[-=]>",
+						returnBegin: true,
+						contains: [PARAMS]
+					}]
+				},
+				{
+					className: "class",
+					beginKeywords: "class",
+					end: "$",
+					illegal: /[:="\[\]]/,
+					contains: [{
+						beginKeywords: "extends",
+						endsWithParent: true,
+						illegal: /[:="\[\]]/,
+						contains: [TITLE]
+					}, TITLE]
+				},
+				{
+					className: "name",
+					begin: "[A-Za-z$_][0-9A-Za-z$_]*:",
+					end: ":",
+					returnBegin: true,
+					returnEnd: true,
+					relevance: 0
+				}
+			])
+		};
+	}
+	module.exports = moonscript;
+}));
+
+//#endregion
+export default require_moonscript();

package/dist/n1ql-C96arvJp.js

@@ -0,0 +1,33 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/n1ql.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+n1ql.displayName = "n1ql";
+n1ql.aliases = [];
+/** @param {Refractor} Prism */
+function n1ql(Prism) {
+	Prism.languages.n1ql = {
+		comment: {
+			pattern: /\/\*[\s\S]*?(?:$|\*\/)|--.*/,
+			greedy: true
+		},
+		string: {
+			pattern: /(["'])(?:\\[\s\S]|(?!\1)[^\\]|\1\1)*\1/,
+			greedy: true
+		},
+		identifier: {
+			pattern: /`(?:\\[\s\S]|[^\\`]|``)*`/,
+			greedy: true
+		},
+		parameter: /\$[\w.]+/,
+		keyword: /\b(?:ADVISE|ALL|ALTER|ANALYZE|AS|ASC|AT|BEGIN|BINARY|BOOLEAN|BREAK|BUCKET|BUILD|BY|CALL|CAST|CLUSTER|COLLATE|COLLECTION|COMMIT|COMMITTED|CONNECT|CONTINUE|CORRELATE|CORRELATED|COVER|CREATE|CURRENT|DATABASE|DATASET|DATASTORE|DECLARE|DECREMENT|DELETE|DERIVED|DESC|DESCRIBE|DISTINCT|DO|DROP|EACH|ELEMENT|EXCEPT|EXCLUDE|EXECUTE|EXPLAIN|FETCH|FILTER|FLATTEN|FLUSH|FOLLOWING|FOR|FORCE|FROM|FTS|FUNCTION|GOLANG|GRANT|GROUP|GROUPS|GSI|HASH|HAVING|IF|IGNORE|ILIKE|INCLUDE|INCREMENT|INDEX|INFER|INLINE|INNER|INSERT|INTERSECT|INTO|IS|ISOLATION|JAVASCRIPT|JOIN|KEY|KEYS|KEYSPACE|KNOWN|LANGUAGE|LAST|LEFT|LET|LETTING|LEVEL|LIMIT|LSM|MAP|MAPPING|MATCHED|MATERIALIZED|MERGE|MINUS|MISSING|NAMESPACE|NEST|NL|NO|NTH_VALUE|NULL|NULLS|NUMBER|OBJECT|OFFSET|ON|OPTION|OPTIONS|ORDER|OTHERS|OUTER|OVER|PARSE|PARTITION|PASSWORD|PATH|POOL|PRECEDING|PREPARE|PRIMARY|PRIVATE|PRIVILEGE|PROBE|PROCEDURE|PUBLIC|RANGE|RAW|REALM|REDUCE|RENAME|RESPECT|RETURN|RETURNING|REVOKE|RIGHT|ROLE|ROLLBACK|ROW|ROWS|SATISFIES|SAVEPOINT|SCHEMA|SCOPE|SELECT|SELF|SEMI|SET|SHOW|SOME|START|STATISTICS|STRING|SYSTEM|TIES|TO|TRAN|TRANSACTION|TRIGGER|TRUNCATE|UNBOUNDED|UNDER|UNION|UNIQUE|UNKNOWN|UNNEST|UNSET|UPDATE|UPSERT|USE|USER|USING|VALIDATE|VALUE|VALUES|VIA|VIEW|WHERE|WHILE|WINDOW|WITH|WORK|XOR)\b/i,
+		function: /\b[a-z_]\w*(?=\s*\()/i,
+		boolean: /\b(?:FALSE|TRUE)\b/i,
+		number: /(?:\b\d+\.|\B\.)\d+e[+\-]?\d+\b|\b\d+(?:\.\d*)?|\B\.\d+\b/i,
+		operator: /[-+*\/%]|!=|==?|\|\||<[>=]?|>=?|\b(?:AND|ANY|ARRAY|BETWEEN|CASE|ELSE|END|EVERY|EXISTS|FIRST|IN|LIKE|NOT|OR|THEN|VALUED|WHEN|WITHIN)\b/i,
+		punctuation: /[;[\](),.{}:]/
+	};
+}
+
+//#endregion
+export { n1ql as default };

package/dist/n1ql-DRmjD5Dx.js

@@ -0,0 +1,48 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/n1ql.js
+var require_n1ql = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function n1ql(hljs) {
+		return {
+			name: "N1QL",
+			case_insensitive: true,
+			contains: [{
+				beginKeywords: "build create index delete drop explain infer|10 insert merge prepare select update upsert|10",
+				end: /;/,
+				endsWithParent: true,
+				keywords: {
+					keyword: "all alter analyze and any array as asc begin between binary boolean break bucket build by call case cast cluster collate collection commit connect continue correlate cover create database dataset datastore declare decrement delete derived desc describe distinct do drop each element else end every except exclude execute exists explain fetch first flatten for force from function grant group gsi having if ignore ilike in include increment index infer inline inner insert intersect into is join key keys keyspace known last left let letting like limit lsm map mapping matched materialized merge minus namespace nest not number object offset on option or order outer over parse partition password path pool prepare primary private privilege procedure public raw realm reduce rename return returning revoke right role rollback satisfies schema select self semi set show some start statistics string system then to transaction trigger truncate under union unique unknown unnest unset update upsert use user using validate value valued values via view when where while with within work xor",
+					literal: "true false null missing|5",
+					built_in: "array_agg array_append array_concat array_contains array_count array_distinct array_ifnull array_length array_max array_min array_position array_prepend array_put array_range array_remove array_repeat array_replace array_reverse array_sort array_sum avg count max min sum greatest least ifmissing ifmissingornull ifnull missingif nullif ifinf ifnan ifnanorinf naninf neginfif posinfif clock_millis clock_str date_add_millis date_add_str date_diff_millis date_diff_str date_part_millis date_part_str date_trunc_millis date_trunc_str duration_to_str millis str_to_millis millis_to_str millis_to_utc millis_to_zone_name now_millis now_str str_to_duration str_to_utc str_to_zone_name decode_json encode_json encoded_size poly_length base64 base64_encode base64_decode meta uuid abs acos asin atan atan2 ceil cos degrees e exp ln log floor pi power radians random round sign sin sqrt tan trunc object_length object_names object_pairs object_inner_pairs object_values object_inner_values object_add object_put object_remove object_unwrap regexp_contains regexp_like regexp_position regexp_replace contains initcap length lower ltrim position repeat replace rtrim split substr title trim upper isarray isatom isboolean isnumber isobject isstring type toarray toatom toboolean tonumber toobject tostring"
+				},
+				contains: [
+					{
+						className: "string",
+						begin: "'",
+						end: "'",
+						contains: [hljs.BACKSLASH_ESCAPE]
+					},
+					{
+						className: "string",
+						begin: "\"",
+						end: "\"",
+						contains: [hljs.BACKSLASH_ESCAPE]
+					},
+					{
+						className: "symbol",
+						begin: "`",
+						end: "`",
+						contains: [hljs.BACKSLASH_ESCAPE],
+						relevance: 2
+					},
+					hljs.C_NUMBER_MODE,
+					hljs.C_BLOCK_COMMENT_MODE
+				]
+			}, hljs.C_BLOCK_COMMENT_MODE]
+		};
+	}
+	module.exports = n1ql;
+}));
+
+//#endregion
+export default require_n1ql();

package/dist/n4js-B0G1BP6w.js

@@ -0,0 +1,21 @@
+import { t as javascript } from "./javascript-BJ-LeMcK.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/n4js.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+n4js.displayName = "n4js";
+n4js.aliases = ["n4jsd"];
+/** @param {Refractor} Prism */
+function n4js(Prism) {
+	Prism.register(javascript);
+	Prism.languages.n4js = Prism.languages.extend("javascript", { keyword: /\b(?:Array|any|boolean|break|case|catch|class|const|constructor|continue|debugger|declare|default|delete|do|else|enum|export|extends|false|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|module|new|null|number|package|private|protected|public|return|set|static|string|super|switch|this|throw|true|try|typeof|var|void|while|with|yield)\b/ });
+	Prism.languages.insertBefore("n4js", "constant", { annotation: {
+		pattern: /@+\w+/,
+		alias: "operator"
+	} });
+	Prism.languages.n4jsd = Prism.languages.n4js;
+}
+
+//#endregion
+export { n4js as default };

package/dist/nand2tetris-hdl-BlZue0BE.js

@@ -0,0 +1,21 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/nand2tetris-hdl.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+nand2tetrisHdl.displayName = "nand2tetris-hdl";
+nand2tetrisHdl.aliases = [];
+/** @param {Refractor} Prism */
+function nand2tetrisHdl(Prism) {
+	Prism.languages["nand2tetris-hdl"] = {
+		comment: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
+		keyword: /\b(?:BUILTIN|CHIP|CLOCKED|IN|OUT|PARTS)\b/,
+		boolean: /\b(?:false|true)\b/,
+		function: /\b[A-Za-z][A-Za-z0-9]*(?=\()/,
+		number: /\b\d+\b/,
+		operator: /=|\.\./,
+		punctuation: /[{}[\];(),:]/
+	};
+}
+
+//#endregion
+export { nand2tetrisHdl as default };

package/dist/naniscript-DA6Nu-1R.js

@@ -0,0 +1,159 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/naniscript.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+naniscript.displayName = "naniscript";
+naniscript.aliases = ["nani"];
+/** @param {Refractor} Prism */
+function naniscript(Prism) {
+	(function(Prism) {
+		var expressionDef = /\{[^\r\n\[\]{}]*\}/;
+		var params = {
+			"quoted-string": {
+				pattern: /"(?:[^"\\]|\\.)*"/,
+				alias: "operator"
+			},
+			"command-param-id": {
+				pattern: /(\s)\w+:/,
+				lookbehind: true,
+				alias: "property"
+			},
+			"command-param-value": [
+				{
+					pattern: expressionDef,
+					alias: "selector"
+				},
+				{
+					pattern: /([\t ])\S+/,
+					lookbehind: true,
+					greedy: true,
+					alias: "operator"
+				},
+				{
+					pattern: /\S(?:.*\S)?/,
+					alias: "operator"
+				}
+			]
+		};
+		Prism.languages.naniscript = {
+			comment: {
+				pattern: /^([\t ]*);.*/m,
+				lookbehind: true
+			},
+			define: {
+				pattern: /^>.+/m,
+				alias: "tag",
+				inside: {
+					value: {
+						pattern: /(^>\w+[\t ]+)(?!\s)[^{}\r\n]+/,
+						lookbehind: true,
+						alias: "operator"
+					},
+					key: {
+						pattern: /(^>)\w+/,
+						lookbehind: true
+					}
+				}
+			},
+			label: {
+				pattern: /^([\t ]*)#[\t ]*\w+[\t ]*$/m,
+				lookbehind: true,
+				alias: "regex"
+			},
+			command: {
+				pattern: /^([\t ]*)@\w+(?=[\t ]|$).*/m,
+				lookbehind: true,
+				alias: "function",
+				inside: {
+					"command-name": /^@\w+/,
+					expression: {
+						pattern: expressionDef,
+						greedy: true,
+						alias: "selector"
+					},
+					"command-params": {
+						pattern: /\s*\S[\s\S]*/,
+						inside: params
+					}
+				}
+			},
+			"generic-text": {
+				pattern: /(^[ \t]*)[^#@>;\s].*/m,
+				lookbehind: true,
+				alias: "punctuation",
+				inside: {
+					"escaped-char": /\\[{}\[\]"]/,
+					expression: {
+						pattern: expressionDef,
+						greedy: true,
+						alias: "selector"
+					},
+					"inline-command": {
+						pattern: /\[[\t ]*\w[^\r\n\[\]]*\]/,
+						greedy: true,
+						alias: "function",
+						inside: {
+							"command-params": {
+								pattern: /(^\[[\t ]*\w+\b)[\s\S]+(?=\]$)/,
+								lookbehind: true,
+								inside: params
+							},
+							"command-param-name": {
+								pattern: /^(\[[\t ]*)\w+/,
+								lookbehind: true,
+								alias: "name"
+							},
+							"start-stop-char": /[\[\]]/
+						}
+					}
+				}
+			}
+		};
+		Prism.languages.nani = Prism.languages["naniscript"];
+		/** @typedef {InstanceType<import("./prism-core")["Token"]>} Token */
+		/**
+		* This hook is used to validate generic-text tokens for balanced brackets.
+		* Mark token as bad-line when contains not balanced brackets: {},[]
+		*/
+		Prism.hooks.add("after-tokenize", function(env) {
+			env.tokens.forEach(function(token) {
+				if (typeof token !== "string" && token.type === "generic-text") {
+					var content = getTextContent(token);
+					if (!isBracketsBalanced(content)) {
+						token.type = "bad-line";
+						token.content = content;
+					}
+				}
+			});
+		});
+		/**
+		* @param {string} input
+		* @returns {boolean}
+		*/
+		function isBracketsBalanced(input) {
+			var brackets = "[]{}";
+			var stack = [];
+			for (var i = 0; i < input.length; i++) {
+				var bracket = input[i];
+				var bracketsIndex = brackets.indexOf(bracket);
+				if (bracketsIndex !== -1) {
+					if (bracketsIndex % 2 === 0) stack.push(bracketsIndex + 1);
+					else if (stack.pop() !== bracketsIndex) return false;
+				}
+			}
+			return stack.length === 0;
+		}
+		/**
+		* @param {string | Token | (string | Token)[]} token
+		* @returns {string}
+		*/
+		function getTextContent(token) {
+			if (typeof token === "string") return token;
+			else if (Array.isArray(token)) return token.map(getTextContent).join("");
+			else return getTextContent(token.content);
+		}
+	})(Prism);
+}
+
+//#endregion
+export { naniscript as default };

package/dist/nasm-CIk3Maz7.js

@@ -0,0 +1,36 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/nasm.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+nasm.displayName = "nasm";
+nasm.aliases = [];
+/** @param {Refractor} Prism */
+function nasm(Prism) {
+	Prism.languages.nasm = {
+		comment: /;.*$/m,
+		string: /(["'`])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+		label: {
+			pattern: /(^\s*)[A-Za-z._?$][\w.?$@~#]*:/m,
+			lookbehind: true,
+			alias: "function"
+		},
+		keyword: [
+			/\[?BITS (?:16|32|64)\]?/,
+			{
+				pattern: /(^\s*)section\s*[a-z.]+:?/im,
+				lookbehind: true
+			},
+			/(?:extern|global)[^;\r\n]*/i,
+			/(?:CPU|DEFAULT|FLOAT).*$/m
+		],
+		register: {
+			pattern: /\b(?:st\d|[xyz]mm\d\d?|[cdt]r\d|r\d\d?[bwd]?|[er]?[abcd]x|[abcd][hl]|[er]?(?:bp|di|si|sp)|[cdefgs]s)\b/i,
+			alias: "variable"
+		},
+		number: /(?:\b|(?=\$))(?:0[hx](?:\.[\da-f]+|[\da-f]+(?:\.[\da-f]+)?)(?:p[+-]?\d+)?|\d[\da-f]+[hx]|\$\d[\da-f]*|0[oq][0-7]+|[0-7]+[oq]|0[by][01]+|[01]+[by]|0[dt]\d+|(?:\d+(?:\.\d+)?|\.\d+)(?:\.?e[+-]?\d+)?[dt]?)\b/i,
+		operator: /[\[\]*+\-\/%<>=&|$!]/
+	};
+}
+
+//#endregion
+export { nasm as default };

package/dist/neon-COQc3WnN.js

@@ -0,0 +1,52 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/neon.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+neon.displayName = "neon";
+neon.aliases = [];
+/** @param {Refractor} Prism */
+function neon(Prism) {
+	Prism.languages.neon = {
+		comment: {
+			pattern: /#.*/,
+			greedy: true
+		},
+		datetime: {
+			pattern: /(^|[[{(=:,\s])\d\d\d\d-\d\d?-\d\d?(?:(?:[Tt]| +)\d\d?:\d\d:\d\d(?:\.\d*)? *(?:Z|[-+]\d\d?(?::?\d\d)?)?)?(?=$|[\]}),\s])/,
+			lookbehind: true,
+			alias: "number"
+		},
+		key: {
+			pattern: /(^|[[{(,\s])[^,:=[\]{}()'"\s]+(?=\s*:(?:$|[\]}),\s])|\s*=)/,
+			lookbehind: true,
+			alias: "property"
+		},
+		number: {
+			pattern: /(^|[[{(=:,\s])[+-]?(?:0x[\da-fA-F]+|0o[0-7]+|0b[01]+|(?:\d+(?:\.\d*)?|\.?\d+)(?:[eE][+-]?\d+)?)(?=$|[\]}),:=\s])/,
+			lookbehind: true
+		},
+		boolean: {
+			pattern: /(^|[[{(=:,\s])(?:false|no|true|yes)(?=$|[\]}),:=\s])/i,
+			lookbehind: true
+		},
+		null: {
+			pattern: /(^|[[{(=:,\s])(?:null)(?=$|[\]}),:=\s])/i,
+			lookbehind: true,
+			alias: "keyword"
+		},
+		string: {
+			pattern: /(^|[[{(=:,\s])(?:('''|""")\r?\n(?:(?:[^\r\n]|\r?\n(?![\t ]*\2))*\r?\n)?[\t ]*\2|'[^'\r\n]*'|"(?:\\.|[^\\"\r\n])*")/,
+			lookbehind: true,
+			greedy: true
+		},
+		literal: {
+			pattern: /(^|[[{(=:,\s])(?:[^#"',:=[\]{}()\s`-]|[:-][^"',=[\]{}()\s])(?:[^,:=\]})(\s]|:(?![\s,\]})]|$)|[ \t]+[^#,:=\]})(\s])*/,
+			lookbehind: true,
+			alias: "string"
+		},
+		punctuation: /[,:=[\]{}()-]/
+	};
+}
+
+//#endregion
+export { neon as default };

package/dist/nevod-BYmtc0a2.js

@@ -0,0 +1,132 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/nevod.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+nevod.displayName = "nevod";
+nevod.aliases = [];
+/** @param {Refractor} Prism */
+function nevod(Prism) {
+	Prism.languages.nevod = {
+		comment: /\/\/.*|(?:\/\*[\s\S]*?(?:\*\/|$))/,
+		string: {
+			pattern: /(?:"(?:""|[^"])*"(?!")|'(?:''|[^'])*'(?!'))!?\*?/,
+			greedy: true,
+			inside: { "string-attrs": /!$|!\*$|\*$/ }
+		},
+		namespace: {
+			pattern: /(@namespace\s+)[a-zA-Z0-9\-.]+(?=\s*\{)/,
+			lookbehind: true
+		},
+		pattern: {
+			pattern: /(@pattern\s+)?#?[a-zA-Z0-9\-.]+(?:\s*\(\s*(?:~\s*)?[a-zA-Z0-9\-.]+\s*(?:,\s*(?:~\s*)?[a-zA-Z0-9\-.]*)*\))?(?=\s*=)/,
+			lookbehind: true,
+			inside: {
+				"pattern-name": {
+					pattern: /^#?[a-zA-Z0-9\-.]+/,
+					alias: "class-name"
+				},
+				fields: {
+					pattern: /\(.*\)/,
+					inside: {
+						"field-name": {
+							pattern: /[a-zA-Z0-9\-.]+/,
+							alias: "variable"
+						},
+						punctuation: /[,()]/,
+						operator: {
+							pattern: /~/,
+							alias: "field-hidden-mark"
+						}
+					}
+				}
+			}
+		},
+		search: {
+			pattern: /(@search\s+|#)[a-zA-Z0-9\-.]+(?:\.\*)?(?=\s*;)/,
+			alias: "function",
+			lookbehind: true
+		},
+		keyword: /@(?:having|inside|namespace|outside|pattern|require|search|where)\b/,
+		"standard-pattern": {
+			pattern: /\b(?:Alpha|AlphaNum|Any|Blank|End|LineBreak|Num|NumAlpha|Punct|Space|Start|Symbol|Word|WordBreak)\b(?:\([a-zA-Z0-9\-.,\s+]*\))?/,
+			inside: {
+				"standard-pattern-name": {
+					pattern: /^[a-zA-Z0-9\-.]+/,
+					alias: "builtin"
+				},
+				quantifier: {
+					pattern: /\b\d+(?:\s*\+|\s*-\s*\d+)?(?!\w)/,
+					alias: "number"
+				},
+				"standard-pattern-attr": {
+					pattern: /[a-zA-Z0-9\-.]+/,
+					alias: "builtin"
+				},
+				punctuation: /[,()]/
+			}
+		},
+		quantifier: {
+			pattern: /\b\d+(?:\s*\+|\s*-\s*\d+)?(?!\w)/,
+			alias: "number"
+		},
+		operator: [
+			{
+				pattern: /=/,
+				alias: "pattern-def"
+			},
+			{
+				pattern: /&/,
+				alias: "conjunction"
+			},
+			{
+				pattern: /~/,
+				alias: "exception"
+			},
+			{
+				pattern: /\?/,
+				alias: "optionality"
+			},
+			{
+				pattern: /[[\]]/,
+				alias: "repetition"
+			},
+			{
+				pattern: /[{}]/,
+				alias: "variation"
+			},
+			{
+				pattern: /[+_]/,
+				alias: "sequence"
+			},
+			{
+				pattern: /\.{2,3}/,
+				alias: "span"
+			}
+		],
+		"field-capture": [{
+			pattern: /([a-zA-Z0-9\-.]+\s*\()\s*[a-zA-Z0-9\-.]+\s*:\s*[a-zA-Z0-9\-.]+(?:\s*,\s*[a-zA-Z0-9\-.]+\s*:\s*[a-zA-Z0-9\-.]+)*(?=\s*\))/,
+			lookbehind: true,
+			inside: {
+				"field-name": {
+					pattern: /[a-zA-Z0-9\-.]+/,
+					alias: "variable"
+				},
+				colon: /:/
+			}
+		}, {
+			pattern: /[a-zA-Z0-9\-.]+\s*:/,
+			inside: {
+				"field-name": {
+					pattern: /[a-zA-Z0-9\-.]+/,
+					alias: "variable"
+				},
+				colon: /:/
+			}
+		}],
+		punctuation: /[:;,()]/,
+		name: /[a-zA-Z0-9\-.]+/
+	};
+}
+
+//#endregion
+export { nevod as default };

package/dist/nginx-CkGcwumj.js

@@ -0,0 +1,60 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/nginx.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+nginx.displayName = "nginx";
+nginx.aliases = [];
+/** @param {Refractor} Prism */
+function nginx(Prism) {
+	(function(Prism) {
+		var variable = /\$(?:\w[a-z\d]*(?:_[^\x00-\x1F\s"'\\()$]*)?|\{[^}\s"'\\]+\})/i;
+		Prism.languages.nginx = {
+			comment: {
+				pattern: /(^|[\s{};])#.*/,
+				lookbehind: true,
+				greedy: true
+			},
+			directive: {
+				pattern: /(^|\s)\w(?:[^;{}"'\\\s]|\\.|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\s+(?:#.*(?!.)|(?![#\s])))*?(?=\s*[;{])/,
+				lookbehind: true,
+				greedy: true,
+				inside: {
+					string: {
+						pattern: /((?:^|[^\\])(?:\\\\)*)(?:"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')/,
+						lookbehind: true,
+						greedy: true,
+						inside: {
+							escape: {
+								pattern: /\\["'\\nrt]/,
+								alias: "entity"
+							},
+							variable
+						}
+					},
+					comment: {
+						pattern: /(\s)#.*/,
+						lookbehind: true,
+						greedy: true
+					},
+					keyword: {
+						pattern: /^\S+/,
+						greedy: true
+					},
+					boolean: {
+						pattern: /(\s)(?:off|on)(?!\S)/,
+						lookbehind: true
+					},
+					number: {
+						pattern: /(\s)\d+[a-z]*(?!\S)/i,
+						lookbehind: true
+					},
+					variable
+				}
+			},
+			punctuation: /[{};]/
+		};
+	})(Prism);
+}
+
+//#endregion
+export { nginx as default };