@webskill/chatbot 0.0.1

package/dist/qore-BhVfCXhu.js

@@ -0,0 +1,34 @@
+import { t as clike } from "./clike-BvmU1AL7.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/qore.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+qore.displayName = "qore";
+qore.aliases = [];
+/** @param {Refractor} Prism */
+function qore(Prism) {
+	Prism.register(clike);
+	Prism.languages.qore = Prism.languages.extend("clike", {
+		comment: {
+			pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:\/\/|#).*)/,
+			lookbehind: true
+		},
+		string: {
+			pattern: /("|')(?:\\[\s\S]|(?!\1)[^\\])*\1/,
+			greedy: true
+		},
+		keyword: /\b(?:abstract|any|assert|binary|bool|boolean|break|byte|case|catch|char|class|code|const|continue|data|default|do|double|else|enum|extends|final|finally|float|for|goto|hash|if|implements|import|inherits|instanceof|int|interface|long|my|native|new|nothing|null|object|our|own|private|reference|rethrow|return|short|soft(?:bool|date|float|int|list|number|string)|static|strictfp|string|sub|super|switch|synchronized|this|throw|throws|transient|try|void|volatile|while)\b/,
+		boolean: /\b(?:false|true)\b/i,
+		function: /\$?\b(?!\d)\w+(?=\()/,
+		number: /\b(?:0b[01]+|0x(?:[\da-f]*\.)?[\da-fp\-]+|(?:\d+(?:\.\d+)?|\.\d+)(?:e\d+)?[df]|(?:\d+(?:\.\d+)?|\.\d+))\b/i,
+		operator: {
+			pattern: /(^|[^.])(?:\+[+=]?|-[-=]?|[!=](?:==?|~)?|>>?=?|<(?:=>?|<=?)?|&[&=]?|\|[|=]?|[*\/%^]=?|[~?])/,
+			lookbehind: true
+		},
+		variable: /\$(?!\d)\w+\b/
+	});
+}
+
+//#endregion
+export { qore as default };

package/dist/qsharp-DuDOe5Uc.js

@@ -0,0 +1,115 @@
+import { t as clike } from "./clike-BvmU1AL7.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/qsharp.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+qsharp.displayName = "qsharp";
+qsharp.aliases = ["qs"];
+/** @param {Refractor} Prism */
+function qsharp(Prism) {
+	Prism.register(clike);
+	(function(Prism) {
+		/**
+		* Replaces all placeholders "<<n>>" of given pattern with the n-th replacement (zero based).
+		*
+		* Note: This is a simple text based replacement. Be careful when using backreferences!
+		*
+		* @param {string} pattern the given pattern.
+		* @param {string[]} replacements a list of replacement which can be inserted into the given pattern.
+		* @returns {string} the pattern with all placeholders replaced with their corresponding replacements.
+		* @example replace(/a<<0>>a/.source, [/b+/.source]) === /a(?:b+)a/.source
+		*/
+		function replace(pattern, replacements) {
+			return pattern.replace(/<<(\d+)>>/g, function(m, index) {
+				return "(?:" + replacements[+index] + ")";
+			});
+		}
+		/**
+		* @param {string} pattern
+		* @param {string[]} replacements
+		* @param {string} [flags]
+		* @returns {RegExp}
+		*/
+		function re(pattern, replacements, flags) {
+			return RegExp(replace(pattern, replacements), flags || "");
+		}
+		/**
+		* Creates a nested pattern where all occurrences of the string `<<self>>` are replaced with the pattern itself.
+		*
+		* @param {string} pattern
+		* @param {number} depthLog2
+		* @returns {string}
+		*/
+		function nested(pattern, depthLog2) {
+			for (var i = 0; i < depthLog2; i++) pattern = pattern.replace(/<<self>>/g, function() {
+				return "(?:" + pattern + ")";
+			});
+			return pattern.replace(/<<self>>/g, "[^\\s\\S]");
+		}
+		var keywordKinds = {
+			type: "Adj BigInt Bool Ctl Double false Int One Pauli PauliI PauliX PauliY PauliZ Qubit Range Result String true Unit Zero",
+			other: "Adjoint adjoint apply as auto body borrow borrowing Controlled controlled distribute elif else fail fixup for function if in internal intrinsic invert is let mutable namespace new newtype open operation repeat return self set until use using while within"
+		};
+		function keywordsToPattern(words) {
+			return "\\b(?:" + words.trim().replace(/ /g, "|") + ")\\b";
+		}
+		var keywords = RegExp(keywordsToPattern(keywordKinds.type + " " + keywordKinds.other));
+		var identifier = /\b[A-Za-z_]\w*\b/.source;
+		var qualifiedName = replace(/<<0>>(?:\s*\.\s*<<0>>)*/.source, [identifier]);
+		var typeInside = {
+			keyword: keywords,
+			punctuation: /[<>()?,.:[\]]/
+		};
+		var regularString = /"(?:\\.|[^\\"])*"/.source;
+		Prism.languages.qsharp = Prism.languages.extend("clike", {
+			comment: /\/\/.*/,
+			string: [{
+				pattern: re(/(^|[^$\\])<<0>>/.source, [regularString]),
+				lookbehind: true,
+				greedy: true
+			}],
+			"class-name": [{
+				pattern: re(/(\b(?:as|open)\s+)<<0>>(?=\s*(?:;|as\b))/.source, [qualifiedName]),
+				lookbehind: true,
+				inside: typeInside
+			}, {
+				pattern: re(/(\bnamespace\s+)<<0>>(?=\s*\{)/.source, [qualifiedName]),
+				lookbehind: true,
+				inside: typeInside
+			}],
+			keyword: keywords,
+			number: /(?:\b0(?:x[\da-f]+|b[01]+|o[0-7]+)|(?:\B\.\d+|\b\d+(?:\.\d*)?)(?:e[-+]?\d+)?)l?\b/i,
+			operator: /\band=|\bor=|\band\b|\bnot\b|\bor\b|<[-=]|[-=]>|>>>=?|<<<=?|\^\^\^=?|\|\|\|=?|&&&=?|w\/=?|~~~|[*\/+\-^=!%]=?/,
+			punctuation: /::|[{}[\];(),.:]/
+		});
+		Prism.languages.insertBefore("qsharp", "number", { range: {
+			pattern: /\.\./,
+			alias: "operator"
+		} });
+		var interpolationExpr = nested(replace(/\{(?:[^"{}]|<<0>>|<<self>>)*\}/.source, [regularString]), 2);
+		Prism.languages.insertBefore("qsharp", "string", { "interpolation-string": {
+			pattern: re(/\$"(?:\\.|<<0>>|[^\\"{])*"/.source, [interpolationExpr]),
+			greedy: true,
+			inside: {
+				interpolation: {
+					pattern: re(/((?:^|[^\\])(?:\\\\)*)<<0>>/.source, [interpolationExpr]),
+					lookbehind: true,
+					inside: {
+						punctuation: /^\{|\}$/,
+						expression: {
+							pattern: /[\s\S]+/,
+							alias: "language-qsharp",
+							inside: Prism.languages.qsharp
+						}
+					}
+				},
+				string: /[\s\S]+/
+			}
+		} });
+	})(Prism);
+	Prism.languages.qs = Prism.languages.qsharp;
+}
+
+//#endregion
+export { qsharp as default };

package/dist/r-DYPUJFxX.js

@@ -0,0 +1,29 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/r.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+r.displayName = "r";
+r.aliases = [];
+/** @param {Refractor} Prism */
+function r(Prism) {
+	Prism.languages.r = {
+		comment: /#.*/,
+		string: {
+			pattern: /(['"])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+			greedy: true
+		},
+		"percent-operator": {
+			pattern: /%[^%\s]*%/,
+			alias: "operator"
+		},
+		boolean: /\b(?:FALSE|TRUE)\b/,
+		ellipsis: /\.\.(?:\.|\d+)/,
+		number: [/\b(?:Inf|NaN)\b/, /(?:\b0x[\dA-Fa-f]+(?:\.\d*)?|\b\d+(?:\.\d*)?|\B\.\d+)(?:[EePp][+-]?\d+)?[iL]?/],
+		keyword: /\b(?:NA|NA_character_|NA_complex_|NA_integer_|NA_real_|NULL|break|else|for|function|if|in|next|repeat|while)\b/,
+		operator: /->?>?|<(?:=|<?-)?|[>=!]=?|::?|&&?|\|\|?|[+*\/^$@~]/,
+		punctuation: /[(){}\[\],;]/
+	};
+}
+
+//#endregion
+export { r as default };

package/dist/r-xHPskriK.js

@@ -0,0 +1,164 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/r.js
+var require_r = /* @__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 lookahead(re) {
+		return concat("(?=", re, ")");
+	}
+	/**
+	* @param {...(RegExp | string) } args
+	* @returns {string}
+	*/
+	function concat(...args) {
+		return args.map((x) => source(x)).join("");
+	}
+	/** @type LanguageFn */
+	function r(hljs) {
+		const IDENT_RE = /(?:(?:[a-zA-Z]|\.[._a-zA-Z])[._a-zA-Z0-9]*)|\.(?!\d)/;
+		return {
+			name: "R",
+			illegal: /->/,
+			keywords: {
+				$pattern: IDENT_RE,
+				keyword: "function if in break next repeat else for while",
+				literal: "NULL NA TRUE FALSE Inf NaN NA_integer_|10 NA_real_|10 NA_character_|10 NA_complex_|10",
+				built_in: "LETTERS letters month.abb month.name pi T F abs acos acosh all any anyNA Arg as.call as.character as.complex as.double as.environment as.integer as.logical as.null.default as.numeric as.raw asin asinh atan atanh attr attributes baseenv browser c call ceiling class Conj cos cosh cospi cummax cummin cumprod cumsum digamma dim dimnames emptyenv exp expression floor forceAndCall gamma gc.time globalenv Im interactive invisible is.array is.atomic is.call is.character is.complex is.double is.environment is.expression is.finite is.function is.infinite is.integer is.language is.list is.logical is.matrix is.na is.name is.nan is.null is.numeric is.object is.pairlist is.raw is.recursive is.single is.symbol lazyLoadDBfetch length lgamma list log max min missing Mod names nargs nzchar oldClass on.exit pos.to.env proc.time prod quote range Re rep retracemem return round seq_along seq_len seq.int sign signif sin sinh sinpi sqrt standardGeneric substitute sum switch tan tanh tanpi tracemem trigamma trunc unclass untracemem UseMethod xtfrm"
+			},
+			compilerExtensions: [(mode, parent) => {
+				if (!mode.beforeMatch) return;
+				if (mode.starts) throw new Error("beforeMatch cannot be used with starts");
+				const originalMode = Object.assign({}, mode);
+				Object.keys(mode).forEach((key) => {
+					delete mode[key];
+				});
+				mode.begin = concat(originalMode.beforeMatch, lookahead(originalMode.begin));
+				mode.starts = {
+					relevance: 0,
+					contains: [Object.assign(originalMode, { endsParent: true })]
+				};
+				mode.relevance = 0;
+				delete originalMode.beforeMatch;
+			}],
+			contains: [
+				hljs.COMMENT(/#'/, /$/, { contains: [
+					{
+						className: "doctag",
+						begin: "@examples",
+						starts: { contains: [
+							{ begin: /\n/ },
+							{
+								begin: /#'\s*(?=@[a-zA-Z]+)/,
+								endsParent: true
+							},
+							{
+								begin: /#'/,
+								end: /$/,
+								excludeBegin: true
+							}
+						] }
+					},
+					{
+						className: "doctag",
+						begin: "@param",
+						end: /$/,
+						contains: [{
+							className: "variable",
+							variants: [{ begin: IDENT_RE }, { begin: /`(?:\\.|[^`\\])+`/ }],
+							endsParent: true
+						}]
+					},
+					{
+						className: "doctag",
+						begin: /@[a-zA-Z]+/
+					},
+					{
+						className: "meta-keyword",
+						begin: /\\[a-zA-Z]+/
+					}
+				] }),
+				hljs.HASH_COMMENT_MODE,
+				{
+					className: "string",
+					contains: [hljs.BACKSLASH_ESCAPE],
+					variants: [
+						hljs.END_SAME_AS_BEGIN({
+							begin: /[rR]"(-*)\(/,
+							end: /\)(-*)"/
+						}),
+						hljs.END_SAME_AS_BEGIN({
+							begin: /[rR]"(-*)\{/,
+							end: /\}(-*)"/
+						}),
+						hljs.END_SAME_AS_BEGIN({
+							begin: /[rR]"(-*)\[/,
+							end: /\](-*)"/
+						}),
+						hljs.END_SAME_AS_BEGIN({
+							begin: /[rR]'(-*)\(/,
+							end: /\)(-*)'/
+						}),
+						hljs.END_SAME_AS_BEGIN({
+							begin: /[rR]'(-*)\{/,
+							end: /\}(-*)'/
+						}),
+						hljs.END_SAME_AS_BEGIN({
+							begin: /[rR]'(-*)\[/,
+							end: /\](-*)'/
+						}),
+						{
+							begin: "\"",
+							end: "\"",
+							relevance: 0
+						},
+						{
+							begin: "'",
+							end: "'",
+							relevance: 0
+						}
+					]
+				},
+				{
+					className: "number",
+					relevance: 0,
+					beforeMatch: /([^a-zA-Z0-9._])/,
+					variants: [
+						{ match: /0[xX][0-9a-fA-F]+\.[0-9a-fA-F]*[pP][+-]?\d+i?/ },
+						{ match: /0[xX][0-9a-fA-F]+([pP][+-]?\d+)?[Li]?/ },
+						{ match: /(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?[Li]?/ }
+					]
+				},
+				{
+					begin: "%",
+					end: "%"
+				},
+				{ begin: concat(/[a-zA-Z][a-zA-Z_0-9]*/, "\\s+<-\\s+") },
+				{
+					begin: "`",
+					end: "`",
+					contains: [{ begin: /\\./ }]
+				}
+			]
+		};
+	}
+	module.exports = r;
+}));
+
+//#endregion
+export default require_r();

package/dist/racket-CpODvyno.js

@@ -0,0 +1,25 @@
+import scheme from "./scheme-B4kNWGag.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/racket.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+racket.displayName = "racket";
+racket.aliases = ["rkt"];
+/** @param {Refractor} Prism */
+function racket(Prism) {
+	Prism.register(scheme);
+	Prism.languages.racket = Prism.languages.extend("scheme", { "lambda-parameter": {
+		pattern: /([(\[]lambda\s+[(\[])[^()\[\]'\s]+/,
+		lookbehind: true
+	} });
+	Prism.languages.insertBefore("racket", "string", { lang: {
+		pattern: /^#lang.+/m,
+		greedy: true,
+		alias: "keyword"
+	} });
+	Prism.languages.rkt = Prism.languages.racket;
+}
+
+//#endregion
+export { racket as default };

package/dist/reason-hsgArTvF.js

@@ -0,0 +1,36 @@
+import { t as clike } from "./clike-BvmU1AL7.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/reason.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+reason.displayName = "reason";
+reason.aliases = [];
+/** @param {Refractor} Prism */
+function reason(Prism) {
+	Prism.register(clike);
+	Prism.languages.reason = Prism.languages.extend("clike", {
+		string: {
+			pattern: /"(?:\\(?:\r\n|[\s\S])|[^\\\r\n"])*"/,
+			greedy: true
+		},
+		"class-name": /\b[A-Z]\w*/,
+		keyword: /\b(?:and|as|assert|begin|class|constraint|do|done|downto|else|end|exception|external|for|fun|function|functor|if|in|include|inherit|initializer|lazy|let|method|module|mutable|new|nonrec|object|of|open|or|private|rec|sig|struct|switch|then|to|try|type|val|virtual|when|while|with)\b/,
+		operator: /\.{3}|:[:=]|\|>|->|=(?:==?|>)?|<=?|>=?|[|^?'#!~`]|[+\-*\/]\.?|\b(?:asr|land|lor|lsl|lsr|lxor|mod)\b/
+	});
+	Prism.languages.insertBefore("reason", "class-name", {
+		char: {
+			pattern: /'(?:\\x[\da-f]{2}|\\o[0-3][0-7][0-7]|\\\d{3}|\\.|[^'\\\r\n])'/,
+			greedy: true
+		},
+		constructor: /\b[A-Z]\w*\b(?!\s*\.)/,
+		label: {
+			pattern: /\b[a-z]\w*(?=::)/,
+			alias: "symbol"
+		}
+	});
+	delete Prism.languages.reason.function;
+}
+
+//#endregion
+export { reason as default };

package/dist/reasonml-CbjAE68o.js

@@ -0,0 +1,250 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/reasonml.js
+var require_reasonml = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function reasonml(hljs) {
+		function orReValues(ops) {
+			return ops.map(function(op) {
+				return op.split("").map(function(char) {
+					return "\\" + char;
+				}).join("");
+			}).join("|");
+		}
+		const RE_IDENT = "~?[a-z$_][0-9a-zA-Z$_]*";
+		const RE_MODULE_IDENT = "`?[A-Z$_][0-9a-zA-Z$_]*";
+		const RE_PARAM = "~?[a-z$_][0-9a-zA-Z$_]*(\\s*:\\s*[a-z$_][0-9a-z$_]*(\\(\\s*('?[a-z$_][0-9a-z$_]*\\s*(,'?[a-z$_][0-9a-z$_]*\\s*)*)?\\))?){0,2}";
+		const RE_OPERATOR = "(" + orReValues([
+			"||",
+			"++",
+			"**",
+			"+.",
+			"*",
+			"/",
+			"*.",
+			"/.",
+			"..."
+		]) + "|\\|>|&&|==|===)";
+		const RE_OPERATOR_SPACED = "\\s+" + RE_OPERATOR + "\\s+";
+		const KEYWORDS = {
+			keyword: "and as asr assert begin class constraint do done downto else end exception external for fun function functor if in include inherit initializer land lazy let lor lsl lsr lxor match method mod module mutable new nonrec object of open or private rec sig struct then to try type val virtual when while with",
+			built_in: "array bool bytes char exn|5 float int int32 int64 list lazy_t|5 nativeint|5 ref string unit ",
+			literal: "true false"
+		};
+		const NUMBER_MODE = {
+			className: "number",
+			relevance: 0,
+			variants: [{ begin: "\\b(0[xX][a-fA-F0-9_]+[Lln]?|0[oO][0-7_]+[Lln]?|0[bB][01_]+[Lln]?|[0-9][0-9_]*([Lln]|(\\.[0-9_]*)?([eE][-+]?[0-9_]+)?)?)" }, { begin: "\\(-\\b(0[xX][a-fA-F0-9_]+[Lln]?|0[oO][0-7_]+[Lln]?|0[bB][01_]+[Lln]?|[0-9][0-9_]*([Lln]|(\\.[0-9_]*)?([eE][-+]?[0-9_]+)?)?)\\)" }]
+		};
+		const OPERATOR_MODE = {
+			className: "operator",
+			relevance: 0,
+			begin: RE_OPERATOR
+		};
+		const LIST_CONTENTS_MODES = [
+			{
+				className: "identifier",
+				relevance: 0,
+				begin: RE_IDENT
+			},
+			OPERATOR_MODE,
+			NUMBER_MODE
+		];
+		const MODULE_ACCESS_CONTENTS = [
+			hljs.QUOTE_STRING_MODE,
+			OPERATOR_MODE,
+			{
+				className: "module",
+				begin: "\\b`?[A-Z$_][0-9a-zA-Z$_]*",
+				returnBegin: true,
+				end: ".",
+				contains: [{
+					className: "identifier",
+					begin: RE_MODULE_IDENT,
+					relevance: 0
+				}]
+			}
+		];
+		const PARAMS_CONTENTS = [{
+			className: "module",
+			begin: "\\b`?[A-Z$_][0-9a-zA-Z$_]*",
+			returnBegin: true,
+			end: ".",
+			relevance: 0,
+			contains: [{
+				className: "identifier",
+				begin: RE_MODULE_IDENT,
+				relevance: 0
+			}]
+		}];
+		const FUNCTION_BLOCK_MODE = {
+			className: "function",
+			relevance: 0,
+			keywords: KEYWORDS,
+			variants: [
+				{
+					begin: "\\s(\\(\\.?.*?\\)|~?[a-z$_][0-9a-zA-Z$_]*)\\s*=>",
+					end: "\\s*=>",
+					returnBegin: true,
+					relevance: 0,
+					contains: [{
+						className: "params",
+						variants: [
+							{ begin: RE_IDENT },
+							{ begin: RE_PARAM },
+							{ begin: /\(\s*\)/ }
+						]
+					}]
+				},
+				{
+					begin: "\\s\\(\\.?[^;\\|]*\\)\\s*=>",
+					end: "\\s=>",
+					returnBegin: true,
+					relevance: 0,
+					contains: [{
+						className: "params",
+						relevance: 0,
+						variants: [{
+							begin: RE_IDENT,
+							end: "(,|\\n|\\))",
+							relevance: 0,
+							contains: [OPERATOR_MODE, {
+								className: "typing",
+								begin: ":",
+								end: "(,|\\n)",
+								returnBegin: true,
+								relevance: 0,
+								contains: PARAMS_CONTENTS
+							}]
+						}]
+					}]
+				},
+				{ begin: "\\(\\.\\s~?[a-z$_][0-9a-zA-Z$_]*\\)\\s*=>" }
+			]
+		};
+		MODULE_ACCESS_CONTENTS.push(FUNCTION_BLOCK_MODE);
+		const CONSTRUCTOR_MODE = {
+			className: "constructor",
+			begin: "`?[A-Z$_][0-9a-zA-Z$_]*\\(",
+			end: "\\)",
+			illegal: "\\n",
+			keywords: KEYWORDS,
+			contains: [
+				hljs.QUOTE_STRING_MODE,
+				OPERATOR_MODE,
+				{
+					className: "params",
+					begin: "\\b~?[a-z$_][0-9a-zA-Z$_]*"
+				}
+			]
+		};
+		const PATTERN_MATCH_BLOCK_MODE = {
+			className: "pattern-match",
+			begin: "\\|",
+			returnBegin: true,
+			keywords: KEYWORDS,
+			end: "=>",
+			relevance: 0,
+			contains: [
+				CONSTRUCTOR_MODE,
+				OPERATOR_MODE,
+				{
+					relevance: 0,
+					className: "constructor",
+					begin: RE_MODULE_IDENT
+				}
+			]
+		};
+		const MODULE_ACCESS_MODE = {
+			className: "module-access",
+			keywords: KEYWORDS,
+			returnBegin: true,
+			variants: [
+				{ begin: "\\b(`?[A-Z$_][0-9a-zA-Z$_]*\\.)+~?[a-z$_][0-9a-zA-Z$_]*" },
+				{
+					begin: "\\b(`?[A-Z$_][0-9a-zA-Z$_]*\\.)+\\(",
+					end: "\\)",
+					returnBegin: true,
+					contains: [FUNCTION_BLOCK_MODE, {
+						begin: "\\(",
+						end: "\\)",
+						skip: true
+					}].concat(MODULE_ACCESS_CONTENTS)
+				},
+				{
+					begin: "\\b(`?[A-Z$_][0-9a-zA-Z$_]*\\.)+\\{",
+					end: /\}/
+				}
+			],
+			contains: MODULE_ACCESS_CONTENTS
+		};
+		PARAMS_CONTENTS.push(MODULE_ACCESS_MODE);
+		return {
+			name: "ReasonML",
+			aliases: ["re"],
+			keywords: KEYWORDS,
+			illegal: "(:-|:=|\\$\\{|\\+=)",
+			contains: [
+				hljs.COMMENT("/\\*", "\\*/", { illegal: "^(#,\\/\\/)" }),
+				{
+					className: "character",
+					begin: "'(\\\\[^']+|[^'])'",
+					illegal: "\\n",
+					relevance: 0
+				},
+				hljs.QUOTE_STRING_MODE,
+				{
+					className: "literal",
+					begin: "\\(\\)",
+					relevance: 0
+				},
+				{
+					className: "literal",
+					begin: "\\[\\|",
+					end: "\\|\\]",
+					relevance: 0,
+					contains: LIST_CONTENTS_MODES
+				},
+				{
+					className: "literal",
+					begin: "\\[",
+					end: "\\]",
+					relevance: 0,
+					contains: LIST_CONTENTS_MODES
+				},
+				CONSTRUCTOR_MODE,
+				{
+					className: "operator",
+					begin: RE_OPERATOR_SPACED,
+					illegal: "-->",
+					relevance: 0
+				},
+				NUMBER_MODE,
+				hljs.C_LINE_COMMENT_MODE,
+				PATTERN_MATCH_BLOCK_MODE,
+				FUNCTION_BLOCK_MODE,
+				{
+					className: "module-def",
+					begin: "\\bmodule\\s+~?[a-z$_][0-9a-zA-Z$_]*\\s+`?[A-Z$_][0-9a-zA-Z$_]*\\s+=\\s+\\{",
+					end: /\}/,
+					returnBegin: true,
+					keywords: KEYWORDS,
+					relevance: 0,
+					contains: [{
+						className: "module",
+						relevance: 0,
+						begin: RE_MODULE_IDENT
+					}, {
+						begin: /\{/,
+						end: /\}/,
+						skip: true
+					}].concat(MODULE_ACCESS_CONTENTS)
+				},
+				MODULE_ACCESS_MODE
+			]
+		};
+	}
+	module.exports = reasonml;
+}));
+
+//#endregion
+export default require_reasonml();