@webskill/chatbot 0.16.0 → 0.17.0

package/dist/markdown-4gn774sm.js

@@ -0,0 +1,280 @@
+import { n as __exportAll } from "./rolldown-runtime-DZ8SGSJo.js";
+import { t as markup } from "./markup-D2NSmoAx.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/markdown.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+var markdown_exports = /* @__PURE__ */ __exportAll({ default: () => markdown });
+markdown.displayName = "markdown";
+markdown.aliases = ["md"];
+/** @param {Refractor} Prism */
+function markdown(Prism) {
+	Prism.register(markup);
+	(function(Prism) {
+		var inner = /(?:\\.|[^\\\n\r]|(?:\n|\r\n?)(?![\r\n]))/.source;
+		/**
+		* This function is intended for the creation of the bold or italic pattern.
+		*
+		* This also adds a lookbehind group to the given pattern to ensure that the pattern is not backslash-escaped.
+		*
+		* _Note:_ Keep in mind that this adds a capturing group.
+		*
+		* @param {string} pattern
+		* @returns {RegExp}
+		*/
+		function createInline(pattern) {
+			pattern = pattern.replace(/<inner>/g, function() {
+				return inner;
+			});
+			return RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + "(?:" + pattern + ")");
+		}
+		var tableCell = /(?:\\.|``(?:[^`\r\n]|`(?!`))+``|`[^`\r\n]+`|[^\\|\r\n`])+/.source;
+		var tableRow = /\|?__(?:\|__)+\|?(?:(?:\n|\r\n?)|(?![\s\S]))/.source.replace(/__/g, function() {
+			return tableCell;
+		});
+		var tableLine = /\|?[ \t]*:?-{3,}:?[ \t]*(?:\|[ \t]*:?-{3,}:?[ \t]*)+\|?(?:\n|\r\n?)/.source;
+		Prism.languages.markdown = Prism.languages.extend("markup", {});
+		Prism.languages.insertBefore("markdown", "prolog", {
+			"front-matter-block": {
+				pattern: /(^(?:\s*[\r\n])?)---(?!.)[\s\S]*?[\r\n]---(?!.)/,
+				lookbehind: true,
+				greedy: true,
+				inside: {
+					punctuation: /^---|---$/,
+					"front-matter": {
+						pattern: /\S+(?:\s+\S+)*/,
+						alias: ["yaml", "language-yaml"],
+						inside: Prism.languages.yaml
+					}
+				}
+			},
+			blockquote: {
+				pattern: /^>(?:[\t ]*>)*/m,
+				alias: "punctuation"
+			},
+			table: {
+				pattern: RegExp("^" + tableRow + tableLine + "(?:" + tableRow + ")*", "m"),
+				inside: {
+					"table-data-rows": {
+						pattern: RegExp("^(" + tableRow + tableLine + ")(?:" + tableRow + ")*$"),
+						lookbehind: true,
+						inside: {
+							"table-data": {
+								pattern: RegExp(tableCell),
+								inside: Prism.languages.markdown
+							},
+							punctuation: /\|/
+						}
+					},
+					"table-line": {
+						pattern: RegExp("^(" + tableRow + ")" + tableLine + "$"),
+						lookbehind: true,
+						inside: { punctuation: /\||:?-{3,}:?/ }
+					},
+					"table-header-row": {
+						pattern: RegExp("^" + tableRow + "$"),
+						inside: {
+							"table-header": {
+								pattern: RegExp(tableCell),
+								alias: "important",
+								inside: Prism.languages.markdown
+							},
+							punctuation: /\|/
+						}
+					}
+				}
+			},
+			code: [{
+				pattern: /((?:^|\n)[ \t]*\n|(?:^|\r\n?)[ \t]*\r\n?)(?: {4}|\t).+(?:(?:\n|\r\n?)(?: {4}|\t).+)*/,
+				lookbehind: true,
+				alias: "keyword"
+			}, {
+				pattern: /^```[\s\S]*?^```$/m,
+				greedy: true,
+				inside: {
+					"code-block": {
+						pattern: /^(```.*(?:\n|\r\n?))[\s\S]+?(?=(?:\n|\r\n?)^```$)/m,
+						lookbehind: true
+					},
+					"code-language": {
+						pattern: /^(```).+/,
+						lookbehind: true
+					},
+					punctuation: /```/
+				}
+			}],
+			title: [{
+				pattern: /\S.*(?:\n|\r\n?)(?:==+|--+)(?=[ \t]*$)/m,
+				alias: "important",
+				inside: { punctuation: /==+$|--+$/ }
+			}, {
+				pattern: /(^\s*)#.+/m,
+				lookbehind: true,
+				alias: "important",
+				inside: { punctuation: /^#+|#+$/ }
+			}],
+			hr: {
+				pattern: /(^\s*)([*-])(?:[\t ]*\2){2,}(?=\s*$)/m,
+				lookbehind: true,
+				alias: "punctuation"
+			},
+			list: {
+				pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m,
+				lookbehind: true,
+				alias: "punctuation"
+			},
+			"url-reference": {
+				pattern: /!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/,
+				inside: {
+					variable: {
+						pattern: /^(!?\[)[^\]]+/,
+						lookbehind: true
+					},
+					string: /(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/,
+					punctuation: /^[\[\]!:]|[<>]/
+				},
+				alias: "url"
+			},
+			bold: {
+				pattern: createInline(/\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\b|\*\*(?:(?!\*)<inner>|\*(?:(?!\*)<inner>)+\*)+\*\*/.source),
+				lookbehind: true,
+				greedy: true,
+				inside: {
+					content: {
+						pattern: /(^..)[\s\S]+(?=..$)/,
+						lookbehind: true,
+						inside: {}
+					},
+					punctuation: /\*\*|__/
+				}
+			},
+			italic: {
+				pattern: createInline(/\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\b|\*(?:(?!\*)<inner>|\*\*(?:(?!\*)<inner>)+\*\*)+\*/.source),
+				lookbehind: true,
+				greedy: true,
+				inside: {
+					content: {
+						pattern: /(^.)[\s\S]+(?=.$)/,
+						lookbehind: true,
+						inside: {}
+					},
+					punctuation: /[*_]/
+				}
+			},
+			strike: {
+				pattern: createInline(/(~~?)(?:(?!~)<inner>)+\2/.source),
+				lookbehind: true,
+				greedy: true,
+				inside: {
+					content: {
+						pattern: /(^~~?)[\s\S]+(?=\1$)/,
+						lookbehind: true,
+						inside: {}
+					},
+					punctuation: /~~?/
+				}
+			},
+			"code-snippet": {
+				pattern: /(^|[^\\`])(?:``[^`\r\n]+(?:`[^`\r\n]+)*``(?!`)|`[^`\r\n]+`(?!`))/,
+				lookbehind: true,
+				greedy: true,
+				alias: ["code", "keyword"]
+			},
+			url: {
+				pattern: createInline(/!?\[(?:(?!\])<inner>)+\](?:\([^\s)]+(?:[\t ]+"(?:\\.|[^"\\])*")?\)|[ \t]?\[(?:(?!\])<inner>)+\])/.source),
+				lookbehind: true,
+				greedy: true,
+				inside: {
+					operator: /^!/,
+					content: {
+						pattern: /(^\[)[^\]]+(?=\])/,
+						lookbehind: true,
+						inside: {}
+					},
+					variable: {
+						pattern: /(^\][ \t]?\[)[^\]]+(?=\]$)/,
+						lookbehind: true
+					},
+					url: {
+						pattern: /(^\]\()[^\s)]+/,
+						lookbehind: true
+					},
+					string: {
+						pattern: /(^[ \t]+)"(?:\\.|[^"\\])*"(?=\)$)/,
+						lookbehind: true
+					}
+				}
+			}
+		});
+		[
+			"url",
+			"bold",
+			"italic",
+			"strike"
+		].forEach(function(token) {
+			[
+				"url",
+				"bold",
+				"italic",
+				"strike",
+				"code-snippet"
+			].forEach(function(inside) {
+				if (token !== inside) Prism.languages.markdown[token].inside.content.inside[inside] = Prism.languages.markdown[inside];
+			});
+		});
+		Prism.hooks.add("after-tokenize", function(env) {
+			if (env.language !== "markdown" && env.language !== "md") return;
+			function walkTokens(tokens) {
+				if (!tokens || typeof tokens === "string") return;
+				for (var i = 0, l = tokens.length; i < l; i++) {
+					var token = tokens[i];
+					if (token.type !== "code") {
+						walkTokens(token.content);
+						continue;
+					}
+					var codeLang = token.content[1];
+					var codeBlock = token.content[3];
+					if (codeLang && codeBlock && codeLang.type === "code-language" && codeBlock.type === "code-block" && typeof codeLang.content === "string") {
+						var lang = codeLang.content.replace(/\b#/g, "sharp").replace(/\b\+\+/g, "pp");
+						lang = (/[a-z][\w-]*/i.exec(lang) || [""])[0].toLowerCase();
+						var alias = "language-" + lang;
+						if (!codeBlock.alias) codeBlock.alias = [alias];
+						else if (typeof codeBlock.alias === "string") codeBlock.alias = [codeBlock.alias, alias];
+						else codeBlock.alias.push(alias);
+					}
+				}
+			}
+			walkTokens(env.tokens);
+		});
+		Prism.hooks.add("wrap", function(env) {
+			if (env.type !== "code-block") return;
+			var codeLang = "";
+			for (var i = 0, l = env.classes.length; i < l; i++) {
+				var cls = env.classes[i];
+				var match = /language-(.+)/.exec(cls);
+				if (match) {
+					codeLang = match[1];
+					break;
+				}
+			}
+			var grammar = Prism.languages[codeLang];
+			if (!grammar) {
+				if (codeLang && codeLang !== "none" && Prism.plugins.autoloader) {
+					var id = "md-" + (/* @__PURE__ */ new Date()).valueOf() + "-" + Math.floor(Math.random() * 0x2386f26fc10000);
+					env.attributes["id"] = id;
+					Prism.plugins.autoloader.loadLanguages(codeLang, function() {
+						var ele = document.getElementById(id);
+						if (ele) ele.innerHTML = Prism.highlight(ele.textContent, Prism.languages[codeLang], codeLang);
+					});
+				}
+			} else env.content = Prism.highlight(env.content.value, grammar, codeLang);
+		});
+		RegExp(Prism.languages.markup.tag.pattern.source, "gi");
+		String.fromCodePoint || String.fromCharCode;
+		Prism.languages.md = Prism.languages.markdown;
+	})(Prism);
+}
+
+//#endregion
+export { markdown_exports as n, markdown as t };