@webskill/chatbot 0.0.1

package/dist/javastacktrace-e_iWBHj3.js

@@ -0,0 +1,103 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/javastacktrace.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+javastacktrace.displayName = "javastacktrace";
+javastacktrace.aliases = [];
+/** @param {Refractor} Prism */
+function javastacktrace(Prism) {
+	Prism.languages.javastacktrace = {
+		summary: {
+			pattern: /^([\t ]*)(?:(?:Caused by:|Suppressed:|Exception in thread "[^"]*")[\t ]+)?[\w$.]+(?::.*)?$/m,
+			lookbehind: true,
+			inside: {
+				keyword: {
+					pattern: /^([\t ]*)(?:(?:Caused by|Suppressed)(?=:)|Exception in thread)/m,
+					lookbehind: true
+				},
+				string: {
+					pattern: /^(\s*)"[^"]*"/,
+					lookbehind: true
+				},
+				exceptions: {
+					pattern: /^(:?\s*)[\w$.]+(?=:|$)/,
+					lookbehind: true,
+					inside: {
+						"class-name": /[\w$]+$/,
+						namespace: /\b[a-z]\w*\b/,
+						punctuation: /\./
+					}
+				},
+				message: {
+					pattern: /(:\s*)\S.*/,
+					lookbehind: true,
+					alias: "string"
+				},
+				punctuation: /:/
+			}
+		},
+		"stack-frame": {
+			pattern: /^([\t ]*)at (?:[\w$./]|@[\w$.+-]*\/)+(?:<init>)?\([^()]*\)/m,
+			lookbehind: true,
+			inside: {
+				keyword: {
+					pattern: /^(\s*)at(?= )/,
+					lookbehind: true
+				},
+				source: [{
+					pattern: /(\()\w+\.\w+:\d+(?=\))/,
+					lookbehind: true,
+					inside: {
+						file: /^\w+\.\w+/,
+						punctuation: /:/,
+						"line-number": {
+							pattern: /\b\d+\b/,
+							alias: "number"
+						}
+					}
+				}, {
+					pattern: /(\()[^()]*(?=\))/,
+					lookbehind: true,
+					inside: { keyword: /^(?:Native Method|Unknown Source)$/ }
+				}],
+				"class-name": /[\w$]+(?=\.(?:<init>|[\w$]+)\()/,
+				function: /(?:<init>|[\w$]+)(?=\()/,
+				"class-loader": {
+					pattern: /(\s)[a-z]\w*(?:\.[a-z]\w*)*(?=\/[\w@$.]*\/)/,
+					lookbehind: true,
+					alias: "namespace",
+					inside: { punctuation: /\./ }
+				},
+				module: {
+					pattern: /([\s/])[a-z]\w*(?:\.[a-z]\w*)*(?:@[\w$.+-]*)?(?=\/)/,
+					lookbehind: true,
+					inside: {
+						version: {
+							pattern: /(@)[\s\S]+/,
+							lookbehind: true,
+							alias: "number"
+						},
+						punctuation: /[@.]/
+					}
+				},
+				namespace: {
+					pattern: /(?:\b[a-z]\w*\.)+/,
+					inside: { punctuation: /\./ }
+				},
+				punctuation: /[()/.]/
+			}
+		},
+		more: {
+			pattern: /^([\t ]*)\.{3} \d+ [a-z]+(?: [a-z]+)*/m,
+			lookbehind: true,
+			inside: {
+				punctuation: /\.{3}/,
+				number: /\d+/,
+				keyword: /\b[a-z]+(?: [a-z]+)*\b/
+			}
+		}
+	};
+}
+
+//#endregion
+export { javastacktrace as default };

package/dist/jboss-cli-BfGB9_g3.js

@@ -0,0 +1,52 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DZ8SGSJo.js";
+
+//#region ../../node_modules/.pnpm/highlight.js@10.7.3/node_modules/highlight.js/lib/languages/jboss-cli.js
+var require_jboss_cli = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function jbossCli(hljs) {
+		return {
+			name: "JBoss CLI",
+			aliases: ["wildfly-cli"],
+			keywords: {
+				$pattern: "[a-z-]+",
+				keyword: "alias batch cd clear command connect connection-factory connection-info data-source deploy deployment-info deployment-overlay echo echo-dmr help history if jdbc-driver-info jms-queue|20 jms-topic|20 ls patch pwd quit read-attribute read-operation reload rollout-plan run-batch set shutdown try unalias undeploy unset version xa-data-source",
+				literal: "true false"
+			},
+			contains: [
+				hljs.HASH_COMMENT_MODE,
+				hljs.QUOTE_STRING_MODE,
+				{
+					className: "params",
+					begin: /--[\w\-=\/]+/
+				},
+				{
+					className: "function",
+					begin: /:[\w\-.]+/,
+					relevance: 0
+				},
+				{
+					className: "string",
+					begin: /\B([\/.])[\w\-.\/=]+/
+				},
+				{
+					className: "params",
+					begin: /\(/,
+					end: /\)/,
+					contains: [{
+						begin: /[\w-]+ *=/,
+						returnBegin: true,
+						relevance: 0,
+						contains: [{
+							className: "attr",
+							begin: /[\w-]+/
+						}]
+					}],
+					relevance: 0
+				}
+			]
+		};
+	}
+	module.exports = jbossCli;
+}));
+
+//#endregion
+export default require_jboss_cli();

