@webskill/chatbot 0.0.1

package/dist/elixir-DgMJkXsA.js

@@ -0,0 +1,223 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/elixir.js
+var require_elixir = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type LanguageFn */
+	function elixir(hljs) {
+		const ELIXIR_IDENT_RE = "[a-zA-Z_][a-zA-Z0-9_.]*(!|\\?)?";
+		const ELIXIR_METHOD_RE = "[a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|=~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~`|]|\\[\\]=?";
+		const ELIXIR_KEYWORDS = {
+			$pattern: ELIXIR_IDENT_RE,
+			keyword: "and false then defined module in return redo retry end for true self when next until do begin unless nil break not case cond alias while ensure or include use alias fn quote require import with|0"
+		};
+		const SUBST = {
+			className: "subst",
+			begin: /#\{/,
+			end: /\}/,
+			keywords: ELIXIR_KEYWORDS
+		};
+		const NUMBER = {
+			className: "number",
+			begin: "(\\b0o[0-7_]+)|(\\b0b[01_]+)|(\\b0x[0-9a-fA-F_]+)|(-?\\b[1-9][0-9_]*(\\.[0-9_]+([eE][-+]?[0-9]+)?)?)",
+			relevance: 0
+		};
+		const LOWERCASE_SIGIL = {
+			className: "string",
+			begin: "~[a-z](?=[/|([{<\"'])",
+			contains: [{
+				endsParent: true,
+				contains: [{
+					contains: [hljs.BACKSLASH_ESCAPE, SUBST],
+					variants: [
+						{
+							begin: /"/,
+							end: /"/
+						},
+						{
+							begin: /'/,
+							end: /'/
+						},
+						{
+							begin: /\//,
+							end: /\//
+						},
+						{
+							begin: /\|/,
+							end: /\|/
+						},
+						{
+							begin: /\(/,
+							end: /\)/
+						},
+						{
+							begin: /\[/,
+							end: /\]/
+						},
+						{
+							begin: /\{/,
+							end: /\}/
+						},
+						{
+							begin: /</,
+							end: />/
+						}
+					]
+				}]
+			}]
+		};
+		const UPCASE_SIGIL = {
+			className: "string",
+			begin: "~[A-Z](?=[/|([{<\"'])",
+			contains: [
+				{
+					begin: /"/,
+					end: /"/
+				},
+				{
+					begin: /'/,
+					end: /'/
+				},
+				{
+					begin: /\//,
+					end: /\//
+				},
+				{
+					begin: /\|/,
+					end: /\|/
+				},
+				{
+					begin: /\(/,
+					end: /\)/
+				},
+				{
+					begin: /\[/,
+					end: /\]/
+				},
+				{
+					begin: /\{/,
+					end: /\}/
+				},
+				{
+					begin: /</,
+					end: />/
+				}
+			]
+		};
+		const STRING = {
+			className: "string",
+			contains: [hljs.BACKSLASH_ESCAPE, SUBST],
+			variants: [
+				{
+					begin: /"""/,
+					end: /"""/
+				},
+				{
+					begin: /'''/,
+					end: /'''/
+				},
+				{
+					begin: /~S"""/,
+					end: /"""/,
+					contains: []
+				},
+				{
+					begin: /~S"/,
+					end: /"/,
+					contains: []
+				},
+				{
+					begin: /~S'''/,
+					end: /'''/,
+					contains: []
+				},
+				{
+					begin: /~S'/,
+					end: /'/,
+					contains: []
+				},
+				{
+					begin: /'/,
+					end: /'/
+				},
+				{
+					begin: /"/,
+					end: /"/
+				}
+			]
+		};
+		const FUNCTION = {
+			className: "function",
+			beginKeywords: "def defp defmacro",
+			end: /\B\b/,
+			contains: [hljs.inherit(hljs.TITLE_MODE, {
+				begin: ELIXIR_IDENT_RE,
+				endsParent: true
+			})]
+		};
+		const CLASS = hljs.inherit(FUNCTION, {
+			className: "class",
+			beginKeywords: "defimpl defmodule defprotocol defrecord",
+			end: /\bdo\b|$|;/
+		});
+		const ELIXIR_DEFAULT_CONTAINS = [
+			STRING,
+			UPCASE_SIGIL,
+			LOWERCASE_SIGIL,
+			hljs.HASH_COMMENT_MODE,
+			CLASS,
+			FUNCTION,
+			{ begin: "::" },
+			{
+				className: "symbol",
+				begin: ":(?![\\s:])",
+				contains: [STRING, { begin: ELIXIR_METHOD_RE }],
+				relevance: 0
+			},
+			{
+				className: "symbol",
+				begin: "[a-zA-Z_][a-zA-Z0-9_.]*(!|\\?)?:(?!:)",
+				relevance: 0
+			},
+			NUMBER,
+			{
+				className: "variable",
+				begin: "(\\$\\W)|((\\$|@@?)(\\w+))"
+			},
+			{ begin: "->" },
+			{
+				begin: "(" + hljs.RE_STARTERS_RE + ")\\s*",
+				contains: [
+					hljs.HASH_COMMENT_MODE,
+					{
+						begin: /\/: (?=\d+\s*[,\]])/,
+						relevance: 0,
+						contains: [NUMBER]
+					},
+					{
+						className: "regexp",
+						illegal: "\\n",
+						contains: [hljs.BACKSLASH_ESCAPE, SUBST],
+						variants: [{
+							begin: "/",
+							end: "/[a-z]*"
+						}, {
+							begin: "%r\\[",
+							end: "\\][a-z]*"
+						}]
+					}
+				],
+				relevance: 0
+			}
+		];
+		SUBST.contains = ELIXIR_DEFAULT_CONTAINS;
+		return {
+			name: "Elixir",
+			keywords: ELIXIR_KEYWORDS,
+			contains: ELIXIR_DEFAULT_CONTAINS
+		};
+	}
+	module.exports = elixir;
+}));
+
+//#endregion
+export default require_elixir();

