@webskill/chatbot 0.0.1

package/dist/coffeescript-DYxKI72B.js

@@ -0,0 +1,297 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/coffeescript.js
+var require_coffeescript = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const KEYWORDS = [
+		"as",
+		"in",
+		"of",
+		"if",
+		"for",
+		"while",
+		"finally",
+		"var",
+		"new",
+		"function",
+		"do",
+		"return",
+		"void",
+		"else",
+		"break",
+		"catch",
+		"instanceof",
+		"with",
+		"throw",
+		"case",
+		"default",
+		"try",
+		"switch",
+		"continue",
+		"typeof",
+		"delete",
+		"let",
+		"yield",
+		"const",
+		"class",
+		"debugger",
+		"async",
+		"await",
+		"static",
+		"import",
+		"from",
+		"export",
+		"extends"
+	];
+	const LITERALS = [
+		"true",
+		"false",
+		"null",
+		"undefined",
+		"NaN",
+		"Infinity"
+	];
+	const BUILT_INS = [].concat([
+		"setInterval",
+		"setTimeout",
+		"clearInterval",
+		"clearTimeout",
+		"require",
+		"exports",
+		"eval",
+		"isFinite",
+		"isNaN",
+		"parseFloat",
+		"parseInt",
+		"decodeURI",
+		"decodeURIComponent",
+		"encodeURI",
+		"encodeURIComponent",
+		"escape",
+		"unescape"
+	], [
+		"arguments",
+		"this",
+		"super",
+		"console",
+		"window",
+		"document",
+		"localStorage",
+		"module",
+		"global"
+	], [
+		"Intl",
+		"DataView",
+		"Number",
+		"Math",
+		"Date",
+		"String",
+		"RegExp",
+		"Object",
+		"Function",
+		"Boolean",
+		"Error",
+		"Symbol",
+		"Set",
+		"Map",
+		"WeakSet",
+		"WeakMap",
+		"Proxy",
+		"Reflect",
+		"JSON",
+		"Promise",
+		"Float64Array",
+		"Int16Array",
+		"Int32Array",
+		"Int8Array",
+		"Uint16Array",
+		"Uint32Array",
+		"Float32Array",
+		"Array",
+		"Uint8Array",
+		"Uint8ClampedArray",
+		"ArrayBuffer",
+		"BigInt64Array",
+		"BigUint64Array",
+		"BigInt"
+	], [
+		"EvalError",
+		"InternalError",
+		"RangeError",
+		"ReferenceError",
+		"SyntaxError",
+		"TypeError",
+		"URIError"
+	]);
+	/** @type LanguageFn */
+	function coffeescript(hljs) {
+		const COFFEE_BUILT_INS = ["npm", "print"];
+		const COFFEE_LITERALS = [
+			"yes",
+			"no",
+			"on",
+			"off"
+		];
+		const COFFEE_KEYWORDS = [
+			"then",
+			"unless",
+			"until",
+			"loop",
+			"by",
+			"when",
+			"and",
+			"or",
+			"is",
+			"isnt",
+			"not"
+		];
+		const NOT_VALID_KEYWORDS = [
+			"var",
+			"const",
+			"let",
+			"function",
+			"static"
+		];
+		const excluding = (list) => (kw) => !list.includes(kw);
+		const KEYWORDS$1 = {
+			keyword: KEYWORDS.concat(COFFEE_KEYWORDS).filter(excluding(NOT_VALID_KEYWORDS)),
+			literal: LITERALS.concat(COFFEE_LITERALS),
+			built_in: BUILT_INS.concat(COFFEE_BUILT_INS)
+		};
+		const JS_IDENT_RE = "[A-Za-z$_][0-9A-Za-z$_]*";
+		const SUBST = {
+			className: "subst",
+			begin: /#\{/,
+			end: /\}/,
+			keywords: KEYWORDS$1
+		};
+		const EXPRESSIONS = [
+			hljs.BINARY_NUMBER_MODE,
+			hljs.inherit(hljs.C_NUMBER_MODE, { starts: {
+				end: "(\\s*/)?",
+				relevance: 0
+			} }),
+			{
+				className: "string",
+				variants: [
+					{
+						begin: /'''/,
+						end: /'''/,
+						contains: [hljs.BACKSLASH_ESCAPE]
+					},
+					{
+						begin: /'/,
+						end: /'/,
+						contains: [hljs.BACKSLASH_ESCAPE]
+					},
+					{
+						begin: /"""/,
+						end: /"""/,
+						contains: [hljs.BACKSLASH_ESCAPE, SUBST]
+					},
+					{
+						begin: /"/,
+						end: /"/,
+						contains: [hljs.BACKSLASH_ESCAPE, SUBST]
+					}
+				]
+			},
+			{
+				className: "regexp",
+				variants: [
+					{
+						begin: "///",
+						end: "///",
+						contains: [SUBST, hljs.HASH_COMMENT_MODE]
+					},
+					{
+						begin: "//[gim]{0,3}(?=\\W)",
+						relevance: 0
+					},
+					{ begin: /\/(?![ *]).*?(?![\\]).\/[gim]{0,3}(?=\W)/ }
+				]
+			},
+			{ begin: "@[A-Za-z$_][0-9A-Za-z$_]*" },
+			{
+				subLanguage: "javascript",
+				excludeBegin: true,
+				excludeEnd: true,
+				variants: [{
+					begin: "```",
+					end: "```"
+				}, {
+					begin: "`",
+					end: "`"
+				}]
+			}
+		];
+		SUBST.contains = EXPRESSIONS;
+		const TITLE = hljs.inherit(hljs.TITLE_MODE, { begin: JS_IDENT_RE });
+		const POSSIBLE_PARAMS_RE = "(\\(.*\\)\\s*)?\\B[-=]>";
+		const PARAMS = {
+			className: "params",
+			begin: "\\([^\\(]",
+			returnBegin: true,
+			contains: [{
+				begin: /\(/,
+				end: /\)/,
+				keywords: KEYWORDS$1,
+				contains: ["self"].concat(EXPRESSIONS)
+			}]
+		};
+		return {
+			name: "CoffeeScript",
+			aliases: [
+				"coffee",
+				"cson",
+				"iced"
+			],
+			keywords: KEYWORDS$1,
+			illegal: /\/\*/,
+			contains: EXPRESSIONS.concat([
+				hljs.COMMENT("###", "###"),
+				hljs.HASH_COMMENT_MODE,
+				{
+					className: "function",
+					begin: "^\\s*[A-Za-z$_][0-9A-Za-z$_]*\\s*=\\s*(\\(.*\\)\\s*)?\\B[-=]>",
+					end: "[-=]>",
+					returnBegin: true,
+					contains: [TITLE, PARAMS]
+				},
+				{
+					begin: /[:\(,=]\s*/,
+					relevance: 0,
+					contains: [{
+						className: "function",
+						begin: POSSIBLE_PARAMS_RE,
+						end: "[-=]>",
+						returnBegin: true,
+						contains: [PARAMS]
+					}]
+				},
+				{
+					className: "class",
+					beginKeywords: "class",
+					end: "$",
+					illegal: /[:="\[\]]/,
+					contains: [{
+						beginKeywords: "extends",
+						endsWithParent: true,
+						illegal: /[:="\[\]]/,
+						contains: [TITLE]
+					}, TITLE]
+				},
+				{
+					begin: "[A-Za-z$_][0-9A-Za-z$_]*:",
+					end: ":",
+					returnBegin: true,
+					returnEnd: true,
+					relevance: 0
+				}
+			])
+		};
+	}
+	module.exports = coffeescript;
+}));
+
+//#endregion
+export default require_coffeescript();

