@webskill/chatbot 0.0.1

package/dist/gradle-BD0xP8L2.js

@@ -0,0 +1,66 @@
+import { t as clike } from "./clike-BvmU1AL7.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/gradle.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+gradle.displayName = "gradle";
+gradle.aliases = [];
+/** @param {Refractor} Prism */
+function gradle(Prism) {
+	Prism.register(clike);
+	(function(Prism) {
+		var interpolation = {
+			pattern: /((?:^|[^\\$])(?:\\{2})*)\$(?:\w+|\{[^{}]*\})/,
+			lookbehind: true,
+			inside: {
+				"interpolation-punctuation": {
+					pattern: /^\$\{?|\}$/,
+					alias: "punctuation"
+				},
+				expression: {
+					pattern: /[\s\S]+/,
+					inside: null
+				}
+			}
+		};
+		Prism.languages.gradle = Prism.languages.extend("clike", {
+			string: {
+				pattern: /'''(?:[^\\]|\\[\s\S])*?'''|'(?:\\.|[^\\'\r\n])*'/,
+				greedy: true
+			},
+			keyword: /\b(?:apply|def|dependencies|else|if|implementation|import|plugin|plugins|project|repositories|repository|sourceSets|tasks|val)\b/,
+			number: /\b(?:0b[01_]+|0x[\da-f_]+(?:\.[\da-f_p\-]+)?|[\d_]+(?:\.[\d_]+)?(?:e[+-]?\d+)?)[glidf]?\b/i,
+			operator: {
+				pattern: /(^|[^.])(?:~|==?~?|\?[.:]?|\*(?:[.=]|\*=?)?|\.[@&]|\.\.<|\.\.(?!\.)|-[-=>]?|\+[+=]?|!=?|<(?:<=?|=>?)?|>(?:>>?=?|=)?|&[&=]?|\|[|=]?|\/=?|\^=?|%=?)/,
+				lookbehind: true
+			},
+			punctuation: /\.+|[{}[\];(),:$]/
+		});
+		Prism.languages.insertBefore("gradle", "string", {
+			shebang: {
+				pattern: /#!.+/,
+				alias: "comment",
+				greedy: true
+			},
+			"interpolation-string": {
+				pattern: /"""(?:[^\\]|\\[\s\S])*?"""|(["/])(?:\\.|(?!\1)[^\\\r\n])*\1|\$\/(?:[^/$]|\$(?:[/$]|(?![/$]))|\/(?!\$))*\/\$/,
+				greedy: true,
+				inside: {
+					interpolation,
+					string: /[\s\S]+/
+				}
+			}
+		});
+		Prism.languages.insertBefore("gradle", "punctuation", { "spock-block": /\b(?:and|cleanup|expect|given|setup|then|when|where):/ });
+		Prism.languages.insertBefore("gradle", "function", { annotation: {
+			pattern: /(^|[^.])@\w+/,
+			lookbehind: true,
+			alias: "punctuation"
+		} });
+		interpolation.inside.expression.inside = Prism.languages.gradle;
+	})(Prism);
+}
+
+//#endregion
+export { gradle as default };

package/dist/gradle-BvJEPLCP.js

@@ -0,0 +1,24 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/gradle.js
+var require_gradle = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function gradle(hljs) {
+		return {
+			name: "Gradle",
+			case_insensitive: true,
+			keywords: { keyword: "task project allprojects subprojects artifacts buildscript configurations dependencies repositories sourceSets description delete from into include exclude source classpath destinationDir includes options sourceCompatibility targetCompatibility group flatDir doLast doFirst flatten todir fromdir ant def abstract break case catch continue default do else extends final finally for if implements instanceof native new private protected public return static switch synchronized throw throws transient try volatile while strictfp package import false null super this true antlrtask checkstyle codenarc copy boolean byte char class double float int interface long short void compile runTime file fileTree abs any append asList asWritable call collect compareTo count div dump each eachByte eachFile eachLine every find findAll flatten getAt getErr getIn getOut getText grep immutable inject inspect intersect invokeMethods isCase join leftShift minus multiply newInputStream newOutputStream newPrintWriter newReader newWriter next plus pop power previous print println push putAt read readBytes readLines reverse reverseEach round size sort splitEachLine step subMap times toInteger toList tokenize upto waitForOrKill withPrintWriter withReader withStream withWriter withWriterAppend write writeLine" },
+			contains: [
+				hljs.C_LINE_COMMENT_MODE,
+				hljs.C_BLOCK_COMMENT_MODE,
+				hljs.APOS_STRING_MODE,
+				hljs.QUOTE_STRING_MODE,
+				hljs.NUMBER_MODE,
+				hljs.REGEXP_MODE
+			]
+		};
+	}
+	module.exports = gradle;
+}));
+
+//#endregion
+export default require_gradle();

