@webskill/chatbot 0.0.1

package/dist/javadoclike-DV682eaV.js

@@ -0,0 +1,74 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/javadoclike.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+javadoclike.displayName = "javadoclike";
+javadoclike.aliases = [];
+/** @param {Refractor} Prism */
+function javadoclike(Prism) {
+	(function(Prism) {
+		var javaDocLike = Prism.languages.javadoclike = {
+			parameter: {
+				pattern: /(^[\t ]*(?:\/{3}|\*|\/\*\*)\s*@(?:arg|arguments|param)\s+)\w+/m,
+				lookbehind: true
+			},
+			keyword: {
+				pattern: /(^[\t ]*(?:\/{3}|\*|\/\*\*)\s*|\{)@[a-z][a-zA-Z-]+\b/m,
+				lookbehind: true
+			},
+			punctuation: /[{}]/
+		};
+		/**
+		* Adds doc comment support to the given language and calls a given callback on each doc comment pattern.
+		*
+		* @param {string} lang the language add doc comment support to.
+		* @param {(pattern: {inside: {rest: undefined}}) => void} callback the function called with each doc comment pattern as argument.
+		*/
+		function docCommentSupport(lang, callback) {
+			var tokenName = "doc-comment";
+			var grammar = Prism.languages[lang];
+			if (!grammar) return;
+			var token = grammar[tokenName];
+			if (!token) {
+				var definition = {};
+				definition[tokenName] = {
+					pattern: /(^|[^\\])\/\*\*[^/][\s\S]*?(?:\*\/|$)/,
+					lookbehind: true,
+					alias: "comment"
+				};
+				grammar = Prism.languages.insertBefore(lang, "comment", definition);
+				token = grammar[tokenName];
+			}
+			if (token instanceof RegExp) token = grammar[tokenName] = { pattern: token };
+			if (Array.isArray(token)) for (var i = 0, l = token.length; i < l; i++) {
+				if (token[i] instanceof RegExp) token[i] = { pattern: token[i] };
+				callback(token[i]);
+			}
+			else callback(token);
+		}
+		/**
+		* Adds doc-comment support to the given languages for the given documentation language.
+		*
+		* @param {string[]|string} languages
+		* @param {Object} docLanguage
+		*/
+		function addSupport(languages, docLanguage) {
+			if (typeof languages === "string") languages = [languages];
+			languages.forEach(function(lang) {
+				docCommentSupport(lang, function(pattern) {
+					if (!pattern.inside) pattern.inside = {};
+					pattern.inside.rest = docLanguage;
+				});
+			});
+		}
+		Object.defineProperty(javaDocLike, "addSupport", { value: addSupport });
+		javaDocLike.addSupport([
+			"java",
+			"javascript",
+			"php"
+		], javaDocLike);
+	})(Prism);
+}
+
+//#endregion
+export { javadoclike as default };

package/dist/javascript-BJ-LeMcK.js

@@ -0,0 +1,126 @@
+import { n as __exportAll } from "./rolldown-runtime-DZ8SGSJo.js";
+import { t as clike } from "./clike-BvmU1AL7.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/javascript.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+var javascript_exports = /* @__PURE__ */ __exportAll({ default: () => javascript });
+javascript.displayName = "javascript";
+javascript.aliases = ["js"];
+/** @param {Refractor} Prism */
+function javascript(Prism) {
+	Prism.register(clike);
+	Prism.languages.javascript = Prism.languages.extend("clike", {
+		"class-name": [Prism.languages.clike["class-name"], {
+			pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,
+			lookbehind: true
+		}],
+		keyword: [{
+			pattern: /((?:^|\})\s*)catch\b/,
+			lookbehind: true
+		}, {
+			pattern: /(^|[^.]|\.\.\.\s*)\b(?:as|assert(?=\s*\{)|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally(?=\s*(?:\{|$))|for|from(?=\s*(?:['"]|$))|function|(?:get|set)(?=\s*(?:[#\[$\w\xA0-\uFFFF]|$))|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/,
+			lookbehind: true
+		}],
+		function: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
+		number: {
+			pattern: RegExp(/(^|[^\w$])/.source + "(?:" + (/NaN|Infinity/.source + "|" + /0[bB][01]+(?:_[01]+)*n?/.source + "|" + /0[oO][0-7]+(?:_[0-7]+)*n?/.source + "|" + /0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source + "|" + /\d+(?:_\d+)*n/.source + "|" + /(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/.source) + ")" + /(?![\w$])/.source),
+			lookbehind: true
+		},
+		operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/
+	});
+	Prism.languages.javascript["class-name"][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/;
+	Prism.languages.insertBefore("javascript", "keyword", {
+		regex: {
+			pattern: RegExp(/((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)/.source + /\//.source + "(?:" + /(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}/.source + "|" + /(?:\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.)*\])*\])*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}v[dgimyus]{0,7}/.source + ")" + /(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/.source),
+			lookbehind: true,
+			greedy: true,
+			inside: {
+				"regex-source": {
+					pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
+					lookbehind: true,
+					alias: "language-regex",
+					inside: Prism.languages.regex
+				},
+				"regex-delimiter": /^\/|\/$/,
+				"regex-flags": /^[a-z]+$/
+			}
+		},
+		"function-variable": {
+			pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,
+			alias: "function"
+		},
+		parameter: [
+			{
+				pattern: /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,
+				lookbehind: true,
+				inside: Prism.languages.javascript
+			},
+			{
+				pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
+				lookbehind: true,
+				inside: Prism.languages.javascript
+			},
+			{
+				pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
+				lookbehind: true,
+				inside: Prism.languages.javascript
+			},
+			{
+				pattern: /((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/,
+				lookbehind: true,
+				inside: Prism.languages.javascript
+			}
+		],
+		constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/
+	});
+	Prism.languages.insertBefore("javascript", "string", {
+		hashbang: {
+			pattern: /^#!.*/,
+			greedy: true,
+			alias: "comment"
+		},
+		"template-string": {
+			pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
+			greedy: true,
+			inside: {
+				"template-punctuation": {
+					pattern: /^`|`$/,
+					alias: "string"
+				},
+				interpolation: {
+					pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
+					lookbehind: true,
+					inside: {
+						"interpolation-punctuation": {
+							pattern: /^\$\{|\}$/,
+							alias: "punctuation"
+						},
+						rest: Prism.languages.javascript
+					}
+				},
+				string: /[\s\S]+/
+			}
+		},
+		"string-property": {
+			pattern: /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m,
+			lookbehind: true,
+			greedy: true,
+			alias: "property"
+		}
+	});
+	Prism.languages.insertBefore("javascript", "operator", { "literal-property": {
+		pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
+		lookbehind: true,
+		alias: "property"
+	} });
+	if (Prism.languages.markup) {
+		Prism.languages.markup.tag.addInlined("script", "javascript");
+		Prism.languages.markup.tag.addAttribute(/on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)/.source, "javascript");
+	}
+	Prism.languages.js = Prism.languages.javascript;
+}
+
+//#endregion
+export { javascript_exports as n, javascript as t };

package/dist/javascript-DZR3s47P.js

@@ -0,0 +1,471 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/javascript.js
+var require_javascript = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const IDENT_RE = "[A-Za-z$_][0-9A-Za-z$_]*";
+	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"
+	]);
+	/**
+	* @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 javascript(hljs) {
+		/**
+		* Takes a string like "<Booger" and checks to see
+		* if we can find a matching "</Booger" later in the
+		* content.
+		* @param {RegExpMatchArray} match
+		* @param {{after:number}} param1
+		*/
+		const hasClosingTag = (match, { after }) => {
+			const tag = "</" + match[0].slice(1);
+			return match.input.indexOf(tag, after) !== -1;
+		};
+		const IDENT_RE$1 = IDENT_RE;
+		const FRAGMENT = {
+			begin: "<>",
+			end: "</>"
+		};
+		const XML_TAG = {
+			begin: /<[A-Za-z0-9\\._:-]+/,
+			end: /\/[A-Za-z0-9\\._:-]+>|\/>/,
+			/**
+			* @param {RegExpMatchArray} match
+			* @param {CallbackResponse} response
+			*/
+			isTrulyOpeningTag: (match, response) => {
+				const afterMatchIndex = match[0].length + match.index;
+				const nextChar = match.input[afterMatchIndex];
+				if (nextChar === "<") {
+					response.ignoreMatch();
+					return;
+				}
+				if (nextChar === ">") {
+					if (!hasClosingTag(match, { after: afterMatchIndex })) response.ignoreMatch();
+				}
+			}
+		};
+		const KEYWORDS$1 = {
+			$pattern: IDENT_RE,
+			keyword: KEYWORDS,
+			literal: LITERALS,
+			built_in: BUILT_INS
+		};
+		const decimalDigits = "[0-9](_?[0-9])*";
+		const frac = `\\.(${decimalDigits})`;
+		const decimalInteger = `0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*`;
+		const NUMBER = {
+			className: "number",
+			variants: [
+				{ begin: `(\\b(${decimalInteger})((${frac})|\\.)?|(${frac}))[eE][+-]?(${decimalDigits})\\b` },
+				{ begin: `\\b(${decimalInteger})\\b((${frac})\\b|\\.)?|(${frac})\\b` },
+				{ begin: `\\b(0|[1-9](_?[0-9])*)n\\b` },
+				{ begin: "\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*n?\\b" },
+				{ begin: "\\b0[bB][0-1](_?[0-1])*n?\\b" },
+				{ begin: "\\b0[oO][0-7](_?[0-7])*n?\\b" },
+				{ begin: "\\b0[0-7]+n?\\b" }
+			],
+			relevance: 0
+		};
+		const SUBST = {
+			className: "subst",
+			begin: "\\$\\{",
+			end: "\\}",
+			keywords: KEYWORDS$1,
+			contains: []
+		};
+		const HTML_TEMPLATE = {
+			begin: "html`",
+			end: "",
+			starts: {
+				end: "`",
+				returnEnd: false,
+				contains: [hljs.BACKSLASH_ESCAPE, SUBST],
+				subLanguage: "xml"
+			}
+		};
+		const CSS_TEMPLATE = {
+			begin: "css`",
+			end: "",
+			starts: {
+				end: "`",
+				returnEnd: false,
+				contains: [hljs.BACKSLASH_ESCAPE, SUBST],
+				subLanguage: "css"
+			}
+		};
+		const TEMPLATE_STRING = {
+			className: "string",
+			begin: "`",
+			end: "`",
+			contains: [hljs.BACKSLASH_ESCAPE, SUBST]
+		};
+		const COMMENT = {
+			className: "comment",
+			variants: [
+				hljs.COMMENT(/\/\*\*(?!\/)/, "\\*/", {
+					relevance: 0,
+					contains: [{
+						className: "doctag",
+						begin: "@[A-Za-z]+",
+						contains: [
+							{
+								className: "type",
+								begin: "\\{",
+								end: "\\}",
+								relevance: 0
+							},
+							{
+								className: "variable",
+								begin: "[A-Za-z$_][0-9A-Za-z$_]*(?=\\s*(-)|$)",
+								endsParent: true,
+								relevance: 0
+							},
+							{
+								begin: /(?=[^\n])\s/,
+								relevance: 0
+							}
+						]
+					}]
+				}),
+				hljs.C_BLOCK_COMMENT_MODE,
+				hljs.C_LINE_COMMENT_MODE
+			]
+		};
+		const SUBST_INTERNALS = [
+			hljs.APOS_STRING_MODE,
+			hljs.QUOTE_STRING_MODE,
+			HTML_TEMPLATE,
+			CSS_TEMPLATE,
+			TEMPLATE_STRING,
+			NUMBER,
+			hljs.REGEXP_MODE
+		];
+		SUBST.contains = SUBST_INTERNALS.concat({
+			begin: /\{/,
+			end: /\}/,
+			keywords: KEYWORDS$1,
+			contains: ["self"].concat(SUBST_INTERNALS)
+		});
+		const SUBST_AND_COMMENTS = [].concat(COMMENT, SUBST.contains);
+		const PARAMS_CONTAINS = SUBST_AND_COMMENTS.concat([{
+			begin: /\(/,
+			end: /\)/,
+			keywords: KEYWORDS$1,
+			contains: ["self"].concat(SUBST_AND_COMMENTS)
+		}]);
+		const PARAMS = {
+			className: "params",
+			begin: /\(/,
+			end: /\)/,
+			excludeBegin: true,
+			excludeEnd: true,
+			keywords: KEYWORDS$1,
+			contains: PARAMS_CONTAINS
+		};
+		return {
+			name: "Javascript",
+			aliases: [
+				"js",
+				"jsx",
+				"mjs",
+				"cjs"
+			],
+			keywords: KEYWORDS$1,
+			exports: { PARAMS_CONTAINS },
+			illegal: /#(?![$_A-z])/,
+			contains: [
+				hljs.SHEBANG({
+					label: "shebang",
+					binary: "node",
+					relevance: 5
+				}),
+				{
+					label: "use_strict",
+					className: "meta",
+					relevance: 10,
+					begin: /^\s*['"]use (strict|asm)['"]/
+				},
+				hljs.APOS_STRING_MODE,
+				hljs.QUOTE_STRING_MODE,
+				HTML_TEMPLATE,
+				CSS_TEMPLATE,
+				TEMPLATE_STRING,
+				COMMENT,
+				NUMBER,
+				{
+					begin: concat(/[{,\n]\s*/, lookahead(concat(/(((\/\/.*$)|(\/\*(\*[^/]|[^*])*\*\/))\s*)*/, "[A-Za-z$_][0-9A-Za-z$_]*\\s*:"))),
+					relevance: 0,
+					contains: [{
+						className: "attr",
+						begin: IDENT_RE$1 + lookahead("\\s*:"),
+						relevance: 0
+					}]
+				},
+				{
+					begin: "(" + hljs.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
+					keywords: "return throw case",
+					contains: [
+						COMMENT,
+						hljs.REGEXP_MODE,
+						{
+							className: "function",
+							begin: "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + hljs.UNDERSCORE_IDENT_RE + ")\\s*=>",
+							returnBegin: true,
+							end: "\\s*=>",
+							contains: [{
+								className: "params",
+								variants: [
+									{
+										begin: hljs.UNDERSCORE_IDENT_RE,
+										relevance: 0
+									},
+									{
+										className: null,
+										begin: /\(\s*\)/,
+										skip: true
+									},
+									{
+										begin: /\(/,
+										end: /\)/,
+										excludeBegin: true,
+										excludeEnd: true,
+										keywords: KEYWORDS$1,
+										contains: PARAMS_CONTAINS
+									}
+								]
+							}]
+						},
+						{
+							begin: /,/,
+							relevance: 0
+						},
+						{
+							className: "",
+							begin: /\s/,
+							end: /\s*/,
+							skip: true
+						},
+						{
+							variants: [{
+								begin: FRAGMENT.begin,
+								end: FRAGMENT.end
+							}, {
+								begin: XML_TAG.begin,
+								"on:begin": XML_TAG.isTrulyOpeningTag,
+								end: XML_TAG.end
+							}],
+							subLanguage: "xml",
+							contains: [{
+								begin: XML_TAG.begin,
+								end: XML_TAG.end,
+								skip: true,
+								contains: ["self"]
+							}]
+						}
+					],
+					relevance: 0
+				},
+				{
+					className: "function",
+					beginKeywords: "function",
+					end: /[{;]/,
+					excludeEnd: true,
+					keywords: KEYWORDS$1,
+					contains: [
+						"self",
+						hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1 }),
+						PARAMS
+					],
+					illegal: /%/
+				},
+				{ beginKeywords: "while if switch catch for" },
+				{
+					className: "function",
+					begin: hljs.UNDERSCORE_IDENT_RE + "\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",
+					returnBegin: true,
+					contains: [PARAMS, hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1 })]
+				},
+				{
+					variants: [{ begin: "\\.[A-Za-z$_][0-9A-Za-z$_]*" }, { begin: "\\$[A-Za-z$_][0-9A-Za-z$_]*" }],
+					relevance: 0
+				},
+				{
+					className: "class",
+					beginKeywords: "class",
+					end: /[{;=]/,
+					excludeEnd: true,
+					illegal: /[:"[\]]/,
+					contains: [{ beginKeywords: "extends" }, hljs.UNDERSCORE_TITLE_MODE]
+				},
+				{
+					begin: /\b(?=constructor)/,
+					end: /[{;]/,
+					excludeEnd: true,
+					contains: [
+						hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1 }),
+						"self",
+						PARAMS
+					]
+				},
+				{
+					begin: "(get|set)\\s+(?=[A-Za-z$_][0-9A-Za-z$_]*\\()",
+					end: /\{/,
+					keywords: "get set",
+					contains: [
+						hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1 }),
+						{ begin: /\(\)/ },
+						PARAMS
+					]
+				},
+				{ begin: /\$[(.]/ }
+			]
+		};
+	}
+	module.exports = javascript;
+}));
+
+//#endregion
+export default require_javascript();