package/dist/coffeescript-DoyGyxrE.js

@@ -0,0 +1,81 @@
+import { t as javascript } from "./javascript-BJ-LeMcK.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/coffeescript.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+coffeescript.displayName = "coffeescript";
+coffeescript.aliases = ["coffee"];
+/** @param {Refractor} Prism */
+function coffeescript(Prism) {
+	Prism.register(javascript);
+	(function(Prism) {
+		var comment = /#(?!\{).+/;
+		var interpolation = {
+			pattern: /#\{[^}]+\}/,
+			alias: "variable"
+		};
+		Prism.languages.coffeescript = Prism.languages.extend("javascript", {
+			comment,
+			string: [{
+				pattern: /'(?:\\[\s\S]|[^\\'])*'/,
+				greedy: true
+			}, {
+				pattern: /"(?:\\[\s\S]|[^\\"])*"/,
+				greedy: true,
+				inside: { interpolation }
+			}],
+			keyword: /\b(?:and|break|by|catch|class|continue|debugger|delete|do|each|else|extend|extends|false|finally|for|if|in|instanceof|is|isnt|let|loop|namespace|new|no|not|null|of|off|on|or|own|return|super|switch|then|this|throw|true|try|typeof|undefined|unless|until|when|while|window|with|yes|yield)\b/,
+			"class-member": {
+				pattern: /@(?!\d)\w+/,
+				alias: "variable"
+			}
+		});
+		Prism.languages.insertBefore("coffeescript", "comment", {
+			"multiline-comment": {
+				pattern: /###[\s\S]+?###/,
+				alias: "comment"
+			},
+			"block-regex": {
+				pattern: /\/{3}[\s\S]*?\/{3}/,
+				alias: "regex",
+				inside: {
+					comment,
+					interpolation
+				}
+			}
+		});
+		Prism.languages.insertBefore("coffeescript", "string", {
+			"inline-javascript": {
+				pattern: /`(?:\\[\s\S]|[^\\`])*`/,
+				inside: {
+					delimiter: {
+						pattern: /^`|`$/,
+						alias: "punctuation"
+					},
+					script: {
+						pattern: /[\s\S]+/,
+						alias: "language-javascript",
+						inside: Prism.languages.javascript
+					}
+				}
+			},
+			"multiline-string": [{
+				pattern: /'''[\s\S]*?'''/,
+				greedy: true,
+				alias: "string"
+			}, {
+				pattern: /"""[\s\S]*?"""/,
+				greedy: true,
+				alias: "string",
+				inside: { interpolation }
+			}]
+		});
+		Prism.languages.insertBefore("coffeescript", "keyword", { property: /(?!\d)\w+(?=\s*:(?!:))/ });
+		delete Prism.languages.coffeescript["template-string"];
+		Prism.languages.coffee = Prism.languages.coffeescript;
+	})(Prism);
+}
+
+//#endregion
+export { coffeescript as default };

package/dist/concurnas-C4USQ-7G.js

@@ -0,0 +1,71 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/concurnas.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+concurnas.displayName = "concurnas";
+concurnas.aliases = ["conc"];
+/** @param {Refractor} Prism */
+function concurnas(Prism) {
+	Prism.languages.concurnas = {
+		comment: {
+			pattern: /(^|[^\\])(?:\/\*[\s\S]*?(?:\*\/|$)|\/\/.*)/,
+			lookbehind: true,
+			greedy: true
+		},
+		langext: {
+			pattern: /\b\w+\s*\|\|[\s\S]+?\|\|/,
+			greedy: true,
+			inside: {
+				"class-name": /^\w+/,
+				string: {
+					pattern: /(^\s*\|\|)[\s\S]+(?=\|\|$)/,
+					lookbehind: true
+				},
+				punctuation: /\|\|/
+			}
+		},
+		function: {
+			pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/,
+			lookbehind: true
+		},
+		keyword: /\b(?:abstract|actor|also|annotation|assert|async|await|bool|boolean|break|byte|case|catch|changed|char|class|closed|constant|continue|def|default|del|double|elif|else|enum|every|extends|false|finally|float|for|from|global|gpudef|gpukernel|if|import|in|init|inject|int|lambda|local|long|loop|match|new|nodefault|null|of|onchange|open|out|override|package|parfor|parforsync|post|pre|private|protected|provide|provider|public|return|shared|short|single|size_t|sizeof|super|sync|this|throw|trait|trans|transient|true|try|typedef|unchecked|using|val|var|void|while|with)\b/,
+		boolean: /\b(?:false|true)\b/,
+		number: /\b0b[01][01_]*L?\b|\b0x(?:[\da-f_]*\.)?[\da-f_p+-]+\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfls]?/i,
+		punctuation: /[{}[\];(),.:]/,
+		operator: /<==|>==|=>|->|<-|<>|&==|&<>|\?:?|\.\?|\+\+|--|[-+*/=<>]=?|[!^~]|\b(?:and|as|band|bor|bxor|comp|is|isnot|mod|or)\b=?/,
+		annotation: {
+			pattern: /@(?:\w+:)?(?:\w+|\[[^\]]+\])?/,
+			alias: "builtin"
+		}
+	};
+	Prism.languages.insertBefore("concurnas", "langext", {
+		"regex-literal": {
+			pattern: /\br("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+			greedy: true,
+			inside: {
+				interpolation: {
+					pattern: /((?:^|[^\\])(?:\\{2})*)\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
+					lookbehind: true,
+					inside: Prism.languages.concurnas
+				},
+				regex: /[\s\S]+/
+			}
+		},
+		"string-literal": {
+			pattern: /(?:\B|\bs)("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+			greedy: true,
+			inside: {
+				interpolation: {
+					pattern: /((?:^|[^\\])(?:\\{2})*)\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
+					lookbehind: true,
+					inside: Prism.languages.concurnas
+				},
+				string: /[\s\S]+/
+			}
+		}
+	});
+	Prism.languages.conc = Prism.languages.concurnas;
+}
+
+//#endregion
+export { concurnas as default };

package/dist/cooklang-HIWZvfsC.js

@@ -0,0 +1,130 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/cooklang.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+cooklang.displayName = "cooklang";
+cooklang.aliases = [];
+/** @param {Refractor} Prism */
+function cooklang(Prism) {
+	(function(Prism) {
+		var single_token_suffix = /(?:(?!\s)[\d$+<=a-zA-Z\x80-\uFFFF])+/.source;
+		var multi_token_infix = /[^{}@#]+/.source;
+		var multi_token = multi_token_infix + /\{[^}#@]*\}/.source;
+		var timer_units = /(?:h|hours|hrs|m|min|minutes)/.source;
+		var amount_group_impl = {
+			pattern: /\{[^{}]*\}/,
+			inside: {
+				amount: {
+					pattern: /([\{|])[^{}|*%]+/,
+					lookbehind: true,
+					alias: "number"
+				},
+				unit: {
+					pattern: /(%)[^}]+/,
+					lookbehind: true,
+					alias: "symbol"
+				},
+				"servings-scaler": {
+					pattern: /\*/,
+					alias: "operator"
+				},
+				"servings-alternative-separator": {
+					pattern: /\|/,
+					alias: "operator"
+				},
+				"unit-separator": {
+					pattern: /(?:%|(\*)%)/,
+					lookbehind: true,
+					alias: "operator"
+				},
+				punctuation: /[{}]/
+			}
+		};
+		Prism.languages.cooklang = {
+			comment: {
+				pattern: /\[-[\s\S]*?-\]|--.*/,
+				greedy: true
+			},
+			meta: {
+				pattern: />>.*:.*/,
+				inside: { property: {
+					pattern: /(>>\s*)[^\s:](?:[^:]*[^\s:])?/,
+					lookbehind: true
+				} }
+			},
+			"cookware-group": {
+				pattern: new RegExp("#(?:" + multi_token + "|" + single_token_suffix + ")"),
+				inside: {
+					cookware: {
+						pattern: new RegExp("(^#)(?:" + multi_token_infix + ")"),
+						lookbehind: true,
+						alias: "variable"
+					},
+					"cookware-keyword": {
+						pattern: /^#/,
+						alias: "keyword"
+					},
+					"quantity-group": {
+						pattern: /* @__PURE__ */ new RegExp(/\{[^{}@#]*\}/),
+						inside: {
+							quantity: {
+								pattern: new RegExp(/(^\{)/.source + multi_token_infix),
+								lookbehind: true,
+								alias: "number"
+							},
+							punctuation: /[{}]/
+						}
+					}
+				}
+			},
+			"ingredient-group": {
+				pattern: new RegExp("@(?:" + multi_token + "|" + single_token_suffix + ")"),
+				inside: {
+					ingredient: {
+						pattern: new RegExp("(^@)(?:" + multi_token_infix + ")"),
+						lookbehind: true,
+						alias: "variable"
+					},
+					"ingredient-keyword": {
+						pattern: /^@/,
+						alias: "keyword"
+					},
+					"amount-group": amount_group_impl
+				}
+			},
+			"timer-group": {
+				pattern: /~(?!\s)[^@#~{}]*\{[^{}]*\}/,
+				inside: {
+					timer: {
+						pattern: /(^~)[^{]+/,
+						lookbehind: true,
+						alias: "variable"
+					},
+					"duration-group": {
+						pattern: /\{[^{}]*\}/,
+						inside: {
+							punctuation: /[{}]/,
+							unit: {
+								pattern: new RegExp(/(%\s*)/.source + timer_units + /\b/.source),
+								lookbehind: true,
+								alias: "symbol"
+							},
+							operator: /%/,
+							duration: {
+								pattern: /\d+/,
+								alias: "number"
+							}
+						}
+					},
+					"timer-keyword": {
+						pattern: /^~/,
+						alias: "keyword"
+					}
+				}
+			}
+		};
+	})(Prism);
+}
+
+//#endregion
+export { cooklang as default };

package/dist/coq-B_5iojXP.js

@@ -0,0 +1,31 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/coq.js
+var require_coq = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type LanguageFn */
+	function coq(hljs) {
+		return {
+			name: "Coq",
+			keywords: {
+				keyword: "_|0 as at cofix else end exists exists2 fix for forall fun if IF in let match mod Prop return Set then Type using where with Abort About Add Admit Admitted All Arguments Assumptions Axiom Back BackTo Backtrack Bind Blacklist Canonical Cd Check Class Classes Close Coercion Coercions CoFixpoint CoInductive Collection Combined Compute Conjecture Conjectures Constant constr Constraint Constructors Context Corollary CreateHintDb Cut Declare Defined Definition Delimit Dependencies Dependent Derive Drop eauto End Equality Eval Example Existential Existentials Existing Export exporting Extern Extract Extraction Fact Field Fields File Fixpoint Focus for From Function Functional Generalizable Global Goal Grab Grammar Graph Guarded Heap Hint HintDb Hints Hypotheses Hypothesis ident Identity If Immediate Implicit Import Include Inductive Infix Info Initial Inline Inspect Instance Instances Intro Intros Inversion Inversion_clear Language Left Lemma Let Libraries Library Load LoadPath Local Locate Ltac ML Mode Module Modules Monomorphic Morphism Next NoInline Notation Obligation Obligations Opaque Open Optimize Options Parameter Parameters Parametric Path Paths pattern Polymorphic Preterm Print Printing Program Projections Proof Proposition Pwd Qed Quit Rec Record Recursive Redirect Relation Remark Remove Require Reserved Reset Resolve Restart Rewrite Right Ring Rings Save Scheme Scope Scopes Script Search SearchAbout SearchHead SearchPattern SearchRewrite Section Separate Set Setoid Show Solve Sorted Step Strategies Strategy Structure SubClass Table Tables Tactic Term Test Theorem Time Timeout Transparent Type Typeclasses Types Undelimit Undo Unfocus Unfocused Unfold Universe Universes Unset Unshelve using Variable Variables Variant Verbose Visibility where with",
+				built_in: "abstract absurd admit after apply as assert assumption at auto autorewrite autounfold before bottom btauto by case case_eq cbn cbv change classical_left classical_right clear clearbody cofix compare compute congruence constr_eq constructor contradict contradiction cut cutrewrite cycle decide decompose dependent destruct destruction dintuition discriminate discrR do double dtauto eapply eassumption eauto ecase econstructor edestruct ediscriminate eelim eexact eexists einduction einjection eleft elim elimtype enough equality erewrite eright esimplify_eq esplit evar exact exactly_once exfalso exists f_equal fail field field_simplify field_simplify_eq first firstorder fix fold fourier functional generalize generalizing gfail give_up has_evar hnf idtac in induction injection instantiate intro intro_pattern intros intuition inversion inversion_clear is_evar is_var lapply lazy left lia lra move native_compute nia nsatz omega once pattern pose progress proof psatz quote record red refine reflexivity remember rename repeat replace revert revgoals rewrite rewrite_strat right ring ring_simplify rtauto set setoid_reflexivity setoid_replace setoid_rewrite setoid_symmetry setoid_transitivity shelve shelve_unifiable simpl simple simplify_eq solve specialize split split_Rabs split_Rmult stepl stepr subst sum swap symmetry tactic tauto time timeout top transitivity trivial try tryif unfold unify until using vm_compute with"
+			},
+			contains: [
+				hljs.QUOTE_STRING_MODE,
+				hljs.COMMENT("\\(\\*", "\\*\\)"),
+				hljs.C_NUMBER_MODE,
+				{
+					className: "type",
+					excludeBegin: true,
+					begin: "\\|\\s*",
+					end: "\\w+"
+				},
+				{ begin: /[-=]>/ }
+			]
+		};
+	}
+	module.exports = coq;
+}));
+
+//#endregion
+export default require_coq();

package/dist/coq-DrnCBTBE.js

@@ -0,0 +1,53 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/coq.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+coq.displayName = "coq";
+coq.aliases = [];
+/** @param {Refractor} Prism */
+function coq(Prism) {
+	(function(Prism) {
+		var commentSource = /\(\*(?:[^(*]|\((?!\*)|\*(?!\))|<self>)*\*\)/.source;
+		for (var i = 0; i < 2; i++) commentSource = commentSource.replace(/<self>/g, function() {
+			return commentSource;
+		});
+		commentSource = commentSource.replace(/<self>/g, "[]");
+		Prism.languages.coq = {
+			comment: RegExp(commentSource),
+			string: {
+				pattern: /"(?:[^"]|"")*"(?!")/,
+				greedy: true
+			},
+			attribute: [{
+				pattern: RegExp(/#\[(?:[^\[\]("]|"(?:[^"]|"")*"(?!")|\((?!\*)|<comment>)*\]/.source.replace(/<comment>/g, function() {
+					return commentSource;
+				})),
+				greedy: true,
+				alias: "attr-name",
+				inside: {
+					comment: RegExp(commentSource),
+					string: {
+						pattern: /"(?:[^"]|"")*"(?!")/,
+						greedy: true
+					},
+					operator: /=/,
+					punctuation: /^#\[|\]$|[,()]/
+				}
+			}, {
+				pattern: /\b(?:Cumulative|Global|Local|Monomorphic|NonCumulative|Polymorphic|Private|Program)\b/,
+				alias: "attr-name"
+			}],
+			keyword: /\b(?:Abort|About|Add|Admit|Admitted|All|Arguments|As|Assumptions|Axiom|Axioms|Back|BackTo|Backtrace|BinOp|BinOpSpec|BinRel|Bind|Blacklist|Canonical|Case|Cd|Check|Class|Classes|Close|CoFixpoint|CoInductive|Coercion|Coercions|Collection|Combined|Compute|Conjecture|Conjectures|Constant|Constants|Constraint|Constructors|Context|Corollary|Create|CstOp|Custom|Cut|Debug|Declare|Defined|Definition|Delimit|Dependencies|Dependent|Derive|Diffs|Drop|Elimination|End|Entry|Equality|Eval|Example|Existential|Existentials|Existing|Export|Extern|Extraction|Fact|Fail|Field|File|Firstorder|Fixpoint|Flags|Focus|From|Funclass|Function|Functional|GC|Generalizable|Goal|Grab|Grammar|Graph|Guarded|Haskell|Heap|Hide|Hint|HintDb|Hints|Hypotheses|Hypothesis|IF|Identity|Immediate|Implicit|Implicits|Import|Include|Induction|Inductive|Infix|Info|Initial|InjTyp|Inline|Inspect|Instance|Instances|Intro|Intros|Inversion|Inversion_clear|JSON|Language|Left|Lemma|Let|Lia|Libraries|Library|Load|LoadPath|Locate|Ltac|Ltac2|ML|Match|Method|Minimality|Module|Modules|Morphism|Next|NoInline|Notation|Number|OCaml|Obligation|Obligations|Opaque|Open|Optimize|Parameter|Parameters|Parametric|Path|Paths|Prenex|Preterm|Primitive|Print|Profile|Projections|Proof|Prop|PropBinOp|PropOp|PropUOp|Property|Proposition|Pwd|Qed|Quit|Rec|Record|Recursive|Redirect|Reduction|Register|Relation|Remark|Remove|Require|Reserved|Reset|Resolve|Restart|Rewrite|Right|Ring|Rings|SProp|Saturate|Save|Scheme|Scope|Scopes|Search|SearchHead|SearchPattern|SearchRewrite|Section|Separate|Set|Setoid|Show|Signatures|Solve|Solver|Sort|Sortclass|Sorted|Spec|Step|Strategies|Strategy|String|Structure|SubClass|Subgraph|SuchThat|Tactic|Term|TestCompile|Theorem|Time|Timeout|To|Transparent|Type|Typeclasses|Types|Typing|UnOp|UnOpSpec|Undelimit|Undo|Unfocus|Unfocused|Unfold|Universe|Universes|Unshelve|Variable|Variables|Variant|Verbose|View|Visibility|Zify|_|apply|as|at|by|cofix|else|end|exists|exists2|fix|for|forall|fun|if|in|let|match|measure|move|removed|return|struct|then|using|wf|where|with)\b/,
+			number: /\b(?:0x[a-f0-9][a-f0-9_]*(?:\.[a-f0-9_]+)?(?:p[+-]?\d[\d_]*)?|\d[\d_]*(?:\.[\d_]+)?(?:e[+-]?\d[\d_]*)?)\b/i,
+			punct: {
+				pattern: /@\{|\{\||\[=|:>/,
+				alias: "punctuation"
+			},
+			operator: /\/\\|\\\/|\.{2,3}|:{1,2}=|\*\*|[-=]>|<(?:->?|[+:=>]|<:)|>(?:=|->)|\|[-|]?|[-!%&*+/<=>?@^~']/,
+			punctuation: /\.\(|`\(|@\{|`\{|\{\||\[=|:>|[:.,;(){}\[\]]/
+		};
+	})(Prism);
+}
+
+//#endregion
+export { coq as default };