package/dist/graphql-C9JoiNGl.js

@@ -0,0 +1,178 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/graphql.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+graphql.displayName = "graphql";
+graphql.aliases = [];
+/** @param {Refractor} Prism */
+function graphql(Prism) {
+	Prism.languages.graphql = {
+		comment: /#.*/,
+		description: {
+			pattern: /(?:"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*")(?=\s*[a-z_])/i,
+			greedy: true,
+			alias: "string",
+			inside: { "language-markdown": {
+				pattern: /(^"(?:"")?)(?!\1)[\s\S]+(?=\1$)/,
+				lookbehind: true,
+				inside: Prism.languages.markdown
+			} }
+		},
+		string: {
+			pattern: /"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*"/,
+			greedy: true
+		},
+		number: /(?:\B-|\b)\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+		boolean: /\b(?:false|true)\b/,
+		variable: /\$[a-z_]\w*/i,
+		directive: {
+			pattern: /@[a-z_]\w*/i,
+			alias: "function"
+		},
+		"attr-name": {
+			pattern: /\b[a-z_]\w*(?=\s*(?:\((?:[^()"]|"(?:\\.|[^\\"\r\n])*")*\))?:)/i,
+			greedy: true
+		},
+		"atom-input": {
+			pattern: /\b[A-Z]\w*Input\b/,
+			alias: "class-name"
+		},
+		scalar: /\b(?:Boolean|Float|ID|Int|String)\b/,
+		constant: /\b[A-Z][A-Z_\d]*\b/,
+		"class-name": {
+			pattern: /(\b(?:enum|implements|interface|on|scalar|type|union)\s+|&\s*|:\s*|\[)[A-Z_]\w*/,
+			lookbehind: true
+		},
+		fragment: {
+			pattern: /(\bfragment\s+|\.{3}\s*(?!on\b))[a-zA-Z_]\w*/,
+			lookbehind: true,
+			alias: "function"
+		},
+		"definition-mutation": {
+			pattern: /(\bmutation\s+)[a-zA-Z_]\w*/,
+			lookbehind: true,
+			alias: "function"
+		},
+		"definition-query": {
+			pattern: /(\bquery\s+)[a-zA-Z_]\w*/,
+			lookbehind: true,
+			alias: "function"
+		},
+		keyword: /\b(?:directive|enum|extend|fragment|implements|input|interface|mutation|on|query|repeatable|scalar|schema|subscription|type|union)\b/,
+		operator: /[!=|&]|\.{3}/,
+		"property-query": /\w+(?=\s*\()/,
+		object: /\w+(?=\s*\{)/,
+		punctuation: /[!(){}\[\]:=,]/,
+		property: /\w+/
+	};
+	Prism.hooks.add("after-tokenize", function afterTokenizeGraphql(env) {
+		if (env.language !== "graphql") return;
+		/**
+		* get the graphql token stream that we want to customize
+		*
+		* @typedef {InstanceType<import("./prism-core")["Token"]>} Token
+		* @type {Token[]}
+		*/
+		var validTokens = env.tokens.filter(function(token) {
+			return typeof token !== "string" && token.type !== "comment" && token.type !== "scalar";
+		});
+		var currentIndex = 0;
+		/**
+		* Returns whether the token relative to the current index has the given type.
+		*
+		* @param {number} offset
+		* @returns {Token | undefined}
+		*/
+		function getToken(offset) {
+			return validTokens[currentIndex + offset];
+		}
+		/**
+		* Returns whether the token relative to the current index has the given type.
+		*
+		* @param {readonly string[]} types
+		* @param {number} [offset=0]
+		* @returns {boolean}
+		*/
+		function isTokenType(types, offset) {
+			offset = offset || 0;
+			for (var i = 0; i < types.length; i++) {
+				var token = getToken(i + offset);
+				if (!token || token.type !== types[i]) return false;
+			}
+			return true;
+		}
+		/**
+		* Returns the index of the closing bracket to an opening bracket.
+		*
+		* It is assumed that `token[currentIndex - 1]` is an opening bracket.
+		*
+		* If no closing bracket could be found, `-1` will be returned.
+		*
+		* @param {RegExp} open
+		* @param {RegExp} close
+		* @returns {number}
+		*/
+		function findClosingBracket(open, close) {
+			var stackHeight = 1;
+			for (var i = currentIndex; i < validTokens.length; i++) {
+				var token = validTokens[i];
+				var content = token.content;
+				if (token.type === "punctuation" && typeof content === "string") {
+					if (open.test(content)) stackHeight++;
+					else if (close.test(content)) {
+						stackHeight--;
+						if (stackHeight === 0) return i;
+					}
+				}
+			}
+			return -1;
+		}
+		/**
+		* Adds an alias to the given token.
+		*
+		* @param {Token} token
+		* @param {string} alias
+		* @returns {void}
+		*/
+		function addAlias(token, alias) {
+			var aliases = token.alias;
+			if (!aliases) token.alias = aliases = [];
+			else if (!Array.isArray(aliases)) token.alias = aliases = [aliases];
+			aliases.push(alias);
+		}
+		for (; currentIndex < validTokens.length;) {
+			var startToken = validTokens[currentIndex++];
+			if (startToken.type === "keyword" && startToken.content === "mutation") {
+				var inputVariables = [];
+				if (isTokenType(["definition-mutation", "punctuation"]) && getToken(1).content === "(") {
+					currentIndex += 2;
+					var definitionEnd = findClosingBracket(/^\($/, /^\)$/);
+					if (definitionEnd === -1) continue;
+					for (; currentIndex < definitionEnd; currentIndex++) {
+						var t = getToken(0);
+						if (t.type === "variable") {
+							addAlias(t, "variable-input");
+							inputVariables.push(t.content);
+						}
+					}
+					currentIndex = definitionEnd + 1;
+				}
+				if (isTokenType(["punctuation", "property-query"]) && getToken(0).content === "{") {
+					currentIndex++;
+					addAlias(getToken(0), "property-mutation");
+					if (inputVariables.length > 0) {
+						var mutationEnd = findClosingBracket(/^\{$/, /^\}$/);
+						if (mutationEnd === -1) continue;
+						for (var i = currentIndex; i < mutationEnd; i++) {
+							var varToken = validTokens[i];
+							if (varToken.type === "variable" && inputVariables.indexOf(varToken.content) >= 0) addAlias(varToken, "variable-input");
+						}
+					}
+				}
+			}
+		}
+	});
+}
+
+//#endregion
+export { graphql as default };

package/dist/groovy-BDKJCVqJ.js

@@ -0,0 +1,134 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/groovy.js
+var require_groovy = /* @__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 } re
+	* @returns {string}
+	*/
+	function lookahead(re) {
+		return concat("(?=", re, ")");
+	}
+	/**
+	* @param {...(RegExp | string) } args
+	* @returns {string}
+	*/
+	function concat(...args) {
+		return args.map((x) => source(x)).join("");
+	}
+	function variants(variants, obj = {}) {
+		obj.variants = variants;
+		return obj;
+	}
+	function groovy(hljs) {
+		const COMMENT = variants([
+			hljs.C_LINE_COMMENT_MODE,
+			hljs.C_BLOCK_COMMENT_MODE,
+			hljs.COMMENT("/\\*\\*", "\\*/", {
+				relevance: 0,
+				contains: [{
+					begin: /\w+@/,
+					relevance: 0
+				}, {
+					className: "doctag",
+					begin: "@[A-Za-z]+"
+				}]
+			})
+		]);
+		const REGEXP = {
+			className: "regexp",
+			begin: /~?\/[^\/\n]+\//,
+			contains: [hljs.BACKSLASH_ESCAPE]
+		};
+		const NUMBER = variants([hljs.BINARY_NUMBER_MODE, hljs.C_NUMBER_MODE]);
+		const STRING = variants([
+			{
+				begin: /"""/,
+				end: /"""/
+			},
+			{
+				begin: /'''/,
+				end: /'''/
+			},
+			{
+				begin: "\\$/",
+				end: "/\\$",
+				relevance: 10
+			},
+			hljs.APOS_STRING_MODE,
+			hljs.QUOTE_STRING_MODE
+		], { className: "string" });
+		return {
+			name: "Groovy",
+			keywords: {
+				built_in: "this super",
+				literal: "true false null",
+				keyword: "byte short char int long boolean float double void def as in assert trait abstract static volatile transient public private protected synchronized final class interface enum if else for while switch case break default continue throw throws try catch finally implements extends new import package return instanceof"
+			},
+			contains: [
+				hljs.SHEBANG({
+					binary: "groovy",
+					relevance: 10
+				}),
+				COMMENT,
+				STRING,
+				REGEXP,
+				NUMBER,
+				{
+					className: "class",
+					beginKeywords: "class interface trait enum",
+					end: /\{/,
+					illegal: ":",
+					contains: [{ beginKeywords: "extends implements" }, hljs.UNDERSCORE_TITLE_MODE]
+				},
+				{
+					className: "meta",
+					begin: "@[A-Za-z]+",
+					relevance: 0
+				},
+				{
+					className: "attr",
+					begin: "[A-Za-z0-9_$]+[ 	]*:",
+					relevance: 0
+				},
+				{
+					begin: /\?/,
+					end: /:/,
+					relevance: 0,
+					contains: [
+						COMMENT,
+						STRING,
+						REGEXP,
+						NUMBER,
+						"self"
+					]
+				},
+				{
+					className: "symbol",
+					begin: "^[ 	]*" + lookahead("[A-Za-z0-9_$]+:"),
+					excludeBegin: true,
+					end: "[A-Za-z0-9_$]+:",
+					relevance: 0
+				}
+			],
+			illegal: /#|<\//
+		};
+	}
+	module.exports = groovy;
+}));
+
+//#endregion
+export default require_groovy();

package/dist/groovy-C9IvQhOU.js

@@ -0,0 +1,66 @@
+import { t as clike } from "./clike-BvmU1AL7.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/groovy.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+groovy.displayName = "groovy";
+groovy.aliases = [];
+/** @param {Refractor} Prism */
+function groovy(Prism) {
+	Prism.register(clike);
+	(function(Prism) {
+		var interpolation = {
+			pattern: /((?:^|[^\\$])(?:\\{2})*)\$(?:\w+|\{[^{}]*\})/,
+			lookbehind: true,
+			inside: {
+				"interpolation-punctuation": {
+					pattern: /^\$\{?|\}$/,
+					alias: "punctuation"
+				},
+				expression: {
+					pattern: /[\s\S]+/,
+					inside: null
+				}
+			}
+		};
+		Prism.languages.groovy = Prism.languages.extend("clike", {
+			string: {
+				pattern: /'''(?:[^\\]|\\[\s\S])*?'''|'(?:\\.|[^\\'\r\n])*'/,
+				greedy: true
+			},
+			keyword: /\b(?:abstract|as|assert|boolean|break|byte|case|catch|char|class|const|continue|def|default|do|double|else|enum|extends|final|finally|float|for|goto|if|implements|import|in|instanceof|int|interface|long|native|new|package|private|protected|public|return|short|static|strictfp|super|switch|synchronized|this|throw|throws|trait|transient|try|void|volatile|while)\b/,
+			number: /\b(?:0b[01_]+|0x[\da-f_]+(?:\.[\da-f_p\-]+)?|[\d_]+(?:\.[\d_]+)?(?:e[+-]?\d+)?)[glidf]?\b/i,
+			operator: {
+				pattern: /(^|[^.])(?:~|==?~?|\?[.:]?|\*(?:[.=]|\*=?)?|\.[@&]|\.\.<|\.\.(?!\.)|-[-=>]?|\+[+=]?|!=?|<(?:<=?|=>?)?|>(?:>>?=?|=)?|&[&=]?|\|[|=]?|\/=?|\^=?|%=?)/,
+				lookbehind: true
+			},
+			punctuation: /\.+|[{}[\];(),:$]/
+		});
+		Prism.languages.insertBefore("groovy", "string", {
+			shebang: {
+				pattern: /#!.+/,
+				alias: "comment",
+				greedy: true
+			},
+			"interpolation-string": {
+				pattern: /"""(?:[^\\]|\\[\s\S])*?"""|(["/])(?:\\.|(?!\1)[^\\\r\n])*\1|\$\/(?:[^/$]|\$(?:[/$]|(?![/$]))|\/(?!\$))*\/\$/,
+				greedy: true,
+				inside: {
+					interpolation,
+					string: /[\s\S]+/
+				}
+			}
+		});
+		Prism.languages.insertBefore("groovy", "punctuation", { "spock-block": /\b(?:and|cleanup|expect|given|setup|then|when|where):/ });
+		Prism.languages.insertBefore("groovy", "function", { annotation: {
+			pattern: /(^|[^.])@\w+/,
+			lookbehind: true,
+			alias: "punctuation"
+		} });
+		interpolation.inside.expression.inside = Prism.languages.groovy;
+	})(Prism);
+}
+
+//#endregion
+export { groovy as default };

package/dist/haml-Bl-0saj7.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/haml.js
+var require_haml = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function haml(hljs) {
+		return {
+			name: "HAML",
+			case_insensitive: true,
+			contains: [
+				{
+					className: "meta",
+					begin: "^!!!( (5|1\\.1|Strict|Frameset|Basic|Mobile|RDFa|XML\\b.*))?$",
+					relevance: 10
+				},
+				hljs.COMMENT("^\\s*(!=#|=#|-#|/).*$", false, { relevance: 0 }),
+				{
+					begin: "^\\s*(-|=|!=)(?!#)",
+					starts: {
+						end: "\\n",
+						subLanguage: "ruby"
+					}
+				},
+				{
+					className: "tag",
+					begin: "^\\s*%",
+					contains: [
+						{
+							className: "selector-tag",
+							begin: "\\w+"
+						},
+						{
+							className: "selector-id",
+							begin: "#[\\w-]+"
+						},
+						{
+							className: "selector-class",
+							begin: "\\.[\\w-]+"
+						},
+						{
+							begin: /\{\s*/,
+							end: /\s*\}/,
+							contains: [{
+								begin: ":\\w+\\s*=>",
+								end: ",\\s+",
+								returnBegin: true,
+								endsWithParent: true,
+								contains: [
+									{
+										className: "attr",
+										begin: ":\\w+"
+									},
+									hljs.APOS_STRING_MODE,
+									hljs.QUOTE_STRING_MODE,
+									{
+										begin: "\\w+",
+										relevance: 0
+									}
+								]
+							}]
+						},
+						{
+							begin: "\\(\\s*",
+							end: "\\s*\\)",
+							excludeEnd: true,
+							contains: [{
+								begin: "\\w+\\s*=",
+								end: "\\s+",
+								returnBegin: true,
+								endsWithParent: true,
+								contains: [
+									{
+										className: "attr",
+										begin: "\\w+",
+										relevance: 0
+									},
+									hljs.APOS_STRING_MODE,
+									hljs.QUOTE_STRING_MODE,
+									{
+										begin: "\\w+",
+										relevance: 0
+									}
+								]
+							}]
+						}
+					]
+				},
+				{ begin: "^\\s*[=~]\\s*" },
+				{
+					begin: /#\{/,
+					starts: {
+						end: /\}/,
+						subLanguage: "ruby"
+					}
+				}
+			]
+		};
+	}
+	module.exports = haml;
+}));
+
+//#endregion
+export default require_haml();