@webskill/chatbot 0.0.1

package/dist/jsdoc-DAHVa1K-.js

@@ -0,0 +1,78 @@
+import { t as javascript } from "./javascript-BJ-LeMcK.js";
+import javadoclike from "./javadoclike-DV682eaV.js";
+import { t as typescript } from "./typescript-DAau_Qyl.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/jsdoc.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+jsdoc.displayName = "jsdoc";
+jsdoc.aliases = [];
+/** @param {Refractor} Prism */
+function jsdoc(Prism) {
+	Prism.register(javadoclike);
+	Prism.register(javascript);
+	Prism.register(typescript);
+	(function(Prism) {
+		var javascript = Prism.languages.javascript;
+		var type = /\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})+\}/.source;
+		var parameterPrefix = "(@(?:arg|argument|param|property)\\s+(?:" + type + "\\s+)?)";
+		Prism.languages.jsdoc = Prism.languages.extend("javadoclike", { parameter: {
+			pattern: RegExp(parameterPrefix + /(?:(?!\s)[$\w\xA0-\uFFFF.])+(?=\s|$)/.source),
+			lookbehind: true,
+			inside: { punctuation: /\./ }
+		} });
+		Prism.languages.insertBefore("jsdoc", "keyword", {
+			"optional-parameter": {
+				pattern: RegExp(parameterPrefix + /\[(?:(?!\s)[$\w\xA0-\uFFFF.])+(?:=[^[\]]+)?\](?=\s|$)/.source),
+				lookbehind: true,
+				inside: {
+					parameter: {
+						pattern: /(^\[)[$\w\xA0-\uFFFF\.]+/,
+						lookbehind: true,
+						inside: { punctuation: /\./ }
+					},
+					code: {
+						pattern: /(=)[\s\S]*(?=\]$)/,
+						lookbehind: true,
+						inside: javascript,
+						alias: "language-javascript"
+					},
+					punctuation: /[=[\]]/
+				}
+			},
+			"class-name": [{
+				pattern: RegExp(/(@(?:augments|class|extends|interface|memberof!?|template|this|typedef)\s+(?:<TYPE>\s+)?)[A-Z]\w*(?:\.[A-Z]\w*)*/.source.replace(/<TYPE>/g, function() {
+					return type;
+				})),
+				lookbehind: true,
+				inside: { punctuation: /\./ }
+			}, {
+				pattern: RegExp("(@[a-z]+\\s+)" + type),
+				lookbehind: true,
+				inside: {
+					string: javascript.string,
+					number: javascript.number,
+					boolean: javascript.boolean,
+					keyword: Prism.languages.typescript.keyword,
+					operator: /=>|\.\.\.|[&|?:*]/,
+					punctuation: /[.,;=<>{}()[\]]/
+				}
+			}],
+			example: {
+				pattern: /(@example\s+(?!\s))(?:[^@\s]|\s+(?!\s))+?(?=\s*(?:\*\s*)?(?:@\w|\*\/))/,
+				lookbehind: true,
+				inside: { code: {
+					pattern: /^([\t ]*(?:\*\s*)?)\S.*$/m,
+					lookbehind: true,
+					inside: javascript,
+					alias: "language-javascript"
+				} }
+			}
+		});
+		Prism.languages.javadoclike.addSupport("javascript", Prism.languages.jsdoc);
+	})(Prism);
+}
+
+//#endregion
+export { jsdoc as default };

package/dist/json-BOcU6nei.js

@@ -0,0 +1,40 @@
+import { n as __exportAll } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/json.js
+var json_exports = /* @__PURE__ */ __exportAll({ default: () => json });
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+json.displayName = "json";
+json.aliases = ["webmanifest"];
+/** @param {Refractor} Prism */
+function json(Prism) {
+	Prism.languages.json = {
+		property: {
+			pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?=\s*:)/,
+			lookbehind: true,
+			greedy: true
+		},
+		string: {
+			pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?!\s*:)/,
+			lookbehind: true,
+			greedy: true
+		},
+		comment: {
+			pattern: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
+			greedy: true
+		},
+		number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+		punctuation: /[{}[\],]/,
+		operator: /:/,
+		boolean: /\b(?:false|true)\b/,
+		null: {
+			pattern: /\bnull\b/,
+			alias: "keyword"
+		}
+	};
+	Prism.languages.webmanifest = Prism.languages.json;
+}
+
+//#endregion
+export { json_exports as n, json as t };