package/dist/jexl-C6H3SnN0.js

@@ -0,0 +1,26 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/jexl.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+jexl.displayName = "jexl";
+jexl.aliases = [];
+/** @param {Refractor} Prism */
+function jexl(Prism) {
+	Prism.languages.jexl = {
+		string: /(["'])(?:\\[\s\S]|(?!\1)[^\\])*\1/,
+		transform: {
+			pattern: /(\|\s*)[a-zA-Zа-яА-Я_\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$][\wа-яА-Я\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$]*/,
+			alias: "function",
+			lookbehind: true
+		},
+		function: /[a-zA-Zа-яА-Я_\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$][\wа-яА-Я\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$]*\s*(?=\()/,
+		number: /\b\d+(?:\.\d+)?\b|\B\.\d+\b/,
+		operator: /[<>!]=?|-|\+|&&|==|\|\|?|\/\/?|[?:*^%]/,
+		boolean: /\b(?:false|true)\b/,
+		keyword: /\bin\b/,
+		punctuation: /[{}[\](),.]/
+	};
+}
+
+//#endregion
+export { jexl as default };

package/dist/jolie-D1pm4AdS.js

@@ -0,0 +1,53 @@
+import { t as clike } from "./clike-BvmU1AL7.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/jolie.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+jolie.displayName = "jolie";
+jolie.aliases = [];
+/** @param {Refractor} Prism */
+function jolie(Prism) {
+	Prism.register(clike);
+	Prism.languages.jolie = Prism.languages.extend("clike", {
+		string: {
+			pattern: /(^|[^\\])"(?:\\[\s\S]|[^"\\])*"/,
+			lookbehind: true,
+			greedy: true
+		},
+		"class-name": {
+			pattern: /((?:\b(?:as|courier|embed|in|inputPort|outputPort|service)\b|@)[ \t]*)\w+/,
+			lookbehind: true
+		},
+		keyword: /\b(?:as|cH|comp|concurrent|constants|courier|cset|csets|default|define|else|embed|embedded|execution|exit|extender|for|foreach|forward|from|global|if|import|in|include|init|inputPort|install|instanceof|interface|is_defined|linkIn|linkOut|main|new|nullProcess|outputPort|over|private|provide|public|scope|sequential|service|single|spawn|synchronized|this|throw|throws|type|undef|until|while|with)\b/,
+		function: /\b[a-z_]\w*(?=[ \t]*[@(])/i,
+		number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?l?/i,
+		operator: /-[-=>]?|\+[+=]?|<[<=]?|[>=*!]=?|&&|\|\||[?\/%^@|]/,
+		punctuation: /[()[\]{},;.:]/,
+		builtin: /\b(?:Byte|any|bool|char|double|enum|float|int|length|long|ranges|regex|string|undefined|void)\b/
+	});
+	Prism.languages.insertBefore("jolie", "keyword", {
+		aggregates: {
+			pattern: /(\bAggregates\s*:\s*)(?:\w+(?:\s+with\s+\w+)?\s*,\s*)*\w+(?:\s+with\s+\w+)?/,
+			lookbehind: true,
+			inside: {
+				keyword: /\bwith\b/,
+				"class-name": /\w+/,
+				punctuation: /,/
+			}
+		},
+		redirects: {
+			pattern: /(\bRedirects\s*:\s*)(?:\w+\s*=>\s*\w+\s*,\s*)*(?:\w+\s*=>\s*\w+)/,
+			lookbehind: true,
+			inside: {
+				punctuation: /,/,
+				"class-name": /\w+/,
+				operator: /=>/
+			}
+		},
+		property: { pattern: /\b(?:Aggregates|[Ii]nterfaces|Java|Javascript|Jolie|[Ll]ocation|OneWay|[Pp]rotocol|Redirects|RequestResponse)\b(?=[ \t]*:)/ }
+	});
+}
+
+//#endregion
+export { jolie as default };

package/dist/jq-J4RdKnWn.js

@@ -0,0 +1,71 @@
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/jq.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+jq.displayName = "jq";
+jq.aliases = [];
+/** @param {Refractor} Prism */
+function jq(Prism) {
+	(function(Prism) {
+		var interpolation = /\\\((?:[^()]|\([^()]*\))*\)/.source;
+		var string = RegExp(/(^|[^\\])"(?:[^"\r\n\\]|\\[^\r\n(]|__)*"/.source.replace(/__/g, function() {
+			return interpolation;
+		}));
+		var stringInterpolation = { interpolation: {
+			pattern: RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + interpolation),
+			lookbehind: true,
+			inside: {
+				content: {
+					pattern: /^(\\\()[\s\S]+(?=\)$)/,
+					lookbehind: true,
+					inside: null
+				},
+				punctuation: /^\\\(|\)$/
+			}
+		} };
+		var jq = Prism.languages.jq = {
+			comment: /#.*/,
+			property: {
+				pattern: RegExp(string.source + /(?=\s*:(?!:))/.source),
+				lookbehind: true,
+				greedy: true,
+				inside: stringInterpolation
+			},
+			string: {
+				pattern: string,
+				lookbehind: true,
+				greedy: true,
+				inside: stringInterpolation
+			},
+			function: {
+				pattern: /(\bdef\s+)[a-z_]\w+/i,
+				lookbehind: true
+			},
+			variable: /\B\$\w+/,
+			"property-literal": {
+				pattern: /\b[a-z_]\w*(?=\s*:(?!:))/i,
+				alias: "property"
+			},
+			keyword: /\b(?:as|break|catch|def|elif|else|end|foreach|if|import|include|label|module|modulemeta|null|reduce|then|try|while)\b/,
+			boolean: /\b(?:false|true)\b/,
+			number: /(?:\b\d+\.|\B\.)?\b\d+(?:[eE][+-]?\d+)?\b/,
+			operator: [{
+				pattern: /\|=?/,
+				alias: "pipe"
+			}, /\.\.|[!=<>]?=|\?\/\/|\/\/=?|[-+*/%]=?|[<>?]|\b(?:and|not|or)\b/],
+			"c-style-function": {
+				pattern: /\b[a-z_]\w*(?=\s*\()/i,
+				alias: "function"
+			},
+			punctuation: /::|[()\[\]{},:;]|\.(?=\s*[\[\w$])/,
+			dot: {
+				pattern: /\./,
+				alias: "important"
+			}
+		};
+		stringInterpolation.interpolation.inside.content.inside = jq;
+	})(Prism);
+}
+
+//#endregion
+export { jq as default };

