@webskill/chatbot 0.0.1

package/dist/crystal-BTPDFDkd.js

@@ -0,0 +1,260 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/crystal.js
+var require_crystal = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type LanguageFn */
+	function crystal(hljs) {
+		const CRYSTAL_IDENT_RE = "[a-zA-Z_]\\w*[!?=]?";
+		const CRYSTAL_METHOD_RE = "[a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|[=!]~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~|]|//|//=|&[-+*]=?|&\\*\\*|\\[\\][=?]?";
+		const CRYSTAL_PATH_RE = "[A-Za-z_]\\w*(::\\w+)*(\\?|!)?";
+		const CRYSTAL_KEYWORDS = {
+			$pattern: CRYSTAL_IDENT_RE,
+			keyword: "abstract alias annotation as as? asm begin break case class def do else elsif end ensure enum extend for fun if include instance_sizeof is_a? lib macro module next nil? of out pointerof private protected rescue responds_to? return require select self sizeof struct super then type typeof union uninitialized unless until verbatim when while with yield __DIR__ __END_LINE__ __FILE__ __LINE__",
+			literal: "false nil true"
+		};
+		const SUBST = {
+			className: "subst",
+			begin: /#\{/,
+			end: /\}/,
+			keywords: CRYSTAL_KEYWORDS
+		};
+		const EXPANSION = {
+			className: "template-variable",
+			variants: [{
+				begin: "\\{\\{",
+				end: "\\}\\}"
+			}, {
+				begin: "\\{%",
+				end: "%\\}"
+			}],
+			keywords: CRYSTAL_KEYWORDS
+		};
+		function recursiveParen(begin, end) {
+			const contains = [{
+				begin,
+				end
+			}];
+			contains[0].contains = contains;
+			return contains;
+		}
+		const STRING = {
+			className: "string",
+			contains: [hljs.BACKSLASH_ESCAPE, SUBST],
+			variants: [
+				{
+					begin: /'/,
+					end: /'/
+				},
+				{
+					begin: /"/,
+					end: /"/
+				},
+				{
+					begin: /`/,
+					end: /`/
+				},
+				{
+					begin: "%[Qwi]?\\(",
+					end: "\\)",
+					contains: recursiveParen("\\(", "\\)")
+				},
+				{
+					begin: "%[Qwi]?\\[",
+					end: "\\]",
+					contains: recursiveParen("\\[", "\\]")
+				},
+				{
+					begin: "%[Qwi]?\\{",
+					end: /\}/,
+					contains: recursiveParen(/\{/, /\}/)
+				},
+				{
+					begin: "%[Qwi]?<",
+					end: ">",
+					contains: recursiveParen("<", ">")
+				},
+				{
+					begin: "%[Qwi]?\\|",
+					end: "\\|"
+				},
+				{
+					begin: /<<-\w+$/,
+					end: /^\s*\w+$/
+				}
+			],
+			relevance: 0
+		};
+		const Q_STRING = {
+			className: "string",
+			variants: [
+				{
+					begin: "%q\\(",
+					end: "\\)",
+					contains: recursiveParen("\\(", "\\)")
+				},
+				{
+					begin: "%q\\[",
+					end: "\\]",
+					contains: recursiveParen("\\[", "\\]")
+				},
+				{
+					begin: "%q\\{",
+					end: /\}/,
+					contains: recursiveParen(/\{/, /\}/)
+				},
+				{
+					begin: "%q<",
+					end: ">",
+					contains: recursiveParen("<", ">")
+				},
+				{
+					begin: "%q\\|",
+					end: "\\|"
+				},
+				{
+					begin: /<<-'\w+'$/,
+					end: /^\s*\w+$/
+				}
+			],
+			relevance: 0
+		};
+		const REGEXP = {
+			begin: "(?!%\\})(" + hljs.RE_STARTERS_RE + "|\\n|\\b(case|if|select|unless|until|when|while)\\b)\\s*",
+			keywords: "case if select unless until when while",
+			contains: [{
+				className: "regexp",
+				contains: [hljs.BACKSLASH_ESCAPE, SUBST],
+				variants: [{
+					begin: "//[a-z]*",
+					relevance: 0
+				}, {
+					begin: "/(?!\\/)",
+					end: "/[a-z]*"
+				}]
+			}],
+			relevance: 0
+		};
+		const CRYSTAL_DEFAULT_CONTAINS = [
+			EXPANSION,
+			STRING,
+			Q_STRING,
+			{
+				className: "regexp",
+				contains: [hljs.BACKSLASH_ESCAPE, SUBST],
+				variants: [
+					{
+						begin: "%r\\(",
+						end: "\\)",
+						contains: recursiveParen("\\(", "\\)")
+					},
+					{
+						begin: "%r\\[",
+						end: "\\]",
+						contains: recursiveParen("\\[", "\\]")
+					},
+					{
+						begin: "%r\\{",
+						end: /\}/,
+						contains: recursiveParen(/\{/, /\}/)
+					},
+					{
+						begin: "%r<",
+						end: ">",
+						contains: recursiveParen("<", ">")
+					},
+					{
+						begin: "%r\\|",
+						end: "\\|"
+					}
+				],
+				relevance: 0
+			},
+			REGEXP,
+			{
+				className: "meta",
+				begin: "@\\[",
+				end: "\\]",
+				contains: [hljs.inherit(hljs.QUOTE_STRING_MODE, { className: "meta-string" })]
+			},
+			hljs.HASH_COMMENT_MODE,
+			{
+				className: "class",
+				beginKeywords: "class module struct",
+				end: "$|;",
+				illegal: /=/,
+				contains: [
+					hljs.HASH_COMMENT_MODE,
+					hljs.inherit(hljs.TITLE_MODE, { begin: CRYSTAL_PATH_RE }),
+					{ begin: "<" }
+				]
+			},
+			{
+				className: "class",
+				beginKeywords: "lib enum union",
+				end: "$|;",
+				illegal: /=/,
+				contains: [hljs.HASH_COMMENT_MODE, hljs.inherit(hljs.TITLE_MODE, { begin: CRYSTAL_PATH_RE })]
+			},
+			{
+				beginKeywords: "annotation",
+				end: "$|;",
+				illegal: /=/,
+				contains: [hljs.HASH_COMMENT_MODE, hljs.inherit(hljs.TITLE_MODE, { begin: CRYSTAL_PATH_RE })],
+				relevance: 2
+			},
+			{
+				className: "function",
+				beginKeywords: "def",
+				end: /\B\b/,
+				contains: [hljs.inherit(hljs.TITLE_MODE, {
+					begin: CRYSTAL_METHOD_RE,
+					endsParent: true
+				})]
+			},
+			{
+				className: "function",
+				beginKeywords: "fun macro",
+				end: /\B\b/,
+				contains: [hljs.inherit(hljs.TITLE_MODE, {
+					begin: CRYSTAL_METHOD_RE,
+					endsParent: true
+				})],
+				relevance: 2
+			},
+			{
+				className: "symbol",
+				begin: hljs.UNDERSCORE_IDENT_RE + "(!|\\?)?:",
+				relevance: 0
+			},
+			{
+				className: "symbol",
+				begin: ":",
+				contains: [STRING, { begin: CRYSTAL_METHOD_RE }],
+				relevance: 0
+			},
+			{
+				className: "number",
+				variants: [
+					{ begin: "\\b0b([01_]+)(_?[ui](8|16|32|64|128))?" },
+					{ begin: "\\b0o([0-7_]+)(_?[ui](8|16|32|64|128))?" },
+					{ begin: "\\b0x([A-Fa-f0-9_]+)(_?[ui](8|16|32|64|128))?" },
+					{ begin: "\\b([1-9][0-9_]*[0-9]|[0-9])(\\.[0-9][0-9_]*)?([eE]_?[-+]?[0-9_]*)?(_?f(32|64))?(?!_)" },
+					{ begin: "\\b([1-9][0-9_]*|0)(_?[ui](8|16|32|64|128))?" }
+				],
+				relevance: 0
+			}
+		];
+		SUBST.contains = CRYSTAL_DEFAULT_CONTAINS;
+		EXPANSION.contains = CRYSTAL_DEFAULT_CONTAINS.slice(1);
+		return {
+			name: "Crystal",
+			aliases: ["cr"],
+			keywords: CRYSTAL_KEYWORDS,
+			contains: CRYSTAL_DEFAULT_CONTAINS
+		};
+	}
+	module.exports = crystal;
+}));
+
+//#endregion
+export default require_crystal();

