nitro-nightly 3.0.1-20260106-130706-e20c92d9 → 3.0.1-20260106-182834-5019d347

package/dist/_libs/hasown.mjs

@@ -0,0 +1,14 @@
+import { t as __commonJSMin } from "../_rolldown.mjs";
+import { t as require_function_bind } from "./function-bind.mjs";
+
+//#region node_modules/.pnpm/hasown@2.0.2/node_modules/hasown/index.js
+var require_hasown = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var call = Function.prototype.call;
+	var $hasOwn = Object.prototype.hasOwnProperty;
+	var bind = require_function_bind();
+	/** @type {import('.')} */
+	module.exports = bind.call(call, $hasOwn);
+}));
+
+//#endregion
+export { require_hasown as t };

package/dist/_libs/is-core-module.mjs

@@ -0,0 +1,220 @@
+import { t as __commonJSMin } from "../_rolldown.mjs";
+import { t as require_hasown } from "./hasown.mjs";
+
+//#region node_modules/.pnpm/is-core-module@2.16.1/node_modules/is-core-module/core.json
+var require_core = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"assert": true,
+		"node:assert": [">= 14.18 && < 15", ">= 16"],
+		"assert/strict": ">= 15",
+		"node:assert/strict": ">= 16",
+		"async_hooks": ">= 8",
+		"node:async_hooks": [">= 14.18 && < 15", ">= 16"],
+		"buffer_ieee754": ">= 0.5 && < 0.9.7",
+		"buffer": true,
+		"node:buffer": [">= 14.18 && < 15", ">= 16"],
+		"child_process": true,
+		"node:child_process": [">= 14.18 && < 15", ">= 16"],
+		"cluster": ">= 0.5",
+		"node:cluster": [">= 14.18 && < 15", ">= 16"],
+		"console": true,
+		"node:console": [">= 14.18 && < 15", ">= 16"],
+		"constants": true,
+		"node:constants": [">= 14.18 && < 15", ">= 16"],
+		"crypto": true,
+		"node:crypto": [">= 14.18 && < 15", ">= 16"],
+		"_debug_agent": ">= 1 && < 8",
+		"_debugger": "< 8",
+		"dgram": true,
+		"node:dgram": [">= 14.18 && < 15", ">= 16"],
+		"diagnostics_channel": [">= 14.17 && < 15", ">= 15.1"],
+		"node:diagnostics_channel": [">= 14.18 && < 15", ">= 16"],
+		"dns": true,
+		"node:dns": [">= 14.18 && < 15", ">= 16"],
+		"dns/promises": ">= 15",
+		"node:dns/promises": ">= 16",
+		"domain": ">= 0.7.12",
+		"node:domain": [">= 14.18 && < 15", ">= 16"],
+		"events": true,
+		"node:events": [">= 14.18 && < 15", ">= 16"],
+		"freelist": "< 6",
+		"fs": true,
+		"node:fs": [">= 14.18 && < 15", ">= 16"],
+		"fs/promises": [">= 10 && < 10.1", ">= 14"],
+		"node:fs/promises": [">= 14.18 && < 15", ">= 16"],
+		"_http_agent": ">= 0.11.1",
+		"node:_http_agent": [">= 14.18 && < 15", ">= 16"],
+		"_http_client": ">= 0.11.1",
+		"node:_http_client": [">= 14.18 && < 15", ">= 16"],
+		"_http_common": ">= 0.11.1",
+		"node:_http_common": [">= 14.18 && < 15", ">= 16"],
+		"_http_incoming": ">= 0.11.1",
+		"node:_http_incoming": [">= 14.18 && < 15", ">= 16"],
+		"_http_outgoing": ">= 0.11.1",
+		"node:_http_outgoing": [">= 14.18 && < 15", ">= 16"],
+		"_http_server": ">= 0.11.1",
+		"node:_http_server": [">= 14.18 && < 15", ">= 16"],
+		"http": true,
+		"node:http": [">= 14.18 && < 15", ">= 16"],
+		"http2": ">= 8.8",
+		"node:http2": [">= 14.18 && < 15", ">= 16"],
+		"https": true,
+		"node:https": [">= 14.18 && < 15", ">= 16"],
+		"inspector": ">= 8",
+		"node:inspector": [">= 14.18 && < 15", ">= 16"],
+		"inspector/promises": [">= 19"],
+		"node:inspector/promises": [">= 19"],
+		"_linklist": "< 8",
+		"module": true,
+		"node:module": [">= 14.18 && < 15", ">= 16"],
+		"net": true,
+		"node:net": [">= 14.18 && < 15", ">= 16"],
+		"node-inspect/lib/_inspect": ">= 7.6 && < 12",
+		"node-inspect/lib/internal/inspect_client": ">= 7.6 && < 12",
+		"node-inspect/lib/internal/inspect_repl": ">= 7.6 && < 12",
+		"os": true,
+		"node:os": [">= 14.18 && < 15", ">= 16"],
+		"path": true,
+		"node:path": [">= 14.18 && < 15", ">= 16"],
+		"path/posix": ">= 15.3",
+		"node:path/posix": ">= 16",
+		"path/win32": ">= 15.3",
+		"node:path/win32": ">= 16",
+		"perf_hooks": ">= 8.5",
+		"node:perf_hooks": [">= 14.18 && < 15", ">= 16"],
+		"process": ">= 1",
+		"node:process": [">= 14.18 && < 15", ">= 16"],
+		"punycode": ">= 0.5",
+		"node:punycode": [">= 14.18 && < 15", ">= 16"],
+		"querystring": true,
+		"node:querystring": [">= 14.18 && < 15", ">= 16"],
+		"readline": true,
+		"node:readline": [">= 14.18 && < 15", ">= 16"],
+		"readline/promises": ">= 17",
+		"node:readline/promises": ">= 17",
+		"repl": true,
+		"node:repl": [">= 14.18 && < 15", ">= 16"],
+		"node:sea": [">= 20.12 && < 21", ">= 21.7"],
+		"smalloc": ">= 0.11.5 && < 3",
+		"node:sqlite": [">= 22.13 && < 23", ">= 23.4"],
+		"_stream_duplex": ">= 0.9.4",
+		"node:_stream_duplex": [">= 14.18 && < 15", ">= 16"],
+		"_stream_transform": ">= 0.9.4",
+		"node:_stream_transform": [">= 14.18 && < 15", ">= 16"],
+		"_stream_wrap": ">= 1.4.1",
+		"node:_stream_wrap": [">= 14.18 && < 15", ">= 16"],
+		"_stream_passthrough": ">= 0.9.4",
+		"node:_stream_passthrough": [">= 14.18 && < 15", ">= 16"],
+		"_stream_readable": ">= 0.9.4",
+		"node:_stream_readable": [">= 14.18 && < 15", ">= 16"],
+		"_stream_writable": ">= 0.9.4",
+		"node:_stream_writable": [">= 14.18 && < 15", ">= 16"],
+		"stream": true,
+		"node:stream": [">= 14.18 && < 15", ">= 16"],
+		"stream/consumers": ">= 16.7",
+		"node:stream/consumers": ">= 16.7",
+		"stream/promises": ">= 15",
+		"node:stream/promises": ">= 16",
+		"stream/web": ">= 16.5",
+		"node:stream/web": ">= 16.5",
+		"string_decoder": true,
+		"node:string_decoder": [">= 14.18 && < 15", ">= 16"],
+		"sys": [">= 0.4 && < 0.7", ">= 0.8"],
+		"node:sys": [">= 14.18 && < 15", ">= 16"],
+		"test/reporters": ">= 19.9 && < 20.2",
+		"node:test/reporters": [
+			">= 18.17 && < 19",
+			">= 19.9",
+			">= 20"
+		],
+		"test/mock_loader": ">= 22.3 && < 22.7",
+		"node:test/mock_loader": ">= 22.3 && < 22.7",
+		"node:test": [">= 16.17 && < 17", ">= 18"],
+		"timers": true,
+		"node:timers": [">= 14.18 && < 15", ">= 16"],
+		"timers/promises": ">= 15",
+		"node:timers/promises": ">= 16",
+		"_tls_common": ">= 0.11.13",
+		"node:_tls_common": [">= 14.18 && < 15", ">= 16"],
+		"_tls_legacy": ">= 0.11.3 && < 10",
+		"_tls_wrap": ">= 0.11.3",
+		"node:_tls_wrap": [">= 14.18 && < 15", ">= 16"],
+		"tls": true,
+		"node:tls": [">= 14.18 && < 15", ">= 16"],
+		"trace_events": ">= 10",
+		"node:trace_events": [">= 14.18 && < 15", ">= 16"],
+		"tty": true,
+		"node:tty": [">= 14.18 && < 15", ">= 16"],
+		"url": true,
+		"node:url": [">= 14.18 && < 15", ">= 16"],
+		"util": true,
+		"node:util": [">= 14.18 && < 15", ">= 16"],
+		"util/types": ">= 15.3",
+		"node:util/types": ">= 16",
+		"v8/tools/arguments": ">= 10 && < 12",
+		"v8/tools/codemap": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+		"v8/tools/consarray": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+		"v8/tools/csvparser": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+		"v8/tools/logreader": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+		"v8/tools/profile_view": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+		"v8/tools/splaytree": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+		"v8": ">= 1",
+		"node:v8": [">= 14.18 && < 15", ">= 16"],
+		"vm": true,
+		"node:vm": [">= 14.18 && < 15", ">= 16"],
+		"wasi": [
+			">= 13.4 && < 13.5",
+			">= 18.17 && < 19",
+			">= 20"
+		],
+		"node:wasi": [">= 18.17 && < 19", ">= 20"],
+		"worker_threads": ">= 11.7",
+		"node:worker_threads": [">= 14.18 && < 15", ">= 16"],
+		"zlib": ">= 0.5",
+		"node:zlib": [">= 14.18 && < 15", ">= 16"]
+	};
+}));
+
+//#endregion
+//#region node_modules/.pnpm/is-core-module@2.16.1/node_modules/is-core-module/index.js
+var require_is_core_module = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var hasOwn = require_hasown();
+	function specifierIncluded(current, specifier) {
+		var nodeParts = current.split(".");
+		var parts = specifier.split(" ");
+		var op = parts.length > 1 ? parts[0] : "=";
+		var versionParts = (parts.length > 1 ? parts[1] : parts[0]).split(".");
+		for (var i = 0; i < 3; ++i) {
+			var cur = parseInt(nodeParts[i] || 0, 10);
+			var ver = parseInt(versionParts[i] || 0, 10);
+			if (cur === ver) continue;
+			if (op === "<") return cur < ver;
+			if (op === ">=") return cur >= ver;
+			return false;
+		}
+		return op === ">=";
+	}
+	function matchesRange(current, range) {
+		var specifiers = range.split(/ ?&& ?/);
+		if (specifiers.length === 0) return false;
+		for (var i = 0; i < specifiers.length; ++i) if (!specifierIncluded(current, specifiers[i])) return false;
+		return true;
+	}
+	function versionIncluded(nodeVersion, specifierValue) {
+		if (typeof specifierValue === "boolean") return specifierValue;
+		var current = typeof nodeVersion === "undefined" ? process.versions && process.versions.node : nodeVersion;
+		if (typeof current !== "string") throw new TypeError(typeof nodeVersion === "undefined" ? "Unable to determine current node version" : "If provided, a valid node version is required");
+		if (specifierValue && typeof specifierValue === "object") {
+			for (var i = 0; i < specifierValue.length; ++i) if (matchesRange(current, specifierValue[i])) return true;
+			return false;
+		}
+		return matchesRange(current, specifierValue);
+	}
+	var data = require_core();
+	module.exports = function isCore(x, nodeVersion) {
+		return hasOwn(data, x) && versionIncluded(nodeVersion, data[x]);
+	};
+}));
+
+//#endregion
+export { require_is_core_module as t };