package/dist/elm-B74Bk5cn.js

@@ -0,0 +1,38 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/elm.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+elm.displayName = "elm";
+elm.aliases = [];
+/** @param {Refractor} Prism */
+function elm(Prism) {
+	Prism.languages.elm = {
+		comment: /--.*|\{-[\s\S]*?-\}/,
+		char: {
+			pattern: /'(?:[^\\'\r\n]|\\(?:[abfnrtv\\']|\d+|x[0-9a-fA-F]+|u\{[0-9a-fA-F]+\}))'/,
+			greedy: true
+		},
+		string: [{
+			pattern: /"""[\s\S]*?"""/,
+			greedy: true
+		}, {
+			pattern: /"(?:[^\\"\r\n]|\\.)*"/,
+			greedy: true
+		}],
+		"import-statement": {
+			pattern: /(^[\t ]*)import\s+[A-Z]\w*(?:\.[A-Z]\w*)*(?:\s+as\s+(?:[A-Z]\w*)(?:\.[A-Z]\w*)*)?(?:\s+exposing\s+)?/m,
+			lookbehind: true,
+			inside: { keyword: /\b(?:as|exposing|import)\b/ }
+		},
+		keyword: /\b(?:alias|as|case|else|exposing|if|in|infixl|infixr|let|module|of|then|type)\b/,
+		builtin: /\b(?:abs|acos|always|asin|atan|atan2|ceiling|clamp|compare|cos|curry|degrees|e|flip|floor|fromPolar|identity|isInfinite|isNaN|logBase|max|min|negate|never|not|pi|radians|rem|round|sin|sqrt|tan|toFloat|toPolar|toString|truncate|turns|uncurry|xor)\b/,
+		number: /\b(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?|0x[0-9a-f]+)\b/i,
+		operator: /\s\.\s|[+\-/*=.$<>:&|^?%#@~!]{2,}|[+\-/*=$<>:&|^?%#@~!]/,
+		hvariable: /\b(?:[A-Z]\w*\.)*[a-z]\w*\b/,
+		constant: /\b(?:[A-Z]\w*\.)*[A-Z]\w*\b/,
+		punctuation: /[{}[\]|(),.:]/
+	};
+}
+
+//#endregion
+export { elm as default };

package/dist/elm-DDVumTG7.js

@@ -0,0 +1,87 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/elm.js
+var require_elm = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type LanguageFn */
+	function elm(hljs) {
+		const COMMENT = { variants: [hljs.COMMENT("--", "$"), hljs.COMMENT(/\{-/, /-\}/, { contains: ["self"] })] };
+		const CONSTRUCTOR = {
+			className: "type",
+			begin: "\\b[A-Z][\\w']*",
+			relevance: 0
+		};
+		const LIST = {
+			begin: "\\(",
+			end: "\\)",
+			illegal: "\"",
+			contains: [{
+				className: "type",
+				begin: "\\b[A-Z][\\w]*(\\((\\.\\.|,|\\w+)\\))?"
+			}, COMMENT]
+		};
+		const RECORD = {
+			begin: /\{/,
+			end: /\}/,
+			contains: LIST.contains
+		};
+		return {
+			name: "Elm",
+			keywords: "let in if then else case of where module import exposing type alias as infix infixl infixr port effect command subscription",
+			contains: [
+				{
+					beginKeywords: "port effect module",
+					end: "exposing",
+					keywords: "port effect module where command subscription exposing",
+					contains: [LIST, COMMENT],
+					illegal: "\\W\\.|;"
+				},
+				{
+					begin: "import",
+					end: "$",
+					keywords: "import as exposing",
+					contains: [LIST, COMMENT],
+					illegal: "\\W\\.|;"
+				},
+				{
+					begin: "type",
+					end: "$",
+					keywords: "type alias",
+					contains: [
+						CONSTRUCTOR,
+						LIST,
+						RECORD,
+						COMMENT
+					]
+				},
+				{
+					beginKeywords: "infix infixl infixr",
+					end: "$",
+					contains: [hljs.C_NUMBER_MODE, COMMENT]
+				},
+				{
+					begin: "port",
+					end: "$",
+					keywords: "port",
+					contains: [COMMENT]
+				},
+				{
+					className: "string",
+					begin: "'\\\\?.",
+					end: "'",
+					illegal: "."
+				},
+				hljs.QUOTE_STRING_MODE,
+				hljs.C_NUMBER_MODE,
+				CONSTRUCTOR,
+				hljs.inherit(hljs.TITLE_MODE, { begin: "^[_a-z][\\w']*" }),
+				COMMENT,
+				{ begin: "->|<-" }
+			],
+			illegal: /;/
+		};
+	}
+	module.exports = elm;
+}));
+
+//#endregion
+export default require_elm();

