@webskill/chatbot 0.0.1

package/dist/puppet-Bbx71Wmu.js

@@ -0,0 +1,91 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/puppet.js
+var require_puppet = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function puppet(hljs) {
+		const PUPPET_KEYWORDS = {
+			keyword: "and case default else elsif false if in import enherits node or true undef unless main settings $string ",
+			literal: "alias audit before loglevel noop require subscribe tag owner ensure group mode name|0 changes context force incl lens load_path onlyif provider returns root show_diff type_check en_address ip_address realname command environment hour monute month monthday special target weekday creates cwd ogoutput refresh refreshonly tries try_sleep umask backup checksum content ctime force ignore links mtime purge recurse recurselimit replace selinux_ignore_defaults selrange selrole seltype seluser source souirce_permissions sourceselect validate_cmd validate_replacement allowdupe attribute_membership auth_membership forcelocal gid ia_load_module members system host_aliases ip allowed_trunk_vlans description device_url duplex encapsulation etherchannel native_vlan speed principals allow_root auth_class auth_type authenticate_user k_of_n mechanisms rule session_owner shared options device fstype enable hasrestart directory present absent link atboot blockdevice device dump pass remounts poller_tag use message withpath adminfile allow_virtual allowcdrom category configfiles flavor install_options instance package_settings platform responsefile status uninstall_options vendor unless_system_user unless_uid binary control flags hasstatus manifest pattern restart running start stop allowdupe auths expiry gid groups home iterations key_membership keys managehome membership password password_max_age password_min_age profile_membership profiles project purge_ssh_keys role_membership roles salt shell uid baseurl cost descr enabled enablegroups exclude failovermethod gpgcheck gpgkey http_caching include includepkgs keepalive metadata_expire metalink mirrorlist priority protect proxy proxy_password proxy_username repo_gpgcheck s3_enabled skip_if_unavailable sslcacert sslclientcert sslclientkey sslverify mounted",
+			built_in: "architecture augeasversion blockdevices boardmanufacturer boardproductname boardserialnumber cfkey dhcp_servers domain ec2_ ec2_userdata facterversion filesystems ldom fqdn gid hardwareisa hardwaremodel hostname id|0 interfaces ipaddress ipaddress_ ipaddress6 ipaddress6_ iphostnumber is_virtual kernel kernelmajversion kernelrelease kernelversion kernelrelease kernelversion lsbdistcodename lsbdistdescription lsbdistid lsbdistrelease lsbmajdistrelease lsbminordistrelease lsbrelease macaddress macaddress_ macosx_buildversion macosx_productname macosx_productversion macosx_productverson_major macosx_productversion_minor manufacturer memoryfree memorysize netmask metmask_ network_ operatingsystem operatingsystemmajrelease operatingsystemrelease osfamily partitions path physicalprocessorcount processor processorcount productname ps puppetversion rubysitedir rubyversion selinux selinux_config_mode selinux_config_policy selinux_current_mode selinux_current_mode selinux_enforced selinux_policyversion serialnumber sp_ sshdsakey sshecdsakey sshrsakey swapencrypted swapfree swapsize timezone type uniqueid uptime uptime_days uptime_hours uptime_seconds uuid virtual vlans xendomains zfs_version zonenae zones zpool_version"
+		};
+		const COMMENT = hljs.COMMENT("#", "$");
+		const TITLE = hljs.inherit(hljs.TITLE_MODE, { begin: "([A-Za-z_]|::)(\\w|::)*" });
+		const VARIABLE = {
+			className: "variable",
+			begin: "\\$([A-Za-z_]|::)(\\w|::)*"
+		};
+		const STRING = {
+			className: "string",
+			contains: [hljs.BACKSLASH_ESCAPE, VARIABLE],
+			variants: [{
+				begin: /'/,
+				end: /'/
+			}, {
+				begin: /"/,
+				end: /"/
+			}]
+		};
+		return {
+			name: "Puppet",
+			aliases: ["pp"],
+			contains: [
+				COMMENT,
+				VARIABLE,
+				STRING,
+				{
+					beginKeywords: "class",
+					end: "\\{|;",
+					illegal: /=/,
+					contains: [TITLE, COMMENT]
+				},
+				{
+					beginKeywords: "define",
+					end: /\{/,
+					contains: [{
+						className: "section",
+						begin: hljs.IDENT_RE,
+						endsParent: true
+					}]
+				},
+				{
+					begin: hljs.IDENT_RE + "\\s+\\{",
+					returnBegin: true,
+					end: /\S/,
+					contains: [{
+						className: "keyword",
+						begin: hljs.IDENT_RE
+					}, {
+						begin: /\{/,
+						end: /\}/,
+						keywords: PUPPET_KEYWORDS,
+						relevance: 0,
+						contains: [
+							STRING,
+							COMMENT,
+							{
+								begin: "[a-zA-Z_]+\\s*=>",
+								returnBegin: true,
+								end: "=>",
+								contains: [{
+									className: "attr",
+									begin: hljs.IDENT_RE
+								}]
+							},
+							{
+								className: "number",
+								begin: "(\\b0[0-7_]+)|(\\b0x[0-9a-fA-F_]+)|(\\b[1-9][0-9_]*(\\.[0-9_]+)?)|[0_]\\b",
+								relevance: 0
+							},
+							VARIABLE
+						]
+					}],
+					relevance: 0
+				}
+			]
+		};
+	}
+	module.exports = puppet;
+}));
+
+//#endregion
+export default require_puppet();