package/dist/_libs/is-module.mjs

@@ -0,0 +1,13 @@
+import { t as __commonJSMin } from "../_rolldown.mjs";
+
+//#region node_modules/.pnpm/is-module@1.0.0/node_modules/is-module/index.js
+var require_is_module = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var ES6ImportExportRegExp = /(?:^\s*|[}{\(\);,\n]\s*)(import\s+['"]|(import|module)\s+[^"'\(\)\n;]+\s+from\s+['"]|export\s+(\*|\{|default|function|var|const|let|[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*))/;
+	var ES6AliasRegExp = /(?:^\s*|[}{\(\);,\n]\s*)(export\s*\*\s*from\s*(?:'([^']+)'|"([^"]+)"))/;
+	module.exports = function(sauce) {
+		return ES6ImportExportRegExp.test(sauce) || ES6AliasRegExp.test(sauce);
+	};
+}));
+
+//#endregion
+export { require_is_module as t };

package/dist/_libs/is-reference.mjs

@@ -0,0 +1,33 @@
+import { t as __commonJSMin } from "../_rolldown.mjs";
+
+//#region node_modules/.pnpm/is-reference@1.2.1/node_modules/is-reference/dist/is-reference.js
+var require_is_reference = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(global, factory) {
+		typeof exports === "object" && typeof module !== "undefined" ? module.exports = factory() : typeof define === "function" && define.amd ? define(factory) : (global = global || self, global.isReference = factory());
+	})(exports, (function() {
+		"use strict";
+		function isReference(node, parent) {
+			if (node.type === "MemberExpression") return !node.computed && isReference(node.object, node);
+			if (node.type === "Identifier") {
+				if (!parent) return true;
+				switch (parent.type) {
+					case "MemberExpression": return parent.computed || node === parent.object;
+					case "MethodDefinition": return parent.computed;
+					case "FieldDefinition": return parent.computed || node === parent.value;
+					case "Property": return parent.computed || node === parent.value;
+					case "ExportSpecifier":
+					case "ImportSpecifier": return node === parent.local;
+					case "LabeledStatement":
+					case "BreakStatement":
+					case "ContinueStatement": return false;
+					default: return true;
+				}
+			}
+			return false;
+		}
+		return isReference;
+	}));
+}));
+
+//#endregion
+export { require_is_reference as t };