package/dist/crystal-Bvp6pk_w.js

@@ -0,0 +1,64 @@
+import ruby from "./ruby-B8TWD6ep.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/crystal.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+crystal.displayName = "crystal";
+crystal.aliases = [];
+/** @param {Refractor} Prism */
+function crystal(Prism) {
+	Prism.register(ruby);
+	(function(Prism) {
+		Prism.languages.crystal = Prism.languages.extend("ruby", {
+			keyword: [/\b(?:__DIR__|__END_LINE__|__FILE__|__LINE__|abstract|alias|annotation|as|asm|begin|break|case|class|def|do|else|elsif|end|ensure|enum|extend|for|fun|if|ifdef|include|instance_sizeof|lib|macro|module|next|of|out|pointerof|private|protected|ptr|require|rescue|return|select|self|sizeof|struct|super|then|type|typeof|undef|uninitialized|union|unless|until|when|while|with|yield)\b/, {
+				pattern: /(\.\s*)(?:is_a|responds_to)\?/,
+				lookbehind: true
+			}],
+			number: /\b(?:0b[01_]*[01]|0o[0-7_]*[0-7]|0x[\da-fA-F_]*[\da-fA-F]|(?:\d(?:[\d_]*\d)?)(?:\.[\d_]*\d)?(?:[eE][+-]?[\d_]*\d)?)(?:_(?:[uif](?:8|16|32|64))?)?\b/,
+			operator: [/->/, Prism.languages.ruby.operator],
+			punctuation: /[(){}[\].,;\\]/
+		});
+		Prism.languages.insertBefore("crystal", "string-literal", {
+			attribute: {
+				pattern: /@\[.*?\]/,
+				inside: {
+					delimiter: {
+						pattern: /^@\[|\]$/,
+						alias: "punctuation"
+					},
+					attribute: {
+						pattern: /^(\s*)\w+/,
+						lookbehind: true,
+						alias: "class-name"
+					},
+					args: {
+						pattern: /\S(?:[\s\S]*\S)?/,
+						inside: Prism.languages.crystal
+					}
+				}
+			},
+			expansion: {
+				pattern: /\{(?:\{.*?\}|%.*?%)\}/,
+				inside: {
+					content: {
+						pattern: /^(\{.)[\s\S]+(?=.\}$)/,
+						lookbehind: true,
+						inside: Prism.languages.crystal
+					},
+					delimiter: {
+						pattern: /^\{[\{%]|[\}%]\}$/,
+						alias: "operator"
+					}
+				}
+			},
+			char: {
+				pattern: /'(?:[^\\\r\n]{1,2}|\\(?:.|u(?:[A-Fa-f0-9]{1,4}|\{[A-Fa-f0-9]{1,6}\})))'/,
+				greedy: true
+			}
+		});
+	})(Prism);
+}
+
+//#endregion
+export { crystal as default };

