@webskill/chatbot 0.0.1

package/dist/pascal-Zk9Hdh8x.js

@@ -0,0 +1,63 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/pascal.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+pascal.displayName = "pascal";
+pascal.aliases = ["objectpascal"];
+/** @param {Refractor} Prism */
+function pascal(Prism) {
+	Prism.languages.pascal = {
+		directive: {
+			pattern: /\{\$[\s\S]*?\}/,
+			greedy: true,
+			alias: ["marco", "property"]
+		},
+		comment: {
+			pattern: /\(\*[\s\S]*?\*\)|\{[\s\S]*?\}|\/\/.*/,
+			greedy: true
+		},
+		string: {
+			pattern: /(?:'(?:''|[^'\r\n])*'(?!')|#[&$%]?[a-f\d]+)+|\^[a-z]/i,
+			greedy: true
+		},
+		asm: {
+			pattern: /(\basm\b)[\s\S]+?(?=\bend\s*[;[])/i,
+			lookbehind: true,
+			greedy: true,
+			inside: null
+		},
+		keyword: [
+			{
+				pattern: /(^|[^&])\b(?:absolute|array|asm|begin|case|const|constructor|destructor|do|downto|else|end|file|for|function|goto|if|implementation|inherited|inline|interface|label|nil|object|of|operator|packed|procedure|program|record|reintroduce|repeat|self|set|string|then|to|type|unit|until|uses|var|while|with)\b/i,
+				lookbehind: true
+			},
+			{
+				pattern: /(^|[^&])\b(?:dispose|exit|false|new|true)\b/i,
+				lookbehind: true
+			},
+			{
+				pattern: /(^|[^&])\b(?:class|dispinterface|except|exports|finalization|finally|initialization|inline|library|on|out|packed|property|raise|resourcestring|threadvar|try)\b/i,
+				lookbehind: true
+			},
+			{
+				pattern: /(^|[^&])\b(?:absolute|abstract|alias|assembler|bitpacked|break|cdecl|continue|cppdecl|cvar|default|deprecated|dynamic|enumerator|experimental|export|external|far|far16|forward|generic|helper|implements|index|interrupt|iochecks|local|message|name|near|nodefault|noreturn|nostackframe|oldfpccall|otherwise|overload|override|pascal|platform|private|protected|public|published|read|register|reintroduce|result|safecall|saveregisters|softfloat|specialize|static|stdcall|stored|strict|unaligned|unimplemented|varargs|virtual|write)\b/i,
+				lookbehind: true
+			}
+		],
+		number: [/(?:[&%]\d+|\$[a-f\d]+)/i, /\b\d+(?:\.\d+)?(?:e[+-]?\d+)?/i],
+		operator: [/\.\.|\*\*|:=|<[<=>]?|>[>=]?|[+\-*\/]=?|[@^=]/, {
+			pattern: /(^|[^&])\b(?:and|as|div|exclude|in|include|is|mod|not|or|shl|shr|xor)\b/,
+			lookbehind: true
+		}],
+		punctuation: /\(\.|\.\)|[()\[\]:;,.]/
+	};
+	Prism.languages.pascal.asm.inside = Prism.languages.extend("pascal", {
+		asm: void 0,
+		keyword: void 0,
+		operator: void 0
+	});
+	Prism.languages.objectpascal = Prism.languages.pascal;
+}
+
+//#endregion
+export { pascal as default };

package/dist/pascaligo-DlFj9gb7.js