package/dist/_libs/js-tokens.mjs

@@ -0,0 +1,382 @@
+import { t as __commonJSMin } from "../_rolldown.mjs";
+
+//#region node_modules/.pnpm/js-tokens@9.0.1/node_modules/js-tokens/index.js
+var require_js_tokens = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var HashbangComment, Identifier, JSXIdentifier, JSXPunctuator, JSXString, JSXText, KeywordsWithExpressionAfter, KeywordsWithNoLineTerminatorAfter, LineTerminatorSequence, MultiLineComment, Newline, NumericLiteral, Punctuator, RegularExpressionLiteral = /\/(?![*\/])(?:\[(?:[^\]\\\n\r\u2028\u2029]+|\\.)*\]?|[^\/[\\\n\r\u2028\u2029]+|\\.)*(\/[$_\u200C\u200D\p{ID_Continue}]*|\\)?/uy, SingleLineComment, StringLiteral, Template, TokensNotPrecedingObjectLiteral, TokensPrecedingExpression, WhiteSpace;
+	Punctuator = /--|\+\+|=>|\.{3}|\??\.(?!\d)|(?:&&|\|\||\?\?|[+\-%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2}|\/(?![\/*]))=?|[?~,:;[\](){}]/y;
+	Identifier = /(\x23?)(?=[$_\p{ID_Start}\\])(?:[$_\u200C\u200D\p{ID_Continue}]+|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+/uy;
+	StringLiteral = /(['"])(?:[^'"\\\n\r]+|(?!\1)['"]|\\(?:\r\n|[^]))*(\1)?/y;
+	NumericLiteral = /(?:0[xX][\da-fA-F](?:_?[\da-fA-F])*|0[oO][0-7](?:_?[0-7])*|0[bB][01](?:_?[01])*)n?|0n|[1-9](?:_?\d)*n|(?:(?:0(?!\d)|0\d*[89]\d*|[1-9](?:_?\d)*)(?:\.(?:\d(?:_?\d)*)?)?|\.\d(?:_?\d)*)(?:[eE][+-]?\d(?:_?\d)*)?|0[0-7]+/y;
+	Template = /[`}](?:[^`\\$]+|\\[^]|\$(?!\{))*(`|\$\{)?/y;
+	WhiteSpace = /[\t\v\f\ufeff\p{Zs}]+/uy;
+	LineTerminatorSequence = /\r?\n|[\r\u2028\u2029]/y;
+	MultiLineComment = /\/\*(?:[^*]+|\*(?!\/))*(\*\/)?/y;
+	SingleLineComment = /\/\/.*/y;
+	HashbangComment = /^#!.*/;
+	JSXPunctuator = /[<>.:={}]|\/(?![\/*])/y;
+	JSXIdentifier = /[$_\p{ID_Start}][$_\u200C\u200D\p{ID_Continue}-]*/uy;
+	JSXString = /(['"])(?:[^'"]+|(?!\1)['"])*(\1)?/y;
+	JSXText = /[^<>{}]+/y;
+	TokensPrecedingExpression = /^(?:[\/+-]|\.{3}|\?(?:InterpolationIn(?:JSX|Template)|NoLineTerminatorHere|NonExpressionParenEnd|UnaryIncDec))?$|[{}([,;<>=*%&|^!~?:]$/;
+	TokensNotPrecedingObjectLiteral = /^(?:=>|[;\]){}]|else|\?(?:NoLineTerminatorHere|NonExpressionParenEnd))?$/;
+	KeywordsWithExpressionAfter = /^(?:await|case|default|delete|do|else|instanceof|new|return|throw|typeof|void|yield)$/;
+	KeywordsWithNoLineTerminatorAfter = /^(?:return|throw|yield)$/;
+	Newline = RegExp(LineTerminatorSequence.source);
+	module.exports = function* (input, { jsx = false } = {}) {
+		var braces, firstCodePoint, isExpression, lastIndex, lastSignificantToken, length, match, mode, nextLastIndex, nextLastSignificantToken, parenNesting, postfixIncDec, punctuator, stack;
+		({length} = input);
+		lastIndex = 0;
+		lastSignificantToken = "";
+		stack = [{ tag: "JS" }];
+		braces = [];
+		parenNesting = 0;
+		postfixIncDec = false;
+		if (match = HashbangComment.exec(input)) {
+			yield {
+				type: "HashbangComment",
+				value: match[0]
+			};
+			lastIndex = match[0].length;
+		}
+		while (lastIndex < length) {
+			mode = stack[stack.length - 1];
+			switch (mode.tag) {
+				case "JS":
+				case "JSNonExpressionParen":
+				case "InterpolationInTemplate":
+				case "InterpolationInJSX":
+					if (input[lastIndex] === "/" && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken))) {
+						RegularExpressionLiteral.lastIndex = lastIndex;
+						if (match = RegularExpressionLiteral.exec(input)) {
+							lastIndex = RegularExpressionLiteral.lastIndex;
+							lastSignificantToken = match[0];
+							postfixIncDec = true;
+							yield {
+								type: "RegularExpressionLiteral",
+								value: match[0],
+								closed: match[1] !== void 0 && match[1] !== "\\"
+							};
+							continue;
+						}
+					}
+					Punctuator.lastIndex = lastIndex;
+					if (match = Punctuator.exec(input)) {
+						punctuator = match[0];
+						nextLastIndex = Punctuator.lastIndex;
+						nextLastSignificantToken = punctuator;
+						switch (punctuator) {
+							case "(":
+								if (lastSignificantToken === "?NonExpressionParenKeyword") stack.push({
+									tag: "JSNonExpressionParen",
+									nesting: parenNesting
+								});
+								parenNesting++;
+								postfixIncDec = false;
+								break;
+							case ")":
+								parenNesting--;
+								postfixIncDec = true;
+								if (mode.tag === "JSNonExpressionParen" && parenNesting === mode.nesting) {
+									stack.pop();
+									nextLastSignificantToken = "?NonExpressionParenEnd";
+									postfixIncDec = false;
+								}
+								break;
+							case "{":
+								Punctuator.lastIndex = 0;
+								isExpression = !TokensNotPrecedingObjectLiteral.test(lastSignificantToken) && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken));
+								braces.push(isExpression);
+								postfixIncDec = false;
+								break;
+							case "}":
+								switch (mode.tag) {
+									case "InterpolationInTemplate":
+										if (braces.length === mode.nesting) {
+											Template.lastIndex = lastIndex;
+											match = Template.exec(input);
+											lastIndex = Template.lastIndex;
+											lastSignificantToken = match[0];
+											if (match[1] === "${") {
+												lastSignificantToken = "?InterpolationInTemplate";
+												postfixIncDec = false;
+												yield {
+													type: "TemplateMiddle",
+													value: match[0]
+												};
+											} else {
+												stack.pop();
+												postfixIncDec = true;
+												yield {
+													type: "TemplateTail",
+													value: match[0],
+													closed: match[1] === "`"
+												};
+											}
+											continue;
+										}
+										break;
+									case "InterpolationInJSX": if (braces.length === mode.nesting) {
+										stack.pop();
+										lastIndex += 1;
+										lastSignificantToken = "}";
+										yield {
+											type: "JSXPunctuator",
+											value: "}"
+										};
+										continue;
+									}
+								}
+								postfixIncDec = braces.pop();
+								nextLastSignificantToken = postfixIncDec ? "?ExpressionBraceEnd" : "}";
+								break;
+							case "]":
+								postfixIncDec = true;
+								break;
+							case "++":
+							case "--":
+								nextLastSignificantToken = postfixIncDec ? "?PostfixIncDec" : "?UnaryIncDec";
+								break;
+							case "<":
+								if (jsx && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken))) {
+									stack.push({ tag: "JSXTag" });
+									lastIndex += 1;
+									lastSignificantToken = "<";
+									yield {
+										type: "JSXPunctuator",
+										value: punctuator
+									};
+									continue;
+								}
+								postfixIncDec = false;
+								break;
+							default: postfixIncDec = false;
+						}
+						lastIndex = nextLastIndex;
+						lastSignificantToken = nextLastSignificantToken;
+						yield {
+							type: "Punctuator",
+							value: punctuator
+						};
+						continue;
+					}
+					Identifier.lastIndex = lastIndex;
+					if (match = Identifier.exec(input)) {
+						lastIndex = Identifier.lastIndex;
+						nextLastSignificantToken = match[0];
+						switch (match[0]) {
+							case "for":
+							case "if":
+							case "while":
+							case "with": if (lastSignificantToken !== "." && lastSignificantToken !== "?.") nextLastSignificantToken = "?NonExpressionParenKeyword";
+						}
+						lastSignificantToken = nextLastSignificantToken;
+						postfixIncDec = !KeywordsWithExpressionAfter.test(match[0]);
+						yield {
+							type: match[1] === "#" ? "PrivateIdentifier" : "IdentifierName",
+							value: match[0]
+						};
+						continue;
+					}
+					StringLiteral.lastIndex = lastIndex;
+					if (match = StringLiteral.exec(input)) {
+						lastIndex = StringLiteral.lastIndex;
+						lastSignificantToken = match[0];
+						postfixIncDec = true;
+						yield {
+							type: "StringLiteral",
+							value: match[0],
+							closed: match[2] !== void 0
+						};
+						continue;
+					}
+					NumericLiteral.lastIndex = lastIndex;
+					if (match = NumericLiteral.exec(input)) {
+						lastIndex = NumericLiteral.lastIndex;
+						lastSignificantToken = match[0];
+						postfixIncDec = true;
+						yield {
+							type: "NumericLiteral",
+							value: match[0]
+						};
+						continue;
+					}
+					Template.lastIndex = lastIndex;
+					if (match = Template.exec(input)) {
+						lastIndex = Template.lastIndex;
+						lastSignificantToken = match[0];
+						if (match[1] === "${") {
+							lastSignificantToken = "?InterpolationInTemplate";
+							stack.push({
+								tag: "InterpolationInTemplate",
+								nesting: braces.length
+							});
+							postfixIncDec = false;
+							yield {
+								type: "TemplateHead",
+								value: match[0]
+							};
+						} else {
+							postfixIncDec = true;
+							yield {
+								type: "NoSubstitutionTemplate",
+								value: match[0],
+								closed: match[1] === "`"
+							};
+						}
+						continue;
+					}
+					break;
+				case "JSXTag":
+				case "JSXTagEnd":
+					JSXPunctuator.lastIndex = lastIndex;
+					if (match = JSXPunctuator.exec(input)) {
+						lastIndex = JSXPunctuator.lastIndex;
+						nextLastSignificantToken = match[0];
+						switch (match[0]) {
+							case "<":
+								stack.push({ tag: "JSXTag" });
+								break;
+							case ">":
+								stack.pop();
+								if (lastSignificantToken === "/" || mode.tag === "JSXTagEnd") {
+									nextLastSignificantToken = "?JSX";
+									postfixIncDec = true;
+								} else stack.push({ tag: "JSXChildren" });
+								break;
+							case "{":
+								stack.push({
+									tag: "InterpolationInJSX",
+									nesting: braces.length
+								});
+								nextLastSignificantToken = "?InterpolationInJSX";
+								postfixIncDec = false;
+								break;
+							case "/": if (lastSignificantToken === "<") {
+								stack.pop();
+								if (stack[stack.length - 1].tag === "JSXChildren") stack.pop();
+								stack.push({ tag: "JSXTagEnd" });
+							}
+						}
+						lastSignificantToken = nextLastSignificantToken;
+						yield {
+							type: "JSXPunctuator",
+							value: match[0]
+						};
+						continue;
+					}
+					JSXIdentifier.lastIndex = lastIndex;
+					if (match = JSXIdentifier.exec(input)) {
+						lastIndex = JSXIdentifier.lastIndex;
+						lastSignificantToken = match[0];
+						yield {
+							type: "JSXIdentifier",
+							value: match[0]
+						};
+						continue;
+					}
+					JSXString.lastIndex = lastIndex;
+					if (match = JSXString.exec(input)) {
+						lastIndex = JSXString.lastIndex;
+						lastSignificantToken = match[0];
+						yield {
+							type: "JSXString",
+							value: match[0],
+							closed: match[2] !== void 0
+						};
+						continue;
+					}
+					break;
+				case "JSXChildren":
+					JSXText.lastIndex = lastIndex;
+					if (match = JSXText.exec(input)) {
+						lastIndex = JSXText.lastIndex;
+						lastSignificantToken = match[0];
+						yield {
+							type: "JSXText",
+							value: match[0]
+						};
+						continue;
+					}
+					switch (input[lastIndex]) {
+						case "<":
+							stack.push({ tag: "JSXTag" });
+							lastIndex++;
+							lastSignificantToken = "<";
+							yield {
+								type: "JSXPunctuator",
+								value: "<"
+							};
+							continue;
+						case "{":
+							stack.push({
+								tag: "InterpolationInJSX",
+								nesting: braces.length
+							});
+							lastIndex++;
+							lastSignificantToken = "?InterpolationInJSX";
+							postfixIncDec = false;
+							yield {
+								type: "JSXPunctuator",
+								value: "{"
+							};
+							continue;
+					}
+			}
+			WhiteSpace.lastIndex = lastIndex;
+			if (match = WhiteSpace.exec(input)) {
+				lastIndex = WhiteSpace.lastIndex;
+				yield {
+					type: "WhiteSpace",
+					value: match[0]
+				};
+				continue;
+			}
+			LineTerminatorSequence.lastIndex = lastIndex;
+			if (match = LineTerminatorSequence.exec(input)) {
+				lastIndex = LineTerminatorSequence.lastIndex;
+				postfixIncDec = false;
+				if (KeywordsWithNoLineTerminatorAfter.test(lastSignificantToken)) lastSignificantToken = "?NoLineTerminatorHere";
+				yield {
+					type: "LineTerminatorSequence",
+					value: match[0]
+				};
+				continue;
+			}
+			MultiLineComment.lastIndex = lastIndex;
+			if (match = MultiLineComment.exec(input)) {
+				lastIndex = MultiLineComment.lastIndex;
+				if (Newline.test(match[0])) {
+					postfixIncDec = false;
+					if (KeywordsWithNoLineTerminatorAfter.test(lastSignificantToken)) lastSignificantToken = "?NoLineTerminatorHere";
+				}
+				yield {
+					type: "MultiLineComment",
+					value: match[0],
+					closed: match[1] !== void 0
+				};
+				continue;
+			}
+			SingleLineComment.lastIndex = lastIndex;
+			if (match = SingleLineComment.exec(input)) {
+				lastIndex = SingleLineComment.lastIndex;
+				postfixIncDec = false;
+				yield {
+					type: "SingleLineComment",
+					value: match[0]
+				};
+				continue;
+			}
+			firstCodePoint = String.fromCodePoint(input.codePointAt(lastIndex));
+			lastIndex += firstCodePoint.length;
+			lastSignificantToken = firstCodePoint;
+			postfixIncDec = false;
+			yield {
+				type: mode.tag.startsWith("JSX") ? "JSXInvalid" : "Invalid",
+				value: firstCodePoint
+			};
+		}
+	};
+}));
+
+//#endregion
+export { require_js_tokens as t };