package/dist/json-GDytwSqH.js

@@ -0,0 +1,49 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/json.js
+var require_json = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function json(hljs) {
+		const LITERALS = { literal: "true false null" };
+		const ALLOWED_COMMENTS = [hljs.C_LINE_COMMENT_MODE, hljs.C_BLOCK_COMMENT_MODE];
+		const TYPES = [hljs.QUOTE_STRING_MODE, hljs.C_NUMBER_MODE];
+		const VALUE_CONTAINER = {
+			end: ",",
+			endsWithParent: true,
+			excludeEnd: true,
+			contains: TYPES,
+			keywords: LITERALS
+		};
+		const OBJECT = {
+			begin: /\{/,
+			end: /\}/,
+			contains: [{
+				className: "attr",
+				begin: /"/,
+				end: /"/,
+				contains: [hljs.BACKSLASH_ESCAPE],
+				illegal: "\\n"
+			}, hljs.inherit(VALUE_CONTAINER, { begin: /:/ })].concat(ALLOWED_COMMENTS),
+			illegal: "\\S"
+		};
+		const ARRAY = {
+			begin: "\\[",
+			end: "\\]",
+			contains: [hljs.inherit(VALUE_CONTAINER)],
+			illegal: "\\S"
+		};
+		TYPES.push(OBJECT, ARRAY);
+		ALLOWED_COMMENTS.forEach(function(rule) {
+			TYPES.push(rule);
+		});
+		return {
+			name: "JSON",
+			contains: TYPES,
+			keywords: LITERALS,
+			illegal: "\\S"
+		};
+	}
+	module.exports = json;
+}));
+
+//#endregion
+export default require_json();

package/dist/json5-Dldp7b9R.js