@@ -0,0 +1,76 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/pascaligo.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+pascaligo.displayName = "pascaligo";
+pascaligo.aliases = [];
+/** @param {Refractor} Prism */
+function pascaligo(Prism) {
+	(function(Prism) {
+		var braces = /\((?:[^()]|\((?:[^()]|\([^()]*\))*\))*\)/.source;
+		var type = /(?:\b\w+(?:<braces>)?|<braces>)/.source.replace(/<braces>/g, function() {
+			return braces;
+		});
+		var pascaligo = Prism.languages.pascaligo = {
+			comment: /\(\*[\s\S]+?\*\)|\/\/.*/,
+			string: {
+				pattern: /(["'`])(?:\\[\s\S]|(?!\1)[^\\])*\1|\^[a-z]/i,
+				greedy: true
+			},
+			"class-name": [
+				{
+					pattern: RegExp(/(\btype\s+\w+\s+is\s+)<type>/.source.replace(/<type>/g, function() {
+						return type;
+					}), "i"),
+					lookbehind: true,
+					inside: null
+				},
+				{
+					pattern: RegExp(/<type>(?=\s+is\b)/.source.replace(/<type>/g, function() {
+						return type;
+					}), "i"),
+					inside: null
+				},
+				{
+					pattern: RegExp(/(:\s*)<type>/.source.replace(/<type>/g, function() {
+						return type;
+					})),
+					lookbehind: true,
+					inside: null
+				}
+			],
+			keyword: {
+				pattern: /(^|[^&])\b(?:begin|block|case|const|else|end|fail|for|from|function|if|is|nil|of|remove|return|skip|then|type|var|while|with)\b/i,
+				lookbehind: true
+			},
+			boolean: {
+				pattern: /(^|[^&])\b(?:False|True)\b/i,
+				lookbehind: true
+			},
+			builtin: {
+				pattern: /(^|[^&])\b(?:bool|int|list|map|nat|record|string|unit)\b/i,
+				lookbehind: true
+			},
+			function: /\b\w+(?=\s*\()/,
+			number: [/%[01]+|&[0-7]+|\$[a-f\d]+/i, /\b\d+(?:\.\d+)?(?:e[+-]?\d+)?(?:mtz|n)?/i],
+			operator: /->|=\/=|\.\.|\*\*|:=|<[<=>]?|>[>=]?|[+\-*\/]=?|[@^=|]|\b(?:and|mod|or)\b/,
+			punctuation: /\(\.|\.\)|[()\[\]:;,.{}]/
+		};
+		var classNameInside = [
+			"comment",
+			"keyword",
+			"builtin",
+			"operator",
+			"punctuation"
+		].reduce(function(accum, key) {
+			accum[key] = pascaligo[key];
+			return accum;
+		}, {});
+		pascaligo["class-name"].forEach(function(p) {
+			p.inside = classNameInside;
+		});
+	})(Prism);
+}
+
+//#endregion
+export { pascaligo as default };

package/dist/pcaxis-BpZTiG1_.js

@@ -0,0 +1,64 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/pcaxis.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+pcaxis.displayName = "pcaxis";
+pcaxis.aliases = ["px"];
+/** @param {Refractor} Prism */
+function pcaxis(Prism) {
+	Prism.languages.pcaxis = {
+		string: /"[^"]*"/,
+		keyword: {
+			pattern: /((?:^|;)\s*)[-A-Z\d]+(?:\s*\[[-\w]+\])?(?:\s*\("[^"]*"(?:,\s*"[^"]*")*\))?(?=\s*=)/,
+			lookbehind: true,
+			greedy: true,
+			inside: {
+				keyword: /^[-A-Z\d]+/,
+				language: {
+					pattern: /^(\s*)\[[-\w]+\]/,
+					lookbehind: true,
+					inside: {
+						punctuation: /^\[|\]$/,
+						property: /[-\w]+/
+					}
+				},
+				"sub-key": {
+					pattern: /^(\s*)\S[\s\S]*/,
+					lookbehind: true,
+					inside: {
+						parameter: {
+							pattern: /"[^"]*"/,
+							alias: "property"
+						},
+						punctuation: /^\(|\)$|,/
+					}
+				}
+			}
+		},
+		operator: /=/,
+		tlist: {
+			pattern: /TLIST\s*\(\s*\w+(?:(?:\s*,\s*"[^"]*")+|\s*,\s*"[^"]*"-"[^"]*")?\s*\)/,
+			greedy: true,
+			inside: {
+				function: /^TLIST/,
+				property: {
+					pattern: /^(\s*\(\s*)\w+/,
+					lookbehind: true
+				},
+				string: /"[^"]*"/,
+				punctuation: /[(),]/,
+				operator: /-/
+			}
+		},
+		punctuation: /[;,]/,
+		number: {
+			pattern: /(^|\s)\d+(?:\.\d+)?(?!\S)/,
+			lookbehind: true
+		},
+		boolean: /NO|YES/
+	};
+	Prism.languages.px = Prism.languages.pcaxis;
+}
+
+//#endregion
+export { pcaxis as default };

package/dist/peoplecode-BvNlpzn4.js

@@ -0,0 +1,46 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/peoplecode.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+peoplecode.displayName = "peoplecode";
+peoplecode.aliases = ["pcode"];
+/** @param {Refractor} Prism */
+function peoplecode(Prism) {
+	Prism.languages.peoplecode = {
+		comment: RegExp([
+			/\/\*[\s\S]*?\*\//.source,
+			/\bREM[^;]*;/.source,
+			/<\*(?:[^<*]|\*(?!>)|<(?!\*)|<\*(?:(?!\*>)[\s\S])*\*>)*\*>/.source,
+			/\/\+[\s\S]*?\+\//.source
+		].join("|")),
+		string: {
+			pattern: /'(?:''|[^'\r\n])*'(?!')|"(?:""|[^"\r\n])*"(?!")/,
+			greedy: true
+		},
+		variable: /%\w+/,
+		"function-definition": {
+			pattern: /((?:^|[^\w-])(?:function|method)\s+)\w+/i,
+			lookbehind: true,
+			alias: "function"
+		},
+		"class-name": {
+			pattern: /((?:^|[^-\w])(?:as|catch|class|component|create|extends|global|implements|instance|local|of|property|returns)\s+)\w+(?::\w+)*/i,
+			lookbehind: true,
+			inside: { punctuation: /:/ }
+		},
+		keyword: /\b(?:abstract|alias|as|catch|class|component|constant|create|declare|else|end-(?:class|evaluate|for|function|get|if|method|set|try|while)|evaluate|extends|for|function|get|global|if|implements|import|instance|library|local|method|null|of|out|peopleCode|private|program|property|protected|readonly|ref|repeat|returns?|set|step|then|throw|to|try|until|value|when(?:-other)?|while)\b/i,
+		"operator-keyword": {
+			pattern: /\b(?:and|not|or)\b/i,
+			alias: "operator"
+		},
+		function: /[_a-z]\w*(?=\s*\()/i,
+		boolean: /\b(?:false|true)\b/i,
+		number: /\b\d+(?:\.\d+)?\b/,
+		operator: /<>|[<>]=?|!=|\*\*|[-+*/|=@]/,
+		punctuation: /[:.;,()[\]]/
+	};
+	Prism.languages.pcode = Prism.languages.peoplecode;
+}
+
+//#endregion
+export { peoplecode as default };