package/dist/erb-BkIFRb4T.js

@@ -0,0 +1,37 @@
+import ruby from "./ruby-B8TWD6ep.js";
+import { t as markupTemplating } from "./markup-templating-Ds-CZFSA.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/erb.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+erb.displayName = "erb";
+erb.aliases = [];
+/** @param {Refractor} Prism */
+function erb(Prism) {
+	Prism.register(markupTemplating);
+	Prism.register(ruby);
+	(function(Prism) {
+		Prism.languages.erb = {
+			delimiter: {
+				pattern: /^(\s*)<%=?|%>(?=\s*$)/,
+				lookbehind: true,
+				alias: "punctuation"
+			},
+			ruby: {
+				pattern: /\s*\S[\s\S]*/,
+				alias: "language-ruby",
+				inside: Prism.languages.ruby
+			}
+		};
+		Prism.hooks.add("before-tokenize", function(env) {
+			Prism.languages["markup-templating"].buildPlaceholders(env, "erb", /<%=?(?:[^\r\n]|[\r\n](?!=begin)|[\r\n]=begin\s(?:[^\r\n]|[\r\n](?!=end))*[\r\n]=end)+?%>/g);
+		});
+		Prism.hooks.add("after-tokenize", function(env) {
+			Prism.languages["markup-templating"].tokenizePlaceholders(env, "erb");
+		});
+	})(Prism);
+}
+
+//#endregion
+export { erb as default };

package/dist/erb-CTt4UcM1.js

@@ -0,0 +1,23 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/erb.js
+var require_erb = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type LanguageFn */
+	function erb(hljs) {
+		return {
+			name: "ERB",
+			subLanguage: "xml",
+			contains: [hljs.COMMENT("<%#", "%>"), {
+				begin: "<%[%=-]?",
+				end: "[%-]?%>",
+				subLanguage: "ruby",
+				excludeBegin: true,
+				excludeEnd: true
+			}]
+		};
+	}
+	module.exports = erb;
+}));
+
+//#endregion
+export default require_erb();

package/dist/erlang-3FNJE57q.js