@@ -0,0 +1,32 @@
+import { t as json } from "./json-BOcU6nei.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/json5.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+json5.displayName = "json5";
+json5.aliases = [];
+/** @param {Refractor} Prism */
+function json5(Prism) {
+	Prism.register(json);
+	(function(Prism) {
+		var string = /("|')(?:\\(?:\r\n?|\n|.)|(?!\1)[^\\\r\n])*\1/;
+		Prism.languages.json5 = Prism.languages.extend("json", {
+			property: [{
+				pattern: RegExp(string.source + "(?=\\s*:)"),
+				greedy: true
+			}, {
+				pattern: /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/,
+				alias: "unquoted"
+			}],
+			string: {
+				pattern: string,
+				greedy: true
+			},
+			number: /[+-]?\b(?:NaN|Infinity|0x[a-fA-F\d]+)\b|[+-]?(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[eE][+-]?\d+\b)?/
+		});
+	})(Prism);
+}
+
+//#endregion
+export { json5 as default };

package/dist/jsonp-_VvPg4Sq.js

@@ -0,0 +1,17 @@
+import { t as json } from "./json-BOcU6nei.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/jsonp.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+jsonp.displayName = "jsonp";
+jsonp.aliases = [];
+/** @param {Refractor} Prism */
+function jsonp(Prism) {
+	Prism.register(json);
+	Prism.languages.jsonp = Prism.languages.extend("json", { punctuation: /[{}[\]();,.]/ });
+	Prism.languages.insertBefore("jsonp", "punctuation", { function: /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*\()/ });
+}
+
+//#endregion
+export { jsonp as default };

package/dist/jsstacktrace-BGl-gflq.js

@@ -0,0 +1,49 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/jsstacktrace.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+jsstacktrace.displayName = "jsstacktrace";
+jsstacktrace.aliases = [];
+/** @param {Refractor} Prism */
+function jsstacktrace(Prism) {
+	Prism.languages.jsstacktrace = {
+		"error-message": {
+			pattern: /^\S.*/m,
+			alias: "string"
+		},
+		"stack-frame": {
+			pattern: /(^[ \t]+)at[ \t].*/m,
+			lookbehind: true,
+			inside: {
+				"not-my-code": {
+					pattern: /^at[ \t]+(?!\s)(?:node\.js|<unknown>|.*(?:node_modules|\(<anonymous>\)|\(<unknown>|<anonymous>$|\(internal\/|\(node\.js)).*/m,
+					alias: "comment"
+				},
+				filename: {
+					pattern: /(\bat\s+(?!\s)|\()(?:[a-zA-Z]:)?[^():]+(?=:)/,
+					lookbehind: true,
+					alias: "url"
+				},
+				function: {
+					pattern: /(\bat\s+(?:new\s+)?)(?!\s)[_$a-zA-Z\xA0-\uFFFF<][.$\w\xA0-\uFFFF<>]*/,
+					lookbehind: true,
+					inside: { punctuation: /\./ }
+				},
+				punctuation: /[()]/,
+				keyword: /\b(?:at|new)\b/,
+				alias: {
+					pattern: /\[(?:as\s+)?(?!\s)[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*\]/,
+					alias: "variable"
+				},
+				"line-number": {
+					pattern: /:\d+(?::\d+)?\b/,
+					alias: "number",
+					inside: { punctuation: /:/ }
+				}
+			}
+		}
+	};
+}
+
+//#endregion
+export { jsstacktrace as default };

package/dist/jsx-D2Jv0wvt.js

@@ -0,0 +1,103 @@
+import { n as __exportAll } from "./rolldown-runtime-DZ8SGSJo.js";
+import { t as markup } from "./markup-D2NSmoAx.js";
+import { t as javascript } from "./javascript-BJ-LeMcK.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/jsx.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+var jsx_exports = /* @__PURE__ */ __exportAll({ default: () => jsx });
+jsx.displayName = "jsx";
+jsx.aliases = [];
+/** @param {Refractor} Prism */
+function jsx(Prism) {
+	Prism.register(javascript);
+	Prism.register(markup);
+	(function(Prism) {
+		var javascript = Prism.util.clone(Prism.languages.javascript);
+		var space = /(?:\s|\/\/.*(?!.)|\/\*(?:[^*]|\*(?!\/))\*\/)/.source;
+		var braces = /(?:\{(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])*\})/.source;
+		var spread = /(?:\{<S>*\.{3}(?:[^{}]|<BRACES>)*\})/.source;
+		/**
+		* @param {string} source
+		* @param {string} [flags]
+		*/
+		function re(source, flags) {
+			source = source.replace(/<S>/g, function() {
+				return space;
+			}).replace(/<BRACES>/g, function() {
+				return braces;
+			}).replace(/<SPREAD>/g, function() {
+				return spread;
+			});
+			return RegExp(source, flags);
+		}
+		spread = re(spread).source;
+		Prism.languages.jsx = Prism.languages.extend("markup", javascript);
+		Prism.languages.jsx.tag.pattern = re(/<\/?(?:[\w.:-]+(?:<S>+(?:[\w.:$-]+(?:=(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s{'"/>=]+|<BRACES>))?|<SPREAD>))*<S>*\/?)?>/.source);
+		Prism.languages.jsx.tag.inside["tag"].pattern = /^<\/?[^\s>\/]*/;
+		Prism.languages.jsx.tag.inside["attr-value"].pattern = /=(?!\{)(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s'">]+)/;
+		Prism.languages.jsx.tag.inside["tag"].inside["class-name"] = /^[A-Z]\w*(?:\.[A-Z]\w*)*$/;
+		Prism.languages.jsx.tag.inside["comment"] = javascript["comment"];
+		Prism.languages.insertBefore("inside", "attr-name", { spread: {
+			pattern: re(/<SPREAD>/.source),
+			inside: Prism.languages.jsx
+		} }, Prism.languages.jsx.tag);
+		Prism.languages.insertBefore("inside", "special-attr", { script: {
+			pattern: re(/=<BRACES>/.source),
+			alias: "language-javascript",
+			inside: {
+				"script-punctuation": {
+					pattern: /^=(?=\{)/,
+					alias: "punctuation"
+				},
+				rest: Prism.languages.jsx
+			}
+		} }, Prism.languages.jsx.tag);
+		var stringifyToken = function(token) {
+			if (!token) return "";
+			if (typeof token === "string") return token;
+			if (typeof token.content === "string") return token.content;
+			return token.content.map(stringifyToken).join("");
+		};
+		var walkTokens = function(tokens) {
+			var openedTags = [];
+			for (var i = 0; i < tokens.length; i++) {
+				var token = tokens[i];
+				var notTagNorBrace = false;
+				if (typeof token !== "string") if (token.type === "tag" && token.content[0] && token.content[0].type === "tag") if (token.content[0].content[0].content === "</") {
+					if (openedTags.length > 0 && openedTags[openedTags.length - 1].tagName === stringifyToken(token.content[0].content[1])) openedTags.pop();
+				} else if (token.content[token.content.length - 1].content === "/>") {} else openedTags.push({
+					tagName: stringifyToken(token.content[0].content[1]),
+					openedBraces: 0
+				});
+				else if (openedTags.length > 0 && token.type === "punctuation" && token.content === "{") openedTags[openedTags.length - 1].openedBraces++;
+				else if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces > 0 && token.type === "punctuation" && token.content === "}") openedTags[openedTags.length - 1].openedBraces--;
+				else notTagNorBrace = true;
+				if (notTagNorBrace || typeof token === "string") {
+					if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces === 0) {
+						var plainText = stringifyToken(token);
+						if (i < tokens.length - 1 && (typeof tokens[i + 1] === "string" || tokens[i + 1].type === "plain-text")) {
+							plainText += stringifyToken(tokens[i + 1]);
+							tokens.splice(i + 1, 1);
+						}
+						if (i > 0 && (typeof tokens[i - 1] === "string" || tokens[i - 1].type === "plain-text")) {
+							plainText = stringifyToken(tokens[i - 1]) + plainText;
+							tokens.splice(i - 1, 1);
+							i--;
+						}
+						tokens[i] = new Prism.Token("plain-text", plainText, null, plainText);
+					}
+				}
+				if (token.content && typeof token.content !== "string") walkTokens(token.content);
+			}
+		};
+		Prism.hooks.add("after-tokenize", function(env) {
+			if (env.language !== "jsx" && env.language !== "tsx") return;
+			walkTokens(env.tokens);
+		});
+	})(Prism);
+}
+
+//#endregion
+export { jsx_exports as n, jsx as t };

package/dist/julia-B3lI6_fR.js

@@ -0,0 +1,37 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/julia.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+julia.displayName = "julia";
+julia.aliases = [];
+/** @param {Refractor} Prism */
+function julia(Prism) {
+	Prism.languages.julia = {
+		comment: {
+			pattern: /(^|[^\\])(?:#=(?:[^#=]|=(?!#)|#(?!=)|#=(?:[^#=]|=(?!#)|#(?!=))*=#)*=#|#.*)/,
+			lookbehind: true
+		},
+		regex: {
+			pattern: /r"(?:\\.|[^"\\\r\n])*"[imsx]{0,4}/,
+			greedy: true
+		},
+		string: {
+			pattern: /"""[\s\S]+?"""|(?:\b\w+)?"(?:\\.|[^"\\\r\n])*"|`(?:[^\\`\r\n]|\\.)*`/,
+			greedy: true
+		},
+		char: {
+			pattern: /(^|[^\w'])'(?:\\[^\r\n][^'\r\n]*|[^\\\r\n])'/,
+			lookbehind: true,
+			greedy: true
+		},
+		keyword: /\b(?:abstract|baremodule|begin|bitstype|break|catch|ccall|const|continue|do|else|elseif|end|export|finally|for|function|global|if|immutable|import|importall|in|let|local|macro|module|print|println|quote|return|struct|try|type|typealias|using|while)\b/,
+		boolean: /\b(?:false|true)\b/,
+		number: /(?:\b(?=\d)|\B(?=\.))(?:0[box])?(?:[\da-f]+(?:_[\da-f]+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[efp][+-]?\d+(?:_\d+)*)?j?/i,
+		operator: /&&|\|\||[-+*^%÷⊻&$\\]=?|\/[\/=]?|!=?=?|\|[=>]?|<(?:<=?|[=:|])?|>(?:=|>>?=?)?|==?=?|[~≠≤≥'√∛]/,
+		punctuation: /::?|[{}[\]();,.?]/,
+		constant: /\b(?:(?:Inf|NaN)(?:16|32|64)?|im|pi)\b|[πℯ]/
+	};
+}
+
+//#endregion
+export { julia as default };