@voidzero-dev/vite-plus-core 0.1.23 → 0.1.24

package/dist/tsdown/{dist-wWM45aJq.js → dist-BHLOKn-2.js}

@@ -1,14 +1,13 @@
-import { n as __exportAll, r as __toESM, t as __commonJSMin } from "./chunk-DJK8HYOj.js";
-import { i as createDebug } from "./main-Cq8Is40L.js";
-import { _ as filename_dts_to, b as replaceTemplateName, c as RE_CSS, d as RE_JS, f as RE_JSON, g as RE_VUE, h as RE_TS, l as RE_DTS, m as RE_ROLLDOWN_RUNTIME, o as at, p as RE_NODE_MODULES, s as ee, u as RE_DTS_MAP, v as filename_js_to_dts, x as resolveTemplateFn, y as filename_to_dts } from "./build-5FURNVr0-CsM6vj3e.js";
-import { n as globalContext, r as invalidateContextFile, t as createContext } from "./tsc-context-DXovbMXp.js";
+import { A as __commonJSMin, M as __toESM, a as createDebug, j as __exportAll } from "./main-nVIFtu2j.js";
+import { _ as filename_dts_to, b as replaceTemplateName, c as RE_CSS, d as RE_JS, f as RE_JSON, g as RE_VUE, h as RE_TS, l as RE_DTS, m as RE_ROLLDOWN_RUNTIME, o as at, p as RE_NODE_MODULES, s as ee, u as RE_DTS_MAP, v as filename_js_to_dts, x as resolveTemplateFn, y as filename_to_dts } from "./build-BZshaq8i-C7uS6x65.js";
+import { n as globalContext, r as invalidateContextFile, t as createContext } from "./tsc-context-DKufFI_s.js";
 import { createRequire } from "node:module";
 import process from "node:process";
 import { fork, spawn } from "node:child_process";
 import path, { dirname, extname } from "node:path";
+import { existsSync } from "node:fs";
 import { mkdtemp, readFile, rm } from "node:fs/promises";
 import { importerId, include } from "@voidzero-dev/vite-plus-core/rolldown/filter";