@@ -0,0 +1,52 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/erlang.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+erlang.displayName = "erlang";
+erlang.aliases = [];
+/** @param {Refractor} Prism */
+function erlang(Prism) {
+	Prism.languages.erlang = {
+		comment: /%.+/,
+		string: {
+			pattern: /"(?:\\.|[^\\"\r\n])*"/,
+			greedy: true
+		},
+		"quoted-function": {
+			pattern: /'(?:\\.|[^\\'\r\n])+'(?=\()/,
+			alias: "function"
+		},
+		"quoted-atom": {
+			pattern: /'(?:\\.|[^\\'\r\n])+'/,
+			alias: "atom"
+		},
+		boolean: /\b(?:false|true)\b/,
+		keyword: /\b(?:after|begin|case|catch|end|fun|if|of|receive|try|when)\b/,
+		number: [
+			/\$\\?./,
+			/\b\d+#[a-z0-9]+/i,
+			/(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i
+		],
+		function: /\b[a-z][\w@]*(?=\()/,
+		variable: {
+			pattern: /(^|[^@])(?:\b|\?)[A-Z_][\w@]*/,
+			lookbehind: true
+		},
+		operator: [
+			/[=\/<>:]=|=[:\/]=|\+\+?|--?|[=*\/!]|\b(?:and|andalso|band|bnot|bor|bsl|bsr|bxor|div|not|or|orelse|rem|xor)\b/,
+			{
+				pattern: /(^|[^<])<(?!<)/,
+				lookbehind: true
+			},
+			{
+				pattern: /(^|[^>])>(?!>)/,
+				lookbehind: true
+			}
+		],
+		atom: /\b[a-z][\w@]*/,
+		punctuation: /[()[\]{}:;,.#|]|<<|>>/
+	};
+}
+
+//#endregion
+export { erlang as default };

package/dist/erlang-C58xuYIJ.js

@@ -0,0 +1,170 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/erlang.js
+var require_erlang = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type LanguageFn */
+	function erlang(hljs) {
+		const BASIC_ATOM_RE = "[a-z'][a-zA-Z0-9_']*";
+		const FUNCTION_NAME_RE = "([a-z'][a-zA-Z0-9_']*:[a-z'][a-zA-Z0-9_']*|[a-z'][a-zA-Z0-9_']*)";
+		const ERLANG_RESERVED = {
+			keyword: "after and andalso|10 band begin bnot bor bsl bzr bxor case catch cond div end fun if let not of orelse|10 query receive rem try when xor",
+			literal: "false true"
+		};
+		const COMMENT = hljs.COMMENT("%", "$");
+		const NUMBER = {
+			className: "number",
+			begin: "\\b(\\d+(_\\d+)*#[a-fA-F0-9]+(_[a-fA-F0-9]+)*|\\d+(_\\d+)*(\\.\\d+(_\\d+)*)?([eE][-+]?\\d+)?)",
+			relevance: 0
+		};
+		const NAMED_FUN = { begin: "fun\\s+[a-z'][a-zA-Z0-9_']*/\\d+" };
+		const FUNCTION_CALL = {
+			begin: "([a-z'][a-zA-Z0-9_']*:[a-z'][a-zA-Z0-9_']*|[a-z'][a-zA-Z0-9_']*)\\(",
+			end: "\\)",
+			returnBegin: true,
+			relevance: 0,
+			contains: [{
+				begin: FUNCTION_NAME_RE,
+				relevance: 0
+			}, {
+				begin: "\\(",
+				end: "\\)",
+				endsWithParent: true,
+				returnEnd: true,
+				relevance: 0
+			}]
+		};
+		const TUPLE = {
+			begin: /\{/,
+			end: /\}/,
+			relevance: 0
+		};
+		const VAR1 = {
+			begin: "\\b_([A-Z][A-Za-z0-9_]*)?",
+			relevance: 0
+		};
+		const VAR2 = {
+			begin: "[A-Z][a-zA-Z0-9_]*",
+			relevance: 0
+		};
+		const RECORD_ACCESS = {
+			begin: "#" + hljs.UNDERSCORE_IDENT_RE,
+			relevance: 0,
+			returnBegin: true,
+			contains: [{
+				begin: "#" + hljs.UNDERSCORE_IDENT_RE,
+				relevance: 0
+			}, {
+				begin: /\{/,
+				end: /\}/,
+				relevance: 0
+			}]
+		};
+		const BLOCK_STATEMENTS = {
+			beginKeywords: "fun receive if try case",
+			end: "end",
+			keywords: ERLANG_RESERVED
+		};
+		BLOCK_STATEMENTS.contains = [
+			COMMENT,
+			NAMED_FUN,
+			hljs.inherit(hljs.APOS_STRING_MODE, { className: "" }),
+			BLOCK_STATEMENTS,
+			FUNCTION_CALL,
+			hljs.QUOTE_STRING_MODE,
+			NUMBER,
+			TUPLE,
+			VAR1,
+			VAR2,
+			RECORD_ACCESS
+		];
+		const BASIC_MODES = [
+			COMMENT,
+			NAMED_FUN,
+			BLOCK_STATEMENTS,
+			FUNCTION_CALL,
+			hljs.QUOTE_STRING_MODE,
+			NUMBER,
+			TUPLE,
+			VAR1,
+			VAR2,
+			RECORD_ACCESS
+		];
+		FUNCTION_CALL.contains[1].contains = BASIC_MODES;
+		TUPLE.contains = BASIC_MODES;
+		RECORD_ACCESS.contains[1].contains = BASIC_MODES;
+		const DIRECTIVES = [
+			"-module",
+			"-record",
+			"-undef",
+			"-export",
+			"-ifdef",
+			"-ifndef",
+			"-author",
+			"-copyright",
+			"-doc",
+			"-vsn",
+			"-import",
+			"-include",
+			"-include_lib",
+			"-compile",
+			"-define",
+			"-else",
+			"-endif",
+			"-file",
+			"-behaviour",
+			"-behavior",
+			"-spec"
+		];
+		const PARAMS = {
+			className: "params",
+			begin: "\\(",
+			end: "\\)",
+			contains: BASIC_MODES
+		};
+		return {
+			name: "Erlang",
+			aliases: ["erl"],
+			keywords: ERLANG_RESERVED,
+			illegal: "(</|\\*=|\\+=|-=|/\\*|\\*/|\\(\\*|\\*\\))",
+			contains: [
+				{
+					className: "function",
+					begin: "^[a-z'][a-zA-Z0-9_']*\\s*\\(",
+					end: "->",
+					returnBegin: true,
+					illegal: "\\(|#|//|/\\*|\\\\|:|;",
+					contains: [PARAMS, hljs.inherit(hljs.TITLE_MODE, { begin: BASIC_ATOM_RE })],
+					starts: {
+						end: ";|\\.",
+						keywords: ERLANG_RESERVED,
+						contains: BASIC_MODES
+					}
+				},
+				COMMENT,
+				{
+					begin: "^-",
+					end: "\\.",
+					relevance: 0,
+					excludeEnd: true,
+					returnBegin: true,
+					keywords: {
+						$pattern: "-" + hljs.IDENT_RE,
+						keyword: DIRECTIVES.map((x) => `${x}|1.5`).join(" ")
+					},
+					contains: [PARAMS]
+				},
+				NUMBER,
+				hljs.QUOTE_STRING_MODE,
+				RECORD_ACCESS,
+				VAR1,
+				VAR2,
+				TUPLE,
+				{ begin: /\.$/ }
+			]
+		};
+	}
+	module.exports = erlang;
+}));
+
+//#endregion
+export default require_erlang();

