@webskill/chatbot 0.0.1

package/dist/haml-DTsOZCFy.js

@@ -0,0 +1,142 @@
+import ruby from "./ruby-B8TWD6ep.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/haml.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+haml.displayName = "haml";
+haml.aliases = [];
+/** @param {Refractor} Prism */
+function haml(Prism) {
+	Prism.register(ruby);
+	(function(Prism) {
+		Prism.languages.haml = {
+			"multiline-comment": {
+				pattern: /((?:^|\r?\n|\r)([\t ]*))(?:\/|-#).*(?:(?:\r?\n|\r)\2[\t ].+)*/,
+				lookbehind: true,
+				alias: "comment"
+			},
+			"multiline-code": [{
+				pattern: /((?:^|\r?\n|\r)([\t ]*)(?:[~-]|[&!]?=)).*,[\t ]*(?:(?:\r?\n|\r)\2[\t ].*,[\t ]*)*(?:(?:\r?\n|\r)\2[\t ].+)/,
+				lookbehind: true,
+				inside: Prism.languages.ruby
+			}, {
+				pattern: /((?:^|\r?\n|\r)([\t ]*)(?:[~-]|[&!]?=)).*\|[\t ]*(?:(?:\r?\n|\r)\2[\t ].*\|[\t ]*)*/,
+				lookbehind: true,
+				inside: Prism.languages.ruby
+			}],
+			filter: {
+				pattern: /((?:^|\r?\n|\r)([\t ]*)):[\w-]+(?:(?:\r?\n|\r)(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/,
+				lookbehind: true,
+				inside: { "filter-name": {
+					pattern: /^:[\w-]+/,
+					alias: "symbol"
+				} }
+			},
+			markup: {
+				pattern: /((?:^|\r?\n|\r)[\t ]*)<.+/,
+				lookbehind: true,
+				inside: Prism.languages.markup
+			},
+			doctype: {
+				pattern: /((?:^|\r?\n|\r)[\t ]*)!!!(?: .+)?/,
+				lookbehind: true
+			},
+			tag: {
+				pattern: /((?:^|\r?\n|\r)[\t ]*)[%.#][\w\-#.]*[\w\-](?:\([^)]+\)|\{(?:\{[^}]+\}|[^{}])+\}|\[[^\]]+\])*[\/<>]*/,
+				lookbehind: true,
+				inside: {
+					attributes: [
+						{
+							pattern: /(^|[^#])\{(?:\{[^}]+\}|[^{}])+\}/,
+							lookbehind: true,
+							inside: Prism.languages.ruby
+						},
+						{
+							pattern: /\([^)]+\)/,
+							inside: {
+								"attr-value": {
+									pattern: /(=\s*)(?:"(?:\\.|[^\\"\r\n])*"|[^)\s]+)/,
+									lookbehind: true
+								},
+								"attr-name": /[\w:-]+(?=\s*!?=|\s*[,)])/,
+								punctuation: /[=(),]/
+							}
+						},
+						{
+							pattern: /\[[^\]]+\]/,
+							inside: Prism.languages.ruby
+						}
+					],
+					punctuation: /[<>]/
+				}
+			},
+			code: {
+				pattern: /((?:^|\r?\n|\r)[\t ]*(?:[~-]|[&!]?=)).+/,
+				lookbehind: true,
+				inside: Prism.languages.ruby
+			},
+			interpolation: {
+				pattern: /#\{[^}]+\}/,
+				inside: {
+					delimiter: {
+						pattern: /^#\{|\}$/,
+						alias: "punctuation"
+					},
+					ruby: {
+						pattern: /[\s\S]+/,
+						inside: Prism.languages.ruby
+					}
+				}
+			},
+			punctuation: {
+				pattern: /((?:^|\r?\n|\r)[\t ]*)[~=\-&!]+/,
+				lookbehind: true
+			}
+		};
+		var filter_pattern = "((?:^|\\r?\\n|\\r)([\\t ]*)):{{filter_name}}(?:(?:\\r?\\n|\\r)(?:\\2[\\t ].+|\\s*?(?=\\r?\\n|\\r)))+";
+		var filters = [
+			"css",
+			{
+				filter: "coffee",
+				language: "coffeescript"
+			},
+			"erb",
+			"javascript",
+			"less",
+			"markdown",
+			"ruby",
+			"scss",
+			"textile"
+		];
+		var all_filters = {};
+		for (var i = 0, l = filters.length; i < l; i++) {
+			var filter = filters[i];
+			filter = typeof filter === "string" ? {
+				filter,
+				language: filter
+			} : filter;
+			if (Prism.languages[filter.language]) all_filters["filter-" + filter.filter] = {
+				pattern: RegExp(filter_pattern.replace("{{filter_name}}", function() {
+					return filter.filter;
+				})),
+				lookbehind: true,
+				inside: {
+					"filter-name": {
+						pattern: /^:[\w-]+/,
+						alias: "symbol"
+					},
+					text: {
+						pattern: /[\s\S]+/,
+						alias: [filter.language, "language-" + filter.language],
+						inside: Prism.languages[filter.language]
+					}
+				}
+			};
+		}
+		Prism.languages.insertBefore("haml", "filter", all_filters);
+	})(Prism);
+}
+
+//#endregion
+export { haml as default };

package/dist/handlebars-CgUpx0AJ.js

@@ -0,0 +1,237 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/handlebars.js
+var require_handlebars = /* @__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 } re
+	* @returns {string}
+	*/
+	function anyNumberOfTimes(re) {
+		return concat("(", re, ")*");
+	}
+	/**
+	* @param {RegExp | string } re
+	* @returns {string}
+	*/
+	function optional(re) {
+		return concat("(", re, ")?");
+	}
+	/**
+	* @param {...(RegExp | string) } args
+	* @returns {string}
+	*/
+	function concat(...args) {
+		return args.map((x) => source(x)).join("");
+	}
+	/**
+	* Any of the passed expresssions may match
+	*
+	* Creates a huge this | this | that | that match
+	* @param {(RegExp | string)[] } args
+	* @returns {string}
+	*/
+	function either(...args) {
+		return "(" + args.map((x) => source(x)).join("|") + ")";
+	}
+	function handlebars(hljs) {
+		const BUILT_INS = { "builtin-name": [
+			"action",
+			"bindattr",
+			"collection",
+			"component",
+			"concat",
+			"debugger",
+			"each",
+			"each-in",
+			"get",
+			"hash",
+			"if",
+			"in",
+			"input",
+			"link-to",
+			"loc",
+			"log",
+			"lookup",
+			"mut",
+			"outlet",
+			"partial",
+			"query-params",
+			"render",
+			"template",
+			"textarea",
+			"unbound",
+			"unless",
+			"view",
+			"with",
+			"yield"
+		] };
+		const LITERALS = { literal: [
+			"true",
+			"false",
+			"undefined",
+			"null"
+		] };
+		const DOUBLE_QUOTED_ID_REGEX = /""|"[^"]+"/;
+		const SINGLE_QUOTED_ID_REGEX = /''|'[^']+'/;
+		const BRACKET_QUOTED_ID_REGEX = /\[\]|\[[^\]]+\]/;
+		const PLAIN_ID_REGEX = /[^\s!"#%&'()*+,.\/;<=>@\[\\\]^`{|}~]+/;
+		const PATH_DELIMITER_REGEX = /(\.|\/)/;
+		const ANY_ID = either(DOUBLE_QUOTED_ID_REGEX, SINGLE_QUOTED_ID_REGEX, BRACKET_QUOTED_ID_REGEX, PLAIN_ID_REGEX);
+		const IDENTIFIER_REGEX = concat(optional(/\.|\.\/|\//), ANY_ID, anyNumberOfTimes(concat(PATH_DELIMITER_REGEX, ANY_ID)));
+		const HASH_PARAM_REGEX = concat("(", BRACKET_QUOTED_ID_REGEX, "|", PLAIN_ID_REGEX, ")(?==)");
+		const HELPER_NAME_OR_PATH_EXPRESSION = {
+			begin: IDENTIFIER_REGEX,
+			lexemes: /[\w.\/]+/
+		};
+		const HELPER_PARAMETER = hljs.inherit(HELPER_NAME_OR_PATH_EXPRESSION, { keywords: LITERALS });
+		const SUB_EXPRESSION = {
+			begin: /\(/,
+			end: /\)/
+		};
+		const HASH = {
+			className: "attr",
+			begin: HASH_PARAM_REGEX,
+			relevance: 0,
+			starts: {
+				begin: /=/,
+				end: /=/,
+				starts: { contains: [
+					hljs.NUMBER_MODE,
+					hljs.QUOTE_STRING_MODE,
+					hljs.APOS_STRING_MODE,
+					HELPER_PARAMETER,
+					SUB_EXPRESSION
+				] }
+			}
+		};
+		const HELPER_PARAMETERS = {
+			contains: [
+				hljs.NUMBER_MODE,
+				hljs.QUOTE_STRING_MODE,
+				hljs.APOS_STRING_MODE,
+				{
+					begin: /as\s+\|/,
+					keywords: { keyword: "as" },
+					end: /\|/,
+					contains: [{ begin: /\w+/ }]
+				},
+				HASH,
+				HELPER_PARAMETER,
+				SUB_EXPRESSION
+			],
+			returnEnd: true
+		};
+		SUB_EXPRESSION.contains = [hljs.inherit(HELPER_NAME_OR_PATH_EXPRESSION, {
+			className: "name",
+			keywords: BUILT_INS,
+			starts: hljs.inherit(HELPER_PARAMETERS, { end: /\)/ })
+		})];
+		const OPENING_BLOCK_MUSTACHE_CONTENTS = hljs.inherit(HELPER_NAME_OR_PATH_EXPRESSION, {
+			keywords: BUILT_INS,
+			className: "name",
+			starts: hljs.inherit(HELPER_PARAMETERS, { end: /\}\}/ })
+		});
+		const CLOSING_BLOCK_MUSTACHE_CONTENTS = hljs.inherit(HELPER_NAME_OR_PATH_EXPRESSION, {
+			keywords: BUILT_INS,
+			className: "name"
+		});
+		const BASIC_MUSTACHE_CONTENTS = hljs.inherit(HELPER_NAME_OR_PATH_EXPRESSION, {
+			className: "name",
+			keywords: BUILT_INS,
+			starts: hljs.inherit(HELPER_PARAMETERS, { end: /\}\}/ })
+		});
+		return {
+			name: "Handlebars",
+			aliases: [
+				"hbs",
+				"html.hbs",
+				"html.handlebars",
+				"htmlbars"
+			],
+			case_insensitive: true,
+			subLanguage: "xml",
+			contains: [
+				{
+					begin: /\\\{\{/,
+					skip: true
+				},
+				{
+					begin: /\\\\(?=\{\{)/,
+					skip: true
+				},
+				hljs.COMMENT(/\{\{!--/, /--\}\}/),
+				hljs.COMMENT(/\{\{!/, /\}\}/),
+				{
+					className: "template-tag",
+					begin: /\{\{\{\{(?!\/)/,
+					end: /\}\}\}\}/,
+					contains: [OPENING_BLOCK_MUSTACHE_CONTENTS],
+					starts: {
+						end: /\{\{\{\{\//,
+						returnEnd: true,
+						subLanguage: "xml"
+					}
+				},
+				{
+					className: "template-tag",
+					begin: /\{\{\{\{\//,
+					end: /\}\}\}\}/,
+					contains: [CLOSING_BLOCK_MUSTACHE_CONTENTS]
+				},
+				{
+					className: "template-tag",
+					begin: /\{\{#/,
+					end: /\}\}/,
+					contains: [OPENING_BLOCK_MUSTACHE_CONTENTS]
+				},
+				{
+					className: "template-tag",
+					begin: /\{\{(?=else\}\})/,
+					end: /\}\}/,
+					keywords: "else"
+				},
+				{
+					className: "template-tag",
+					begin: /\{\{(?=else if)/,
+					end: /\}\}/,
+					keywords: "else if"
+				},
+				{
+					className: "template-tag",
+					begin: /\{\{\//,
+					end: /\}\}/,
+					contains: [CLOSING_BLOCK_MUSTACHE_CONTENTS]
+				},
+				{
+					className: "template-variable",
+					begin: /\{\{\{/,
+					end: /\}\}\}/,
+					contains: [BASIC_MUSTACHE_CONTENTS]
+				},
+				{
+					className: "template-variable",
+					begin: /\{\{/,
+					end: /\}\}/,
+					contains: [BASIC_MUSTACHE_CONTENTS]
+				}
+			]
+		};
+	}
+	module.exports = handlebars;
+}));
+
+//#endregion
+export default require_handlebars();

package/dist/handlebars-DxHgnodb.js

@@ -0,0 +1,49 @@
+import { t as markupTemplating } from "./markup-templating-Ds-CZFSA.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/handlebars.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+handlebars.displayName = "handlebars";
+handlebars.aliases = ["hbs", "mustache"];
+/** @param {Refractor} Prism */
+function handlebars(Prism) {
+	Prism.register(markupTemplating);
+	(function(Prism) {
+		Prism.languages.handlebars = {
+			comment: /\{\{![\s\S]*?\}\}/,
+			delimiter: {
+				pattern: /^\{\{\{?|\}\}\}?$/,
+				alias: "punctuation"
+			},
+			string: /(["'])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+			number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee][+-]?\d+)?/,
+			boolean: /\b(?:false|true)\b/,
+			block: {
+				pattern: /^(\s*(?:~\s*)?)[#\/]\S+?(?=\s*(?:~\s*)?$|\s)/,
+				lookbehind: true,
+				alias: "keyword"
+			},
+			brackets: {
+				pattern: /\[[^\]]+\]/,
+				inside: {
+					punctuation: /\[|\]/,
+					variable: /[\s\S]+/
+				}
+			},
+			punctuation: /[!"#%&':()*+,.\/;<=>@\[\\\]^`{|}~]/,
+			variable: /[^!"#%&'()*+,\/;<=>@\[\\\]^`{|}~\s]+/
+		};
+		Prism.hooks.add("before-tokenize", function(env) {
+			Prism.languages["markup-templating"].buildPlaceholders(env, "handlebars", /\{\{\{[\s\S]+?\}\}\}|\{\{[\s\S]+?\}\}/g);
+		});
+		Prism.hooks.add("after-tokenize", function(env) {
+			Prism.languages["markup-templating"].tokenizePlaceholders(env, "handlebars");
+		});
+		Prism.languages.hbs = Prism.languages.handlebars;
+		Prism.languages.mustache = Prism.languages.handlebars;
+	})(Prism);
+}
+
+//#endregion
+export { handlebars as default };

package/dist/haskell-BFcEKjsB.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/haskell.js
+var require_haskell = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function haskell(hljs) {
+		const COMMENT = { variants: [hljs.COMMENT("--", "$"), hljs.COMMENT(/\{-/, /-\}/, { contains: ["self"] })] };
+		const PRAGMA = {
+			className: "meta",
+			begin: /\{-#/,
+			end: /#-\}/
+		};
+		const PREPROCESSOR = {
+			className: "meta",
+			begin: "^#",
+			end: "$"
+		};
+		const CONSTRUCTOR = {
+			className: "type",
+			begin: "\\b[A-Z][\\w']*",
+			relevance: 0
+		};
+		const LIST = {
+			begin: "\\(",
+			end: "\\)",
+			illegal: "\"",
+			contains: [
+				PRAGMA,
+				PREPROCESSOR,
+				{
+					className: "type",
+					begin: "\\b[A-Z][\\w]*(\\((\\.\\.|,|\\w+)\\))?"
+				},
+				hljs.inherit(hljs.TITLE_MODE, { begin: "[_a-z][\\w']*" }),
+				COMMENT
+			]
+		};
+		const RECORD = {
+			begin: /\{/,
+			end: /\}/,
+			contains: LIST.contains
+		};
+		return {
+			name: "Haskell",
+			aliases: ["hs"],
+			keywords: "let in if then else case of where do module import hiding qualified type data newtype deriving class instance as default infix infixl infixr foreign export ccall stdcall cplusplus jvm dotnet safe unsafe family forall mdo proc rec",
+			contains: [
+				{
+					beginKeywords: "module",
+					end: "where",
+					keywords: "module where",
+					contains: [LIST, COMMENT],
+					illegal: "\\W\\.|;"
+				},
+				{
+					begin: "\\bimport\\b",
+					end: "$",
+					keywords: "import qualified as hiding",
+					contains: [LIST, COMMENT],
+					illegal: "\\W\\.|;"
+				},
+				{
+					className: "class",
+					begin: "^(\\s*)?(class|instance)\\b",
+					end: "where",
+					keywords: "class family instance where",
+					contains: [
+						CONSTRUCTOR,
+						LIST,
+						COMMENT
+					]
+				},
+				{
+					className: "class",
+					begin: "\\b(data|(new)?type)\\b",
+					end: "$",
+					keywords: "data family type newtype deriving",
+					contains: [
+						PRAGMA,
+						CONSTRUCTOR,
+						LIST,
+						RECORD,
+						COMMENT
+					]
+				},
+				{
+					beginKeywords: "default",
+					end: "$",
+					contains: [
+						CONSTRUCTOR,
+						LIST,
+						COMMENT
+					]
+				},
+				{
+					beginKeywords: "infix infixl infixr",
+					end: "$",
+					contains: [hljs.C_NUMBER_MODE, COMMENT]
+				},
+				{
+					begin: "\\bforeign\\b",
+					end: "$",
+					keywords: "foreign import export ccall stdcall cplusplus jvm dotnet safe unsafe",
+					contains: [
+						CONSTRUCTOR,
+						hljs.QUOTE_STRING_MODE,
+						COMMENT
+					]
+				},
+				{
+					className: "meta",
+					begin: "#!\\/usr\\/bin\\/env runhaskell",
+					end: "$"
+				},
+				PRAGMA,
+				PREPROCESSOR,
+				hljs.QUOTE_STRING_MODE,
+				hljs.C_NUMBER_MODE,
+				CONSTRUCTOR,
+				hljs.inherit(hljs.TITLE_MODE, { begin: "^[_a-z][\\w']*" }),
+				COMMENT,
+				{ begin: "->|<-" }
+			]
+		};
+	}
+	module.exports = haskell;
+}));
+
+//#endregion
+export default require_haskell();

package/dist/haskell-DDqg24-B.js

@@ -0,0 +1,58 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/haskell.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+haskell.displayName = "haskell";
+haskell.aliases = ["hs"];
+/** @param {Refractor} Prism */
+function haskell(Prism) {
+	Prism.languages.haskell = {
+		comment: {
+			pattern: /(^|[^-!#$%*+=?&@|~.:<>^\\\/])(?:--(?:(?=.)[^-!#$%*+=?&@|~.:<>^\\\/].*|$)|\{-[\s\S]*?-\})/m,
+			lookbehind: true
+		},
+		char: {
+			pattern: /'(?:[^\\']|\\(?:[abfnrtv\\"'&]|\^[A-Z@[\]^_]|ACK|BEL|BS|CAN|CR|DC1|DC2|DC3|DC4|DEL|DLE|EM|ENQ|EOT|ESC|ETB|ETX|FF|FS|GS|HT|LF|NAK|NUL|RS|SI|SO|SOH|SP|STX|SUB|SYN|US|VT|\d+|o[0-7]+|x[0-9a-fA-F]+))'/,
+			alias: "string"
+		},
+		string: {
+			pattern: /"(?:[^\\"]|\\(?:\S|\s+\\))*"/,
+			greedy: true
+		},
+		keyword: /\b(?:case|class|data|deriving|do|else|if|in|infixl|infixr|instance|let|module|newtype|of|primitive|then|type|where)\b/,
+		"import-statement": {
+			pattern: /(^[\t ]*)import\s+(?:qualified\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|qualified)\b/,
+				punctuation: /\./
+			}
+		},
+		builtin: /\b(?:abs|acos|acosh|all|and|any|appendFile|approxRational|asTypeOf|asin|asinh|atan|atan2|atanh|basicIORun|break|catch|ceiling|chr|compare|concat|concatMap|const|cos|cosh|curry|cycle|decodeFloat|denominator|digitToInt|div|divMod|drop|dropWhile|either|elem|encodeFloat|enumFrom|enumFromThen|enumFromThenTo|enumFromTo|error|even|exp|exponent|fail|filter|flip|floatDigits|floatRadix|floatRange|floor|fmap|foldl|foldl1|foldr|foldr1|fromDouble|fromEnum|fromInt|fromInteger|fromIntegral|fromRational|fst|gcd|getChar|getContents|getLine|group|head|id|inRange|index|init|intToDigit|interact|ioError|isAlpha|isAlphaNum|isAscii|isControl|isDenormalized|isDigit|isHexDigit|isIEEE|isInfinite|isLower|isNaN|isNegativeZero|isOctDigit|isPrint|isSpace|isUpper|iterate|last|lcm|length|lex|lexDigits|lexLitChar|lines|log|logBase|lookup|map|mapM|mapM_|max|maxBound|maximum|maybe|min|minBound|minimum|mod|negate|not|notElem|null|numerator|odd|or|ord|otherwise|pack|pi|pred|primExitWith|print|product|properFraction|putChar|putStr|putStrLn|quot|quotRem|range|rangeSize|read|readDec|readFile|readFloat|readHex|readIO|readInt|readList|readLitChar|readLn|readOct|readParen|readSigned|reads|readsPrec|realToFrac|recip|rem|repeat|replicate|return|reverse|round|scaleFloat|scanl|scanl1|scanr|scanr1|seq|sequence|sequence_|show|showChar|showInt|showList|showLitChar|showParen|showSigned|showString|shows|showsPrec|significand|signum|sin|sinh|snd|sort|span|splitAt|sqrt|subtract|succ|sum|tail|take|takeWhile|tan|tanh|threadToIOResult|toEnum|toInt|toInteger|toLower|toRational|toUpper|truncate|uncurry|undefined|unlines|until|unwords|unzip|unzip3|userError|words|writeFile|zip|zip3|zipWith|zipWith3)\b/,
+		number: /\b(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?|0o[0-7]+|0x[0-9a-f]+)\b/i,
+		operator: [
+			{
+				pattern: /`(?:[A-Z][\w']*\.)*[_a-z][\w']*`/,
+				greedy: true
+			},
+			{
+				pattern: /(\s)\.(?=\s)/,
+				lookbehind: true
+			},
+			/[-!#$%*+=?&@|~:<>^\\\/][-!#$%*+=?&@|~.:<>^\\\/]*|\.[-!#$%*+=?&@|~.:<>^\\\/]+/
+		],
+		hvariable: {
+			pattern: /\b(?:[A-Z][\w']*\.)*[_a-z][\w']*/,
+			inside: { punctuation: /\./ }
+		},
+		constant: {
+			pattern: /\b(?:[A-Z][\w']*\.)*[A-Z][\w']*/,
+			inside: { punctuation: /\./ }
+		},
+		punctuation: /[{}[\];(),.:]/
+	};
+	Prism.languages.hs = Prism.languages.haskell;
+}
+
+//#endregion
+export { haskell as default };