package/dist/csharp-ha-Vb1Oy.js

@@ -0,0 +1,367 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/csharp.js
+var require_csharp = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type LanguageFn */
+	function csharp(hljs) {
+		const BUILT_IN_KEYWORDS = [
+			"bool",
+			"byte",
+			"char",
+			"decimal",
+			"delegate",
+			"double",
+			"dynamic",
+			"enum",
+			"float",
+			"int",
+			"long",
+			"nint",
+			"nuint",
+			"object",
+			"sbyte",
+			"short",
+			"string",
+			"ulong",
+			"uint",
+			"ushort"
+		];
+		const FUNCTION_MODIFIERS = [
+			"public",
+			"private",
+			"protected",
+			"static",
+			"internal",
+			"protected",
+			"abstract",
+			"async",
+			"extern",
+			"override",
+			"unsafe",
+			"virtual",
+			"new",
+			"sealed",
+			"partial"
+		];
+		const KEYWORDS = {
+			keyword: [
+				"abstract",
+				"as",
+				"base",
+				"break",
+				"case",
+				"class",
+				"const",
+				"continue",
+				"do",
+				"else",
+				"event",
+				"explicit",
+				"extern",
+				"finally",
+				"fixed",
+				"for",
+				"foreach",
+				"goto",
+				"if",
+				"implicit",
+				"in",
+				"interface",
+				"internal",
+				"is",
+				"lock",
+				"namespace",
+				"new",
+				"operator",
+				"out",
+				"override",
+				"params",
+				"private",
+				"protected",
+				"public",
+				"readonly",
+				"record",
+				"ref",
+				"return",
+				"sealed",
+				"sizeof",
+				"stackalloc",
+				"static",
+				"struct",
+				"switch",
+				"this",
+				"throw",
+				"try",
+				"typeof",
+				"unchecked",
+				"unsafe",
+				"using",
+				"virtual",
+				"void",
+				"volatile",
+				"while"
+			].concat([
+				"add",
+				"alias",
+				"and",
+				"ascending",
+				"async",
+				"await",
+				"by",
+				"descending",
+				"equals",
+				"from",
+				"get",
+				"global",
+				"group",
+				"init",
+				"into",
+				"join",
+				"let",
+				"nameof",
+				"not",
+				"notnull",
+				"on",
+				"or",
+				"orderby",
+				"partial",
+				"remove",
+				"select",
+				"set",
+				"unmanaged",
+				"value|0",
+				"var",
+				"when",
+				"where",
+				"with",
+				"yield"
+			]),
+			built_in: BUILT_IN_KEYWORDS,
+			literal: [
+				"default",
+				"false",
+				"null",
+				"true"
+			]
+		};
+		const TITLE_MODE = hljs.inherit(hljs.TITLE_MODE, { begin: "[a-zA-Z](\\.?\\w)*" });
+		const NUMBERS = {
+			className: "number",
+			variants: [
+				{ begin: "\\b(0b[01']+)" },
+				{ begin: "(-?)\\b([\\d']+(\\.[\\d']*)?|\\.[\\d']+)(u|U|l|L|ul|UL|f|F|b|B)" },
+				{ begin: "(-?)(\\b0[xX][a-fA-F0-9']+|(\\b[\\d']+(\\.[\\d']*)?|\\.[\\d']+)([eE][-+]?[\\d']+)?)" }
+			],
+			relevance: 0
+		};
+		const VERBATIM_STRING = {
+			className: "string",
+			begin: "@\"",
+			end: "\"",
+			contains: [{ begin: "\"\"" }]
+		};
+		const VERBATIM_STRING_NO_LF = hljs.inherit(VERBATIM_STRING, { illegal: /\n/ });
+		const SUBST = {
+			className: "subst",
+			begin: /\{/,
+			end: /\}/,
+			keywords: KEYWORDS
+		};
+		const SUBST_NO_LF = hljs.inherit(SUBST, { illegal: /\n/ });
+		const INTERPOLATED_STRING = {
+			className: "string",
+			begin: /\$"/,
+			end: "\"",
+			illegal: /\n/,
+			contains: [
+				{ begin: /\{\{/ },
+				{ begin: /\}\}/ },
+				hljs.BACKSLASH_ESCAPE,
+				SUBST_NO_LF
+			]
+		};
+		const INTERPOLATED_VERBATIM_STRING = {
+			className: "string",
+			begin: /\$@"/,
+			end: "\"",
+			contains: [
+				{ begin: /\{\{/ },
+				{ begin: /\}\}/ },
+				{ begin: "\"\"" },
+				SUBST
+			]
+		};
+		const INTERPOLATED_VERBATIM_STRING_NO_LF = hljs.inherit(INTERPOLATED_VERBATIM_STRING, {
+			illegal: /\n/,
+			contains: [
+				{ begin: /\{\{/ },
+				{ begin: /\}\}/ },
+				{ begin: "\"\"" },
+				SUBST_NO_LF
+			]
+		});
+		SUBST.contains = [
+			INTERPOLATED_VERBATIM_STRING,
+			INTERPOLATED_STRING,
+			VERBATIM_STRING,
+			hljs.APOS_STRING_MODE,
+			hljs.QUOTE_STRING_MODE,
+			NUMBERS,
+			hljs.C_BLOCK_COMMENT_MODE
+		];
+		SUBST_NO_LF.contains = [
+			INTERPOLATED_VERBATIM_STRING_NO_LF,
+			INTERPOLATED_STRING,
+			VERBATIM_STRING_NO_LF,
+			hljs.APOS_STRING_MODE,
+			hljs.QUOTE_STRING_MODE,
+			NUMBERS,
+			hljs.inherit(hljs.C_BLOCK_COMMENT_MODE, { illegal: /\n/ })
+		];
+		const STRING = { variants: [
+			INTERPOLATED_VERBATIM_STRING,
+			INTERPOLATED_STRING,
+			VERBATIM_STRING,
+			hljs.APOS_STRING_MODE,
+			hljs.QUOTE_STRING_MODE
+		] };
+		const GENERIC_MODIFIER = {
+			begin: "<",
+			end: ">",
+			contains: [{ beginKeywords: "in out" }, TITLE_MODE]
+		};
+		const TYPE_IDENT_RE = hljs.IDENT_RE + "(<" + hljs.IDENT_RE + "(\\s*,\\s*" + hljs.IDENT_RE + ")*>)?(\\[\\])?";
+		const AT_IDENTIFIER = {
+			begin: "@" + hljs.IDENT_RE,
+			relevance: 0
+		};
+		return {
+			name: "C#",
+			aliases: ["cs", "c#"],
+			keywords: KEYWORDS,
+			illegal: /::/,
+			contains: [
+				hljs.COMMENT("///", "$", {
+					returnBegin: true,
+					contains: [{
+						className: "doctag",
+						variants: [
+							{
+								begin: "///",
+								relevance: 0
+							},
+							{ begin: "<!--|-->" },
+							{
+								begin: "</?",
+								end: ">"
+							}
+						]
+					}]
+				}),
+				hljs.C_LINE_COMMENT_MODE,
+				hljs.C_BLOCK_COMMENT_MODE,
+				{
+					className: "meta",
+					begin: "#",
+					end: "$",
+					keywords: { "meta-keyword": "if else elif endif define undef warning error line region endregion pragma checksum" }
+				},
+				STRING,
+				NUMBERS,
+				{
+					beginKeywords: "class interface",
+					relevance: 0,
+					end: /[{;=]/,
+					illegal: /[^\s:,]/,
+					contains: [
+						{ beginKeywords: "where class" },
+						TITLE_MODE,
+						GENERIC_MODIFIER,
+						hljs.C_LINE_COMMENT_MODE,
+						hljs.C_BLOCK_COMMENT_MODE
+					]
+				},
+				{
+					beginKeywords: "namespace",
+					relevance: 0,
+					end: /[{;=]/,
+					illegal: /[^\s:]/,
+					contains: [
+						TITLE_MODE,
+						hljs.C_LINE_COMMENT_MODE,
+						hljs.C_BLOCK_COMMENT_MODE
+					]
+				},
+				{
+					beginKeywords: "record",
+					relevance: 0,
+					end: /[{;=]/,
+					illegal: /[^\s:]/,
+					contains: [
+						TITLE_MODE,
+						GENERIC_MODIFIER,
+						hljs.C_LINE_COMMENT_MODE,
+						hljs.C_BLOCK_COMMENT_MODE
+					]
+				},
+				{
+					className: "meta",
+					begin: "^\\s*\\[",
+					excludeBegin: true,
+					end: "\\]",
+					excludeEnd: true,
+					contains: [{
+						className: "meta-string",
+						begin: /"/,
+						end: /"/
+					}]
+				},
+				{
+					beginKeywords: "new return throw await else",
+					relevance: 0
+				},
+				{
+					className: "function",
+					begin: "(" + TYPE_IDENT_RE + "\\s+)+" + hljs.IDENT_RE + "\\s*(<.+>\\s*)?\\(",
+					returnBegin: true,
+					end: /\s*[{;=]/,
+					excludeEnd: true,
+					keywords: KEYWORDS,
+					contains: [
+						{
+							beginKeywords: FUNCTION_MODIFIERS.join(" "),
+							relevance: 0
+						},
+						{
+							begin: hljs.IDENT_RE + "\\s*(<.+>\\s*)?\\(",
+							returnBegin: true,
+							contains: [hljs.TITLE_MODE, GENERIC_MODIFIER],
+							relevance: 0
+						},
+						{
+							className: "params",
+							begin: /\(/,
+							end: /\)/,
+							excludeBegin: true,
+							excludeEnd: true,
+							keywords: KEYWORDS,
+							relevance: 0,
+							contains: [
+								STRING,
+								NUMBERS,
+								hljs.C_BLOCK_COMMENT_MODE
+							]
+						},
+						hljs.C_LINE_COMMENT_MODE,
+						hljs.C_BLOCK_COMMENT_MODE
+					]
+				},
+				AT_IDENTIFIER
+			]
+		};
+	}
+	module.exports = csharp;
+}));
+
+//#endregion
+export default require_csharp();