@webskill/chatbot 0.0.1

package/dist/xquery-Bc1R9nUG.js

@@ -0,0 +1,129 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/xquery.js
+var require_xquery = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type LanguageFn */
+	function xquery(_hljs) {
+		return {
+			name: "XQuery",
+			aliases: ["xpath", "xq"],
+			case_insensitive: false,
+			illegal: /(proc)|(abstract)|(extends)|(until)|(#)/,
+			keywords: {
+				$pattern: /[a-zA-Z$][a-zA-Z0-9_:-]*/,
+				keyword: "module schema namespace boundary-space preserve no-preserve strip default collation base-uri ordering context decimal-format decimal-separator copy-namespaces empty-sequence except exponent-separator external grouping-separator inherit no-inherit lax minus-sign per-mille percent schema-attribute schema-element strict unordered zero-digit declare import option function validate variable for at in let where order group by return if then else tumbling sliding window start when only end previous next stable ascending descending allowing empty greatest least some every satisfies switch case typeswitch try catch and or to union intersect instance of treat as castable cast map array delete insert into replace value rename copy modify update",
+				type: "item document-node node attribute document element comment namespace namespace-node processing-instruction text construction xs:anyAtomicType xs:untypedAtomic xs:duration xs:time xs:decimal xs:float xs:double xs:gYearMonth xs:gYear xs:gMonthDay xs:gMonth xs:gDay xs:boolean xs:base64Binary xs:hexBinary xs:anyURI xs:QName xs:NOTATION xs:dateTime xs:dateTimeStamp xs:date xs:string xs:normalizedString xs:token xs:language xs:NMTOKEN xs:Name xs:NCName xs:ID xs:IDREF xs:ENTITY xs:integer xs:nonPositiveInteger xs:negativeInteger xs:long xs:int xs:short xs:byte xs:nonNegativeInteger xs:unisignedLong xs:unsignedInt xs:unsignedShort xs:unsignedByte xs:positiveInteger xs:yearMonthDuration xs:dayTimeDuration",
+				literal: "eq ne lt le gt ge is self:: child:: descendant:: descendant-or-self:: attribute:: following:: following-sibling:: parent:: ancestor:: ancestor-or-self:: preceding:: preceding-sibling:: NaN"
+			},
+			contains: [
+				{
+					className: "variable",
+					begin: /[$][\w\-:]+/
+				},
+				{
+					className: "built_in",
+					variants: [
+						{
+							begin: /\barray:/,
+							end: /(?:append|filter|flatten|fold-(?:left|right)|for-each(?:-pair)?|get|head|insert-before|join|put|remove|reverse|size|sort|subarray|tail)\b/
+						},
+						{
+							begin: /\bmap:/,
+							end: /(?:contains|entry|find|for-each|get|keys|merge|put|remove|size)\b/
+						},
+						{
+							begin: /\bmath:/,
+							end: /(?:a(?:cos|sin|tan[2]?)|cos|exp(?:10)?|log(?:10)?|pi|pow|sin|sqrt|tan)\b/
+						},
+						{
+							begin: /\bop:/,
+							end: /\(/,
+							excludeEnd: true
+						},
+						{
+							begin: /\bfn:/,
+							end: /\(/,
+							excludeEnd: true
+						},
+						{ begin: /[^</$:'"-]\b(?:abs|accumulator-(?:after|before)|adjust-(?:date(?:Time)?|time)-to-timezone|analyze-string|apply|available-(?:environment-variables|system-properties)|avg|base-uri|boolean|ceiling|codepoints?-(?:equal|to-string)|collation-key|collection|compare|concat|contains(?:-token)?|copy-of|count|current(?:-)?(?:date(?:Time)?|time|group(?:ing-key)?|output-uri|merge-(?:group|key))?data|dateTime|days?-from-(?:date(?:Time)?|duration)|deep-equal|default-(?:collation|language)|distinct-values|document(?:-uri)?|doc(?:-available)?|element-(?:available|with-id)|empty|encode-for-uri|ends-with|environment-variable|error|escape-html-uri|exactly-one|exists|false|filter|floor|fold-(?:left|right)|for-each(?:-pair)?|format-(?:date(?:Time)?|time|integer|number)|function-(?:arity|available|lookup|name)|generate-id|has-children|head|hours-from-(?:dateTime|duration|time)|id(?:ref)?|implicit-timezone|in-scope-prefixes|index-of|innermost|insert-before|iri-to-uri|json-(?:doc|to-xml)|key|lang|last|load-xquery-module|local-name(?:-from-QName)?|(?:lower|upper)-case|matches|max|minutes-from-(?:dateTime|duration|time)|min|months?-from-(?:date(?:Time)?|duration)|name(?:space-uri-?(?:for-prefix|from-QName)?)?|nilled|node-name|normalize-(?:space|unicode)|not|number|one-or-more|outermost|parse-(?:ietf-date|json)|path|position|(?:prefix-from-)?QName|random-number-generator|regex-group|remove|replace|resolve-(?:QName|uri)|reverse|root|round(?:-half-to-even)?|seconds-from-(?:dateTime|duration|time)|snapshot|sort|starts-with|static-base-uri|stream-available|string-?(?:join|length|to-codepoints)?|subsequence|substring-?(?:after|before)?|sum|system-property|tail|timezone-from-(?:date(?:Time)?|time)|tokenize|trace|trans(?:form|late)|true|type-available|unordered|unparsed-(?:entity|text)?-?(?:public-id|uri|available|lines)?|uri-collection|xml-to-json|years?-from-(?:date(?:Time)?|duration)|zero-or-one)\b/ },
+						{
+							begin: /\blocal:/,
+							end: /\(/,
+							excludeEnd: true
+						},
+						{
+							begin: /\bzip:/,
+							end: /(?:zip-file|(?:xml|html|text|binary)-entry| (?:update-)?entries)\b/
+						},
+						{
+							begin: /\b(?:util|db|functx|app|xdmp|xmldb):/,
+							end: /\(/,
+							excludeEnd: true
+						}
+					]
+				},
+				{
+					className: "string",
+					variants: [{
+						begin: /"/,
+						end: /"/,
+						contains: [{
+							begin: /""/,
+							relevance: 0
+						}]
+					}, {
+						begin: /'/,
+						end: /'/,
+						contains: [{
+							begin: /''/,
+							relevance: 0
+						}]
+					}]
+				},
+				{
+					className: "number",
+					begin: /(\b0[0-7_]+)|(\b0x[0-9a-fA-F_]+)|(\b[1-9][0-9_]*(\.[0-9_]+)?)|[0_]\b/,
+					relevance: 0
+				},
+				{
+					className: "comment",
+					begin: /\(:/,
+					end: /:\)/,
+					relevance: 10,
+					contains: [{
+						className: "doctag",
+						begin: /@\w+/
+					}]
+				},
+				{
+					className: "meta",
+					begin: /%[\w\-:]+/
+				},
+				{
+					className: "title",
+					begin: /\bxquery version "[13]\.[01]"\s?(?:encoding ".+")?/,
+					end: /;/
+				},
+				{
+					beginKeywords: "element attribute comment document processing-instruction",
+					end: /\{/,
+					excludeEnd: true
+				},
+				{
+					begin: /<([\w._:-]+)(\s+\S*=('|").*('|"))?>/,
+					end: /(\/[\w._:-]+>)/,
+					subLanguage: "xml",
+					contains: [{
+						begin: /\{/,
+						end: /\}/,
+						subLanguage: "xquery"
+					}, "self"]
+				}
+			]
+		};
+	}
+	module.exports = xquery;
+}));
+
+//#endregion
+export default require_xquery();

package/dist/xquery-Bih1YSSU.js

@@ -0,0 +1,120 @@
+import { t as markup } from "./markup-D2NSmoAx.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/xquery.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+xquery.displayName = "xquery";
+xquery.aliases = [];
+/** @param {Refractor} Prism */
+function xquery(Prism) {
+	Prism.register(markup);
+	(function(Prism) {
+		Prism.languages.xquery = Prism.languages.extend("markup", {
+			"xquery-comment": {
+				pattern: /\(:[\s\S]*?:\)/,
+				greedy: true,
+				alias: "comment"
+			},
+			string: {
+				pattern: /(["'])(?:\1\1|(?!\1)[\s\S])*\1/,
+				greedy: true
+			},
+			extension: {
+				pattern: /\(#.+?#\)/,
+				alias: "symbol"
+			},
+			variable: /\$[-\w:]+/,
+			axis: {
+				pattern: /(^|[^-])(?:ancestor(?:-or-self)?|attribute|child|descendant(?:-or-self)?|following(?:-sibling)?|parent|preceding(?:-sibling)?|self)(?=::)/,
+				lookbehind: true,
+				alias: "operator"
+			},
+			"keyword-operator": {
+				pattern: /(^|[^:-])\b(?:and|castable as|div|eq|except|ge|gt|idiv|instance of|intersect|is|le|lt|mod|ne|or|union)\b(?=$|[^:-])/,
+				lookbehind: true,
+				alias: "operator"
+			},
+			keyword: {
+				pattern: /(^|[^:-])\b(?:as|ascending|at|base-uri|boundary-space|case|cast as|collation|construction|copy-namespaces|declare|default|descending|else|empty (?:greatest|least)|encoding|every|external|for|function|if|import|in|inherit|lax|let|map|module|namespace|no-inherit|no-preserve|option|order(?: by|ed|ing)?|preserve|return|satisfies|schema|some|stable|strict|strip|then|to|treat as|typeswitch|unordered|validate|variable|version|where|xquery)\b(?=$|[^:-])/,
+				lookbehind: true
+			},
+			function: /[\w-]+(?::[\w-]+)*(?=\s*\()/,
+			"xquery-element": {
+				pattern: /(element\s+)[\w-]+(?::[\w-]+)*/,
+				lookbehind: true,
+				alias: "tag"
+			},
+			"xquery-attribute": {
+				pattern: /(attribute\s+)[\w-]+(?::[\w-]+)*/,
+				lookbehind: true,
+				alias: "attr-name"
+			},
+			builtin: {
+				pattern: /(^|[^:-])\b(?:attribute|comment|document|element|processing-instruction|text|xs:(?:ENTITIES|ENTITY|ID|IDREFS?|NCName|NMTOKENS?|NOTATION|Name|QName|anyAtomicType|anyType|anyURI|base64Binary|boolean|byte|date|dateTime|dayTimeDuration|decimal|double|duration|float|gDay|gMonth|gMonthDay|gYear|gYearMonth|hexBinary|int|integer|language|long|negativeInteger|nonNegativeInteger|nonPositiveInteger|normalizedString|positiveInteger|short|string|time|token|unsigned(?:Byte|Int|Long|Short)|untyped(?:Atomic)?|yearMonthDuration))\b(?=$|[^:-])/,
+				lookbehind: true
+			},
+			number: /\b\d+(?:\.\d+)?(?:E[+-]?\d+)?/,
+			operator: [/[+*=?|@]|\.\.?|:=|!=|<[=<]?|>[=>]?/, {
+				pattern: /(\s)-(?=\s)/,
+				lookbehind: true
+			}],
+			punctuation: /[[\](){},;:/]/
+		});
+		Prism.languages.xquery.tag.pattern = /<\/?(?!\d)[^\s>\/=$<%]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\[\s\S]|\{(?!\{)(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])+\}|(?!\1)[^\\])*\1|[^\s'">=]+))?)*\s*\/?>/;
+		Prism.languages.xquery["tag"].inside["attr-value"].pattern = /=(?:("|')(?:\\[\s\S]|\{(?!\{)(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])+\}|(?!\1)[^\\])*\1|[^\s'">=]+)/;
+		Prism.languages.xquery["tag"].inside["attr-value"].inside["punctuation"] = /^="|"$/;
+		Prism.languages.xquery["tag"].inside["attr-value"].inside["expression"] = {
+			pattern: /\{(?!\{)(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])+\}/,
+			inside: Prism.languages.xquery,
+			alias: "language-xquery"
+		};
+		var stringifyToken = function(token) {
+			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 === "{" && (!tokens[i + 1] || tokens[i + 1].type !== "punctuation" || tokens[i + 1].content !== "{") && (!tokens[i - 1] || tokens[i - 1].type !== "plain-text" || tokens[i - 1].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 if (token.type !== "comment") 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--;
+						}
+						if (/^\s+$/.test(plainText)) tokens[i] = plainText;
+						else 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 !== "xquery") return;
+			walkTokens(env.tokens);
+		});
+	})(Prism);
+}
+
+//#endregion
+export { xquery as default };

package/dist/yaml-C888tCbJ.js

@@ -0,0 +1,92 @@
+import { n as __exportAll } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/yaml.js
+var yaml_exports = /* @__PURE__ */ __exportAll({ default: () => yaml });
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+yaml.displayName = "yaml";
+yaml.aliases = ["yml"];
+/** @param {Refractor} Prism */
+function yaml(Prism) {
+	(function(Prism) {
+		var anchorOrAlias = /[*&][^\s[\]{},]+/;
+		var tag = /!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/;
+		var properties = "(?:" + tag.source + "(?:[ 	]+" + anchorOrAlias.source + ")?|" + anchorOrAlias.source + "(?:[ 	]+" + tag.source + ")?)";
+		var plainKey = /(?:[^\s\x00-\x08\x0e-\x1f!"#%&'*,\-:>?@[\]`{|}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]|[?:-]<PLAIN>)(?:[ \t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*/.source.replace(/<PLAIN>/g, function() {
+			return /[^\s\x00-\x08\x0e-\x1f,[\]{}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]/.source;
+		});
+		var string = /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/.source;
+		/**
+		*
+		* @param {string} value
+		* @param {string} [flags]
+		* @returns {RegExp}
+		*/
+		function createValuePattern(value, flags) {
+			flags = (flags || "").replace(/m/g, "") + "m";
+			var pattern = /([:\-,[{]\s*(?:\s<<prop>>[ \t]+)?)(?:<<value>>)(?=[ \t]*(?:$|,|\]|\}|(?:[\r\n]\s*)?#))/.source.replace(/<<prop>>/g, function() {
+				return properties;
+			}).replace(/<<value>>/g, function() {
+				return value;
+			});
+			return RegExp(pattern, flags);
+		}
+		Prism.languages.yaml = {
+			scalar: {
+				pattern: RegExp(/([\-:]\s*(?:\s<<prop>>[ \t]+)?[|>])[ \t]*(?:((?:\r?\n|\r)[ \t]+)\S[^\r\n]*(?:\2[^\r\n]+)*)/.source.replace(/<<prop>>/g, function() {
+					return properties;
+				})),
+				lookbehind: true,
+				alias: "string"
+			},
+			comment: /#.*/,
+			key: {
+				pattern: RegExp(/((?:^|[:\-,[{\r\n?])[ \t]*(?:<<prop>>[ \t]+)?)<<key>>(?=\s*:\s)/.source.replace(/<<prop>>/g, function() {
+					return properties;
+				}).replace(/<<key>>/g, function() {
+					return "(?:" + plainKey + "|" + string + ")";
+				})),
+				lookbehind: true,
+				greedy: true,
+				alias: "atrule"
+			},
+			directive: {
+				pattern: /(^[ \t]*)%.+/m,
+				lookbehind: true,
+				alias: "important"
+			},
+			datetime: {
+				pattern: createValuePattern(/\d{4}-\d\d?-\d\d?(?:[tT]|[ \t]+)\d\d?:\d{2}:\d{2}(?:\.\d*)?(?:[ \t]*(?:Z|[-+]\d\d?(?::\d{2})?))?|\d{4}-\d{2}-\d{2}|\d\d?:\d{2}(?::\d{2}(?:\.\d*)?)?/.source),
+				lookbehind: true,
+				alias: "number"
+			},
+			boolean: {
+				pattern: createValuePattern(/false|true/.source, "i"),
+				lookbehind: true,
+				alias: "important"
+			},
+			null: {
+				pattern: createValuePattern(/null|~/.source, "i"),
+				lookbehind: true,
+				alias: "important"
+			},
+			string: {
+				pattern: createValuePattern(string),
+				lookbehind: true,
+				greedy: true
+			},
+			number: {
+				pattern: createValuePattern(/[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|\.inf|\.nan)/.source, "i"),
+				lookbehind: true
+			},
+			tag,
+			important: anchorOrAlias,
+			punctuation: /---|[:[\]{}\-,|>?]|\.\.\./
+		};
+		Prism.languages.yml = Prism.languages.yaml;
+	})(Prism);
+}
+
+//#endregion
+export { yaml_exports as n, yaml as t };

package/dist/yaml-sXJydZ-C.js

@@ -0,0 +1,155 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/yaml.js
+var require_yaml = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function yaml(hljs) {
+		var LITERALS = "true false yes no null";
+		var URI_CHARACTERS = "[\\w#;/?:@&=+$,.~*'()[\\]]+";
+		var KEY = {
+			className: "attr",
+			variants: [
+				{ begin: "\\w[\\w :\\/.-]*:(?=[ 	]|$)" },
+				{ begin: "\"\\w[\\w :\\/.-]*\":(?=[ 	]|$)" },
+				{ begin: "'\\w[\\w :\\/.-]*':(?=[ 	]|$)" }
+			]
+		};
+		var STRING = {
+			className: "string",
+			relevance: 0,
+			variants: [
+				{
+					begin: /'/,
+					end: /'/
+				},
+				{
+					begin: /"/,
+					end: /"/
+				},
+				{ begin: /\S+/ }
+			],
+			contains: [hljs.BACKSLASH_ESCAPE, {
+				className: "template-variable",
+				variants: [{
+					begin: /\{\{/,
+					end: /\}\}/
+				}, {
+					begin: /%\{/,
+					end: /\}/
+				}]
+			}]
+		};
+		var CONTAINER_STRING = hljs.inherit(STRING, { variants: [
+			{
+				begin: /'/,
+				end: /'/
+			},
+			{
+				begin: /"/,
+				end: /"/
+			},
+			{ begin: /[^\s,{}[\]]+/ }
+		] });
+		var TIMESTAMP = {
+			className: "number",
+			begin: "\\b[0-9]{4}(-[0-9][0-9]){0,2}([Tt \\t][0-9][0-9]?(:[0-9][0-9]){2})?(\\.[0-9]*)?([ \\t])*(Z|[-+][0-9][0-9]?(:[0-9][0-9])?)?\\b"
+		};
+		var VALUE_CONTAINER = {
+			end: ",",
+			endsWithParent: true,
+			excludeEnd: true,
+			keywords: LITERALS,
+			relevance: 0
+		};
+		var OBJECT = {
+			begin: /\{/,
+			end: /\}/,
+			contains: [VALUE_CONTAINER],
+			illegal: "\\n",
+			relevance: 0
+		};
+		var ARRAY = {
+			begin: "\\[",
+			end: "\\]",
+			contains: [VALUE_CONTAINER],
+			illegal: "\\n",
+			relevance: 0
+		};
+		var MODES = [
+			KEY,
+			{
+				className: "meta",
+				begin: "^---\\s*$",
+				relevance: 10
+			},
+			{
+				className: "string",
+				begin: "[\\|>]([1-9]?[+-])?[ ]*\\n( +)[^ ][^\\n]*\\n(\\2[^\\n]+\\n?)*"
+			},
+			{
+				begin: "<%[%=-]?",
+				end: "[%-]?%>",
+				subLanguage: "ruby",
+				excludeBegin: true,
+				excludeEnd: true,
+				relevance: 0
+			},
+			{
+				className: "type",
+				begin: "!\\w+!" + URI_CHARACTERS
+			},
+			{
+				className: "type",
+				begin: "!<" + URI_CHARACTERS + ">"
+			},
+			{
+				className: "type",
+				begin: "!" + URI_CHARACTERS
+			},
+			{
+				className: "type",
+				begin: "!!" + URI_CHARACTERS
+			},
+			{
+				className: "meta",
+				begin: "&" + hljs.UNDERSCORE_IDENT_RE + "$"
+			},
+			{
+				className: "meta",
+				begin: "\\*" + hljs.UNDERSCORE_IDENT_RE + "$"
+			},
+			{
+				className: "bullet",
+				begin: "-(?=[ ]|$)",
+				relevance: 0
+			},
+			hljs.HASH_COMMENT_MODE,
+			{
+				beginKeywords: LITERALS,
+				keywords: { literal: LITERALS }
+			},
+			TIMESTAMP,
+			{
+				className: "number",
+				begin: hljs.C_NUMBER_RE + "\\b",
+				relevance: 0
+			},
+			OBJECT,
+			ARRAY,
+			STRING
+		];
+		var VALUE_MODES = [...MODES];
+		VALUE_MODES.pop();
+		VALUE_MODES.push(CONTAINER_STRING);
+		VALUE_CONTAINER.contains = VALUE_MODES;
+		return {
+			name: "YAML",
+			case_insensitive: true,
+			aliases: ["yml"],
+			contains: MODES
+		};
+	}
+	module.exports = yaml;
+}));
+
+//#endregion
+export default require_yaml();

package/dist/yang-BPvrq4K7.js

@@ -0,0 +1,30 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/yang.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+yang.displayName = "yang";
+yang.aliases = [];
+/** @param {Refractor} Prism */
+function yang(Prism) {
+	Prism.languages.yang = {
+		comment: /\/\*[\s\S]*?\*\/|\/\/.*/,
+		string: {
+			pattern: /"(?:[^\\"]|\\.)*"|'[^']*'/,
+			greedy: true
+		},
+		keyword: {
+			pattern: /(^|[{};\r\n][ \t]*)[a-z_][\w.-]*/i,
+			lookbehind: true
+		},
+		namespace: {
+			pattern: /(\s)[a-z_][\w.-]*(?=:)/i,
+			lookbehind: true
+		},
+		boolean: /\b(?:false|true)\b/,
+		operator: /\+/,
+		punctuation: /[{};:]/
+	};
+}
+
+//#endregion
+export { yang as default };

package/dist/zephir-DLtCQJhr.js

@@ -0,0 +1,80 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/zephir.js
+var require_zephir = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type LanguageFn */
+	function zephir(hljs) {
+		const STRING = {
+			className: "string",
+			contains: [hljs.BACKSLASH_ESCAPE],
+			variants: [hljs.inherit(hljs.APOS_STRING_MODE, { illegal: null }), hljs.inherit(hljs.QUOTE_STRING_MODE, { illegal: null })]
+		};
+		const TITLE_MODE = hljs.UNDERSCORE_TITLE_MODE;
+		const NUMBER = { variants: [hljs.BINARY_NUMBER_MODE, hljs.C_NUMBER_MODE] };
+		const KEYWORDS = "namespace class interface use extends function return abstract final public protected private static deprecated throw try catch Exception echo empty isset instanceof unset let var new const self require if else elseif switch case default do while loop for continue break likely unlikely __LINE__ __FILE__ __DIR__ __FUNCTION__ __CLASS__ __TRAIT__ __METHOD__ __NAMESPACE__ array boolean float double integer object resource string char long unsigned bool int uint ulong uchar true false null undefined";
+		return {
+			name: "Zephir",
+			aliases: ["zep"],
+			keywords: KEYWORDS,
+			contains: [
+				hljs.C_LINE_COMMENT_MODE,
+				hljs.COMMENT(/\/\*/, /\*\//, { contains: [{
+					className: "doctag",
+					begin: /@[A-Za-z]+/
+				}] }),
+				{
+					className: "string",
+					begin: /<<<['"]?\w+['"]?$/,
+					end: /^\w+;/,
+					contains: [hljs.BACKSLASH_ESCAPE]
+				},
+				{ begin: /(::|->)+[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/ },
+				{
+					className: "function",
+					beginKeywords: "function fn",
+					end: /[;{]/,
+					excludeEnd: true,
+					illegal: /\$|\[|%/,
+					contains: [TITLE_MODE, {
+						className: "params",
+						begin: /\(/,
+						end: /\)/,
+						keywords: KEYWORDS,
+						contains: [
+							"self",
+							hljs.C_BLOCK_COMMENT_MODE,
+							STRING,
+							NUMBER
+						]
+					}]
+				},
+				{
+					className: "class",
+					beginKeywords: "class interface",
+					end: /\{/,
+					excludeEnd: true,
+					illegal: /[:($"]/,
+					contains: [{ beginKeywords: "extends implements" }, TITLE_MODE]
+				},
+				{
+					beginKeywords: "namespace",
+					end: /;/,
+					illegal: /[.']/,
+					contains: [TITLE_MODE]
+				},
+				{
+					beginKeywords: "use",
+					end: /;/,
+					contains: [TITLE_MODE]
+				},
+				{ begin: /=>/ },
+				STRING,
+				NUMBER
+			]
+		};
+	}
+	module.exports = zephir;
+}));
+
+//#endregion
+export default require_zephir();

package/dist/zig-XkIsWF4D.js

@@ -0,0 +1,76 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/zig.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+zig.displayName = "zig";
+zig.aliases = [];
+/** @param {Refractor} Prism */
+function zig(Prism) {
+	(function(Prism) {
+		function literal(str) {
+			return function() {
+				return str;
+			};
+		}
+		var keyword = /\b(?:align|allowzero|and|anyframe|anytype|asm|async|await|break|cancel|catch|comptime|const|continue|defer|else|enum|errdefer|error|export|extern|fn|for|if|inline|linksection|nakedcc|noalias|nosuspend|null|or|orelse|packed|promise|pub|resume|return|stdcallcc|struct|suspend|switch|test|threadlocal|try|undefined|union|unreachable|usingnamespace|var|volatile|while)\b/;
+		var IDENTIFIER = "\\b(?!" + keyword.source + ")(?!\\d)\\w+\\b";
+		var ALIGN = /align\s*\((?:[^()]|\([^()]*\))*\)/.source;
+		var PREFIX_TYPE_OP = /(?:\?|\bpromise->|(?:\[[^[\]]*\]|\*(?!\*)|\*\*)(?:\s*<ALIGN>|\s*const\b|\s*volatile\b|\s*allowzero\b)*)/.source.replace(/<ALIGN>/g, literal(ALIGN));
+		var SUFFIX_EXPR = /(?:\bpromise\b|(?:\berror\.)?<ID>(?:\.<ID>)*(?!\s+<ID>))/.source.replace(/<ID>/g, literal(IDENTIFIER));
+		var TYPE = "(?!\\s)(?:!?\\s*(?:" + PREFIX_TYPE_OP + "\\s*)*" + SUFFIX_EXPR + ")+";
+		Prism.languages.zig = {
+			comment: [{
+				pattern: /\/\/[/!].*/,
+				alias: "doc-comment"
+			}, /\/{2}.*/],
+			string: [{
+				pattern: /(^|[^\\@])c?"(?:[^"\\\r\n]|\\.)*"/,
+				lookbehind: true,
+				greedy: true
+			}, {
+				pattern: /([\r\n])([ \t]+c?\\{2}).*(?:(?:\r\n?|\n)\2.*)*/,
+				lookbehind: true,
+				greedy: true
+			}],
+			char: {
+				pattern: /(^|[^\\])'(?:[^'\\\r\n]|[\uD800-\uDFFF]{2}|\\(?:.|x[a-fA-F\d]{2}|u\{[a-fA-F\d]{1,6}\}))'/,
+				lookbehind: true,
+				greedy: true
+			},
+			builtin: /\B@(?!\d)\w+(?=\s*\()/,
+			label: {
+				pattern: /(\b(?:break|continue)\s*:\s*)\w+\b|\b(?!\d)\w+\b(?=\s*:\s*(?:\{|while\b))/,
+				lookbehind: true
+			},
+			"class-name": [
+				/\b(?!\d)\w+(?=\s*=\s*(?:(?:extern|packed)\s+)?(?:enum|struct|union)\s*[({])/,
+				{
+					pattern: RegExp(/(:\s*)<TYPE>(?=\s*(?:<ALIGN>\s*)?[=;,)])|<TYPE>(?=\s*(?:<ALIGN>\s*)?\{)/.source.replace(/<TYPE>/g, literal(TYPE)).replace(/<ALIGN>/g, literal(ALIGN))),
+					lookbehind: true,
+					inside: null
+				},
+				{
+					pattern: RegExp(/(\)\s*)<TYPE>(?=\s*(?:<ALIGN>\s*)?;)/.source.replace(/<TYPE>/g, literal(TYPE)).replace(/<ALIGN>/g, literal(ALIGN))),
+					lookbehind: true,
+					inside: null
+				}
+			],
+			"builtin-type": {
+				pattern: /\b(?:anyerror|bool|c_u?(?:int|long|longlong|short)|c_longdouble|c_void|comptime_(?:float|int)|f(?:16|32|64|128)|[iu](?:8|16|32|64|128|size)|noreturn|type|void)\b/,
+				alias: "keyword"
+			},
+			keyword,
+			function: /\b(?!\d)\w+(?=\s*\()/,
+			number: /\b(?:0b[01]+|0o[0-7]+|0x[a-fA-F\d]+(?:\.[a-fA-F\d]*)?(?:[pP][+-]?[a-fA-F\d]+)?|\d+(?:\.\d*)?(?:[eE][+-]?\d+)?)\b/,
+			boolean: /\b(?:false|true)\b/,
+			operator: /\.[*?]|\.{2,3}|[-=]>|\*\*|\+\+|\|\||(?:<<|>>|[-+*]%|[-+*/%^&|<>!=])=?|[?~]/,
+			punctuation: /[.:,;(){}[\]]/
+		};
+		Prism.languages.zig["class-name"].forEach(function(obj) {
+			if (obj.inside === null) obj.inside = Prism.languages.zig;
+		});
+	})(Prism);
+}
+
+//#endregion
+export { zig as default };