package/dist/perl-D3TeFX3f.js

@@ -0,0 +1,91 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/perl.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+perl.displayName = "perl";
+perl.aliases = [];
+/** @param {Refractor} Prism */
+function perl(Prism) {
+	(function(Prism) {
+		var brackets = /(?:\((?:[^()\\]|\\[\s\S])*\)|\{(?:[^{}\\]|\\[\s\S])*\}|\[(?:[^[\]\\]|\\[\s\S])*\]|<(?:[^<>\\]|\\[\s\S])*>)/.source;
+		Prism.languages.perl = {
+			comment: [{
+				pattern: /(^\s*)=\w[\s\S]*?=cut.*/m,
+				lookbehind: true,
+				greedy: true
+			}, {
+				pattern: /(^|[^\\$])#.*/,
+				lookbehind: true,
+				greedy: true
+			}],
+			string: [
+				{
+					pattern: RegExp(/\b(?:q|qq|qw|qx)(?![a-zA-Z0-9])\s*/.source + "(?:" + [
+						/([^a-zA-Z0-9\s{(\[<])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source,
+						/([a-zA-Z0-9])(?:(?!\2)[^\\]|\\[\s\S])*\2/.source,
+						brackets
+					].join("|") + ")"),
+					greedy: true
+				},
+				{
+					pattern: /("|`)(?:(?!\1)[^\\]|\\[\s\S])*\1/,
+					greedy: true
+				},
+				{
+					pattern: /'(?:[^'\\\r\n]|\\.)*'/,
+					greedy: true
+				}
+			],
+			regex: [
+				{
+					pattern: RegExp(/\b(?:m|qr)(?![a-zA-Z0-9])\s*/.source + "(?:" + [
+						/([^a-zA-Z0-9\s{(\[<])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source,
+						/([a-zA-Z0-9])(?:(?!\2)[^\\]|\\[\s\S])*\2/.source,
+						brackets
+					].join("|") + ")" + /[msixpodualngc]*/.source),
+					greedy: true
+				},
+				{
+					pattern: RegExp(/(^|[^-])\b(?:s|tr|y)(?![a-zA-Z0-9])\s*/.source + "(?:" + [
+						/([^a-zA-Z0-9\s{(\[<])(?:(?!\2)[^\\]|\\[\s\S])*\2(?:(?!\2)[^\\]|\\[\s\S])*\2/.source,
+						/([a-zA-Z0-9])(?:(?!\3)[^\\]|\\[\s\S])*\3(?:(?!\3)[^\\]|\\[\s\S])*\3/.source,
+						brackets + /\s*/.source + brackets
+					].join("|") + ")" + /[msixpodualngcer]*/.source),
+					lookbehind: true,
+					greedy: true
+				},
+				{
+					pattern: /\/(?:[^\/\\\r\n]|\\.)*\/[msixpodualngc]*(?=\s*(?:$|[\r\n,.;})&|\-+*~<>!?^]|(?:and|cmp|eq|ge|gt|le|lt|ne|not|or|x|xor)\b))/,
+					greedy: true
+				}
+			],
+			variable: [
+				/[&*$@%]\{\^[A-Z]+\}/,
+				/[&*$@%]\^[A-Z_]/,
+				/[&*$@%]#?(?=\{)/,
+				/[&*$@%]#?(?:(?:::)*'?(?!\d)[\w$]+(?![\w$]))+(?:::)*/,
+				/[&*$@%]\d+/,
+				/(?!%=)[$@%][!"#$%&'()*+,\-.\/:;<=>?@[\\\]^_`{|}~]/
+			],
+			filehandle: {
+				pattern: /<(?![<=])\S*?>|\b_\b/,
+				alias: "symbol"
+			},
+			"v-string": {
+				pattern: /v\d+(?:\.\d+)*|\d+(?:\.\d+){2,}/,
+				alias: "string"
+			},
+			function: {
+				pattern: /(\bsub[ \t]+)\w+/,
+				lookbehind: true
+			},
+			keyword: /\b(?:any|break|continue|default|delete|die|do|else|elsif|eval|for|foreach|given|goto|if|last|local|my|next|our|package|print|redo|require|return|say|state|sub|switch|undef|unless|until|use|when|while)\b/,
+			number: /\b(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0b[01](?:_?[01])*|(?:(?:\d(?:_?\d)*)?\.)?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)\b/,
+			operator: /-[rwxoRWXOezsfdlpSbctugkTBMAC]\b|\+[+=]?|-[-=>]?|\*\*?=?|\/\/?=?|=[=~>]?|~[~=]?|\|\|?=?|&&?=?|<(?:=>?|<=?)?|>>?=?|![~=]?|[%^]=?|\.(?:=|\.\.?)?|[\\?]|\bx(?:=|\b)|\b(?:and|cmp|eq|ge|gt|le|lt|ne|not|or|xor)\b/,
+			punctuation: /[{}[\];(),:]/
+		};
+	})(Prism);
+}
+
+//#endregion
+export { perl as default };