package/dist/js-extras-DBfQswmg.js

@@ -0,0 +1,119 @@
+import { t as javascript } from "./javascript-BJ-LeMcK.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/js-extras.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+jsExtras.displayName = "js-extras";
+jsExtras.aliases = [];
+/** @param {Refractor} Prism */
+function jsExtras(Prism) {
+	Prism.register(javascript);
+	(function(Prism) {
+		Prism.languages.insertBefore("javascript", "function-variable", { "method-variable": {
+			pattern: RegExp("(\\.\\s*)" + Prism.languages.javascript["function-variable"].pattern.source),
+			lookbehind: true,
+			alias: [
+				"function-variable",
+				"method",
+				"function",
+				"property-access"
+			]
+		} });
+		Prism.languages.insertBefore("javascript", "function", { method: {
+			pattern: RegExp("(\\.\\s*)" + Prism.languages.javascript["function"].source),
+			lookbehind: true,
+			alias: ["function", "property-access"]
+		} });
+		Prism.languages.insertBefore("javascript", "constant", { "known-class-name": [{
+			pattern: /\b(?:(?:Float(?:32|64)|(?:Int|Uint)(?:8|16|32)|Uint8Clamped)?Array|ArrayBuffer|BigInt|Boolean|DataView|Date|Error|Function|Intl|JSON|(?:Weak)?(?:Map|Set)|Math|Number|Object|Promise|Proxy|Reflect|RegExp|String|Symbol|WebAssembly)\b/,
+			alias: "class-name"
+		}, {
+			pattern: /\b(?:[A-Z]\w*)Error\b/,
+			alias: "class-name"
+		}] });
+		/**
+		* Replaces the `<ID>` placeholder in the given pattern with a pattern for general JS identifiers.
+		*
+		* @param {string} source
+		* @param {string} [flags]
+		* @returns {RegExp}
+		*/
+		function withId(source, flags) {
+			return RegExp(source.replace(/<ID>/g, function() {
+				return /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/.source;
+			}), flags);
+		}
+		Prism.languages.insertBefore("javascript", "keyword", {
+			imports: {
+				pattern: withId(/(\bimport\b\s*)(?:<ID>(?:\s*,\s*(?:\*\s*as\s+<ID>|\{[^{}]*\}))?|\*\s*as\s+<ID>|\{[^{}]*\})(?=\s*\bfrom\b)/.source),
+				lookbehind: true,
+				inside: Prism.languages.javascript
+			},
+			exports: {
+				pattern: withId(/(\bexport\b\s*)(?:\*(?:\s*as\s+<ID>)?(?=\s*\bfrom\b)|\{[^{}]*\})/.source),
+				lookbehind: true,
+				inside: Prism.languages.javascript
+			}
+		});
+		Prism.languages.javascript["keyword"].unshift({
+			pattern: /\b(?:as|default|export|from|import)\b/,
+			alias: "module"
+		}, {
+			pattern: /\b(?:await|break|catch|continue|do|else|finally|for|if|return|switch|throw|try|while|yield)\b/,
+			alias: "control-flow"
+		}, {
+			pattern: /\bnull\b/,
+			alias: ["null", "nil"]
+		}, {
+			pattern: /\bundefined\b/,
+			alias: "nil"
+		});
+		Prism.languages.insertBefore("javascript", "operator", {
+			spread: {
+				pattern: /\.{3}/,
+				alias: "operator"
+			},
+			arrow: {
+				pattern: /=>/,
+				alias: "operator"
+			}
+		});
+		Prism.languages.insertBefore("javascript", "punctuation", {
+			"property-access": {
+				pattern: withId(/(\.\s*)#?<ID>/.source),
+				lookbehind: true
+			},
+			"maybe-class-name": {
+				pattern: /(^|[^$\w\xA0-\uFFFF])[A-Z][$\w\xA0-\uFFFF]+/,
+				lookbehind: true
+			},
+			dom: {
+				pattern: /\b(?:document|(?:local|session)Storage|location|navigator|performance|window)\b/,
+				alias: "variable"
+			},
+			console: {
+				pattern: /\bconsole(?=\s*\.)/,
+				alias: "class-name"
+			}
+		});
+		var maybeClassNameTokens = [
+			"function",
+			"function-variable",
+			"method",
+			"method-variable",
+			"property-access"
+		];
+		for (var i = 0; i < maybeClassNameTokens.length; i++) {
+			var token = maybeClassNameTokens[i];
+			var value = Prism.languages.javascript[token];
+			if (Prism.util.type(value) === "RegExp") value = Prism.languages.javascript[token] = { pattern: value };
+			var inside = value.inside || {};
+			value.inside = inside;
+			inside["maybe-class-name"] = /^[A-Z][\s\S]*/;
+		}
+	})(Prism);
+}
+
+//#endregion
+export { jsExtras as default };

package/dist/js-templates-Bma-myhs.js

@@ -0,0 +1,264 @@
+import { t as javascript } from "./javascript-BJ-LeMcK.js";
+
+//#region ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/js-templates.js
+/**
+* @import {Refractor} from '../lib/core.js'
+*/
+jsTemplates.displayName = "js-templates";
+jsTemplates.aliases = [];
+/** @param {Refractor} Prism */
+function jsTemplates(Prism) {
+	Prism.register(javascript);
+	(function(Prism) {
+		var templateString = Prism.languages.javascript["template-string"];
+		var templateLiteralPattern = templateString.pattern.source;
+		var interpolationObject = templateString.inside["interpolation"];
+		var interpolationPunctuationObject = interpolationObject.inside["interpolation-punctuation"];
+		var interpolationPattern = interpolationObject.pattern.source;
+		/**
+		* Creates a new pattern to match a template string with a special tag.
+		*
+		* This will return `undefined` if there is no grammar with the given language id.
+		*
+		* @param {string} language The language id of the embedded language. E.g. `markdown`.
+		* @param {string} tag The regex pattern to match the tag.
+		* @returns {object | undefined}
+		* @example
+		* createTemplate('css', /\bcss/.source);
+		*/
+		function createTemplate(language, tag) {
+			if (!Prism.languages[language]) return;
+			return {
+				pattern: RegExp("((?:" + tag + ")\\s*)" + templateLiteralPattern),
+				lookbehind: true,
+				greedy: true,
+				inside: {
+					"template-punctuation": {
+						pattern: /^`|`$/,
+						alias: "string"
+					},
+					"embedded-code": {
+						pattern: /[\s\S]+/,
+						alias: language
+					}
+				}
+			};
+		}
+		Prism.languages.javascript["template-string"] = [
+			createTemplate("css", /\b(?:styled(?:\([^)]*\))?(?:\s*\.\s*\w+(?:\([^)]*\))*)*|css(?:\s*\.\s*(?:global|resolve))?|createGlobalStyle|keyframes)/.source),
+			createTemplate("html", /\bhtml|\.\s*(?:inner|outer)HTML\s*\+?=/.source),
+			createTemplate("svg", /\bsvg/.source),
+			createTemplate("markdown", /\b(?:markdown|md)/.source),
+			createTemplate("graphql", /\b(?:gql|graphql(?:\s*\.\s*experimental)?)/.source),
+			createTemplate("sql", /\bsql/.source),
+			templateString
+		].filter(Boolean);
+		/**
+		* Returns a specific placeholder literal for the given language.
+		*
+		* @param {number} counter
+		* @param {string} language
+		* @returns {string}
+		*/
+		function getPlaceholder(counter, language) {
+			return "___" + language.toUpperCase() + "_" + counter + "___";
+		}
+		/**
+		* Returns the tokens of `Prism.tokenize` but also runs the `before-tokenize` and `after-tokenize` hooks.
+		*
+		* @param {string} code
+		* @param {any} grammar
+		* @param {string} language
+		* @returns {(string|Token)[]}
+		*/
+		function tokenizeWithHooks(code, grammar, language) {
+			var env = {
+				code,
+				grammar,
+				language
+			};
+			Prism.hooks.run("before-tokenize", env);
+			env.tokens = Prism.tokenize(env.code, env.grammar);
+			Prism.hooks.run("after-tokenize", env);
+			return env.tokens;
+		}
+		/**
+		* Returns the token of the given JavaScript interpolation expression.
+		*
+		* @param {string} expression The code of the expression. E.g. `"${42}"`
+		* @returns {Token}
+		*/
+		function tokenizeInterpolationExpression(expression) {
+			var tempGrammar = {};
+			tempGrammar["interpolation-punctuation"] = interpolationPunctuationObject;
+			/** @type {Array} */
+			var tokens = Prism.tokenize(expression, tempGrammar);
+			if (tokens.length === 3) {
+				/**
+				* The token array will look like this
+				* [
+				*     ["interpolation-punctuation", "${"]
+				*     "..." // JavaScript expression of the interpolation
+				*     ["interpolation-punctuation", "}"]
+				* ]
+				*/
+				var args = [1, 1];
+				args.push.apply(args, tokenizeWithHooks(tokens[1], Prism.languages.javascript, "javascript"));
+				tokens.splice.apply(tokens, args);
+			}
+			return new Prism.Token("interpolation", tokens, interpolationObject.alias, expression);
+		}
+		/**
+		* Tokenizes the given code with support for JavaScript interpolation expressions mixed in.
+		*
+		* This function has 3 phases:
+		*
+		* 1. Replace all JavaScript interpolation expression with a placeholder.
+		*    The placeholder will have the syntax of a identify of the target language.
+		* 2. Tokenize the code with placeholders.
+		* 3. Tokenize the interpolation expressions and re-insert them into the tokenize code.
+		*    The insertion only works if a placeholder hasn't been "ripped apart" meaning that the placeholder has been
+		*    tokenized as two tokens by the grammar of the embedded language.
+		*
+		* @param {string} code
+		* @param {object} grammar
+		* @param {string} language
+		* @returns {Token}
+		*/
+		function tokenizeEmbedded(code, grammar, language) {
+			/** @type {(Token|string)[]} */
+			var _tokens = Prism.tokenize(code, { interpolation: {
+				pattern: RegExp(interpolationPattern),
+				lookbehind: true
+			} });
+			var placeholderCounter = 0;
+			/** @type {Object<string, string>} */
+			var placeholderMap = {};
+			var embeddedTokens = tokenizeWithHooks(_tokens.map(function(token) {
+				if (typeof token === "string") return token;
+				else {
+					var interpolationExpression = token.content;
+					var placeholder;
+					while (code.indexOf(placeholder = getPlaceholder(placeholderCounter++, language)) !== -1);
+					placeholderMap[placeholder] = interpolationExpression;
+					return placeholder;
+				}
+			}).join(""), grammar, language);
+			var placeholders = Object.keys(placeholderMap);
+			placeholderCounter = 0;
+			/**
+			*
+			* @param {(Token|string)[]} tokens
+			* @returns {void}
+			*/
+			function walkTokens(tokens) {
+				for (var i = 0; i < tokens.length; i++) {
+					if (placeholderCounter >= placeholders.length) return;
+					var token = tokens[i];
+					if (typeof token === "string" || typeof token.content === "string") {
+						var placeholder = placeholders[placeholderCounter];
+						var s = typeof token === "string" ? token : 						/** @type {string} */ token.content;
+						var index = s.indexOf(placeholder);
+						if (index !== -1) {
+							++placeholderCounter;
+							var before = s.substring(0, index);
+							var middle = tokenizeInterpolationExpression(placeholderMap[placeholder]);
+							var after = s.substring(index + placeholder.length);
+							var replacement = [];
+							if (before) replacement.push(before);
+							replacement.push(middle);
+							if (after) {
+								var afterTokens = [after];
+								walkTokens(afterTokens);
+								replacement.push.apply(replacement, afterTokens);
+							}
+							if (typeof token === "string") {
+								tokens.splice.apply(tokens, [i, 1].concat(replacement));
+								i += replacement.length - 1;
+							} else token.content = replacement;
+						}
+					} else {
+						var content = token.content;
+						if (Array.isArray(content)) walkTokens(content);
+						else walkTokens([content]);
+					}
+				}
+			}
+			walkTokens(embeddedTokens);
+			return new Prism.Token(language, embeddedTokens, "language-" + language, code);
+		}
+		/**
+		* The languages for which JS templating will handle tagged template literals.
+		*
+		* JS templating isn't active for only JavaScript but also related languages like TypeScript, JSX, and TSX.
+		*/
+		var supportedLanguages = {
+			javascript: true,
+			js: true,
+			typescript: true,
+			ts: true,
+			jsx: true,
+			tsx: true
+		};
+		Prism.hooks.add("after-tokenize", function(env) {
+			if (!(env.language in supportedLanguages)) return;
+			/**
+			* Finds and tokenizes all template strings with an embedded languages.
+			*
+			* @param {(Token | string)[]} tokens
+			* @returns {void}
+			*/
+			function findTemplateStrings(tokens) {
+				for (var i = 0, l = tokens.length; i < l; i++) {
+					var token = tokens[i];
+					if (typeof token === "string") continue;
+					var content = token.content;
+					if (!Array.isArray(content)) {
+						if (typeof content !== "string") findTemplateStrings([content]);
+						continue;
+					}
+					if (token.type === "template-string") {
+						/**
+						* A JavaScript template-string token will look like this:
+						*
+						* ["template-string", [
+						*     ["template-punctuation", "`"],
+						*     (
+						*         An array of "string" and "interpolation" tokens. This is the simple string case.
+						*         or
+						*         ["embedded-code", "..."] This is the token containing the embedded code.
+						*                                  It also has an alias which is the language of the embedded code.
+						*     ),
+						*     ["template-punctuation", "`"]
+						* ]]
+						*/
+						var embedded = content[1];
+						if (content.length === 3 && typeof embedded !== "string" && embedded.type === "embedded-code") {
+							var code = stringContent(embedded);
+							var alias = embedded.alias;
+							var language = Array.isArray(alias) ? alias[0] : alias;
+							var grammar = Prism.languages[language];
+							if (!grammar) continue;
+							content[1] = tokenizeEmbedded(code, grammar, language);
+						}
+					} else findTemplateStrings(content);
+				}
+			}
+			findTemplateStrings(env.tokens);
+		});
+		/**
+		* Returns the string content of a token or token stream.
+		*
+		* @param {string | Token | (string | Token)[]} value
+		* @returns {string}
+		*/
+		function stringContent(value) {
+			if (typeof value === "string") return value;
+			else if (Array.isArray(value)) return value.map(stringContent).join("");
+			else return stringContent(value.content);
+		}
+	})(Prism);
+}
+
+//#endregion
+export { jsTemplates as default };