-import { existsSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { ResolverFactory, isolatedDeclarationSync } from "@voidzero-dev/vite-plus-core/rolldown/experimental";
 //#region ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.5/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
@@ -653,7 +652,7 @@ function addMappingInternal(skipable, map, mapping) {
 	return addSegmentInternal(skipable, map, generated.line - 1, generated.column, source, original.line - 1, original.column, name, content);
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@babel+helper-validator-identifier@8.0.0-rc.5/node_modules/@babel/helper-validator-identifier/lib/index.js
+//#region ../../node_modules/.pnpm/@babel+helper-validator-identifier@8.0.0-rc.6/node_modules/@babel/helper-validator-identifier/lib/index.js
 const nonASCIIidentifierStart$1 = /* @__PURE__ */ new RegExp("[ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙՠ-ֈא-תׯ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࡠ-ࡪࡰ-ࢇࢉ-࢏ࢠ-ࣉऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱৼਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚ౜ౝౠౡಀಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ೜-ೞೠೡೱೲഄ-ഌഎ-ഐഒ-ഺഽൎൔ-ൖൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄຆ-ຊຌ-ຣລວ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜑᜟ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡸᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭌᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᲀ-ᲊᲐ-ᲺᲽ-Ჿᳩ-ᳬᳮ-ᳳᳵᳶᳺᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄯㄱ-ㆎㆠ-ㆿㇰ-ㇿ㐀-䶿一-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-Ƛ꟱-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꣾꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭩꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ]");
 const nonASCIIidentifier$1 = /* @__PURE__ */ new RegExp("[ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙՠ-ֈא-תׯ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࡠ-ࡪࡰ-ࢇࢉ-࢏ࢠ-ࣉऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱৼਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚ౜ౝౠౡಀಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ೜-ೞೠೡೱೲഄ-ഌഎ-ഐഒ-ഺഽൎൔ-ൖൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄຆ-ຊຌ-ຣລວ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜑᜟ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡸᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭌᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᲀ-ᲊᲐ-ᲺᲽ-Ჿᳩ-ᳬᳮ-ᳳᳵᳶᳺᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄯㄱ-ㆎㆠ-ㆿㇰ-ㇿ㐀-䶿一-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-Ƛ꟱-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꣾꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭩꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-٩ٰۖ-ۜ۟-۪ۤۧۨ-ۭ۰-۹ܑܰ-݊ަ-ް߀-߉߫-߽߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛ࢗ-࢟࣊-ࣣ࣡-ःऺ-़ा-ॏ॑-ॗॢॣ०-९ঁ-ঃ়া-ৄেৈো-্ৗৢৣ০-৯৾ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑ੦-ੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣ૦-૯ૺ-૿ଁ-ଃ଼ା-ୄେୈୋ-୍୕-ୗୢୣ୦-୯ஂா-ூெ-ைொ-்ௗ௦-௯ఀ-ఄ఼ా-ౄె-ైొ-్ౕౖౢౣ౦-౯ಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣ೦-೯ೳഀ-ഃ഻഼ാ-ൄെ-ൈൊ-്ൗൢൣ൦-൯ඁ-ඃ්ා-ුූෘ-ෟ෦-෯ෲෳัิ-ฺ็-๎๐-๙ັິ-ຼ່-໎໐-໙༘༙༠-༩༹༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှ၀-၉ၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏ-ႝ፝-፟፩-፱ᜒ-᜕ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝០-៩᠋-᠍᠏-᠙ᢩᤠ-ᤫᤰ-᤻᥆-᥏᧐-᧚ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼-᪉᪐-᪙᪰-᪽ᪿ-᫝᫠-᫫ᬀ-ᬄ᬴-᭄᭐-᭙᭫-᭳ᮀ-ᮂᮡ-ᮭ᮰-᮹᯦-᯳ᰤ-᰷᱀-᱉᱐-᱙᳐-᳔᳒-᳨᳭᳴᳷-᳹᷀-᷿‌‍‿⁀⁔⃐-⃥⃜⃡-⃰⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯・꘠-꘩꙯ꙴ-꙽ꚞꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧ꠬ꢀꢁꢴ-ꣅ꣐-꣙꣠-꣱ꣿ-꤉ꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀꧐-꧙ꧥ꧰-꧹ꨩ-ꨶꩃꩌꩍ꩐-꩙ꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭꯰-꯹ﬞ︀-️︠-︯︳︴﹍-﹏０-９＿･]");
 const astralIdentifierStartCodes$1 = [
@@ -1651,7 +1650,7 @@ function isIdentifierName(name) {
 	}
 	return !isFirst;
 }
-const reservedWords$2 = {
+const reservedWords$1 = {
 	keyword: [
 		"break",
 		"case",
@@ -1702,20 +1701,20 @@ const reservedWords$2 = {
 	],
 	strictBind: ["eval", "arguments"]
 };
-const keywords$3 = new Set(reservedWords$2.keyword);
-const reservedWordsStrictSet$2 = new Set(reservedWords$2.strict);
-new Set(reservedWords$2.strictBind);
+const keywords$2 = new Set(reservedWords$1.keyword);
+const reservedWordsStrictSet$1 = new Set(reservedWords$1.strict);
+new Set(reservedWords$1.strictBind);
 function isReservedWord$1(word, inModule) {
 	return inModule && word === "await" || word === "enum";
 }
 function isStrictReservedWord$1(word, inModule) {
-	return isReservedWord$1(word, inModule) || reservedWordsStrictSet$2.has(word);
+	return isReservedWord$1(word, inModule) || reservedWordsStrictSet$1.has(word);
 }
 function isKeyword$1(word) {
-	return keywords$3.has(word);
+	return keywords$2.has(word);
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@babel+helper-string-parser@8.0.0-rc.5/node_modules/@babel/helper-string-parser/lib/index.js
+//#region ../../node_modules/.pnpm/@babel+helper-string-parser@8.0.0-rc.6/node_modules/@babel/helper-string-parser/lib/index.js
 var _isDigit$1 = function isDigit(code) {
 	return code >= 48 && code <= 57;
 };
@@ -1935,7 +1934,7 @@ function readCodePoint$1(input, pos, lineStart, curLine, throwOnInvalid, errors)
 	};
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@babel+types@8.0.0-rc.5/node_modules/@babel/types/lib/index.js
+//#region ../../node_modules/.pnpm/@babel+types@8.0.0-rc.6/node_modules/@babel/types/lib/index.js
 var lib_exports = /* @__PURE__ */ __exportAll({
 	ACCESSOR_TYPES: () => ACCESSOR_TYPES,
 	ALIAS_KEYS: () => ALIAS_KEYS,
@@ -2829,7 +2828,7 @@ var lib_exports = /* @__PURE__ */ __exportAll({
 	isLet: () => isLet,
 	isLiteral: () => isLiteral$1,
 	isLogicalExpression: () => isLogicalExpression,
-	isLoop: () => isLoop$2,
+	isLoop: () => isLoop$1,
 	isMemberExpression: () => isMemberExpression$2,
 	isMetaProperty: () => isMetaProperty,
 	isMethod: () => isMethod,
@@ -4788,7 +4787,7 @@ function isConditional(node, opts) {
 	}
 	return opts == null || shallowEqual(node, opts);
 }
-function isLoop$2(node, opts) {
+function isLoop$1(node, opts) {
 	if (!node) return false;
 	switch (node.type) {
 		case "DoWhileStatement":
@@ -13650,7 +13649,7 @@ const react = {
 	buildChildren
 };
 //#endregion
-//#region ../../node_modules/.pnpm/@babel+generator@8.0.0-rc.5/node_modules/@babel/generator/lib/index.js
+//#region ../../node_modules/.pnpm/@babel+generator@8.0.0-rc.6/node_modules/@babel/generator/lib/index.js
 var import_jsesc = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const object = {};
 	const hasOwnProperty = object.hasOwnProperty;
@@ -13881,7 +13880,7 @@ var SourceMap = class {
 	getRawMappings() {
 		return this._rawMappings ||= allMappings(this._map);
 	}
-	mark(generated, line, column, identifierName, identifierNamePos, filename) {
+	mark(generated, generatedIdentifierName, line, column, identifierName, identifierNamePos, filename) {
 		this._rawMappings = void 0;
 		let originalMapping;
 		if (line != null) if (this._inputMap) {
@@ -13889,7 +13888,8 @@ var SourceMap = class {
 				line,
 				column
 			});
-			if (!originalMapping.name && identifierNamePos) {
+			if (originalMapping.name && (identifierNamePos || identifierName != null && originalMapping.column === column)) identifierName = originalMapping.name;
+			else if (identifierNamePos) {
 				const originalIdentifierMapping = originalPositionFor(this._inputMap, identifierNamePos);
 				if (originalIdentifierMapping.name) identifierName = originalIdentifierMapping.name;
 			}
@@ -13899,6 +13899,7 @@ var SourceMap = class {
 			line,
 			column
 		};
+		if (identifierName != null && identifierName === generatedIdentifierName) identifierName = null;
 		maybeAddMapping(this._map, {
 			name: identifierName,
 			generated,
@@ -13971,9 +13972,9 @@ var Buffer$1 = class {
 		};
 		return result;
 	}
-	append(str, maybeNewline) {
+	append(str, maybeNewline, ignoreMapping = false) {
 		this._flush();
-		this._append(str, maybeNewline);
+		this._append(str, maybeNewline, ignoreMapping);
 	}
 	appendChar(char) {
 		this._flush();
@@ -14002,12 +14003,12 @@ var Buffer$1 = class {
 			if (this._map) {
 				const sourcePos = this._sourcePosition;
 				if (useSourcePos && sourcePos) {
-					this._map.mark(position, sourcePos.line, sourcePos.column, isSpace ? void 0 : sourcePos.identifierName, isSpace ? void 0 : sourcePos.identifierNamePos, sourcePos.filename);
+					this._map.mark(position, null, sourcePos.line, sourcePos.column, isSpace ? void 0 : sourcePos.identifierName, isSpace ? void 0 : sourcePos.identifierNamePos, sourcePos.filename);
 					if (!isSpace && this._canMarkIdName) {
 						sourcePos.identifierName = void 0;
 						sourcePos.identifierNamePos = void 0;
 					}
-				} else this._map.mark(position);
+				} else this._map.mark(position, null);
 			}
 			position.column += repeat;
 		} else {
@@ -14015,7 +14016,7 @@ var Buffer$1 = class {
 			position.column = 0;
 		}
 	}
-	_append(str, maybeNewline) {
+	_append(str, maybeNewline, ignoreMapping) {
 		const len = str.length;
 		const position = this._position;
 		const sourcePos = this._sourcePosition;
@@ -14026,7 +14027,7 @@ var Buffer$1 = class {
 			this._str = str;
 			this._appendCount = 0;
 		} else this._str += str;
-		const hasMap = this._map !== null;
+		const hasMap = !ignoreMapping && this._map !== null;
 		if (!maybeNewline && !hasMap) {
 			position.column += len;
 			return;
@@ -14039,14 +14040,14 @@ var Buffer$1 = class {
 		}
 		let i = str.indexOf("\n");
 		let last = 0;
-		if (hasMap && i !== 0) this._map.mark(position, line, column, identifierName, identifierNamePos, filename);
+		if (hasMap && i !== 0) this._map.mark(position, str, line, column, identifierName, identifierNamePos, filename);
 		while (i !== -1) {
 			position.line++;
 			position.column = 0;
 			last = i + 1;
 			if (last < len && line !== void 0) {
 				line++;
-				if (hasMap) this._map.mark(position, line, 0, void 0, void 0, filename);
+				if (hasMap) this._map.mark(position, str, line, 0, void 0, void 0, filename);
 			}
 			i = str.indexOf("\n", last);
 		}
@@ -14097,13 +14098,16 @@ var Buffer$1 = class {
 	_normalizePosition(prop, loc, columnOffset) {
 		this._flush();
 		const pos = loc[prop];
-		const target = this._sourcePosition;
 		if (pos) {
-			target.line = pos.line;
-			target.column = Math.max(pos.column + columnOffset, 0);
-			target.filename = loc.filename;
+			this.setSourcePosition(pos.line, Math.max(pos.column + columnOffset, 0));
+			this._sourcePosition.filename = loc.filename;
 		}
 	}
+	setSourcePosition(line, column) {
+		const target = this._sourcePosition;
+		target.line = line;
+		target.column = column;
+	}
 	getCurrentColumn() {
 		return this._position.column + (this._queuedChar ? 1 : 0);
 	}
@@ -14966,6 +14970,9 @@ function _shouldPrintArrowParamsParens(node) {
 	if (this.format.retainLines) return true;
 	return false;
 }
+function isRenamedIdentifier(id) {
+	return !!id.loc?.identifierName && id.loc.identifierName !== id.name;
+}
 function _getFuncIdName(idNode, parent) {
 	let id = idNode;
 	if (!id && parent) {
@@ -14976,18 +14983,22 @@ function _getFuncIdName(idNode, parent) {
 			if (!parent.computed || parent.key.type === "StringLiteral") id = parent.key;
 		} else if (parentType === "ClassPrivateProperty" || parentType === "ClassAccessorProperty") id = parent.key;
 	}
-	if (!id) return;
+	if (!id?.loc) return;
 	let nameInfo;
-	if (id.type === "Identifier") nameInfo = {
-		pos: id.loc?.start,
-		name: id.loc?.identifierName || id.name
-	};
-	else if (id.type === "PrivateName") nameInfo = {
-		pos: id.loc?.start,
-		name: "#" + id.id.name
-	};
-	else if (id.type === "StringLiteral") nameInfo = {
-		pos: id.loc?.start,
+	if (id.type === "Identifier") {
+		if (!isRenamedIdentifier(id)) return;
+		nameInfo = {
+			pos: id.loc.start,
+			name: id.loc.identifierName
+		};
+	} else if (id.type === "PrivateName") {
+		if (!isRenamedIdentifier(id.id)) return;
+		nameInfo = {
+			pos: id.loc.start,
+			name: "#" + id.id.loc.identifierName
+		};
+	} else if (id.type === "StringLiteral") nameInfo = {
+		pos: id.loc.start,
 		name: id.value
 	};
 	return nameInfo;
@@ -15789,7 +15800,7 @@ function _getRawIdentifier(node) {
 	return lastRawIdentResult = node.name;
 }
 function Identifier(node) {
-	if (this._buf._map) this.sourceIdentifierName(node.loc?.identifierName || node.name);
+	if (this._buf._map && node.loc?.identifierName && node.loc.identifierName !== node.name) this.sourceIdentifierName(node.loc.identifierName);
 	this.word(this.tokenMap ? lastRawIdentResult : node.name);
 }
 function ArgumentPlaceholder() {
@@ -17476,7 +17487,8 @@ var Printer = class {
 		const spacesCount = count > 0 ? column : column - this._buf.getCurrentColumn();
 		if (spacesCount > 0) {
 			const spaces = this._originalCode ? this._originalCode.slice(index - spacesCount, index).replace(/[^\t\v\f\uFEFF\p{Space_Separator}]/gu, " ") : " ".repeat(spacesCount);
-			this._append(spaces, false);
+			this._buf.append(spaces, false, true);
+			this._buf.setSourcePosition(line, column);
 			this.setLastChar(32);
 		}
 	}
@@ -17854,8 +17866,8 @@ function generate(ast, opts = {}, code) {
 	return new Printer(normalizeOptions(code, opts, ast), opts.sourceMaps ? new SourceMap(opts, code) : null, ast.tokens, typeof code === "string" ? code : null).generate(ast);
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@babel+parser@8.0.0-rc.4/node_modules/@babel/parser/lib/index.js
-var Position$1 = class {
+//#region ../../node_modules/.pnpm/@babel+parser@8.0.0-rc.6/node_modules/@babel/parser/lib/index.js
+var Position = class {
 	constructor(line, col, index) {
 		this.line = void 0;
 		this.column = void 0;
@@ -17865,7 +17877,7 @@ var Position$1 = class {
 		if (index !== void 0) this.index = index;
 	}
 };
-var SourceLocation$1 = class {
+var SourceLocation = class {
 	start;
 	end;
 	filename;
@@ -17877,20 +17889,20 @@ var SourceLocation$1 = class {
 };
 function createPositionWithColumnOffset(position, columnOffset) {
 	const { line, column, index } = position;
-	return new Position$1(line, column + columnOffset, index + columnOffset);
+	return new Position(line, column + columnOffset, index + columnOffset);
 }
-const code$1 = "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED";
-const ModuleErrors$1 = {
+const code = "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED";
+const ModuleErrors = {
 	ImportMetaOutsideModule: {
 		message: `import.meta may appear only with 'sourceType: "module"'`,
-		code: code$1
+		code
 	},
 	ImportOutsideModule: {
 		message: `'import' and 'export' may appear only with 'sourceType: "module"'`,
-		code: code$1
+		code
 	}
 };
-const NodeDescriptions$1 = {
+const NodeDescriptions = {
 	ArrayPattern: "array destructuring pattern",
 	AssignmentExpression: "assignment expression",
 	AssignmentPattern: "assignment expression",
@@ -17915,8 +17927,8 @@ const NodeDescriptions$1 = {
 	VariableDeclarator: "variable declaration",
 	YieldExpression: "yield expression"
 };
-const toNodeDescription$1 = (node) => node.type === "UpdateExpression" ? NodeDescriptions$1.UpdateExpression[`${node.prefix}`] : NodeDescriptions$1[node.type];
-const StandardErrors$1 = {
+const toNodeDescription = (node) => node.type === "UpdateExpression" ? NodeDescriptions.UpdateExpression[`${node.prefix}`] : NodeDescriptions[node.type];
+const StandardErrors = {
 	AccessorIsGenerator: ({ kind }) => `A ${kind}ter cannot be a generator.`,
 	ArgumentsInClass: "'arguments' is only allowed in functions and class methods.",
 	AsyncFunctionInSingleStatementContext: "Async functions can only be declared at the top level or inside a block.",
@@ -17934,7 +17946,6 @@ const StandardErrors$1 = {
 	ConstructorIsAsync: "Constructor can't be an async function.",
 	ConstructorIsGenerator: "Constructor can't be a generator.",
 	DeclarationMissingInitializer: ({ kind }) => `Missing initializer in ${kind} declaration.`,
-	DecoratorAbstractMethod: "Decorators can't be used with an abstract method.",
 	DecoratorArgumentsOutsideParentheses: "Decorator arguments must be moved inside parentheses: use '@(decorator(args))' instead of '@(decorator)(args)'.",
 	DecoratorsBeforeAfterExport: "Decorators can be placed *either* before or after the 'export' keyword, but not in both locations at the same time.",
 	DecoratorConstructor: "Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?",
@@ -17974,9 +17985,9 @@ const StandardErrors$1 = {
 	InvalidEscapeSequenceTemplate: "Invalid escape sequence in template.",
 	InvalidEscapedReservedWord: ({ reservedWord }) => `Escape sequence in keyword ${reservedWord}.`,
 	InvalidIdentifier: ({ identifierName }) => `Invalid identifier ${identifierName}.`,
-	InvalidLhs: ({ ancestor }) => `Invalid left-hand side in ${toNodeDescription$1(ancestor)}.`,
-	InvalidLhsBinding: ({ ancestor }) => `Binding invalid left-hand side in ${toNodeDescription$1(ancestor)}.`,
-	InvalidLhsOptionalChaining: ({ ancestor }) => `Invalid optional chaining in the left-hand side of ${toNodeDescription$1(ancestor)}.`,
+	InvalidLhs: ({ ancestor }) => `Invalid left-hand side in ${toNodeDescription(ancestor)}.`,
+	InvalidLhsBinding: ({ ancestor }) => `Binding invalid left-hand side in ${toNodeDescription(ancestor)}.`,
+	InvalidLhsOptionalChaining: ({ ancestor }) => `Invalid optional chaining in the left-hand side of ${toNodeDescription(ancestor)}.`,
 	InvalidNumber: "Invalid number.",
 	InvalidOrMissingExponent: "Floating-point numbers require a valid exponent after the 'e'.",
 	InvalidOrUnexpectedToken: ({ unexpected }) => `Unexpected character '${unexpected}'.`,
@@ -18058,7 +18069,7 @@ const StandardErrors$1 = {
 	YieldNotInGeneratorFunction: "'yield' is only allowed within generator functions.",
 	ZeroDigitNumericSeparator: "Numeric separator can not be used after leading 0."
 };
-const StrictModeErrors$1 = {
+const StrictModeErrors = {
 	StrictDelete: "Deleting local variable in strict mode.",
 	StrictEvalArguments: ({ referenceName }) => `Assigning to '${referenceName}' in strict mode.`,
 	StrictEvalArgumentsBinding: ({ bindingName }) => `Binding '${bindingName}' in strict mode.`,
@@ -18067,7 +18078,7 @@ const StrictModeErrors$1 = {
 	StrictOctalLiteral: "Legacy octal literals are not allowed in strict mode.",
 	StrictWith: "'with' in strict mode."
 };
-const ParseExpressionErrors$1 = {
+const ParseExpressionErrors = {
 	ParseExpressionEmptyInput: "Unexpected parseExpression() input: The input is empty or contains only comments.",
 	ParseExpressionExpectsEOF: ({ unexpected }) => `Unexpected parseExpression() input: The input should contain exactly one expression, but the first expression is followed by the unexpected character \`${String.fromCodePoint(unexpected)}\`.`
 };
@@ -18077,26 +18088,26 @@ const UnparenthesizedPipeBodyDescriptions = new Set([
 	"ConditionalExpression",
 	"YieldExpression"
 ]);
-const PipelineOperatorErrors$1 = {
+const PipelineOperatorErrors = {
 	PipeTopicRequiresHackPipes: "Topic references are only supported when using the `\"proposal\": \"hack\"` version of the pipeline proposal.",
 	PipeTopicUnbound: "Topic reference is unbound; it must be inside a pipe body.",
 	PipeTopicUnconfiguredToken: ({ token }) => `Invalid topic token ${token}. In order to use ${token} as a topic reference, the pipelineOperator plugin must be configured with { "proposal": "hack", "topicToken": "${token}" }.`,
 	PipeTopicUnused: "Hack-style pipe body does not contain a topic reference; Hack-style pipes must use topic at least once.",
-	PipeUnparenthesizedBody: ({ type }) => `Hack-style pipe body cannot be an unparenthesized ${toNodeDescription$1({ type })}; please wrap it in parentheses.`,
+	PipeUnparenthesizedBody: ({ type }) => `Hack-style pipe body cannot be an unparenthesized ${toNodeDescription({ type })}; please wrap it in parentheses.`,
 	PipelineUnparenthesized: "Cannot mix binary operator with solo-await F#-style pipeline. Please wrap the pipeline in parentheses."
 };
-const FunctionBindErrors$1 = {
+const FunctionBindErrors = {
 	UnsupportedBind: "Binding should be performed on object property.",
 	UnsupportedBindRHS: "The right-hand side of binding can not be super or import."
 };
-function defineHidden$1(obj, key, value) {
+function defineHidden(obj, key, value) {
 	Object.defineProperty(obj, key, {
 		enumerable: false,
 		configurable: true,
 		value
 	});
 }
-function toParseErrorConstructor$1({ toMessage, code, reasonCode, syntaxPlugin }) {
+function toParseErrorConstructor({ toMessage, code, reasonCode, syntaxPlugin }) {
 	const hasMissingPlugin = reasonCode === "MissingPlugin" || reasonCode === "MissingOneOfPlugins";
 	return function constructor(loc, pos, details) {
 		const error = /* @__PURE__ */ new SyntaxError();
@@ -18106,14 +18117,14 @@ function toParseErrorConstructor$1({ toMessage, code, reasonCode, syntaxPlugin }
 		error.pos = pos;
 		error.syntaxPlugin = syntaxPlugin;
 		if (hasMissingPlugin) error.missingPlugin = details.missingPlugin;
-		defineHidden$1(error, "clone", function clone(overrides = {}) {
+		defineHidden(error, "clone", function clone(overrides = {}) {
 			const { line, column, index = pos } = overrides.loc ?? loc;
-			return constructor(new Position$1(line, column), index, {
+			return constructor(new Position(line, column), index, {
 				...details,
 				...overrides.details
 			});
 		});
-		defineHidden$1(error, "details", details);
+		defineHidden(error, "details", details);
 		Object.defineProperty(error, "message", {
 			configurable: true,
 			get() {
@@ -18131,13 +18142,13 @@ function toParseErrorConstructor$1({ toMessage, code, reasonCode, syntaxPlugin }
 		return error;
 	};
 }
-function ParseErrorEnum$1(argument, syntaxPlugin) {
-	if (Array.isArray(argument)) return (parseErrorTemplates) => ParseErrorEnum$1(parseErrorTemplates, argument[0]);
+function ParseErrorEnum(argument, syntaxPlugin) {
+	if (Array.isArray(argument)) return (parseErrorTemplates) => ParseErrorEnum(parseErrorTemplates, argument[0]);
 	const ParseErrorConstructors = {};
 	for (const reasonCode of Object.keys(argument)) {
 		const template = argument[reasonCode];
 		const { message, ...rest } = typeof template === "string" ? { message: () => template } : typeof template === "function" ? { message: template } : template;
-		ParseErrorConstructors[reasonCode] = toParseErrorConstructor$1({
+		ParseErrorConstructors[reasonCode] = toParseErrorConstructor({
 			code: "BABEL_PARSER_SYNTAX_ERROR",
 			reasonCode,
 			toMessage: typeof message === "string" ? () => message : message,
@@ -18147,13 +18158,13 @@ function ParseErrorEnum$1(argument, syntaxPlugin) {
 	}
 	return ParseErrorConstructors;
 }
-const Errors$1 = {
-	...ParseErrorEnum$1(ModuleErrors$1),
-	...ParseErrorEnum$1(StandardErrors$1),
-	...ParseErrorEnum$1(StrictModeErrors$1),
-	...ParseErrorEnum$1(ParseExpressionErrors$1),
-	...ParseErrorEnum$1`pipelineOperator`(PipelineOperatorErrors$1),
-	...ParseErrorEnum$1`functionBind`(FunctionBindErrors$1)
+const Errors = {
+	...ParseErrorEnum(ModuleErrors),
+	...ParseErrorEnum(StandardErrors),
+	...ParseErrorEnum(StrictModeErrors),
+	...ParseErrorEnum(ParseExpressionErrors),
+	...ParseErrorEnum`pipelineOperator`(PipelineOperatorErrors),
+	...ParseErrorEnum`functionBind`(FunctionBindErrors)
 };
 function createDefaultOptions() {
 	return {
@@ -18199,13 +18210,13 @@ function getOptions(opts) {
 }
 function toESTreeLocation(node) {
 	const { start, end } = node.loc;
-	node.loc.start = new Position$1(start.line, start.column);
-	node.loc.end = new Position$1(end.line, end.column);
+	node.loc.start = new Position(start.line, start.column);
+	node.loc.end = new Position(end.line, end.column);
 	return node;
 }
 const estree = (superClass) => class ESTreeParserMixin extends superClass {
 	createPosition(loc) {
-		return new Position$1(loc.line, loc.column);
+		return new Position(loc.line, loc.column);
 	}
 	parse() {
 		const file = super.parse();
@@ -18404,8 +18415,8 @@ const estree = (superClass) => class ESTreeParserMixin extends superClass {
 		} else super.toAssignable(node, isLHS);
 	}
 	toAssignableObjectExpressionProp(prop, isLast, isLHS) {
-		if (prop.type === "Property" && (prop.kind === "get" || prop.kind === "set")) this.raise(Errors$1.PatternHasAccessor, prop.key);
-		else if (prop.type === "Property" && prop.method) this.raise(Errors$1.PatternHasMethod, prop.key);
+		if (prop.type === "Property" && (prop.kind === "get" || prop.kind === "set")) this.raise(Errors.PatternHasAccessor, prop.key);
+		else if (prop.type === "Property" && prop.method) this.raise(Errors.PatternHasMethod, prop.key);
 		else super.toAssignableObjectExpressionProp(prop, isLast, isLHS);
 	}
 	finishCallExpression(unfinished, optional) {
@@ -18500,13 +18511,13 @@ const estree = (superClass) => class ESTreeParserMixin extends superClass {
 		toESTreeLocation(node);
 	}
 };
-const beforeExpr$1 = true;
-const startsExpr$1 = true;
-const isLoop$1 = true;
-const isAssign$1 = true;
-const prefix$1 = true;
-const postfix$1 = true;
-var ExportedTokenType$1 = class {
+const beforeExpr = true;
+const startsExpr = true;
+const isLoop = true;
+const isAssign = true;
+const prefix = true;
+const postfix = true;
+var ExportedTokenType = class {
 	label;
 	keyword;
 	beforeExpr;
@@ -18530,300 +18541,300 @@ var ExportedTokenType$1 = class {
 		this.binop = conf.binop != null ? conf.binop : null;
 	}
 };
-const keywords$1$1 = /* @__PURE__ */ new Map();
-function createKeyword$1(name, options = {}) {
+const keywords$1 = /* @__PURE__ */ new Map();
+function createKeyword(name, options = {}) {
 	options.keyword = name;
-	const token = createToken$1(name, options);
-	keywords$1$1.set(name, token);
+	const token = createToken(name, options);
+	keywords$1.set(name, token);
 	return token;
 }
-function createBinop$1(name, binop) {
-	return createToken$1(name, {
-		beforeExpr: beforeExpr$1,
+function createBinop(name, binop) {
+	return createToken(name, {
+		beforeExpr,
 		binop
 	});
 }
-let tokenTypeCounter$1 = -1;
-const tokenTypes$1 = [];
-const tokenLabels$1 = [];
-const tokenBinops$1 = [];
-const tokenBeforeExprs$1 = [];
-const tokenStartsExprs$1 = [];
-const tokenPrefixes$1 = [];
-function createToken$1(name, options = {}) {
-	++tokenTypeCounter$1;
-	tokenLabels$1.push(name);
-	tokenBinops$1.push(options.binop ?? -1);
-	tokenBeforeExprs$1.push(options.beforeExpr ?? false);
-	tokenStartsExprs$1.push(options.startsExpr ?? false);
-	tokenPrefixes$1.push(options.prefix ?? false);
-	tokenTypes$1.push(new ExportedTokenType$1(name, options));
-	return tokenTypeCounter$1;
-}
-function createKeywordLike$1(name, options = {}) {
-	++tokenTypeCounter$1;
-	keywords$1$1.set(name, tokenTypeCounter$1);
-	tokenLabels$1.push(name);
-	tokenBinops$1.push(options.binop ?? -1);
-	tokenBeforeExprs$1.push(options.beforeExpr ?? false);
-	tokenStartsExprs$1.push(options.startsExpr ?? false);
-	tokenPrefixes$1.push(options.prefix ?? false);
-	tokenTypes$1.push(new ExportedTokenType$1("name", options));
-	return tokenTypeCounter$1;
-}
-const tt$1 = {
-	bracketL: createToken$1("[", {
-		beforeExpr: beforeExpr$1,
-		startsExpr: startsExpr$1
+let tokenTypeCounter = -1;
+const tokenTypes = [];
+const tokenLabels = [];
+const tokenBinops = [];
+const tokenBeforeExprs = [];
+const tokenStartsExprs = [];
+const tokenPrefixes = [];
+function createToken(name, options = {}) {
+	++tokenTypeCounter;
+	tokenLabels.push(name);
+	tokenBinops.push(options.binop ?? -1);
+	tokenBeforeExprs.push(options.beforeExpr ?? false);
+	tokenStartsExprs.push(options.startsExpr ?? false);
+	tokenPrefixes.push(options.prefix ?? false);
+	tokenTypes.push(new ExportedTokenType(name, options));
+	return tokenTypeCounter;
+}
+function createKeywordLike(name, options = {}) {
+	++tokenTypeCounter;
+	keywords$1.set(name, tokenTypeCounter);
+	tokenLabels.push(name);
+	tokenBinops.push(options.binop ?? -1);
+	tokenBeforeExprs.push(options.beforeExpr ?? false);
+	tokenStartsExprs.push(options.startsExpr ?? false);
+	tokenPrefixes.push(options.prefix ?? false);
+	tokenTypes.push(new ExportedTokenType("name", options));
+	return tokenTypeCounter;
+}
+const tt = {
+	bracketL: createToken("[", {
+		beforeExpr,
+		startsExpr
 	}),
-	bracketR: createToken$1("]"),
-	braceL: createToken$1("{", {
-		beforeExpr: beforeExpr$1,
-		startsExpr: startsExpr$1
+	bracketR: createToken("]"),
+	braceL: createToken("{", {
+		beforeExpr,
+		startsExpr
 	}),
-	braceBarL: createToken$1("{|", {
-		beforeExpr: beforeExpr$1,
-		startsExpr: startsExpr$1
+	braceBarL: createToken("{|", {
+		beforeExpr,
+		startsExpr
 	}),
-	braceR: createToken$1("}"),
-	braceBarR: createToken$1("|}"),
-	parenL: createToken$1("(", {
-		beforeExpr: beforeExpr$1,
-		startsExpr: startsExpr$1
+	braceR: createToken("}"),
+	braceBarR: createToken("|}"),
+	parenL: createToken("(", {
+		beforeExpr,
+		startsExpr
 	}),
-	parenR: createToken$1(")"),
-	comma: createToken$1(",", { beforeExpr: beforeExpr$1 }),
-	semi: createToken$1(";", { beforeExpr: beforeExpr$1 }),
-	colon: createToken$1(":", { beforeExpr: beforeExpr$1 }),
-	doubleColon: createToken$1("::", { beforeExpr: beforeExpr$1 }),
-	dot: createToken$1("."),
-	question: createToken$1("?", { beforeExpr: beforeExpr$1 }),
-	questionDot: createToken$1("?."),
-	arrow: createToken$1("=>", { beforeExpr: beforeExpr$1 }),
-	template: createToken$1("template"),
-	ellipsis: createToken$1("...", { beforeExpr: beforeExpr$1 }),
-	backQuote: createToken$1("`", { startsExpr: startsExpr$1 }),
-	dollarBraceL: createToken$1("${", {
-		beforeExpr: beforeExpr$1,
-		startsExpr: startsExpr$1
+	parenR: createToken(")"),
+	comma: createToken(",", { beforeExpr }),
+	semi: createToken(";", { beforeExpr }),
+	colon: createToken(":", { beforeExpr }),
+	doubleColon: createToken("::", { beforeExpr }),
+	dot: createToken("."),
+	question: createToken("?", { beforeExpr }),
+	questionDot: createToken("?."),
+	arrow: createToken("=>", { beforeExpr }),
+	template: createToken("template"),
+	ellipsis: createToken("...", { beforeExpr }),
+	backQuote: createToken("`", { startsExpr }),
+	dollarBraceL: createToken("${", {
+		beforeExpr,
+		startsExpr
 	}),
-	templateTail: createToken$1("...`", { startsExpr: startsExpr$1 }),
-	templateNonTail: createToken$1("...${", {
-		beforeExpr: beforeExpr$1,
-		startsExpr: startsExpr$1
+	templateTail: createToken("...`", { startsExpr }),
+	templateNonTail: createToken("...${", {
+		beforeExpr,
+		startsExpr
 	}),
-	at: createToken$1("@"),
-	hash: createToken$1("#", { startsExpr: startsExpr$1 }),
-	interpreterDirective: createToken$1("#!..."),
-	eq: createToken$1("=", {
-		beforeExpr: beforeExpr$1,
-		isAssign: isAssign$1
+	at: createToken("@"),
+	hash: createToken("#", { startsExpr }),
+	interpreterDirective: createToken("#!..."),
+	eq: createToken("=", {
+		beforeExpr,
+		isAssign
 	}),
-	assign: createToken$1("_=", {
-		beforeExpr: beforeExpr$1,
-		isAssign: isAssign$1
+	assign: createToken("_=", {
+		beforeExpr,
+		isAssign
 	}),
-	slashAssign: createToken$1("_=", {
-		beforeExpr: beforeExpr$1,
-		isAssign: isAssign$1
+	slashAssign: createToken("_=", {
+		beforeExpr,
+		isAssign
 	}),
-	xorAssign: createToken$1("_=", {
-		beforeExpr: beforeExpr$1,
-		isAssign: isAssign$1
+	xorAssign: createToken("_=", {
+		beforeExpr,
+		isAssign
 	}),
-	moduloAssign: createToken$1("_=", {
-		beforeExpr: beforeExpr$1,
-		isAssign: isAssign$1
+	moduloAssign: createToken("_=", {
+		beforeExpr,
+		isAssign
 	}),
-	incDec: createToken$1("++/--", {
-		prefix: prefix$1,
-		postfix: postfix$1,
-		startsExpr: startsExpr$1
+	incDec: createToken("++/--", {
+		prefix,
+		postfix,
+		startsExpr
 	}),
-	bang: createToken$1("!", {
-		beforeExpr: beforeExpr$1,
-		prefix: prefix$1,
-		startsExpr: startsExpr$1
+	bang: createToken("!", {
+		beforeExpr,
+		prefix,
+		startsExpr
 	}),
-	tilde: createToken$1("~", {
-		beforeExpr: beforeExpr$1,
-		prefix: prefix$1,
-		startsExpr: startsExpr$1
+	tilde: createToken("~", {
+		beforeExpr,
+		prefix,
+		startsExpr
 	}),
-	doubleCaret: createToken$1("^^", { startsExpr: startsExpr$1 }),
-	doubleAt: createToken$1("@@", { startsExpr: startsExpr$1 }),
-	pipeline: createBinop$1("|>", 0),
-	nullishCoalescing: createBinop$1("??", 1),
-	logicalOR: createBinop$1("||", 1),
-	logicalAND: createBinop$1("&&", 2),
-	bitwiseOR: createBinop$1("|", 3),
-	bitwiseXOR: createBinop$1("^", 4),
-	bitwiseAND: createBinop$1("&", 5),
-	equality: createBinop$1("==/!=/===/!==", 6),
-	lt: createBinop$1("</>/<=/>=", 7),
-	gt: createBinop$1("</>/<=/>=", 7),
-	relational: createBinop$1("</>/<=/>=", 7),
-	bitShift: createBinop$1("<</>>/>>>", 8),
-	bitShiftL: createBinop$1("<</>>/>>>", 8),
-	bitShiftR: createBinop$1("<</>>/>>>", 8),
-	plusMin: createToken$1("+/-", {
-		beforeExpr: beforeExpr$1,
+	doubleCaret: createToken("^^", { startsExpr }),
+	doubleAt: createToken("@@", { startsExpr }),
+	pipeline: createBinop("|>", 0),
+	nullishCoalescing: createBinop("??", 1),
+	logicalOR: createBinop("||", 1),
+	logicalAND: createBinop("&&", 2),
+	bitwiseOR: createBinop("|", 3),
+	bitwiseXOR: createBinop("^", 4),
+	bitwiseAND: createBinop("&", 5),
+	equality: createBinop("==/!=/===/!==", 6),
+	lt: createBinop("</>/<=/>=", 7),
+	gt: createBinop("</>/<=/>=", 7),
+	relational: createBinop("</>/<=/>=", 7),
+	bitShift: createBinop("<</>>/>>>", 8),
+	bitShiftL: createBinop("<</>>/>>>", 8),
+	bitShiftR: createBinop("<</>>/>>>", 8),
+	plusMin: createToken("+/-", {
+		beforeExpr,
 		binop: 9,
-		prefix: prefix$1,
-		startsExpr: startsExpr$1
+		prefix,
+		startsExpr
 	}),
-	modulo: createToken$1("%", {
+	modulo: createToken("%", {
 		binop: 10,
-		startsExpr: startsExpr$1
+		startsExpr
 	}),
-	star: createToken$1("*", { binop: 10 }),
-	slash: createBinop$1("/", 10),
-	exponent: createToken$1("**", {
-		beforeExpr: beforeExpr$1,
+	star: createToken("*", { binop: 10 }),
+	slash: createBinop("/", 10),
+	exponent: createToken("**", {
+		beforeExpr,
 		binop: 11,
 		rightAssociative: true
 	}),
-	_in: createKeyword$1("in", {
-		beforeExpr: beforeExpr$1,
+	_in: createKeyword("in", {
+		beforeExpr,
 		binop: 7
 	}),
-	_instanceof: createKeyword$1("instanceof", {
-		beforeExpr: beforeExpr$1,
+	_instanceof: createKeyword("instanceof", {
+		beforeExpr,
 		binop: 7
 	}),
-	_break: createKeyword$1("break"),
-	_case: createKeyword$1("case", { beforeExpr: beforeExpr$1 }),
-	_catch: createKeyword$1("catch"),
-	_continue: createKeyword$1("continue"),
-	_debugger: createKeyword$1("debugger"),
-	_default: createKeyword$1("default", { beforeExpr: beforeExpr$1 }),
-	_else: createKeyword$1("else", { beforeExpr: beforeExpr$1 }),
-	_finally: createKeyword$1("finally"),
-	_function: createKeyword$1("function", { startsExpr: startsExpr$1 }),
-	_if: createKeyword$1("if"),
-	_return: createKeyword$1("return", { beforeExpr: beforeExpr$1 }),
-	_switch: createKeyword$1("switch"),
-	_throw: createKeyword$1("throw", {
-		beforeExpr: beforeExpr$1,
-		prefix: prefix$1,
-		startsExpr: startsExpr$1
+	_break: createKeyword("break"),
+	_case: createKeyword("case", { beforeExpr }),
+	_catch: createKeyword("catch"),
+	_continue: createKeyword("continue"),
+	_debugger: createKeyword("debugger"),
+	_default: createKeyword("default", { beforeExpr }),
+	_else: createKeyword("else", { beforeExpr }),
+	_finally: createKeyword("finally"),
+	_function: createKeyword("function", { startsExpr }),
+	_if: createKeyword("if"),
+	_return: createKeyword("return", { beforeExpr }),
+	_switch: createKeyword("switch"),
+	_throw: createKeyword("throw", {
+		beforeExpr,
+		prefix,
+		startsExpr
 	}),
-	_try: createKeyword$1("try"),
-	_var: createKeyword$1("var"),
-	_const: createKeyword$1("const"),
-	_with: createKeyword$1("with"),
-	_new: createKeyword$1("new", {
-		beforeExpr: beforeExpr$1,
-		startsExpr: startsExpr$1
+	_try: createKeyword("try"),
+	_var: createKeyword("var"),
+	_const: createKeyword("const"),
+	_with: createKeyword("with"),
+	_new: createKeyword("new", {
+		beforeExpr,
+		startsExpr
 	}),
-	_this: createKeyword$1("this", { startsExpr: startsExpr$1 }),
-	_super: createKeyword$1("super", { startsExpr: startsExpr$1 }),
-	_class: createKeyword$1("class", { startsExpr: startsExpr$1 }),
-	_extends: createKeyword$1("extends", { beforeExpr: beforeExpr$1 }),
-	_export: createKeyword$1("export"),
-	_import: createKeyword$1("import", { startsExpr: startsExpr$1 }),
-	_null: createKeyword$1("null", { startsExpr: startsExpr$1 }),
-	_true: createKeyword$1("true", { startsExpr: startsExpr$1 }),
-	_false: createKeyword$1("false", { startsExpr: startsExpr$1 }),
-	_typeof: createKeyword$1("typeof", {
-		beforeExpr: beforeExpr$1,
-		prefix: prefix$1,
-		startsExpr: startsExpr$1
+	_this: createKeyword("this", { startsExpr }),
+	_super: createKeyword("super", { startsExpr }),
+	_class: createKeyword("class", { startsExpr }),
+	_extends: createKeyword("extends", { beforeExpr }),
+	_export: createKeyword("export"),
+	_import: createKeyword("import", { startsExpr }),
+	_null: createKeyword("null", { startsExpr }),
+	_true: createKeyword("true", { startsExpr }),
+	_false: createKeyword("false", { startsExpr }),
+	_typeof: createKeyword("typeof", {
+		beforeExpr,
+		prefix,
+		startsExpr
 	}),
-	_void: createKeyword$1("void", {
-		beforeExpr: beforeExpr$1,
-		prefix: prefix$1,
-		startsExpr: startsExpr$1
+	_void: createKeyword("void", {
+		beforeExpr,
+		prefix,
+		startsExpr
 	}),
-	_delete: createKeyword$1("delete", {
-		beforeExpr: beforeExpr$1,
-		prefix: prefix$1,
-		startsExpr: startsExpr$1
+	_delete: createKeyword("delete", {
+		beforeExpr,
+		prefix,
+		startsExpr
 	}),
-	_do: createKeyword$1("do", {
-		isLoop: isLoop$1,
-		beforeExpr: beforeExpr$1
+	_do: createKeyword("do", {
+		isLoop,
+		beforeExpr
 	}),
-	_for: createKeyword$1("for", { isLoop: isLoop$1 }),
-	_while: createKeyword$1("while", { isLoop: isLoop$1 }),
-	_as: createKeywordLike$1("as", { startsExpr: startsExpr$1 }),
-	_assert: createKeywordLike$1("assert", { startsExpr: startsExpr$1 }),
-	_async: createKeywordLike$1("async", { startsExpr: startsExpr$1 }),
-	_await: createKeywordLike$1("await", { startsExpr: startsExpr$1 }),
-	_defer: createKeywordLike$1("defer", { startsExpr: startsExpr$1 }),
-	_from: createKeywordLike$1("from", { startsExpr: startsExpr$1 }),
-	_get: createKeywordLike$1("get", { startsExpr: startsExpr$1 }),
-	_let: createKeywordLike$1("let", { startsExpr: startsExpr$1 }),
-	_meta: createKeywordLike$1("meta", { startsExpr: startsExpr$1 }),
-	_of: createKeywordLike$1("of", { startsExpr: startsExpr$1 }),
-	_sent: createKeywordLike$1("sent", { startsExpr: startsExpr$1 }),
-	_set: createKeywordLike$1("set", { startsExpr: startsExpr$1 }),
-	_source: createKeywordLike$1("source", { startsExpr: startsExpr$1 }),
-	_static: createKeywordLike$1("static", { startsExpr: startsExpr$1 }),
-	_using: createKeywordLike$1("using", { startsExpr: startsExpr$1 }),
-	_yield: createKeywordLike$1("yield", { startsExpr: startsExpr$1 }),
-	_asserts: createKeywordLike$1("asserts", { startsExpr: startsExpr$1 }),
-	_checks: createKeywordLike$1("checks", { startsExpr: startsExpr$1 }),
-	_exports: createKeywordLike$1("exports", { startsExpr: startsExpr$1 }),
-	_global: createKeywordLike$1("global", { startsExpr: startsExpr$1 }),
-	_implements: createKeywordLike$1("implements", { startsExpr: startsExpr$1 }),
-	_intrinsic: createKeywordLike$1("intrinsic", { startsExpr: startsExpr$1 }),
-	_infer: createKeywordLike$1("infer", { startsExpr: startsExpr$1 }),
-	_is: createKeywordLike$1("is", { startsExpr: startsExpr$1 }),
-	_mixins: createKeywordLike$1("mixins", { startsExpr: startsExpr$1 }),
-	_proto: createKeywordLike$1("proto", { startsExpr: startsExpr$1 }),
-	_require: createKeywordLike$1("require", { startsExpr: startsExpr$1 }),
-	_satisfies: createKeywordLike$1("satisfies", { startsExpr: startsExpr$1 }),
-	_keyof: createKeywordLike$1("keyof", { startsExpr: startsExpr$1 }),
-	_readonly: createKeywordLike$1("readonly", { startsExpr: startsExpr$1 }),
-	_unique: createKeywordLike$1("unique", { startsExpr: startsExpr$1 }),
-	_abstract: createKeywordLike$1("abstract", { startsExpr: startsExpr$1 }),
-	_declare: createKeywordLike$1("declare", { startsExpr: startsExpr$1 }),
-	_enum: createKeywordLike$1("enum", { startsExpr: startsExpr$1 }),
-	_module: createKeywordLike$1("module", { startsExpr: startsExpr$1 }),
-	_namespace: createKeywordLike$1("namespace", { startsExpr: startsExpr$1 }),
-	_interface: createKeywordLike$1("interface", { startsExpr: startsExpr$1 }),
-	_type: createKeywordLike$1("type", { startsExpr: startsExpr$1 }),
-	_opaque: createKeywordLike$1("opaque", { startsExpr: startsExpr$1 }),
-	name: createToken$1("name", { startsExpr: startsExpr$1 }),
-	placeholder: createToken$1("%%", { startsExpr: startsExpr$1 }),
-	string: createToken$1("string", { startsExpr: startsExpr$1 }),
-	num: createToken$1("num", { startsExpr: startsExpr$1 }),
-	bigint: createToken$1("bigint", { startsExpr: startsExpr$1 }),
-	regexp: createToken$1("regexp", { startsExpr: startsExpr$1 }),
-	privateName: createToken$1("#name", { startsExpr: startsExpr$1 }),
-	eof: createToken$1("eof"),
-	jsxName: createToken$1("jsxName"),
-	jsxText: createToken$1("jsxText", { beforeExpr: beforeExpr$1 }),
-	jsxTagStart: createToken$1("jsxTagStart", { startsExpr: startsExpr$1 }),
-	jsxTagEnd: createToken$1("jsxTagEnd")
-};
-function tokenIsIdentifier(token) {
-	return token >= 89 && token <= 129;
-}
-function tokenKeywordOrIdentifierIsKeyword(token) {
-	return token <= 88;
-}
-function tokenIsKeywordOrIdentifier(token) {
-	return token >= 54 && token <= 129;
-}
-function tokenIsLiteralPropertyName(token) {
-	return token >= 54 && token <= 132;
-}
-function tokenComesBeforeExpression(token) {
-	return tokenBeforeExprs$1[token];
-}
-function tokenCanStartExpression(token) {
-	return tokenStartsExprs$1[token];
-}
-function tokenIsAssignment(token) {
-	return token >= 25 && token <= 29;
-}
-function tokenIsFlowInterfaceOrTypeOrOpaque(token) {
-	return token >= 125 && token <= 127;
-}
-function tokenIsLoop(token) {
-	return token >= 86 && token <= 88;
+	_for: createKeyword("for", { isLoop }),
+	_while: createKeyword("while", { isLoop }),
+	_as: createKeywordLike("as", { startsExpr }),
+	_assert: createKeywordLike("assert", { startsExpr }),
+	_async: createKeywordLike("async", { startsExpr }),
+	_await: createKeywordLike("await", { startsExpr }),
+	_defer: createKeywordLike("defer", { startsExpr }),
+	_from: createKeywordLike("from", { startsExpr }),
+	_get: createKeywordLike("get", { startsExpr }),
+	_let: createKeywordLike("let", { startsExpr }),
+	_meta: createKeywordLike("meta", { startsExpr }),
+	_of: createKeywordLike("of", { startsExpr }),
+	_sent: createKeywordLike("sent", { startsExpr }),
+	_set: createKeywordLike("set", { startsExpr }),
+	_source: createKeywordLike("source", { startsExpr }),
+	_static: createKeywordLike("static", { startsExpr }),
+	_using: createKeywordLike("using", { startsExpr }),
+	_yield: createKeywordLike("yield", { startsExpr }),
+	_asserts: createKeywordLike("asserts", { startsExpr }),
+	_checks: createKeywordLike("checks", { startsExpr }),
+	_exports: createKeywordLike("exports", { startsExpr }),
+	_global: createKeywordLike("global", { startsExpr }),
+	_implements: createKeywordLike("implements", { startsExpr }),
+	_intrinsic: createKeywordLike("intrinsic", { startsExpr }),
+	_infer: createKeywordLike("infer", { startsExpr }),
+	_is: createKeywordLike("is", { startsExpr }),
+	_mixins: createKeywordLike("mixins", { startsExpr }),
+	_proto: createKeywordLike("proto", { startsExpr }),
+	_require: createKeywordLike("require", { startsExpr }),
+	_satisfies: createKeywordLike("satisfies", { startsExpr }),
+	_keyof: createKeywordLike("keyof", { startsExpr }),
+	_readonly: createKeywordLike("readonly", { startsExpr }),
+	_unique: createKeywordLike("unique", { startsExpr }),
+	_abstract: createKeywordLike("abstract", { startsExpr }),
+	_declare: createKeywordLike("declare", { startsExpr }),
+	_enum: createKeywordLike("enum", { startsExpr }),
+	_module: createKeywordLike("module", { startsExpr }),
+	_namespace: createKeywordLike("namespace", { startsExpr }),
+	_interface: createKeywordLike("interface", { startsExpr }),
+	_type: createKeywordLike("type", { startsExpr }),
+	_opaque: createKeywordLike("opaque", { startsExpr }),
+	name: createToken("name", { startsExpr }),
+	placeholder: createToken("%%", { startsExpr }),
+	string: createToken("string", { startsExpr }),
+	num: createToken("num", { startsExpr }),
+	bigint: createToken("bigint", { startsExpr }),
+	regexp: createToken("regexp", { startsExpr }),
+	privateName: createToken("#name", { startsExpr }),
+	eof: createToken("eof"),
+	jsxName: createToken("jsxName"),
+	jsxText: createToken("jsxText", { beforeExpr }),
+	jsxTagStart: createToken("jsxTagStart", { startsExpr }),
+	jsxTagEnd: createToken("jsxTagEnd")
+};
+function tokenIsIdentifier(token) {
+	return token >= 89 && token <= 129;
+}
+function tokenKeywordOrIdentifierIsKeyword(token) {
+	return token <= 88;
+}
+function tokenIsKeywordOrIdentifier(token) {
+	return token >= 54 && token <= 129;
+}
+function tokenIsLiteralPropertyName(token) {
+	return token >= 54 && token <= 132;
+}
+function tokenComesBeforeExpression(token) {
+	return tokenBeforeExprs[token];
+}
+function tokenCanStartExpression(token) {
+	return tokenStartsExprs[token];
+}
+function tokenIsAssignment(token) {
+	return token >= 25 && token <= 29;
+}
+function tokenIsFlowInterfaceOrTypeOrOpaque(token) {
+	return token >= 125 && token <= 127;
+}
+function tokenIsLoop(token) {
+	return token >= 86 && token <= 88;
 }
 function tokenIsKeyword(token) {
 	return token >= 54 && token <= 88;
@@ -18835,7 +18846,7 @@ function tokenIsPostfix(token) {
 	return token === 30;
 }
 function tokenIsPrefix(token) {
-	return tokenPrefixes$1[token];
+	return tokenPrefixes[token];
 }
 function tokenIsTSTypeOperator(token) {
 	return token >= 117 && token <= 119;
@@ -18844,10 +18855,10 @@ function tokenIsTSDeclarationStart(token) {
 	return token >= 120 && token <= 126;
 }
 function tokenLabelName(token) {
-	return tokenLabels$1[token];
+	return tokenLabels[token];
 }
 function tokenOperatorPrecedence(token) {
-	return tokenBinops$1[token];
+	return tokenBinops[token];
 }
 function tokenIsRightAssociative(token) {
 	return token === 53;
@@ -18855,10 +18866,10 @@ function tokenIsRightAssociative(token) {
 function tokenIsTemplate(token) {
 	return token >= 20 && token <= 21;
 }
-function getExportedToken$1(token) {
-	return tokenTypes$1[token];
+function getExportedToken(token) {
+	return tokenTypes[token];
 }
-var TokContext$1 = class {
+var TokContext = class {
 	constructor(token, preserveSpace) {
 		this.token = token;
 		this.preserveSpace = !!preserveSpace;
@@ -18866,11 +18877,11 @@ var TokContext$1 = class {
 	token;
 	preserveSpace;
 };
-const types$1 = {
-	brace: new TokContext$1("{"),
-	j_oTag: new TokContext$1("<tag"),
-	j_cTag: new TokContext$1("</tag"),
-	j_expr: new TokContext$1("<tag>...</tag>", true)
+const types = {
+	brace: new TokContext("{"),
+	j_oTag: new TokContext("<tag"),
+	j_cTag: new TokContext("</tag"),
+	j_expr: new TokContext("<tag>...</tag>", true)
 };
 const nonASCIIidentifierStart = /* @__PURE__ */ new RegExp("[ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙՠ-ֈא-תׯ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࡠ-ࡪࡰ-ࢇࢉ-࢏ࢠ-ࣉऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱৼਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚ౜ౝౠౡಀಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ೜-ೞೠೡೱೲഄ-ഌഎ-ഐഒ-ഺഽൎൔ-ൖൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄຆ-ຊຌ-ຣລວ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜑᜟ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡸᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭌᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᲀ-ᲊᲐ-ᲺᲽ-Ჿᳩ-ᳬᳮ-ᳳᳵᳶᳺᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄯㄱ-ㆎㆠ-ㆿㇰ-ㇿ㐀-䶿一-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-Ƛ꟱-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꣾꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭩꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ]");
 const nonASCIIidentifier = /* @__PURE__ */ new RegExp("[ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙՠ-ֈא-תׯ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࡠ-ࡪࡰ-ࢇࢉ-࢏ࢠ-ࣉऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱৼਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚ౜ౝౠౡಀಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ೜-ೞೠೡೱೲഄ-ഌഎ-ഐഒ-ഺഽൎൔ-ൖൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄຆ-ຊຌ-ຣລວ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜑᜟ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡸᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭌᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᲀ-ᲊᲐ-ᲺᲽ-Ჿᳩ-ᳬᳮ-ᳳᳵᳶᳺᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄯㄱ-ㆎㆠ-ㆿㇰ-ㇿ㐀-䶿一-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-Ƛ꟱-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꣾꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭩꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-٩ٰۖ-ۜ۟-۪ۤۧۨ-ۭ۰-۹ܑܰ-݊ަ-ް߀-߉߫-߽߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛ࢗ-࢟࣊-ࣣ࣡-ःऺ-़ा-ॏ॑-ॗॢॣ०-९ঁ-ঃ়া-ৄেৈো-্ৗৢৣ০-৯৾ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑ੦-ੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣ૦-૯ૺ-૿ଁ-ଃ଼ା-ୄେୈୋ-୍୕-ୗୢୣ୦-୯ஂா-ூெ-ைொ-்ௗ௦-௯ఀ-ఄ఼ా-ౄె-ైొ-్ౕౖౢౣ౦-౯ಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣ೦-೯ೳഀ-ഃ഻഼ാ-ൄെ-ൈൊ-്ൗൢൣ൦-൯ඁ-ඃ්ා-ුූෘ-ෟ෦-෯ෲෳัิ-ฺ็-๎๐-๙ັິ-ຼ່-໎໐-໙༘༙༠-༩༹༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှ၀-၉ၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏ-ႝ፝-፟፩-፱ᜒ-᜕ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝០-៩᠋-᠍᠏-᠙ᢩᤠ-ᤫᤰ-᤻᥆-᥏᧐-᧚ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼-᪉᪐-᪙᪰-᪽ᪿ-᫝᫠-᫫ᬀ-ᬄ᬴-᭄᭐-᭙᭫-᭳ᮀ-ᮂᮡ-ᮭ᮰-᮹᯦-᯳ᰤ-᰷᱀-᱉᱐-᱙᳐-᳔᳒-᳨᳭᳴᳷-᳹᷀-᷿‌‍‿⁀⁔⃐-⃥⃜⃡-⃰⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯・꘠-꘩꙯ꙴ-꙽ꚞꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧ꠬ꢀꢁꢴ-ꣅ꣐-꣙꣠-꣱ꣿ-꤉ꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀꧐-꧙ꧥ꧰-꧹ꨩ-ꨶꩃꩌꩍ꩐-꩙ꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭꯰-꯹ﬞ︀-️︠-︯︳︴﹍-﹏０-９＿･]");
@@ -19854,7 +19865,7 @@ function isIdentifierChar(code) {
 	if (code <= 65535) return code >= 170 && nonASCIIidentifier.test(String.fromCharCode(code));
 	return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
 }
-const reservedWords$1 = {
+const reservedWords = {
 	keyword: [
 		"break",
 		"case",
@@ -19905,23 +19916,23 @@ const reservedWords$1 = {
 	],
 	strictBind: ["eval", "arguments"]
 };
-const keywords$2 = new Set(reservedWords$1.keyword);
-const reservedWordsStrictSet$1 = new Set(reservedWords$1.strict);
-const reservedWordsStrictBindSet$1 = new Set(reservedWords$1.strictBind);
+const keywords = new Set(reservedWords.keyword);
+const reservedWordsStrictSet = new Set(reservedWords.strict);
+const reservedWordsStrictBindSet = new Set(reservedWords.strictBind);
 function isReservedWord(word, inModule) {
 	return inModule && word === "await" || word === "enum";
 }
 function isStrictReservedWord(word, inModule) {
-	return isReservedWord(word, inModule) || reservedWordsStrictSet$1.has(word);
+	return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
 }
 function isStrictBindOnlyReservedWord(word) {
-	return reservedWordsStrictBindSet$1.has(word);
+	return reservedWordsStrictBindSet.has(word);
 }
 function isStrictBindReservedWord(word, inModule) {
 	return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
 }
 function isKeyword(word) {
-	return keywords$2.has(word);
+	return keywords.has(word);
 }
 function isIteratorStart(current, next, next2) {
 	return current === 64 && next === 64 && isIdentifierStart(next2);
@@ -20071,7 +20082,7 @@ var ScopeHandler = class {
 		if (this.parser.inModule && scope.flags & 1) this.undefinedExports.delete(name);
 	}
 	checkRedeclarationInScope(scope, name, bindingType, loc) {
-		if (this.isRedeclaredInScope(scope, name, bindingType)) this.parser.raise(Errors$1.VarRedeclaration, loc, { identifierName: name });
+		if (this.isRedeclaredInScope(scope, name, bindingType)) this.parser.raise(Errors.VarRedeclaration, loc, { identifierName: name });
 	}
 	isRedeclaredInScope(scope, name, bindingType) {
 		if (!(bindingType & 1)) return false;
@@ -20147,7 +20158,7 @@ const reservedTypes = new Set([
 	"typeof",
 	"void"
 ]);
-const FlowErrors$1 = ParseErrorEnum$1`flow`({
+const FlowErrors = ParseErrorEnum`flow`({
 	AmbiguousConditionalArrow: "Ambiguous expression: wrap the arrow functions in parentheses to disambiguate.",
 	AmbiguousDeclareModuleKind: "Found both `declare module.exports` and `declare export` in the same module. Modules can only have 1 since they are either an ES module or they are a CommonJS module.",
 	AssignReservedType: ({ reservedType }) => `Cannot overwrite reserved type ${reservedType}.`,
@@ -20252,7 +20263,7 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 		const moduloLoc = this.state.startLoc;
 		this.next();
 		this.expectContextual(106);
-		if (this.state.lastTokStartLoc.index > moduloLoc.index + 1) this.raise(FlowErrors$1.UnexpectedSpaceBetweenModuloChecks, moduloLoc);
+		if (this.state.lastTokStartLoc.index > moduloLoc.index + 1) this.raise(FlowErrors.UnexpectedSpaceBetweenModuloChecks, moduloLoc);
 		if (this.eat(6)) {
 			node.value = super.parseExpression();
 			this.expect(7);
@@ -20307,7 +20318,7 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 		else if (this.match(70)) return this.flowParseDeclareVariable(node);
 		else if (this.eatContextual(123)) if (this.match(12)) return this.flowParseDeclareModuleExports(node);
 		else {
-			if (insideModule) this.raise(FlowErrors$1.NestedDeclareModule, this.state.lastTokStartLoc);
+			if (insideModule) this.raise(FlowErrors.NestedDeclareModule, this.state.lastTokStartLoc);
 			return this.flowParseDeclareModule(node);
 		}
 		else if (this.isContextual(126)) return this.flowParseDeclareTypeAlias(node);
@@ -20334,10 +20345,10 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 			const bodyNode = this.startNode();
 			if (this.match(79)) {
 				this.next();
-				if (!this.isContextual(126) && !this.match(83)) this.raise(FlowErrors$1.InvalidNonTypeImportInDeclareModule, this.state.lastTokStartLoc);
+				if (!this.isContextual(126) && !this.match(83)) this.raise(FlowErrors.InvalidNonTypeImportInDeclareModule, this.state.lastTokStartLoc);
 				body.push(super.parseImport(bodyNode));
 			} else {
-				this.expectContextual(121, FlowErrors$1.UnsupportedStatementInDeclareModule);
+				this.expectContextual(121, FlowErrors.UnsupportedStatementInDeclareModule);
 				body.push(this.flowParseDeclare(bodyNode, true));
 			}
 		}
@@ -20348,11 +20359,11 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 		let hasModuleExport = false;
 		body.forEach((bodyElement) => {
 			if (isEsModuleType(bodyElement)) {
-				if (kind === "CommonJS") this.raise(FlowErrors$1.AmbiguousDeclareModuleKind, bodyElement);
+				if (kind === "CommonJS") this.raise(FlowErrors.AmbiguousDeclareModuleKind, bodyElement);
 				kind = "ES";
 			} else if (bodyElement.type === "DeclareModuleExports") {
-				if (hasModuleExport) this.raise(FlowErrors$1.DuplicateDeclareModuleExports, bodyElement);
-				if (kind === "ES") this.raise(FlowErrors$1.AmbiguousDeclareModuleKind, bodyElement);
+				if (hasModuleExport) this.raise(FlowErrors.DuplicateDeclareModuleExports, bodyElement);
+				if (kind === "ES") this.raise(FlowErrors.AmbiguousDeclareModuleKind, bodyElement);
 				kind = "CommonJS";
 				hasModuleExport = true;
 			}
@@ -20373,7 +20384,7 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 		} else {
 			if (this.match(71) || this.isLet() || (this.isContextual(126) || this.isContextual(125)) && !insideModule) {
 				const label = this.state.value;
-				throw this.raise(FlowErrors$1.UnsupportedDeclareExportKind, this.state.startLoc, {
+				throw this.raise(FlowErrors.UnsupportedDeclareExportKind, this.state.startLoc, {
 					unsupportedExportKind: label,
 					suggestion: exportSuggestions[label]
 				});
@@ -20456,11 +20467,11 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 		return this.finishNode(node, "InterfaceDeclaration");
 	}
 	checkNotUnderscore(word) {
-		if (word === "_") this.raise(FlowErrors$1.UnexpectedReservedUnderscore, this.state.startLoc);
+		if (word === "_") this.raise(FlowErrors.UnexpectedReservedUnderscore, this.state.startLoc);
 	}
 	checkReservedType(word, startLoc, declaration) {
 		if (!reservedTypes.has(word)) return;
-		this.raise(declaration ? FlowErrors$1.AssignReservedType : FlowErrors$1.UnexpectedReservedType, startLoc, { reservedType: word });
+		this.raise(declaration ? FlowErrors.AssignReservedType : FlowErrors.UnexpectedReservedType, startLoc, { reservedType: word });
 	}
 	flowParseRestrictedIdentifierName(liberal, declaration) {
 		this.checkReservedType(this.state.value, this.state.startLoc, declaration);
@@ -20511,7 +20522,7 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 		if (this.match(25)) {
 			this.eat(25);
 			node.default = this.flowParseType();
-		} else if (requireDefault) this.raise(FlowErrors$1.MissingTypeParamDefault, nodeStartLoc);
+		} else if (requireDefault) this.raise(FlowErrors.MissingTypeParamDefault, nodeStartLoc);
 		return this.finishNode(node, "TypeParameter");
 	}
 	flowParseTypeParameterDeclaration() {
@@ -20533,7 +20544,7 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 		return this.finishNode(node, "TypeParameterDeclaration");
 	}
 	flowInTopLevelContext(cb) {
-		if (this.curContext() !== types$1.brace) {
+		if (this.curContext() !== types.brace) {
 			const oldContext = this.state.context;
 			this.state.context = [oldContext[0]];
 			try {
@@ -20563,7 +20574,7 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 			this.state.noAnonFunctionType = oldNoAnonFunctionType;
 		});
 		this.state.inType = oldInType;
-		if (!this.state.inType && this.curContext() === types$1.brace) this.reScan_lt_gt();
+		if (!this.state.inType && this.curContext() === types.brace) this.reScan_lt_gt();
 		this.expect(44);
 		return this.finishNode(node, "TypeParameterInstantiation");
 	}
@@ -20725,7 +20736,7 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 				} else nodeStart.properties.push(propOrInexact);
 			}
 			this.flowObjectTypeSemicolon();
-			if (inexactStartLoc && !this.match(4) && !this.match(5)) this.raise(FlowErrors$1.UnexpectedExplicitInexactInObject, inexactStartLoc);
+			if (inexactStartLoc && !this.match(4) && !this.match(5)) this.raise(FlowErrors.UnexpectedExplicitInexactInObject, inexactStartLoc);
 		}
 		this.expect(endDelim);
 		if (allowSpread) nodeStart.inexact = inexact;
@@ -20736,14 +20747,14 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 	flowParseObjectTypeProperty(node, isStatic, protoStartLoc, variance, kind, allowSpread, allowInexact) {
 		if (this.eat(17)) {
 			if (this.match(8) || this.match(9) || this.match(4) || this.match(5)) {
-				if (!allowSpread) this.raise(FlowErrors$1.InexactInsideNonObject, this.state.lastTokStartLoc);
-				else if (!allowInexact) this.raise(FlowErrors$1.InexactInsideExact, this.state.lastTokStartLoc);
-				if (variance) this.raise(FlowErrors$1.InexactVariance, variance);
+				if (!allowSpread) this.raise(FlowErrors.InexactInsideNonObject, this.state.lastTokStartLoc);
+				else if (!allowInexact) this.raise(FlowErrors.InexactInsideExact, this.state.lastTokStartLoc);
+				if (variance) this.raise(FlowErrors.InexactVariance, variance);
 				return null;
 			}
-			if (!allowSpread) this.raise(FlowErrors$1.UnexpectedSpreadType, this.state.lastTokStartLoc);
+			if (!allowSpread) this.raise(FlowErrors.UnexpectedSpreadType, this.state.lastTokStartLoc);
 			if (protoStartLoc != null) this.unexpected(protoStartLoc);
-			if (variance) this.raise(FlowErrors$1.SpreadVariance, variance);
+			if (variance) this.raise(FlowErrors.SpreadVariance, variance);
 			node.argument = this.flowParseType();
 			return this.finishNode(node, "ObjectTypeSpreadProperty");
 		} else {
@@ -20758,7 +20769,7 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 				if (variance) this.unexpected(variance.start);
 				node.value = this.flowParseObjectTypeMethodish(this.startNodeAtNode(node));
 				if (kind === "get" || kind === "set") this.flowCheckGetterSetterParams(node);
-				else if (!isStatic && !allowSpread && node.key.name === "constructor" && node.value.this) this.raise(FlowErrors$1.ThisParamBannedInConstructor, node.value.this);
+				else if (!isStatic && !allowSpread && node.key.name === "constructor" && node.value.this) this.raise(FlowErrors.ThisParamBannedInConstructor, node.value.this);
 			} else {
 				if (kind !== "init") this.unexpected();
 				node.method = false;
@@ -20774,9 +20785,9 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 		const paramCount = property.kind === "get" ? 0 : 1;
 		const value = property.value;
 		const length = value.params.length + (value.rest ? 1 : 0);
-		if (value.this) this.raise(property.kind === "get" ? FlowErrors$1.GetterMayNotHaveThisParam : FlowErrors$1.SetterMayNotHaveThisParam, value.this);
-		if (length !== paramCount) this.raise(property.kind === "get" ? Errors$1.BadGetterArity : Errors$1.BadSetterArity, property);
-		if (property.kind === "set" && value.rest) this.raise(Errors$1.BadSetterRestParameter, property);
+		if (value.this) this.raise(property.kind === "get" ? FlowErrors.GetterMayNotHaveThisParam : FlowErrors.SetterMayNotHaveThisParam, value.this);
+		if (length !== paramCount) this.raise(property.kind === "get" ? Errors.BadGetterArity : Errors.BadSetterArity, property);
+		if (property.kind === "set" && value.rest) this.raise(Errors.BadSetterRestParameter, property);
 	}
 	flowObjectTypeSemicolon() {
 		if (!this.eat(9) && !this.eat(8) && !this.match(4) && !this.match(5)) this.unexpected();
@@ -20825,11 +20836,11 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 		const lh = this.lookahead();
 		const isThis = this.state.type === 74;
 		if (lh.type === 10 || lh.type === 13) {
-			if (isThis && !first) this.raise(FlowErrors$1.ThisParamMustBeFirst, node);
+			if (isThis && !first) this.raise(FlowErrors.ThisParamMustBeFirst, node);
 			name = this.parseIdentifier(isThis);
 			if (this.eat(13)) {
 				optional = true;
-				if (isThis) this.raise(FlowErrors$1.ThisParamMayNotBeOptional, node);
+				if (isThis) this.raise(FlowErrors.ThisParamMayNotBeOptional, node);
 			}
 			typeAnnotation = this.flowParseTypeInitialiser();
 		} else typeAnnotation = this.flowParseType();
@@ -20957,7 +20968,7 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 					this.next();
 					if (this.match(131)) return this.parseLiteralAtNode(-this.state.value, "NumberLiteralTypeAnnotation", node);
 					if (this.match(132)) return this.parseLiteralAtNode(-this.state.value, "BigIntLiteralTypeAnnotation", node);
-					throw this.raise(FlowErrors$1.UnexpectedSubtractionOperand, this.state.startLoc);
+					throw this.raise(FlowErrors.UnexpectedSubtractionOperand, this.state.startLoc);
 				}
 				throw this.unexpected();
 			case 131: return this.parseLiteral(this.state.value, "NumberLiteralTypeAnnotation");
@@ -21176,7 +21187,7 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 				({consequent, failed} = this.tryParseConditionalConsequent());
 				[valid] = this.getArrowLikeExpressions(consequent);
 			}
-			if (failed && valid.length > 1) this.raise(FlowErrors$1.AmbiguousConditionalArrow, state.startLoc);
+			if (failed && valid.length > 1) this.raise(FlowErrors.AmbiguousConditionalArrow, state.startLoc);
 			if (failed && valid.length === 1) {
 				this.state = state;
 				noArrowAt.push(valid[0].start);
@@ -21314,8 +21325,8 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 		}
 		super.parseClassMember(classBody, member, state);
 		if (member.declare) {
-			if (member.type !== "ClassProperty" && member.type !== "ClassPrivateProperty" && member.type !== "PropertyDefinition") this.raise(FlowErrors$1.DeclareClassElement, startLoc);
-			else if (member.value) this.raise(FlowErrors$1.DeclareClassFieldInitializer, member.value);
+			if (member.type !== "ClassProperty" && member.type !== "ClassPrivateProperty" && member.type !== "PropertyDefinition") this.raise(FlowErrors.DeclareClassElement, startLoc);
+			else if (member.value) this.raise(FlowErrors.DeclareClassFieldInitializer, member.value);
 		}
 	}
 	isIterator(word) {
@@ -21324,7 +21335,7 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 	readIterator() {
 		const word = super.readWord1();
 		const fullWord = "@@" + word;
-		if (!this.isIterator(word) || !this.state.inType) this.raise(Errors$1.InvalidIdentifier, this.state.curPosition(), { identifierName: fullWord });
+		if (!this.isIterator(word) || !this.state.inType) this.raise(Errors.InvalidIdentifier, this.state.curPosition(), { identifierName: fullWord });
 		this.finishToken(128, fullWord);
 	}
 	getTokenFromCode(code) {
@@ -21354,7 +21365,7 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 	toReferencedList(exprList, isParenthesizedExpr) {
 		for (let i = 0; i < exprList.length; i++) {
 			const expr = exprList[i];
-			if (expr?.type === "TypeCastExpression" && !expr.extra?.parenthesized && (exprList.length > 1 || !isParenthesizedExpr)) this.raise(FlowErrors$1.TypeCastInPattern, expr.typeAnnotation);
+			if (expr?.type === "TypeCastExpression" && !expr.extra?.parenthesized && (exprList.length > 1 || !isParenthesizedExpr)) this.raise(FlowErrors.TypeCastInPattern, expr.typeAnnotation);
 		}
 		return exprList;
 	}
@@ -21390,10 +21401,10 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 		super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);
 		if (method.params && isConstructor) {
 			const params = method.params;
-			if (params.length > 0 && this.isThisParam(params[0])) this.raise(FlowErrors$1.ThisParamBannedInConstructor, method);
+			if (params.length > 0 && this.isThisParam(params[0])) this.raise(FlowErrors.ThisParamBannedInConstructor, method);
 		} else if (method.type === "MethodDefinition" && isConstructor && method.value.params) {
 			const params = method.value.params;
-			if (params.length > 0 && this.isThisParam(params[0])) this.raise(FlowErrors$1.ThisParamBannedInConstructor, method);
+			if (params.length > 0 && this.isThisParam(params[0])) this.raise(FlowErrors.ThisParamBannedInConstructor, method);
 		}
 	}
 	pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {
@@ -21424,8 +21435,8 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 		const params = this.getObjectOrClassMethodParams(method);
 		if (params.length > 0) {
 			const param = params[0];
-			if (this.isThisParam(param) && method.kind === "get") this.raise(FlowErrors$1.GetterMayNotHaveThisParam, param);
-			else if (this.isThisParam(param)) this.raise(FlowErrors$1.SetterMayNotHaveThisParam, param);
+			if (this.isThisParam(param) && method.kind === "get") this.raise(FlowErrors.GetterMayNotHaveThisParam, param);
+			else if (this.isThisParam(param)) this.raise(FlowErrors.SetterMayNotHaveThisParam, param);
 		}
 	}
 	parsePropertyNamePrefixOperator(node) {
@@ -21445,19 +21456,19 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 	}
 	parseFunctionParamType(param) {
 		if (this.eat(13)) {
-			if (param.type !== "Identifier") this.raise(FlowErrors$1.PatternIsOptional, param);
-			if (this.isThisParam(param)) this.raise(FlowErrors$1.ThisParamMayNotBeOptional, param);
+			if (param.type !== "Identifier") this.raise(FlowErrors.PatternIsOptional, param);
+			if (this.isThisParam(param)) this.raise(FlowErrors.ThisParamMayNotBeOptional, param);
 			param.optional = true;
 		}
 		if (this.match(10)) param.typeAnnotation = this.flowParseTypeAnnotation();
-		else if (this.isThisParam(param)) this.raise(FlowErrors$1.ThisParamAnnotationRequired, param);
-		if (this.match(25) && this.isThisParam(param)) this.raise(FlowErrors$1.ThisParamNoDefault, param);
+		else if (this.isThisParam(param)) this.raise(FlowErrors.ThisParamAnnotationRequired, param);
+		if (this.match(25) && this.isThisParam(param)) this.raise(FlowErrors.ThisParamNoDefault, param);
 		this.resetEndLocation(param);
 		return param;
 	}
 	parseMaybeDefault(startLoc, left) {
 		const node = super.parseMaybeDefault(startLoc, left);
-		if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) this.raise(FlowErrors$1.TypeBeforeInitializer, node.typeAnnotation);
+		if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) this.raise(FlowErrors.TypeBeforeInitializer, node.typeAnnotation);
 		return node;
 	}
 	parseImportSpecifierLocal(node, specifier, type) {
@@ -21507,7 +21518,7 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 				specifier.imported = this.parseIdentifier(true);
 				specifier.importKind = specifierTypeKind;
 			} else {
-				if (importedIsString) throw this.raise(Errors$1.ImportBindingIsString, specifier, { importName: firstIdent.value });
+				if (importedIsString) throw this.raise(Errors.ImportBindingIsString, specifier, { importName: firstIdent.value });
 				specifier.imported = firstIdent;
 				specifier.importKind = null;
 			}
@@ -21518,7 +21529,7 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 			}
 		}
 		const specifierIsTypeImport = hasTypeImportKind(specifier);
-		if (isInTypeOnlyImport && specifierIsTypeImport) this.raise(FlowErrors$1.ImportTypeShorthandOnlyInPureImport, specifier);
+		if (isInTypeOnlyImport && specifierIsTypeImport) this.raise(FlowErrors.ImportTypeShorthandOnlyInPureImport, specifier);
 		if (isInTypeOnlyImport || specifierIsTypeImport) this.checkReservedType(specifier.local.name, specifier.local.start, true);
 		if (isBinding && !isInTypeOnlyImport && !specifierIsTypeImport) this.checkReservedWord(specifier.local.name, specifier.start, true, true);
 		return this.finishImportSpecifier(specifier, "ImportSpecifier");
@@ -21562,7 +21573,7 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 			if (!jsx.error) return jsx.node;
 			const { context } = this.state;
 			const currentContext = context[context.length - 1];
-			if (currentContext === types$1.j_oTag || currentContext === types$1.j_expr) context.pop();
+			if (currentContext === types.j_oTag || currentContext === types.j_expr) context.pop();
 		}
 		if (jsx?.error || this.match(43)) {
 			state = state || this.state.clone();
@@ -21584,7 +21595,7 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 			let arrowExpression = null;
 			if (arrow.node && this.maybeUnwrapTypeCastExpression(arrow.node).type === "ArrowFunctionExpression") {
 				if (!arrow.error && !arrow.aborted) {
-					if (arrow.node.async) this.raise(FlowErrors$1.UnexpectedTypeParameterBeforeAsyncArrowFunction, typeParameters);
+					if (arrow.node.async) this.raise(FlowErrors.UnexpectedTypeParameterBeforeAsyncArrowFunction, typeParameters);
 					return arrow.node;
 				}
 				arrowExpression = arrow.node;
@@ -21599,7 +21610,7 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 			}
 			if (jsx?.thrown) throw jsx.error;
 			if (arrow.thrown) throw arrow.error;
-			throw this.raise(FlowErrors$1.UnexpectedTokenAfterTypeParameter, typeParameters);
+			throw this.raise(FlowErrors.UnexpectedTokenAfterTypeParameter, typeParameters);
 		}
 		return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
 	}
@@ -21630,7 +21641,7 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 	}
 	checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged = true) {
 		if (isArrowFunction && this.state.noArrowParamsConversionAt.includes(this.offsetToSourcePos(node.start))) return;
-		for (let i = 0; i < node.params.length; i++) if (this.isThisParam(node.params[i]) && i > 0) this.raise(FlowErrors$1.ThisParamMustBeFirst, node.params[i]);
+		for (let i = 0; i < node.params.length; i++) if (this.isThisParam(node.params[i]) && i > 0) this.raise(FlowErrors.ThisParamMustBeFirst, node.params[i]);
 		super.checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged);
 	}
 	parseParenAndDistinguishExpression(canStartArrow) {
@@ -21725,12 +21736,12 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 	}
 	parseTopLevel(file, program) {
 		const fileNode = super.parseTopLevel(file, program);
-		if (this.state.hasFlowComment) this.raise(FlowErrors$1.UnterminatedFlowComment, this.state.curPosition());
+		if (this.state.hasFlowComment) this.raise(FlowErrors.UnterminatedFlowComment, this.state.curPosition());
 		return fileNode;
 	}
 	skipBlockComment() {
 		if (this.hasPlugin("flowComments") && this.skipFlowComment()) {
-			if (this.state.hasFlowComment) throw this.raise(FlowErrors$1.NestedFlowComment, this.state.startLoc);
+			if (this.state.hasFlowComment) throw this.raise(FlowErrors.NestedFlowComment, this.state.startLoc);
 			this.hasFlowCommentCompletion();
 			const commentSkip = this.skipFlowComment();
 			if (commentSkip) {
@@ -21753,19 +21764,19 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 		return false;
 	}
 	hasFlowCommentCompletion() {
-		if (this.input.indexOf("*/", this.state.pos) === -1) throw this.raise(Errors$1.UnterminatedComment, this.state.curPosition());
+		if (this.input.indexOf("*/", this.state.pos) === -1) throw this.raise(Errors.UnterminatedComment, this.state.curPosition());
 	}
 	flowEnumErrorBooleanMemberNotInitialized(loc, names) {
-		this.raise(FlowErrors$1.EnumBooleanMemberNotInitialized, loc, names);
+		this.raise(FlowErrors.EnumBooleanMemberNotInitialized, loc, names);
 	}
 	flowEnumErrorInvalidMemberInitializer(loc, enumContext) {
-		return this.raise(!enumContext.explicitType ? FlowErrors$1.EnumInvalidMemberInitializerUnknownType : enumContext.explicitType === "symbol" ? FlowErrors$1.EnumInvalidMemberInitializerSymbolType : FlowErrors$1.EnumInvalidMemberInitializerPrimaryType, loc, enumContext);
+		return this.raise(!enumContext.explicitType ? FlowErrors.EnumInvalidMemberInitializerUnknownType : enumContext.explicitType === "symbol" ? FlowErrors.EnumInvalidMemberInitializerSymbolType : FlowErrors.EnumInvalidMemberInitializerPrimaryType, loc, enumContext);
 	}
 	flowEnumErrorNumberMemberNotInitialized(loc, details) {
-		this.raise(FlowErrors$1.EnumNumberMemberNotInitialized, loc, details);
+		this.raise(FlowErrors.EnumNumberMemberNotInitialized, loc, details);
 	}
 	flowEnumErrorStringMemberInconsistentlyInitialized(node, details) {
-		this.raise(FlowErrors$1.EnumStringMemberInconsistentlyInitialized, node, details);
+		this.raise(FlowErrors.EnumStringMemberInconsistentlyInitialized, node, details);
 	}
 	flowEnumMemberInit() {
 		const startLoc = this.state.startLoc;
@@ -21837,12 +21848,12 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 			const { id, init } = this.flowEnumMemberRaw();
 			const memberName = id.name;
 			if (memberName === "") continue;
-			if (/^[a-z]/.test(memberName)) this.raise(FlowErrors$1.EnumInvalidMemberName, id, {
+			if (/^[a-z]/.test(memberName)) this.raise(FlowErrors.EnumInvalidMemberName, id, {
 				memberName,
 				suggestion: memberName[0].toUpperCase() + memberName.slice(1),
 				enumName
 			});
-			if (seenNames.has(memberName)) this.raise(FlowErrors$1.EnumDuplicateMemberName, id, {
+			if (seenNames.has(memberName)) this.raise(FlowErrors.EnumDuplicateMemberName, id, {
 				memberName,
 				enumName
 			});
@@ -21900,10 +21911,10 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 	}
 	flowEnumParseExplicitType({ enumName }) {
 		if (!this.eatContextual(98)) return null;
-		if (!tokenIsIdentifier(this.state.type)) throw this.raise(FlowErrors$1.EnumInvalidExplicitTypeUnknownSupplied, this.state.startLoc, { enumName });
+		if (!tokenIsIdentifier(this.state.type)) throw this.raise(FlowErrors.EnumInvalidExplicitTypeUnknownSupplied, this.state.startLoc, { enumName });
 		const { value } = this.state;
 		this.next();
-		if (value !== "boolean" && value !== "number" && value !== "string" && value !== "symbol") this.raise(FlowErrors$1.EnumInvalidExplicitType, this.state.startLoc, {
+		if (value !== "boolean" && value !== "number" && value !== "string" && value !== "symbol") this.raise(FlowErrors.EnumInvalidExplicitType, this.state.startLoc, {
 			enumName,
 			invalidEnumType: value
 		});
@@ -21972,7 +21983,7 @@ const flow = (superClass) => class FlowParserMixin extends superClass {
 					this.expect(4);
 					return this.finishNode(node, "EnumNumberBody");
 				} else {
-					this.raise(FlowErrors$1.EnumInconsistentMemberValues, nameLoc, { enumName });
+					this.raise(FlowErrors.EnumInconsistentMemberValues, nameLoc, { enumName });
 					return empty();
 				}
 			}
@@ -22277,7 +22288,7 @@ const entities = {
 	hearts: "♥",
 	diams: "♦"
 };
-const lineBreakG$1 = new RegExp(/\r\n|[\r\n\u2028\u2029]/.source, "g");
+const lineBreakG = new RegExp(/\r\n|[\r\n\u2028\u2029]/.source, "g");
 function isNewLine(code) {
 	switch (code) {
 		case 10:
@@ -22319,7 +22330,7 @@ function isWhitespace(code) {
 		default: return false;
 	}
 }
-const JsxErrors$1 = ParseErrorEnum$1`jsx`({
+const JsxErrors = ParseErrorEnum`jsx`({
 	AttributeIsEmpty: "JSX attributes must only be assigned a non-empty expression.",
 	MissingClosingTagElement: ({ openingTagName }) => `Expected corresponding JSX closing tag for <${openingTagName}>.`,
 	MissingClosingTagFragment: "Expected corresponding JSX closing tag for <>.",
@@ -22343,7 +22354,7 @@ const jsx = (superClass) => class JSXParserMixin extends superClass {
 		let out = "";
 		let chunkStart = this.state.pos;
 		for (;;) {
-			if (this.state.pos >= this.length) throw this.raise(JsxErrors$1.UnterminatedJsxContent, this.state.startLoc);
+			if (this.state.pos >= this.length) throw this.raise(JsxErrors.UnterminatedJsxContent, this.state.startLoc);
 			const ch = this.input.charCodeAt(this.state.pos);
 			switch (ch) {
 				case 60:
@@ -22364,7 +22375,7 @@ const jsx = (superClass) => class JSXParserMixin extends superClass {
 					chunkStart = this.state.pos;
 					break;
 				case 62:
-				case 125: this.raise(JsxErrors$1.UnexpectedToken, this.state.curPosition(), {
+				case 125: this.raise(JsxErrors.UnexpectedToken, this.state.curPosition(), {
 					unexpected: this.input[this.state.pos],
 					HTMLEntity: ch === 125 ? "&rbrace;" : "&gt;"
 				});
@@ -22392,7 +22403,7 @@ const jsx = (superClass) => class JSXParserMixin extends superClass {
 		let out = "";
 		let chunkStart = ++this.state.pos;
 		for (;;) {
-			if (this.state.pos >= this.length) throw this.raise(Errors$1.UnterminatedString, this.state.startLoc);
+			if (this.state.pos >= this.length) throw this.raise(Errors.UnterminatedString, this.state.startLoc);
 			const ch = this.input.charCodeAt(this.state.pos);
 			if (ch === quote) break;
 			if (ch === 38) {
@@ -22477,14 +22488,14 @@ const jsx = (superClass) => class JSXParserMixin extends superClass {
 		switch (this.state.type) {
 			case 2:
 				node = this.startNode();
-				this.setContext(types$1.brace);
+				this.setContext(types.brace);
 				this.next();
-				node = this.jsxParseExpressionContainer(node, types$1.j_oTag);
-				if (node.expression.type === "JSXEmptyExpression") this.raise(JsxErrors$1.AttributeIsEmpty, node);
+				node = this.jsxParseExpressionContainer(node, types.j_oTag);
+				if (node.expression.type === "JSXEmptyExpression") this.raise(JsxErrors.AttributeIsEmpty, node);
 				return node;
 			case 138:
 			case 130: return this.parseExprAtom();
-			default: throw this.raise(JsxErrors$1.UnsupportedJsxValue, this.state.startLoc);
+			default: throw this.raise(JsxErrors.UnsupportedJsxValue, this.state.startLoc);
 		}
 	}
 	jsxParseEmptyExpression() {
@@ -22494,7 +22505,7 @@ const jsx = (superClass) => class JSXParserMixin extends superClass {
 	jsxParseSpreadChild(node) {
 		this.next();
 		node.expression = this.parseExpression();
-		this.setContext(types$1.j_expr);
+		this.setContext(types.j_expr);
 		this.state.canStartJSXElement = true;
 		this.expect(4);
 		return this.finishNode(node, "JSXSpreadChild");
@@ -22503,7 +22514,7 @@ const jsx = (superClass) => class JSXParserMixin extends superClass {
 		if (this.match(4)) node.expression = this.jsxParseEmptyExpression();
 		else {
 			const expression = this.parseExpression();
-			if (expression.type === "SequenceExpression" && !expression.extra?.parenthesized) this.raise(JsxErrors$1.UnexpectedSequenceExpression, expression.expressions[1]);
+			if (expression.type === "SequenceExpression" && !expression.extra?.parenthesized) this.raise(JsxErrors.UnexpectedSequenceExpression, expression.expressions[1]);
 			node.expression = expression;
 		}
 		this.setContext(previousContext);
@@ -22514,11 +22525,11 @@ const jsx = (superClass) => class JSXParserMixin extends superClass {
 	jsxParseAttribute() {
 		if (this.match(2)) {
 			const node = this.startNode();
-			this.setContext(types$1.brace);
+			this.setContext(types.brace);
 			this.next();
 			this.expect(17);
 			node.argument = this.parseMaybeAssignAllowIn();
-			this.setContext(types$1.j_oTag);
+			this.setContext(types.j_oTag);
 			this.state.canStartJSXElement = true;
 			this.expect(4);
 			return this.finishNode(node, "JSXSpreadAttribute");
@@ -22577,18 +22588,18 @@ const jsx = (superClass) => class JSXParserMixin extends superClass {
 					break;
 				case 2: {
 					const node = this.startNode();
-					this.setContext(types$1.brace);
+					this.setContext(types.brace);
 					this.next();
 					if (this.match(17)) children.push(this.jsxParseSpreadChild(node));
-					else children.push(this.jsxParseExpressionContainer(node, types$1.j_expr));
+					else children.push(this.jsxParseExpressionContainer(node, types.j_expr));
 					break;
 				}
 				default: this.unexpected();
 			}
-			if (isFragment(openingElement) && !isFragment(closingElement) && closingElement !== null) this.raise(JsxErrors$1.MissingClosingTagFragment, closingElement);
-			else if (!isFragment(openingElement) && isFragment(closingElement)) this.raise(JsxErrors$1.MissingClosingTagElement, closingElement, { openingTagName: getQualifiedJSXName(openingElement.name) });
+			if (isFragment(openingElement) && !isFragment(closingElement) && closingElement !== null) this.raise(JsxErrors.MissingClosingTagFragment, closingElement);
+			else if (!isFragment(openingElement) && isFragment(closingElement)) this.raise(JsxErrors.MissingClosingTagElement, closingElement, { openingTagName: getQualifiedJSXName(openingElement.name) });
 			else if (!isFragment(openingElement) && !isFragment(closingElement)) {
-				if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name)) this.raise(JsxErrors$1.MissingClosingTagElement, closingElement, { openingTagName: getQualifiedJSXName(openingElement.name) });
+				if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name)) this.raise(JsxErrors.MissingClosingTagElement, closingElement, { openingTagName: getQualifiedJSXName(openingElement.name) });
 			}
 		}
 		if (isFragment(openingElement)) {
@@ -22599,7 +22610,7 @@ const jsx = (superClass) => class JSXParserMixin extends superClass {
 			node.closingElement = closingElement;
 		}
 		node.children = children;
-		if (this.match(43)) throw this.raise(JsxErrors$1.UnwrappedAdjacentJSXElements, this.state.startLoc);
+		if (this.match(43)) throw this.raise(JsxErrors.UnwrappedAdjacentJSXElements, this.state.startLoc);
 		return isFragment(openingElement) ? this.finishNode(node, "JSXFragment") : this.finishNode(node, "JSXElement");
 	}
 	jsxParseElement() {
@@ -22623,11 +22634,11 @@ const jsx = (superClass) => class JSXParserMixin extends superClass {
 	}
 	getTokenFromCode(code) {
 		const context = this.curContext();
-		if (context === types$1.j_expr) {
+		if (context === types.j_expr) {
 			this.jsxReadToken();
 			return;
 		}
-		if (context === types$1.j_oTag || context === types$1.j_cTag) {
+		if (context === types.j_oTag || context === types.j_cTag) {
 			if (isIdentifierStart(code)) {
 				this.jsxReadWord();
 				return;
@@ -22637,7 +22648,7 @@ const jsx = (superClass) => class JSXParserMixin extends superClass {
 				this.finishToken(139);
 				return;
 			}
-			if ((code === 34 || code === 39) && context === types$1.j_oTag) {
+			if ((code === 34 || code === 39) && context === types.j_oTag) {
 				this.jsxReadString(code);
 				return;
 			}
@@ -22652,16 +22663,16 @@ const jsx = (superClass) => class JSXParserMixin extends superClass {
 	updateContext(prevType) {
 		const { context, type } = this.state;
 		if (type === 52 && prevType === 138) {
-			context.splice(-2, 2, types$1.j_cTag);
+			context.splice(-2, 2, types.j_cTag);
 			this.state.canStartJSXElement = false;
-		} else if (type === 138) context.push(types$1.j_oTag);
+		} else if (type === 138) context.push(types.j_oTag);
 		else if (type === 139) {
 			const out = context[context.length - 1];
-			if (out === types$1.j_oTag && prevType === 52 || out === types$1.j_cTag) {
+			if (out === types.j_oTag && prevType === 52 || out === types.j_cTag) {
 				context.pop();
-				this.state.canStartJSXElement = context[context.length - 1] === types$1.j_expr;
+				this.state.canStartJSXElement = context[context.length - 1] === types.j_expr;
 			} else {
-				this.setContext(types$1.j_expr);
+				this.setContext(types.j_expr);
 				this.state.canStartJSXElement = true;
 			}
 		} else this.state.canStartJSXElement = tokenComesBeforeExpression(type);
@@ -22699,7 +22710,7 @@ var TypeScriptScopeHandler = class extends ScopeHandler {
 	}
 	declareName(name, bindingType, loc) {
 		if (bindingType & 4096) {
-			if (this.hasImport(name, true)) this.parser.raise(Errors$1.VarRedeclaration, loc, { identifierName: name });
+			if (this.hasImport(name, true)) this.parser.raise(Errors.VarRedeclaration, loc, { identifierName: name });
 			this.importsStack[this.importsStack.length - 1].add(name);
 			return;
 		}
@@ -22913,7 +22924,7 @@ var State = class State {
 		this.startIndex = startIndex;
 		this.curLine = startLine;
 		this.lineStart = -startColumn;
-		this.startLoc = this.endLoc = new Position$1(startLine, startColumn, startIndex);
+		this.startLoc = this.endLoc = new Position(startLine, startColumn, startIndex);
 	}
 	errors = [];
 	noArrowAt = [];
@@ -22998,7 +23009,7 @@ var State = class State {
 	end = 0;
 	lastTokEndLoc = null;
 	lastTokStartLoc = null;
-	context = [types$1.brace];
+	context = [types.brace];
 	get canStartJSXElement() {
 		return (this.flags & 2048) > 0;
 	}
@@ -23024,7 +23035,7 @@ var State = class State {
 	strictErrors = /* @__PURE__ */ new Map();
 	tokensLength = 0;
 	curPosition() {
-		return new Position$1(this.curLine, this.pos - this.lineStart, this.pos + this.startIndex);
+		return new Position(this.curLine, this.pos - this.lineStart, this.pos + this.startIndex);
 	}
 	clone() {
 		const state = new State();
@@ -23273,7 +23284,7 @@ function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
 	};
 }
 function buildPosition(pos, lineStart, curLine) {
-	return new Position$1(curLine, pos - lineStart, pos);
+	return new Position(curLine, pos - lineStart, pos);
 }
 const VALID_REGEX_FLAGS = new Set([
 	103,
@@ -23292,7 +23303,7 @@ var Token = class {
 		this.value = state.value;
 		this.start = startIndex + state.start;
 		this.end = startIndex + state.end;
-		this.loc = new SourceLocation$1(state.startLoc, state.endLoc);
+		this.loc = new SourceLocation(state.startLoc, state.endLoc);
 	}
 };
 let locDataCache;
@@ -23322,7 +23333,7 @@ var Tokenizer = class extends CommentsParser {
 	}
 	getLoc(locIndex) {
 		const dataIndex = this.offsetToSourcePos(locIndex);
-		return new Position$1(this.locData[dataIndex * 2], this.locData[dataIndex * 2 + 1], locIndex);
+		return new Position(this.locData[dataIndex * 2], this.locData[dataIndex * 2 + 1], locIndex);
 	}
 	pushToken(token) {
 		this.tokens.length = this.state.tokensLength;
@@ -23427,12 +23438,12 @@ var Tokenizer = class extends CommentsParser {
 		if (!this.isLookahead) startLoc = this.state.curPosition();
 		const start = this.state.pos;
 		const end = this.input.indexOf(commentEnd, start + 2);
-		if (end === -1) throw this.raise(Errors$1.UnterminatedComment, this.state.curPosition());
+		if (end === -1) throw this.raise(Errors.UnterminatedComment, this.state.curPosition());
 		this.state.pos = end + commentEnd.length;
-		lineBreakG$1.lastIndex = start + 2;
-		while (lineBreakG$1.test(this.input) && lineBreakG$1.lastIndex <= end) {
+		lineBreakG.lastIndex = start + 2;
+		while (lineBreakG.test(this.input) && lineBreakG.lastIndex <= end) {
 			++this.state.curLine;
-			this.state.lineStart = lineBreakG$1.lastIndex;
+			this.state.lineStart = lineBreakG.lastIndex;
 		}
 		if (this.isLookahead) return;
 		const comment = {
@@ -23440,7 +23451,7 @@ var Tokenizer = class extends CommentsParser {
 			value: this.input.slice(start + 2, end),
 			start: this.sourceToOffsetPos(start),
 			end: this.sourceToOffsetPos(end + commentEnd.length),
-			loc: new SourceLocation$1(startLoc, this.state.curPosition())
+			loc: new SourceLocation(startLoc, this.state.curPosition())
 		};
 		if (this.optionFlags & 512) this.pushToken(comment);
 		return comment;
@@ -23458,7 +23469,7 @@ var Tokenizer = class extends CommentsParser {
 			value: this.input.slice(start + startSkip, end),
 			start: this.sourceToOffsetPos(start),
 			end: this.sourceToOffsetPos(end),
-			loc: new SourceLocation$1(startLoc, this.state.curPosition())
+			loc: new SourceLocation(startLoc, this.state.curPosition())
 		};
 		if (this.optionFlags & 512) this.pushToken(comment);
 		return comment;
@@ -23554,7 +23565,7 @@ var Tokenizer = class extends CommentsParser {
 		if (this.state.pos === 0 && this.readToken_interpreter()) return;
 		const nextPos = this.state.pos + 1;
 		const next = this.codePointAtPos(nextPos);
-		if (next >= 48 && next <= 57) throw this.raise(Errors$1.UnexpectedDigitAfterHash, this.state.curPosition());
+		if (next >= 48 && next <= 57) throw this.raise(Errors.UnexpectedDigitAfterHash, this.state.curPosition());
 		if (isIdentifierStart(next)) {
 			++this.state.pos;
 			this.finishToken(134, this.readWord1(next));
@@ -23839,7 +23850,7 @@ var Tokenizer = class extends CommentsParser {
 				return;
 			}
 		}
-		throw this.raise(Errors$1.InvalidOrUnexpectedToken, this.state.curPosition(), { unexpected: String.fromCodePoint(code) });
+		throw this.raise(Errors.InvalidOrUnexpectedToken, this.state.curPosition(), { unexpected: String.fromCodePoint(code) });
 	}
 	finishOp(type, size) {
 		const str = this.input.slice(this.state.pos, this.state.pos + size);
@@ -23852,9 +23863,9 @@ var Tokenizer = class extends CommentsParser {
 		let escaped, inClass;
 		let { pos } = this.state;
 		for (;; ++pos) {
-			if (pos >= this.length) throw this.raise(Errors$1.UnterminatedRegExp, createPositionWithColumnOffset(startLoc, 1));
+			if (pos >= this.length) throw this.raise(Errors.UnterminatedRegExp, createPositionWithColumnOffset(startLoc, 1));
 			const ch = this.input.charCodeAt(pos);
-			if (isNewLine(ch)) throw this.raise(Errors$1.UnterminatedRegExp, createPositionWithColumnOffset(startLoc, 1));
+			if (isNewLine(ch)) throw this.raise(Errors.UnterminatedRegExp, createPositionWithColumnOffset(startLoc, 1));
 			if (escaped) escaped = false;
 			else {
 				if (ch === 91) inClass = true;
@@ -23872,12 +23883,12 @@ var Tokenizer = class extends CommentsParser {
 			const char = String.fromCharCode(cp);
 			if (VALID_REGEX_FLAGS.has(cp)) {
 				if (cp === 118) {
-					if (mods.includes("u")) this.raise(Errors$1.IncompatibleRegExpUVFlags, nextPos());
+					if (mods.includes("u")) this.raise(Errors.IncompatibleRegExpUVFlags, nextPos());
 				} else if (cp === 117) {
-					if (mods.includes("v")) this.raise(Errors$1.IncompatibleRegExpUVFlags, nextPos());
+					if (mods.includes("v")) this.raise(Errors.IncompatibleRegExpUVFlags, nextPos());
 				}
-				if (mods.includes(char)) this.raise(Errors$1.DuplicateRegExpFlags, nextPos());
-			} else if (isIdentifierChar(cp) || cp === 92) this.raise(Errors$1.MalformedRegExpFlags, nextPos());
+				if (mods.includes(char)) this.raise(Errors.DuplicateRegExpFlags, nextPos());
+			} else if (isIdentifierChar(cp) || cp === 92) this.raise(Errors.MalformedRegExpFlags, nextPos());
 			else break;
 			++pos;
 			mods += char;
@@ -23899,12 +23910,12 @@ var Tokenizer = class extends CommentsParser {
 		let isBigInt = false;
 		this.state.pos += 2;
 		const val = this.readInt(radix);
-		if (val == null) this.raise(Errors$1.InvalidDigit, createPositionWithColumnOffset(startLoc, 2), { radix });
+		if (val == null) this.raise(Errors.InvalidDigit, createPositionWithColumnOffset(startLoc, 2), { radix });
 		if (this.input.charCodeAt(this.state.pos) === 110) {
 			++this.state.pos;
 			isBigInt = true;
 		}
-		if (isIdentifierStart(this.codePointAtPos(this.state.pos))) throw this.raise(Errors$1.NumberIdentifier, this.state.curPosition());
+		if (isIdentifierStart(this.codePointAtPos(this.state.pos))) throw this.raise(Errors.NumberIdentifier, this.state.curPosition());
 		if (isBigInt) {
 			const str = this.input.slice(start, this.state.pos).replace(/[_n]/g, "");
 			this.finishToken(132, str);
@@ -23918,14 +23929,14 @@ var Tokenizer = class extends CommentsParser {
 		let isFloat = false;
 		let isBigInt = false;
 		let isOctal = false;
-		if (!startsWithDot && this.readInt(10) === null) this.raise(Errors$1.InvalidNumber, this.state.curPosition());
+		if (!startsWithDot && this.readInt(10) === null) this.raise(Errors.InvalidNumber, this.state.curPosition());
 		const hasLeadingZero = this.state.pos - start >= 2 && this.input.charCodeAt(start) === 48;
 		if (hasLeadingZero) {
 			const integer = this.input.slice(start, this.state.pos);
-			this.recordStrictModeErrors(Errors$1.StrictOctalLiteral, startLoc);
+			this.recordStrictModeErrors(Errors.StrictOctalLiteral, startLoc);
 			if (!this.state.strict) {
 				const underscorePos = integer.indexOf("_");
-				if (underscorePos > 0) this.raise(Errors$1.ZeroDigitNumericSeparator, createPositionWithColumnOffset(startLoc, underscorePos));
+				if (underscorePos > 0) this.raise(Errors.ZeroDigitNumericSeparator, createPositionWithColumnOffset(startLoc, underscorePos));
 			}
 			isOctal = hasLeadingZero && !/[89]/.test(integer);
 		}
@@ -23939,17 +23950,17 @@ var Tokenizer = class extends CommentsParser {
 		if ((next === 69 || next === 101) && !isOctal) {
 			next = this.input.charCodeAt(++this.state.pos);
 			if (next === 43 || next === 45) ++this.state.pos;
-			if (this.readInt(10) === null) this.raise(Errors$1.InvalidOrMissingExponent, startLoc);
+			if (this.readInt(10) === null) this.raise(Errors.InvalidOrMissingExponent, startLoc);
 			isFloat = true;
 			next = this.input.charCodeAt(this.state.pos);
 		}
 		const str = this.input.slice(start, this.state.pos).replaceAll("_", "");
 		if (next === 110) {
-			if (isFloat || hasLeadingZero) this.raise(Errors$1.InvalidBigIntLiteral, startLoc);
+			if (isFloat || hasLeadingZero) this.raise(Errors.InvalidBigIntLiteral, startLoc);
 			++this.state.pos;
 			isBigInt = true;
 		}
-		if (isIdentifierStart(this.codePointAtPos(this.state.pos))) throw this.raise(Errors$1.NumberIdentifier, this.state.curPosition());
+		if (isIdentifierStart(this.codePointAtPos(this.state.pos))) throw this.raise(Errors.NumberIdentifier, this.state.curPosition());
 		if (isBigInt) {
 			this.finishToken(132, str);
 			return;
@@ -23980,7 +23991,7 @@ var Tokenizer = class extends CommentsParser {
 		this.state.pos = pos + 1;
 		this.state.lineStart = lineStart;
 		this.state.curLine = curLine;
-		if (firstInvalidLoc) this.state.firstInvalidTemplateEscapePos = new Position$1(firstInvalidLoc.curLine, firstInvalidLoc.pos - firstInvalidLoc.lineStart, this.sourceToOffsetPos(firstInvalidLoc.pos));
+		if (firstInvalidLoc) this.state.firstInvalidTemplateEscapePos = new Position(firstInvalidLoc.curLine, firstInvalidLoc.pos - firstInvalidLoc.lineStart, this.sourceToOffsetPos(firstInvalidLoc.pos));
 		if (this.input.codePointAt(pos) === 96) this.finishToken(20, firstInvalidLoc ? null : opening + str + "`");
 		else {
 			this.state.pos++;
@@ -24007,14 +24018,14 @@ var Tokenizer = class extends CommentsParser {
 				const escStart = this.state.curPosition();
 				const identifierCheck = this.state.pos === start ? isIdentifierStart : isIdentifierChar;
 				if (this.input.charCodeAt(++this.state.pos) !== 117) {
-					this.raise(Errors$1.MissingUnicodeEscape, this.state.curPosition());
+					this.raise(Errors.MissingUnicodeEscape, this.state.curPosition());
 					chunkStart = this.state.pos - 1;
 					continue;
 				}
 				++this.state.pos;
 				const esc = this.readCodePoint(true);
 				if (esc !== null) {
-					if (!identifierCheck(esc)) this.raise(Errors$1.EscapedCharNotAnIdentifier, escStart);
+					if (!identifierCheck(esc)) this.raise(Errors.EscapedCharNotAnIdentifier, escStart);
 					word += String.fromCodePoint(esc);
 				}
 				chunkStart = this.state.pos;
@@ -24024,24 +24035,24 @@ var Tokenizer = class extends CommentsParser {
 	}
 	readWord(firstCode) {
 		const word = this.readWord1(firstCode);
-		const type = keywords$1$1.get(word);
+		const type = keywords$1.get(word);
 		if (type !== void 0) this.finishToken(type, tokenLabelName(type));
 		else this.finishToken(128, word);
 	}
 	checkKeywordEscapes() {
 		const { type } = this.state;
-		if (tokenIsKeyword(type) && this.state.containsEsc) this.raise(Errors$1.InvalidEscapedReservedWord, this.state.startLoc, { reservedWord: tokenLabelName(type) });
+		if (tokenIsKeyword(type) && this.state.containsEsc) this.raise(Errors.InvalidEscapedReservedWord, this.state.startLoc, { reservedWord: tokenLabelName(type) });
 	}
 	raise(toParseError, at, details = {}) {
-		const loc = at instanceof Position$1 ? at : typeof at === "number" ? this.getLoc(at) : this.optionFlags & 256 ? at.loc.start : this.getLoc(at.start);
-		const error = toParseError(loc, at instanceof Position$1 ? loc.index : typeof at === "number" ? at : at.start, details);
+		const loc = at instanceof Position ? at : typeof at === "number" ? this.getLoc(at) : this.optionFlags & 256 ? at.loc.start : this.getLoc(at.start);
+		const error = toParseError(loc, at instanceof Position ? loc.index : typeof at === "number" ? at : at.start, details);
 		if (!(this.optionFlags & 4096)) throw error;
 		if (!this.isLookahead) this.state.errors.push(error);
 		return error;
 	}
 	raiseOverwrite(toParseError, at, details = {}) {
-		const loc = at instanceof Position$1 ? at : this.optionFlags & 256 ? at.loc.start : this.getLoc(at.start);
-		const pos = at instanceof Position$1 ? loc.index : at.start;
+		const loc = at instanceof Position ? at : this.optionFlags & 256 ? at.loc.start : this.getLoc(at.start);
+		const pos = at instanceof Position ? loc.index : at.start;
 		const errors = this.state.errors;
 		for (let i = errors.length - 1; i >= 0; i--) {
 			const error = errors[i];
@@ -24052,14 +24063,14 @@ var Tokenizer = class extends CommentsParser {
 	}
 	updateContext(prevType) {}
 	unexpected(loc, type) {
-		throw this.raise(Errors$1.UnexpectedToken, loc != null ? loc : this.state.startLoc, { expected: type ? tokenLabelName(type) : null });
+		throw this.raise(Errors.UnexpectedToken, loc != null ? loc : this.state.startLoc, { expected: type ? tokenLabelName(type) : null });
 	}
 	expectPlugin(pluginName, loc) {
 		if (this.hasPlugin(pluginName)) return true;
-		throw this.raise(Errors$1.MissingPlugin, loc != null ? loc : this.state.startLoc, { missingPlugin: [pluginName] });
+		throw this.raise(Errors.MissingPlugin, loc != null ? loc : this.state.startLoc, { missingPlugin: [pluginName] });
 	}
 	expectOnePlugin(pluginNames) {
-		if (!pluginNames.some((name) => this.hasPlugin(name))) throw this.raise(Errors$1.MissingOneOfPlugins, this.state.startLoc, { missingPlugin: pluginNames });
+		if (!pluginNames.some((name) => this.hasPlugin(name))) throw this.raise(Errors.MissingOneOfPlugins, this.state.startLoc, { missingPlugin: pluginNames });
 	}
 	errorBuilder(error) {
 		return (pos, lineStart, curLine) => {
@@ -24069,31 +24080,31 @@ var Tokenizer = class extends CommentsParser {
 	errorHandlers_readInt = {
 		invalidDigit: (pos, lineStart, curLine, radix) => {
 			if (!(this.optionFlags & 4096)) return false;
-			this.raise(Errors$1.InvalidDigit, buildPosition(pos, lineStart, curLine), { radix });
+			this.raise(Errors.InvalidDigit, buildPosition(pos, lineStart, curLine), { radix });
 			return true;
 		},
-		numericSeparatorInEscapeSequence: this.errorBuilder(Errors$1.NumericSeparatorInEscapeSequence),
-		unexpectedNumericSeparator: this.errorBuilder(Errors$1.UnexpectedNumericSeparator)
+		numericSeparatorInEscapeSequence: this.errorBuilder(Errors.NumericSeparatorInEscapeSequence),
+		unexpectedNumericSeparator: this.errorBuilder(Errors.UnexpectedNumericSeparator)
 	};
 	errorHandlers_readCodePoint = {
 		...this.errorHandlers_readInt,
-		invalidEscapeSequence: this.errorBuilder(Errors$1.InvalidEscapeSequence),
-		invalidCodePoint: this.errorBuilder(Errors$1.InvalidCodePoint)
+		invalidEscapeSequence: this.errorBuilder(Errors.InvalidEscapeSequence),
+		invalidCodePoint: this.errorBuilder(Errors.InvalidCodePoint)
 	};
 	errorHandlers_readStringContents_string = {
 		...this.errorHandlers_readCodePoint,
 		strictNumericEscape: (pos, lineStart, curLine) => {
-			this.recordStrictModeErrors(Errors$1.StrictNumericEscape, buildPosition(pos, lineStart, curLine));
+			this.recordStrictModeErrors(Errors.StrictNumericEscape, buildPosition(pos, lineStart, curLine));
 		},
 		unterminated: (pos, lineStart, curLine) => {
-			throw this.raise(Errors$1.UnterminatedString, buildPosition(pos - 1, lineStart, curLine));
+			throw this.raise(Errors.UnterminatedString, buildPosition(pos - 1, lineStart, curLine));
 		}
 	};
 	errorHandlers_readStringContents_template = {
 		...this.errorHandlers_readCodePoint,
-		strictNumericEscape: this.errorBuilder(Errors$1.StrictNumericEscape),
+		strictNumericEscape: this.errorBuilder(Errors.StrictNumericEscape),
 		unterminated: (pos, lineStart, curLine) => {
-			throw this.raise(Errors$1.UnterminatedTemplate, buildPosition(pos, lineStart, curLine));
+			throw this.raise(Errors.UnterminatedTemplate, buildPosition(pos, lineStart, curLine));
 		}
 	};
 };
@@ -24119,7 +24130,7 @@ var ClassScopeHandler = class {
 		const current = this.current();
 		for (const [name, loc] of Array.from(oldClassScope.undefinedPrivateNames)) if (current) {
 			if (!current.undefinedPrivateNames.has(name)) current.undefinedPrivateNames.set(name, loc);
-		} else this.parser.raise(Errors$1.InvalidPrivateFieldResolution, loc, { identifierName: name });
+		} else this.parser.raise(Errors.InvalidPrivateFieldResolution, loc, { identifierName: name });
 	}
 	declarePrivateName(name, elementType, loc) {
 		const { privateNames, loneAccessors, undefinedPrivateNames } = this.current();
@@ -24133,7 +24144,7 @@ var ClassScopeHandler = class {
 				if (!redefined) loneAccessors.delete(name);
 			} else if (!redefined) loneAccessors.set(name, elementType);
 		}
-		if (redefined) this.parser.raise(Errors$1.PrivateNameRedeclaration, loc, { identifierName: name });
+		if (redefined) this.parser.raise(Errors.PrivateNameRedeclaration, loc, { identifierName: name });
 		privateNames.add(name);
 		undefinedPrivateNames.delete(name);
 	}
@@ -24141,7 +24152,7 @@ var ClassScopeHandler = class {
 		let classScope;
 		for (classScope of this.stack) if (classScope.privateNames.has(name)) return;
 		if (classScope) classScope.undefinedPrivateNames.set(name, loc);
-		else this.parser.raise(Errors$1.InvalidPrivateFieldResolution, loc, { identifierName: name });
+		else this.parser.raise(Errors.InvalidPrivateFieldResolution, loc, { identifierName: name });
 	}
 };
 var ExpressionScope = class {
@@ -24206,7 +24217,7 @@ var ExpressionScopeHandler = class {
 		let i = stack.length - 1;
 		let scope = stack[i];
 		while (scope.canBeArrowParameterDeclaration()) {
-			if (scope.type === 2) scope.recordDeclarationError(Errors$1.AwaitBindingIdentifier, at);
+			if (scope.type === 2) scope.recordDeclarationError(Errors.AwaitBindingIdentifier, at);
 			scope = stack[--i];
 		}
 	}
@@ -24322,7 +24333,7 @@ var UtilParser = class extends Tokenizer {
 	}
 	semicolon(allowAsi = true) {
 		if (allowAsi ? this.isLineTerminator() : this.eat(9)) return;
-		this.raise(Errors$1.MissingSemicolon, this.state.lastTokEndLoc);
+		this.raise(Errors.MissingSemicolon, this.state.lastTokEndLoc);
 	}
 	expect(type, loc) {
 		if (!this.eat(type)) this.unexpected(loc, type);
@@ -24378,11 +24389,11 @@ var UtilParser = class extends Tokenizer {
 		const { shorthandAssignLoc, doubleProtoLoc, privateKeyLoc, optionalParametersLoc, voidPatternLoc } = refExpressionErrors;
 		const hasErrors = !!shorthandAssignLoc || !!doubleProtoLoc || !!optionalParametersLoc || !!privateKeyLoc || !!voidPatternLoc;
 		if (!andThrow) return hasErrors;
-		if (shorthandAssignLoc != null) this.raise(Errors$1.InvalidCoverInitializedName, shorthandAssignLoc);
-		if (doubleProtoLoc != null) this.raise(Errors$1.DuplicateProto, doubleProtoLoc);
-		if (privateKeyLoc != null) this.raise(Errors$1.UnexpectedPrivateField, privateKeyLoc);
+		if (shorthandAssignLoc != null) this.raise(Errors.InvalidCoverInitializedName, shorthandAssignLoc);
+		if (doubleProtoLoc != null) this.raise(Errors.DuplicateProto, doubleProtoLoc);
+		if (privateKeyLoc != null) this.raise(Errors.UnexpectedPrivateField, privateKeyLoc);
 		if (optionalParametersLoc != null) this.unexpected(optionalParametersLoc);
-		if (voidPatternLoc != null) this.raise(Errors$1.InvalidCoverDiscardElement, voidPatternLoc);
+		if (voidPatternLoc != null) this.raise(Errors.InvalidCoverDiscardElement, voidPatternLoc);
 	}
 	isLiteralPropertyName() {
 		return tokenIsLiteralPropertyName(this.state.type);
@@ -24452,17 +24463,17 @@ var ExpressionErrors = class {
 	optionalParametersLoc = null;
 	voidPatternLoc = null;
 };
-var Node$1 = class {
+var Node = class {
 	constructor(optionFlags, filename, pos, loc) {
 		this.start = pos;
 		this.end = 0;
-		if (loc !== void 0) this.loc = new SourceLocation$1(loc);
+		if (loc !== void 0) this.loc = new SourceLocation(loc);
 		if (optionFlags & 128) this.range = [pos, 0];
 		if (loc !== void 0 && filename) this.loc.filename = filename;
 	}
 	type = "";
 };
-const NodePrototype$1 = Node$1.prototype;
+const NodePrototype = Node.prototype;
 var NodeUtils = class extends UtilParser {
 	createPosition(loc) {
 		return loc;
@@ -24474,13 +24485,13 @@ var NodeUtils = class extends UtilParser {
 	}
 	startNodeAt(loc) {
 		const { optionFlags, filename } = this;
-		if (!(optionFlags & 256)) return new Node$1(optionFlags, filename, loc.index);
-		return new Node$1(optionFlags, filename, loc.index, this.createPosition(loc));
+		if (!(optionFlags & 256)) return new Node(optionFlags, filename, loc.index);
+		return new Node(optionFlags, filename, loc.index, this.createPosition(loc));
 	}
 	startNodeAtNode(type) {
 		const { optionFlags, filename } = this;
-		if (!(optionFlags & 256)) return new Node$1(optionFlags, filename, type.start);
-		return new Node$1(optionFlags, filename, type.start, type.loc.start);
+		if (!(optionFlags & 256)) return new Node(optionFlags, filename, type.start);
+		return new Node(optionFlags, filename, type.start, type.loc.start);
 	}
 	finishNode(node, type) {
 		return this.finishNodeAt(node, type, this.state.lastTokEndLoc);
@@ -24533,7 +24544,7 @@ var NodeUtils = class extends UtilParser {
 	}
 	cloneIdentifier(node) {
 		const { type, start, end, loc, range, name } = node;
-		const cloned = Object.create(NodePrototype$1);
+		const cloned = Object.create(NodePrototype);
 		cloned.type = type;
 		cloned.start = start;
 		cloned.end = end;
@@ -24545,7 +24556,7 @@ var NodeUtils = class extends UtilParser {
 	}
 	cloneStringLiteral(node) {
 		const { type, start, end, loc, range, extra } = node;
-		const cloned = Object.create(NodePrototype$1);
+		const cloned = Object.create(NodePrototype);
 		cloned.type = type;
 		cloned.start = start;
 		cloned.end = end;
@@ -24565,9 +24576,9 @@ var LValParser = class extends NodeUtils {
 		if (node.type === "ParenthesizedExpression" || node.extra?.parenthesized) {
 			parenthesized = unwrapParenthesizedExpression(node);
 			if (isLHS) {
-				if (parenthesized.type === "Identifier") this.expressionScope.recordArrowParameterBindingError(Errors$1.InvalidParenthesizedAssignment, node);
-				else if (parenthesized.type !== "CallExpression" && parenthesized.type !== "MemberExpression" && !this.isOptionalMemberExpression(parenthesized)) this.raise(Errors$1.InvalidParenthesizedAssignment, node);
-			} else this.raise(Errors$1.InvalidParenthesizedAssignment, node);
+				if (parenthesized.type === "Identifier") this.expressionScope.recordArrowParameterBindingError(Errors.InvalidParenthesizedAssignment, node);
+				else if (parenthesized.type !== "CallExpression" && parenthesized.type !== "MemberExpression" && !this.isOptionalMemberExpression(parenthesized)) this.raise(Errors.InvalidParenthesizedAssignment, node);
+			} else this.raise(Errors.InvalidParenthesizedAssignment, node);
 		}
 		switch (node.type) {
 			case "Identifier":
@@ -24582,7 +24593,7 @@ var LValParser = class extends NodeUtils {
 					const prop = node.properties[i];
 					const isLast = i === last;
 					this.toAssignableObjectExpressionProp(prop, isLast, isLHS);
-					if (isLast && prop.type === "RestElement" && node.extra?.trailingCommaLoc) this.raise(Errors$1.RestTrailingComma, node.extra.trailingCommaLoc);
+					if (isLast && prop.type === "RestElement" && node.extra?.trailingCommaLoc) this.raise(Errors.RestTrailingComma, node.extra.trailingCommaLoc);
 				}
 				break;
 			case "ObjectProperty": {
@@ -24597,10 +24608,10 @@ var LValParser = class extends NodeUtils {
 				this.toAssignableList(node.elements, node.extra?.trailingCommaLoc, isLHS);
 				break;
 			case "AssignmentExpression":
-				if (node.operator !== "=") this.raise(Errors$1.MissingEqInAssignment, this.optionFlags & 256 ? node.left.loc.end : node.left);
+				if (node.operator !== "=") this.raise(Errors.MissingEqInAssignment, this.optionFlags & 256 ? node.left.loc.end : node.left);
 				this.castNodeTo(node, "AssignmentPattern");
 				delete node.operator;
-				if (node.left.type === "VoidPattern") this.raise(Errors$1.VoidPatternInitializer, node.left);
+				if (node.left.type === "VoidPattern") this.raise(Errors.VoidPatternInitializer, node.left);
 				this.toAssignable(node.left, isLHS);
 				break;
 			case "ParenthesizedExpression":
@@ -24609,13 +24620,13 @@ var LValParser = class extends NodeUtils {
 		}
 	}
 	toAssignableObjectExpressionProp(prop, isLast, isLHS) {
-		if (prop.type === "ObjectMethod") this.raise(prop.kind === "get" || prop.kind === "set" ? Errors$1.PatternHasAccessor : Errors$1.PatternHasMethod, prop.key);
+		if (prop.type === "ObjectMethod") this.raise(prop.kind === "get" || prop.kind === "set" ? Errors.PatternHasAccessor : Errors.PatternHasMethod, prop.key);
 		else if (prop.type === "SpreadElement") {
 			this.castNodeTo(prop, "RestElement");
 			const arg = prop.argument;
 			this.checkToRestConversion(arg, false);
 			this.toAssignable(arg, isLHS);
-			if (!isLast) this.raise(Errors$1.RestTrailingComma, prop);
+			if (!isLast) this.raise(Errors.RestTrailingComma, prop);
 		} else this.toAssignable(prop, isLHS);
 	}
 	toAssignableList(exprList, trailingCommaLoc, isLHS) {
@@ -24625,8 +24636,8 @@ var LValParser = class extends NodeUtils {
 			if (!elt) continue;
 			this.toAssignableListItem(exprList, i, isLHS);
 			if (elt.type === "RestElement") {
-				if (i < end) this.raise(Errors$1.RestTrailingComma, elt);
-				else if (trailingCommaLoc) this.raise(Errors$1.RestTrailingComma, trailingCommaLoc);
+				if (i < end) this.raise(Errors.RestTrailingComma, elt);
+				else if (trailingCommaLoc) this.raise(Errors.RestTrailingComma, trailingCommaLoc);
 			}
 		}
 	}
@@ -24676,7 +24687,7 @@ var LValParser = class extends NodeUtils {
 		const node = this.startNode();
 		this.next();
 		const argument = this.parseBindingAtom();
-		if (argument.type === "VoidPattern") this.raise(Errors$1.UnexpectedVoidPattern, argument);
+		if (argument.type === "VoidPattern") this.raise(Errors.UnexpectedVoidPattern, argument);
 		node.argument = argument;
 		return this.finishNode(node, "RestElement");
 	}
@@ -24713,7 +24724,7 @@ var LValParser = class extends NodeUtils {
 			} else {
 				const decorators = [];
 				if (flags & 2) {
-					if (this.match(22) && this.hasPlugin("decorators")) this.raise(Errors$1.UnsupportedParameterDecorator, this.state.startLoc);
+					if (this.match(22) && this.hasPlugin("decorators")) this.raise(Errors.UnsupportedParameterDecorator, this.state.startLoc);
 					while (this.match(22)) decorators.push(this.parseDecorator());
 				}
 				elts.push(this.parseBindingElement(flags, decorators));
@@ -24725,7 +24736,7 @@ var LValParser = class extends NodeUtils {
 		this.next();
 		if (this.hasPlugin("discardBinding") && this.match(84)) {
 			prop.argument = this.parseVoidPattern(null);
-			this.raise(Errors$1.UnexpectedVoidPattern, prop.argument);
+			this.raise(Errors.UnexpectedVoidPattern, prop.argument);
 		} else prop.argument = this.parseIdentifier();
 		this.checkCommaAfterRest(125);
 		return this.finishNode(prop, "RestElement");
@@ -24760,7 +24771,7 @@ var LValParser = class extends NodeUtils {
 		left = left ?? this.parseBindingAtom();
 		if (!this.eat(25)) return left;
 		const node = this.startNodeAt(startLoc);
-		if (left.type === "VoidPattern") this.raise(Errors$1.VoidPatternInitializer, left);
+		if (left.type === "VoidPattern") this.raise(Errors.VoidPatternInitializer, left);
 		node.left = left;
 		node.right = this.parseMaybeAssignAllowIn();
 		return this.finishNode(node, "AssignmentPattern");
@@ -24788,24 +24799,24 @@ var LValParser = class extends NodeUtils {
 		if (isOptionalMemberExpression || type === "MemberExpression") {
 			if (isOptionalMemberExpression) {
 				this.expectPlugin("optionalChainingAssign", expression.start);
-				if (ancestor.type !== "AssignmentExpression") this.raise(Errors$1.InvalidLhsOptionalChaining, expression, { ancestor });
+				if (ancestor.type !== "AssignmentExpression") this.raise(Errors.InvalidLhsOptionalChaining, expression, { ancestor });
 			}
-			if (binding !== 64) this.raise(Errors$1.InvalidPropertyBindingPattern, expression);
+			if (binding !== 64) this.raise(Errors.InvalidPropertyBindingPattern, expression);
 			return;
 		}
 		if (type === "Identifier") {
 			this.checkIdentifier(expression, binding, strictModeChanged);
 			const { name } = expression;
-			if (checkClashes) if (checkClashes.has(name)) this.raise(Errors$1.ParamDupe, expression);
+			if (checkClashes) if (checkClashes.has(name)) this.raise(Errors.ParamDupe, expression);
 			else checkClashes.add(name);
 			return;
-		} else if (type === "VoidPattern" && ancestor.type === "CatchClause") this.raise(Errors$1.VoidPatternCatchClauseParam, expression);
+		} else if (type === "VoidPattern" && ancestor.type === "CatchClause") this.raise(Errors.VoidPatternCatchClauseParam, expression);
 		const unwrappedExpression = unwrapParenthesizedExpression(expression);
 		disallowCallExpression ||= unwrappedExpression.type === "CallExpression" && (unwrappedExpression.callee.type === "Import" || unwrappedExpression.callee.type === "Super");
 		const validity = this.isValidLVal(type, disallowCallExpression, !(hasParenthesizedAncestor || expression.extra?.parenthesized) && ancestor.type === "AssignmentExpression", binding);
 		if (validity === true) return;
 		if (validity === false) {
-			const ParseErrorClass = binding === 64 ? Errors$1.InvalidLhs : Errors$1.InvalidLhsBinding;
+			const ParseErrorClass = binding === 64 ? Errors.InvalidLhs : Errors.InvalidLhsBinding;
 			this.raise(ParseErrorClass, expression, { ancestor });
 			return;
 		}
@@ -24821,9 +24832,9 @@ var LValParser = class extends NodeUtils {
 		} else if (val) this.checkLVal(val, nextAncestor, binding, checkClashes, strictModeChanged, isParenthesizedExpression, disallowCallExpression);
 	}
 	checkIdentifier(at, bindingType, strictModeChanged = false) {
-		if (this.state.strict && (strictModeChanged ? isStrictBindReservedWord(at.name, this.inModule) : isStrictBindOnlyReservedWord(at.name))) if (bindingType === 64) this.raise(Errors$1.StrictEvalArguments, at, { referenceName: at.name });
-		else this.raise(Errors$1.StrictEvalArgumentsBinding, at, { bindingName: at.name });
-		if (bindingType & 8192 && at.name === "let") this.raise(Errors$1.LetInLexicalBinding, at);
+		if (this.state.strict && (strictModeChanged ? isStrictBindReservedWord(at.name, this.inModule) : isStrictBindOnlyReservedWord(at.name))) if (bindingType === 64) this.raise(Errors.StrictEvalArguments, at, { referenceName: at.name });
+		else this.raise(Errors.StrictEvalArgumentsBinding, at, { bindingName: at.name });
+		if (bindingType & 8192 && at.name === "let") this.raise(Errors.LetInLexicalBinding, at);
 		if (!(bindingType & 64)) this.declareNameFromIdentifier(at, bindingType);
 	}
 	declareNameFromIdentifier(identifier, binding) {
@@ -24838,12 +24849,12 @@ var LValParser = class extends NodeUtils {
 			case "MemberExpression": break;
 			case "ArrayExpression":
 			case "ObjectExpression": if (allowPattern) break;
-			default: this.raise(Errors$1.InvalidRestAssignmentPattern, node);
+			default: this.raise(Errors.InvalidRestAssignmentPattern, node);
 		}
 	}
 	checkCommaAfterRest(close) {
 		if (!this.match(8)) return false;
-		this.raise(this.lookaheadCharCode() === close ? Errors$1.RestTrailingComma : Errors$1.ElementAfterRest, this.state.startLoc);
+		this.raise(this.lookaheadCharCode() === close ? Errors.RestTrailingComma : Errors.ElementAfterRest, this.state.startLoc);
 		return true;
 	}
 };
@@ -24854,7 +24865,7 @@ var ExpressionParser = class extends LValParser {
 		if ((key.type === "Identifier" ? key.name : key.value) === "__proto__") {
 			if (sawProto) if (refExpressionErrors) {
 				if (refExpressionErrors.doubleProtoLoc === null) refExpressionErrors.doubleProtoLoc = this.getLoc(key.start);
-			} else this.raise(Errors$1.DuplicateProto, key);
+			} else this.raise(Errors.DuplicateProto, key);
 			return true;
 		}
 		return sawProto;
@@ -24865,9 +24876,9 @@ var ExpressionParser = class extends LValParser {
 	getExpression() {
 		this.enterInitialScopes();
 		this.nextToken();
-		if (this.match(135)) throw this.raise(Errors$1.ParseExpressionEmptyInput, this.state.startLoc);
+		if (this.match(135)) throw this.raise(Errors.ParseExpressionEmptyInput, this.state.startLoc);
 		const expr = this.parseExpression();
-		if (!this.match(135)) throw this.raise(Errors$1.ParseExpressionExpectsEOF, this.state.startLoc, { unexpected: this.input.codePointAt(this.state.start) });
+		if (!this.match(135)) throw this.raise(Errors.ParseExpressionExpectsEOF, this.state.startLoc, { unexpected: this.input.codePointAt(this.state.start) });
 		this.finalizeRemainingComments();
 		expr.comments = this.comments;
 		expr.errors = this.state.errors;
@@ -24944,7 +24955,7 @@ var ExpressionParser = class extends LValParser {
 		if (isYield) {
 			const { type } = this.state;
 			if ((this.hasPlugin("v8intrinsic") ? tokenCanStartExpression(type) : tokenCanStartExpression(type) && !this.match(50)) && !this.isAmbiguousPrefixOrIdentifier()) {
-				this.raiseOverwrite(Errors$1.YieldNotInGeneratorFunction, startLoc);
+				this.raiseOverwrite(Errors.YieldNotInGeneratorFunction, startLoc);
 				return this.parseYield(startLoc);
 			}
 		}
@@ -24980,7 +24991,7 @@ var ExpressionParser = class extends LValParser {
 	parseExprOp(left, leftStartLoc, minPrec) {
 		if (this.isPrivateName(left)) {
 			const value = this.getPrivateNameSV(left);
-			if (minPrec >= tokenOperatorPrecedence(54) || !this.prodParam.hasIn || !this.match(54)) this.raise(Errors$1.PrivateInExpectedIn, leftStartLoc, { identifierName: value });
+			if (minPrec >= tokenOperatorPrecedence(54) || !this.prodParam.hasIn || !this.match(54)) this.raise(Errors.PrivateInExpectedIn, leftStartLoc, { identifierName: value });
 			this.classScope.usePrivateName(value, leftStartLoc);
 		}
 		const op = this.state.type;
@@ -25001,7 +25012,7 @@ var ExpressionParser = class extends LValParser {
 				node.right = this.parseExprOpRightExpr(op, prec);
 				const finishedNode = this.finishNode(node, logical || coalesce ? "LogicalExpression" : "BinaryExpression");
 				const nextOp = this.state.type;
-				if (coalesce && (nextOp === 37 || nextOp === 38) || logical && nextOp === 36) throw this.raise(Errors$1.MixingCoalesceWithLogical, this.state.startLoc);
+				if (coalesce && (nextOp === 37 || nextOp === 38) || logical && nextOp === 36) throw this.raise(Errors.MixingCoalesceWithLogical, this.state.startLoc);
 				return this.parseExprOp(finishedNode, leftStartLoc, minPrec);
 			}
 		}
@@ -25025,12 +25036,12 @@ var ExpressionParser = class extends LValParser {
 	parseHackPipeBody() {
 		const { startLoc } = this.state;
 		const body = this.parseMaybeAssign();
-		if (UnparenthesizedPipeBodyDescriptions.has(body.type) && !body.extra?.parenthesized) this.raise(Errors$1.PipeUnparenthesizedBody, startLoc, { type: body.type });
-		if (!this.topicReferenceWasUsedInCurrentContext()) this.raise(Errors$1.PipeTopicUnused, startLoc);
+		if (UnparenthesizedPipeBodyDescriptions.has(body.type) && !body.extra?.parenthesized) this.raise(Errors.PipeUnparenthesizedBody, startLoc, { type: body.type });
+		if (!this.topicReferenceWasUsedInCurrentContext()) this.raise(Errors.PipeTopicUnused, startLoc);
 		return body;
 	}
 	checkExponentialAfterUnary(node) {
-		if (this.match(53)) this.raise(Errors$1.UnexpectedTokenUnaryExponentiation, node.argument);
+		if (this.match(53)) this.raise(Errors.UnexpectedTokenUnaryExponentiation, node.argument);
 	}
 	parseMaybeUnary(refExpressionErrors, sawUnary) {
 		const startLoc = this.state.startLoc;
@@ -25054,8 +25065,8 @@ var ExpressionParser = class extends LValParser {
 			this.checkExpressionErrors(refExpressionErrors, true);
 			if (this.state.strict && isDelete) {
 				const arg = node.argument;
-				if (arg.type === "Identifier") this.raise(Errors$1.StrictDelete, node);
-				else if (this.hasPropertyAsPrivateName(arg)) this.raise(Errors$1.DeletePrivateField, node);
+				if (arg.type === "Identifier") this.raise(Errors.StrictDelete, node);
+				else if (this.hasPropertyAsPrivateName(arg)) this.raise(Errors.DeletePrivateField, node);
 			}
 			if (!update) {
 				if (!sawUnary) this.checkExponentialAfterUnary(node);
@@ -25066,7 +25077,7 @@ var ExpressionParser = class extends LValParser {
 		if (isAwait) {
 			const { type } = this.state;
 			if ((this.hasPlugin("v8intrinsic") ? tokenCanStartExpression(type) : tokenCanStartExpression(type) && !this.match(50)) && !this.isAmbiguousPrefixOrIdentifier()) {
-				this.raiseOverwrite(Errors$1.AwaitNotInAsyncContext, startLoc);
+				this.raiseOverwrite(Errors.AwaitNotInAsyncContext, startLoc);
 				return this.parseAwait(startLoc);
 			}
 		}
@@ -25117,7 +25128,7 @@ var ExpressionParser = class extends LValParser {
 		let optional = false;
 		if (type === 14) {
 			if (noCalls) {
-				this.raise(Errors$1.OptionalChainingNoNew, this.state.startLoc);
+				this.raise(Errors.OptionalChainingNoNew, this.state.startLoc);
 				if (this.lookaheadCharCode() === 40) return this.stopParseSubscript(base, state);
 			}
 			state.optionalChainMember = optional = true;
@@ -25142,7 +25153,7 @@ var ExpressionParser = class extends LValParser {
 			node.property = this.parseExpression();
 			this.expect(1);
 		} else if (this.match(134)) {
-			if (base.type === "Super") this.raise(Errors$1.SuperPrivateField, startLoc);
+			if (base.type === "Super") this.raise(Errors.SuperPrivateField, startLoc);
 			this.classScope.usePrivateName(this.state.value, this.state.startLoc);
 			node.property = this.parsePrivateName();
 		} else node.property = this.parseIdentifier(true);
@@ -25157,7 +25168,7 @@ var ExpressionParser = class extends LValParser {
 		this.next();
 		const isImport = this.match(79);
 		const callee = this.parseNoCallExpr();
-		if (callee.type === "Super" || isImport && callee.type === "ImportExpression" || callee.type === "Import") throw this.raise(Errors$1.UnsupportedBindRHS, callee);
+		if (callee.type === "Super" || isImport && callee.type === "ImportExpression" || callee.type === "Import") throw this.raise(Errors.UnsupportedBindRHS, callee);
 		node.callee = callee;
 		state.stop = true;
 		return this.parseSubscripts(this.finishNode(node, "BindExpression"), startLoc, false);
@@ -25195,7 +25206,7 @@ var ExpressionParser = class extends LValParser {
 		const node = this.startNodeAt(startLoc);
 		node.tag = base;
 		node.quasi = this.parseTemplate(true);
-		if (state.optionalChainMember) this.raise(Errors$1.OptionalChainingNoTemplate, startLoc);
+		if (state.optionalChainMember) this.raise(Errors.OptionalChainingNoTemplate, startLoc);
 		return this.finishNode(node, "TaggedTemplateExpression");
 	}
 	atPossibleAsyncArrow(base) {
@@ -25203,8 +25214,8 @@ var ExpressionParser = class extends LValParser {
 	}
 	finishCallExpression(node, optional) {
 		if (node.callee.type === "Import") {
-			if (node.arguments.length === 0 || node.arguments.length > 2) this.raise(Errors$1.ImportCallArity, node);
-			else for (const arg of node.arguments) if (arg.type === "SpreadElement") this.raise(Errors$1.ImportCallSpreadArgument, arg);
+			if (node.arguments.length === 0 || node.arguments.length > 2) this.raise(Errors.ImportCallArity, node);
+			else for (const arg of node.arguments) if (arg.type === "SpreadElement") this.raise(Errors.ImportCallSpreadArgument, arg);
 		}
 		return this.finishNode(node, optional ? "OptionalCallExpression" : "CallExpression");
 	}
@@ -25253,7 +25264,7 @@ var ExpressionParser = class extends LValParser {
 				if (this.match(6)) if (this.optionFlags & 1024) return this.parseImportCall(node);
 				else return this.finishNode(node, "Import");
 				else {
-					this.raise(Errors$1.UnsupportedImport, this.state.lastTokStartLoc);
+					this.raise(Errors.UnsupportedImport, this.state.lastTokStartLoc);
 					return this.finishNode(node, "Import");
 				}
 			case 74:
@@ -25286,10 +25297,10 @@ var ExpressionParser = class extends LValParser {
 				node.object = null;
 				const callee = node.callee = this.parseNoCallExpr();
 				if (callee.type === "MemberExpression") return this.finishNode(node, "BindExpression");
-				else throw this.raise(Errors$1.UnsupportedBind, callee);
+				else throw this.raise(Errors.UnsupportedBind, callee);
 			}
 			case 134:
-				this.raise(Errors$1.PrivateInExpectedIn, this.state.startLoc, { identifierName: this.state.value });
+				this.raise(Errors.PrivateInExpectedIn, this.state.startLoc, { identifierName: this.state.value });
 				return this.parsePrivateName();
 			case 29: return this.parseTopicReferenceThenEqualsSign(50, "%");
 			case 28: return this.parseTopicReferenceThenEqualsSign(40, "^");
@@ -25357,22 +25368,22 @@ var ExpressionParser = class extends LValParser {
 	}
 	finishTopicReference(node, startLoc, pipeProposal, tokenType) {
 		if (this.testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType)) {
-			if (!this.topicReferenceIsAllowedInCurrentContext()) this.raise(Errors$1.PipeTopicUnbound, startLoc);
+			if (!this.topicReferenceIsAllowedInCurrentContext()) this.raise(Errors.PipeTopicUnbound, startLoc);
 			this.registerTopicReference();
 			return this.finishNode(node, "TopicReference");
-		} else throw this.raise(Errors$1.PipeTopicUnconfiguredToken, startLoc, { token: tokenLabelName(tokenType) });
+		} else throw this.raise(Errors.PipeTopicUnconfiguredToken, startLoc, { token: tokenLabelName(tokenType) });
 	}
 	testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType) {
 		switch (pipeProposal) {
 			case "hack": return this.hasPlugin(["pipelineOperator", { topicToken: tokenLabelName(tokenType) }]);
-			default: throw this.raise(Errors$1.PipeTopicRequiresHackPipes, startLoc);
+			default: throw this.raise(Errors.PipeTopicRequiresHackPipes, startLoc);
 		}
 	}
 	parseAsyncArrowUnaryFunction(node) {
 		this.prodParam.enter(functionFlags(true, this.prodParam.hasYield));
 		const params = [this.parseIdentifier()];
 		this.prodParam.exit();
-		if (this.hasPrecedingLineBreak()) this.raise(Errors$1.LineTerminatorBeforeArrow, this.state.curPosition());
+		if (this.hasPrecedingLineBreak()) this.raise(Errors.LineTerminatorBeforeArrow, this.state.curPosition());
 		this.expect(15);
 		return this.parseArrowExpression(node, params, true);
 	}
@@ -25394,9 +25405,9 @@ var ExpressionParser = class extends LValParser {
 	parseSuper() {
 		const node = this.startNode();
 		this.next();
-		if (this.match(6) && !this.scope.allowDirectSuper) this.raise(Errors$1.SuperNotAllowed, node);
-		else if (!this.scope.allowSuper) this.raise(Errors$1.UnexpectedSuper, node);
-		if (!this.match(6) && !this.match(0) && !this.match(12)) this.raise(Errors$1.UnsupportedSuper, node);
+		if (this.match(6) && !this.scope.allowDirectSuper) this.raise(Errors.SuperNotAllowed, node);
+		else if (!this.scope.allowSuper) this.raise(Errors.UnexpectedSuper, node);
+		if (!this.match(6) && !this.match(0) && !this.match(12)) this.raise(Errors.UnsupportedSuper, node);
 		return this.finishNode(node, "Super");
 	}
 	parsePrivateName() {
@@ -25423,7 +25434,7 @@ var ExpressionParser = class extends LValParser {
 		node.meta = meta;
 		const containsEsc = this.state.containsEsc;
 		node.property = this.parseIdentifier(true);
-		if (node.property.name !== propertyName || containsEsc) this.raise(Errors$1.UnsupportedMetaProperty, node.property, {
+		if (node.property.name !== propertyName || containsEsc) this.raise(Errors.UnsupportedMetaProperty, node.property, {
 			target: meta.name,
 			onlyValidPropertyName: propertyName
 		});
@@ -25440,7 +25451,7 @@ var ExpressionParser = class extends LValParser {
 		} else {
 			const id = this.createIdentifierAt(this.startNodeAtNode(node), "import", this.state.lastTokStartLoc);
 			if (this.isContextual(97)) {
-				if (!this.inModule) this.raise(Errors$1.ImportMetaOutsideModule, id);
+				if (!this.inModule) this.raise(Errors.ImportMetaOutsideModule, id);
 				this.sawUnambiguousESM = true;
 			}
 			return this.parseMetaProperty(node, id, "meta");
@@ -25569,7 +25580,7 @@ var ExpressionParser = class extends LValParser {
 			const meta = this.createIdentifier(this.startNodeAtNode(node), "new");
 			this.next();
 			const metaProp = this.parseMetaProperty(node, meta, "target");
-			if (!this.scope.allowNewTarget) this.raise(Errors$1.UnexpectedNewTarget, metaProp);
+			if (!this.scope.allowNewTarget) this.raise(Errors.UnexpectedNewTarget, metaProp);
 			return metaProp;
 		}
 		return this.parseNew(node);
@@ -25587,16 +25598,16 @@ var ExpressionParser = class extends LValParser {
 		const isImport = this.match(79);
 		const callee = this.parseNoCallExpr();
 		node.callee = callee;
-		if (isImport && callee.type === "ImportExpression") this.raise(Errors$1.ImportCallNotNewExpression, callee, callee);
-		if (callee.type === "Import") this.raise(Errors$1.ImportCallNotNewExpression, callee);
-		if (callee.type === "Super") this.raise(Errors$1.SuperCallNotNewExpression, callee);
+		if (isImport && callee.type === "ImportExpression") this.raise(Errors.ImportCallNotNewExpression, callee, callee);
+		if (callee.type === "Import") this.raise(Errors.ImportCallNotNewExpression, callee);
+		if (callee.type === "Super") this.raise(Errors.SuperCallNotNewExpression, callee);
 	}
 	parseTemplateElement(isTagged) {
 		const { start, startLoc, end, value } = this.state;
 		const elemStart = start + 1;
 		const elem = this.startNodeAt(createPositionWithColumnOffset(startLoc, 1));
 		if (value === null) {
-			if (!isTagged) this.raise(Errors$1.InvalidEscapeSequenceTemplate, createPositionWithColumnOffset(this.state.firstInvalidTemplateEscapePos, 1));
+			if (!isTagged) this.raise(Errors.InvalidEscapeSequenceTemplate, createPositionWithColumnOffset(this.state.firstInvalidTemplateEscapePos, 1));
 		}
 		const isTail = this.match(20);
 		const endOffset = isTail ? -1 : -2;
@@ -25665,7 +25676,7 @@ var ExpressionParser = class extends LValParser {
 	parsePropertyDefinition(refExpressionErrors) {
 		const decorators = [];
 		if (this.match(22)) {
-			if (this.hasPlugin("decorators")) this.raise(Errors$1.UnsupportedPropertyDecorator, this.state.startLoc);
+			if (this.hasPlugin("decorators")) this.raise(Errors.UnsupportedPropertyDecorator, this.state.startLoc);
 			while (this.match(22)) decorators.push(this.parseDecorator());
 		}
 		const prop = this.startNode();
@@ -25698,7 +25709,7 @@ var ExpressionParser = class extends LValParser {
 				prop.kind = keyName;
 				if (this.match(51)) {
 					isGenerator = true;
-					this.raise(Errors$1.AccessorIsGenerator, this.state.curPosition(), { kind: keyName });
+					this.raise(Errors.AccessorIsGenerator, this.state.curPosition(), { kind: keyName });
 					this.next();
 				}
 				this.parsePropertyName(prop);
@@ -25715,8 +25726,8 @@ var ExpressionParser = class extends LValParser {
 	checkGetterSetterParams(method) {
 		const paramCount = this.getGetterSetterExpectedParamCount(method);
 		const params = this.getObjectOrClassMethodParams(method);
-		if (params.length !== paramCount) this.raise(method.kind === "get" ? Errors$1.BadGetterArity : Errors$1.BadSetterArity, method);
-		if (method.kind === "set" && params[params.length - 1]?.type === "RestElement") this.raise(Errors$1.BadSetterRestParameter, method);
+		if (params.length !== paramCount) this.raise(method.kind === "get" ? Errors.BadGetterArity : Errors.BadSetterArity, method);
+		if (method.kind === "set" && params[params.length - 1]?.type === "RestElement") this.raise(Errors.BadSetterRestParameter, method);
 	}
 	parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) {
 		if (isAccessor) {
@@ -25744,7 +25755,7 @@ var ExpressionParser = class extends LValParser {
 				const shorthandAssignLoc = this.state.startLoc;
 				if (refExpressionErrors != null) {
 					if (refExpressionErrors.shorthandAssignLoc === null) refExpressionErrors.shorthandAssignLoc = shorthandAssignLoc;
-				} else this.raise(Errors$1.InvalidCoverInitializedName, shorthandAssignLoc);
+				} else this.raise(Errors.InvalidCoverInitializedName, shorthandAssignLoc);
 				prop.value = this.parseMaybeDefault(startLoc, this.cloneIdentifier(prop.key));
 			} else prop.value = this.cloneIdentifier(prop.key);
 			prop.shorthand = true;
@@ -25782,7 +25793,7 @@ var ExpressionParser = class extends LValParser {
 					const privateKeyLoc = this.state.startLoc;
 					if (refExpressionErrors != null) {
 						if (refExpressionErrors.privateKeyLoc === null) refExpressionErrors.privateKeyLoc = privateKeyLoc;
-					} else this.raise(Errors$1.UnexpectedPrivateField, privateKeyLoc);
+					} else this.raise(Errors.UnexpectedPrivateField, privateKeyLoc);
 					key = this.parsePrivateName();
 					break;
 				}
@@ -25847,7 +25858,7 @@ var ExpressionParser = class extends LValParser {
 			this.prodParam.enter(this.prodParam.currentFlags() | 4);
 			node.body = this.parseBlock(true, false, (hasStrictModeDirective) => {
 				const nonSimple = !this.isSimpleParamList(node.params);
-				if (hasStrictModeDirective && nonSimple) this.raise(Errors$1.IllegalLanguageModeDirective, (node.kind === "method" || node.kind === "constructor") && !!node.key ? this.optionFlags & 256 ? node.key.loc.end : node.key : node);
+				if (hasStrictModeDirective && nonSimple) this.raise(Errors.IllegalLanguageModeDirective, (node.kind === "method" || node.kind === "constructor") && !!node.key ? this.optionFlags & 256 ? node.key.loc.end : node.key : node);
 				const strictModeChanged = !oldStrict && this.state.strict;
 				this.checkParams(node, !this.state.strict && !allowExpression && !isMethod && !nonSimple, allowExpression, strictModeChanged);
 				if (this.state.strict && node.id) this.checkIdentifier(node.id, 65, strictModeChanged);
@@ -25889,14 +25900,14 @@ var ExpressionParser = class extends LValParser {
 	parseExprListItem(close, allowEmpty, refExpressionErrors, allowPlaceholder) {
 		let elt;
 		if (this.match(8)) {
-			if (!allowEmpty) this.raise(Errors$1.UnexpectedToken, this.state.curPosition(), { unexpected: "," });
+			if (!allowEmpty) this.raise(Errors.UnexpectedToken, this.state.curPosition(), { unexpected: "," });
 			elt = null;
 		} else if (this.match(17)) {
 			const spreadNodeStartLoc = this.state.startLoc;
 			elt = this.parseParenItem(this.parseSpread(refExpressionErrors), spreadNodeStartLoc);
 		} else if (this.match(13)) {
 			this.expectPlugin("partialApplication");
-			if (!allowPlaceholder) this.raise(Errors$1.UnexpectedArgumentPlaceholder, this.state.startLoc);
+			if (!allowPlaceholder) this.raise(Errors.UnexpectedArgumentPlaceholder, this.state.startLoc);
 			const node = this.startNode();
 			this.next();
 			elt = this.finishNode(node, "ArgumentPlaceholder");
@@ -25934,30 +25945,30 @@ var ExpressionParser = class extends LValParser {
 		if (word.length > 10) return;
 		if (!canBeReservedWord(word)) return;
 		if (checkKeywords && isKeyword(word)) {
-			this.raise(Errors$1.UnexpectedKeyword, startLoc, { keyword: word });
+			this.raise(Errors.UnexpectedKeyword, startLoc, { keyword: word });
 			return;
 		}
 		if ((!this.state.strict ? isReservedWord : isBinding ? isStrictBindReservedWord : isStrictReservedWord)(word, this.inModule)) {
-			this.raise(Errors$1.UnexpectedReservedWord, startLoc, { reservedWord: word });
+			this.raise(Errors.UnexpectedReservedWord, startLoc, { reservedWord: word });
 			return;
 		} else if (word === "yield") {
 			if (this.prodParam.hasYield) {
-				this.raise(Errors$1.YieldBindingIdentifier, startLoc);
+				this.raise(Errors.YieldBindingIdentifier, startLoc);
 				return;
 			}
 		} else if (word === "await") {
 			if (this.prodParam.hasAwait) {
-				this.raise(Errors$1.AwaitBindingIdentifier, startLoc);
+				this.raise(Errors.AwaitBindingIdentifier, startLoc);
 				return;
 			}
 			if (this.scope.inStaticBlock) {
-				this.raise(Errors$1.AwaitBindingIdentifierInStaticBlock, startLoc);
+				this.raise(Errors.AwaitBindingIdentifierInStaticBlock, startLoc);
 				return;
 			}
 			this.expressionScope.recordAsyncArrowParametersError(startLoc);
 		} else if (word === "arguments") {
 			if (this.scope.inClassAndNotInNonArrowFunction) {
-				this.raise(Errors$1.ArgumentsInClass, startLoc);
+				this.raise(Errors.ArgumentsInClass, startLoc);
 				return;
 			}
 		}
@@ -25971,8 +25982,8 @@ var ExpressionParser = class extends LValParser {
 		const startIndex = startLoc.index;
 		this.setLoc(startLoc);
 		const node = this.startNodeAt(startLoc);
-		this.expressionScope.recordParameterInitializerError(Errors$1.AwaitExpressionFormalParameter, startIndex);
-		if (this.eat(51)) this.raise(Errors$1.ObsoleteAwaitStar, startLoc);
+		this.expressionScope.recordParameterInitializerError(Errors.AwaitExpressionFormalParameter, startIndex);
+		if (this.eat(51)) this.raise(Errors.ObsoleteAwaitStar, startLoc);
 		if (!this.scope.inFunction && !(this.optionFlags & 1)) if (this.isAmbiguousPrefixOrIdentifier()) this.ambiguousScriptDifferentAst = true;
 		else this.sawUnambiguousESM = true;
 		if (!soloAwait) node.argument = this.parseMaybeUnary(null, true);
@@ -25986,7 +25997,7 @@ var ExpressionParser = class extends LValParser {
 	parseYield(startLoc) {
 		this.setLoc(startLoc);
 		const node = this.startNodeAt(startLoc);
-		this.expressionScope.recordParameterInitializerError(Errors$1.YieldInParameter, startLoc.index);
+		this.expressionScope.recordParameterInitializerError(Errors.YieldInParameter, startLoc.index);
 		let delegating = false;
 		let argument = null;
 		if (!this.hasPrecedingLineBreak()) {
@@ -26010,8 +26021,8 @@ var ExpressionParser = class extends LValParser {
 	parseImportCall(node) {
 		this.next();
 		const args = this.parseCallExpressionArguments();
-		if (args.length === 0 || args.length > 2) this.raise(Errors$1.ImportCallArity, node, node);
-		else for (const arg of args) if (arg.type === "SpreadElement") this.raise(Errors$1.ImportCallSpreadArgument, arg, node);
+		if (args.length === 0 || args.length > 2) this.raise(Errors.ImportCallArity, node, node);
+		else for (const arg of args) if (arg.type === "SpreadElement") this.raise(Errors.ImportCallSpreadArgument, arg, node);
 		node.source = args[0];
 		node.options = args[1] ?? null;
 		return this.finishNode(node, "ImportExpression");
@@ -26071,7 +26082,7 @@ var ExpressionParser = class extends LValParser {
 			this.next();
 			ret = this.parseAwait(startLoc, true);
 			const nextOp = this.state.type;
-			if (tokenIsOperator(nextOp) && nextOp !== 35 && (this.prodParam.hasIn || nextOp !== 54)) this.raise(Errors$1.PipelineUnparenthesized, startLoc);
+			if (tokenIsOperator(nextOp) && nextOp !== 35 && (this.prodParam.hasIn || nextOp !== 54)) this.raise(Errors.PipelineUnparenthesized, startLoc);
 		} else {
 			this.state.canStartArrow = true;
 			ret = this.parseExprOp(this.parseMaybeUnaryOrPrivate(), startLoc, prec);
@@ -26118,7 +26129,7 @@ function createExportedTokens(tokens) {
 	for (let i = 0; i < tokens.length; i++) {
 		const token = tokens[i];
 		const { type } = token;
-		if (typeof type === "number") token.type = getExportedToken$1(type);
+		if (typeof type === "number") token.type = getExportedToken(type);
 	}
 	return tokens;
 }
@@ -26134,7 +26145,7 @@ var StatementParser = class extends ExpressionParser {
 		program.interpreter = this.parseInterpreterDirective();
 		this.parseBlockBody(program, true, true, end);
 		if (this.inModule) {
-			if (!(this.optionFlags & 64) && this.scope.undefinedExports.size > 0) for (const [localName, at] of Array.from(this.scope.undefinedExports)) this.raise(Errors$1.ModuleExportUndefined, at, { localName });
+			if (!(this.optionFlags & 64) && this.scope.undefinedExports.size > 0) for (const [localName, at] of Array.from(this.scope.undefinedExports)) this.raise(Errors.ModuleExportUndefined, at, { localName });
 			this.addExtra(program, "topLevelAwait", this.state.hasTopLevelAwait);
 		}
 		let finishedProgram;
@@ -26259,7 +26270,7 @@ var StatementParser = class extends ExpressionParser {
 			case 87: return this.parseForStatement(node);
 			case 64:
 				if (this.lookaheadCharCode() === 46) break;
-				if (!allowFunctionDeclaration) this.raise(this.state.strict ? Errors$1.StrictFunction : this.options.annexB ? Errors$1.SloppyFunctionAnnexB : Errors$1.SloppyFunction, this.state.startLoc);
+				if (!allowFunctionDeclaration) this.raise(this.state.strict ? Errors.StrictFunction : this.options.annexB ? Errors.SloppyFunctionAnnexB : Errors.SloppyFunction, this.state.startLoc);
 				return this.parseFunctionStatement(node, false, !allowDeclaration && allowFunctionDeclaration);
 			case 76:
 				if (!allowDeclaration) this.unexpected();
@@ -26271,17 +26282,17 @@ var StatementParser = class extends ExpressionParser {
 			case 69: return this.parseTryStatement(node);
 			case 92:
 				if (this.isAwaitUsing()) {
-					if (!this.allowsUsing()) this.raise(Errors$1.UnexpectedUsingDeclaration, node);
-					else if (!allowDeclaration) this.raise(Errors$1.UnexpectedLexicalDeclaration, node);
-					else if (!this.recordAwaitIfAllowed()) this.raise(Errors$1.AwaitUsingNotInAsyncContext, node);
+					if (!this.allowsUsing()) this.raise(Errors.UnexpectedUsingDeclaration, node);
+					else if (!allowDeclaration) this.raise(Errors.UnexpectedLexicalDeclaration, node);
+					else if (!this.recordAwaitIfAllowed()) this.raise(Errors.AwaitUsingNotInAsyncContext, node);
 					this.next();
 					return this.parseVarStatement(node, "await using");
 				}
 				break;
 			case 103:
 				if (this.state.containsEsc || !this.hasInLineFollowingBindingIdentifierOrBrace()) break;
-				if (!this.allowsUsing()) this.raise(Errors$1.UnexpectedUsingDeclaration, this.state.startLoc);
-				else if (!allowDeclaration) this.raise(Errors$1.UnexpectedLexicalDeclaration, this.state.startLoc);
+				if (!this.allowsUsing()) this.raise(Errors.UnexpectedUsingDeclaration, this.state.startLoc);
+				else if (!allowDeclaration) this.raise(Errors.UnexpectedLexicalDeclaration, this.state.startLoc);
 				return this.parseVarStatement(node, "using");
 			case 96: {
 				if (this.state.containsEsc) break;
@@ -26292,7 +26303,7 @@ var StatementParser = class extends ExpressionParser {
 					if (!this.chStartsBindingIdentifier(nextCh, next) && nextCh !== 123) break;
 				}
 			}
-			case 71: if (!allowDeclaration) this.raise(Errors$1.UnexpectedLexicalDeclaration, this.state.startLoc);
+			case 71: if (!allowDeclaration) this.raise(Errors.UnexpectedLexicalDeclaration, this.state.startLoc);
 			case 70: {
 				const kind = this.state.value;
 				return this.parseVarStatement(node, kind);
@@ -26306,7 +26317,7 @@ var StatementParser = class extends ExpressionParser {
 				if (nextTokenCharCode === 40 || nextTokenCharCode === 46) break;
 			}
 			case 78: {
-				if (!(this.optionFlags & 8) && !topLevel) this.raise(Errors$1.UnexpectedImportExport, this.state.startLoc);
+				if (!(this.optionFlags & 8) && !topLevel) this.raise(Errors.UnexpectedImportExport, this.state.startLoc);
 				this.next();
 				let result;
 				if (startType === 79) result = this.parseImport(node);
@@ -26315,7 +26326,7 @@ var StatementParser = class extends ExpressionParser {
 				return result;
 			}
 			default: if (this.isAsyncFunction()) {
-				if (!allowDeclaration) this.raise(Errors$1.AsyncFunctionInSingleStatementContext, this.state.startLoc);
+				if (!allowDeclaration) this.raise(Errors.AsyncFunctionInSingleStatementContext, this.state.startLoc);
 				this.next();
 				return this.parseFunctionStatement(node, true, !allowDeclaration && allowFunctionDeclaration);
 			}
@@ -26326,12 +26337,12 @@ var StatementParser = class extends ExpressionParser {
 		else return this.parseExpressionStatement(node, expr, decorators);
 	}
 	assertModuleNodeAllowed(node) {
-		if (!(this.optionFlags & 8) && !this.inModule) this.raise(Errors$1.ImportOutsideModule, node);
+		if (!(this.optionFlags & 8) && !this.inModule) this.raise(Errors.ImportOutsideModule, node);
 	}
 	maybeTakeDecorators(maybeDecorators, classNode, exportNode) {
 		if (maybeDecorators) {
 			if (classNode.decorators?.length) {
-				this.raise(Errors$1.DecoratorsBeforeAfterExport, classNode.decorators[0]);
+				this.raise(Errors.DecoratorsBeforeAfterExport, classNode.decorators[0]);
 				classNode.decorators.unshift(...maybeDecorators);
 			} else classNode.decorators = maybeDecorators;
 			this.resetStartLocationFromNode(classNode, maybeDecorators[0]);
@@ -26349,7 +26360,7 @@ var StatementParser = class extends ExpressionParser {
 		while (this.match(22));
 		if (this.match(78)) {
 			if (!allowExport) this.unexpected();
-		} else if (!this.canHaveLeadingDecorator()) throw this.raise(Errors$1.UnexpectedLeadingDecorator, this.state.startLoc);
+		} else if (!this.canHaveLeadingDecorator()) throw this.raise(Errors.UnexpectedLeadingDecorator, this.state.startLoc);
 		return decorators;
 	}
 	parseDecorator() {
@@ -26367,7 +26378,7 @@ var StatementParser = class extends ExpressionParser {
 				expr = this.wrapParenthesis(startLoc, expr);
 				const paramsStartLoc = this.state.startLoc;
 				node.expression = this.parseMaybeDecoratorArguments(expr, startLoc);
-				if (node.expression !== expr) this.raise(Errors$1.DecoratorArgumentsOutsideParentheses, paramsStartLoc);
+				if (node.expression !== expr) this.raise(Errors.DecoratorArgumentsOutsideParentheses, paramsStartLoc);
 			} else {
 				expr = this.parseIdentifier(false);
 				while (this.eat(12)) {
@@ -26419,7 +26430,7 @@ var StatementParser = class extends ExpressionParser {
 		}
 		if (i === this.state.labels.length) {
 			const type = isBreak ? "BreakStatement" : "ContinueStatement";
-			this.raise(Errors$1.IllegalBreakContinue, node, { type });
+			this.raise(Errors.IllegalBreakContinue, node, { type });
 		}
 	}
 	parseDebuggerStatement(node) {
@@ -26467,14 +26478,14 @@ var StatementParser = class extends ExpressionParser {
 				let kind;
 				if (startsWithAwaitUsing) {
 					kind = "await using";
-					if (!this.recordAwaitIfAllowed()) this.raise(Errors$1.AwaitUsingNotInAsyncContext, this.state.startLoc);
+					if (!this.recordAwaitIfAllowed()) this.raise(Errors.AwaitUsingNotInAsyncContext, this.state.startLoc);
 					this.next();
 				} else kind = this.state.value;
 				this.next();
 				this.parseVar(initNode, true, kind);
 				const init = this.finishNode(initNode, "VariableDeclaration");
 				const isForIn = this.match(54);
-				if (isForIn && starsWithUsingDeclaration) this.raise(Errors$1.ForInUsing, init);
+				if (isForIn && starsWithUsingDeclaration) this.raise(Errors.ForInUsing, init);
 				if ((isForIn || this.isContextual(98)) && init.declarations.length === 1) return this.parseForIn(node, init, awaitAt);
 				if (awaitAt !== null) this.unexpected(awaitAt);
 				return this.parseFor(node, init);
@@ -26485,8 +26496,8 @@ var StatementParser = class extends ExpressionParser {
 		const init = this.parseExpression(true, refExpressionErrors);
 		const isForOf = this.isContextual(98);
 		if (isForOf) {
-			if (startsWithLet) this.raise(Errors$1.ForOfLet, init);
-			if (awaitAt === null && startsWithAsync && init.type === "Identifier") this.raise(Errors$1.ForOfAsync, init);
+			if (startsWithLet) this.raise(Errors.ForOfLet, init);
+			if (awaitAt === null && startsWithAsync && init.type === "Identifier") this.raise(Errors.ForOfAsync, init);
 		}
 		if (isForOf || this.match(54)) {
 			this.checkDestructuringPrivate(refExpressionErrors);
@@ -26510,7 +26521,7 @@ var StatementParser = class extends ExpressionParser {
 		return this.finishNode(node, "IfStatement");
 	}
 	parseReturnStatement(node) {
-		if (!this.prodParam.hasReturn) this.raise(Errors$1.IllegalReturn, this.state.startLoc);
+		if (!this.prodParam.hasReturn) this.raise(Errors.IllegalReturn, this.state.startLoc);
 		this.next();
 		if (this.isLineTerminator()) node.argument = null;
 		else {
@@ -26535,7 +26546,7 @@ var StatementParser = class extends ExpressionParser {
 			this.next();
 			if (isCase) cur.test = this.parseExpression();
 			else {
-				if (sawDefault) this.raise(Errors$1.MultipleDefaultsInSwitch, this.state.lastTokStartLoc);
+				if (sawDefault) this.raise(Errors.MultipleDefaultsInSwitch, this.state.lastTokStartLoc);
 				sawDefault = true;
 				cur.test = null;
 			}
@@ -26550,7 +26561,7 @@ var StatementParser = class extends ExpressionParser {
 	}
 	parseThrowStatement(node) {
 		this.next();
-		if (this.hasPrecedingLineBreak()) this.raise(Errors$1.NewlineAfterThrow, this.state.lastTokEndLoc);
+		if (this.hasPrecedingLineBreak()) this.raise(Errors.NewlineAfterThrow, this.state.lastTokEndLoc);
 		node.argument = this.parseExpression();
 		this.semicolon();
 		return this.finishNode(node, "ThrowStatement");
@@ -26581,7 +26592,7 @@ var StatementParser = class extends ExpressionParser {
 			node.handler = this.finishNode(clause, "CatchClause");
 		}
 		node.finalizer = this.eat(63) ? this.parseBlock() : null;
-		if (!node.handler && !node.finalizer) this.raise(Errors$1.NoCatchOrFinally, node);
+		if (!node.handler && !node.finalizer) this.raise(Errors.NoCatchOrFinally, node);
 		return this.finishNode(node, "TryStatement");
 	}
 	parseVarStatement(node, kind, allowMissingInitializer = false) {
@@ -26599,7 +26610,7 @@ var StatementParser = class extends ExpressionParser {
 		return this.finishNode(node, "WhileStatement");
 	}
 	parseWithStatement(node) {
-		if (this.state.strict) this.raise(Errors$1.StrictWith, this.state.startLoc);
+		if (this.state.strict) this.raise(Errors.StrictWith, this.state.startLoc);
 		this.next();
 		node.object = this.parseHeaderExpression();
 		node.body = this.parseStatement();
@@ -26610,7 +26621,7 @@ var StatementParser = class extends ExpressionParser {
 		return this.finishNode(node, "EmptyStatement");
 	}
 	parseLabeledStatement(node, maybeName, expr, flags) {
-		for (const label of this.state.labels) if (label.name === maybeName) this.raise(Errors$1.LabelRedeclaration, expr, { labelName: maybeName });
+		for (const label of this.state.labels) if (label.name === maybeName) this.raise(Errors.LabelRedeclaration, expr, { labelName: maybeName });
 		const kind = tokenIsLoop(this.state.type) ? 1 : this.match(67) ? 2 : null;
 		for (let i = this.state.labels.length - 1; i >= 0; i--) {
 			const label = this.state.labels[i];
@@ -26694,8 +26705,8 @@ var StatementParser = class extends ExpressionParser {
 		if (isForIn) {
 			if (awaitAt !== null) this.unexpected(awaitAt);
 		} else node.await = awaitAt !== null;
-		if (init.type === "VariableDeclaration" && init.declarations[0].init != null && (!isForIn || !this.options.annexB || this.state.strict || init.kind !== "var" || init.declarations[0].id.type !== "Identifier")) this.raise(Errors$1.ForInOfLoopInitializer, init, { type: isForIn ? "ForInStatement" : "ForOfStatement" });
-		if (init.type === "AssignmentPattern") this.raise(Errors$1.InvalidLhs, init, { ancestor: { type: "ForStatement" } });
+		if (init.type === "VariableDeclaration" && init.declarations[0].init != null && (!isForIn || !this.options.annexB || this.state.strict || init.kind !== "var" || init.declarations[0].id.type !== "Identifier")) this.raise(Errors.ForInOfLoopInitializer, init, { type: isForIn ? "ForInStatement" : "ForOfStatement" });
+		if (init.type === "AssignmentPattern") this.raise(Errors.InvalidLhs, init, { ancestor: { type: "ForStatement" } });
 		node.left = init;
 		node.right = isForIn ? this.parseExpression() : this.parseMaybeAssignAllowIn();
 		this.expect(7);
@@ -26712,8 +26723,8 @@ var StatementParser = class extends ExpressionParser {
 			this.parseVarId(decl, kind);
 			decl.init = !this.eat(25) ? null : isFor ? this.parseMaybeAssignDisallowIn() : this.parseMaybeAssignAllowIn();
 			if (decl.init === null && !allowMissingInitializer) {
-				if (decl.id.type !== "Identifier" && !(isFor && (this.match(54) || this.isContextual(98)))) this.raise(Errors$1.DeclarationMissingInitializer, this.state.lastTokEndLoc, { kind: "destructuring" });
-				else if ((kind === "const" || kind === "using" || kind === "await using") && !(this.match(54) || this.isContextual(98))) this.raise(Errors$1.DeclarationMissingInitializer, this.state.lastTokEndLoc, { kind });
+				if (decl.id.type !== "Identifier" && !(isFor && (this.match(54) || this.isContextual(98)))) this.raise(Errors.DeclarationMissingInitializer, this.state.lastTokEndLoc, { kind: "destructuring" });
+				else if ((kind === "const" || kind === "using" || kind === "await using") && !(this.match(54) || this.isContextual(98))) this.raise(Errors.DeclarationMissingInitializer, this.state.lastTokEndLoc, { kind });
 			}
 			declarations.push(this.finishNode(decl, "VariableDeclarator"));
 			if (!this.eat(8)) break;
@@ -26723,8 +26734,8 @@ var StatementParser = class extends ExpressionParser {
 	parseVarId(decl, kind) {
 		const id = this.parseBindingAtom();
 		if (kind === "using" || kind === "await using") {
-			if (id.type === "ArrayPattern" || id.type === "ObjectPattern") this.raise(Errors$1.UsingDeclarationHasBindingPattern, id);
-		} else if (id.type === "VoidPattern") this.raise(Errors$1.UnexpectedVoidPattern, id);
+			if (id.type === "ArrayPattern" || id.type === "ObjectPattern") this.raise(Errors.UsingDeclarationHasBindingPattern, id);
+		} else if (id.type === "VoidPattern") this.raise(Errors.UnexpectedVoidPattern, id);
 		this.checkLVal(id, { type: "VariableDeclarator" }, kind === "var" ? 5 : 8201);
 		decl.id = id;
 	}
@@ -26738,7 +26749,7 @@ var StatementParser = class extends ExpressionParser {
 		const isAsync = !!(flags & 8);
 		this.initFunction(node, isAsync);
 		if (this.match(51)) {
-			if (hangingDeclaration) this.raise(Errors$1.GeneratorInSingleStatementContext, this.state.startLoc);
+			if (hangingDeclaration) this.raise(Errors.GeneratorInSingleStatementContext, this.state.startLoc);
 			this.next();
 			node.generator = true;
 		}
@@ -26799,7 +26810,7 @@ var StatementParser = class extends ExpressionParser {
 		this.expect(2);
 		while (!this.match(4)) {
 			if (this.eat(9)) {
-				if (decorators.length > 0) throw this.raise(Errors$1.DecoratorSemicolon, this.state.lastTokEndLoc);
+				if (decorators.length > 0) throw this.raise(Errors.DecoratorSemicolon, this.state.lastTokEndLoc);
 				continue;
 			}
 			if (this.match(22)) {
@@ -26813,14 +26824,10 @@ var StatementParser = class extends ExpressionParser {
 				decorators = [];
 			}
 			this.parseClassMember(classBody, member, state);
-			if (member.decorators && member.decorators.length > 0) {
-				if (this.hasPlugin("typescript") && (this.hasPlugin("estree") ? member.type === "TSAbstractMethodDefinition" : member.type === "TSDeclareMethod")) this.raise(Errors$1.DecoratorAbstractMethod, member);
-				if (member.kind === "constructor") this.raise(Errors$1.DecoratorConstructor, member);
-			}
 		}
 		this.state.strict = oldStrict;
 		this.next();
-		if (decorators.length) throw this.raise(Errors$1.TrailingDecorator, this.state.startLoc);
+		if (decorators.length) throw this.raise(Errors.TrailingDecorator, this.state.startLoc);
 		this.classScope.exit();
 		return this.finishNode(classBody, "ClassBody");
 	}
@@ -26875,7 +26882,7 @@ var StatementParser = class extends ExpressionParser {
 				this.pushClassPrivateMethod(classBody, privateMethod, true, false);
 				return;
 			}
-			if (this.isNonstaticConstructor(publicMethod)) this.raise(Errors$1.ConstructorIsGenerator, publicMethod.key);
+			if (this.isNonstaticConstructor(publicMethod)) this.raise(Errors.ConstructorIsGenerator, publicMethod.key);
 			this.pushClassMethod(classBody, publicMethod, true, false, false, false);
 			return;
 		}
@@ -26895,8 +26902,9 @@ var StatementParser = class extends ExpressionParser {
 			let allowsDirectSuper = false;
 			if (isConstructor) {
 				publicMethod.kind = "constructor";
-				if (state.hadConstructor && !this.hasPlugin("typescript")) this.raise(Errors$1.DuplicateConstructor, key);
-				if (isConstructor && this.hasPlugin("typescript") && member.override) this.raise(Errors$1.OverrideOnConstructor, key);
+				if (publicMethod.decorators && publicMethod.decorators.length > 0) this.raise(Errors.DecoratorConstructor, member);
+				if (state.hadConstructor && !this.hasPlugin("typescript")) this.raise(Errors.DuplicateConstructor, key);
+				if (isConstructor && this.hasPlugin("typescript") && member.override) this.raise(Errors.OverrideOnConstructor, key);
 				state.hadConstructor = true;
 				allowsDirectSuper = state.hadSuperClass;
 			}
@@ -26913,7 +26921,7 @@ var StatementParser = class extends ExpressionParser {
 			this.parsePostMemberNameModifiers(publicMember);
 			if (isPrivate) this.pushClassPrivateMethod(classBody, privateMethod, isGenerator, true);
 			else {
-				if (this.isNonstaticConstructor(publicMethod)) this.raise(Errors$1.ConstructorIsAsync, publicMethod.key);
+				if (this.isNonstaticConstructor(publicMethod)) this.raise(Errors.ConstructorIsAsync, publicMethod.key);
 				this.pushClassMethod(classBody, publicMethod, isGenerator, true, false, false);
 			}
 		} else if ((maybeContextualKw === "get" || maybeContextualKw === "set") && !(this.match(51) && this.isLineTerminator())) {
@@ -26923,7 +26931,7 @@ var StatementParser = class extends ExpressionParser {
 			this.parseClassElementName(publicMethod);
 			if (isPrivate) this.pushClassPrivateMethod(classBody, privateMethod, false, false);
 			else {
-				if (this.isNonstaticConstructor(publicMethod)) this.raise(Errors$1.ConstructorIsAccessor, publicMethod.key);
+				if (this.isNonstaticConstructor(publicMethod)) this.raise(Errors.ConstructorIsAccessor, publicMethod.key);
 				this.pushClassMethod(classBody, publicMethod, false, false, false, false);
 			}
 			this.checkGetterSetterParams(publicMethod);
@@ -26939,9 +26947,9 @@ var StatementParser = class extends ExpressionParser {
 	}
 	parseClassElementName(member) {
 		const { type, value } = this.state;
-		if ((type === 128 || type === 130) && member.static && value === "prototype") this.raise(Errors$1.StaticPrototype, this.state.startLoc);
+		if ((type === 128 || type === 130) && member.static && value === "prototype") this.raise(Errors.StaticPrototype, this.state.startLoc);
 		if (type === 134) {
-			if (value === "constructor") this.raise(Errors$1.ConstructorClassPrivateField, this.state.startLoc);
+			if (value === "constructor") this.raise(Errors.ConstructorClassPrivateField, this.state.startLoc);
 			const key = this.parsePrivateName();
 			member.key = key;
 			return key;
@@ -26960,10 +26968,10 @@ var StatementParser = class extends ExpressionParser {
 		this.scope.exit();
 		this.state.labels = oldLabels;
 		classBody.body.push(this.finishNode(member, "StaticBlock"));
-		if (member.decorators?.length) this.raise(Errors$1.DecoratorStaticBlock, member);
+		if (member.decorators?.length) this.raise(Errors.DecoratorStaticBlock, member);
 	}
 	pushClassProperty(classBody, prop) {
-		if (!prop.computed && this.nameIsConstructor(prop.key)) this.raise(Errors$1.ConstructorClassField, prop.key);
+		if (!prop.computed && this.nameIsConstructor(prop.key)) this.raise(Errors.ConstructorClassField, prop.key);
 		classBody.body.push(this.parseClassProperty(prop));
 	}
 	pushClassPrivateProperty(classBody, prop) {
@@ -26972,7 +26980,7 @@ var StatementParser = class extends ExpressionParser {
 		this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), 0, node.key.start);
 	}
 	pushClassAccessorProperty(classBody, prop, isPrivate) {
-		if (!isPrivate && !prop.computed && this.nameIsConstructor(prop.key)) this.raise(Errors$1.ConstructorClassField, prop.key);
+		if (!isPrivate && !prop.computed && this.nameIsConstructor(prop.key)) this.raise(Errors.ConstructorClassField, prop.key);
 		const node = this.parseClassAccessorProperty(prop);
 		classBody.body.push(node);
 		if (isPrivate) this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), 0, node.key.start);
@@ -27019,7 +27027,7 @@ var StatementParser = class extends ExpressionParser {
 			node.id = this.parseIdentifier();
 			if (isStatement) this.declareNameFromIdentifier(node.id, bindingType);
 		} else if (optionalId || !isStatement) node.id = null;
-		else throw this.raise(Errors$1.MissingClassName, this.state.startLoc);
+		else throw this.raise(Errors.MissingClassName, this.state.startLoc);
 	}
 	parseClassSuper(node) {
 		if (this.eat(77)) {
@@ -27037,7 +27045,7 @@ var StatementParser = class extends ExpressionParser {
 		const isFromRequired = hasDefault || hasStar;
 		if (hasStar && !hasNamespace) {
 			if (hasDefault) this.unexpected();
-			if (decorators) throw this.raise(Errors$1.UnsupportedDecoratorExport, node);
+			if (decorators) throw this.raise(Errors.UnsupportedDecoratorExport, node);
 			this.parseExportFrom(node, true);
 			this.sawUnambiguousESM = true;
 			return this.finishNode(node, "ExportAllDeclaration");
@@ -27048,14 +27056,14 @@ var StatementParser = class extends ExpressionParser {
 		let hasDeclaration;
 		if (isFromRequired || hasSpecifiers) {
 			hasDeclaration = false;
-			if (decorators) throw this.raise(Errors$1.UnsupportedDecoratorExport, node);
+			if (decorators) throw this.raise(Errors.UnsupportedDecoratorExport, node);
 			this.parseExportFrom(node, isFromRequired);
 		} else hasDeclaration = this.maybeParseExportDeclaration(node);
 		if (isFromRequired || hasSpecifiers || hasDeclaration) {
 			const node2 = node;
 			this.checkExport(node2, true, false, !!node2.source);
 			if (node2.declaration?.type === "ClassDeclaration") this.maybeTakeDecorators(decorators, node2.declaration, node2);
-			else if (decorators) throw this.raise(Errors$1.UnsupportedDecoratorExport, node);
+			else if (decorators) throw this.raise(Errors.UnsupportedDecoratorExport, node);
 			this.sawUnambiguousESM = true;
 			return this.finishNode(node2, "ExportNamedDeclaration");
 		}
@@ -27064,14 +27072,14 @@ var StatementParser = class extends ExpressionParser {
 			const decl = this.parseExportDefaultExpression();
 			node2.declaration = decl;
 			if (decl.type === "ClassDeclaration") this.maybeTakeDecorators(decorators, decl, node2);
-			else if (decorators) throw this.raise(Errors$1.UnsupportedDecoratorExport, node);
+			else if (decorators) throw this.raise(Errors.UnsupportedDecoratorExport, node);
 			this.checkExport(node2, true, true);
 			this.sawUnambiguousESM = true;
 			return this.finishNode(node2, "ExportDefaultDeclaration");
 		}
 		throw this.unexpected(null, 2);
 	}
-	eatExportStar(node) {
+	eatExportStar(_) {
 		return this.eat(51);
 	}
 	maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier) {
@@ -27136,7 +27144,7 @@ var StatementParser = class extends ExpressionParser {
 		}
 		if (this.match(76)) return this.parseClass(expr, true, true);
 		if (this.match(22)) return this.parseClass(this.maybeTakeDecorators(this.parseDecorators(false), this.startNode()), true, true);
-		if (this.match(71) || this.match(70) || this.isLet() || this.isUsing() || this.isAwaitUsing()) throw this.raise(Errors$1.UnsupportedDefaultExport, this.state.startLoc);
+		if (this.match(71) || this.match(70) || this.isLet() || this.isUsing() || this.isAwaitUsing()) throw this.raise(Errors.UnsupportedDefaultExport, this.state.startLoc);
 		const res = this.parseMaybeAssignAllowIn();
 		this.semicolon();
 		return res;
@@ -27182,11 +27190,11 @@ var StatementParser = class extends ExpressionParser {
 			if (this.hasPlugin("decorators")) return true;
 		}
 		if (this.isUsing()) {
-			this.raise(Errors$1.UsingDeclarationExport, this.state.startLoc);
+			this.raise(Errors.UsingDeclarationExport, this.state.startLoc);
 			return true;
 		}
 		if (this.isAwaitUsing()) {
-			this.raise(Errors$1.UsingDeclarationExport, this.state.startLoc);
+			this.raise(Errors.UsingDeclarationExport, this.state.startLoc);
 			return true;
 		}
 		return type === 70 || type === 71 || type === 64 || type === 76 || this.isLet() || this.isAsyncFunction();
@@ -27197,7 +27205,7 @@ var StatementParser = class extends ExpressionParser {
 				this.checkDuplicateExports(node, "default");
 				if (this.hasPlugin("exportDefaultFrom")) {
 					const declaration = node.declaration;
-					if (declaration.type === "Identifier" && declaration.name === "from" && declaration.end - declaration.start === 4 && !declaration.extra?.parenthesized) this.raise(Errors$1.ExportDefaultFromAsIdentifier, declaration);
+					if (declaration.type === "Identifier" && declaration.name === "from" && declaration.end - declaration.start === 4 && !declaration.extra?.parenthesized) this.raise(Errors.ExportDefaultFromAsIdentifier, declaration);
 				}
 			} else if (node.specifiers?.length) for (const specifier of node.specifiers) {
 				const { exported } = specifier;
@@ -27205,7 +27213,7 @@ var StatementParser = class extends ExpressionParser {
 				this.checkDuplicateExports(specifier, exportName);
 				if (!isFrom && specifier.local) {
 					const { local } = specifier;
-					if (local.type !== "Identifier") this.raise(Errors$1.ExportBindingIsString, specifier, {
+					if (local.type !== "Identifier") this.raise(Errors.ExportBindingIsString, specifier, {
 						localName: local.value,
 						exportName
 					});
@@ -27235,8 +27243,8 @@ var StatementParser = class extends ExpressionParser {
 		else if (node.type === "AssignmentPattern") this.checkDeclaration(node.left);
 	}
 	checkDuplicateExports(node, exportName) {
-		if (this.exportedIdentifiers.has(exportName)) if (exportName === "default") this.raise(Errors$1.DuplicateDefaultExport, node);
-		else this.raise(Errors$1.DuplicateExport, node, { exportName });
+		if (this.exportedIdentifiers.has(exportName)) if (exportName === "default") this.raise(Errors.DuplicateDefaultExport, node);
+		else this.raise(Errors.DuplicateExport, node, { exportName });
 		this.exportedIdentifiers.add(exportName);
 	}
 	parseExportSpecifiers(isInTypeExport) {
@@ -27267,7 +27275,7 @@ var StatementParser = class extends ExpressionParser {
 		if (this.match(130)) {
 			const result = this.parseStringLiteral(this.state.value);
 			const surrogate = loneSurrogate.exec(result.value);
-			if (surrogate) this.raise(Errors$1.ModuleExportNameHasLoneSurrogate, result, { surrogateCharCode: surrogate[0].charCodeAt(0) });
+			if (surrogate) this.raise(Errors.ModuleExportNameHasLoneSurrogate, result, { surrogateCharCode: surrogate[0].charCodeAt(0) });
 			return result;
 		}
 		return this.parseIdentifier(true);
@@ -27276,9 +27284,9 @@ var StatementParser = class extends ExpressionParser {
 		const { specifiers } = node;
 		const singleBindingType = specifiers.length === 1 ? specifiers[0].type : null;
 		if (node.phase === "source") {
-			if (singleBindingType !== "ImportDefaultSpecifier") this.raise(Errors$1.SourcePhaseImportRequiresDefault, specifiers[0]);
+			if (singleBindingType !== "ImportDefaultSpecifier") this.raise(Errors.SourcePhaseImportRequiresDefault, specifiers[0]);
 		} else if (node.phase === "defer") {
-			if (singleBindingType !== "ImportNamespaceSpecifier") this.raise(Errors$1.DeferImportRequiresNamespace, specifiers[0]);
+			if (singleBindingType !== "ImportNamespaceSpecifier") this.raise(Errors.DeferImportRequiresNamespace, specifiers[0]);
 		}
 	}
 	isPotentialImportPhase(isExport) {
@@ -27356,12 +27364,12 @@ var StatementParser = class extends ExpressionParser {
 			if (this.match(4)) break;
 			const node = this.startNode();
 			const keyName = this.state.value;
-			if (attrNames.has(keyName)) this.raise(Errors$1.ModuleAttributesWithDuplicateKeys, this.state.startLoc, { key: keyName });
+			if (attrNames.has(keyName)) this.raise(Errors.ModuleAttributesWithDuplicateKeys, this.state.startLoc, { key: keyName });
 			attrNames.add(keyName);
 			if (this.match(130)) node.key = this.parseStringLiteral(keyName);
 			else node.key = this.parseIdentifier(true);
 			this.expect(10);
-			if (!this.match(130)) throw this.raise(Errors$1.ModuleAttributeInvalidValue, this.state.startLoc);
+			if (!this.match(130)) throw this.raise(Errors.ModuleAttributeInvalidValue, this.state.startLoc);
 			node.value = this.parseStringLiteral(this.state.value);
 			attrs.push(this.finishNode(node, "ImportAttribute"));
 		} while (this.eat(8));
@@ -27405,7 +27413,7 @@ var StatementParser = class extends ExpressionParser {
 		while (!this.eat(4)) {
 			if (first) first = false;
 			else {
-				if (this.eat(10)) throw this.raise(Errors$1.DestructureNamedImport, this.state.startLoc);
+				if (this.eat(10)) throw this.raise(Errors.DestructureNamedImport, this.state.startLoc);
 				this.expect(8);
 				if (this.eat(4)) break;
 			}
@@ -27421,7 +27429,7 @@ var StatementParser = class extends ExpressionParser {
 		if (this.eatContextual(89)) specifier.local = this.parseIdentifier();
 		else {
 			const { imported } = specifier;
-			if (importedIsString) throw this.raise(Errors$1.ImportBindingIsString, specifier, { importName: imported.value });
+			if (importedIsString) throw this.raise(Errors.ImportBindingIsString, specifier, { importName: imported.value });
 			this.checkReservedWord(imported.name, specifier.start, true, true);
 			if (!specifier.local) specifier.local = this.cloneIdentifier(imported);
 		}
@@ -27439,7 +27447,7 @@ function nonNull(x) {
 function assert(x) {
 	if (!x) throw new Error("Assert fail");
 }
-const TSErrors$1 = ParseErrorEnum$1`typescript`({
+const TSErrors = ParseErrorEnum`typescript`({
 	AbstractMethodHasImplementation: ({ methodName }) => `Method '${methodName}' cannot have an implementation because it is marked abstract.`,
 	AbstractPropertyHasInitializer: ({ propertyName }) => `Property '${propertyName}' cannot have an initializer because it is marked abstract.`,
 	AccessorCannotBeOptional: "An 'accessor' property cannot be declared optional.",
@@ -27452,6 +27460,7 @@ const TSErrors$1 = ParseErrorEnum$1`typescript`({
 	DeclareAccessor: ({ kind }) => `'declare' is not allowed in ${kind}ters.`,
 	DeclareClassFieldHasInitializer: "Initializers are not allowed in ambient contexts.",
 	DeclareFunctionHasImplementation: "An implementation cannot be declared in ambient contexts.",
+	DecoratorAbstractMethod: ({ kind }) => `Decorators can't be used with ${kind.startsWith("a") ? "an" : "a"} ${kind}.`,
 	DuplicateAccessibilityModifier: ({ modifier }) => `Accessibility modifier already seen: '${modifier}'.`,
 	DuplicateModifier: ({ modifier }) => `Duplicate modifier: '${modifier}'.`,
 	EmptyHeritageClauseType: ({ token }) => `'${token}' list cannot be empty.`,
@@ -27573,18 +27582,18 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 			if (this.tsTryParse(this.tsNextTokenCanFollowModifier.bind(this))) return modifier;
 		}
 	}
-	tsParseModifiers({ allowedModifiers, disallowedModifiers, stopOnStartOfClassStaticBlock, errorTemplate = TSErrors$1.InvalidModifierOnTypeMember }, modified) {
+	tsParseModifiers({ allowedModifiers, disallowedModifiers, stopOnStartOfClassStaticBlock, errorTemplate = TSErrors.InvalidModifierOnTypeMember }, modified) {
 		const enforceOrder = (loc, modifier, before, after) => {
-			if (modifier === before && modified[after]) this.raise(TSErrors$1.InvalidModifiersOrder, loc, { orderedModifiers: [before, after] });
+			if (modifier === before && modified[after]) this.raise(TSErrors.InvalidModifiersOrder, loc, { orderedModifiers: [before, after] });
 		};
 		const incompatible = (loc, modifier, mod1, mod2) => {
-			if (modified[mod1] && modifier === mod2 || modified[mod2] && modifier === mod1) this.raise(TSErrors$1.IncompatibleModifiers, loc, { modifiers: [mod1, mod2] });
+			if (modified[mod1] && modifier === mod2 || modified[mod2] && modifier === mod1) this.raise(TSErrors.IncompatibleModifiers, loc, { modifiers: [mod1, mod2] });
 		};
 		for (;;) {
 			const { startLoc } = this.state;
 			const modifier = this.tsParseModifier(allowedModifiers.concat(disallowedModifiers ?? []), stopOnStartOfClassStaticBlock, modified.static);
 			if (!modifier) break;
-			if (tsIsAccessModifier(modifier)) if (modified.accessibility) this.raise(TSErrors$1.DuplicateAccessibilityModifier, startLoc, { modifier });
+			if (tsIsAccessModifier(modifier)) if (modified.accessibility) this.raise(TSErrors.DuplicateAccessibilityModifier, startLoc, { modifier });
 			else {
 				enforceOrder(startLoc, modifier, modifier, "override");
 				enforceOrder(startLoc, modifier, modifier, "static");
@@ -27592,11 +27601,11 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 				modified.accessibility = modifier;
 			}
 			else if (tsIsVarianceAnnotations(modifier)) {
-				if (modified[modifier]) this.raise(TSErrors$1.DuplicateModifier, startLoc, { modifier });
+				if (modified[modifier]) this.raise(TSErrors.DuplicateModifier, startLoc, { modifier });
 				modified[modifier] = true;
 				enforceOrder(startLoc, modifier, "in", "out");
 			} else {
-				if (Object.hasOwn(modified, modifier)) this.raise(TSErrors$1.DuplicateModifier, startLoc, { modifier });
+				if (Object.hasOwn(modified, modifier)) this.raise(TSErrors.DuplicateModifier, startLoc, { modifier });
 				else {
 					enforceOrder(startLoc, modifier, "static", "readonly");
 					enforceOrder(startLoc, modifier, "static", "override");
@@ -27660,7 +27669,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 		this.expect(79);
 		this.expect(6);
 		if (!this.match(130)) {
-			this.raise(TSErrors$1.UnsupportedImportTypeArgument, this.state.startLoc);
+			this.raise(TSErrors.UnsupportedImportTypeArgument, this.state.startLoc);
 			node.source = this.tsParseNonConditionalType();
 		} else node.source = this.parseStringLiteral(this.state.value);
 		if (this.eat(8)) node.options = this.tsParseImportTypeOptions();
@@ -27757,12 +27766,12 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 			"abstract",
 			"override"
 		],
-		errorTemplate: TSErrors$1.InvalidModifierOnTypeParameter
+		errorTemplate: TSErrors.InvalidModifierOnTypeParameter
 	});
 	tsParseConstModifier = this.tsParseModifiers.bind(this, {
 		allowedModifiers: ["const"],
 		disallowedModifiers: ["in", "out"],
-		errorTemplate: TSErrors$1.InvalidModifierOnTypeParameterPositions
+		errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions
 	});
 	tsParseInOutConstModifiers = this.tsParseModifiers.bind(this, {
 		allowedModifiers: [
@@ -27779,7 +27788,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 			"abstract",
 			"override"
 		],
-		errorTemplate: TSErrors$1.InvalidModifierOnTypeParameter
+		errorTemplate: TSErrors.InvalidModifierOnTypeParameter
 	});
 	tsParseTypeParameter(parseModifiers) {
 		const node = this.startNode();
@@ -27798,7 +27807,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 		else this.unexpected();
 		const refTrailingCommaPos = { value: -1 };
 		node.params = this.tsParseBracketedList("TypeParametersOrArguments", this.tsParseTypeParameter.bind(this, parseModifiers), false, true, refTrailingCommaPos);
-		if (node.params.length === 0) this.raise(TSErrors$1.EmptyTypeParameters, node);
+		if (node.params.length === 0) this.raise(TSErrors.EmptyTypeParameters, node);
 		if (refTrailingCommaPos.value !== -1) this.addExtra(node, "trailingComma", refTrailingCommaPos.value);
 		return this.finishNode(node, "TSTypeParameterDeclaration");
 	}
@@ -27816,7 +27825,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 		const list = super.parseBindingList(7, 41, 2);
 		for (const pattern of list) {
 			const { type } = pattern;
-			if (type === "AssignmentPattern" || type === "TSParameterProperty") this.raise(TSErrors$1.UnsupportedSignatureParameterKind, pattern, { type });
+			if (type === "AssignmentPattern" || type === "TSParameterProperty") this.raise(TSErrors.UnsupportedSignatureParameterKind, pattern, { type });
 		}
 		return list;
 	}
@@ -27852,25 +27861,25 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 	tsParsePropertyOrMethodSignature(node, readonly) {
 		if (this.eat(13)) node.optional = true;
 		if (this.match(6) || this.match(43)) {
-			if (readonly) this.raise(TSErrors$1.ReadonlyForMethodSignature, node);
+			if (readonly) this.raise(TSErrors.ReadonlyForMethodSignature, node);
 			const method = node;
-			if (method.kind && this.match(43)) this.raise(TSErrors$1.AccessorCannotHaveTypeParameters, this.state.curPosition());
+			if (method.kind && this.match(43)) this.raise(TSErrors.AccessorCannotHaveTypeParameters, this.state.curPosition());
 			this.tsFillSignature(10, method);
 			this.tsParseTypeMemberSemicolon();
 			if (method.kind === "get") {
 				if (method.params.length > 0) {
-					this.raise(Errors$1.BadGetterArity, this.state.curPosition());
-					if (this.isThisParam(method.params[0])) this.raise(TSErrors$1.AccessorCannotDeclareThisParameter, this.state.curPosition());
+					this.raise(Errors.BadGetterArity, this.state.curPosition());
+					if (this.isThisParam(method.params[0])) this.raise(TSErrors.AccessorCannotDeclareThisParameter, this.state.curPosition());
 				}
 			} else if (method.kind === "set") {
-				if (method.params.length !== 1) this.raise(Errors$1.BadSetterArity, this.state.curPosition());
+				if (method.params.length !== 1) this.raise(Errors.BadSetterArity, this.state.curPosition());
 				else {
 					const firstParameter = method.params[0];
-					if (this.isThisParam(firstParameter)) this.raise(TSErrors$1.AccessorCannotDeclareThisParameter, this.state.curPosition());
-					if (firstParameter.type === "Identifier" && firstParameter.optional) this.raise(TSErrors$1.SetAccessorCannotHaveOptionalParameter, this.state.curPosition());
-					if (firstParameter.type === "RestElement") this.raise(TSErrors$1.SetAccessorCannotHaveRestParameter, this.state.curPosition());
+					if (this.isThisParam(firstParameter)) this.raise(TSErrors.AccessorCannotDeclareThisParameter, this.state.curPosition());
+					if (firstParameter.type === "Identifier" && firstParameter.optional) this.raise(TSErrors.SetAccessorCannotHaveOptionalParameter, this.state.curPosition());
+					if (firstParameter.type === "RestElement") this.raise(TSErrors.SetAccessorCannotHaveRestParameter, this.state.curPosition());
 				}
-				if (method.returnType) this.raise(TSErrors$1.SetAccessorCannotHaveReturnType, method.returnType);
+				if (method.returnType) this.raise(TSErrors.SetAccessorCannotHaveReturnType, method.returnType);
 			} else method.kind = "method";
 			return this.finishNode(method, "TSMethodSignature");
 		} else {
@@ -27966,7 +27975,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 		let seenOptionalElement = false;
 		node.elementTypes.forEach((elementNode) => {
 			const { type } = elementNode;
-			if (seenOptionalElement && type !== "TSRestType" && type !== "TSOptionalType" && !(type === "TSNamedTupleMember" && elementNode.optional)) this.raise(TSErrors$1.OptionalTypeBeforeRequired, elementNode);
+			if (seenOptionalElement && type !== "TSRestType" && type !== "TSOptionalType" && !(type === "TSNamedTupleMember" && elementNode.optional)) this.raise(TSErrors.OptionalTypeBeforeRequired, elementNode);
 			seenOptionalElement ||= type === "TSNamedTupleMember" && elementNode.optional || type === "TSOptionalType";
 		});
 		return this.finishNode(node, "TSTupleType");
@@ -28015,12 +28024,12 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 				labeledNode.elementType = type;
 				if (this.eat(13)) {
 					labeledNode.optional = true;
-					this.raise(TSErrors$1.TupleOptionalAfterType, this.state.lastTokStartLoc);
+					this.raise(TSErrors.TupleOptionalAfterType, this.state.lastTokStartLoc);
 				}
 			} else {
 				labeledNode = this.startNodeAt(startLoc);
 				labeledNode.optional = optional;
-				this.raise(TSErrors$1.InvalidTupleMemberLabel, type);
+				this.raise(TSErrors.InvalidTupleMemberLabel, type);
 				labeledNode.label = type;
 				labeledNode.elementType = this.tsParseType();
 			}
@@ -28180,7 +28189,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 		switch (node.typeAnnotation.type) {
 			case "TSTupleType":
 			case "TSArrayType": return;
-			default: this.raise(TSErrors$1.UnexpectedReadonly, node);
+			default: this.raise(TSErrors.UnexpectedReadonly, node);
 		}
 	}
 	tsParseInferType() {
@@ -28320,7 +28329,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 		const containsEsc = this.state.containsEsc;
 		this.next();
 		if (!tokenIsIdentifier(this.state.type) && !this.match(74)) return false;
-		if (containsEsc) this.raise(Errors$1.InvalidEscapedReservedWord, this.state.lastTokStartLoc, { reservedWord: "asserts" });
+		if (containsEsc) this.raise(Errors.InvalidEscapedReservedWord, this.state.lastTokStartLoc, { reservedWord: "asserts" });
 		return true;
 	}
 	tsParseTypeAnnotation(eatColon = true, t = this.startNode()) {
@@ -28353,7 +28362,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 		return this.tsParseUnionTypeOrHigher();
 	}
 	tsParseTypeAssertion() {
-		if (this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) this.raise(TSErrors$1.ReservedTypeAssertion, this.state.startLoc);
+		if (this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) this.raise(TSErrors.ReservedTypeAssertion, this.state.startLoc);
 		const node = this.startNode();
 		node.typeAnnotation = this.tsInType(() => {
 			this.next();
@@ -28367,7 +28376,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 		const originalStartLoc = this.state.startLoc;
 		const delimitedList = this.tsParseDelimitedList("HeritageClauseElement", () => {
 			const expression = (this.state.canStartArrow = false, super.parseExprSubscripts());
-			if (!tsIsEntityName(expression)) this.raise(TSErrors$1.InvalidHeritageClauseType, expression.start, { token });
+			if (!tsIsEntityName(expression)) this.raise(TSErrors.InvalidHeritageClauseType, expression.start, { token });
 			const nodeType = token === "extends" ? "TSInterfaceHeritage" : "TSClassImplements";
 			if (expression.type === "TSInstantiationExpression") {
 				expression.type = nodeType;
@@ -28378,7 +28387,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 			if (this.match(43) || this.match(47)) node.typeArguments = this.tsParseTypeArgumentsInExpression();
 			return this.finishNode(node, nodeType);
 		});
-		if (!delimitedList.length) this.raise(TSErrors$1.EmptyHeritageClauseType, originalStartLoc, { token });
+		if (!delimitedList.length) this.raise(TSErrors.EmptyHeritageClauseType, originalStartLoc, { token });
 		return delimitedList;
 	}
 	tsParseInterfaceDeclaration(node, properties = {}) {
@@ -28390,7 +28399,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 			this.checkIdentifier(node.id, 130);
 		} else {
 			node.id = null;
-			this.raise(TSErrors$1.MissingInterfaceName, this.state.startLoc);
+			this.raise(TSErrors.MissingInterfaceName, this.state.startLoc);
 		}
 		node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers);
 		if (this.eat(77)) node.extends = this.tsParseHeritageClause("extends");
@@ -28416,7 +28425,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 		return this.finishNode(node, "TSTypeAliasDeclaration");
 	}
 	tsInTopLevelContext(cb) {
-		if (this.curContext() !== types$1.brace) {
+		if (this.curContext() !== types.brace) {
 			const oldContext = this.state.context;
 			this.state.context = [oldContext[0]];
 			try {
@@ -28531,7 +28540,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 		this.checkIdentifier(node.id, 4096);
 		this.expect(25);
 		const moduleReference = this.tsParseModuleReference();
-		if (node.importKind === "type" && moduleReference.type !== "TSExternalModuleReference") this.raise(TSErrors$1.ImportAliasHasImportType, moduleReference);
+		if (node.importKind === "type" && moduleReference.type !== "TSExternalModuleReference") this.raise(TSErrors.ImportAliasHasImportType, moduleReference);
 		node.moduleReference = moduleReference;
 		this.semicolon();
 		return this.finishNode(node, "TSImportEqualsDeclaration");
@@ -28597,14 +28606,14 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 					});
 				case 103:
 					if (this.isUsing()) {
-						this.raise(TSErrors$1.InvalidModifierOnUsingDeclaration, this.state.startLoc, "declare");
+						this.raise(TSErrors.InvalidModifierOnUsingDeclaration, this.state.startLoc, "declare");
 						node.declare = true;
 						return this.parseVarStatement(node, "using", true);
 					}
 					break;
 				case 92:
 					if (this.isAwaitUsing()) {
-						this.raise(TSErrors$1.InvalidModifierOnAwaitUsingDeclaration, this.state.startLoc, "declare");
+						this.raise(TSErrors.InvalidModifierOnAwaitUsingDeclaration, this.state.startLoc, "declare");
 						node.declare = true;
 						this.next();
 						return this.parseVarStatement(node, "await using", true);
@@ -28671,8 +28680,8 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 			this.expect(43);
 			return this.tsParseDelimitedList("TypeParametersOrArguments", this.tsParseType.bind(this));
 		}));
-		if (node.params.length === 0) this.raise(TSErrors$1.EmptyTypeArguments, node);
-		else if (!this.state.inType && this.curContext() === types$1.brace) this.reScan_lt_gt();
+		if (node.params.length === 0) this.raise(TSErrors.EmptyTypeArguments, node);
+		else if (!this.state.inType && this.curContext() === types.brace) this.reScan_lt_gt();
 		this.expect(44);
 		return this.finishNode(node, "TSTypeParameterInstantiation");
 	}
@@ -28696,7 +28705,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 		const accessibility = modified.accessibility;
 		const override = modified.override;
 		const readonly = modified.readonly;
-		if (!(flags & 4) && (accessibility || readonly || override)) this.raise(TSErrors$1.UnexpectedParameterModifier, startLoc || decorators[0]);
+		if (!(flags & 4) && (accessibility || readonly || override)) this.raise(TSErrors.UnexpectedParameterModifier, startLoc || decorators[0]);
 		const startLoc2 = this.state.startLoc;
 		const left = this.parseMaybeDefault(startLoc2);
 		if (flags & 2) this.parseFunctionParamType(left);
@@ -28708,7 +28717,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 			if (accessibility) pp.accessibility = accessibility;
 			if (readonly) pp.readonly = readonly;
 			if (override) pp.override = override;
-			if (elt.type !== "Identifier" && elt.type !== "AssignmentPattern") this.raise(TSErrors$1.UnsupportedParameterPropertyKind, startLoc || decorators[0]);
+			if (elt.type !== "Identifier" && elt.type !== "AssignmentPattern") this.raise(TSErrors.UnsupportedParameterPropertyKind, startLoc || decorators[0]);
 			pp.parameter = elt;
 			return this.finishNode(pp, "TSParameterProperty");
 		}
@@ -28719,7 +28728,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 		return node.type === "TSParameterProperty" && super.isSimpleParameter(node.parameter) || super.isSimpleParameter(node);
 	}
 	tsDisallowOptionalPattern(node) {
-		for (const param of node.params) if (param.type !== "Identifier" && param.optional && !this.state.isAmbientContext) this.raise(TSErrors$1.PatternIsOptional, param);
+		for (const param of node.params) if (param.type !== "Identifier" && param.optional && !this.state.isAmbientContext) this.raise(TSErrors.PatternIsOptional, param);
 	}
 	setArrowFunctionParameters(node, params, trailingCommaLoc) {
 		super.setArrowFunctionParameters(node, params, trailingCommaLoc);
@@ -28730,13 +28739,13 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 		const bodilessType = type === "FunctionDeclaration" ? "TSDeclareFunction" : type === "ClassMethod" || type === "ClassPrivateMethod" ? "TSDeclareMethod" : void 0;
 		if (bodilessType && !this.match(2) && this.isLineTerminator()) {
 			if (bodilessType === "TSDeclareMethod" && node.kind === "constructor") {
-				for (const param of node.params) if (param.type === "TSParameterProperty") this.raise(TSErrors$1.UnexpectedParameterModifier, param);
-				else if (param.type === "AssignmentPattern") this.raise(TSErrors$1.UnexpectedParameterInitializer, param);
-			} else for (const param of node.params) if (param.type === "AssignmentPattern") this.raise(TSErrors$1.UnexpectedParameterInitializer, param);
+				for (const param of node.params) if (param.type === "TSParameterProperty") this.raise(TSErrors.UnexpectedParameterModifier, param);
+				else if (param.type === "AssignmentPattern") this.raise(TSErrors.UnexpectedParameterInitializer, param);
+			} else for (const param of node.params) if (param.type === "AssignmentPattern") this.raise(TSErrors.UnexpectedParameterInitializer, param);
 			return this.finishNode(node, bodilessType);
 		}
 		if (bodilessType && this.state.isAmbientContext) {
-			this.raise(TSErrors$1.DeclareFunctionHasImplementation, this.state.startLoc);
+			this.raise(TSErrors.DeclareFunctionHasImplementation, this.state.startLoc);
 			if (bodilessType === "TSDeclareFunction" && node.declare) return super.parseFunctionBodyAndFinish(node, bodilessType, isMethod);
 		}
 		this.tsDisallowOptionalPattern(node);
@@ -28748,7 +28757,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 	}
 	tsCheckForInvalidTypeCasts(items) {
 		items.forEach((node) => {
-			if (node?.type === "TSTypeCastExpression") this.raise(TSErrors$1.UnexpectedTypeAnnotation, node.typeAnnotation);
+			if (node?.type === "TSTypeCastExpression") this.raise(TSErrors.UnexpectedTypeAnnotation, node.typeAnnotation);
 		});
 	}
 	toReferencedList(exprList, isInParens) {
@@ -28817,7 +28826,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 			if (missingParenErrorLoc) this.unexpected(missingParenErrorLoc, 6);
 			if (result) {
 				if (result.type === "TSInstantiationExpression") {
-					if (this.match(12) || this.match(14) && this.lookaheadCharCode() !== 40) this.raise(TSErrors$1.InvalidPropertyAccessAfterInstantiationExpression, this.state.startLoc);
+					if (this.match(12) || this.match(14) && this.lookaheadCharCode() !== 40) this.raise(TSErrors.InvalidPropertyAccessAfterInstantiationExpression, this.state.startLoc);
 					if (!this.match(12) && !this.match(14)) result.expression = super.stopParseSubscript(base, state);
 				}
 				return result;
@@ -28841,7 +28850,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 			node.typeAnnotation = this.tsInType(() => {
 				this.next();
 				if (this.match(71)) {
-					if (isSatisfies) this.raise(Errors$1.UnexpectedKeyword, this.state.startLoc, { keyword: "const" });
+					if (isSatisfies) this.raise(Errors.UnexpectedKeyword, this.state.startLoc, { keyword: "const" });
 					return this.tsParseTypeReference();
 				}
 				return this.tsParseType();
@@ -28872,24 +28881,24 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 	parseImport(node) {
 		if (this.match(130)) {
 			node.importKind = "value";
-			if (this.scope.inTSNamespace) this.raise(TSErrors$1.ImportInTSNamespace, node);
+			if (this.scope.inTSNamespace) this.raise(TSErrors.ImportInTSNamespace, node);
 			return super.parseImport(node);
 		}
 		let importNode;
 		if (tokenIsIdentifier(this.state.type) && this.lookaheadCharCode() === 61) {
 			node.importKind = "value";
 			const result = this.tsParseImportEqualsDeclaration(node);
-			if (this.scope.inTSNamespace && result.moduleReference.type === "TSExternalModuleReference") this.raise(TSErrors$1.ImportInTSNamespace, node);
+			if (this.scope.inTSNamespace && result.moduleReference.type === "TSExternalModuleReference") this.raise(TSErrors.ImportInTSNamespace, node);
 			return result;
 		} else if (this.isContextual(126)) {
 			const maybeDefaultIdentifier = this.parseMaybeImportPhase(node, false);
 			if (this.lookaheadCharCode() === 61) {
-				if (this.scope.inTSNamespace) this.raise(TSErrors$1.ImportInTSNamespace, node);
+				if (this.scope.inTSNamespace) this.raise(TSErrors.ImportInTSNamespace, node);
 				return this.tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier);
 			} else importNode = super.parseImportSpecifiersAndAfter(node, maybeDefaultIdentifier);
 		} else importNode = super.parseImport(node);
-		if (importNode.importKind === "type" && importNode.specifiers.length > 1 && importNode.specifiers[0].type === "ImportDefaultSpecifier") this.raise(TSErrors$1.TypeImportCannotSpecifyDefaultAndNamed, importNode);
-		else if (this.scope.inTSNamespace) this.raise(TSErrors$1.ImportInTSNamespace, importNode);
+		if (importNode.importKind === "type" && importNode.specifiers.length > 1 && importNode.specifiers[0].type === "ImportDefaultSpecifier") this.raise(TSErrors.TypeImportCannotSpecifyDefaultAndNamed, importNode);
+		else if (this.scope.inTSNamespace) this.raise(TSErrors.ImportInTSNamespace, importNode);
 		return importNode;
 	}
 	parseExport(node, decorators) {
@@ -28911,7 +28920,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 			assign.expression = super.parseExpression();
 			this.semicolon();
 			this.sawUnambiguousESM = true;
-			if (this.scope.inTSNamespace) this.raise(TSErrors$1.ExportAssignmentInTSNamespace, assign);
+			if (this.scope.inTSNamespace) this.raise(TSErrors.ExportAssignmentInTSNamespace, assign);
 			return this.finishNode(assign, "TSExportAssignment");
 		} else if (this.eatContextual(89)) {
 			const decl = node;
@@ -28919,11 +28928,11 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 			decl.id = this.parseIdentifier();
 			this.checkIdentifier(decl.id, 8201);
 			this.semicolon();
-			if (this.scope.inTSNamespace) this.raise(TSErrors$1.NamespaceExportInTSNamespace, decl);
+			if (this.scope.inTSNamespace) this.raise(TSErrors.NamespaceExportInTSNamespace, decl);
 			return this.finishNode(decl, "TSNamespaceExportDeclaration");
 		} else {
 			const result = super.parseExport(node, decorators);
-			if (this.scope.inTSNamespace && (result.type !== "ExportNamedDeclaration" || result.source || !result.declaration && !this.state.isAmbientContext)) this.raise(TSErrors$1.ExportInTSNamespace, result);
+			if (this.scope.inTSNamespace && (result.type !== "ExportNamedDeclaration" || result.source || !result.declaration && !this.state.isAmbientContext)) this.raise(TSErrors.ExportInTSNamespace, result);
 			return result;
 		}
 	}
@@ -28948,13 +28957,13 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 		const declaration = super.parseVarStatement(node, kind, allowMissingInitializer || isAmbientContext);
 		if (!isAmbientContext) return declaration;
 		if (!node.declare && (kind === "using" || kind === "await using")) {
-			this.raiseOverwrite(TSErrors$1.UsingDeclarationInAmbientContext, node, kind);
+			this.raiseOverwrite(TSErrors.UsingDeclarationInAmbientContext, node, kind);
 			return declaration;
 		}
 		for (const { id, init } of declaration.declarations) {
 			if (!init) continue;
-			if (kind === "var" || kind === "let" || !!id.typeAnnotation) this.raise(TSErrors$1.InitializerNotAllowedInAmbientContext, init);
-			else if (!isValidAmbientConstInitializer(init, this.hasPlugin("estree"))) this.raise(TSErrors$1.ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference, init);
+			if (kind === "var" || kind === "let" || !!id.typeAnnotation) this.raise(TSErrors.InitializerNotAllowedInAmbientContext, init);
+			else if (!isValidAmbientConstInitializer(init, this.hasPlugin("estree"))) this.raise(TSErrors.ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference, init);
 		}
 		return declaration;
 	}
@@ -28995,7 +29004,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 			case 125: {
 				const result = this.tsParseInterfaceDeclaration(this.startNode());
 				if (result) {
-					if (!allowDeclaration) this.raise(TSErrors$1.UnexpectedTypeDeclaration, result, "interface");
+					if (!allowDeclaration) this.raise(TSErrors.UnexpectedTypeDeclaration, result, "interface");
 					return result;
 				}
 				break;
@@ -29006,7 +29015,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 					this.next();
 					return this.tsParseDeclaration(node, 123, false, decorators);
 				} else if (this.nextTokenIsIdentifierOnSameLine()) {
-					this.raise(TSErrors$1.InlineModuleDeclarationMustUseString, this.state.startLoc);
+					this.raise(TSErrors.InlineModuleDeclarationMustUseString, this.state.startLoc);
 					const node = this.startNode();
 					this.next();
 					return this.tsParseDeclaration(node, 124, false, decorators);
@@ -29022,7 +29031,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 			case 126:
 				if (this.nextTokenIsIdentifierOnSameLine()) {
 					const node = this.startNode();
-					if (!allowDeclaration) this.raise(TSErrors$1.UnexpectedTypeDeclaration, node, "type");
+					if (!allowDeclaration) this.raise(TSErrors.UnexpectedTypeDeclaration, node, "type");
 					this.next();
 					return this.tsParseTypeAliasDeclaration(node);
 				}
@@ -29061,39 +29070,43 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 			allowedModifiers: modifiers,
 			disallowedModifiers: ["in", "out"],
 			stopOnStartOfClassStaticBlock: true,
-			errorTemplate: TSErrors$1.InvalidModifierOnTypeParameterPositions
+			errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions
 		}, member);
 		const callParseClassMemberWithIsStatic = () => {
 			if (this.tsIsStartOfStaticBlocks()) {
 				this.next();
 				this.next();
-				if (this.tsHasSomeModifiers(member, modifiers)) this.raise(TSErrors$1.StaticBlockCannotHaveModifier, this.state.curPosition());
+				if (this.tsHasSomeModifiers(member, modifiers)) this.raise(TSErrors.StaticBlockCannotHaveModifier, this.state.curPosition());
 				super.parseClassStaticBlock(classBody, member);
 			} else this.parseClassMemberWithIsStatic(classBody, member, state, !!member.static);
 		};
 		if (member.declare) this.tsInAmbientContext(callParseClassMemberWithIsStatic);
 		else callParseClassMemberWithIsStatic();
+		if (member.decorators && member.decorators.length > 0 && !this.hasPlugin("decorators-legacy")) {
+			if (member.type === "TSAbstractMethodDefinition" || member.type === "TSDeclareMethod") this.raise(TSErrors.DecoratorAbstractMethod, member, { kind: "abstract method" });
+			else if (member.type === "ClassProperty" && member.abstract || member.type === "ClassProperty" && member.declare || member.type === "TSAbstractPropertyDefinition" || member.type === "PropertyDefinition" && member.declare) this.raise(TSErrors.DecoratorAbstractMethod, member, { kind: member.declare ? "declare field" : "abstract field" });
+		}
 	}
 	parseClassMemberWithIsStatic(classBody, member, state, isStatic) {
 		const idx = this.tsTryParseIndexSignature(member);
 		if (idx) {
 			classBody.body.push(idx);
-			if (member.abstract) this.raise(TSErrors$1.IndexSignatureHasAbstract, member);
-			if (member.accessibility) this.raise(TSErrors$1.IndexSignatureHasAccessibility, member, { modifier: member.accessibility });
-			if (member.declare) this.raise(TSErrors$1.IndexSignatureHasDeclare, member);
-			if (member.override) this.raise(TSErrors$1.IndexSignatureHasOverride, member);
+			if (member.abstract) this.raise(TSErrors.IndexSignatureHasAbstract, member);
+			if (member.accessibility) this.raise(TSErrors.IndexSignatureHasAccessibility, member, { modifier: member.accessibility });
+			if (member.declare) this.raise(TSErrors.IndexSignatureHasDeclare, member);
+			if (member.override) this.raise(TSErrors.IndexSignatureHasOverride, member);
 			return;
 		}
-		if (!this.state.inAbstractClass && member.abstract) this.raise(TSErrors$1.NonAbstractClassHasAbstractMethod, member);
+		if (!this.state.inAbstractClass && member.abstract) this.raise(TSErrors.NonAbstractClassHasAbstractMethod, member);
 		if (member.override) {
-			if (!state.hadSuperClass) this.raise(TSErrors$1.OverrideNotInSubClass, member);
+			if (!state.hadSuperClass) this.raise(TSErrors.OverrideNotInSubClass, member);
 		}
 		super.parseClassMemberWithIsStatic(classBody, member, state, isStatic);
 	}
 	parsePostMemberNameModifiers(methodOrProp) {
 		if (this.eat(13)) methodOrProp.optional = true;
-		if (methodOrProp.readonly && this.match(6)) this.raise(TSErrors$1.ClassMethodHasReadonly, methodOrProp);
-		if (methodOrProp.declare && this.match(6)) this.raise(TSErrors$1.ClassMethodHasDeclare, methodOrProp);
+		if (methodOrProp.readonly && this.match(6)) this.raise(TSErrors.ClassMethodHasReadonly, methodOrProp);
+		if (methodOrProp.declare && this.match(6)) this.raise(TSErrors.ClassMethodHasDeclare, methodOrProp);
 	}
 	shouldParseExportDeclaration() {
 		if (this.tsIsDeclarationStart()) return true;
@@ -29137,7 +29150,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 		if (!this.state.isAmbientContext && this.isContextual(121)) return this.tsInAmbientContext(() => this.parseExportDeclaration(node));
 		const startLoc = this.state.startLoc;
 		const isDeclare = this.eatContextual(121);
-		if (isDeclare && (this.isContextual(121) || !this.shouldParseExportDeclaration())) throw this.raise(TSErrors$1.ExpectedAmbientAfterExportDeclare, this.state.startLoc);
+		if (isDeclare && (this.isContextual(121) || !this.shouldParseExportDeclaration())) throw this.raise(TSErrors.ExpectedAmbientAfterExportDeclare, this.state.startLoc);
 		const declaration = tokenIsIdentifier(this.state.type) && this.tsTryParseExportDeclaration() || super.parseExportDeclaration(node);
 		if (!declaration) return null;
 		if (declaration.type === "TSInterfaceDeclaration" || declaration.type === "TSTypeAliasDeclaration" || isDeclare) node.exportKind = "type";
@@ -29166,29 +29179,29 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 	}
 	parseClassProperty(node) {
 		this.parseClassPropertyAnnotation(node);
-		if (this.state.isAmbientContext && !(node.readonly && !node.typeAnnotation) && this.match(25)) this.raise(TSErrors$1.DeclareClassFieldHasInitializer, this.state.startLoc);
+		if (this.state.isAmbientContext && !(node.readonly && !node.typeAnnotation) && this.match(25)) this.raise(TSErrors.DeclareClassFieldHasInitializer, this.state.startLoc);
 		if (node.abstract && this.match(25)) {
 			const { key } = node;
-			this.raise(TSErrors$1.AbstractPropertyHasInitializer, this.state.startLoc, { propertyName: key.type === "Identifier" && !node.computed ? key.name : `[${this.input.slice(this.offsetToSourcePos(key.start), this.offsetToSourcePos(key.end))}]` });
+			this.raise(TSErrors.AbstractPropertyHasInitializer, this.state.startLoc, { propertyName: key.type === "Identifier" && !node.computed ? key.name : `[${this.input.slice(this.offsetToSourcePos(key.start), this.offsetToSourcePos(key.end))}]` });
 		}
 		return super.parseClassProperty(node);
 	}
 	parseClassPrivateProperty(node) {
-		if (node.abstract) this.raise(TSErrors$1.PrivateElementHasAbstract, node);
-		if (node.accessibility) this.raise(TSErrors$1.PrivateElementHasAccessibility, node, { modifier: node.accessibility });
+		if (node.abstract) this.raise(TSErrors.PrivateElementHasAbstract, node);
+		if (node.accessibility) this.raise(TSErrors.PrivateElementHasAccessibility, node, { modifier: node.accessibility });
 		this.parseClassPropertyAnnotation(node);
 		return super.parseClassPrivateProperty(node);
 	}
 	parseClassAccessorProperty(node) {
 		this.parseClassPropertyAnnotation(node);
-		if (node.optional) this.raise(TSErrors$1.AccessorCannotBeOptional, node);
+		if (node.optional) this.raise(TSErrors.AccessorCannotBeOptional, node);
 		return super.parseClassAccessorProperty(node);
 	}
 	pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
 		const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
-		if (typeParameters && isConstructor) this.raise(TSErrors$1.ConstructorHasTypeParameters, typeParameters);
+		if (typeParameters && isConstructor) this.raise(TSErrors.ConstructorHasTypeParameters, typeParameters);
 		const { declare = false, kind } = method;
-		if (declare && (kind === "get" || kind === "set")) this.raise(TSErrors$1.DeclareAccessor, method, { kind });
+		if (declare && (kind === "get" || kind === "set")) this.raise(TSErrors.DeclareAccessor, method, { kind });
 		if (typeParameters) method.typeParameters = typeParameters;
 		super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);
 	}
@@ -29250,7 +29263,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 			if (!jsx.error) return jsx.node;
 			const { context } = this.state;
 			const currentContext = context[context.length - 1];
-			if (currentContext === types$1.j_oTag || currentContext === types$1.j_expr) context.pop();
+			if (currentContext === types.j_oTag || currentContext === types.j_expr) context.pop();
 		}
 		if (!jsx?.error && !this.match(43)) return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
 		if (!state || state === this.state) state = this.state.clone();
@@ -29263,7 +29276,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 			expr.typeParameters = typeParameters;
 			if (this.hasPlugin("jsx") && expr.typeParameters.params.length === 1 && !expr.typeParameters.extra?.trailingComma) {
 				const parameter = expr.typeParameters.params[0];
-				if (!parameter.constraint) this.raise(TSErrors$1.SingleTypeParameterWithoutTrailingComma, this.optionFlags & 256 ? createPositionWithColumnOffset(parameter.loc.end, 1) : parameter, { typeParameterName: parameter.name.name });
+				if (!parameter.constraint) this.raise(TSErrors.SingleTypeParameterWithoutTrailingComma, this.optionFlags & 256 ? createPositionWithColumnOffset(parameter.loc.end, 1) : parameter, { typeParameterName: parameter.name.name });
 			}
 			return expr;
 		}, state);
@@ -29292,7 +29305,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 		throw jsx?.error || arrow.error || typeCast?.error;
 	}
 	reportReservedArrowTypeParam(node) {
-		if (node.params.length === 1 && !node.params[0].constraint && !node.extra?.trailingComma && this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) this.raise(TSErrors$1.ReservedArrowTypeParam, node);
+		if (node.params.length === 1 && !node.params[0].constraint && !node.extra?.trailingComma && this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) this.raise(TSErrors.ReservedArrowTypeParam, node);
 	}
 	parseMaybeUnary(refExpressionErrors, sawUnary) {
 		if (!this.hasPlugin("jsx") && this.match(43)) return this.tsParseTypeAssertion();
@@ -29336,8 +29349,8 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 			case "TSSatisfiesExpression":
 			case "TSNonNullExpression":
 			case "TSTypeAssertion":
-				if (isLHS) this.expressionScope.recordArrowParameterBindingError(TSErrors$1.UnexpectedTypeCastInParameter, node);
-				else this.raise(TSErrors$1.UnexpectedTypeCastInParameter, node);
+				if (isLHS) this.expressionScope.recordArrowParameterBindingError(TSErrors.UnexpectedTypeCastInParameter, node);
+				else this.raise(TSErrors.UnexpectedTypeCastInParameter, node);
 				this.toAssignable(node.expression, isLHS);
 				break;
 			case "AssignmentExpression": if (!isLHS && node.left.type === "TSTypeCastExpression") node.left = this.typeCastToParameter(node.left);
@@ -29409,7 +29422,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 	}
 	parseMaybeDefault(startLoc, left) {
 		const node = super.parseMaybeDefault(startLoc, left);
-		if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) this.raise(TSErrors$1.TypeAnnotationAfterAssign, node.typeAnnotation);
+		if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) this.raise(TSErrors.TypeAnnotationAfterAssign, node.typeAnnotation);
 		return node;
 	}
 	getTokenFromCode(code) {
@@ -29522,7 +29535,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 			return this.maybeTakeDecorators(decorators, this.parseClass(node, true, false));
 		} else if (this.isContextual(125)) if (!this.hasFollowingLineBreak()) {
 			node.abstract = true;
-			this.raise(TSErrors$1.NonClassMethodPropertyHasAbstractModifier, node);
+			this.raise(TSErrors.NonClassMethodPropertyHasAbstractModifier, node);
 			return this.tsParseInterfaceDeclaration(node);
 		} else return null;
 		throw this.unexpected(null, 76);
@@ -29532,7 +29545,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 		if (method.abstract || method.type === "TSAbstractMethodDefinition") {
 			if ((this.hasPlugin("estree") ? method.value : method).body) {
 				const { key } = method;
-				this.raise(TSErrors$1.AbstractMethodHasImplementation, method, { methodName: key.type === "Identifier" && !method.computed ? key.name : `[${this.input.slice(this.offsetToSourcePos(key.start), this.offsetToSourcePos(key.end))}]` });
+				this.raise(TSErrors.AbstractMethodHasImplementation, method, { methodName: key.type === "Identifier" && !method.computed ? key.name : `[${this.input.slice(this.offsetToSourcePos(key.start), this.offsetToSourcePos(key.end))}]` });
 			}
 		}
 		return method;
@@ -29602,7 +29615,7 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 				if (!this.isContextual(89)) this.checkReservedWord(leftOfAs.name, leftOfAs.start, true, true);
 			} else leftOfAs = this.parseModuleExportName();
 		}
-		if (hasTypeSpecifier && isInTypeOnlyImportExport) this.raise(isImport ? TSErrors$1.TypeModifierIsUsedInTypeImports : TSErrors$1.TypeModifierIsUsedInTypeExports, loc);
+		if (hasTypeSpecifier && isInTypeOnlyImportExport) this.raise(isImport ? TSErrors.TypeModifierIsUsedInTypeImports : TSErrors.TypeModifierIsUsedInTypeExports, loc);
 		node[leftOfAsKey] = leftOfAs;
 		node[rightOfAsKey] = rightOfAs;
 		const kindKey = isImport ? "importKind" : "exportKind";
@@ -29772,7 +29785,7 @@ function isUncomputedMemberExpressionChain(expression) {
 	if (expression.type !== "MemberExpression" || expression.computed) return false;
 	return isUncomputedMemberExpressionChain(expression.object);
 }
-const PlaceholderErrors$1 = ParseErrorEnum$1`placeholders`({
+const PlaceholderErrors = ParseErrorEnum`placeholders`({
 	ClassNameIsRequired: "A class name is required.",
 	UnexpectedSpace: "Unexpected space in placeholder."
 });
@@ -29866,7 +29879,7 @@ const placeholders = (superClass) => class PlaceholdersParserMixin extends super
 			node.id = null;
 			node.body = this.finishPlaceholder(placeholder, "ClassBody");
 			return this.finishNode(node, type);
-		} else throw this.raise(PlaceholderErrors$1.ClassNameIsRequired, this.state.startLoc);
+		} else throw this.raise(PlaceholderErrors.ClassNameIsRequired, this.state.startLoc);
 		else this.parseClassId(node, isStatement, optionalId);
 		super.parseClassSuper(node);
 		node.body = this.parsePlaceholder("ClassBody") || super.parseClassBody(!!node.superClass, oldStrict);
@@ -29931,7 +29944,7 @@ const placeholders = (superClass) => class PlaceholdersParserMixin extends super
 		return this.parsePlaceholder("StringLiteral") || super.parseImportSource();
 	}
 	assertNoSpace() {
-		if (this.state.start > this.offsetToSourcePos(this.state.lastTokEndLoc.index)) this.raise(PlaceholderErrors$1.UnexpectedSpace, this.state.lastTokEndLoc);
+		if (this.state.start > this.offsetToSourcePos(this.state.lastTokEndLoc.index)) this.raise(PlaceholderErrors.UnexpectedSpace, this.state.lastTokEndLoc);
 	}
 };
 const v8intrinsic = (superClass) => class V8IntrinsicMixin extends superClass {
@@ -30073,12 +30086,12 @@ function parse$1(input, options) {
 		}
 	} else return getParser(options, input).parse();
 }
-function generateExportedTokenTypes$1(internalTokenTypes) {
+function generateExportedTokenTypes(internalTokenTypes) {
 	const tokenTypes = {};
-	for (const typeName of Object.keys(internalTokenTypes)) tokenTypes[typeName] = getExportedToken$1(internalTokenTypes[typeName]);
+	for (const typeName of Object.keys(internalTokenTypes)) tokenTypes[typeName] = getExportedToken(internalTokenTypes[typeName]);
 	return tokenTypes;
 }
-generateExportedTokenTypes$1(tt$1);
+generateExportedTokenTypes(tt);
 function getParser(options, input) {
 	let cls = Parser;
 	const pluginsMap = /* @__PURE__ */ new Map();
@@ -30108,816 +30121,6 @@ function getParserClass(pluginsMap) {
 	return cls;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@babel+parser@8.0.0-rc.5/node_modules/@babel/parser/lib/index.js
-var Position = class {
-	constructor(line, col, index) {
-		this.line = void 0;
-		this.column = void 0;
-		if (index !== void 0) this.index = void 0;
-		this.line = line;
-		this.column = col;
-		if (index !== void 0) this.index = index;
-	}
-};
-var SourceLocation = class {
-	start;
-	end;
-	filename;
-	identifierName;
-	constructor(start, end) {
-		this.start = start;
-		this.end = end;
-	}
-};
-const code = "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED";
-const ModuleErrors = {
-	ImportMetaOutsideModule: {
-		message: `import.meta may appear only with 'sourceType: "module"'`,
-		code
-	},
-	ImportOutsideModule: {
-		message: `'import' and 'export' may appear only with 'sourceType: "module"'`,
-		code
-	}
-};
-const NodeDescriptions = {
-	ArrayPattern: "array destructuring pattern",
-	AssignmentExpression: "assignment expression",
-	AssignmentPattern: "assignment expression",
-	ArrowFunctionExpression: "arrow function expression",
-	ConditionalExpression: "conditional expression",
-	CatchClause: "catch clause",
-	ForOfStatement: "for-of statement",
-	ForInStatement: "for-in statement",
-	ForStatement: "for-loop",
-	FormalParameters: "function parameter list",
-	Identifier: "identifier",
-	ImportSpecifier: "import specifier",
-	ImportDefaultSpecifier: "import default specifier",
-	ImportNamespaceSpecifier: "import namespace specifier",
-	ObjectPattern: "object destructuring pattern",
-	ParenthesizedExpression: "parenthesized expression",
-	RestElement: "rest element",
-	UpdateExpression: {
-		true: "prefix operation",
-		false: "postfix operation"
-	},
-	VariableDeclarator: "variable declaration",
-	YieldExpression: "yield expression"
-};
-const toNodeDescription = (node) => node.type === "UpdateExpression" ? NodeDescriptions.UpdateExpression[`${node.prefix}`] : NodeDescriptions[node.type];
-const StandardErrors = {
-	AccessorIsGenerator: ({ kind }) => `A ${kind}ter cannot be a generator.`,
-	ArgumentsInClass: "'arguments' is only allowed in functions and class methods.",
-	AsyncFunctionInSingleStatementContext: "Async functions can only be declared at the top level or inside a block.",
-	AwaitBindingIdentifier: "Can not use 'await' as identifier inside an async function.",
-	AwaitBindingIdentifierInStaticBlock: "Can not use 'await' as identifier inside a static block.",
-	AwaitExpressionFormalParameter: "'await' is not allowed in async function parameters.",
-	AwaitUsingNotInAsyncContext: "'await using' is only allowed within async functions and at the top levels of modules.",
-	AwaitNotInAsyncContext: "'await' is only allowed within async functions and at the top levels of modules.",
-	BadGetterArity: "A 'get' accessor must not have any formal parameters.",
-	BadSetterArity: "A 'set' accessor must have exactly one formal parameter.",
-	BadSetterRestParameter: "A 'set' accessor function argument must not be a rest parameter.",
-	ConstructorClassField: "Classes may not have a field named 'constructor'.",
-	ConstructorClassPrivateField: "Classes may not have a private field named '#constructor'.",
-	ConstructorIsAccessor: "Class constructor may not be an accessor.",
-	ConstructorIsAsync: "Constructor can't be an async function.",
-	ConstructorIsGenerator: "Constructor can't be a generator.",
-	DeclarationMissingInitializer: ({ kind }) => `Missing initializer in ${kind} declaration.`,
-	DecoratorArgumentsOutsideParentheses: "Decorator arguments must be moved inside parentheses: use '@(decorator(args))' instead of '@(decorator)(args)'.",
-	DecoratorsBeforeAfterExport: "Decorators can be placed *either* before or after the 'export' keyword, but not in both locations at the same time.",
-	DecoratorConstructor: "Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?",
-	DecoratorSemicolon: "Decorators must not be followed by a semicolon.",
-	DecoratorStaticBlock: "Decorators can't be used with a static block.",
-	DeferImportRequiresNamespace: "Only `import defer * as x from \"./module\"` is valid.",
-	DeletePrivateField: "Deleting a private field is not allowed.",
-	DestructureNamedImport: "ES2015 named imports do not destructure. Use another statement for destructuring after the import.",
-	DuplicateConstructor: "Duplicate constructor in the same class.",
-	DuplicateDefaultExport: "Only one default export allowed per module.",
-	DuplicateExport: ({ exportName }) => `\`${exportName}\` has already been exported. Exported identifiers must be unique.`,
-	DuplicateProto: "Redefinition of __proto__ property.",
-	DuplicateRegExpFlags: "Duplicate regular expression flag.",
-	ElementAfterRest: "Rest element must be last element.",
-	EscapedCharNotAnIdentifier: "Invalid Unicode escape.",
-	ExportBindingIsString: ({ localName, exportName }) => `A string literal cannot be used as an exported binding without \`from\`.\n- Did you mean \`export { '${localName}' as '${exportName}' } from 'some-module'\`?`,
-	ExportDefaultFromAsIdentifier: "'from' is not allowed as an identifier after 'export default'.",
-	ForInOfLoopInitializer: ({ type }) => `'${type === "ForInStatement" ? "for-in" : "for-of"}' loop variable declaration may not have an initializer.`,
-	ForInUsing: "For-in loop may not start with 'using' declaration.",
-	ForOfAsync: "The left-hand side of a for-of loop may not be 'async'.",
-	ForOfLet: "The left-hand side of a for-of loop may not start with 'let'.",
-	GeneratorInSingleStatementContext: "Generators can only be declared at the top level or inside a block.",
-	IllegalBreakContinue: ({ type }) => `Unsyntactic ${type === "BreakStatement" ? "break" : "continue"}.`,
-	IllegalLanguageModeDirective: "Illegal 'use strict' directive in function with non-simple parameter list.",
-	IllegalReturn: "'return' outside of function.",
-	ImportBindingIsString: ({ importName }) => `A string literal cannot be used as an imported binding.\n- Did you mean \`import { "${importName}" as foo }\`?`,
-	ImportCallArity: ({ phase }) => `\`import${phase ? `.${phase}` : ""}()\` requires exactly one or two arguments.`,
-	ImportCallNotNewExpression: ({ phase }) => `Cannot use new with import${phase ? `.${phase}` : ""}().`,
-	ImportCallSpreadArgument: ({ phase }) => `\`...\` is not allowed in \`import${phase ? `.${phase}` : ""}()\`.`,
-	IncompatibleRegExpUVFlags: "The 'u' and 'v' regular expression flags cannot be enabled at the same time.",
-	InvalidBigIntLiteral: "Invalid BigIntLiteral.",
-	InvalidCodePoint: "Code point out of bounds.",
-	InvalidCoverDiscardElement: "'void' must be followed by an expression when not used in a binding position.",
-	InvalidCoverInitializedName: "Invalid shorthand property initializer.",
-	InvalidDigit: ({ radix }) => `Expected number in radix ${radix}.`,
-	InvalidEscapeSequence: "Bad character escape sequence.",
-	InvalidEscapeSequenceTemplate: "Invalid escape sequence in template.",
-	InvalidEscapedReservedWord: ({ reservedWord }) => `Escape sequence in keyword ${reservedWord}.`,
-	InvalidIdentifier: ({ identifierName }) => `Invalid identifier ${identifierName}.`,
-	InvalidLhs: ({ ancestor }) => `Invalid left-hand side in ${toNodeDescription(ancestor)}.`,
-	InvalidLhsBinding: ({ ancestor }) => `Binding invalid left-hand side in ${toNodeDescription(ancestor)}.`,
-	InvalidLhsOptionalChaining: ({ ancestor }) => `Invalid optional chaining in the left-hand side of ${toNodeDescription(ancestor)}.`,
-	InvalidNumber: "Invalid number.",
-	InvalidOrMissingExponent: "Floating-point numbers require a valid exponent after the 'e'.",
-	InvalidOrUnexpectedToken: ({ unexpected }) => `Unexpected character '${unexpected}'.`,
-	InvalidParenthesizedAssignment: "Invalid parenthesized assignment pattern.",
-	InvalidPrivateFieldResolution: ({ identifierName }) => `Private name #${identifierName} is not defined.`,
-	InvalidPropertyBindingPattern: "Binding member expression.",
-	InvalidRestAssignmentPattern: "Invalid rest operator's argument.",
-	LabelRedeclaration: ({ labelName }) => `Label '${labelName}' is already declared.`,
-	LetInLexicalBinding: "'let' is disallowed as a lexically bound name.",
-	LineTerminatorBeforeArrow: "No line break is allowed before '=>'.",
-	MalformedRegExpFlags: "Invalid regular expression flag.",
-	MissingClassName: "A class name is required.",
-	MissingEqInAssignment: "Only '=' operator can be used for specifying default value.",
-	MissingSemicolon: "Missing semicolon.",
-	MissingPlugin: ({ missingPlugin }) => `This experimental syntax requires enabling the parser plugin: ${missingPlugin.map((name) => JSON.stringify(name)).join(", ")}.`,
-	MissingOneOfPlugins: ({ missingPlugin }) => `This experimental syntax requires enabling one of the following parser plugin(s): ${missingPlugin.map((name) => JSON.stringify(name)).join(", ")}.`,
-	MissingUnicodeEscape: "Expecting Unicode escape sequence \\uXXXX.",
-	MixingCoalesceWithLogical: "Nullish coalescing operator(??) requires parens when mixing with logical operators.",
-	ModuleAttributeInvalidValue: "Only string literals are allowed as module attribute values.",
-	ModuleAttributesWithDuplicateKeys: ({ key }) => `Duplicate key "${key}" is not allowed in module attributes.`,
-	ModuleExportNameHasLoneSurrogate: ({ surrogateCharCode }) => `An export name cannot include a lone surrogate, found '\\u${surrogateCharCode.toString(16)}'.`,
-	ModuleExportUndefined: ({ localName }) => `Export '${localName}' is not defined.`,
-	MultipleDefaultsInSwitch: "Multiple default clauses.",
-	NewlineAfterThrow: "Illegal newline after throw.",
-	NoCatchOrFinally: "Missing catch or finally clause.",
-	NumberIdentifier: "Identifier directly after number.",
-	NumericSeparatorInEscapeSequence: "Numeric separators are not allowed inside unicode escape sequences or hex escape sequences.",
-	ObsoleteAwaitStar: "'await*' has been removed from the async functions proposal. Use Promise.all() instead.",
-	OptionalChainingNoNew: "Constructors in/after an Optional Chain are not allowed.",
-	OptionalChainingNoTemplate: "Tagged Template Literals are not allowed in optionalChain.",
-	OverrideOnConstructor: "'override' modifier cannot appear on a constructor declaration.",
-	ParamDupe: "Argument name clash.",
-	PatternHasAccessor: "Object pattern can't contain getter or setter.",
-	PatternHasMethod: "Object pattern can't contain methods.",
-	PrivateInExpectedIn: ({ identifierName }) => `Private names are only allowed in property accesses (\`obj.#${identifierName}\`) or in \`in\` expressions (\`#${identifierName} in obj\`).`,
-	PrivateNameRedeclaration: ({ identifierName }) => `Duplicate private name #${identifierName}.`,
-	RestTrailingComma: "Unexpected trailing comma after rest element.",
-	SloppyFunction: "In non-strict mode code, functions can only be declared at top level or inside a block.",
-	SloppyFunctionAnnexB: "In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement.",
-	SourcePhaseImportRequiresDefault: "Only `import source x from \"./module\"` is valid.",
-	StaticPrototype: "Classes may not have static property named prototype.",
-	SuperCallNotNewExpression: "Cannot use new with super(...).",
-	SuperNotAllowed: "`super()` is only valid inside a class constructor of a subclass. Maybe a typo in the method name ('constructor') or not extending another class?",
-	SuperPrivateField: "Private fields can't be accessed on super.",
-	TrailingDecorator: "Decorators must be attached to a class element.",
-	UnexpectedArgumentPlaceholder: "Unexpected argument placeholder.",
-	UnexpectedDigitAfterHash: "Unexpected digit after hash token.",
-	UnexpectedImportExport: "'import' and 'export' may only appear at the top level.",
-	UnexpectedKeyword: ({ keyword }) => `Unexpected keyword '${keyword}'.`,
-	UnexpectedLeadingDecorator: "Leading decorators must be attached to a class declaration.",
-	UnexpectedLexicalDeclaration: "Lexical declaration cannot appear in a single-statement context.",
-	UnexpectedNewTarget: "`new.target` can only be used in functions or class properties.",
-	UnexpectedNumericSeparator: "A numeric separator is only allowed between two digits.",
-	UnexpectedPrivateField: "Unexpected private name.",
-	UnexpectedReservedWord: ({ reservedWord }) => `Unexpected reserved word '${reservedWord}'.`,
-	UnexpectedSuper: "'super' is only allowed in object methods and classes.",
-	UnexpectedToken: ({ expected, unexpected }) => `Unexpected token${unexpected ? ` '${unexpected}'.` : ""}${expected ? `, expected "${expected}"` : ""}`,
-	UnexpectedTokenUnaryExponentiation: "Illegal expression. Wrap left hand side or entire exponentiation in parentheses.",
-	UnexpectedUsingDeclaration: "Using declaration cannot appear in the top level when source type is `script` or in the bare case statement.",
-	UnexpectedVoidPattern: "Unexpected void binding.",
-	UnsupportedDecoratorExport: "A decorated export must export a class declaration.",
-	UnsupportedDefaultExport: "Only expressions, functions or classes are allowed as the `default` export.",
-	UnsupportedImport: "`import` can only be used in `import()` or `import.meta`.",
-	UnsupportedMetaProperty: ({ target, onlyValidPropertyName }) => `The only valid meta property for ${target} is ${target}.${onlyValidPropertyName}.`,
-	UnsupportedParameterDecorator: "Decorators cannot be used to decorate parameters.",
-	UnsupportedPropertyDecorator: "Decorators cannot be used to decorate object literal properties.",
-	UnsupportedSuper: "'super' can only be used with function calls (i.e. super()) or in property accesses (i.e. super.prop or super[prop]).",
-	UnterminatedComment: "Unterminated comment.",
-	UnterminatedRegExp: "Unterminated regular expression.",
-	UnterminatedString: "Unterminated string constant.",
-	UnterminatedTemplate: "Unterminated template.",
-	UsingDeclarationExport: "Using declaration cannot be exported.",
-	UsingDeclarationHasBindingPattern: "Using declaration cannot have destructuring patterns.",
-	VarRedeclaration: ({ identifierName }) => `Identifier '${identifierName}' has already been declared.`,
-	VoidPatternCatchClauseParam: "A void binding can not be the catch clause parameter. Use `try { ... } catch { ... }` if you want to discard the caught error.",
-	VoidPatternInitializer: "A void binding may not have an initializer.",
-	YieldBindingIdentifier: "Can not use 'yield' as identifier inside a generator.",
-	YieldInParameter: "Yield expression is not allowed in formal parameters.",
-	YieldNotInGeneratorFunction: "'yield' is only allowed within generator functions.",
-	ZeroDigitNumericSeparator: "Numeric separator can not be used after leading 0."
-};
-const StrictModeErrors = {
-	StrictDelete: "Deleting local variable in strict mode.",
-	StrictEvalArguments: ({ referenceName }) => `Assigning to '${referenceName}' in strict mode.`,
-	StrictEvalArgumentsBinding: ({ bindingName }) => `Binding '${bindingName}' in strict mode.`,
-	StrictFunction: "In strict mode code, functions can only be declared at top level or inside a block.",
-	StrictNumericEscape: "The only valid numeric escape in strict mode is '\\0'.",
-	StrictOctalLiteral: "Legacy octal literals are not allowed in strict mode.",
-	StrictWith: "'with' in strict mode."
-};
-const ParseExpressionErrors = {
-	ParseExpressionEmptyInput: "Unexpected parseExpression() input: The input is empty or contains only comments.",
-	ParseExpressionExpectsEOF: ({ unexpected }) => `Unexpected parseExpression() input: The input should contain exactly one expression, but the first expression is followed by the unexpected character \`${String.fromCodePoint(unexpected)}\`.`
-};
-const PipelineOperatorErrors = {
-	PipeTopicRequiresHackPipes: "Topic references are only supported when using the `\"proposal\": \"hack\"` version of the pipeline proposal.",
-	PipeTopicUnbound: "Topic reference is unbound; it must be inside a pipe body.",
-	PipeTopicUnconfiguredToken: ({ token }) => `Invalid topic token ${token}. In order to use ${token} as a topic reference, the pipelineOperator plugin must be configured with { "proposal": "hack", "topicToken": "${token}" }.`,
-	PipeTopicUnused: "Hack-style pipe body does not contain a topic reference; Hack-style pipes must use topic at least once.",
-	PipeUnparenthesizedBody: ({ type }) => `Hack-style pipe body cannot be an unparenthesized ${toNodeDescription({ type })}; please wrap it in parentheses.`,
-	PipelineUnparenthesized: "Cannot mix binary operator with solo-await F#-style pipeline. Please wrap the pipeline in parentheses."
-};
-const FunctionBindErrors = {
-	UnsupportedBind: "Binding should be performed on object property.",
-	UnsupportedBindRHS: "The right-hand side of binding can not be super or import."
-};
-function defineHidden(obj, key, value) {
-	Object.defineProperty(obj, key, {
-		enumerable: false,
-		configurable: true,
-		value
-	});
-}
-function toParseErrorConstructor({ toMessage, code, reasonCode, syntaxPlugin }) {
-	const hasMissingPlugin = reasonCode === "MissingPlugin" || reasonCode === "MissingOneOfPlugins";
-	return function constructor(loc, pos, details) {
-		const error = /* @__PURE__ */ new SyntaxError();
-		error.code = code;
-		error.reasonCode = reasonCode;
-		error.loc = loc;
-		error.pos = pos;
-		error.syntaxPlugin = syntaxPlugin;
-		if (hasMissingPlugin) error.missingPlugin = details.missingPlugin;
-		defineHidden(error, "clone", function clone(overrides = {}) {
-			const { line, column, index = pos } = overrides.loc ?? loc;
-			return constructor(new Position(line, column), index, {
-				...details,
-				...overrides.details
-			});
-		});
-		defineHidden(error, "details", details);
-		Object.defineProperty(error, "message", {
-			configurable: true,
-			get() {
-				const message = `${toMessage(details)} (${loc.line}:${loc.column})`;
-				this.message = message;
-				return message;
-			},
-			set(value) {
-				Object.defineProperty(this, "message", {
-					value,
-					writable: true
-				});
-			}
-		});
-		return error;
-	};
-}
-function ParseErrorEnum(argument, syntaxPlugin) {
-	if (Array.isArray(argument)) return (parseErrorTemplates) => ParseErrorEnum(parseErrorTemplates, argument[0]);
-	const ParseErrorConstructors = {};
-	for (const reasonCode of Object.keys(argument)) {
-		const template = argument[reasonCode];
-		const { message, ...rest } = typeof template === "string" ? { message: () => template } : typeof template === "function" ? { message: template } : template;
-		ParseErrorConstructors[reasonCode] = toParseErrorConstructor({
-			code: "BABEL_PARSER_SYNTAX_ERROR",
-			reasonCode,
-			toMessage: typeof message === "string" ? () => message : message,
-			...syntaxPlugin ? { syntaxPlugin } : {},
-			...rest
-		});
-	}
-	return ParseErrorConstructors;
-}
-({
-	...ParseErrorEnum(ModuleErrors),
-	...ParseErrorEnum(StandardErrors),
-	...ParseErrorEnum(StrictModeErrors),
-	...ParseErrorEnum(ParseExpressionErrors),
-	...ParseErrorEnum`pipelineOperator`(PipelineOperatorErrors),
-	...ParseErrorEnum`functionBind`(FunctionBindErrors)
-});
-const beforeExpr = true;
-const startsExpr = true;
-const isLoop = true;
-const isAssign = true;
-const prefix = true;
-const postfix = true;
-var ExportedTokenType = class {
-	label;
-	keyword;
-	beforeExpr;
-	startsExpr;
-	rightAssociative;
-	isLoop;
-	isAssign;
-	prefix;
-	postfix;
-	binop;
-	constructor(label, conf = {}) {
-		this.label = label;
-		this.keyword = conf.keyword;
-		this.beforeExpr = !!conf.beforeExpr;
-		this.startsExpr = !!conf.startsExpr;
-		this.rightAssociative = !!conf.rightAssociative;
-		this.isLoop = !!conf.isLoop;
-		this.isAssign = !!conf.isAssign;
-		this.prefix = !!conf.prefix;
-		this.postfix = !!conf.postfix;
-		this.binop = conf.binop != null ? conf.binop : null;
-	}
-};
-const keywords$1 = /* @__PURE__ */ new Map();
-function createKeyword(name, options = {}) {
-	options.keyword = name;
-	const token = createToken(name, options);
-	keywords$1.set(name, token);
-	return token;
-}
-function createBinop(name, binop) {
-	return createToken(name, {
-		beforeExpr,
-		binop
-	});
-}
-let tokenTypeCounter = -1;
-const tokenTypes = [];
-const tokenLabels = [];
-const tokenBinops = [];
-const tokenBeforeExprs = [];
-const tokenStartsExprs = [];
-const tokenPrefixes = [];
-function createToken(name, options = {}) {
-	++tokenTypeCounter;
-	tokenLabels.push(name);
-	tokenBinops.push(options.binop ?? -1);
-	tokenBeforeExprs.push(options.beforeExpr ?? false);
-	tokenStartsExprs.push(options.startsExpr ?? false);
-	tokenPrefixes.push(options.prefix ?? false);
-	tokenTypes.push(new ExportedTokenType(name, options));
-	return tokenTypeCounter;
-}
-function createKeywordLike(name, options = {}) {
-	++tokenTypeCounter;
-	keywords$1.set(name, tokenTypeCounter);
-	tokenLabels.push(name);
-	tokenBinops.push(options.binop ?? -1);
-	tokenBeforeExprs.push(options.beforeExpr ?? false);
-	tokenStartsExprs.push(options.startsExpr ?? false);
-	tokenPrefixes.push(options.prefix ?? false);
-	tokenTypes.push(new ExportedTokenType("name", options));
-	return tokenTypeCounter;
-}
-const tt = {
-	bracketL: createToken("[", {
-		beforeExpr,
-		startsExpr
-	}),
-	bracketR: createToken("]"),
-	braceL: createToken("{", {
-		beforeExpr,
-		startsExpr
-	}),
-	braceBarL: createToken("{|", {
-		beforeExpr,
-		startsExpr
-	}),
-	braceR: createToken("}"),
-	braceBarR: createToken("|}"),
-	parenL: createToken("(", {
-		beforeExpr,
-		startsExpr
-	}),
-	parenR: createToken(")"),
-	comma: createToken(",", { beforeExpr }),
-	semi: createToken(";", { beforeExpr }),
-	colon: createToken(":", { beforeExpr }),
-	doubleColon: createToken("::", { beforeExpr }),
-	dot: createToken("."),
-	question: createToken("?", { beforeExpr }),
-	questionDot: createToken("?."),
-	arrow: createToken("=>", { beforeExpr }),
-	template: createToken("template"),
-	ellipsis: createToken("...", { beforeExpr }),
-	backQuote: createToken("`", { startsExpr }),
-	dollarBraceL: createToken("${", {
-		beforeExpr,
-		startsExpr
-	}),
-	templateTail: createToken("...`", { startsExpr }),
-	templateNonTail: createToken("...${", {
-		beforeExpr,
-		startsExpr
-	}),
-	at: createToken("@"),
-	hash: createToken("#", { startsExpr }),
-	interpreterDirective: createToken("#!..."),
-	eq: createToken("=", {
-		beforeExpr,
-		isAssign
-	}),
-	assign: createToken("_=", {
-		beforeExpr,
-		isAssign
-	}),
-	slashAssign: createToken("_=", {
-		beforeExpr,
-		isAssign
-	}),
-	xorAssign: createToken("_=", {
-		beforeExpr,
-		isAssign
-	}),
-	moduloAssign: createToken("_=", {
-		beforeExpr,
-		isAssign
-	}),
-	incDec: createToken("++/--", {
-		prefix,
-		postfix,
-		startsExpr
-	}),
-	bang: createToken("!", {
-		beforeExpr,
-		prefix,
-		startsExpr
-	}),
-	tilde: createToken("~", {
-		beforeExpr,
-		prefix,
-		startsExpr
-	}),
-	doubleCaret: createToken("^^", { startsExpr }),
-	doubleAt: createToken("@@", { startsExpr }),
-	pipeline: createBinop("|>", 0),
-	nullishCoalescing: createBinop("??", 1),
-	logicalOR: createBinop("||", 1),
-	logicalAND: createBinop("&&", 2),
-	bitwiseOR: createBinop("|", 3),
-	bitwiseXOR: createBinop("^", 4),
-	bitwiseAND: createBinop("&", 5),
-	equality: createBinop("==/!=/===/!==", 6),
-	lt: createBinop("</>/<=/>=", 7),
-	gt: createBinop("</>/<=/>=", 7),
-	relational: createBinop("</>/<=/>=", 7),
-	bitShift: createBinop("<</>>/>>>", 8),
-	bitShiftL: createBinop("<</>>/>>>", 8),
-	bitShiftR: createBinop("<</>>/>>>", 8),
-	plusMin: createToken("+/-", {
-		beforeExpr,
-		binop: 9,
-		prefix,
-		startsExpr
-	}),
-	modulo: createToken("%", {
-		binop: 10,
-		startsExpr
-	}),
-	star: createToken("*", { binop: 10 }),
-	slash: createBinop("/", 10),
-	exponent: createToken("**", {
-		beforeExpr,
-		binop: 11,
-		rightAssociative: true
-	}),
-	_in: createKeyword("in", {
-		beforeExpr,
-		binop: 7
-	}),
-	_instanceof: createKeyword("instanceof", {
-		beforeExpr,
-		binop: 7
-	}),
-	_break: createKeyword("break"),
-	_case: createKeyword("case", { beforeExpr }),
-	_catch: createKeyword("catch"),
-	_continue: createKeyword("continue"),
-	_debugger: createKeyword("debugger"),
-	_default: createKeyword("default", { beforeExpr }),
-	_else: createKeyword("else", { beforeExpr }),
-	_finally: createKeyword("finally"),
-	_function: createKeyword("function", { startsExpr }),
-	_if: createKeyword("if"),
-	_return: createKeyword("return", { beforeExpr }),
-	_switch: createKeyword("switch"),
-	_throw: createKeyword("throw", {
-		beforeExpr,
-		prefix,
-		startsExpr
-	}),
-	_try: createKeyword("try"),
-	_var: createKeyword("var"),
-	_const: createKeyword("const"),
-	_with: createKeyword("with"),
-	_new: createKeyword("new", {
-		beforeExpr,
-		startsExpr
-	}),
-	_this: createKeyword("this", { startsExpr }),
-	_super: createKeyword("super", { startsExpr }),
-	_class: createKeyword("class", { startsExpr }),
-	_extends: createKeyword("extends", { beforeExpr }),
-	_export: createKeyword("export"),
-	_import: createKeyword("import", { startsExpr }),
-	_null: createKeyword("null", { startsExpr }),
-	_true: createKeyword("true", { startsExpr }),
-	_false: createKeyword("false", { startsExpr }),
-	_typeof: createKeyword("typeof", {
-		beforeExpr,
-		prefix,
-		startsExpr
-	}),
-	_void: createKeyword("void", {
-		beforeExpr,
-		prefix,
-		startsExpr
-	}),
-	_delete: createKeyword("delete", {
-		beforeExpr,
-		prefix,
-		startsExpr
-	}),
-	_do: createKeyword("do", {
-		isLoop,
-		beforeExpr
-	}),
-	_for: createKeyword("for", { isLoop }),
-	_while: createKeyword("while", { isLoop }),
-	_as: createKeywordLike("as", { startsExpr }),
-	_assert: createKeywordLike("assert", { startsExpr }),
-	_async: createKeywordLike("async", { startsExpr }),
-	_await: createKeywordLike("await", { startsExpr }),
-	_defer: createKeywordLike("defer", { startsExpr }),
-	_from: createKeywordLike("from", { startsExpr }),
-	_get: createKeywordLike("get", { startsExpr }),
-	_let: createKeywordLike("let", { startsExpr }),
-	_meta: createKeywordLike("meta", { startsExpr }),
-	_of: createKeywordLike("of", { startsExpr }),
-	_sent: createKeywordLike("sent", { startsExpr }),
-	_set: createKeywordLike("set", { startsExpr }),
-	_source: createKeywordLike("source", { startsExpr }),
-	_static: createKeywordLike("static", { startsExpr }),
-	_using: createKeywordLike("using", { startsExpr }),
-	_yield: createKeywordLike("yield", { startsExpr }),
-	_asserts: createKeywordLike("asserts", { startsExpr }),
-	_checks: createKeywordLike("checks", { startsExpr }),
-	_exports: createKeywordLike("exports", { startsExpr }),
-	_global: createKeywordLike("global", { startsExpr }),
-	_implements: createKeywordLike("implements", { startsExpr }),
-	_intrinsic: createKeywordLike("intrinsic", { startsExpr }),
-	_infer: createKeywordLike("infer", { startsExpr }),
-	_is: createKeywordLike("is", { startsExpr }),
-	_mixins: createKeywordLike("mixins", { startsExpr }),
-	_proto: createKeywordLike("proto", { startsExpr }),
-	_require: createKeywordLike("require", { startsExpr }),
-	_satisfies: createKeywordLike("satisfies", { startsExpr }),
-	_keyof: createKeywordLike("keyof", { startsExpr }),
-	_readonly: createKeywordLike("readonly", { startsExpr }),
-	_unique: createKeywordLike("unique", { startsExpr }),
-	_abstract: createKeywordLike("abstract", { startsExpr }),
-	_declare: createKeywordLike("declare", { startsExpr }),
-	_enum: createKeywordLike("enum", { startsExpr }),
-	_module: createKeywordLike("module", { startsExpr }),
-	_namespace: createKeywordLike("namespace", { startsExpr }),
-	_interface: createKeywordLike("interface", { startsExpr }),
-	_type: createKeywordLike("type", { startsExpr }),
-	_opaque: createKeywordLike("opaque", { startsExpr }),
-	name: createToken("name", { startsExpr }),
-	placeholder: createToken("%%", { startsExpr }),
-	string: createToken("string", { startsExpr }),
-	num: createToken("num", { startsExpr }),
-	bigint: createToken("bigint", { startsExpr }),
-	regexp: createToken("regexp", { startsExpr }),
-	privateName: createToken("#name", { startsExpr }),
-	eof: createToken("eof"),
-	jsxName: createToken("jsxName"),
-	jsxText: createToken("jsxText", { beforeExpr }),
-	jsxTagStart: createToken("jsxTagStart", { startsExpr }),
-	jsxTagEnd: createToken("jsxTagEnd")
-};
-function getExportedToken(token) {
-	return tokenTypes[token];
-}
-var TokContext = class {
-	constructor(token, preserveSpace) {
-		this.token = token;
-		this.preserveSpace = !!preserveSpace;
-	}
-	token;
-	preserveSpace;
-};
-new TokContext("{"), new TokContext("<tag"), new TokContext("</tag"), new TokContext("<tag>...</tag>", true);
-const reservedWords = {
-	keyword: [
-		"break",
-		"case",
-		"catch",
-		"continue",
-		"debugger",
-		"default",
-		"do",
-		"else",
-		"finally",
-		"for",
-		"function",
-		"if",
-		"return",
-		"switch",
-		"throw",
-		"try",
-		"var",
-		"const",
-		"while",
-		"with",
-		"new",
-		"this",
-		"super",
-		"class",
-		"extends",
-		"export",
-		"import",
-		"null",
-		"true",
-		"false",
-		"in",
-		"instanceof",
-		"typeof",
-		"void",
-		"delete"
-	],
-	strict: [
-		"implements",
-		"interface",
-		"let",
-		"package",
-		"private",
-		"protected",
-		"public",
-		"static",
-		"yield"
-	],
-	strictBind: ["eval", "arguments"]
-};
-new Set(reservedWords.keyword);
-new Set(reservedWords.strict);
-new Set(reservedWords.strictBind);
-ParseErrorEnum`flow`({
-	AmbiguousConditionalArrow: "Ambiguous expression: wrap the arrow functions in parentheses to disambiguate.",
-	AmbiguousDeclareModuleKind: "Found both `declare module.exports` and `declare export` in the same module. Modules can only have 1 since they are either an ES module or they are a CommonJS module.",
-	AssignReservedType: ({ reservedType }) => `Cannot overwrite reserved type ${reservedType}.`,
-	DeclareClassElement: "The `declare` modifier can only appear on class fields.",
-	DeclareClassFieldInitializer: "Initializers are not allowed in fields with the `declare` modifier.",
-	DuplicateDeclareModuleExports: "Duplicate `declare module.exports` statement.",
-	EnumBooleanMemberNotInitialized: ({ memberName, enumName }) => `Boolean enum members need to be initialized. Use either \`${memberName} = true,\` or \`${memberName} = false,\` in enum \`${enumName}\`.`,
-	EnumDuplicateMemberName: ({ memberName, enumName }) => `Enum member names need to be unique, but the name \`${memberName}\` has already been used before in enum \`${enumName}\`.`,
-	EnumInconsistentMemberValues: ({ enumName }) => `Enum \`${enumName}\` has inconsistent member initializers. Either use no initializers, or consistently use literals (either booleans, numbers, or strings) for all member initializers.`,
-	EnumInvalidExplicitType: ({ invalidEnumType, enumName }) => `Enum type \`${invalidEnumType}\` is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`,
-	EnumInvalidExplicitTypeUnknownSupplied: ({ enumName }) => `Supplied enum type is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`,
-	EnumInvalidMemberInitializerPrimaryType: ({ enumName, memberName, explicitType }) => `Enum \`${enumName}\` has type \`${explicitType}\`, so the initializer of \`${memberName}\` needs to be a ${explicitType} literal.`,
-	EnumInvalidMemberInitializerSymbolType: ({ enumName, memberName }) => `Symbol enum members cannot be initialized. Use \`${memberName},\` in enum \`${enumName}\`.`,
-	EnumInvalidMemberInitializerUnknownType: ({ enumName, memberName }) => `The enum member initializer for \`${memberName}\` needs to be a literal (either a boolean, number, or string) in enum \`${enumName}\`.`,
-	EnumInvalidMemberName: ({ enumName, memberName, suggestion }) => `Enum member names cannot start with lowercase 'a' through 'z'. Instead of using \`${memberName}\`, consider using \`${suggestion}\`, in enum \`${enumName}\`.`,
-	EnumNumberMemberNotInitialized: ({ enumName, memberName }) => `Number enum members need to be initialized, e.g. \`${memberName} = 1\` in enum \`${enumName}\`.`,
-	EnumStringMemberInconsistentlyInitialized: ({ enumName }) => `String enum members need to consistently either all use initializers, or use no initializers, in enum \`${enumName}\`.`,
-	GetterMayNotHaveThisParam: "A getter cannot have a `this` parameter.",
-	ImportTypeShorthandOnlyInPureImport: "The `type` and `typeof` keywords on named imports can only be used on regular `import` statements. It cannot be used with `import type` or `import typeof` statements.",
-	InexactInsideExact: "Explicit inexact syntax cannot appear inside an explicit exact object type.",
-	InexactInsideNonObject: "Explicit inexact syntax cannot appear in class or interface definitions.",
-	InexactVariance: "Explicit inexact syntax cannot have variance.",
-	InvalidNonTypeImportInDeclareModule: "Imports within a `declare module` body must always be `import type` or `import typeof`.",
-	MissingTypeParamDefault: "Type parameter declaration needs a default, since a preceding type parameter declaration has a default.",
-	NestedDeclareModule: "`declare module` cannot be used inside another `declare module`.",
-	NestedFlowComment: "Cannot have a flow comment inside another flow comment.",
-	PatternIsOptional: { message: "A binding pattern parameter cannot be optional in an implementation signature." },
-	SetterMayNotHaveThisParam: "A setter cannot have a `this` parameter.",
-	SpreadVariance: "Spread properties cannot have variance.",
-	ThisParamAnnotationRequired: "A type annotation is required for the `this` parameter.",
-	ThisParamBannedInConstructor: "Constructors cannot have a `this` parameter; constructors don't bind `this` like other functions.",
-	ThisParamMayNotBeOptional: "The `this` parameter cannot be optional.",
-	ThisParamMustBeFirst: "The `this` parameter must be the first function parameter.",
-	ThisParamNoDefault: "The `this` parameter may not have a default value.",
-	TypeBeforeInitializer: "Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.",
-	TypeCastInPattern: "The type cast expression is expected to be wrapped with parenthesis.",
-	UnexpectedExplicitInexactInObject: "Explicit inexact syntax must appear at the end of an inexact object.",
-	UnexpectedReservedType: ({ reservedType }) => `Unexpected reserved type ${reservedType}.`,
-	UnexpectedReservedUnderscore: "`_` is only allowed as a type argument to call or new.",
-	UnexpectedSpaceBetweenModuloChecks: "Spaces between `%` and `checks` are not allowed here.",
-	UnexpectedSpreadType: "Spread operator cannot appear in class or interface definitions.",
-	UnexpectedSubtractionOperand: "Unexpected token, expected \"number\" or \"bigint\".",
-	UnexpectedTokenAfterTypeParameter: "Expected an arrow function after this type parameter declaration.",
-	UnexpectedTypeParameterBeforeAsyncArrowFunction: "Type parameters must come after the async keyword, e.g. instead of `<T> async () => {}`, use `async <T>() => {}`.",
-	UnsupportedDeclareExportKind: ({ unsupportedExportKind, suggestion }) => `\`declare export ${unsupportedExportKind}\` is not supported. Use \`${suggestion}\` instead.`,
-	UnsupportedStatementInDeclareModule: "Only declares and type imports are allowed inside declare module.",
-	UnterminatedFlowComment: "Unterminated flow-comment."
-});
-new RegExp(/\r\n|[\r\n\u2028\u2029]/.source, "g");
-ParseErrorEnum`jsx`({
-	AttributeIsEmpty: "JSX attributes must only be assigned a non-empty expression.",
-	MissingClosingTagElement: ({ openingTagName }) => `Expected corresponding JSX closing tag for <${openingTagName}>.`,
-	MissingClosingTagFragment: "Expected corresponding JSX closing tag for <>.",
-	UnexpectedSequenceExpression: "Sequence expressions cannot be directly nested inside JSX. Did you mean to wrap it in parentheses (...)?",
-	UnexpectedToken: ({ unexpected, HTMLEntity }) => `Unexpected token \`${unexpected}\`. Did you mean \`${HTMLEntity}\` or \`{'${unexpected}'}\`?`,
-	UnsupportedJsxValue: "JSX value should be either an expression or a quoted JSX text.",
-	UnterminatedJsxContent: "Unterminated JSX contents.",
-	UnwrappedAdjacentJSXElements: "Adjacent JSX elements must be wrapped in an enclosing tag. Did you want a JSX fragment <>...</>?"
-});
-var Node = class {
-	constructor(optionFlags, filename, pos, loc) {
-		this.start = pos;
-		this.end = 0;
-		if (loc !== void 0) this.loc = new SourceLocation(loc);
-		if (optionFlags & 128) this.range = [pos, 0];
-		if (loc !== void 0 && filename) this.loc.filename = filename;
-	}
-	type = "";
-};
-Node.prototype;
-ParseErrorEnum`typescript`({
-	AbstractMethodHasImplementation: ({ methodName }) => `Method '${methodName}' cannot have an implementation because it is marked abstract.`,
-	AbstractPropertyHasInitializer: ({ propertyName }) => `Property '${propertyName}' cannot have an initializer because it is marked abstract.`,
-	AccessorCannotBeOptional: "An 'accessor' property cannot be declared optional.",
-	AccessorCannotDeclareThisParameter: "'get' and 'set' accessors cannot declare 'this' parameters.",
-	AccessorCannotHaveTypeParameters: "An accessor cannot have type parameters.",
-	ClassMethodHasDeclare: "Class methods cannot have the 'declare' modifier.",
-	ClassMethodHasReadonly: "Class methods cannot have the 'readonly' modifier.",
-	ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference: "A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference.",
-	ConstructorHasTypeParameters: "Type parameters cannot appear on a constructor declaration.",
-	DeclareAccessor: ({ kind }) => `'declare' is not allowed in ${kind}ters.`,
-	DeclareClassFieldHasInitializer: "Initializers are not allowed in ambient contexts.",
-	DeclareFunctionHasImplementation: "An implementation cannot be declared in ambient contexts.",
-	DecoratorAbstractMethod: ({ kind }) => `Decorators can't be used with ${kind.startsWith("a") ? "an" : "a"} ${kind}.`,
-	DuplicateAccessibilityModifier: ({ modifier }) => `Accessibility modifier already seen: '${modifier}'.`,
-	DuplicateModifier: ({ modifier }) => `Duplicate modifier: '${modifier}'.`,
-	EmptyHeritageClauseType: ({ token }) => `'${token}' list cannot be empty.`,
-	EmptyTypeArguments: "Type argument list cannot be empty.",
-	EmptyTypeParameters: "Type parameter list cannot be empty.",
-	ExpectedAmbientAfterExportDeclare: "'export declare' must be followed by an ambient declaration.",
-	ExportAssignmentInTSNamespace: "An export assignment cannot be used in a namespace.",
-	ExportInTSNamespace: "Export declarations are not permitted in a namespace.",
-	ImportAliasHasImportType: "An import alias can not use 'import type'.",
-	ImportInTSNamespace: "Import declarations in a namespace cannot reference a module.",
-	IncompatibleModifiers: ({ modifiers }) => `'${modifiers[0]}' modifier cannot be used with '${modifiers[1]}' modifier.`,
-	IndexSignatureHasAbstract: "Index signatures cannot have the 'abstract' modifier.",
-	IndexSignatureHasAccessibility: ({ modifier }) => `Index signatures cannot have an accessibility modifier ('${modifier}').`,
-	IndexSignatureHasDeclare: "Index signatures cannot have the 'declare' modifier.",
-	IndexSignatureHasOverride: "'override' modifier cannot appear on an index signature.",
-	IndexSignatureHasStatic: "Index signatures cannot have the 'static' modifier.",
-	InitializerNotAllowedInAmbientContext: "Initializers are not allowed in ambient contexts.",
-	InlineModuleDeclarationMustUseString: "`module ... {}` declarations must have a string name. Use `namespace ... {}` instead.",
-	InvalidHeritageClauseType: ({ token }) => `'${token}' list can only include identifiers or qualified-names with optional type arguments.`,
-	InvalidModifierOnAwaitUsingDeclaration: (modifier) => `'${modifier}' modifier cannot appear on an await using declaration.`,
-	InvalidModifierOnTypeMember: ({ modifier }) => `'${modifier}' modifier cannot appear on a type member.`,
-	InvalidModifierOnTypeParameter: ({ modifier }) => `'${modifier}' modifier cannot appear on a type parameter.`,
-	InvalidModifierOnTypeParameterPositions: ({ modifier }) => `'${modifier}' modifier can only appear on a type parameter of a class, interface or type alias.`,
-	InvalidModifierOnUsingDeclaration: (modifier) => `'${modifier}' modifier cannot appear on a using declaration.`,
-	InvalidModifiersOrder: ({ orderedModifiers }) => `'${orderedModifiers[0]}' modifier must precede '${orderedModifiers[1]}' modifier.`,
-	InvalidPropertyAccessAfterInstantiationExpression: "Invalid property access after an instantiation expression. You can either wrap the instantiation expression in parentheses, or delete the type arguments.",
-	InvalidTupleMemberLabel: "Tuple members must be labeled with a simple identifier.",
-	MissingInterfaceName: "'interface' declarations must be followed by an identifier.",
-	NamespaceExportInTSNamespace: "Global module exports may only appear at top level.",
-	NonAbstractClassHasAbstractMethod: "Abstract methods can only appear within an abstract class.",
-	NonClassMethodPropertyHasAbstractModifier: "'abstract' modifier can only appear on a class, method, or property declaration.",
-	OptionalTypeBeforeRequired: "A required element cannot follow an optional element.",
-	OverrideNotInSubClass: "This member cannot have an 'override' modifier because its containing class does not extend another class.",
-	PatternIsOptional: "A binding pattern parameter cannot be optional in an implementation signature.",
-	PrivateElementHasAbstract: "Private elements cannot have the 'abstract' modifier.",
-	PrivateElementHasAccessibility: ({ modifier }) => `Private elements cannot have an accessibility modifier ('${modifier}').`,
-	ReadonlyForMethodSignature: "'readonly' modifier can only appear on a property declaration or index signature.",
-	ReservedArrowTypeParam: "This syntax is reserved in files with the .mts or .cts extension. Add a trailing comma, as in `<T,>() => ...`.",
-	ReservedTypeAssertion: "This syntax is reserved in files with the .mts or .cts extension. Use an `as` expression instead.",
-	SetAccessorCannotHaveOptionalParameter: "A 'set' accessor cannot have an optional parameter.",
-	SetAccessorCannotHaveRestParameter: "A 'set' accessor cannot have rest parameter.",
-	SetAccessorCannotHaveReturnType: "A 'set' accessor cannot have a return type annotation.",
-	SingleTypeParameterWithoutTrailingComma: ({ typeParameterName }) => `Single type parameter ${typeParameterName} should have a trailing comma. Example usage: <${typeParameterName},>.`,
-	StaticBlockCannotHaveModifier: "Static class blocks cannot have any modifier.",
-	TupleOptionalAfterType: "A labeled tuple optional element must be declared using a question mark after the name and before the colon (`name?: type`), rather than after the type (`name: type?`).",
-	TypeAnnotationAfterAssign: "Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.",
-	TypeImportCannotSpecifyDefaultAndNamed: "A type-only import can specify a default import or named bindings, but not both.",
-	TypeModifierIsUsedInTypeExports: "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement.",
-	TypeModifierIsUsedInTypeImports: "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement.",
-	UnexpectedParameterInitializer: "A parameter initializer is only allowed in a function or constructor implementation.",
-	UnexpectedParameterModifier: "A parameter property is only allowed in a constructor implementation.",
-	UnexpectedReadonly: "'readonly' type modifier is only permitted on array and tuple literal types.",
-	UnexpectedTypeAnnotation: "Did not expect a type annotation here.",
-	UnexpectedTypeCastInParameter: "Unexpected type cast in parameter position.",
-	UnexpectedTypeDeclaration: (type) => `'${type}' declarations can only be declared inside a block.`,
-	UnsupportedImportTypeArgument: "Argument in a type import must be a string literal.",
-	UnsupportedParameterPropertyKind: "A parameter property may not be declared using a binding pattern.",
-	UnsupportedSignatureParameterKind: ({ type }) => `Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ${type}.`,
-	UsingDeclarationInAmbientContext: (kind) => `'${kind}' declarations are not allowed in ambient contexts.`
-});
-ParseErrorEnum`placeholders`({
-	ClassNameIsRequired: "A class name is required.",
-	UnexpectedSpace: "Unexpected space in placeholder."
-});
-function generateExportedTokenTypes(internalTokenTypes) {
-	const tokenTypes = {};
-	for (const typeName of Object.keys(internalTokenTypes)) tokenTypes[typeName] = getExportedToken(internalTokenTypes[typeName]);
-	return tokenTypes;
-}
-generateExportedTokenTypes(tt);
-//#endregion
 //#region ../../node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/walker.js
 /**
 * @typedef { import('estree').Node} Node
@@ -31522,7 +30725,7 @@ function ensureValue(value) {
 	return value && ALLOW_EXTENSIONS.has(extname(value)) ? value.replaceAll("\\", "/") : null;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/rolldown-plugin-dts@0.25.1_@typescript+native-preview@7.0.0-dev.20260122.2_oxc-resolver_93c1f8e38767dc05c2802c79a6f0fd5e/node_modules/rolldown-plugin-dts/dist/index.mjs
+//#region ../../node_modules/.pnpm/rolldown-plugin-dts@0.25.2_@typescript+native-preview@7.0.0-dev.20260122.2_oxc-resolver_8152cf0e534aee518f40abeb59f8494a/node_modules/rolldown-plugin-dts/dist/index.mjs
 function createDtsInputPlugin({ sideEffects }) {
 	return {
 		name: "rolldown-plugin-dts:dts-input",
@@ -32068,7 +31271,8 @@ async function collectDependencies(context, node, importer, namespaceStmts, chil
 				"ObjectProperty",
 				"ClassProperty",
 				"TSPropertySignature",
-				"TSDeclareMethod"
+				"TSDeclareMethod",
+				"TSMethodSignature"
 			])) {
 				if (node.computed && isReferenceId(node.key)) addDependency(node.key);
 				if ("value" in node && isReferenceId(node.value)) addDependency(node.value);
@@ -32468,7 +31672,7 @@ function createGeneratePlugin({ entry, tsconfig, tsconfigRaw, build, incremental
 					on: (fn) => childProcess.on("message", fn)
 				});
 			} else {
-				tscModule = await import("./tsc-Dp9emiKb.js");
+				tscModule = await import("./tsc-WMktM0FW.js");
 				if (newContext) tscContext = createContext();
 			}
 			if (!Array.isArray(options.input)) for (const [name, id] of Object.entries(options.input)) {
@@ -32800,7 +32004,7 @@ function createDtsResolvePlugin({ cwd, tsconfig, tsconfigRaw, resolver, sideEffe
 	async function resolveDtsPath(id, importer, rolldownResolution) {
 		let dtsPath;
 		if (resolver === "tsc") {
-			const { tscResolve } = await import("./resolver-DkvdaW3s-Dz1U-gxd.js");
+			const { tscResolve } = await import("./resolver-DtsKFXi2-QB-x8j3e.js");
 			dtsPath = tscResolve(id, importer, cwd, tsconfig, tsconfigRaw);
 		} else dtsPath = baseDtsResolver(id, importer);
 		debug$1("Using %s for dts import: %O -> %O", resolver, id, dtsPath);