package/dist/erlang-repl-BpgJ1Xxr.js

@@ -0,0 +1,66 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/erlang-repl.js
+var require_erlang_repl = /* @__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("");
+	}
+	/** @type LanguageFn */
+	function erlangRepl(hljs) {
+		return {
+			name: "Erlang REPL",
+			keywords: {
+				built_in: "spawn spawn_link self",
+				keyword: "after and andalso|10 band begin bnot bor bsl bsr bxor case catch cond div end fun if let not of or orelse|10 query receive rem try when xor"
+			},
+			contains: [
+				{
+					className: "meta",
+					begin: "^[0-9]+> ",
+					relevance: 10
+				},
+				hljs.COMMENT("%", "$"),
+				{
+					className: "number",
+					begin: "\\b(\\d+(_\\d+)*#[a-fA-F0-9]+(_[a-fA-F0-9]+)*|\\d+(_\\d+)*(\\.\\d+(_\\d+)*)?([eE][-+]?\\d+)?)",
+					relevance: 0
+				},
+				hljs.APOS_STRING_MODE,
+				hljs.QUOTE_STRING_MODE,
+				{ begin: concat(/\?(::)?/, /([A-Z]\w*)/, /((::)[A-Z]\w*)*/) },
+				{ begin: "->" },
+				{ begin: "ok" },
+				{ begin: "!" },
+				{
+					begin: "(\\b[a-z'][a-zA-Z0-9_']*:[a-z'][a-zA-Z0-9_']*)|(\\b[a-z'][a-zA-Z0-9_']*)",
+					relevance: 0
+				},
+				{
+					begin: "[A-Z][a-zA-Z0-9_']*",
+					relevance: 0
+				}
+			]
+		};
+	}
+	module.exports = erlangRepl;
+}));
+
+//#endregion
+export default require_erlang_repl();