package/dist/puppet-DWNpvtV0.js

@@ -0,0 +1,109 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/puppet.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+puppet.displayName = "puppet";
+puppet.aliases = [];
+/** @param {Refractor} Prism */
+function puppet(Prism) {
+	(function(Prism) {
+		Prism.languages.puppet = {
+			heredoc: [
+				{
+					pattern: /(@\("([^"\r\n\/):]+)"(?:\/[nrts$uL]*)?\).*(?:\r?\n|\r))(?:.*(?:\r?\n|\r(?!\n)))*?[ \t]*(?:\|[ \t]*)?(?:-[ \t]*)?\2/,
+					lookbehind: true,
+					alias: "string",
+					inside: { punctuation: /(?=\S).*\S(?= *$)/ }
+				},
+				{
+					pattern: /(@\(([^"\r\n\/):]+)(?:\/[nrts$uL]*)?\).*(?:\r?\n|\r))(?:.*(?:\r?\n|\r(?!\n)))*?[ \t]*(?:\|[ \t]*)?(?:-[ \t]*)?\2/,
+					lookbehind: true,
+					greedy: true,
+					alias: "string",
+					inside: { punctuation: /(?=\S).*\S(?= *$)/ }
+				},
+				{
+					pattern: /@\("?(?:[^"\r\n\/):]+)"?(?:\/[nrts$uL]*)?\)/,
+					alias: "string",
+					inside: { punctuation: {
+						pattern: /(\().+?(?=\))/,
+						lookbehind: true
+					} }
+				}
+			],
+			"multiline-comment": {
+				pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
+				lookbehind: true,
+				greedy: true,
+				alias: "comment"
+			},
+			regex: {
+				pattern: /((?:\bnode\s+|[~=\(\[\{,]\s*|[=+]>\s*|^\s*))\/(?:[^\/\\]|\\[\s\S])+\/(?:[imx]+\b|\B)/,
+				lookbehind: true,
+				greedy: true,
+				inside: { "extended-regex": {
+					pattern: /^\/(?:[^\/\\]|\\[\s\S])+\/[im]*x[im]*$/,
+					inside: { comment: /#.*/ }
+				} }
+			},
+			comment: {
+				pattern: /(^|[^\\])#.*/,
+				lookbehind: true,
+				greedy: true
+			},
+			string: {
+				pattern: /(["'])(?:\$\{(?:[^'"}]|(["'])(?:(?!\2)[^\\]|\\[\s\S])*\2)+\}|\$(?!\{)|(?!\1)[^\\$]|\\[\s\S])*\1/,
+				greedy: true,
+				inside: { "double-quoted": {
+					pattern: /^"[\s\S]*"$/,
+					inside: {}
+				} }
+			},
+			variable: {
+				pattern: /\$(?:::)?\w+(?:::\w+)*/,
+				inside: { punctuation: /::/ }
+			},
+			"attr-name": /(?:\b\w+|\*)(?=\s*=>)/,
+			function: [{
+				pattern: /(\.)(?!\d)\w+/,
+				lookbehind: true
+			}, /\b(?:contain|debug|err|fail|include|info|notice|realize|require|tag|warning)\b|\b(?!\d)\w+(?=\()/],
+			number: /\b(?:0x[a-f\d]+|\d+(?:\.\d+)?(?:e-?\d+)?)\b/i,
+			boolean: /\b(?:false|true)\b/,
+			keyword: /\b(?:application|attr|case|class|consumes|default|define|else|elsif|function|if|import|inherits|node|private|produces|type|undef|unless)\b/,
+			datatype: {
+				pattern: /\b(?:Any|Array|Boolean|Callable|Catalogentry|Class|Collection|Data|Default|Enum|Float|Hash|Integer|NotUndef|Numeric|Optional|Pattern|Regexp|Resource|Runtime|Scalar|String|Struct|Tuple|Type|Undef|Variant)\b/,
+				alias: "symbol"
+			},
+			operator: /=[=~>]?|![=~]?|<(?:<\|?|[=~|-])?|>[>=]?|->?|~>|\|>?>?|[*\/%+?]|\b(?:and|in|or)\b/,
+			punctuation: /[\[\]{}().,;]|:+/
+		};
+		var interpolation = [{
+			pattern: /(^|[^\\])\$\{(?:[^'"{}]|\{[^}]*\}|(["'])(?:(?!\2)[^\\]|\\[\s\S])*\2)+\}/,
+			lookbehind: true,
+			inside: {
+				"short-variable": {
+					pattern: /(^\$\{)(?!\w+\()(?:::)?\w+(?:::\w+)*/,
+					lookbehind: true,
+					alias: "variable",
+					inside: { punctuation: /::/ }
+				},
+				delimiter: {
+					pattern: /^\$/,
+					alias: "variable"
+				},
+				rest: Prism.languages.puppet
+			}
+		}, {
+			pattern: /(^|[^\\])\$(?:::)?\w+(?:::\w+)*/,
+			lookbehind: true,
+			alias: "variable",
+			inside: { punctuation: /::/ }
+		}];
+		Prism.languages.puppet["heredoc"][0].inside.interpolation = interpolation;
+		Prism.languages.puppet["string"].inside["double-quoted"].inside.interpolation = interpolation;
+	})(Prism);
+}
+
+//#endregion
+export { puppet as default };

package/dist/pure-Bu8y9uqf.js

@@ -0,0 +1,84 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/pure.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+pure.displayName = "pure";
+pure.aliases = [];
+/** @param {Refractor} Prism */
+function pure(Prism) {
+	(function(Prism) {
+		Prism.languages.pure = {
+			comment: [
+				{
+					pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
+					lookbehind: true
+				},
+				{
+					pattern: /(^|[^\\:])\/\/.*/,
+					lookbehind: true
+				},
+				/#!.+/
+			],
+			"inline-lang": {
+				pattern: /%<[\s\S]+?%>/,
+				greedy: true,
+				inside: {
+					lang: {
+						pattern: /(^%< *)-\*-.+?-\*-/,
+						lookbehind: true,
+						alias: "comment"
+					},
+					delimiter: {
+						pattern: /^%<.*|%>$/,
+						alias: "punctuation"
+					}
+				}
+			},
+			string: {
+				pattern: /"(?:\\.|[^"\\\r\n])*"/,
+				greedy: true
+			},
+			number: {
+				pattern: /((?:\.\.)?)(?:\b(?:inf|nan)\b|\b0x[\da-f]+|(?:\b(?:0b)?\d+(?:\.\d+)?|\B\.\d+)(?:e[+-]?\d+)?L?)/i,
+				lookbehind: true
+			},
+			keyword: /\b(?:NULL|ans|break|bt|case|catch|cd|clear|const|def|del|dump|else|end|exit|extern|false|force|help|if|infix[lr]?|interface|let|ls|mem|namespace|nonfix|of|otherwise|outfix|override|postfix|prefix|private|public|pwd|quit|run|save|show|stats|then|throw|trace|true|type|underride|using|when|with)\b/,
+			function: /\b(?:abs|add_(?:addr|constdef|(?:fundef|interface|macdef|typedef)(?:_at)?|vardef)|all|any|applp?|arity|bigintp?|blob(?:_crc|_size|p)?|boolp?|byte_c?string(?:_pointer)?|byte_(?:matrix|pointer)|calloc|cat|catmap|ceil|char[ps]?|check_ptrtag|chr|clear_sentry|clearsym|closurep?|cmatrixp?|cols?|colcat(?:map)?|colmap|colrev|colvector(?:p|seq)?|complex(?:_float_(?:matrix|pointer)|_matrix(?:_view)?|_pointer|p)?|conj|cookedp?|cst|cstring(?:_(?:dup|list|vector))?|curry3?|cyclen?|del_(?:constdef|fundef|interface|macdef|typedef|vardef)|delete|diag(?:mat)?|dim|dmatrixp?|do|double(?:_matrix(?:_view)?|_pointer|p)?|dowith3?|drop|dropwhile|eval(?:cmd)?|exactp|filter|fix|fixity|flip|float(?:_matrix|_pointer)|floor|fold[lr]1?|frac|free|funp?|functionp?|gcd|get(?:_(?:byte|constdef|double|float|fundef|int(?:64)?|interface(?:_typedef)?|long|macdef|pointer|ptrtag|sentry|short|string|typedef|vardef))?|globsym|hash|head|id|im|imatrixp?|index|inexactp|infp|init|insert|int(?:_matrix(?:_view)?|_pointer|p)?|int64_(?:matrix|pointer)|integerp?|iteraten?|iterwhile|join|keys?|lambdap?|last(?:err(?:pos)?)?|lcd|list[2p]?|listmap|make_ptrtag|malloc|map|matcat|matrixp?|max|member|min|nanp|nargs|nmatrixp?|null|numberp?|ord|pack(?:ed)?|pointer(?:_cast|_tag|_type|p)?|pow|pred|ptrtag|put(?:_(?:byte|double|float|int(?:64)?|long|pointer|short|string))?|rationalp?|re|realp?|realloc|recordp?|redim|reduce(?:_with)?|refp?|repeatn?|reverse|rlistp?|round|rows?|rowcat(?:map)?|rowmap|rowrev|rowvector(?:p|seq)?|same|scan[lr]1?|sentry|sgn|short_(?:matrix|pointer)|slice|smatrixp?|sort|split|str|strcat|stream|stride|string(?:_(?:dup|list|vector)|p)?|subdiag(?:mat)?|submat|subseq2?|substr|succ|supdiag(?:mat)?|symbolp?|tail|take|takewhile|thunkp?|transpose|trunc|tuplep?|typep|ubyte|uint(?:64)?|ulong|uncurry3?|unref|unzip3?|update|ushort|vals?|varp?|vector(?:p|seq)?|void|zip3?|zipwith3?)\b/,
+			special: {
+				pattern: /\b__[a-z]+__\b/i,
+				alias: "builtin"
+			},
+			operator: /(?:[!"#$%&'*+,\-.\/:<=>?@\\^`|~\u00a1-\u00bf\u00d7-\u00f7\u20d0-\u2bff]|\b_+\b)+|\b(?:and|div|mod|not|or)\b/,
+			punctuation: /[(){}\[\];,|]/
+		};
+		var inlineLanguages = [
+			"c",
+			{
+				lang: "c++",
+				alias: "cpp"
+			},
+			"fortran"
+		];
+		var inlineLanguageRe = /%< *-\*- *<lang>\d* *-\*-[\s\S]+?%>/.source;
+		inlineLanguages.forEach(function(lang) {
+			var alias = lang;
+			if (typeof lang !== "string") {
+				alias = lang.alias;
+				lang = lang.lang;
+			}
+			if (Prism.languages[alias]) {
+				var o = {};
+				o["inline-lang-" + alias] = {
+					pattern: RegExp(inlineLanguageRe.replace("<lang>", lang.replace(/([.+*?\/\\(){}\[\]])/g, "\\$1")), "i"),
+					inside: Prism.util.clone(Prism.languages.pure["inline-lang"].inside)
+				};
+				o["inline-lang-" + alias].inside.rest = Prism.util.clone(Prism.languages[alias]);
+				Prism.languages.insertBefore("pure", "inline-lang", o);
+			}
+		});
+		if (Prism.languages.c) Prism.languages.pure["inline-lang"].inside.rest = Prism.util.clone(Prism.languages.c);
+	})(Prism);
+}
+
+//#endregion
+export { pure as default };

package/dist/purebasic-CrbZ5tkq.js

@@ -0,0 +1,48 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/purebasic.js
+var require_purebasic = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function purebasic(hljs) {
+		return {
+			name: "PureBASIC",
+			aliases: ["pb", "pbi"],
+			keywords: "Align And Array As Break CallDebugger Case CompilerCase CompilerDefault CompilerElse CompilerElseIf CompilerEndIf CompilerEndSelect CompilerError CompilerIf CompilerSelect CompilerWarning Continue Data DataSection Debug DebugLevel Declare DeclareC DeclareCDLL DeclareDLL DeclareModule Default Define Dim DisableASM DisableDebugger DisableExplicit Else ElseIf EnableASM EnableDebugger EnableExplicit End EndDataSection EndDeclareModule EndEnumeration EndIf EndImport EndInterface EndMacro EndModule EndProcedure EndSelect EndStructure EndStructureUnion EndWith Enumeration EnumerationBinary Extends FakeReturn For ForEach ForEver Global Gosub Goto If Import ImportC IncludeBinary IncludeFile IncludePath Interface List Macro MacroExpandedCount Map Module NewList NewMap Next Not Or Procedure ProcedureC ProcedureCDLL ProcedureDLL ProcedureReturn Protected Prototype PrototypeC ReDim Read Repeat Restore Return Runtime Select Shared Static Step Structure StructureUnion Swap Threaded To UndefineMacro Until Until  UnuseModule UseModule Wend While With XIncludeFile XOr",
+			contains: [
+				hljs.COMMENT(";", "$", { relevance: 0 }),
+				{
+					className: "function",
+					begin: "\\b(Procedure|Declare)(C|CDLL|DLL)?\\b",
+					end: "\\(",
+					excludeEnd: true,
+					returnBegin: true,
+					contains: [
+						{
+							className: "keyword",
+							begin: "(Procedure|Declare)(C|CDLL|DLL)?",
+							excludeEnd: true
+						},
+						{
+							className: "type",
+							begin: "\\.\\w*"
+						},
+						hljs.UNDERSCORE_TITLE_MODE
+					]
+				},
+				{
+					className: "string",
+					begin: "(~)?\"",
+					end: "\"",
+					illegal: "\\n"
+				},
+				{
+					className: "symbol",
+					begin: "#[a-zA-Z_]\\w*\\$?"
+				}
+			]
+		};
+	}
+	module.exports = purebasic;
+}));
+
+//#endregion
+export default require_purebasic();

package/dist/purebasic-DXeoj54G.js

@@ -0,0 +1,68 @@
+import { t as clike } from "./clike-BvmU1AL7.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/purebasic.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+purebasic.displayName = "purebasic";
+purebasic.aliases = ["pbfasm"];
+/** @param {Refractor} Prism */
+function purebasic(Prism) {
+	Prism.register(clike);
+	Prism.languages.purebasic = Prism.languages.extend("clike", {
+		comment: /;.*/,
+		keyword: /\b(?:align|and|as|break|calldebugger|case|compilercase|compilerdefault|compilerelse|compilerelseif|compilerendif|compilerendselect|compilererror|compilerif|compilerselect|continue|data|datasection|debug|debuglevel|declare|declarec|declarecdll|declaredll|declaremodule|default|define|dim|disableasm|disabledebugger|disableexplicit|else|elseif|enableasm|enabledebugger|enableexplicit|end|enddatasection|enddeclaremodule|endenumeration|endif|endimport|endinterface|endmacro|endmodule|endprocedure|endselect|endstructure|endstructureunion|endwith|enumeration|extends|fakereturn|for|foreach|forever|global|gosub|goto|if|import|importc|includebinary|includefile|includepath|interface|macro|module|newlist|newmap|next|not|or|procedure|procedurec|procedurecdll|proceduredll|procedurereturn|protected|prototype|prototypec|read|redim|repeat|restore|return|runtime|select|shared|static|step|structure|structureunion|swap|threaded|to|until|wend|while|with|xincludefile|xor)\b/i,
+		function: /\b\w+(?:\.\w+)?\s*(?=\()/,
+		number: /(?:\$[\da-f]+|\b-?(?:\d+(?:\.\d+)?|\.\d+)(?:e[+-]?\d+)?)\b/i,
+		operator: /(?:@\*?|\?|\*)\w+\$?|-[>-]?|\+\+?|!=?|<<?=?|>>?=?|==?|&&?|\|?\||[~^%?*/@]/
+	});
+	Prism.languages.insertBefore("purebasic", "keyword", {
+		tag: /#\w+\$?/,
+		asm: {
+			pattern: /(^[\t ]*)!.*/m,
+			lookbehind: true,
+			alias: "tag",
+			inside: {
+				comment: /;.*/,
+				string: {
+					pattern: /(["'`])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+					greedy: true
+				},
+				"label-reference-anonymous": {
+					pattern: /(!\s*j[a-z]+\s+)@[fb]/i,
+					lookbehind: true,
+					alias: "fasm-label"
+				},
+				"label-reference-addressed": {
+					pattern: /(!\s*j[a-z]+\s+)[A-Z._?$@][\w.?$@~#]*/i,
+					lookbehind: true,
+					alias: "fasm-label"
+				},
+				keyword: [/\b(?:extern|global)\b[^;\r\n]*/i, /\b(?:CPU|DEFAULT|FLOAT)\b.*/],
+				function: {
+					pattern: /^([\t ]*!\s*)[\da-z]+(?=\s|$)/im,
+					lookbehind: true
+				},
+				"function-inline": {
+					pattern: /(:\s*)[\da-z]+(?=\s)/i,
+					lookbehind: true,
+					alias: "function"
+				},
+				label: {
+					pattern: /^([\t ]*!\s*)[A-Za-z._?$@][\w.?$@~#]*(?=:)/m,
+					lookbehind: true,
+					alias: "fasm-label"
+				},
+				register: /\b(?:st\d|[xyz]mm\d\d?|[cdt]r\d|r\d\d?[bwd]?|[er]?[abcd]x|[abcd][hl]|[er]?(?:bp|di|si|sp)|[cdefgs]s|mm\d+)\b/i,
+				number: /(?:\b|-|(?=\$))(?:0[hx](?:[\da-f]*\.)?[\da-f]+(?:p[+-]?\d+)?|\d[\da-f]+[hx]|\$\d[\da-f]*|0[oq][0-7]+|[0-7]+[oq]|0[by][01]+|[01]+[by]|0[dt]\d+|(?:\d+(?:\.\d+)?|\.\d+)(?:\.?e[+-]?\d+)?[dt]?)\b/i,
+				operator: /[\[\]*+\-/%<>=&|$!,.:]/
+			}
+		}
+	});
+	delete Prism.languages.purebasic["class-name"];
+	delete Prism.languages.purebasic["boolean"];
+	Prism.languages.pbfasm = Prism.languages["purebasic"];
+}
+
+//#endregion
+export { purebasic as default };

package/dist/purescript-DEmt8FwY.js

@@ -0,0 +1,33 @@
+import haskell from "./haskell-DDqg24-B.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/purescript.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+purescript.displayName = "purescript";
+purescript.aliases = ["purs"];
+/** @param {Refractor} Prism */
+function purescript(Prism) {
+	Prism.register(haskell);
+	Prism.languages.purescript = Prism.languages.extend("haskell", {
+		keyword: /\b(?:ado|case|class|data|derive|do|else|forall|if|in|infixl|infixr|instance|let|module|newtype|of|primitive|then|type|where)\b|∀/,
+		"import-statement": {
+			pattern: /(^[\t ]*)import\s+[A-Z][\w']*(?:\.[A-Z][\w']*)*(?:\s+as\s+[A-Z][\w']*(?:\.[A-Z][\w']*)*)?(?:\s+hiding\b)?/m,
+			lookbehind: true,
+			inside: {
+				keyword: /\b(?:as|hiding|import)\b/,
+				punctuation: /\./
+			}
+		},
+		builtin: /\b(?:absurd|add|ap|append|apply|between|bind|bottom|clamp|compare|comparing|compose|conj|const|degree|discard|disj|div|eq|flap|flip|gcd|identity|ifM|join|lcm|liftA1|liftM1|map|max|mempty|min|mod|mul|negate|not|notEq|one|otherwise|recip|show|sub|top|unit|unless|unlessM|void|when|whenM|zero)\b/,
+		operator: [
+			Prism.languages.haskell.operator[0],
+			Prism.languages.haskell.operator[2],
+			/[\xa2-\xa6\xa8\xa9\xac\xae-\xb1\xb4\xb8\xd7\xf7\u02c2-\u02c5\u02d2-\u02df\u02e5-\u02eb\u02ed\u02ef-\u02ff\u0375\u0384\u0385\u03f6\u0482\u058d-\u058f\u0606-\u0608\u060b\u060e\u060f\u06de\u06e9\u06fd\u06fe\u07f6\u07fe\u07ff\u09f2\u09f3\u09fa\u09fb\u0af1\u0b70\u0bf3-\u0bfa\u0c7f\u0d4f\u0d79\u0e3f\u0f01-\u0f03\u0f13\u0f15-\u0f17\u0f1a-\u0f1f\u0f34\u0f36\u0f38\u0fbe-\u0fc5\u0fc7-\u0fcc\u0fce\u0fcf\u0fd5-\u0fd8\u109e\u109f\u1390-\u1399\u166d\u17db\u1940\u19de-\u19ff\u1b61-\u1b6a\u1b74-\u1b7c\u1fbd\u1fbf-\u1fc1\u1fcd-\u1fcf\u1fdd-\u1fdf\u1fed-\u1fef\u1ffd\u1ffe\u2044\u2052\u207a-\u207c\u208a-\u208c\u20a0-\u20bf\u2100\u2101\u2103-\u2106\u2108\u2109\u2114\u2116-\u2118\u211e-\u2123\u2125\u2127\u2129\u212e\u213a\u213b\u2140-\u2144\u214a-\u214d\u214f\u218a\u218b\u2190-\u2307\u230c-\u2328\u232b-\u2426\u2440-\u244a\u249c-\u24e9\u2500-\u2767\u2794-\u27c4\u27c7-\u27e5\u27f0-\u2982\u2999-\u29d7\u29dc-\u29fb\u29fe-\u2b73\u2b76-\u2b95\u2b97-\u2bff\u2ce5-\u2cea\u2e50\u2e51\u2e80-\u2e99\u2e9b-\u2ef3\u2f00-\u2fd5\u2ff0-\u2ffb\u3004\u3012\u3013\u3020\u3036\u3037\u303e\u303f\u309b\u309c\u3190\u3191\u3196-\u319f\u31c0-\u31e3\u3200-\u321e\u322a-\u3247\u3250\u3260-\u327f\u328a-\u32b0\u32c0-\u33ff\u4dc0-\u4dff\ua490-\ua4c6\ua700-\ua716\ua720\ua721\ua789\ua78a\ua828-\ua82b\ua836-\ua839\uaa77-\uaa79\uab5b\uab6a\uab6b\ufb29\ufbb2-\ufbc1\ufdfc\ufdfd\ufe62\ufe64-\ufe66\ufe69\uff04\uff0b\uff1c-\uff1e\uff3e\uff40\uff5c\uff5e\uffe0-\uffe6\uffe8-\uffee\ufffc\ufffd]/
+		]
+	});
+	Prism.languages.purs = Prism.languages.purescript;
+}
+
+//#endregion
+export { purescript as default };

package/dist/python-B_JMVOcZ.js

@@ -0,0 +1,72 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/python.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+python.displayName = "python";
+python.aliases = ["py"];
+/** @param {Refractor} Prism */
+function python(Prism) {
+	Prism.languages.python = {
+		comment: {
+			pattern: /(^|[^\\])#.*/,
+			lookbehind: true,
+			greedy: true
+		},
+		"string-interpolation": {
+			pattern: /(?:f|fr|rf)(?:("""|''')[\s\S]*?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i,
+			greedy: true,
+			inside: {
+				interpolation: {
+					pattern: /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}])+\})+\})+\}/,
+					lookbehind: true,
+					inside: {
+						"format-spec": {
+							pattern: /(:)[^:(){}]+(?=\}$)/,
+							lookbehind: true
+						},
+						"conversion-option": {
+							pattern: /![sra](?=[:}]$)/,
+							alias: "punctuation"
+						},
+						rest: null
+					}
+				},
+				string: /[\s\S]+/
+			}
+		},
+		"triple-quoted-string": {
+			pattern: /(?:[rub]|br|rb)?("""|''')[\s\S]*?\1/i,
+			greedy: true,
+			alias: "string"
+		},
+		string: {
+			pattern: /(?:[rub]|br|rb)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i,
+			greedy: true
+		},
+		function: {
+			pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g,
+			lookbehind: true
+		},
+		"class-name": {
+			pattern: /(\bclass\s+)\w+/i,
+			lookbehind: true
+		},
+		decorator: {
+			pattern: /(^[\t ]*)@\w+(?:\.\w+)*/m,
+			lookbehind: true,
+			alias: ["annotation", "punctuation"],
+			inside: { punctuation: /\./ }
+		},
+		keyword: /\b(?:_(?=\s*:)|and|as|assert|async|await|break|case|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\b/,
+		builtin: /\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\b/,
+		boolean: /\b(?:False|None|True)\b/,
+		number: /\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f0-9])+)\b|(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:e[+-]?\d+(?:_\d+)*)?j?(?!\w)/i,
+		operator: /[-+%=]=?|!=|:=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
+		punctuation: /[{}[\];(),.:]/
+	};
+	Prism.languages.python["string-interpolation"].inside["interpolation"].inside.rest = Prism.languages.python;
+	Prism.languages.py = Prism.languages.python;
+}
+
+//#endregion
+export { python as default };