npm - @voidzero-dev/vite-plus-core - Versions diffs - 0.1.15-alpha.5 → 0.1.15-alpha.7 - Mend

@voidzero-dev/vite-plus-core 0.1.15-alpha.5 → 0.1.15-alpha.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

package/dist/tsdown/{dist-CtF_Stv5.js → dist-B98oBzil.js} RENAMED Viewed

@@ -1,19 +1,17 @@
 import { n as __exportAll, r as __toESM, t as __commonJSMin } from "./chunk-CSNpwdVU.js";
 import { t as createDebug } from "./node-B3Gdtau1.js";
-import { a as RE_JSON, c as RE_TS, d as filename_js_to_dts, f as filename_to_dts, i as RE_JS, l as RE_VUE, m as resolveTemplateFn, n as RE_DTS, o as RE_NODE_MODULES, p as replaceTemplateName, r as RE_DTS_MAP, s as RE_ROLLDOWN_RUNTIME, t as RE_CSS, u as filename_dts_to } from "./filename-UU7z2A9Z.js";
-import { n as globalContext, r as invalidateContextFile, t as createContext } from "./tsc-context-BQtoHArj.js";
-import module$1, { createRequire } from "node:module";
-import process$1 from "node:process";
+import { a as RE_JSON, c as RE_TS, d as filename_js_to_dts, f as filename_to_dts, i as RE_JS, l as RE_VUE, m as resolveTemplateFn, n as RE_DTS, o as RE_NODE_MODULES, p as replaceTemplateName, r as RE_DTS_MAP, s as RE_ROLLDOWN_RUNTIME, t as RE_CSS, u as filename_dts_to } from "./filename-DQnUJlio-B_23lF2M.js";
+import { n as pe, t as Ge } from "./dist-CxeZzY9B.js";
+import { n as globalContext, r as invalidateContextFile, t as createContext } from "./tsc-context-CltQOpVo.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 { mkdtemp, readFile, rm } from "node:fs/promises";
 import { importerId, include } from "@voidzero-dev/vite-plus-core/rolldown/filter";
-import nativeFs from "fs";
-import path$1 from "path";
+import { existsSync } from "node:fs";
 import { tmpdir } from "node:os";
-import re, { existsSync } from "node:fs";
 import { ResolverFactory, isolatedDeclarationSync } from "@voidzero-dev/vite-plus-core/rolldown/experimental";
-import Be from "os";
 //#region ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.5/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
 var comma = ",".charCodeAt(0);
 var semicolon = ";".charCodeAt(0);
@@ -307,7 +305,7 @@ function normalizePath(url, type) {
 /**
 * Attempts to resolve `input` URL/path relative to `base`.
 */
-function resolve$2(input, base) {
+function resolve$1(input, base) {
 	if (!input && !base) return "";
 	const url = parseUrl(input);
 	let inputType = url.type;
@@ -352,7 +350,7 @@ function stripFilename(path) {
 function resolver(mapUrl, sourceRoot) {
 	const from = stripFilename(mapUrl);
 	const prefix = sourceRoot ? sourceRoot + "/" : "";
-	return (source) => resolve$2(prefix + (source || ""), from);
+	return (source) => resolve$1(prefix + (source || ""), from);
 }
 var COLUMN$1 = 0;
 var SOURCES_INDEX$1 = 1;
@@ -660,12 +658,11 @@ 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.2/node_modules/@babel/helper-validator-identifier/lib/index.js
-let nonASCIIidentifierStartChars$1 = "ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙՠ-ֈא-תׯ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࡠ-ࡪࡰ-ࢇࢉ-࢏ࢠ-ࣉऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱৼਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚ౜ౝౠౡಀಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ೜-ೞೠೡೱೲഄ-ഌഎ-ഐഒ-ഺഽൎൔ-ൖൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄຆ-ຊຌ-ຣລວ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜑᜟ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡸᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭌᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᲀ-ᲊᲐ-ᲺᲽ-Ჿᳩ-ᳬᳮ-ᳳᳵᳶᳺᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄯㄱ-ㆎㆠ-ㆿㇰ-ㇿ㐀-䶿一-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-Ƛ꟱-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꣾꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭩꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ﬀ-ﬆﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ";
-let nonASCIIidentifierChars$1 = "·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-٩ٰۖ-ۜ۟-۪ۤۧۨ-ۭ۰-۹ܑܰ-݊ަ-ް߀-߉߫-߽߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛ࢗ-࢟࣊-ࣣ࣡-ःऺ-़ा-ॏ॑-ॗॢॣ०-९ঁ-ঃ়া-ৄেৈো-্ৗৢৣ০-৯৾ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑ੦-ੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣ૦-૯ૺ-૿ଁ-ଃ଼ା-ୄେୈୋ-୍୕-ୗୢୣ୦-୯ஂா-ூெ-ைொ-்ௗ௦-௯ఀ-ఄ఼ా-ౄె-ైొ-్ౕౖౢౣ౦-౯ಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣ೦-೯ೳഀ-ഃ഻഼ാ-ൄെ-ൈൊ-്ൗൢൣ൦-൯ඁ-ඃ්ා-ුූෘ-ෟ෦-෯ෲෳัิ-ฺ็-๎๐-๙ັິ-ຼ່-໎໐-໙༘༙༠-༩༹༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှ၀-၉ၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏ-ႝ፝-፟፩-፱ᜒ-᜕ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝០-៩᠋-᠍᠏-᠙ᢩᤠ-ᤫᤰ-᤻᥆-᥏᧐-᧚ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼-᪉᪐-᪙᪰-᪽ᪿ-᫝᫠-᫫ᬀ-ᬄ᬴-᭄᭐-᭙᭫-᭳ᮀ-ᮂᮡ-ᮭ᮰-᮹᯦-᯳ᰤ-᰷᱀-᱉᱐-᱙᳐-᳔᳒-᳨᳭᳴᳷-᳹᷀-᷿‌‍‿⁀⁔⃐-⃥⃜⃡-⃰⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯・꘠-꘩꙯ꙴ-꙽ꚞꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧ꠬ꢀꢁꢴ-ꣅ꣐-꣙꣠-꣱ꣿ-꤉ꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀꧐-꧙ꧥ꧰-꧹ꨩ-ꨶꩃꩌꩍ꩐-꩙ꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭꯰-꯹ﬞ︀-️︠-︯︳︴﹍-﹏０-９＿･";
+//#region ../../node_modules/.pnpm/@babel+helper-validator-identifier@8.0.0-rc.3/node_modules/@babel/helper-validator-identifier/lib/index.js
+const nonASCIIidentifierStartChars$1 = "ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙՠ-ֈא-תׯ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࡠ-ࡪࡰ-ࢇࢉ-࢏ࢠ-ࣉऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱৼਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚ౜ౝౠౡಀಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ೜-ೞೠೡೱೲഄ-ഌഎ-ഐഒ-ഺഽൎൔ-ൖൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄຆ-ຊຌ-ຣລວ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜑᜟ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡸᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭌᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᲀ-ᲊᲐ-ᲺᲽ-Ჿᳩ-ᳬᳮ-ᳳᳵᳶᳺᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄯㄱ-ㆎㆠ-ㆿㇰ-ㇿ㐀-䶿一-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-Ƛ꟱-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꣾꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭩꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ﬀ-ﬆﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ";
+const nonASCIIidentifierChars$1 = "·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-٩ٰۖ-ۜ۟-۪ۤۧۨ-ۭ۰-۹ܑܰ-݊ަ-ް߀-߉߫-߽߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛ࢗ-࢟࣊-ࣣ࣡-ःऺ-़ा-ॏ॑-ॗॢॣ०-९ঁ-ঃ়া-ৄেৈো-্ৗৢৣ০-৯৾ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑ੦-ੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣ૦-૯ૺ-૿ଁ-ଃ଼ା-ୄେୈୋ-୍୕-ୗୢୣ୦-୯ஂா-ூெ-ைொ-்ௗ௦-௯ఀ-ఄ఼ా-ౄె-ైొ-్ౕౖౢౣ౦-౯ಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣ೦-೯ೳഀ-ഃ഻഼ാ-ൄെ-ൈൊ-്ൗൢൣ൦-൯ඁ-ඃ්ා-ුූෘ-ෟ෦-෯ෲෳัิ-ฺ็-๎๐-๙ັິ-ຼ່-໎໐-໙༘༙༠-༩༹༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှ၀-၉ၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏ-ႝ፝-፟፩-፱ᜒ-᜕ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝០-៩᠋-᠍᠏-᠙ᢩᤠ-ᤫᤰ-᤻᥆-᥏᧐-᧚ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼-᪉᪐-᪙᪰-᪽ᪿ-᫝᫠-᫫ᬀ-ᬄ᬴-᭄᭐-᭙᭫-᭳ᮀ-ᮂᮡ-ᮭ᮰-᮹᯦-᯳ᰤ-᰷᱀-᱉᱐-᱙᳐-᳔᳒-᳨᳭᳴᳷-᳹᷀-᷿‌‍‿⁀⁔⃐-⃥⃜⃡-⃰⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯・꘠-꘩꙯ꙴ-꙽ꚞꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧ꠬ꢀꢁꢴ-ꣅ꣐-꣙꣠-꣱ꣿ-꤉ꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀꧐-꧙ꧥ꧰-꧹ꨩ-ꨶꩃꩌꩍ꩐-꩙ꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭꯰-꯹ﬞ︀-️︠-︯︳︴﹍-﹏０-９＿･";
 const nonASCIIidentifierStart$1 = new RegExp("[" + nonASCIIidentifierStartChars$1 + "]");
 const nonASCIIidentifier$1 = new RegExp("[" + nonASCIIidentifierStartChars$1 + nonASCIIidentifierChars$1 + "]");
-nonASCIIidentifierStartChars$1 = nonASCIIidentifierChars$1 = null;
 const astralIdentifierStartCodes$1 = [
 	0,
 	11,
@@ -1725,7 +1722,7 @@ function isKeyword$1(word) {
 	return keywords$2.has(word);
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@babel+helper-string-parser@8.0.0-rc.2/node_modules/@babel/helper-string-parser/lib/index.js
+//#region ../../node_modules/.pnpm/@babel+helper-string-parser@8.0.0-rc.3/node_modules/@babel/helper-string-parser/lib/index.js
 var _isDigit$1 = function isDigit(code) {
 	return code >= 48 && code <= 57;
 };
@@ -1945,7 +1942,7 @@ function readCodePoint$1(input, pos, lineStart, curLine, throwOnInvalid, errors)
 	};
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@babel+types@8.0.0-rc.2/node_modules/@babel/types/lib/index.js
+//#region ../../node_modules/.pnpm/@babel+types@8.0.0-rc.3/node_modules/@babel/types/lib/index.js
 var lib_exports = /* @__PURE__ */ __exportAll({
 	ACCESSOR_TYPES: () => ACCESSOR_TYPES,
 	ALIAS_KEYS: () => ALIAS_KEYS,
@@ -1968,6 +1965,7 @@ var lib_exports = /* @__PURE__ */ __exportAll({
 	BOOLEAN_UNARY_OPERATORS: () => BOOLEAN_UNARY_OPERATORS,
 	BUILDER_KEYS: () => BUILDER_KEYS,
 	BigIntLiteral: () => BigIntLiteral$1,
+	BigIntLiteralTypeAnnotation: () => BigIntLiteralTypeAnnotation,
 	BinaryExpression: () => BinaryExpression$2,
 	BindExpression: () => BindExpression$1,
 	BlockStatement: () => BlockStatement$1,
@@ -2297,6 +2295,7 @@ var lib_exports = /* @__PURE__ */ __exportAll({
 	assertAssignmentPattern: () => assertAssignmentPattern,
 	assertAwaitExpression: () => assertAwaitExpression,
 	assertBigIntLiteral: () => assertBigIntLiteral,
+	assertBigIntLiteralTypeAnnotation: () => assertBigIntLiteralTypeAnnotation,
 	assertBinary: () => assertBinary,
 	assertBinaryExpression: () => assertBinaryExpression,
 	assertBindExpression: () => assertBindExpression,
@@ -2593,6 +2592,7 @@ var lib_exports = /* @__PURE__ */ __exportAll({
 	assignmentPattern: () => assignmentPattern,
 	awaitExpression: () => awaitExpression,
 	bigIntLiteral: () => bigIntLiteral,
+	bigIntLiteralTypeAnnotation: () => bigIntLiteralTypeAnnotation,
 	binaryExpression: () => binaryExpression,
 	bindExpression: () => bindExpression,
 	blockStatement: () => blockStatement,
@@ -2707,6 +2707,7 @@ var lib_exports = /* @__PURE__ */ __exportAll({
 	isAssignmentPattern: () => isAssignmentPattern$1,
 	isAwaitExpression: () => isAwaitExpression,
 	isBigIntLiteral: () => isBigIntLiteral,
+	isBigIntLiteralTypeAnnotation: () => isBigIntLiteralTypeAnnotation,
 	isBinary: () => isBinary,
 	isBinaryExpression: () => isBinaryExpression,
 	isBindExpression: () => isBindExpression,
@@ -3554,11 +3555,6 @@ function isImportSpecifier(node, opts) {
 	if (node.type !== "ImportSpecifier") return false;
 	return opts == null || shallowEqual(node, opts);
 }
-function isImportExpression(node, opts) {
-	if (!node) return false;
-	if (node.type !== "ImportExpression") return false;
-	return opts == null || shallowEqual(node, opts);
-}
 function isMetaProperty(node, opts) {
 	if (!node) return false;
 	if (node.type !== "MetaProperty") return false;
@@ -3609,6 +3605,11 @@ function isAwaitExpression(node, opts) {
 	if (node.type !== "AwaitExpression") return false;
 	return opts == null || shallowEqual(node, opts);
 }
+function isImportExpression(node, opts) {
+	if (!node) return false;
+	if (node.type !== "ImportExpression") return false;
+	return opts == null || shallowEqual(node, opts);
+}
 function isImport(node, opts) {
 	if (!node) return false;
 	if (node.type !== "Import") return false;
@@ -3814,6 +3815,11 @@ function isNumberLiteralTypeAnnotation(node, opts) {
 	if (node.type !== "NumberLiteralTypeAnnotation") return false;
 	return opts == null || shallowEqual(node, opts);
 }
+function isBigIntLiteralTypeAnnotation(node, opts) {
+	if (!node) return false;
+	if (node.type !== "BigIntLiteralTypeAnnotation") return false;
+	return opts == null || shallowEqual(node, opts);
+}
 function isNumberTypeAnnotation(node, opts) {
 	if (!node) return false;
 	if (node.type !== "NumberTypeAnnotation") return false;
@@ -4528,7 +4534,6 @@ function isStandardized(node, opts) {
 		case "ImportDefaultSpecifier":
 		case "ImportNamespaceSpecifier":
 		case "ImportSpecifier":
-		case "ImportExpression":
 		case "MetaProperty":
 		case "ClassMethod":
 		case "ObjectPattern":
@@ -4539,6 +4544,7 @@ function isStandardized(node, opts) {
 		case "TemplateLiteral":
 		case "YieldExpression":
 		case "AwaitExpression":
+		case "ImportExpression":
 		case "Import":
 		case "BigIntLiteral":
 		case "ExportNamespaceSpecifier":
@@ -4589,13 +4595,12 @@ function isExpression$1(node, opts) {
 		case "UpdateExpression":
 		case "ArrowFunctionExpression":
 		case "ClassExpression":
-		case "ImportExpression":
 		case "MetaProperty":
 		case "TaggedTemplateExpression":
 		case "TemplateLiteral":
 		case "YieldExpression":
 		case "AwaitExpression":
-		case "Import":
+		case "ImportExpression":
 		case "BigIntLiteral":
 		case "OptionalMemberExpression":
 		case "OptionalCallExpression":
@@ -5158,6 +5163,7 @@ function isFlow(node, opts) {
 		case "EmptyTypeAnnotation":
 		case "NullableTypeAnnotation":
 		case "NumberLiteralTypeAnnotation":
+		case "BigIntLiteralTypeAnnotation":
 		case "NumberTypeAnnotation":
 		case "ObjectTypeAnnotation":
 		case "ObjectTypeInternalSlot":
@@ -5214,6 +5220,7 @@ function isFlowType(node, opts) {
 		case "EmptyTypeAnnotation":
 		case "NullableTypeAnnotation":
 		case "NumberLiteralTypeAnnotation":
+		case "BigIntLiteralTypeAnnotation":
 		case "NumberTypeAnnotation":
 		case "ObjectTypeAnnotation":
 		case "StringLiteralTypeAnnotation":
@@ -5950,6 +5957,18 @@ const classMethodOrPropertyUnionShapeCommon = (allowPrivateName = false) => ({ u
 		properties: { key: { validate: allowPrivateName ? assertNodeType("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "PrivateName") : assertNodeType("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral") } }
 	}]
 } });
+const memberExpressionUnionShapeCommon = { unionShape: {
+	discriminator: "computed",
+	shapes: [{
+		name: "computed",
+		value: [true],
+		properties: { property: { validate: assertNodeType("Expression") } }
+	}, {
+		name: "nonComputed",
+		value: [false],
+		properties: { property: { validate: assertNodeType("Identifier", "PrivateName") } }
+	}]
+} };
 const defineType$4 = defineAliasedType("Standardized");
 defineType$4("ArrayExpression", {
 	fields: { elements: {
@@ -5996,6 +6015,18 @@ defineType$4("BinaryExpression", {
 		}() },
 		right: { validate: assertNodeType("Expression") }
 	},
+	unionShape: {
+		discriminator: "operator",
+		shapes: [{
+			name: "in",
+			value: ["in"],
+			properties: { left: { validate: assertNodeType("Expression", "PrivateName") } }
+		}, {
+			name: "notIn",
+			value: BINARY_OPERATORS.filter((op) => op !== "in"),
+			properties: { left: { validate: assertNodeType("Expression") } }
+		}]
+	},
 	visitor: ["left", "right"],
 	aliases: ["Binary", "Expression"]
 });
@@ -6049,7 +6080,7 @@ defineType$4("CallExpression", {
 	builder: ["callee", "arguments"],
 	aliases: ["Expression"],
 	fields: {
-		callee: { validate: assertNodeType("Expression", "Super", "V8IntrinsicIdentifier") },
+		callee: { validate: assertNodeType("Expression", "Super", "Import", "V8IntrinsicIdentifier") },
 		arguments: validateArrayOfType("Expression", "SpreadElement", "ArgumentPlaceholder"),
 		typeArguments: {
 			validate: assertNodeType("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
@@ -6231,7 +6262,7 @@ defineType$4("FunctionDeclaration", {
 		...functionTypeAnnotationCommon(),
 		body: { validate: assertNodeType("BlockStatement") },
 		predicate: {
-			validate: assertNodeType("DeclaredPredicate", "InferredPredicate"),
+			validate: assertNodeType("FlowPredicate"),
 			optional: true
 		}
 	},
@@ -6270,7 +6301,7 @@ defineType$4("FunctionExpression", {
 		},
 		body: { validate: assertNodeType("BlockStatement") },
 		predicate: {
-			validate: assertNodeType("DeclaredPredicate", "InferredPredicate"),
+			validate: assertNodeType("FlowPredicate"),
 			optional: true
 		}
 	}
@@ -6429,8 +6460,7 @@ defineType$4("MemberExpression", {
 	builder: [
 		"object",
 		"property",
-		"computed",
-		...[]
+		"computed"
 	],
 	visitor: ["object", "property"],
 	aliases: [
@@ -6438,18 +6468,7 @@ defineType$4("MemberExpression", {
 		"LVal",
 		"PatternLike"
 	],
-	unionShape: {
-		discriminator: "computed",
-		shapes: [{
-			name: "computed",
-			value: [true],
-			properties: { property: { validate: assertNodeType("Expression") } }
-		}, {
-			name: "nonComputed",
-			value: [false],
-			properties: { property: { validate: assertNodeType("Identifier", "PrivateName") } }
-		}]
-	},
+	...memberExpressionUnionShapeCommon,
 	fields: {
 		object: { validate: assertNodeType("Expression", "Super") },
 		property: { validate: function() {
@@ -6564,21 +6583,9 @@ defineType$4("ObjectProperty", {
 		"key",
 		"value",
 		"computed",
-		"shorthand",
-		...[]
+		"shorthand"
 	],
-	unionShape: {
-		discriminator: "computed",
-		shapes: [{
-			name: "computed",
-			value: [true],
-			properties: { key: { validate: assertNodeType("Expression") } }
-		}, {
-			name: "nonComputed",
-			value: [false],
-			properties: { key: { validate: assertNodeType("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "PrivateName") } }
-		}]
-	},
+	...classMethodOrPropertyUnionShapeCommon(true),
 	fields: {
 		computed: { default: false },
 		key: { validate: function() {
@@ -6880,7 +6887,7 @@ defineType$4("ArrowFunctionExpression", {
 		expression: { validate: assertValueType("boolean") },
 		body: { validate: assertNodeType("BlockStatement", "Expression") },
 		predicate: {
-			validate: assertNodeType("DeclaredPredicate", "InferredPredicate"),
+			validate: assertNodeType("FlowPredicate"),
 			optional: true
 		}
 	}
@@ -7024,7 +7031,7 @@ defineType$4("ExportDefaultDeclaration", {
 		"ExportDeclaration"
 	],
 	fields: {
-		declaration: validateType("TSDeclareFunction", "FunctionDeclaration", "ClassDeclaration", "Expression"),
+		declaration: validateType("FunctionDeclaration", "ClassDeclaration", "Expression", "TSDeclareFunction", "TSInterfaceDeclaration", "EnumDeclaration"),
 		exportKind: validateOptional(assertOneOf("value"))
 	}
 });
@@ -7053,7 +7060,21 @@ defineType$4("ExportNamedDeclaration", {
 			validate: chain(assertNodeType("Declaration"), Object.assign(function(node, key, val) {
 				if (val && node.specifiers.length) throw new TypeError("Only declaration or specifiers is allowed on ExportNamedDeclaration");
 				if (val && node.source) throw new TypeError("Cannot export a declaration from a source");
-			}, { oneOfNodeTypes: ["Declaration"] }))
+			}, { oneOfNodeTypes: [
+				"VariableDeclaration",
+				"FunctionDeclaration",
+				"ClassDeclaration",
+				"TSDeclareFunction",
+				"TSEnumDeclaration",
+				"TSImportEqualsDeclaration",
+				"TSInterfaceDeclaration",
+				"TSModuleDeclaration",
+				"TSTypeAliasDeclaration",
+				"EnumDeclaration",
+				"InterfaceDeclaration",
+				"OpaqueType",
+				"TypeAlias"
+			] }))
 		},
 		...importAttributes,
 		specifiers: {
@@ -7190,21 +7211,6 @@ defineType$4("ImportSpecifier", {
 		}
 	}
 });
-defineType$4("ImportExpression", {
-	visitor: ["source", "options"],
-	aliases: ["Expression"],
-	fields: {
-		phase: {
-			default: null,
-			validate: assertOneOf("source", "defer")
-		},
-		source: { validate: assertNodeType("Expression") },
-		options: {
-			validate: assertNodeType("Expression"),
-			optional: true
-		}
-	}
-});
 defineType$4("MetaProperty", {
 	visitor: ["meta", "property"],
 	aliases: ["Expression"],
@@ -7256,7 +7262,7 @@ const classMethodOrPropertyCommon = () => ({
 		};
 	}(), assertNodeType("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "Expression")) }
 });
-const classMethodOrDeclareMethodCommon = () => ({
+const classMethodOrDeclareMethodCommon = (allowDecorators = true) => ({
 	...functionCommon(),
 	...classMethodOrPropertyCommon(),
 	params: validateArrayOfType("FunctionParameter", "TSParameterProperty"),
@@ -7268,10 +7274,10 @@ const classMethodOrDeclareMethodCommon = () => ({
 		validate: chain(assertValueType("string"), assertOneOf("public", "private", "protected")),
 		optional: true
 	},
-	decorators: {
+	...allowDecorators ? { decorators: {
 		validate: arrayOfType("Decorator"),
 		optional: true
-	}
+	} } : {}
 });
 defineType$4("ClassMethod", {
 	aliases: [
@@ -7330,7 +7336,7 @@ defineType$4("SpreadElement", {
 	deprecatedAlias: "SpreadProperty",
 	fields: { argument: { validate: assertNodeType("Expression") } }
 });
-defineType$4("Super", void 0);
+defineType$4("Super");
 defineType$4("TaggedTemplateExpression", {
 	visitor: [
 		"tag",
@@ -7413,7 +7419,22 @@ defineType$4("AwaitExpression", {
 	aliases: ["Expression", "Terminatorless"],
 	fields: { argument: { validate: assertNodeType("Expression") } }
 });
-defineType$4("Import", { aliases: ["Expression"] });
+defineType$4("ImportExpression", {
+	visitor: ["source", "options"],
+	aliases: ["Expression"],
+	fields: {
+		phase: {
+			default: null,
+			validate: assertOneOf("source", "defer")
+		},
+		source: { validate: assertNodeType("Expression") },
+		options: {
+			validate: assertNodeType("Expression"),
+			optional: true
+		}
+	}
+});
+defineType$4("Import");
 defineType$4("BigIntLiteral", {
 	builder: ["value"],
 	fields: { value: { validate: assertValueType("bigint") } },
@@ -7427,7 +7448,7 @@ defineType$4("BigIntLiteral", {
 defineType$4("ExportNamespaceSpecifier", {
 	visitor: ["exported"],
 	aliases: ["ModuleSpecifier"],
-	fields: { exported: { validate: assertNodeType("Identifier") } }
+	fields: { exported: { validate: assertNodeType("Identifier", "StringLiteral") } }
 });
 defineType$4("OptionalMemberExpression", {
 	builder: [
@@ -7438,14 +7459,15 @@ defineType$4("OptionalMemberExpression", {
 	],
 	visitor: ["object", "property"],
 	aliases: ["Expression"],
+	...memberExpressionUnionShapeCommon,
 	fields: {
 		object: { validate: assertNodeType("Expression") },
 		property: { validate: function() {
-			const normal = assertNodeType("Identifier");
+			const normal = assertNodeType("Identifier", "PrivateName");
 			const computed = assertNodeType("Expression");
 			return Object.assign(function(node, key, val) {
 				(node.computed ? computed : normal)(node, key, val);
-			}, { oneOfNodeTypes: ["Expression", "Identifier"] });
+			}, { oneOfNodeTypes: ["Expression", "PrivateName"] });
 		}() },
 		computed: { default: false },
 		optional: { validate: chain(assertValueType("boolean"), assertOptionalChainStart()) }
@@ -7695,7 +7717,7 @@ defineType$3("DeclareFunction", {
 	],
 	fields: {
 		id: validateType("Identifier"),
-		predicate: validateOptionalType("DeclaredPredicate")
+		predicate: validateOptionalType("FlowPredicate")
 	}
 });
 defineInterfaceishType("DeclareInterface");
@@ -7806,7 +7828,7 @@ defineType$3("DeclareExportAllDeclaration", {
 defineType$3("DeclaredPredicate", {
 	visitor: ["value"],
 	aliases: ["FlowPredicate"],
-	fields: { value: validateType("Flow") }
+	fields: { value: validateType("Expression") }
 });
 defineType$3("ExistsTypeAnnotation", { aliases: ["FlowType"] });
 defineType$3("FunctionTypeAnnotation", {
@@ -7882,6 +7904,11 @@ defineType$3("NumberLiteralTypeAnnotation", {
 	aliases: ["FlowType"],
 	fields: { value: validate$2(assertValueType("number")) }
 });
+defineType$3("BigIntLiteralTypeAnnotation", {
+	builder: ["value"],
+	aliases: ["FlowType"],
+	fields: { value: validate$2(assertValueType("bigint")) }
+});
 defineType$3("NumberTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] });
 defineType$3("ObjectTypeAnnotation", {
 	visitor: [
@@ -7978,7 +8005,7 @@ defineType$3("ObjectTypeProperty", {
 	],
 	aliases: ["UserWhitespacable"],
 	fields: {
-		key: validateType("Identifier", "StringLiteral"),
+		key: validateType("Identifier", "StringLiteral", "NumericLiteral"),
 		value: validateType("FlowType"),
 		kind: {
 			validate: assertOneOf("init", "get", "set"),
@@ -8360,7 +8387,7 @@ defineType$5("BindExpression", {
 	visitor: ["object", "callee"],
 	aliases: ["Expression"],
 	fields: {
-		object: { validate: assertNodeType("Expression") },
+		object: { validate: assertNodeOrValueType("null", "Expression") },
 		callee: { validate: assertNodeType("Expression") }
 	}
 });
@@ -8502,7 +8529,6 @@ defineType("TSDeclareFunction", {
 });
 defineType("TSDeclareMethod", {
 	visitor: [
-		"decorators",
 		"key",
 		"typeParameters",
 		"params",
@@ -8510,7 +8536,7 @@ defineType("TSDeclareMethod", {
 	],
 	...classMethodOrPropertyUnionShapeCommon(),
 	fields: {
-		...classMethodOrDeclareMethodCommon(),
+		...classMethodOrDeclareMethodCommon(false),
 		...tSFunctionTypeAnnotationCommon()
 	}
 });
@@ -8834,7 +8860,7 @@ defineType("TSInterfaceDeclaration", {
 		declare: validateOptional(bool),
 		id: validateType("Identifier"),
 		typeParameters: validateOptionalType("TSTypeParameterDeclaration"),
-		extends: validateOptional(arrayOfType("TSClassImplements")),
+		extends: validateOptional(arrayOfType("TSInterfaceHeritage")),
 		body: validateType("TSInterfaceBody")
 	}
 });
@@ -8916,7 +8942,7 @@ defineType("TSModuleDeclaration", {
 	visitor: ["id", "body"],
 	fields: {
 		kind: {
-			validate: assertOneOf("global", "namespace"),
+			validate: assertOneOf("global", "namespace", "module"),
 			default: "namespace"
 		},
 		declare: validateOptional(bool),
@@ -9814,17 +9840,6 @@ function importSpecifier(local, imported) {
 	validate(defs.imported, node, "imported", imported, 1);
 	return node;
 }
-function importExpression(source, options = null) {
-	const node = {
-		type: "ImportExpression",
-		source,
-		options
-	};
-	const defs = NODE_FIELDS.ImportExpression;
-	validate(defs.source, node, "source", source, 1);
-	validate(defs.options, node, "options", options, 1);
-	return node;
-}
 function metaProperty(meta, property) {
 	const node = {
 		type: "MetaProperty",
@@ -9933,6 +9948,17 @@ function awaitExpression(argument) {
 	validate(defs.argument, node, "argument", argument, 1);
 	return node;
 }
+function importExpression(source, options = null) {
+	const node = {
+		type: "ImportExpression",
+		source,
+		options
+	};
+	const defs = NODE_FIELDS.ImportExpression;
+	validate(defs.source, node, "source", source, 1);
+	validate(defs.options, node, "options", options, 1);
+	return node;
+}
 function _import() {
 	return { type: "Import" };
 }
@@ -10347,6 +10373,15 @@ function numberLiteralTypeAnnotation(value) {
 	validate(defs.value, node, "value", value);
 	return node;
 }
+function bigIntLiteralTypeAnnotation(value) {
+	const node = {
+		type: "BigIntLiteralTypeAnnotation",
+		value
+	};
+	const defs = NODE_FIELDS.BigIntLiteralTypeAnnotation;
+	validate(defs.value, node, "value", value);
+	return node;
+}
 function numberTypeAnnotation() {
 	return { type: "NumberTypeAnnotation" };
 }
@@ -10963,10 +10998,9 @@ function tsDeclareFunction(id = null, typeParameters = null, params, returnType
 	validate(defs.returnType, node, "returnType", returnType, 1);
 	return node;
 }
-function tsDeclareMethod(decorators = null, key, typeParameters = null, params, returnType = null) {
+function tsDeclareMethod(key, typeParameters = null, params, returnType = null) {
 	const node = {
 		type: "TSDeclareMethod",
-		decorators,
 		key,
 		typeParameters,
 		params,
@@ -10978,7 +11012,6 @@ function tsDeclareMethod(decorators = null, key, typeParameters = null, params,
 		static: false
 	};
 	const defs = NODE_FIELDS.TSDeclareMethod;
-	validate(defs.decorators, node, "decorators", decorators, 1);
 	validate(defs.key, node, "key", key, 1);
 	validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
 	validate(defs.params, node, "params", params, 1);
@@ -11614,6 +11647,7 @@ var b = /* @__PURE__ */ Object.freeze({
 	assignmentPattern,
 	awaitExpression,
 	bigIntLiteral,
+	bigIntLiteralTypeAnnotation,
 	binaryExpression,
 	bindExpression,
 	blockStatement,
@@ -11862,7 +11896,7 @@ function alias(lowercase) {
 		return b[lowercase](...arguments);
 	};
 }
-const ArrayExpression$1 = alias("arrayExpression"), AssignmentExpression$2 = alias("assignmentExpression"), BinaryExpression$2 = alias("binaryExpression"), InterpreterDirective$1 = alias("interpreterDirective"), Directive$1 = alias("directive"), DirectiveLiteral$1 = alias("directiveLiteral"), BlockStatement$1 = alias("blockStatement"), BreakStatement$1 = alias("breakStatement"), CallExpression$1 = alias("callExpression"), CatchClause$1 = alias("catchClause"), ConditionalExpression$2 = alias("conditionalExpression"), ContinueStatement$1 = alias("continueStatement"), DebuggerStatement$1 = alias("debuggerStatement"), DoWhileStatement$1 = alias("doWhileStatement"), EmptyStatement$1 = alias("emptyStatement"), ExpressionStatement$1 = alias("expressionStatement"), File$1 = alias("file"), ForInStatement$1 = alias("forInStatement"), ForStatement$1 = alias("forStatement"), FunctionDeclaration = alias("functionDeclaration"), FunctionExpression$2 = alias("functionExpression"), Identifier$2 = alias("identifier"), IfStatement$1 = alias("ifStatement"), LabeledStatement$1 = alias("labeledStatement"), StringLiteral$1 = alias("stringLiteral"), NumericLiteral$1 = alias("numericLiteral"), NullLiteral$1 = alias("nullLiteral"), BooleanLiteral$1 = alias("booleanLiteral"), RegExpLiteral$1 = alias("regExpLiteral"), LogicalExpression$1 = alias("logicalExpression"), MemberExpression$1 = alias("memberExpression"), NewExpression$1 = alias("newExpression"), Program$1 = alias("program"), ObjectExpression$2 = alias("objectExpression"), ObjectMethod$1 = alias("objectMethod"), ObjectProperty$1 = alias("objectProperty"), RestElement$1 = alias("restElement"), ReturnStatement$1 = alias("returnStatement"), SequenceExpression$2 = alias("sequenceExpression"), ParenthesizedExpression$1 = alias("parenthesizedExpression"), SwitchCase$1 = alias("switchCase"), SwitchStatement$1 = alias("switchStatement"), ThisExpression$1 = alias("thisExpression"), ThrowStatement$1 = alias("throwStatement"), TryStatement$1 = alias("tryStatement"), UnaryExpression$1 = alias("unaryExpression"), UpdateExpression$2 = alias("updateExpression"), VariableDeclaration$1 = alias("variableDeclaration"), VariableDeclarator$1 = alias("variableDeclarator"), WhileStatement$1 = alias("whileStatement"), WithStatement$1 = alias("withStatement"), AssignmentPattern$1 = alias("assignmentPattern"), ArrayPattern = alias("arrayPattern"), ArrowFunctionExpression$1 = alias("arrowFunctionExpression"), ClassBody$1 = alias("classBody"), ClassExpression$1 = alias("classExpression"), ClassDeclaration$1 = alias("classDeclaration"), ExportAllDeclaration$1 = alias("exportAllDeclaration"), ExportDefaultDeclaration$1 = alias("exportDefaultDeclaration"), ExportNamedDeclaration$1 = alias("exportNamedDeclaration"), ExportSpecifier$1 = alias("exportSpecifier"), ForOfStatement$1 = alias("forOfStatement"), ImportDeclaration$1 = alias("importDeclaration"), ImportDefaultSpecifier$1 = alias("importDefaultSpecifier"), ImportNamespaceSpecifier$1 = alias("importNamespaceSpecifier"), ImportSpecifier$1 = alias("importSpecifier"), ImportExpression$1 = alias("importExpression"), MetaProperty$1 = alias("metaProperty"), ClassMethod$1 = alias("classMethod"), ObjectPattern = alias("objectPattern"), SpreadElement = alias("spreadElement"), Super$1 = alias("super"), TaggedTemplateExpression$1 = alias("taggedTemplateExpression"), TemplateElement$1 = alias("templateElement"), TemplateLiteral$1 = alias("templateLiteral"), YieldExpression$2 = alias("yieldExpression"), AwaitExpression$1 = alias("awaitExpression"), Import$1 = alias("import"), BigIntLiteral$1 = alias("bigIntLiteral"), ExportNamespaceSpecifier$1 = alias("exportNamespaceSpecifier"), OptionalMemberExpression$2 = alias("optionalMemberExpression"), OptionalCallExpression$1 = alias("optionalCallExpression"), ClassProperty$1 = alias("classProperty"), ClassPrivateProperty$1 = alias("classPrivateProperty"), ClassPrivateMethod$1 = alias("classPrivateMethod"), PrivateName$1 = alias("privateName"), StaticBlock$1 = alias("staticBlock"), ImportAttribute$1 = alias("importAttribute"), AnyTypeAnnotation$1 = alias("anyTypeAnnotation"), ArrayTypeAnnotation$1 = alias("arrayTypeAnnotation"), BooleanTypeAnnotation$1 = alias("booleanTypeAnnotation"), BooleanLiteralTypeAnnotation$1 = alias("booleanLiteralTypeAnnotation"), NullLiteralTypeAnnotation$1 = alias("nullLiteralTypeAnnotation"), ClassImplements = alias("classImplements"), DeclareClass$1 = alias("declareClass"), DeclareFunction$1 = alias("declareFunction"), DeclareInterface$1 = alias("declareInterface"), DeclareModule$1 = alias("declareModule"), DeclareModuleExports$1 = alias("declareModuleExports"), DeclareTypeAlias$1 = alias("declareTypeAlias"), DeclareOpaqueType$1 = alias("declareOpaqueType"), DeclareVariable$1 = alias("declareVariable"), DeclareExportDeclaration$1 = alias("declareExportDeclaration"), DeclareExportAllDeclaration$1 = alias("declareExportAllDeclaration"), DeclaredPredicate$1 = alias("declaredPredicate"), ExistsTypeAnnotation$1 = alias("existsTypeAnnotation"), FunctionTypeAnnotation$2 = alias("functionTypeAnnotation"), FunctionTypeParam$1 = alias("functionTypeParam"), GenericTypeAnnotation = alias("genericTypeAnnotation"), InferredPredicate$1 = alias("inferredPredicate"), InterfaceExtends$1 = alias("interfaceExtends"), InterfaceDeclaration$1 = alias("interfaceDeclaration"), InterfaceTypeAnnotation$1 = alias("interfaceTypeAnnotation"), IntersectionTypeAnnotation$1 = alias("intersectionTypeAnnotation"), MixedTypeAnnotation$1 = alias("mixedTypeAnnotation"), EmptyTypeAnnotation$1 = alias("emptyTypeAnnotation"), NullableTypeAnnotation$2 = alias("nullableTypeAnnotation"), NumberLiteralTypeAnnotation = alias("numberLiteralTypeAnnotation"), NumberTypeAnnotation$1 = alias("numberTypeAnnotation"), ObjectTypeAnnotation$1 = alias("objectTypeAnnotation"), ObjectTypeInternalSlot$1 = alias("objectTypeInternalSlot"), ObjectTypeCallProperty$1 = alias("objectTypeCallProperty"), ObjectTypeIndexer$1 = alias("objectTypeIndexer"), ObjectTypeProperty$1 = alias("objectTypeProperty"), ObjectTypeSpreadProperty$1 = alias("objectTypeSpreadProperty"), OpaqueType$1 = alias("opaqueType"), QualifiedTypeIdentifier$1 = alias("qualifiedTypeIdentifier"), StringLiteralTypeAnnotation = alias("stringLiteralTypeAnnotation"), StringTypeAnnotation$1 = alias("stringTypeAnnotation"), SymbolTypeAnnotation$1 = alias("symbolTypeAnnotation"), ThisTypeAnnotation$1 = alias("thisTypeAnnotation"), TupleTypeAnnotation$1 = alias("tupleTypeAnnotation"), TypeofTypeAnnotation$1 = alias("typeofTypeAnnotation"), TypeAlias$1 = alias("typeAlias"), TypeAnnotation$1 = alias("typeAnnotation"), TypeCastExpression$1 = alias("typeCastExpression"), TypeParameter$1 = alias("typeParameter"), TypeParameterDeclaration = alias("typeParameterDeclaration"), TypeParameterInstantiation$1 = alias("typeParameterInstantiation"), UnionTypeAnnotation$2 = alias("unionTypeAnnotation"), Variance$1 = alias("variance"), VoidTypeAnnotation$1 = alias("voidTypeAnnotation"), EnumDeclaration$1 = alias("enumDeclaration"), EnumBooleanBody$1 = alias("enumBooleanBody"), EnumNumberBody$1 = alias("enumNumberBody"), EnumStringBody$1 = alias("enumStringBody"), EnumSymbolBody$1 = alias("enumSymbolBody"), EnumBooleanMember$1 = alias("enumBooleanMember"), EnumNumberMember$1 = alias("enumNumberMember"), EnumStringMember$1 = alias("enumStringMember"), EnumDefaultedMember$1 = alias("enumDefaultedMember"), IndexedAccessType$1 = alias("indexedAccessType"), OptionalIndexedAccessType$2 = alias("optionalIndexedAccessType"), JSXAttribute$1 = alias("jsxAttribute"), JSXClosingElement$1 = alias("jsxClosingElement"), JSXElement$1 = alias("jsxElement"), JSXEmptyExpression$1 = alias("jsxEmptyExpression"), JSXExpressionContainer$1 = alias("jsxExpressionContainer"), JSXSpreadChild$1 = alias("jsxSpreadChild"), JSXIdentifier$1 = alias("jsxIdentifier"), JSXMemberExpression$1 = alias("jsxMemberExpression"), JSXNamespacedName$1 = alias("jsxNamespacedName"), JSXOpeningElement$1 = alias("jsxOpeningElement"), JSXSpreadAttribute$1 = alias("jsxSpreadAttribute"), JSXText$1 = alias("jsxText"), JSXFragment$1 = alias("jsxFragment"), JSXOpeningFragment$1 = alias("jsxOpeningFragment"), JSXClosingFragment$1 = alias("jsxClosingFragment"), Placeholder$1 = alias("placeholder"), V8IntrinsicIdentifier$1 = alias("v8IntrinsicIdentifier"), ArgumentPlaceholder$1 = alias("argumentPlaceholder"), BindExpression$1 = alias("bindExpression"), ClassAccessorProperty$1 = alias("classAccessorProperty"), Decorator$1 = alias("decorator"), DoExpression$2 = alias("doExpression"), ExportDefaultSpecifier$1 = alias("exportDefaultSpecifier"), ModuleExpression$1 = alias("moduleExpression"), TopicReference$1 = alias("topicReference"), VoidPattern$1 = alias("voidPattern"), TSParameterProperty$1 = alias("tsParameterProperty"), TSDeclareFunction$1 = alias("tsDeclareFunction"), TSDeclareMethod$1 = alias("tsDeclareMethod"), TSQualifiedName$1 = alias("tsQualifiedName"), TSCallSignatureDeclaration$1 = alias("tsCallSignatureDeclaration"), TSConstructSignatureDeclaration$1 = alias("tsConstructSignatureDeclaration"), TSPropertySignature$1 = alias("tsPropertySignature"), TSMethodSignature$1 = alias("tsMethodSignature"), TSIndexSignature$1 = alias("tsIndexSignature"), TSAnyKeyword$1 = alias("tsAnyKeyword"), TSBooleanKeyword$1 = alias("tsBooleanKeyword"), TSBigIntKeyword$1 = alias("tsBigIntKeyword"), TSIntrinsicKeyword$1 = alias("tsIntrinsicKeyword"), TSNeverKeyword$1 = alias("tsNeverKeyword"), TSNullKeyword$1 = alias("tsNullKeyword"), TSNumberKeyword$1 = alias("tsNumberKeyword"), TSObjectKeyword$1 = alias("tsObjectKeyword"), TSStringKeyword$1 = alias("tsStringKeyword"), TSSymbolKeyword$1 = alias("tsSymbolKeyword"), TSUndefinedKeyword$1 = alias("tsUndefinedKeyword"), TSUnknownKeyword$1 = alias("tsUnknownKeyword"), TSVoidKeyword$1 = alias("tsVoidKeyword"), TSThisType$1 = alias("tsThisType"), TSFunctionType$2 = alias("tsFunctionType"), TSConstructorType$1 = alias("tsConstructorType"), TSTypeReference$1 = alias("tsTypeReference"), TSTypePredicate$1 = alias("tsTypePredicate"), TSTypeQuery$1 = alias("tsTypeQuery"), TSTypeLiteral$1 = alias("tsTypeLiteral"), TSArrayType$1 = alias("tsArrayType"), TSTupleType$1 = alias("tsTupleType"), TSOptionalType$1 = alias("tsOptionalType"), TSRestType$1 = alias("tsRestType"), TSNamedTupleMember$1 = alias("tsNamedTupleMember"), TSUnionType$2 = alias("tsUnionType"), TSIntersectionType$2 = alias("tsIntersectionType"), TSConditionalType$2 = alias("tsConditionalType"), TSInferType$2 = alias("tsInferType"), TSParenthesizedType$1 = alias("tsParenthesizedType"), TSTypeOperator$2 = alias("tsTypeOperator"), TSIndexedAccessType$1 = alias("tsIndexedAccessType"), TSMappedType$1 = alias("tsMappedType"), TSTemplateLiteralType$1 = alias("tsTemplateLiteralType"), TSLiteralType$1 = alias("tsLiteralType"), TSClassImplements$1 = alias("tsClassImplements"), TSInterfaceHeritage = alias("tsInterfaceHeritage"), TSInterfaceDeclaration$1 = alias("tsInterfaceDeclaration"), TSInterfaceBody$1 = alias("tsInterfaceBody"), TSTypeAliasDeclaration$1 = alias("tsTypeAliasDeclaration"), TSInstantiationExpression$2 = alias("tsInstantiationExpression"), TSAsExpression$2 = alias("tsAsExpression"), TSSatisfiesExpression$1 = alias("tsSatisfiesExpression"), TSTypeAssertion$1 = alias("tsTypeAssertion"), TSEnumBody$1 = alias("tsEnumBody"), TSEnumDeclaration$1 = alias("tsEnumDeclaration"), TSEnumMember$1 = alias("tsEnumMember"), TSModuleDeclaration$1 = alias("tsModuleDeclaration"), TSModuleBlock$1 = alias("tsModuleBlock"), TSImportType$1 = alias("tsImportType"), TSImportEqualsDeclaration$1 = alias("tsImportEqualsDeclaration"), TSExternalModuleReference$1 = alias("tsExternalModuleReference"), TSNonNullExpression$1 = alias("tsNonNullExpression"), TSExportAssignment$1 = alias("tsExportAssignment"), TSNamespaceExportDeclaration$1 = alias("tsNamespaceExportDeclaration"), TSTypeAnnotation$1 = alias("tsTypeAnnotation"), TSTypeParameterInstantiation$1 = alias("tsTypeParameterInstantiation"), TSTypeParameterDeclaration = alias("tsTypeParameterDeclaration"), TSTypeParameter$1 = alias("tsTypeParameter");
+const ArrayExpression$1 = alias("arrayExpression"), AssignmentExpression$2 = alias("assignmentExpression"), BinaryExpression$2 = alias("binaryExpression"), InterpreterDirective$1 = alias("interpreterDirective"), Directive$1 = alias("directive"), DirectiveLiteral$1 = alias("directiveLiteral"), BlockStatement$1 = alias("blockStatement"), BreakStatement$1 = alias("breakStatement"), CallExpression$1 = alias("callExpression"), CatchClause$1 = alias("catchClause"), ConditionalExpression$2 = alias("conditionalExpression"), ContinueStatement$1 = alias("continueStatement"), DebuggerStatement$1 = alias("debuggerStatement"), DoWhileStatement$1 = alias("doWhileStatement"), EmptyStatement$1 = alias("emptyStatement"), ExpressionStatement$1 = alias("expressionStatement"), File$1 = alias("file"), ForInStatement$1 = alias("forInStatement"), ForStatement$1 = alias("forStatement"), FunctionDeclaration = alias("functionDeclaration"), FunctionExpression$2 = alias("functionExpression"), Identifier$2 = alias("identifier"), IfStatement$1 = alias("ifStatement"), LabeledStatement$1 = alias("labeledStatement"), StringLiteral$1 = alias("stringLiteral"), NumericLiteral$1 = alias("numericLiteral"), NullLiteral$1 = alias("nullLiteral"), BooleanLiteral$1 = alias("booleanLiteral"), RegExpLiteral$1 = alias("regExpLiteral"), LogicalExpression$1 = alias("logicalExpression"), MemberExpression$1 = alias("memberExpression"), NewExpression$1 = alias("newExpression"), Program$1 = alias("program"), ObjectExpression$2 = alias("objectExpression"), ObjectMethod$1 = alias("objectMethod"), ObjectProperty$1 = alias("objectProperty"), RestElement$1 = alias("restElement"), ReturnStatement$1 = alias("returnStatement"), SequenceExpression$2 = alias("sequenceExpression"), ParenthesizedExpression$1 = alias("parenthesizedExpression"), SwitchCase$1 = alias("switchCase"), SwitchStatement$1 = alias("switchStatement"), ThisExpression$1 = alias("thisExpression"), ThrowStatement$1 = alias("throwStatement"), TryStatement$1 = alias("tryStatement"), UnaryExpression$1 = alias("unaryExpression"), UpdateExpression$2 = alias("updateExpression"), VariableDeclaration$1 = alias("variableDeclaration"), VariableDeclarator$1 = alias("variableDeclarator"), WhileStatement$1 = alias("whileStatement"), WithStatement$1 = alias("withStatement"), AssignmentPattern$1 = alias("assignmentPattern"), ArrayPattern = alias("arrayPattern"), ArrowFunctionExpression$1 = alias("arrowFunctionExpression"), ClassBody$1 = alias("classBody"), ClassExpression$1 = alias("classExpression"), ClassDeclaration$1 = alias("classDeclaration"), ExportAllDeclaration$1 = alias("exportAllDeclaration"), ExportDefaultDeclaration$1 = alias("exportDefaultDeclaration"), ExportNamedDeclaration$1 = alias("exportNamedDeclaration"), ExportSpecifier$1 = alias("exportSpecifier"), ForOfStatement$1 = alias("forOfStatement"), ImportDeclaration$1 = alias("importDeclaration"), ImportDefaultSpecifier$1 = alias("importDefaultSpecifier"), ImportNamespaceSpecifier$1 = alias("importNamespaceSpecifier"), ImportSpecifier$1 = alias("importSpecifier"), MetaProperty$1 = alias("metaProperty"), ClassMethod$1 = alias("classMethod"), ObjectPattern = alias("objectPattern"), SpreadElement = alias("spreadElement"), Super$1 = alias("super"), TaggedTemplateExpression$1 = alias("taggedTemplateExpression"), TemplateElement$1 = alias("templateElement"), TemplateLiteral$1 = alias("templateLiteral"), YieldExpression$2 = alias("yieldExpression"), AwaitExpression$1 = alias("awaitExpression"), ImportExpression$1 = alias("importExpression"), Import$1 = alias("import"), BigIntLiteral$1 = alias("bigIntLiteral"), ExportNamespaceSpecifier$1 = alias("exportNamespaceSpecifier"), OptionalMemberExpression$2 = alias("optionalMemberExpression"), OptionalCallExpression$1 = alias("optionalCallExpression"), ClassProperty$1 = alias("classProperty"), ClassPrivateProperty$1 = alias("classPrivateProperty"), ClassPrivateMethod$1 = alias("classPrivateMethod"), PrivateName$1 = alias("privateName"), StaticBlock$1 = alias("staticBlock"), ImportAttribute$1 = alias("importAttribute"), AnyTypeAnnotation$1 = alias("anyTypeAnnotation"), ArrayTypeAnnotation$1 = alias("arrayTypeAnnotation"), BooleanTypeAnnotation$1 = alias("booleanTypeAnnotation"), BooleanLiteralTypeAnnotation$1 = alias("booleanLiteralTypeAnnotation"), NullLiteralTypeAnnotation$1 = alias("nullLiteralTypeAnnotation"), ClassImplements = alias("classImplements"), DeclareClass$1 = alias("declareClass"), DeclareFunction$1 = alias("declareFunction"), DeclareInterface$1 = alias("declareInterface"), DeclareModule$1 = alias("declareModule"), DeclareModuleExports$1 = alias("declareModuleExports"), DeclareTypeAlias$1 = alias("declareTypeAlias"), DeclareOpaqueType$1 = alias("declareOpaqueType"), DeclareVariable$1 = alias("declareVariable"), DeclareExportDeclaration$1 = alias("declareExportDeclaration"), DeclareExportAllDeclaration$1 = alias("declareExportAllDeclaration"), DeclaredPredicate$1 = alias("declaredPredicate"), ExistsTypeAnnotation$1 = alias("existsTypeAnnotation"), FunctionTypeAnnotation$2 = alias("functionTypeAnnotation"), FunctionTypeParam$1 = alias("functionTypeParam"), GenericTypeAnnotation = alias("genericTypeAnnotation"), InferredPredicate$1 = alias("inferredPredicate"), InterfaceExtends$1 = alias("interfaceExtends"), InterfaceDeclaration$1 = alias("interfaceDeclaration"), InterfaceTypeAnnotation$1 = alias("interfaceTypeAnnotation"), IntersectionTypeAnnotation$1 = alias("intersectionTypeAnnotation"), MixedTypeAnnotation$1 = alias("mixedTypeAnnotation"), EmptyTypeAnnotation$1 = alias("emptyTypeAnnotation"), NullableTypeAnnotation$2 = alias("nullableTypeAnnotation"), NumberLiteralTypeAnnotation = alias("numberLiteralTypeAnnotation"), BigIntLiteralTypeAnnotation = alias("bigIntLiteralTypeAnnotation"), NumberTypeAnnotation$1 = alias("numberTypeAnnotation"), ObjectTypeAnnotation$1 = alias("objectTypeAnnotation"), ObjectTypeInternalSlot$1 = alias("objectTypeInternalSlot"), ObjectTypeCallProperty$1 = alias("objectTypeCallProperty"), ObjectTypeIndexer$1 = alias("objectTypeIndexer"), ObjectTypeProperty$1 = alias("objectTypeProperty"), ObjectTypeSpreadProperty$1 = alias("objectTypeSpreadProperty"), OpaqueType$1 = alias("opaqueType"), QualifiedTypeIdentifier$1 = alias("qualifiedTypeIdentifier"), StringLiteralTypeAnnotation = alias("stringLiteralTypeAnnotation"), StringTypeAnnotation$1 = alias("stringTypeAnnotation"), SymbolTypeAnnotation$1 = alias("symbolTypeAnnotation"), ThisTypeAnnotation$1 = alias("thisTypeAnnotation"), TupleTypeAnnotation$1 = alias("tupleTypeAnnotation"), TypeofTypeAnnotation$1 = alias("typeofTypeAnnotation"), TypeAlias$1 = alias("typeAlias"), TypeAnnotation$1 = alias("typeAnnotation"), TypeCastExpression$1 = alias("typeCastExpression"), TypeParameter$1 = alias("typeParameter"), TypeParameterDeclaration = alias("typeParameterDeclaration"), TypeParameterInstantiation$1 = alias("typeParameterInstantiation"), UnionTypeAnnotation$2 = alias("unionTypeAnnotation"), Variance$1 = alias("variance"), VoidTypeAnnotation$1 = alias("voidTypeAnnotation"), EnumDeclaration$1 = alias("enumDeclaration"), EnumBooleanBody$1 = alias("enumBooleanBody"), EnumNumberBody$1 = alias("enumNumberBody"), EnumStringBody$1 = alias("enumStringBody"), EnumSymbolBody$1 = alias("enumSymbolBody"), EnumBooleanMember$1 = alias("enumBooleanMember"), EnumNumberMember$1 = alias("enumNumberMember"), EnumStringMember$1 = alias("enumStringMember"), EnumDefaultedMember$1 = alias("enumDefaultedMember"), IndexedAccessType$1 = alias("indexedAccessType"), OptionalIndexedAccessType$2 = alias("optionalIndexedAccessType"), JSXAttribute$1 = alias("jsxAttribute"), JSXClosingElement$1 = alias("jsxClosingElement"), JSXElement$1 = alias("jsxElement"), JSXEmptyExpression$1 = alias("jsxEmptyExpression"), JSXExpressionContainer$1 = alias("jsxExpressionContainer"), JSXSpreadChild$1 = alias("jsxSpreadChild"), JSXIdentifier$1 = alias("jsxIdentifier"), JSXMemberExpression$1 = alias("jsxMemberExpression"), JSXNamespacedName$1 = alias("jsxNamespacedName"), JSXOpeningElement$1 = alias("jsxOpeningElement"), JSXSpreadAttribute$1 = alias("jsxSpreadAttribute"), JSXText$1 = alias("jsxText"), JSXFragment$1 = alias("jsxFragment"), JSXOpeningFragment$1 = alias("jsxOpeningFragment"), JSXClosingFragment$1 = alias("jsxClosingFragment"), Placeholder$1 = alias("placeholder"), V8IntrinsicIdentifier$1 = alias("v8IntrinsicIdentifier"), ArgumentPlaceholder$1 = alias("argumentPlaceholder"), BindExpression$1 = alias("bindExpression"), ClassAccessorProperty$1 = alias("classAccessorProperty"), Decorator$1 = alias("decorator"), DoExpression$2 = alias("doExpression"), ExportDefaultSpecifier$1 = alias("exportDefaultSpecifier"), ModuleExpression$1 = alias("moduleExpression"), TopicReference$1 = alias("topicReference"), VoidPattern$1 = alias("voidPattern"), TSParameterProperty$1 = alias("tsParameterProperty"), TSDeclareFunction$1 = alias("tsDeclareFunction"), TSDeclareMethod$1 = alias("tsDeclareMethod"), TSQualifiedName$1 = alias("tsQualifiedName"), TSCallSignatureDeclaration$1 = alias("tsCallSignatureDeclaration"), TSConstructSignatureDeclaration$1 = alias("tsConstructSignatureDeclaration"), TSPropertySignature$1 = alias("tsPropertySignature"), TSMethodSignature$1 = alias("tsMethodSignature"), TSIndexSignature$1 = alias("tsIndexSignature"), TSAnyKeyword$1 = alias("tsAnyKeyword"), TSBooleanKeyword$1 = alias("tsBooleanKeyword"), TSBigIntKeyword$1 = alias("tsBigIntKeyword"), TSIntrinsicKeyword$1 = alias("tsIntrinsicKeyword"), TSNeverKeyword$1 = alias("tsNeverKeyword"), TSNullKeyword$1 = alias("tsNullKeyword"), TSNumberKeyword$1 = alias("tsNumberKeyword"), TSObjectKeyword$1 = alias("tsObjectKeyword"), TSStringKeyword$1 = alias("tsStringKeyword"), TSSymbolKeyword$1 = alias("tsSymbolKeyword"), TSUndefinedKeyword$1 = alias("tsUndefinedKeyword"), TSUnknownKeyword$1 = alias("tsUnknownKeyword"), TSVoidKeyword$1 = alias("tsVoidKeyword"), TSThisType$1 = alias("tsThisType"), TSFunctionType$2 = alias("tsFunctionType"), TSConstructorType$1 = alias("tsConstructorType"), TSTypeReference$1 = alias("tsTypeReference"), TSTypePredicate$1 = alias("tsTypePredicate"), TSTypeQuery$1 = alias("tsTypeQuery"), TSTypeLiteral$1 = alias("tsTypeLiteral"), TSArrayType$1 = alias("tsArrayType"), TSTupleType$1 = alias("tsTupleType"), TSOptionalType$1 = alias("tsOptionalType"), TSRestType$1 = alias("tsRestType"), TSNamedTupleMember$1 = alias("tsNamedTupleMember"), TSUnionType$2 = alias("tsUnionType"), TSIntersectionType$2 = alias("tsIntersectionType"), TSConditionalType$2 = alias("tsConditionalType"), TSInferType$2 = alias("tsInferType"), TSParenthesizedType$1 = alias("tsParenthesizedType"), TSTypeOperator$2 = alias("tsTypeOperator"), TSIndexedAccessType$1 = alias("tsIndexedAccessType"), TSMappedType$1 = alias("tsMappedType"), TSTemplateLiteralType$1 = alias("tsTemplateLiteralType"), TSLiteralType$1 = alias("tsLiteralType"), TSClassImplements$1 = alias("tsClassImplements"), TSInterfaceHeritage = alias("tsInterfaceHeritage"), TSInterfaceDeclaration$1 = alias("tsInterfaceDeclaration"), TSInterfaceBody$1 = alias("tsInterfaceBody"), TSTypeAliasDeclaration$1 = alias("tsTypeAliasDeclaration"), TSInstantiationExpression$2 = alias("tsInstantiationExpression"), TSAsExpression$2 = alias("tsAsExpression"), TSSatisfiesExpression$1 = alias("tsSatisfiesExpression"), TSTypeAssertion$1 = alias("tsTypeAssertion"), TSEnumBody$1 = alias("tsEnumBody"), TSEnumDeclaration$1 = alias("tsEnumDeclaration"), TSEnumMember$1 = alias("tsEnumMember"), TSModuleDeclaration$1 = alias("tsModuleDeclaration"), TSModuleBlock$1 = alias("tsModuleBlock"), TSImportType$1 = alias("tsImportType"), TSImportEqualsDeclaration$1 = alias("tsImportEqualsDeclaration"), TSExternalModuleReference$1 = alias("tsExternalModuleReference"), TSNonNullExpression$1 = alias("tsNonNullExpression"), TSExportAssignment$1 = alias("tsExportAssignment"), TSNamespaceExportDeclaration$1 = alias("tsNamespaceExportDeclaration"), TSTypeAnnotation$1 = alias("tsTypeAnnotation"), TSTypeParameterInstantiation$1 = alias("tsTypeParameterInstantiation"), TSTypeParameterDeclaration = alias("tsTypeParameterDeclaration"), TSTypeParameter$1 = alias("tsTypeParameter");
 function cleanJSXElementLiteralChild(child, args) {
 	const lines = child.value.split(/\r\n|\n|\r/);
 	let lastNonEmptyLine = 0;
@@ -12107,9 +12141,6 @@ function assertImportNamespaceSpecifier(node, opts) {
 function assertImportSpecifier(node, opts) {
 	assert$1("ImportSpecifier", node, opts);
 }
-function assertImportExpression(node, opts) {
-	assert$1("ImportExpression", node, opts);
-}
 function assertMetaProperty(node, opts) {
 	assert$1("MetaProperty", node, opts);
 }
@@ -12140,6 +12171,9 @@ function assertYieldExpression(node, opts) {
 function assertAwaitExpression(node, opts) {
 	assert$1("AwaitExpression", node, opts);
 }
+function assertImportExpression(node, opts) {
+	assert$1("ImportExpression", node, opts);
+}
 function assertImport(node, opts) {
 	assert$1("Import", node, opts);
 }
@@ -12263,6 +12297,9 @@ function assertNullableTypeAnnotation(node, opts) {
 function assertNumberLiteralTypeAnnotation(node, opts) {
 	assert$1("NumberLiteralTypeAnnotation", node, opts);
 }
+function assertBigIntLiteralTypeAnnotation(node, opts) {
+	assert$1("BigIntLiteralTypeAnnotation", node, opts);
+}
 function assertNumberTypeAnnotation(node, opts) {
 	assert$1("NumberTypeAnnotation", node, opts);
 }
@@ -12861,13 +12898,13 @@ function removeTypeDuplicates$1(nodesIn) {
 		if (isGenericTypeAnnotation(node)) {
 			const name = getQualifiedName$1(node.id);
 			if (generics.has(name)) {
-				let existing = generics.get(name);
-				if (existing.typeParameters) {
+				const existingTypeParameters = generics.get(name).typeParameters;
+				if (existingTypeParameters) {
 					if (node.typeParameters) {
-						existing.typeParameters.params.push(...node.typeParameters.params);
-						existing.typeParameters.params = removeTypeDuplicates$1(existing.typeParameters.params);
+						existingTypeParameters.params.push(...node.typeParameters.params);
+						existingTypeParameters.params = removeTypeDuplicates$1(existingTypeParameters.params);
 					}
-				} else existing = node.typeParameters;
+				}
 			} else generics.set(name, node);
 			continue;
 		}
@@ -12912,12 +12949,11 @@ function removeTypeDuplicates(nodesIn) {
 			const typeArguments = node[typeArgumentsKey];
 			const name = getQualifiedName(node.typeName);
 			if (generics.has(name)) {
-				let existing = generics.get(name);
-				const existingTypeArguments = existing[typeArgumentsKey];
+				const existingTypeArguments = generics.get(name)[typeArgumentsKey];
 				if (existingTypeArguments) {
 					existingTypeArguments.params.push(...typeArguments.params);
 					existingTypeArguments.params = removeTypeDuplicates(existingTypeArguments.params);
-				} else existing = typeArguments;
+				}
 			} else generics.set(name, node);
 			continue;
 		}
@@ -12947,6 +12983,7 @@ function cloneIfNodeOrArray(obj, deep, withoutLoc, commentsCache) {
 	return cloneIfNode(obj, deep, withoutLoc, commentsCache);
 }
 function cloneNode(node, deep = true, withoutLoc = false) {
+	if (!node) return node;
 	return cloneNodeInternal(node, deep, withoutLoc, /* @__PURE__ */ new Map());
 }
 function cloneNodeInternal(node, deep = true, withoutLoc = false, commentsCache) {
@@ -13088,7 +13125,7 @@ const TSBASETYPE_TYPES = FLIPPED_ALIAS_KEYS["TSBaseType"];
 const MODULEDECLARATION_TYPES = IMPORTOREXPORTDECLARATION_TYPES;
 function toBlock(node, parent) {
 	if (isBlockStatement(node)) return node;
-	let blockNodes = [];
+	let blockNodes;
 	if (isEmptyStatement(node)) blockNodes = [];
 	else {
 		if (!isStatement$5(node)) if (isFunction$1(parent)) node = returnStatement(node);
@@ -13610,7 +13647,7 @@ const react = {
 	buildChildren
 };
 //#endregion
-//#region ../../node_modules/.pnpm/@babel+generator@8.0.0-rc.2/node_modules/@babel/generator/lib/index.js
+//#region ../../node_modules/.pnpm/@babel+generator@8.0.0-rc.3/node_modules/@babel/generator/lib/index.js
 var import_jsesc = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const object = {};
 	const hasOwnProperty = object.hasOwnProperty;
@@ -14103,20 +14140,20 @@ const PRECEDENCE = new Map([
 	["**", 11]
 ]);
 function isTSTypeExpression(nodeId) {
-	return nodeId === 153 || nodeId === 198 || nodeId === 206;
+	return nodeId === 154 || nodeId === 199 || nodeId === 207;
 }
 const isClassExtendsClause = (node, parent, parentId) => {
-	return (parentId === 21 || parentId === 22) && parent.superClass === node;
+	return (parentId === 22 || parentId === 23) && parent.superClass === node;
 };
 const hasPostfixPart = (node, parent, parentId) => {
 	switch (parentId) {
-		case 108:
-		case 132: return parent.object === node;
-		case 17:
-		case 130:
-		case 112: return parent.callee === node;
-		case 219: return parent.tag === node;
-		case 188: return true;
+		case 109:
+		case 133: return parent.object === node;
+		case 18:
+		case 131:
+		case 113: return parent.callee === node;
+		case 220: return parent.tag === node;
+		case 189: return true;
 	}
 	return false;
 };
@@ -14124,7 +14161,7 @@ function NullableTypeAnnotation$1(node, parent, parentId) {
 	return parentId === 4;
 }
 function FunctionTypeAnnotation$1(node, parent, parentId, tokenContext) {
-	return parentId === 236 || parentId === 90 || parentId === 4 || (tokenContext & 8) > 0;
+	return parentId === 237 || parentId === 91 || parentId === 4 || (tokenContext & 8) > 0;
 }
 function UpdateExpression$1(node, parent, parentId) {
 	return hasPostfixPart(node, parent, parentId) || isClassExtendsClause(node, parent, parentId);
@@ -14140,92 +14177,92 @@ function DoExpression$1(node, parent, parentId, tokenContext) {
 }
 function BinaryLike(node, parent, parentId, nodeType) {
 	if (isClassExtendsClause(node, parent, parentId)) return true;
-	if (hasPostfixPart(node, parent, parentId) || parentId === 235 || parentId === 142 || parentId === 8) return true;
+	if (hasPostfixPart(node, parent, parentId) || parentId === 236 || parentId === 143 || parentId === 8) return true;
 	let parentPos;
 	switch (parentId) {
-		case 10:
-		case 107:
+		case 11:
+		case 108:
 			parentPos = PRECEDENCE.get(parent.operator);
 			break;
-		case 153:
-		case 198: parentPos = 7;
+		case 154:
+		case 199: parentPos = 7;
 	}
 	if (parentPos !== void 0) {
 		const nodePos = nodeType === 2 ? 7 : PRECEDENCE.get(node.operator);
 		if (parentPos > nodePos) return true;
-		if (parentPos === nodePos && parentId === 10 && (nodePos === 11 ? parent.left === node : parent.right === node)) return true;
-		if (nodeType === 1 && parentId === 107 && (nodePos === 1 && parentPos !== 1 || parentPos === 1 && nodePos !== 1)) return true;
+		if (parentPos === nodePos && parentId === 11 && (nodePos === 11 ? parent.left === node : parent.right === node)) return true;
+		if (nodeType === 1 && parentId === 108 && (nodePos === 1 && parentPos !== 1 || parentPos === 1 && nodePos !== 1)) return true;
 	}
 	return false;
 }
 function UnionTypeAnnotation$1(node, parent, parentId) {
 	switch (parentId) {
 		case 4:
-		case 115:
-		case 90:
-		case 236: return true;
+		case 116:
+		case 91:
+		case 237: return true;
 	}
 	return false;
 }
 function OptionalIndexedAccessType$1(node, parent, parentId) {
-	return parentId === 84 && parent.objectType === node;
+	return parentId === 85 && parent.objectType === node;
 }
 function TSAsExpression$1(node, parent, parentId) {
 	if ((parentId === 6 || parentId === 7) && parent.left === node) return true;
-	if (parentId === 10 && (parent.operator === "|" || parent.operator === "&") && node === parent.left) return true;
+	if (parentId === 11 && (parent.operator === "|" || parent.operator === "&") && node === parent.left) return true;
 	return BinaryLike(node, parent, parentId, 2);
 }
 function TSConditionalType$1(node, parent, parentId) {
 	switch (parentId) {
-		case 152:
-		case 192:
-		case 208:
+		case 153:
+		case 193:
 		case 209:
-		case 178:
-		case 216: return true;
-		case 172: return parent.objectType === node;
-		case 158: return parent.checkType === node || parent.extendsType === node;
+		case 210:
+		case 179:
+		case 217: return true;
+		case 173: return parent.objectType === node;
+		case 159: return parent.checkType === node || parent.extendsType === node;
 	}
 	return false;
 }
 function TSUnionType$1(node, parent, parentId) {
 	switch (parentId) {
-		case 178:
-		case 208:
-		case 152:
-		case 192: return true;
-		case 172: return parent.objectType === node;
+		case 179:
+		case 209:
+		case 153:
+		case 193: return true;
+		case 173: return parent.objectType === node;
 	}
 	return false;
 }
 function TSIntersectionType$1(node, parent, parentId) {
-	return parentId === 208 || TSTypeOperator$1(node, parent, parentId);
+	return parentId === 209 || TSTypeOperator$1(node, parent, parentId);
 }
 function TSInferType$1(node, parent, parentId) {
 	if (TSTypeOperator$1(node, parent, parentId)) return true;
-	if ((parentId === 178 || parentId === 216) && node.typeParameter.constraint != null) return true;
+	if ((parentId === 179 || parentId === 217) && node.typeParameter.constraint != null) return true;
 	return false;
 }
 function TSTypeOperator$1(node, parent, parentId) {
 	switch (parentId) {
-		case 152:
-		case 192: return true;
-		case 172: if (parent.objectType === node) return true;
+		case 153:
+		case 193: return true;
+		case 173: if (parent.objectType === node) return true;
 	}
 	return false;
 }
 function TSInstantiationExpression$1(node, parent, parentId) {
 	switch (parentId) {
-		case 17:
-		case 130:
-		case 112:
-		case 174: return parent.typeArguments != null;
+		case 18:
+		case 131:
+		case 113:
+		case 175: return parent.typeArguments != null;
 	}
 	return false;
 }
 function TSFunctionType$1(node, parent, parentId) {
 	if (TSUnionType$1(node, parent, parentId)) return true;
-	return parentId === 216 || parentId === 158 && (parent.checkType === node || parent.extendsType === node);
+	return parentId === 217 || parentId === 159 && (parent.checkType === node || parent.extendsType === node);
 }
 function BinaryExpression$1(node, parent, parentId, tokenContext) {
 	if (BinaryLike(node, parent, parentId, 0)) return true;
@@ -14235,40 +14272,40 @@ function LogicalExpression(node, parent, parentId) {
 	return BinaryLike(node, parent, parentId, 1);
 }
 function SequenceExpression$1(node, parent, parentId) {
-	if (parentId === 141 || parentId === 133 || parentId === 108 && parent.property === node || parentId === 132 && parent.property === node || parentId === 221) return false;
-	if (parentId === 21) return true;
-	if (parentId === 68) return parent.right === node;
-	if (parentId === 60) return true;
+	if (parentId === 142 || parentId === 134 || parentId === 109 && parent.property === node || parentId === 133 && parent.property === node || parentId === 222) return false;
+	if (parentId === 22) return true;
+	if (parentId === 69) return parent.right === node;
+	if (parentId === 61) return true;
 	return !isStatement$4(parent);
 }
 function YieldExpression$1(node, parent, parentId) {
-	return parentId === 10 || parentId === 107 || parentId === 235 || parentId === 142 || hasPostfixPart(node, parent, parentId) || parentId === 8 && isYieldExpression(node) || parentId === 28 && node === parent.test || isClassExtendsClause(node, parent, parentId) || isTSTypeExpression(parentId);
+	return parentId === 11 || parentId === 108 || parentId === 236 || parentId === 143 || hasPostfixPart(node, parent, parentId) || parentId === 8 && isYieldExpression(node) || parentId === 29 && node === parent.test || isClassExtendsClause(node, parent, parentId) || isTSTypeExpression(parentId);
 }
 function ClassExpression(node, parent, parentId, tokenContext) {
 	return (tokenContext & 5) > 0;
 }
 function UnaryLike(node, parent, parentId) {
-	return hasPostfixPart(node, parent, parentId) || parentId === 10 && parent.operator === "**" && parent.left === node || isClassExtendsClause(node, parent, parentId);
+	return hasPostfixPart(node, parent, parentId) || parentId === 11 && parent.operator === "**" && parent.left === node || isClassExtendsClause(node, parent, parentId);
 }
 function FunctionExpression$1(node, parent, parentId, tokenContext) {
 	return (tokenContext & 5) > 0;
 }
 function ConditionalExpression$1(node, parent, parentId) {
 	switch (parentId) {
-		case 235:
-		case 142:
-		case 10:
-		case 107:
+		case 236:
+		case 143:
+		case 11:
+		case 108:
 		case 8: return true;
-		case 28: if (parent.test === node) return true;
+		case 29: if (parent.test === node) return true;
 	}
 	if (isTSTypeExpression(parentId)) return true;
 	return UnaryLike(node, parent, parentId);
 }
 function OptionalMemberExpression$1(node, parent, parentId) {
 	switch (parentId) {
-		case 17: return parent.callee === node;
-		case 108: return parent.object === node;
+		case 18: return parent.callee === node;
+		case 109: return parent.object === node;
 	}
 	return false;
 }
@@ -14282,7 +14319,7 @@ function Identifier$1(node, parent, parentId, tokenContext, getRawIdentifier) {
 		const rightType = parent.right.type;
 		if ((rightType === "FunctionExpression" || rightType === "ClassExpression") && parent.right.id == null) return true;
 	}
-	if (tokenContext & 64 || (parentId === 108 || parentId === 132) && tokenContext & 49) {
+	if (tokenContext & 64 || (parentId === 109 || parentId === 133) && tokenContext & 49) {
 		if (node.name === "let") {
 			if ((isMemberExpression$1(parent, {
 				object: node,
@@ -14295,7 +14332,7 @@ function Identifier$1(node, parent, parentId, tokenContext, getRawIdentifier) {
 			return (tokenContext & 64) > 0;
 		}
 	}
-	return parentId === 68 && parent.left === node && node.name === "async" && !parent.await;
+	return parentId === 69 && parent.left === node && node.name === "async" && !parent.await;
 }
 var parens = /* @__PURE__ */ Object.freeze({
 	__proto__: null,
@@ -15018,7 +15055,7 @@ function TSDeclareFunction(node, parent) {
 	this.semicolon();
 }
 function TSDeclareMethod(node) {
-	_classMethodHead.call(this, node);
+	_classMethodHead.call(this, node, false);
 	this.semicolon();
 }
 function TSQualifiedName(node) {
@@ -16552,8 +16589,8 @@ function ClassPrivateMethod(node) {
 	this.space();
 	this.print(node.body);
 }
-function _classMethodHead(node) {
-	this.printJoin(node.decorators);
+function _classMethodHead(node, allowDecorators = true) {
+	if (allowDecorators) this.printJoin(node.decorators);
 	if (!this.format.preserveFormat) {
 		const endLine = node.key.loc?.end?.line;
 		if (endLine) this.catchUp(endLine);
@@ -16730,6 +16767,7 @@ var generatorFunctions = /* @__PURE__ */ Object.freeze({
 	AssignmentPattern,
 	AwaitExpression,
 	BigIntLiteral,
+	BigIntLiteralTypeAnnotation: BigIntLiteral,
 	BinaryExpression,
 	BindExpression,
 	BlockStatement,
@@ -17007,12 +17045,12 @@ function isOrHasCallExpression(node) {
 }
 function parentNeedsParens(node, parent, parentId) {
 	switch (parentId) {
-		case 112:
+		case 113:
 			if (parent.callee === node) {
 				if (isOrHasCallExpression(node)) return true;
 			}
 			break;
-		case 42: return !isDecoratorMemberExpression(node) && !(node.type === "CallExpression" && isDecoratorMemberExpression(node.callee)) && node.type !== "ParenthesizedExpression";
+		case 43: return !isDecoratorMemberExpression(node) && !(node.type === "CallExpression" && isDecoratorMemberExpression(node.callee)) && node.type !== "ParenthesizedExpression";
 	}
 	return false;
 }
@@ -17476,15 +17514,15 @@ var Printer = class {
 			else oldTokenContext = 0;
 		}
 		const parenthesized = extra != null && extra.parenthesized;
-		let shouldPrintParens = parenthesized && flags & 1 || parenthesized && flags & 16 && nodeId === 71 || parent && (parentNeedsParens(node, parent, parentId) || needsParens != null && needsParens(node, parent, parentId, this.tokenContext, flags & 1 ? this._boundGetRawIdentifier : void 0));
+		let shouldPrintParens = parenthesized && flags & 1 || parenthesized && flags & 16 && nodeId === 72 || parent && (parentNeedsParens(node, parent, parentId) || needsParens != null && needsParens(node, parent, parentId, this.tokenContext, flags & 1 ? this._boundGetRawIdentifier : void 0));
 		if (!shouldPrintParens && parenthesized && node.leadingComments?.length && node.leadingComments[0].type === "CommentBlock") switch (parentId) {
-			case 65:
-			case 240:
+			case 66:
+			case 241:
 			case 6:
-			case 140: break;
-			case 17:
-			case 130:
-			case 112: if (parent.callee !== node) break;
+			case 141: break;
+			case 18:
+			case 131:
+			case 113: if (parent.callee !== node) break;
 			default: shouldPrintParens = true;
 		}
 		let indentParenthesized = false;
@@ -17512,7 +17550,7 @@ var Printer = class {
 			this._noLineTerminatorAfterNode = null;
 		}
 		this._printLeadingComments(node, parent);
-		this.exactSource(nodeId === 136 || nodeId === 66 ? null : loc, printMethod.bind(this, node, parent));
+		this.exactSource(nodeId === 137 || nodeId === 67 ? null : loc, printMethod.bind(this, node, parent));
 		if (shouldPrintParens) {
 			this._printTrailingComments(node, parent);
 			if (indentParenthesized) {
@@ -17815,15 +17853,15 @@ 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.2/node_modules/@babel/parser/lib/index.js
+//#region ../../node_modules/.pnpm/@babel+parser@8.0.0-rc.3/node_modules/@babel/parser/lib/index.js
 var Position = class {
-	line;
-	column;
-	index;
 	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;
-		this.index = index;
+		if (index !== void 0) this.index = index;
 	}
 };
 var SourceLocation = class {
@@ -17895,6 +17933,7 @@ var StandardErrors = {
 	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 { ... }'?",
@@ -18042,7 +18081,8 @@ var PipelineOperatorErrors = {
 	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.`
+	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."
 };
 function defineHidden(obj, key, value) {
 	Object.defineProperty(obj, key, {
@@ -18053,17 +18093,17 @@ function defineHidden(obj, key, value) {
 }
 function toParseErrorConstructor({ toMessage, code, reasonCode, syntaxPlugin }) {
 	const hasMissingPlugin = reasonCode === "MissingPlugin" || reasonCode === "MissingOneOfPlugins";
-	return function constructor(loc, details) {
+	return function constructor(loc, pos, details) {
 		const error = /* @__PURE__ */ new SyntaxError();
 		error.code = code;
 		error.reasonCode = reasonCode;
 		error.loc = loc;
-		error.pos = loc.index;
+		error.pos = pos;
 		error.syntaxPlugin = syntaxPlugin;
 		if (hasMissingPlugin) error.missingPlugin = details.missingPlugin;
 		defineHidden(error, "clone", function clone(overrides = {}) {
-			const { line, column, index } = overrides.loc ?? loc;
-			return constructor(new Position(line, column, index), {
+			const { line, column, index = pos } = overrides.loc ?? loc;
+			return constructor(new Position(line, column), index, {
 				...details,
 				...overrides.details
 			});
@@ -18126,6 +18166,7 @@ function createDefaultOptions() {
 		plugins: [],
 		strictMode: void 0,
 		ranges: false,
+		locations: true,
 		tokens: false,
 		createImportExpressions: true,
 		createParenthesizedExpressions: false,
@@ -18150,23 +18191,20 @@ function getOptions(opts) {
 	}
 	return options;
 }
-const { defineProperty } = Object;
-const toUnenumerable = (object, key) => {
-	if (object) defineProperty(object, key, {
-		enumerable: false,
-		value: object[key]
-	});
-};
 function toESTreeLocation(node) {
-	toUnenumerable(node.loc.start, "index");
-	toUnenumerable(node.loc.end, "index");
+	const { start, end } = node.loc;
+	node.loc.start = new Position(start.line, start.column);
+	node.loc.end = new Position(end.line, end.column);
 	return node;
 }
 var estree = (superClass) => class ESTreeParserMixin extends superClass {
+	createPosition(loc) {
+		return new Position(loc.line, loc.column);
+	}
 	parse() {
-		const file = toESTreeLocation(super.parse());
-		if (this.optionFlags & 256) file.tokens = file.tokens.map(toESTreeLocation);
-		return file;
+		const file = super.parse();
+		if (this.optionFlags & 512) file.tokens = file.tokens.map(toESTreeLocation);
+		return toESTreeLocation(file);
 	}
 	parseRegExpLiteral({ pattern, flags }) {
 		let regex = null;
@@ -18206,10 +18244,10 @@ var estree = (superClass) => class ESTreeParserMixin extends superClass {
 	parseBooleanLiteral(value) {
 		return this.estreeParseLiteral(value);
 	}
-	estreeParseChainExpression(node, endLoc) {
+	estreeParseChainExpression(node, endNode) {
 		const chain = this.startNodeAtNode(node);
 		chain.expression = node;
-		return this.finishNodeAt(chain, "ChainExpression", endLoc);
+		return this.finishNodeAtNode(chain, "ChainExpression", endNode);
 	}
 	directiveToStmt(directive) {
 		const expression = directive.value;
@@ -18355,7 +18393,7 @@ var estree = (superClass) => class ESTreeParserMixin extends superClass {
 	toAssignable(node, isLHS = false) {
 		if (node != null && this.isObjectProperty(node)) {
 			const { key, value } = node;
-			if (this.isPrivateName(key)) this.classScope.usePrivateName(this.getPrivateNameSV(key), key.loc.start);
+			if (this.isPrivateName(key)) this.classScope.usePrivateName(this.getPrivateNameSV(key), key.start);
 			this.toAssignable(value, isLHS);
 		} else super.toAssignable(node, isLHS);
 	}
@@ -18399,7 +18437,7 @@ var estree = (superClass) => class ESTreeParserMixin extends superClass {
 	}
 	stopParseSubscript(base, state) {
 		const node = super.stopParseSubscript(base, state);
-		if (state.optionalChainMember) return this.estreeParseChainExpression(node, base.loc.end);
+		if (state.optionalChainMember) return this.estreeParseChainExpression(node, base);
 		return node;
 	}
 	parseMember(base, startLoc, state, computed, optional) {
@@ -18439,6 +18477,9 @@ var estree = (superClass) => class ESTreeParserMixin extends superClass {
 	finishNodeAt(node, type, endLoc) {
 		return toESTreeLocation(super.finishNodeAt(node, type, endLoc));
 	}
+	finishNodeAtNode(node, type, endNode) {
+		return toESTreeLocation(super.finishNodeAtNode(node, type, endNode));
+	}
 	finishNode(node, type) {
 		const result = super.finishNode(node, type);
 		this.fillOptionalPropertiesForTSESLint(result);
@@ -18825,11 +18866,10 @@ const types = {
 	j_cTag: new TokContext("</tag"),
 	j_expr: new TokContext("<tag>...</tag>", true)
 };
-let nonASCIIidentifierStartChars = "ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙՠ-ֈא-תׯ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࡠ-ࡪࡰ-ࢇࢉ-࢏ࢠ-ࣉऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱৼਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚ౜ౝౠౡಀಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ೜-ೞೠೡೱೲഄ-ഌഎ-ഐഒ-ഺഽൎൔ-ൖൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄຆ-ຊຌ-ຣລວ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜑᜟ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡸᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭌᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᲀ-ᲊᲐ-ᲺᲽ-Ჿᳩ-ᳬᳮ-ᳳᳵᳶᳺᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄯㄱ-ㆎㆠ-ㆿㇰ-ㇿ㐀-䶿一-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-Ƛ꟱-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꣾꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭩꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ﬀ-ﬆﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ";
-let nonASCIIidentifierChars = "·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-٩ٰۖ-ۜ۟-۪ۤۧۨ-ۭ۰-۹ܑܰ-݊ަ-ް߀-߉߫-߽߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛ࢗ-࢟࣊-ࣣ࣡-ःऺ-़ा-ॏ॑-ॗॢॣ०-९ঁ-ঃ়া-ৄেৈো-্ৗৢৣ০-৯৾ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑ੦-ੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣ૦-૯ૺ-૿ଁ-ଃ଼ା-ୄେୈୋ-୍୕-ୗୢୣ୦-୯ஂா-ூெ-ைொ-்ௗ௦-௯ఀ-ఄ఼ా-ౄె-ైొ-్ౕౖౢౣ౦-౯ಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣ೦-೯ೳഀ-ഃ഻഼ാ-ൄെ-ൈൊ-്ൗൢൣ൦-൯ඁ-ඃ්ා-ුූෘ-ෟ෦-෯ෲෳัิ-ฺ็-๎๐-๙ັິ-ຼ່-໎໐-໙༘༙༠-༩༹༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှ၀-၉ၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏ-ႝ፝-፟፩-፱ᜒ-᜕ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝០-៩᠋-᠍᠏-᠙ᢩᤠ-ᤫᤰ-᤻᥆-᥏᧐-᧚ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼-᪉᪐-᪙᪰-᪽ᪿ-᫝᫠-᫫ᬀ-ᬄ᬴-᭄᭐-᭙᭫-᭳ᮀ-ᮂᮡ-ᮭ᮰-᮹᯦-᯳ᰤ-᰷᱀-᱉᱐-᱙᳐-᳔᳒-᳨᳭᳴᳷-᳹᷀-᷿‌‍‿⁀⁔⃐-⃥⃜⃡-⃰⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯・꘠-꘩꙯ꙴ-꙽ꚞꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧ꠬ꢀꢁꢴ-ꣅ꣐-꣙꣠-꣱ꣿ-꤉ꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀꧐-꧙ꧥ꧰-꧹ꨩ-ꨶꩃꩌꩍ꩐-꩙ꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭꯰-꯹ﬞ︀-️︠-︯︳︴﹍-﹏０-９＿･";
+const nonASCIIidentifierStartChars = "ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙՠ-ֈא-תׯ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࡠ-ࡪࡰ-ࢇࢉ-࢏ࢠ-ࣉऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱৼਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚ౜ౝౠౡಀಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ೜-ೞೠೡೱೲഄ-ഌഎ-ഐഒ-ഺഽൎൔ-ൖൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄຆ-ຊຌ-ຣລວ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜑᜟ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡸᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭌᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᲀ-ᲊᲐ-ᲺᲽ-Ჿᳩ-ᳬᳮ-ᳳᳵᳶᳺᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄯㄱ-ㆎㆠ-ㆿㇰ-ㇿ㐀-䶿一-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-Ƛ꟱-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꣾꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭩꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ﬀ-ﬆﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ";
+const nonASCIIidentifierChars = "·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-٩ٰۖ-ۜ۟-۪ۤۧۨ-ۭ۰-۹ܑܰ-݊ަ-ް߀-߉߫-߽߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛ࢗ-࢟࣊-ࣣ࣡-ःऺ-़ा-ॏ॑-ॗॢॣ०-९ঁ-ঃ়া-ৄেৈো-্ৗৢৣ০-৯৾ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑ੦-ੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣ૦-૯ૺ-૿ଁ-ଃ଼ା-ୄେୈୋ-୍୕-ୗୢୣ୦-୯ஂா-ூெ-ைொ-்ௗ௦-௯ఀ-ఄ఼ా-ౄె-ైొ-్ౕౖౢౣ౦-౯ಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣ೦-೯ೳഀ-ഃ഻഼ാ-ൄെ-ൈൊ-്ൗൢൣ൦-൯ඁ-ඃ්ා-ුූෘ-ෟ෦-෯ෲෳัิ-ฺ็-๎๐-๙ັິ-ຼ່-໎໐-໙༘༙༠-༩༹༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှ၀-၉ၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏ-ႝ፝-፟፩-፱ᜒ-᜕ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝០-៩᠋-᠍᠏-᠙ᢩᤠ-ᤫᤰ-᤻᥆-᥏᧐-᧚ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼-᪉᪐-᪙᪰-᪽ᪿ-᫝᫠-᫫ᬀ-ᬄ᬴-᭄᭐-᭙᭫-᭳ᮀ-ᮂᮡ-ᮭ᮰-᮹᯦-᯳ᰤ-᰷᱀-᱉᱐-᱙᳐-᳔᳒-᳨᳭᳴᳷-᳹᷀-᷿‌‍‿⁀⁔⃐-⃥⃜⃡-⃰⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯・꘠-꘩꙯ꙴ-꙽ꚞꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧ꠬ꢀꢁꢴ-ꣅ꣐-꣙꣠-꣱ꣿ-꤉ꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀꧐-꧙ꧥ꧰-꧹ꨩ-ꨶꩃꩌꩍ꩐-꩙ꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭꯰-꯹ﬞ︀-️︠-︯︳︴﹍-﹏０-９＿･";
 const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
 const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
-nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
 const astralIdentifierStartCodes = [
 	0,
 	11,
@@ -20038,7 +20078,7 @@ var ScopeHandler = class {
 	}
 	checkLocalExport(id) {
 		const { name } = id;
-		if (!this.scopeStack[0].names.has(name)) this.undefinedExports.set(name, id.loc.start);
+		if (!this.scopeStack[0].names.has(name)) this.undefinedExports.set(name, id.start);
 	}
 	currentScope() {
 		return this.scopeStack[this.scopeStack.length - 1];
@@ -20254,7 +20294,7 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 		id.typeAnnotation = this.finishNode(typeContainer, "TypeAnnotation");
 		this.resetEndLocation(id);
 		this.semicolon();
-		this.scope.declareName(node.id.name, 2048, node.id.loc.start);
+		this.scope.declareName(node.id.name, 2048, node.id.start);
 		return this.finishNode(node, "DeclareFunction");
 	}
 	flowParseDeclare(node, insideModule) {
@@ -20275,7 +20315,7 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 	flowParseDeclareVariable(node) {
 		this.next();
 		node.id = this.flowParseTypeAnnotatableIdentifier(true);
-		this.scope.declareName(node.id.name, 5, node.id.loc.start);
+		this.scope.declareName(node.id.name, 5, node.id.start);
 		this.semicolon();
 		return this.finishNode(node, "DeclareVariable");
 	}
@@ -20283,7 +20323,7 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 		this.scope.enter(0);
 		if (this.match(130)) node.id = super.parseExprAtom();
 		else node.id = this.parseIdentifier();
-		const bodyNode = node.body = this.startNode();
+		const bodyNode = this.startNode();
 		const body = bodyNode.body = [];
 		this.expect(2);
 		while (!this.match(4)) {
@@ -20299,7 +20339,7 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 		}
 		this.scope.exit();
 		this.expect(4);
-		this.finishNode(bodyNode, "BlockStatement");
+		node.body = this.finishNode(bodyNode, "BlockStatement");
 		let kind = null;
 		let hasModuleExport = false;
 		body.forEach((bodyElement) => {
@@ -20339,12 +20379,12 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 				node.default = false;
 				return this.finishNode(node, "DeclareExportDeclaration");
 			} else if (this.match(51) || this.match(2) || this.isContextual(125) || this.isContextual(126) || this.isContextual(127)) {
-				node = this.parseExport(node, null);
-				if (node.type === "ExportNamedDeclaration") {
-					node.default = false;
-					delete node.exportKind;
-					return this.castNodeTo(node, "DeclareExportDeclaration");
-				} else return this.castNodeTo(node, "DeclareExportAllDeclaration");
+				const result = this.parseExport(node, null);
+				if (result.type === "ExportNamedDeclaration") {
+					result.default = false;
+					delete result.exportKind;
+					return this.castNodeTo(result, "DeclareExportDeclaration");
+				} else return this.castNodeTo(result, "DeclareExportAllDeclaration");
 			}
 		}
 		throw this.unexpected();
@@ -20375,7 +20415,7 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 	}
 	flowParseInterfaceish(node, isClass) {
 		node.id = this.flowParseRestrictedIdentifier(!isClass, true);
-		this.scope.declareName(node.id.name, isClass ? 17 : 8201, node.id.loc.start);
+		this.scope.declareName(node.id.name, isClass ? 17 : 8201, node.id.start);
 		if (this.match(43)) node.typeParameters = this.flowParseTypeParameterDeclaration();
 		else node.typeParameters = null;
 		node.extends = [];
@@ -20383,14 +20423,16 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 			node.extends.push(this.flowParseInterfaceExtends());
 		while (!isClass && this.eat(8));
 		if (isClass) {
-			node.implements = [];
-			node.mixins = [];
+			const implementsList = [];
+			const mixins = [];
 			if (this.eatContextual(113)) do
-				node.mixins.push(this.flowParseInterfaceExtends());
+				mixins.push(this.flowParseInterfaceExtends());
 			while (this.eat(8));
 			if (this.eatContextual(109)) do
-				node.implements.push(this.flowParseInterfaceExtends());
+				implementsList.push(this.flowParseInterfaceExtends());
 			while (this.eat(8));
+			node.mixins = mixins;
+			node.implements = implementsList;
 		}
 		node.body = this.flowParseObjectType({
 			allowStatic: isClass,
@@ -20424,7 +20466,7 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 	}
 	flowParseTypeAlias(node) {
 		node.id = this.flowParseRestrictedIdentifier(false, true);
-		this.scope.declareName(node.id.name, 8201, node.id.loc.start);
+		this.scope.declareName(node.id.name, 8201, node.id.start);
 		if (this.match(43)) node.typeParameters = this.flowParseTypeParameterDeclaration();
 		else node.typeParameters = null;
 		node.right = this.flowParseTypeInitialiser(25);
@@ -20434,7 +20476,7 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 	flowParseOpaqueType(node, declare) {
 		this.expectContextual(126);
 		node.id = this.flowParseRestrictedIdentifier(true, true);
-		this.scope.declareName(node.id.name, 8201, node.id.loc.start);
+		this.scope.declareName(node.id.name, 8201, node.id.start);
 		if (this.match(43)) node.typeParameters = this.flowParseTypeParameterDeclaration();
 		else node.typeParameters = null;
 		node.supertype = null;
@@ -20567,7 +20609,7 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 		if (this.match(43) || this.match(6)) {
 			node.method = true;
 			node.optional = false;
-			node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.loc.start));
+			node.value = this.flowParseObjectTypeMethodish(this.startNodeAtNode(node));
 		} else {
 			node.method = false;
 			if (this.eat(13)) node.optional = true;
@@ -20647,12 +20689,12 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 			if (this.eat(0)) {
 				if (protoStartLoc != null) this.unexpected(protoStartLoc);
 				if (this.eat(0)) {
-					if (variance) this.unexpected(variance.loc.start);
+					if (variance) this.unexpected(variance.start);
 					nodeStart.internalSlots.push(this.flowParseObjectTypeInternalSlot(node, isStatic));
 				} else nodeStart.indexers.push(this.flowParseObjectTypeIndexer(node, isStatic, variance));
 			} else if (this.match(6) || this.match(43)) {
 				if (protoStartLoc != null) this.unexpected(protoStartLoc);
-				if (variance) this.unexpected(variance.loc.start);
+				if (variance) this.unexpected(variance.start);
 				nodeStart.callProperties.push(this.flowParseObjectTypeCallProperty(node, isStatic));
 			} else {
 				let kind = "init";
@@ -20699,8 +20741,8 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 			if (this.match(43) || this.match(6)) {
 				node.method = true;
 				if (protoStartLoc != null) this.unexpected(protoStartLoc);
-				if (variance) this.unexpected(variance.loc.start);
-				node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.loc.start));
+				if (variance) this.unexpected(variance.start);
+				node.value = this.flowParseObjectTypeMethodish(this.startNodeAtNode(node));
 				if (kind === "get" || kind === "set") this.flowCheckGetterSetterParams(node);
 				if (!allowSpread && node.key.name === "constructor" && node.value.this) this.raise(FlowErrors.ThisParamBannedInConstructor, node.value.this);
 			} else {
@@ -20763,7 +20805,7 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 	flowParseFunctionTypeParam(first) {
 		let name = null;
 		let optional = false;
-		let typeAnnotation = null;
+		let typeAnnotation;
 		const node = this.startNode();
 		const lh = this.lookahead();
 		const isThis = this.state.type === 74;
@@ -20782,7 +20824,7 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 		return this.finishNode(node, "FunctionTypeParam");
 	}
 	reinterpretTypeAsFunctionTypeParam(type) {
-		const node = this.startNodeAt(type.loc.start);
+		const node = this.startNodeAtNode(type);
 		node.name = null;
 		node.optional = false;
 		node.typeAnnotation = type;
@@ -20964,7 +21006,7 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 	flowParseAnonFunctionWithoutParens() {
 		const param = this.flowParsePrefixType();
 		if (!this.state.noAnonFunctionType && this.eat(15)) {
-			const node = this.startNodeAt(param.loc.start);
+			const node = this.startNodeAtNode(param);
 			node.params = [this.reinterpretTypeAsFunctionTypeParam(param)];
 			node.rest = null;
 			node.this = null;
@@ -21019,7 +21061,7 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 	}
 	typeCastToParameter(node) {
 		node.expression.typeAnnotation = node.typeAnnotation;
-		this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);
+		this.resetEndLocationFromNode(node.expression, node.typeAnnotation);
 		return node.expression;
 	}
 	flowParseVariance() {
@@ -21108,7 +21150,9 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 		const originalNoArrowAt = this.state.noArrowAt;
 		const node = this.startNodeAt(startLoc);
 		let { consequent, failed } = this.tryParseConditionalConsequent();
-		let [valid, invalid] = this.getArrowLikeExpressions(consequent);
+		const result = this.getArrowLikeExpressions(consequent);
+		let valid = result[0];
+		const invalid = result[1];
 		if (failed || invalid.length > 0) {
 			const noArrowAt = [...originalNoArrowAt];
 			if (invalid.length > 0) {
@@ -21116,14 +21160,14 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 				this.state.noArrowAt = noArrowAt;
 				for (let i = 0; i < invalid.length; i++) noArrowAt.push(invalid[i].start);
 				({consequent, failed} = this.tryParseConditionalConsequent());
-				[valid, invalid] = this.getArrowLikeExpressions(consequent);
+				[valid] = this.getArrowLikeExpressions(consequent);
 			}
 			if (failed && valid.length > 1) this.raise(FlowErrors.AmbiguousConditionalArrow, state.startLoc);
 			if (failed && valid.length === 1) {
 				this.state = state;
 				noArrowAt.push(valid[0].start);
 				this.state.noArrowAt = noArrowAt;
-				({consequent, failed} = this.tryParseConditionalConsequent());
+				({consequent} = this.tryParseConditionalConsequent());
 			}
 		}
 		this.getArrowLikeExpressions(consequent, true);
@@ -21292,7 +21336,7 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 	toReferencedList(exprList, isParenthesizedExpr) {
 		for (let i = 0; i < exprList.length; i++) {
 			const expr = exprList[i];
-			if (expr && expr.type === "TypeCastExpression" && !expr.extra?.parenthesized && (exprList.length > 1 || !isParenthesizedExpr)) this.raise(FlowErrors.TypeCastInPattern, expr.typeAnnotation);
+			if (expr?.type === "TypeCastExpression" && !expr.extra?.parenthesized && (exprList.length > 1 || !isParenthesizedExpr)) this.raise(FlowErrors.TypeCastInPattern, expr.typeAnnotation);
 		}
 		return exprList;
 	}
@@ -21322,7 +21366,7 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 		return !this.match(10) && super.isNonstaticConstructor(method);
 	}
 	pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
-		if (method.variance) this.unexpected(method.variance.loc.start);
+		if (method.variance) this.unexpected(method.variance.start);
 		delete method.variance;
 		if (this.match(43)) method.typeParameters = this.flowParseTypeParameterDeclaration();
 		super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);
@@ -21335,7 +21379,7 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 		}
 	}
 	pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {
-		if (method.variance) this.unexpected(method.variance.loc.start);
+		if (method.variance) this.unexpected(method.variance.start);
 		delete method.variance;
 		if (this.match(43)) method.typeParameters = this.flowParseTypeParameterDeclaration();
 		super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync);
@@ -21368,7 +21412,7 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 		node.variance = this.flowParseVariance();
 	}
 	parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {
-		if (prop.variance) this.unexpected(prop.variance.loc.start);
+		if (prop.variance) this.unexpected(prop.variance.start);
 		delete prop.variance;
 		let typeParameters;
 		if (this.match(43) && !isAccessor) {
@@ -21455,8 +21499,8 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 		}
 		const specifierIsTypeImport = hasTypeImportKind(specifier);
 		if (isInTypeOnlyImport && specifierIsTypeImport) this.raise(FlowErrors.ImportTypeShorthandOnlyInPureImport, specifier);
-		if (isInTypeOnlyImport || specifierIsTypeImport) this.checkReservedType(specifier.local.name, specifier.local.loc.start, true);
-		if (isBinding && !isInTypeOnlyImport && !specifierIsTypeImport) this.checkReservedWord(specifier.local.name, specifier.loc.start, true, true);
+		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");
 	}
 	parseBindingAtom() {
@@ -21569,8 +21613,8 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 		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(canBeArrow) {
-		return super.parseParenAndDistinguishExpression(canBeArrow && !this.state.noArrowAt.includes(this.sourceToOffsetPos(this.state.start)));
+	parseParenAndDistinguishExpression(canStartArrow) {
+		return super.parseParenAndDistinguishExpression(canStartArrow && !this.state.noArrowAt.includes(this.sourceToOffsetPos(this.state.start)));
 	}
 	parseSubscripts(base, startLoc, noCalls) {
 		if (base.type === "Identifier" && base.name === "async" && this.state.noArrowAt.includes(startLoc.index)) {
@@ -21691,11 +21735,8 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 	hasFlowCommentCompletion() {
 		if (this.input.indexOf("*/", this.state.pos) === -1) throw this.raise(Errors.UnterminatedComment, this.state.curPosition());
 	}
-	flowEnumErrorBooleanMemberNotInitialized(loc, { enumName, memberName }) {
-		this.raise(FlowErrors.EnumBooleanMemberNotInitialized, loc, {
-			memberName,
-			enumName
-		});
+	flowEnumErrorBooleanMemberNotInitialized(loc, names) {
+		this.raise(FlowErrors.EnumBooleanMemberNotInitialized, loc, names);
 	}
 	flowEnumErrorInvalidMemberInitializer(loc, enumContext) {
 		return this.raise(!enumContext.explicitType ? FlowErrors.EnumInvalidMemberInitializerUnknownType : enumContext.explicitType === "symbol" ? FlowErrors.EnumInvalidMemberInitializerSymbolType : FlowErrors.EnumInvalidMemberInitializerPrimaryType, loc, enumContext);
@@ -21714,44 +21755,34 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 				const literal = this.parseNumericLiteral(this.state.value);
 				if (endOfInit()) return {
 					type: "number",
-					loc: literal.loc.start,
+					loc: literal.start,
 					value: literal
 				};
-				return {
-					type: "invalid",
-					loc: startLoc
-				};
+				break;
 			}
 			case 130: {
 				const literal = this.parseStringLiteral(this.state.value);
 				if (endOfInit()) return {
 					type: "string",
-					loc: literal.loc.start,
+					loc: literal.start,
 					value: literal
 				};
-				return {
-					type: "invalid",
-					loc: startLoc
-				};
+				break;
 			}
 			case 81:
 			case 82: {
 				const literal = this.parseBooleanLiteral(this.match(81));
 				if (endOfInit()) return {
 					type: "boolean",
-					loc: literal.loc.start,
+					loc: literal.start,
 					value: literal
 				};
-				return {
-					type: "invalid",
-					loc: startLoc
-				};
 			}
-			default: return {
-				type: "invalid",
-				loc: startLoc
-			};
 		}
+		return {
+			type: "invalid",
+			loc: startLoc
+		};
 	}
 	flowEnumMemberRaw() {
 		const loc = this.state.startLoc;
@@ -21860,7 +21891,7 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 	}
 	flowEnumBody(node, id) {
 		const enumName = id.name;
-		const nameLoc = id.loc.start;
+		const nameLoc = id.start;
 		const explicitType = this.flowEnumParseExplicitType({ enumName });
 		this.expect(2);
 		const { members, hasUnknownMembers } = this.flowEnumMembers({
@@ -21905,7 +21936,7 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 					this.expect(4);
 					return this.finishNode(node, "EnumStringBody");
 				} else if (!numsLen && !strsLen && boolsLen >= defaultedLen) {
-					for (const member of members.defaultedMembers) this.flowEnumErrorBooleanMemberNotInitialized(member.loc.start, {
+					for (const member of members.defaultedMembers) this.flowEnumErrorBooleanMemberNotInitialized(member.start, {
 						enumName,
 						memberName: member.id.name
 					});
@@ -21913,7 +21944,7 @@ var flow = (superClass) => class FlowParserMixin extends superClass {
 					this.expect(4);
 					return this.finishNode(node, "EnumBooleanBody");
 				} else if (!boolsLen && !strsLen && numsLen >= defaultedLen) {
-					for (const member of members.defaultedMembers) this.flowEnumErrorNumberMemberNotInitialized(member.loc.start, {
+					for (const member of members.defaultedMembers) this.flowEnumErrorNumberMemberNotInitialized(member.start, {
 						enumName,
 						memberName: member.id.name
 					});
@@ -22461,8 +22492,8 @@ var jsx = (superClass) => class JSXParserMixin extends superClass {
 		return this.finishNode(node, "JSXExpressionContainer");
 	}
 	jsxParseAttribute() {
-		const node = this.startNode();
 		if (this.match(2)) {
+			const node = this.startNode();
 			this.setContext(types.brace);
 			this.next();
 			this.expect(17);
@@ -22472,13 +22503,17 @@ var jsx = (superClass) => class JSXParserMixin extends superClass {
 			this.expect(4);
 			return this.finishNode(node, "JSXSpreadAttribute");
 		}
+		const node = this.startNode();
 		node.name = this.jsxParseNamespacedName();
 		node.value = this.eat(25) ? this.jsxParseAttributeValue() : null;
 		return this.finishNode(node, "JSXAttribute");
 	}
 	jsxParseOpeningElementAt(startLoc) {
+		if (this.eat(139)) {
+			const node = this.startNodeAt(startLoc);
+			return this.finishNode(node, "JSXOpeningFragment");
+		}
 		const node = this.startNodeAt(startLoc);
-		if (this.eat(139)) return this.finishNode(node, "JSXOpeningFragment");
 		node.name = this.jsxParseElementName();
 		return this.jsxParseOpeningElementAfterName(node);
 	}
@@ -22491,8 +22526,11 @@ var jsx = (superClass) => class JSXParserMixin extends superClass {
 		return this.finishNode(node, "JSXOpeningElement");
 	}
 	jsxParseClosingElementAt(startLoc) {
+		if (this.eat(139)) {
+			const node = this.startNodeAt(startLoc);
+			return this.finishNode(node, "JSXClosingFragment");
+		}
 		const node = this.startNodeAt(startLoc);
-		if (this.eat(139)) return this.finishNode(node, "JSXClosingFragment");
 		node.name = this.jsxParseElementName();
 		this.expect(139);
 		return this.finishNode(node, "JSXClosingElement");
@@ -22508,6 +22546,7 @@ var jsx = (superClass) => class JSXParserMixin extends superClass {
 					startLoc = this.state.startLoc;
 					this.next();
 					if (this.eat(52)) {
+						this.setLoc(startLoc);
 						closingElement = this.jsxParseClosingElementAt(startLoc);
 						break contents;
 					}
@@ -22705,6 +22744,9 @@ var ProductionParameterHandler = class {
 	get hasIn() {
 		return (this.currentFlags() & 8) > 0;
 	}
+	get inFSharpPipelineDirectBody() {
+		return (this.currentFlags() & 16) === 0;
+	}
 };
 function functionFlags(isAsync, isGenerator) {
 	return (isAsync ? 2 : 0) | (isGenerator ? 1 : 0);
@@ -22769,7 +22811,7 @@ var CommentsParser = class extends BaseParser {
 			lastCommentWS.leadingNode = node;
 			i--;
 		}
-		const { start: nodeStart } = node;
+		const nodeStart = node.start;
 		for (; i >= 0; i--) {
 			const commentWS = commentStack[i];
 			const commentEnd = commentWS.end;
@@ -22797,6 +22839,7 @@ var CommentsParser = class extends BaseParser {
 					adjustInnerComments(node, node.properties, commentWS);
 					break;
 				case "CallExpression":
+				case "NewExpression":
 				case "OptionalCallExpression":
 					adjustInnerComments(node, node.arguments, commentWS);
 					break;
@@ -22809,6 +22852,7 @@ var CommentsParser = class extends BaseParser {
 				case "ObjectMethod":
 				case "ClassMethod":
 				case "ClassPrivateMethod":
+				case "TSTypeParameterDeclaration":
 					adjustInnerComments(node, node.params, commentWS);
 					break;
 				case "ArrayExpression":
@@ -22819,12 +22863,12 @@ var CommentsParser = class extends BaseParser {
 				case "ImportDeclaration":
 					adjustInnerComments(node, node.specifiers, commentWS);
 					break;
-				case "TSEnumDeclaration":
-					setInnerComments(node, comments);
-					break;
 				case "TSEnumBody":
 					adjustInnerComments(node, node.members, commentWS);
 					break;
+				case "TSInterfaceBody":
+					adjustInnerComments(node, node.body, commentWS);
+					break;
 				default: setInnerComments(node, comments);
 			}
 			else setInnerComments(node, comments);
@@ -22857,7 +22901,7 @@ var CommentsParser = class extends BaseParser {
 	}
 };
 var State = class State {
-	flags = 512;
+	flags = 2048;
 	get strict() {
 		return (this.flags & 1) > 0;
 	}
@@ -22878,69 +22922,78 @@ var State = class State {
 		this.startLoc = this.endLoc = new Position(startLine, startColumn, startIndex);
 	}
 	errors = [];
-	potentialArrowAt = -1;
 	noArrowAt = [];
 	noArrowParamsConversionAt = [];
-	get inType() {
+	get canStartArrow() {
 		return (this.flags & 2) > 0;
 	}
-	set inType(v) {
+	set canStartArrow(v) {
 		if (v) this.flags |= 2;
 		else this.flags &= -3;
 	}
-	get noAnonFunctionType() {
+	get inType() {
 		return (this.flags & 4) > 0;
 	}
-	set noAnonFunctionType(v) {
+	set inType(v) {
 		if (v) this.flags |= 4;
 		else this.flags &= -5;
 	}
-	get hasFlowComment() {
+	get noAnonFunctionType() {
 		return (this.flags & 8) > 0;
 	}
-	set hasFlowComment(v) {
+	set noAnonFunctionType(v) {
 		if (v) this.flags |= 8;
 		else this.flags &= -9;
 	}
-	get isAmbientContext() {
+	get hasFlowComment() {
 		return (this.flags & 16) > 0;
 	}
-	set isAmbientContext(v) {
+	set hasFlowComment(v) {
 		if (v) this.flags |= 16;
 		else this.flags &= -17;
 	}
-	get inAbstractClass() {
+	get isAmbientContext() {
 		return (this.flags & 32) > 0;
 	}
-	set inAbstractClass(v) {
+	set isAmbientContext(v) {
 		if (v) this.flags |= 32;
 		else this.flags &= -33;
 	}
-	get inDisallowConditionalTypesContext() {
+	get inAbstractClass() {
 		return (this.flags & 64) > 0;
 	}
-	set inDisallowConditionalTypesContext(v) {
+	set inAbstractClass(v) {
 		if (v) this.flags |= 64;
 		else this.flags &= -65;
 	}
-	topicContext = {
-		maxNumOfResolvableTopics: 0,
-		maxTopicIndex: null
-	};
-	get soloAwait() {
+	get inDisallowConditionalTypesContext() {
 		return (this.flags & 128) > 0;
 	}
-	set soloAwait(v) {
+	set inDisallowConditionalTypesContext(v) {
 		if (v) this.flags |= 128;
 		else this.flags &= -129;
 	}
-	get inFSharpPipelineDirectBody() {
+	get inConditionalConsequent() {
 		return (this.flags & 256) > 0;
 	}
-	set inFSharpPipelineDirectBody(v) {
+	set inConditionalConsequent(v) {
 		if (v) this.flags |= 256;
 		else this.flags &= -257;
 	}
+	get inHackPipelineBody() {
+		return (this.flags & 512) > 0;
+	}
+	set inHackPipelineBody(v) {
+		if (v) this.flags |= 512;
+		else this.flags &= -513;
+	}
+	get seenTopicReference() {
+		return (this.flags & 1024) > 0;
+	}
+	set seenTopicReference(v) {
+		if (v) this.flags |= 1024;
+		else this.flags &= -1025;
+	}
 	labels = [];
 	commentsLen = 0;
 	commentStack = [];
@@ -22953,26 +23006,26 @@ var State = class State {
 	lastTokStartLoc = null;
 	context = [types.brace];
 	get canStartJSXElement() {
-		return (this.flags & 512) > 0;
+		return (this.flags & 2048) > 0;
 	}
 	set canStartJSXElement(v) {
-		if (v) this.flags |= 512;
-		else this.flags &= -513;
+		if (v) this.flags |= 2048;
+		else this.flags &= -2049;
 	}
 	get containsEsc() {
-		return (this.flags & 1024) > 0;
+		return (this.flags & 4096) > 0;
 	}
 	set containsEsc(v) {
-		if (v) this.flags |= 1024;
-		else this.flags &= -1025;
+		if (v) this.flags |= 4096;
+		else this.flags &= -4097;
 	}
 	firstInvalidTemplateEscapePos = null;
 	get hasTopLevelAwait() {
-		return (this.flags & 2048) > 0;
+		return (this.flags & 8192) > 0;
 	}
 	set hasTopLevelAwait(v) {
-		if (v) this.flags |= 2048;
-		else this.flags &= -2049;
+		if (v) this.flags |= 8192;
+		else this.flags &= -8193;
 	}
 	strictErrors = /* @__PURE__ */ new Map();
 	tokensLength = 0;
@@ -22988,10 +23041,8 @@ var State = class State {
 		state.startLoc = this.startLoc;
 		state.endLoc = this.endLoc;
 		state.errors = this.errors.slice();
-		state.potentialArrowAt = this.potentialArrowAt;
 		state.noArrowAt = this.noArrowAt.slice();
 		state.noArrowParamsConversionAt = this.noArrowParamsConversionAt.slice();
-		state.topicContext = this.topicContext;
 		state.labels = this.labels.slice();
 		state.commentsLen = this.commentsLen;
 		state.commentStack = this.commentStack.slice();
@@ -23250,6 +23301,12 @@ var Token = class {
 		this.loc = new SourceLocation(state.startLoc, state.endLoc);
 	}
 };
+let locDataCache;
+function resetLocData() {
+	const data = locDataCache;
+	locDataCache = void 0;
+	return data;
+}
 var Tokenizer = class extends CommentsParser {
 	isLookahead;
 	tokens = [];
@@ -23261,6 +23318,17 @@ var Tokenizer = class extends CommentsParser {
 		this.length = input.length;
 		this.comments = [];
 		this.isLookahead = false;
+		if (!locDataCache || locDataCache.length < (this.length + 1) * 2 || options.locations === "packed") locDataCache = new Uint32Array((this.length + 1) * 2);
+		this.locData = locDataCache;
+	}
+	setLoc(loc) {
+		const dataIndex = this.offsetToSourcePos(loc.index);
+		this.locData[dataIndex * 2] = loc.line;
+		this.locData[dataIndex * 2 + 1] = loc.column;
+	}
+	getLoc(locIndex) {
+		const dataIndex = this.offsetToSourcePos(locIndex);
+		return new Position(this.locData[dataIndex * 2], this.locData[dataIndex * 2 + 1], locIndex);
 	}
 	pushToken(token) {
 		this.tokens.length = this.state.tokensLength;
@@ -23269,7 +23337,7 @@ var Tokenizer = class extends CommentsParser {
 	}
 	next() {
 		this.checkKeywordEscapes();
-		if (this.optionFlags & 256) this.pushToken(new Token(this.state));
+		if (this.optionFlags & 512) this.pushToken(new Token(this.state));
 		this.state.lastTokEndLoc = this.state.endLoc;
 		this.state.lastTokStartLoc = this.state.startLoc;
 		this.nextToken();
@@ -23380,7 +23448,7 @@ var Tokenizer = class extends CommentsParser {
 			end: this.sourceToOffsetPos(end + commentEnd.length),
 			loc: new SourceLocation(startLoc, this.state.curPosition())
 		};
-		if (this.optionFlags & 256) this.pushToken(comment);
+		if (this.optionFlags & 512) this.pushToken(comment);
 		return comment;
 	}
 	skipLineComment(startSkip) {
@@ -23398,12 +23466,12 @@ var Tokenizer = class extends CommentsParser {
 			end: this.sourceToOffsetPos(end),
 			loc: new SourceLocation(startLoc, this.state.curPosition())
 		};
-		if (this.optionFlags & 256) this.pushToken(comment);
+		if (this.optionFlags & 512) this.pushToken(comment);
 		return comment;
 	}
 	skipSpace() {
 		const spaceStart = this.state.pos;
-		const comments = this.optionFlags & 4096 ? [] : null;
+		const comments = this.optionFlags & 8192 ? [] : null;
 		loop: while (this.state.pos < this.length) {
 			const ch = this.input.charCodeAt(this.state.pos);
 			switch (ch) {
@@ -23442,7 +23510,7 @@ var Tokenizer = class extends CommentsParser {
 					}
 					break;
 				default: if (isWhitespace(ch)) ++this.state.pos;
-				else if (ch === 45 && !this.inModule && this.optionFlags & 8192) {
+				else if (ch === 45 && !this.inModule && this.optionFlags & 16384) {
 					const pos = this.state.pos;
 					if (this.input.charCodeAt(pos + 1) === 45 && this.input.charCodeAt(pos + 2) === 62 && (spaceStart === 0 || this.state.lineStart > spaceStart)) {
 						const comment = this.skipLineComment(3);
@@ -23451,7 +23519,7 @@ var Tokenizer = class extends CommentsParser {
 							comments?.push(comment);
 						}
 					} else break loop;
-				} else if (ch === 60 && !this.inModule && this.optionFlags & 8192) {
+				} else if (ch === 60 && !this.inModule && this.optionFlags & 16384) {
 					const pos = this.state.pos;
 					if (this.input.charCodeAt(pos + 1) === 33 && this.input.charCodeAt(pos + 2) === 45 && this.input.charCodeAt(pos + 3) === 45) {
 						const comment = this.skipLineComment(4);
@@ -23881,13 +23949,13 @@ var Tokenizer = class extends CommentsParser {
 			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.InvalidBigIntLiteral, startLoc);
 			++this.state.pos;
 			isBigInt = true;
 		}
 		if (isIdentifierStart(this.codePointAtPos(this.state.pos))) throw this.raise(Errors.NumberIdentifier, this.state.curPosition());
-		const str = this.input.slice(start, this.state.pos).replace(/[_mn]/g, "");
 		if (isBigInt) {
 			this.finishToken(132, str);
 			return;
@@ -23971,21 +24039,22 @@ var Tokenizer = class extends CommentsParser {
 		if (tokenIsKeyword(type) && this.state.containsEsc) this.raise(Errors.InvalidEscapedReservedWord, this.state.startLoc, { reservedWord: tokenLabelName(type) });
 	}
 	raise(toParseError, at, details = {}) {
-		const error = toParseError(at instanceof Position ? at : at.loc.start, details);
-		if (!(this.optionFlags & 2048)) throw error;
+		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 ? at : at.loc.start;
-		const pos = loc.index;
+		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];
-			if (error.loc.index === pos) return errors[i] = toParseError(loc, details);
-			if (error.loc.index < pos) break;
+			if (error.pos === pos) return errors[i] = toParseError(loc, pos, details);
+			if (error.pos < pos) break;
 		}
-		return this.raise(toParseError, at, details);
+		return this.raise(toParseError, loc, details);
 	}
 	updateContext(prevType) {}
 	unexpected(loc, type) {
@@ -24005,7 +24074,7 @@ var Tokenizer = class extends CommentsParser {
 	}
 	errorHandlers_readInt = {
 		invalidDigit: (pos, lineStart, curLine, radix) => {
-			if (!(this.optionFlags & 2048)) return false;
+			if (!(this.optionFlags & 4096)) return false;
 			this.raise(Errors.InvalidDigit, buildPosition(pos, lineStart, curLine), { radix });
 			return true;
 		},
@@ -24042,7 +24111,6 @@ var ClassScope = class {
 var ClassScopeHandler = class {
 	parser;
 	stack = [];
-	undefinedPrivateNames = /* @__PURE__ */ new Map();
 	constructor(parser) {
 		this.parser = parser;
 	}
@@ -24098,9 +24166,8 @@ var ArrowHeadParsingScope = class extends ExpressionScope {
 	constructor(type) {
 		super(type);
 	}
-	recordDeclarationError(ParsingErrorClass, at) {
-		const index = at.index;
-		this.declarationErrors.set(index, [ParsingErrorClass, at]);
+	recordDeclarationError(ParsingErrorClass, index) {
+		this.declarationErrors.set(index, ParsingErrorClass);
 	}
 	clearDeclarationError(index) {
 		this.declarationErrors.delete(index);
@@ -24121,22 +24188,21 @@ var ExpressionScopeHandler = class {
 	exit() {
 		this.stack.pop();
 	}
-	recordParameterInitializerError(toParseError, node) {
-		const origin = node.loc.start;
+	recordParameterInitializerError(toParseError, loc) {
 		const { stack } = this;
 		let i = stack.length - 1;
 		let scope = stack[i];
 		while (!scope.isCertainlyParameterDeclaration()) {
-			if (scope.canBeArrowParameterDeclaration()) scope.recordDeclarationError(toParseError, origin);
+			if (scope.canBeArrowParameterDeclaration()) scope.recordDeclarationError(toParseError, loc);
 			else return;
 			scope = stack[--i];
 		}
-		this.parser.raise(toParseError, origin);
+		this.parser.raise(toParseError, loc);
 	}
 	recordArrowParameterBindingError(error, node) {
 		const { stack } = this;
 		const scope = stack[stack.length - 1];
-		const origin = node.loc.start;
+		const origin = node.start;
 		if (scope.isCertainlyParameterDeclaration()) this.parser.raise(error, origin);
 		else if (scope.canBeArrowParameterDeclaration()) scope.recordDeclarationError(error, origin);
 		else return;
@@ -24154,12 +24220,12 @@ var ExpressionScopeHandler = class {
 		const { stack } = this;
 		const currentScope = stack[stack.length - 1];
 		if (!currentScope.canBeArrowParameterDeclaration()) return;
-		currentScope.iterateErrors(([toParseError, loc]) => {
-			this.parser.raise(toParseError, loc);
+		currentScope.iterateErrors((toParseError, key) => {
+			this.parser.raise(toParseError, key);
 			let i = stack.length - 2;
 			let scope = stack[i];
 			while (scope.canBeArrowParameterDeclaration()) {
-				scope.clearDeclarationError(loc.index);
+				scope.clearDeclarationError(key);
 				scope = stack[--i];
 			}
 		});
@@ -24362,51 +24428,79 @@ var ExpressionErrors = class {
 	voidPatternLoc = null;
 };
 var Node = class {
-	constructor(parser, pos, loc) {
+	constructor(optionFlags, filename, pos, loc) {
 		this.start = pos;
 		this.end = 0;
-		this.loc = new SourceLocation(loc);
-		if (parser?.optionFlags & 128) this.range = [pos, 0];
-		if (parser?.filename) this.loc.filename = parser.filename;
+		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 = Node.prototype;
 var NodeUtils = class extends UtilParser {
+	createPosition(loc) {
+		return loc;
+	}
 	startNode() {
-		const loc = this.state.startLoc;
-		return new Node(this, loc.index, loc);
+		const { startLoc } = this.state;
+		this.setLoc(startLoc);
+		return this.startNodeAt(startLoc);
 	}
 	startNodeAt(loc) {
-		return new Node(this, loc.index, loc);
+		const { optionFlags, filename } = this;
+		if (!(optionFlags & 256)) return new Node(optionFlags, filename, loc.index);
+		return new Node(optionFlags, filename, loc.index, this.createPosition(loc));
 	}
 	startNodeAtNode(type) {
-		return this.startNodeAt(type.loc.start);
+		const { optionFlags, filename } = this;
+		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);
 	}
 	finishNodeAt(node, type, endLoc) {
-		if (process.env.NODE_ENV !== "production" && node.end > 0) throw new Error("Do not call finishNode*() twice on the same node. Instead use resetEndLocation() or change type directly.");
 		node.type = type;
 		node.end = endLoc.index;
-		node.loc.end = endLoc;
-		if (this.optionFlags & 128) node.range[1] = endLoc.index;
-		if (this.optionFlags & 4096) this.processComment(node);
+		const { optionFlags } = this;
+		if (optionFlags & 256) node.loc.end = this.createPosition(endLoc);
+		if (optionFlags & 128) node.range[1] = endLoc.index;
+		if (optionFlags & 8192) this.processComment(node);
+		return node;
+	}
+	finishNodeAtNode(node, type, endNode) {
+		node.type = type;
+		node.end = endNode.end;
+		const { optionFlags } = this;
+		if (optionFlags & 256) node.loc.end = endNode.loc.end;
+		if (optionFlags & 128) node.range[1] = node.end;
+		if (optionFlags & 8192) this.processComment(node);
 		return node;
 	}
 	resetStartLocation(node, startLoc) {
 		node.start = startLoc.index;
-		node.loc.start = startLoc;
-		if (this.optionFlags & 128) node.range[0] = startLoc.index;
+		const { optionFlags } = this;
+		if (optionFlags & 256) node.loc.start = this.createPosition(startLoc);
+		if (optionFlags & 128) node.range[0] = startLoc.index;
 	}
 	resetEndLocation(node, endLoc = this.state.lastTokEndLoc) {
 		node.end = endLoc.index;
-		node.loc.end = endLoc;
-		if (this.optionFlags & 128) node.range[1] = endLoc.index;
+		const { optionFlags } = this;
+		if (optionFlags & 256) node.loc.end = this.createPosition(endLoc);
+		if (optionFlags & 128) node.range[1] = endLoc.index;
 	}
 	resetStartLocationFromNode(node, locationNode) {
-		this.resetStartLocation(node, locationNode.loc.start);
+		node.start = locationNode.start;
+		const { optionFlags } = this;
+		if (optionFlags & 256) node.loc.start = locationNode.loc.start;
+		if (optionFlags & 128) node.range[0] = locationNode.start;
+	}
+	resetEndLocationFromNode(node, locationNode) {
+		node.end = locationNode.end;
+		const { optionFlags } = this;
+		if (optionFlags & 256) node.loc.end = locationNode.loc.end;
+		if (optionFlags & 128) node.range[1] = locationNode.end;
 	}
 	castNodeTo(node, type) {
 		node.type = type;
@@ -24468,7 +24562,7 @@ var LValParser = class extends NodeUtils {
 				break;
 			case "ObjectProperty": {
 				const { key, value } = node;
-				if (this.isPrivateName(key)) this.classScope.usePrivateName(this.getPrivateNameSV(key), key.loc.start);
+				if (this.isPrivateName(key)) this.classScope.usePrivateName(this.getPrivateNameSV(key), key.start);
 				this.toAssignable(value, isLHS);
 				break;
 			}
@@ -24478,7 +24572,7 @@ var LValParser = class extends NodeUtils {
 				this.toAssignableList(node.elements, node.extra?.trailingCommaLoc, isLHS);
 				break;
 			case "AssignmentExpression":
-				if (node.operator !== "=") this.raise(Errors.MissingEqInAssignment, node.left.loc.end);
+				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.VoidPatternInitializer, node.left);
@@ -24624,13 +24718,14 @@ var LValParser = class extends NodeUtils {
 		return this.parseObjPropValue(prop, startLoc, false, false, true, false);
 	}
 	parseBindingElement(flags, decorators) {
+		const { startLoc } = this.state;
 		const left = this.parseMaybeDefault();
 		if (flags & 2) this.parseFunctionParamType(left);
 		if (decorators.length) {
 			left.decorators = decorators;
 			this.resetStartLocationFromNode(left, decorators[0]);
 		}
-		return this.parseMaybeDefault(left.loc.start, left);
+		return this.parseMaybeDefault(startLoc, left);
 	}
 	parseFunctionParamType(param) {
 		return param;
@@ -24654,7 +24749,7 @@ var LValParser = class extends NodeUtils {
 			case "ArrayPattern": return "elements";
 			case "ObjectPattern": return "properties";
 			case "VoidPattern": return true;
-			case "CallExpression": if (!disallowCallExpression && !this.state.strict && this.optionFlags & 8192) return true;
+			case "CallExpression": if (!disallowCallExpression && !this.state.strict && this.optionFlags & 16384) return true;
 		}
 		return false;
 	}
@@ -24667,7 +24762,7 @@ var LValParser = class extends NodeUtils {
 		const isOptionalMemberExpression = this.isOptionalMemberExpression(expression);
 		if (isOptionalMemberExpression || type === "MemberExpression") {
 			if (isOptionalMemberExpression) {
-				this.expectPlugin("optionalChainingAssign", expression.loc.start);
+				this.expectPlugin("optionalChainingAssign", expression.start);
 				if (ancestor.type !== "AssignmentExpression") this.raise(Errors.InvalidLhsOptionalChaining, expression, { ancestor });
 			}
 			if (binding !== 64) this.raise(Errors.InvalidPropertyBindingPattern, expression);
@@ -24707,7 +24802,7 @@ var LValParser = class extends NodeUtils {
 		if (!(bindingType & 64)) this.declareNameFromIdentifier(at, bindingType);
 	}
 	declareNameFromIdentifier(identifier, binding) {
-		this.scope.declareName(identifier.name, binding, identifier.loc.start);
+		this.scope.declareName(identifier.name, binding, identifier.start);
 	}
 	checkToRestConversion(node, allowPattern) {
 		switch (node.type) {
@@ -25413,7 +25508,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
 			case 2: return this.tsLookAhead(this.tsIsStartOfMappedType.bind(this)) ? this.tsParseMappedType() : this.tsParseTypeLiteral();
 			case 0: return this.tsParseTupleType();
 			case 6:
-				if (!(this.optionFlags & 1024)) {
+				if (!(this.optionFlags & 2048)) {
 					const startLoc = this.state.startLoc;
 					this.next();
 					const type = this.tsParseType();
@@ -25656,8 +25751,8 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
 	tsParseHeritageClause(token) {
 		const originalStartLoc = this.state.startLoc;
 		const delimitedList = this.tsParseDelimitedList("HeritageClauseElement", () => {
-			const expression = super.parseExprSubscripts();
-			if (!tsIsEntityName(expression)) this.raise(TSErrors.InvalidHeritageClauseType, expression.loc.start, { token });
+			const expression = (this.state.canStartArrow = false, super.parseExprSubscripts());
+			if (!tsIsEntityName(expression)) this.raise(TSErrors.InvalidHeritageClauseType, expression.start, { token });
 			const nodeType = token === "extends" ? "TSInterfaceHeritage" : "TSClassImplements";
 			if (expression.type === "TSInstantiationExpression") {
 				expression.type = nodeType;
@@ -25973,7 +26068,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
 		return super.isExportDefaultSpecifier();
 	}
 	parseBindingElement(flags, decorators) {
-		const startLoc = decorators.length ? decorators[0].loc.start : this.state.startLoc;
+		const startLoc = decorators.length ? null : this.state.startLoc;
 		const modified = {};
 		this.tsParseModifiers({ allowedModifiers: [
 			"public",
@@ -25985,17 +26080,18 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
 		const accessibility = modified.accessibility;
 		const override = modified.override;
 		const readonly = modified.readonly;
-		if (!(flags & 4) && (accessibility || readonly || override)) this.raise(TSErrors.UnexpectedParameterModifier, startLoc);
-		const left = this.parseMaybeDefault();
+		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);
-		const elt = this.parseMaybeDefault(left.loc.start, left);
+		const elt = this.parseMaybeDefault(startLoc2, left);
 		if (accessibility || readonly || override) {
-			const pp = this.startNodeAt(startLoc);
+			const pp = startLoc ? this.startNodeAt(startLoc) : this.startNodeAtNode(decorators[0]);
 			if (decorators.length) pp.decorators = decorators;
 			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.UnsupportedParameterPropertyKind, pp);
+			if (elt.type !== "Identifier" && elt.type !== "AssignmentPattern") this.raise(TSErrors.UnsupportedParameterPropertyKind, startLoc || decorators[0]);
 			pp.parameter = elt;
 			return this.finishNode(pp, "TSParameterProperty");
 		}
@@ -26246,7 +26342,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
 						if (token === 121) declaration.declare = true;
 						return declaration;
 					} else {
-						node.expression = this.createIdentifier(this.startNodeAt(node.loc.start), token === 121 ? "declare" : "abstract");
+						node.expression = this.createIdentifier(this.startNodeAtNode(node), token === 121 ? "declare" : "abstract");
 						this.semicolon(false);
 						return this.finishNode(node, "ExpressionStatement");
 					}
@@ -26371,7 +26467,16 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
 				return expr;
 			}
 		}
-		return super.parseConditional(expr, startLoc, refExpressionErrors);
+		this.next();
+		const node = this.startNodeAt(startLoc);
+		node.test = expr;
+		const oldInConditionalConsequent = this.state.inConditionalConsequent;
+		this.state.inConditionalConsequent = true;
+		node.consequent = this.parseMaybeAssignAllowIn();
+		this.state.inConditionalConsequent = oldInConditionalConsequent;
+		this.expect(10);
+		node.alternate = this.parseMaybeAssign();
+		return this.finishNode(node, "ConditionalExpression");
 	}
 	parseParenItem(node, startLoc) {
 		const newNode = super.parseParenItem(node, startLoc);
@@ -26514,7 +26619,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
 			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.SingleTypeParameterWithoutTrailingComma, createPositionWithColumnOffset(parameter.loc.end, 1), { 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);
@@ -26702,7 +26807,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
 	}
 	typeCastToParameter(node) {
 		node.expression.typeAnnotation = node.typeAnnotation;
-		this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);
+		this.resetEndLocationFromNode(node.expression, node.typeAnnotation);
 		return node.expression;
 	}
 	shouldParseArrow(params) {
@@ -26710,7 +26815,18 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
 		return super.shouldParseArrow(params);
 	}
 	shouldParseAsyncArrow() {
-		return this.match(10) || super.shouldParseAsyncArrow();
+		if (this.match(10)) {
+			if (this.state.inConditionalConsequent) return false;
+			return true;
+		}
+		return super.shouldParseAsyncArrow();
+	}
+	parseParenAndDistinguishExpression(canStartArrow) {
+		const oldInConditionalConsequent = this.state.inConditionalConsequent;
+		this.state.inConditionalConsequent = false;
+		const result = super.parseParenAndDistinguishExpression(canStartArrow);
+		this.state.inConditionalConsequent = oldInConditionalConsequent;
+		return result;
 	}
 	canHaveLeadingDecorator() {
 		return super.canHaveLeadingDecorator() || this.isAbstractClass();
@@ -26814,7 +26930,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
 		let rightOfAs;
 		let hasTypeSpecifier = false;
 		let canParseAsKeyword = true;
-		const loc = leftOfAs.loc.start;
+		const loc = leftOfAs.start;
 		if (this.isContextual(89)) {
 			const firstAs = this.parseIdentifier();
 			if (this.isContextual(89)) {
@@ -26839,7 +26955,7 @@ var typescript = (superClass) => class TypeScriptParserMixin extends superClass
 			hasTypeSpecifier = true;
 			if (isImport) {
 				leftOfAs = this.parseIdentifier(true);
-				if (!this.isContextual(89)) this.checkReservedWord(leftOfAs.name, leftOfAs.loc.start, true, true);
+				if (!this.isContextual(89)) this.checkReservedWord(leftOfAs.name, leftOfAs.start, true, true);
 			} else leftOfAs = this.parseModuleExportName();
 		}
 		if (hasTypeSpecifier && isInTypeOnlyImportExport) this.raise(isImport ? TSErrors.TypeModifierIsUsedInTypeImports : TSErrors.TypeModifierIsUsedInTypeExports, loc);
@@ -27253,14 +27369,14 @@ var ExpressionParser = class extends LValParser {
 		const key = prop.key;
 		if ((key.type === "Identifier" ? key.name : key.value) === "__proto__") {
 			if (sawProto) if (refExpressionErrors) {
-				if (refExpressionErrors.doubleProtoLoc === null) refExpressionErrors.doubleProtoLoc = key.loc.start;
+				if (refExpressionErrors.doubleProtoLoc === null) refExpressionErrors.doubleProtoLoc = this.getLoc(key.start);
 			} else this.raise(Errors.DuplicateProto, key);
 			return true;
 		}
 		return sawProto;
 	}
-	shouldExitDescending(expr, potentialArrowAt) {
-		return expr.type === "ArrowFunctionExpression" && this.offsetToSourcePos(expr.start) === potentialArrowAt;
+	shouldExitDescending(expr) {
+		return expr.type === "ArrowFunctionExpression" && !expr.extra?.parenthesized;
 	}
 	getExpression() {
 		this.enterInitialScopes();
@@ -27271,7 +27387,8 @@ var ExpressionParser = class extends LValParser {
 		this.finalizeRemainingComments();
 		expr.comments = this.comments;
 		expr.errors = this.state.errors;
-		if (this.optionFlags & 256) expr.tokens = createExportedTokens(this.tokens);
+		if (this.optionFlags & 512) expr.tokens = createExportedTokens(this.tokens);
+		if (this.options.locations === "packed") expr.locData = resetLocData();
 		return expr;
 	}
 	parseExpression(disallowIn, refExpressionErrors) {
@@ -27316,8 +27433,7 @@ var ExpressionParser = class extends LValParser {
 			refExpressionErrors = new ExpressionErrors();
 			ownExpressionErrors = true;
 		}
-		const { type } = this.state;
-		if (type === 6 || tokenIsIdentifier(type)) this.state.potentialArrowAt = this.state.start;
+		this.state.canStartArrow = true;
 		let left = this.parseMaybeConditional(refExpressionErrors);
 		if (afterLeftParse) left = afterLeftParse.call(this, left, startLoc);
 		if (tokenIsAssignment(this.state.type)) {
@@ -27352,9 +27468,8 @@ var ExpressionParser = class extends LValParser {
 	}
 	parseMaybeConditional(refExpressionErrors) {
 		const startLoc = this.state.startLoc;
-		const potentialArrowAt = this.state.potentialArrowAt;
 		const expr = this.parseExprOps(refExpressionErrors);
-		if (this.shouldExitDescending(expr, potentialArrowAt)) return expr;
+		if (this.shouldExitDescending(expr)) return expr;
 		return this.parseConditional(expr, startLoc, refExpressionErrors);
 	}
 	parseConditional(expr, startLoc, refExpressionErrors) {
@@ -27373,16 +27488,16 @@ var ExpressionParser = class extends LValParser {
 	}
 	parseExprOps(refExpressionErrors) {
 		const startLoc = this.state.startLoc;
-		const potentialArrowAt = this.state.potentialArrowAt;
 		const expr = this.parseMaybeUnaryOrPrivate(refExpressionErrors);
-		if (this.shouldExitDescending(expr, potentialArrowAt)) return expr;
+		if (this.shouldExitDescending(expr)) return expr;
+		this.state.canStartArrow = false;
 		return this.parseExprOp(expr, startLoc, -1);
 	}
 	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.PrivateInExpectedIn, left, { identifierName: value });
-			this.classScope.usePrivateName(value, left.loc.start);
+			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;
 		if (tokenIsOperator(op) && (this.prodParam.hasIn || !this.match(54))) {
@@ -27390,7 +27505,7 @@ var ExpressionParser = class extends LValParser {
 			if (prec > minPrec) {
 				if (op === 35) {
 					this.expectPlugin("pipelineOperator");
-					if (this.state.inFSharpPipelineDirectBody) return left;
+					if (this.prodParam.inFSharpPipelineDirectBody) return left;
 				}
 				const node = this.startNodeAt(leftStartLoc);
 				node.left = left;
@@ -27414,9 +27529,7 @@ var ExpressionParser = class extends LValParser {
 				case "hack": return this.withTopicBindingContext(() => {
 					return this.parseHackPipeBody();
 				});
-				case "fsharp": return this.withSoloAwaitPermittingContext(() => {
-					return this.parseFSharpPipelineBody(prec);
-				});
+				case "fsharp": return this.parseFSharpPipelineBody(prec);
 			}
 			default: return this.parseExprOpBaseRightExpr(op, prec);
 		}
@@ -27449,6 +27562,7 @@ var ExpressionParser = class extends LValParser {
 		if (tokenIsPrefix(this.state.type)) {
 			node.operator = this.state.value;
 			node.prefix = true;
+			this.state.canStartArrow = false;
 			if (this.match(68)) this.expectPlugin("throwExpressions");
 			const isDelete = this.match(85);
 			this.next();
@@ -27476,9 +27590,9 @@ var ExpressionParser = class extends LValParser {
 	}
 	parseUpdate(node, update, refExpressionErrors) {
 		if (update) {
-			const updateExpressionNode = node;
-			this.checkLVal(updateExpressionNode.argument, this.finishNode(updateExpressionNode, "UpdateExpression"));
-			return node;
+			const result = this.finishNode(node, "UpdateExpression");
+			this.checkLVal(result.argument, result);
+			return result;
 		}
 		const startLoc = this.state.startLoc;
 		let expr = this.parseExprSubscripts(refExpressionErrors);
@@ -27495,9 +27609,9 @@ var ExpressionParser = class extends LValParser {
 	}
 	parseExprSubscripts(refExpressionErrors) {
 		const startLoc = this.state.startLoc;
-		const potentialArrowAt = this.state.potentialArrowAt;
+		this.setLoc(startLoc);
 		const expr = this.parseExprAtom(refExpressionErrors);
-		if (this.shouldExitDescending(expr, potentialArrowAt)) return expr;
+		if (this.shouldExitDescending(expr)) return expr;
 		return this.parseSubscripts(expr, startLoc);
 	}
 	parseSubscripts(base, startLoc, noCalls) {
@@ -27598,7 +27712,7 @@ var ExpressionParser = class extends LValParser {
 		return this.finishNode(node, "TaggedTemplateExpression");
 	}
 	atPossibleAsyncArrow(base) {
-		return base.type === "Identifier" && base.name === "async" && this.state.lastTokEndLoc.index === base.end && !this.canInsertSemicolon() && base.end - base.start === 5 && this.offsetToSourcePos(base.start) === this.state.potentialArrowAt;
+		return base.type === "Identifier" && base.name === "async" && this.state.lastTokEndLoc.index === base.end && !this.canInsertSemicolon() && base.end - base.start === 5 && this.state.canStartArrow;
 	}
 	finishCallExpression(node, optional) {
 		if (node.callee.type === "Import") {
@@ -27610,8 +27724,6 @@ var ExpressionParser = class extends LValParser {
 	parseCallExpressionArguments(allowPlaceholder, nodeForExtra, refExpressionErrors) {
 		const elts = [];
 		let first = true;
-		const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
-		this.state.inFSharpPipelineDirectBody = false;
 		while (!this.eat(7)) {
 			if (first) first = false;
 			else {
@@ -27624,7 +27736,6 @@ var ExpressionParser = class extends LValParser {
 			}
 			elts.push(this.parseExprListItem(7, false, refExpressionErrors, allowPlaceholder));
 		}
-		this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
 		return elts;
 	}
 	shouldParseAsyncArrow() {
@@ -27652,7 +27763,7 @@ var ExpressionParser = class extends LValParser {
 				node = this.startNode();
 				this.next();
 				if (this.match(12)) return this.parseImportMetaPropertyOrPhaseCall(node);
-				if (this.match(6)) if (this.optionFlags & 512) return this.parseImportCall(node);
+				if (this.match(6)) if (this.optionFlags & 1024) return this.parseImportCall(node);
 				else return this.finishNode(node, "Import");
 				else {
 					this.raise(Errors.UnsupportedImport, this.state.lastTokStartLoc);
@@ -27673,10 +27784,7 @@ var ExpressionParser = class extends LValParser {
 			case 80: return this.parseNullLiteral();
 			case 81: return this.parseBooleanLiteral(true);
 			case 82: return this.parseBooleanLiteral(false);
-			case 6: {
-				const canBeArrow = this.state.potentialArrowAt === this.state.start;
-				return this.parseParenAndDistinguishExpression(canBeArrow);
-			}
+			case 6: return this.parseParenAndDistinguishExpression(this.state.canStartArrow);
 			case 0: return this.parseArrayLike(1, refExpressionErrors);
 			case 2: return this.parseObjectLike(4, false, refExpressionErrors);
 			case 64: return this.parseFunctionOrFunctionSent();
@@ -27718,8 +27826,7 @@ var ExpressionParser = class extends LValParser {
 			}
 			default: if (tokenIsIdentifier(type)) {
 				if (this.isContextual(123) && this.lookaheadInLineCharCode() === 123) return this.parseModuleExpression();
-				const canBeArrow = this.state.potentialArrowAt === this.state.start;
-				const containsEsc = this.state.containsEsc;
+				const { canStartArrow, containsEsc } = this.state;
 				const id = this.parseIdentifier();
 				if (!containsEsc && id.name === "async" && !this.canInsertSemicolon()) {
 					const { type } = this.state;
@@ -27727,14 +27834,14 @@ var ExpressionParser = class extends LValParser {
 						this.resetPreviousNodeTrailingComments(id);
 						this.next();
 						return this.parseAsyncFunctionExpression(this.startNodeAtNode(id));
-					} else if (tokenIsIdentifier(type)) if (this.lookaheadCharCode() === 61) return this.parseAsyncArrowUnaryFunction(this.startNodeAtNode(id));
+					} else if (tokenIsIdentifier(type)) if (canStartArrow && this.lookaheadCharCode() === 61) return this.parseAsyncArrowUnaryFunction(this.startNodeAtNode(id));
 					else return id;
 					else if (type === 86) {
 						this.resetPreviousNodeTrailingComments(id);
 						return this.parseDo(this.startNodeAtNode(id), true);
 					}
 				}
-				if (canBeArrow && this.match(15) && !this.canInsertSemicolon()) {
+				if (canStartArrow && this.match(15) && !this.canInsertSemicolon()) {
 					this.next();
 					return this.parseArrowExpression(this.startNodeAtNode(id), [id], false);
 				}
@@ -27897,13 +28004,11 @@ var ExpressionParser = class extends LValParser {
 		this.next();
 		return this.finishNode(node, "NullLiteral");
 	}
-	parseParenAndDistinguishExpression(canBeArrow) {
+	parseParenAndDistinguishExpression(canStartArrow) {
 		const startLoc = this.state.startLoc;
 		let val;
 		this.next();
 		this.expressionScope.enter(newArrowHeadScope());
-		const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
-		this.state.inFSharpPipelineDirectBody = false;
 		const innerStartLoc = this.state.startLoc;
 		const exprList = [];
 		const refExpressionErrors = new ExpressionErrors();
@@ -27928,9 +28033,8 @@ var ExpressionParser = class extends LValParser {
 		}
 		const innerEndLoc = this.state.lastTokEndLoc;
 		this.expect(7);
-		this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
 		let arrowNode = this.startNodeAt(startLoc);
-		if (canBeArrow && this.shouldParseArrow(exprList) && (arrowNode = this.parseArrow(arrowNode))) {
+		if (canStartArrow && this.shouldParseArrow(exprList) && (arrowNode = this.parseArrow(arrowNode))) {
 			this.checkDestructuringPrivate(refExpressionErrors);
 			this.expressionScope.validateAsPattern();
 			this.expressionScope.exit();
@@ -27952,7 +28056,7 @@ var ExpressionParser = class extends LValParser {
 		return this.wrapParenthesis(startLoc, val);
 	}
 	wrapParenthesis(startLoc, expression) {
-		if (!(this.optionFlags & 1024)) {
+		if (!(this.optionFlags & 2048)) {
 			this.addExtra(expression, "parenthesized", true);
 			this.addExtra(expression, "parenStart", startLoc.index);
 			this.takeSurroundingComments(expression, startLoc.index, this.state.lastTokEndLoc.index);
@@ -28036,8 +28140,6 @@ var ExpressionParser = class extends LValParser {
 		return this.parseExpression();
 	}
 	parseObjectLike(close, isPattern, refExpressionErrors) {
-		const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
-		this.state.inFSharpPipelineDirectBody = false;
 		let sawProto = false;
 		let first = true;
 		const node = this.startNode();
@@ -28061,7 +28163,6 @@ var ExpressionParser = class extends LValParser {
 			node.properties.push(prop);
 		}
 		this.next();
-		this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
 		const type = isPattern ? "ObjectPattern" : "ObjectExpression";
 		return this.finishNode(node, type);
 	}
@@ -28073,7 +28174,7 @@ var ExpressionParser = class extends LValParser {
 		return !prop.computed && prop.key.type === "Identifier" && (this.isLiteralPropertyName() || this.match(0) || this.match(51));
 	}
 	parsePropertyDefinition(refExpressionErrors) {
-		let decorators = [];
+		const decorators = [];
 		if (this.match(22)) {
 			if (this.hasPlugin("decorators")) this.raise(Errors.UnsupportedPropertyDecorator, this.state.startLoc);
 			while (this.match(22)) decorators.push(this.parseDecorator());
@@ -28086,10 +28187,7 @@ var ExpressionParser = class extends LValParser {
 			if (decorators.length) this.unexpected();
 			return this.parseSpread();
 		}
-		if (decorators.length) {
-			prop.decorators = decorators;
-			decorators = [];
-		}
+		if (decorators.length) prop.decorators = decorators;
 		prop.method = false;
 		if (refExpressionErrors) startLoc = this.state.startLoc;
 		let isGenerator = this.eat(51);
@@ -28151,7 +28249,7 @@ var ExpressionParser = class extends LValParser {
 			return this.finishObjectProperty(prop);
 		}
 		if (!prop.computed && prop.key.type === "Identifier") {
-			this.checkReservedWord(prop.key.name, prop.key.loc.start, true, false);
+			this.checkReservedWord(prop.key.name, prop.key.start, true, false);
 			if (isPattern) prop.value = this.parseMaybeDefault(startLoc, this.cloneIdentifier(prop.key));
 			else if (this.match(25)) {
 				const shorthandAssignLoc = this.state.startLoc;
@@ -28222,18 +28320,15 @@ var ExpressionParser = class extends LValParser {
 		return finishedNode;
 	}
 	parseArrayLike(close, refExpressionErrors) {
-		const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
-		this.state.inFSharpPipelineDirectBody = false;
 		const node = this.startNode();
 		this.next();
 		node.elements = this.parseExprList(close, true, refExpressionErrors, node);
-		this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
 		return this.finishNode(node, "ArrayExpression");
 	}
 	parseArrowExpression(node, params, isAsync, trailingCommaLoc) {
 		this.scope.enter(518);
 		let flags = functionFlags(isAsync, false);
-		if (!this.match(2) && this.prodParam.hasIn) flags |= 8;
+		if (!this.match(2)) flags |= this.prodParam.currentFlags() & 24;
 		this.prodParam.enter(flags);
 		this.initFunction(node, isAsync);
 		if (params) this.setArrowFunctionParameters(node, params, trailingCommaLoc);
@@ -28263,7 +28358,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.IllegalLanguageModeDirective, (node.kind === "method" || node.kind === "constructor") && !!node.key ? node.key.loc.end : 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);
@@ -28326,23 +28421,23 @@ var ExpressionParser = class extends LValParser {
 	}
 	createIdentifier(node, name) {
 		node.name = name;
-		node.loc.identifierName = name;
+		if (this.optionFlags & 256) node.loc.identifierName = name;
 		return this.finishNode(node, "Identifier");
 	}
 	createIdentifierAt(node, name, endLoc) {
 		node.name = name;
-		node.loc.identifierName = name;
+		if (this.optionFlags & 256) node.loc.identifierName = name;
 		return this.finishNodeAt(node, "Identifier", endLoc);
 	}
 	parseIdentifierName(liberal) {
 		let name;
-		const { startLoc, type } = this.state;
+		const { start, type } = this.state;
 		if (tokenIsKeywordOrIdentifier(type)) name = this.state.value;
 		else this.unexpected();
 		const tokenIsKeyword = tokenKeywordOrIdentifierIsKeyword(type);
 		if (liberal) {
 			if (tokenIsKeyword) this.replaceToken(128);
-		} else this.checkReservedWord(name, startLoc, tokenIsKeyword, false);
+		} else this.checkReservedWord(name, this.sourceToOffsetPos(start), tokenIsKeyword, false);
 		this.next();
 		return name;
 	}
@@ -28383,13 +28478,15 @@ var ExpressionParser = class extends LValParser {
 		if (isAwaitAllowed && !this.scope.inFunction) this.state.hasTopLevelAwait = true;
 		return isAwaitAllowed;
 	}
-	parseAwait(startLoc) {
+	parseAwait(startLoc, soloAwait) {
+		const startIndex = startLoc.index;
+		this.setLoc(startLoc);
 		const node = this.startNodeAt(startLoc);
-		this.expressionScope.recordParameterInitializerError(Errors.AwaitExpressionFormalParameter, node);
-		if (this.eat(51)) this.raise(Errors.ObsoleteAwaitStar, node);
+		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 (!this.state.soloAwait) node.argument = this.parseMaybeUnary(null, true);
+		if (!soloAwait) node.argument = this.parseMaybeUnary(null, true);
 		return this.finishNode(node, "AwaitExpression");
 	}
 	isAmbiguousPrefixOrIdentifier() {
@@ -28398,8 +28495,9 @@ var ExpressionParser = class extends LValParser {
 		return type === 49 || type === 6 || type === 0 || tokenIsTemplate(type) || type === 98 && !this.state.containsEsc || type === 133 || type === 52 || this.hasPlugin("v8intrinsic") && type === 50;
 	}
 	parseYield(startLoc) {
+		this.setLoc(startLoc);
 		const node = this.startNodeAt(startLoc);
-		this.expressionScope.recordParameterInitializerError(Errors.YieldInParameter, node);
+		this.expressionScope.recordParameterInitializerError(Errors.YieldInParameter, startLoc.index);
 		let delegating = false;
 		let argument = null;
 		if (!this.hasPrecedingLineBreak()) {
@@ -28440,30 +28538,21 @@ var ExpressionParser = class extends LValParser {
 		return this.finishNode(node, "ImportExpression");
 	}
 	withTopicBindingContext(callback) {
-		const outerContextTopicState = this.state.topicContext;
-		this.state.topicContext = {
-			maxNumOfResolvableTopics: 1,
-			maxTopicIndex: null
-		};
-		try {
-			return callback();
-		} finally {
-			this.state.topicContext = outerContextTopicState;
-		}
-	}
-	withSoloAwaitPermittingContext(callback) {
-		const outerContextSoloAwaitState = this.state.soloAwait;
-		this.state.soloAwait = true;
+		const oldInHackPipelineBody = this.state.inHackPipelineBody;
+		this.state.inHackPipelineBody = true;
+		const oldSeenTopicReference = this.state.seenTopicReference;
+		this.state.seenTopicReference = false;
 		try {
 			return callback();
 		} finally {
-			this.state.soloAwait = outerContextSoloAwaitState;
+			this.state.inHackPipelineBody = oldInHackPipelineBody;
+			this.state.seenTopicReference = oldSeenTopicReference;
 		}
 	}
 	allowInAnd(callback) {
 		const flags = this.prodParam.currentFlags();
-		if (8 & ~flags) {
-			this.prodParam.enter(flags | 8);
+		if (24 & ~flags) {
+			this.prodParam.enter(flags | 24);
 			try {
 				return callback();
 			} finally {
@@ -28474,8 +28563,10 @@ var ExpressionParser = class extends LValParser {
 	}
 	disallowInAnd(callback) {
 		const flags = this.prodParam.currentFlags();
-		if (8 & flags) {
-			this.prodParam.enter(flags & -9);
+		const prodParamToClear = 8 & flags;
+		const prodParamToSet = 16 & ~flags;
+		if (prodParamToClear || prodParamToSet) {
+			this.prodParam.enter(flags & -9 | 16);
 			try {
 				return callback();
 			} finally {
@@ -28485,21 +28576,28 @@ var ExpressionParser = class extends LValParser {
 		return callback();
 	}
 	registerTopicReference() {
-		this.state.topicContext.maxTopicIndex = 0;
+		this.state.seenTopicReference = true;
 	}
 	topicReferenceIsAllowedInCurrentContext() {
-		return this.state.topicContext.maxNumOfResolvableTopics >= 1;
+		return this.state.inHackPipelineBody;
 	}
 	topicReferenceWasUsedInCurrentContext() {
-		return this.state.topicContext.maxTopicIndex != null && this.state.topicContext.maxTopicIndex >= 0;
+		return this.state.seenTopicReference;
 	}
 	parseFSharpPipelineBody(prec) {
 		const startLoc = this.state.startLoc;
-		this.state.potentialArrowAt = this.state.start;
-		const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
-		this.state.inFSharpPipelineDirectBody = true;
-		const ret = this.parseExprOp(this.parseMaybeUnaryOrPrivate(), startLoc, prec);
-		this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
+		this.prodParam.enter(this.prodParam.currentFlags() & -17);
+		let ret;
+		if (this.isContextual(92) && this.recordAwaitIfAllowed()) {
+			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.PipelineUnparenthesized, startLoc);
+		} else {
+			this.state.canStartArrow = true;
+			ret = this.parseExprOp(this.parseMaybeUnaryOrPrivate(), startLoc, prec);
+		}
+		this.prodParam.exit();
 		return ret;
 	}
 	parseModuleExpression() {
@@ -28549,7 +28647,7 @@ var StatementParser = class extends ExpressionParser {
 	parseTopLevel(file, program) {
 		file.program = this.parseProgram(program, 135, this.options.sourceType === "module" ? "module" : "script");
 		file.comments = this.comments;
-		if (this.optionFlags & 256) file.tokens = createExportedTokens(this.tokens);
+		if (this.optionFlags & 512) file.tokens = createExportedTokens(this.tokens);
 		return this.finishNode(file, "File");
 	}
 	parseProgram(program, end, sourceType) {
@@ -28805,7 +28903,10 @@ var StatementParser = class extends ExpressionParser {
 				}
 				node.expression = this.parseMaybeDecoratorArguments(expr, startLoc);
 			}
-		} else node.expression = this.parseExprSubscripts();
+		} else {
+			this.state.canStartArrow = false;
+			node.expression = this.parseExprSubscripts();
+		}
 		return this.finishNode(node, "Decorator");
 	}
 	parseMaybeDecoratorArguments(expr, startLoc) {
@@ -29143,8 +29244,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.UsingDeclarationHasBindingPattern, id.loc.start);
-		} else if (id.type === "VoidPattern") this.raise(Errors.UnexpectedVoidPattern, id.loc.start);
+			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;
 	}
@@ -29184,7 +29285,7 @@ var StatementParser = class extends ExpressionParser {
 	}
 	registerFunctionStatementId(node) {
 		if (!node.id) return;
-		this.scope.declareName(node.id.name, !this.options.annexB || this.state.strict || node.generator || node.async ? this.scope.treatFunctionsAsVar ? 5 : 8201 : 17, node.id.loc.start);
+		this.scope.declareName(node.id.name, !this.options.annexB || this.state.strict || node.generator || node.async ? this.scope.treatFunctionsAsVar ? 5 : 8201 : 17, node.id.start);
 	}
 	parseClass(node, isStatement, optionalId) {
 		this.next();
@@ -29233,7 +29334,10 @@ var StatementParser = class extends ExpressionParser {
 				decorators = [];
 			}
 			this.parseClassMember(classBody, member, state);
-			if (member.kind === "constructor" && member.decorators && member.decorators.length > 0) this.raise(Errors.DecoratorConstructor, member);
+			if (member.decorators && member.decorators.length > 0) {
+				if (this.hasPlugin("typescript") && (this.hasPlugin("estree") ? member.type === "TSAbstractMethodDefinition" : member.type === "TSDeclareMethod")) this.raise(Errors.DecoratorAbstractMethod, member);
+				if (member.kind === "constructor") this.raise(Errors.DecoratorConstructor, member);
+			}
 		}
 		this.state.strict = oldStrict;
 		this.next();
@@ -29386,13 +29490,13 @@ var StatementParser = class extends ExpressionParser {
 	pushClassPrivateProperty(classBody, prop) {
 		const node = this.parseClassPrivateProperty(prop);
 		classBody.body.push(node);
-		this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), 0, node.key.loc.start);
+		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.ConstructorClassField, prop.key);
 		const node = this.parseClassAccessorProperty(prop);
 		classBody.body.push(node);
-		if (isPrivate) this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), 0, node.key.loc.start);
+		if (isPrivate) this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), 0, node.key.start);
 	}
 	pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
 		classBody.body.push(this.parseMethod(method, isGenerator, isAsync, isConstructor, allowsDirectSuper, "ClassMethod", true));
@@ -29404,7 +29508,7 @@ var StatementParser = class extends ExpressionParser {
 		this.declareClassPrivateMethodInScope(node, kind);
 	}
 	declareClassPrivateMethodInScope(node, kind) {
-		this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), kind, node.key.loc.start);
+		this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), kind, node.key.start);
 	}
 	parsePostMemberNameModifiers(methodOrProp) {}
 	parseClassPrivateProperty(node) {
@@ -29439,7 +29543,10 @@ var StatementParser = class extends ExpressionParser {
 		else throw this.raise(Errors.MissingClassName, this.state.startLoc);
 	}
 	parseClassSuper(node) {
-		node.superClass = this.eat(77) ? this.parseExprSubscripts() : null;
+		if (this.eat(77)) {
+			this.state.canStartArrow = false;
+			node.superClass = this.parseExprSubscripts();
+		} else node.superClass = null;
 	}
 	parseExport(node, decorators) {
 		const maybeDefaultIdentifier = this.parseMaybeImportPhase(node, true);
@@ -29490,7 +29597,7 @@ var StatementParser = class extends ExpressionParser {
 	}
 	maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier) {
 		if (maybeDefaultIdentifier || this.isExportDefaultSpecifier()) {
-			this.expectPlugin("exportDefaultFrom", maybeDefaultIdentifier?.loc.start);
+			this.expectPlugin("exportDefaultFrom", maybeDefaultIdentifier?.start);
 			const id = maybeDefaultIdentifier || this.parseIdentifier(true);
 			const specifier = this.startNodeAtNode(id);
 			specifier.exported = id;
@@ -29624,7 +29731,7 @@ var StatementParser = class extends ExpressionParser {
 						exportName
 					});
 					else {
-						this.checkReservedWord(local.name, local.loc.start, true, false);
+						this.checkReservedWord(local.name, local.start, true, false);
 						this.scope.checkLocalExport(local);
 					}
 				}
@@ -29690,9 +29797,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.SourcePhaseImportRequiresDefault, specifiers[0].loc.start);
+			if (singleBindingType !== "ImportDefaultSpecifier") this.raise(Errors.SourcePhaseImportRequiresDefault, specifiers[0]);
 		} else if (node.phase === "defer") {
-			if (singleBindingType !== "ImportNamespaceSpecifier") this.raise(Errors.DeferImportRequiresNamespace, specifiers[0].loc.start);
+			if (singleBindingType !== "ImportNamespaceSpecifier") this.raise(Errors.DeferImportRequiresNamespace, specifiers[0]);
 		}
 	}
 	isPotentialImportPhase(isExport) {
@@ -29718,7 +29825,7 @@ var StatementParser = class extends ExpressionParser {
 		const phaseIdentifierName = this.parseIdentifierName(true);
 		const { type } = this.state;
 		if (tokenIsKeywordOrIdentifier(type) ? type !== 94 || this.lookaheadCharCode() === 102 : type !== 8) {
-			this.applyImportPhase(node, isExport, phaseIdentifierName, phaseIdentifier.loc.start);
+			this.applyImportPhase(node, isExport, phaseIdentifierName, phaseIdentifier.start);
 			return null;
 		} else {
 			this.applyImportPhase(node, isExport, null);
@@ -29836,7 +29943,7 @@ var StatementParser = class extends ExpressionParser {
 		else {
 			const { imported } = specifier;
 			if (importedIsString) throw this.raise(Errors.ImportBindingIsString, specifier, { importName: imported.value });
-			this.checkReservedWord(imported.name, specifier.loc.start, true, true);
+			this.checkReservedWord(imported.name, specifier.start, true, true);
 			if (!specifier.local) specifier.local = this.cloneIdentifier(imported);
 		}
 		return this.finishImportSpecifier(specifier, "ImportSpecifier", bindingType);
@@ -29863,12 +29970,13 @@ var Parser = class extends StatementParser {
 		if (normalizedOptions.allowNewTargetOutsideFunction) optionFlags |= 4;
 		if (normalizedOptions.allowYieldOutsideFunction) optionFlags |= 32;
 		if (normalizedOptions.ranges) optionFlags |= 128;
-		if (normalizedOptions.tokens) optionFlags |= 256;
-		if (normalizedOptions.createImportExpressions) optionFlags |= 512;
-		if (normalizedOptions.createParenthesizedExpressions) optionFlags |= 1024;
-		if (normalizedOptions.errorRecovery) optionFlags |= 2048;
-		if (normalizedOptions.attachComment) optionFlags |= 4096;
-		if (normalizedOptions.annexB) optionFlags |= 8192;
+		if (normalizedOptions.locations === true) optionFlags |= 256;
+		if (normalizedOptions.tokens) optionFlags |= 512;
+		if (normalizedOptions.createImportExpressions) optionFlags |= 1024;
+		if (normalizedOptions.createParenthesizedExpressions) optionFlags |= 2048;
+		if (normalizedOptions.errorRecovery) optionFlags |= 4096;
+		if (normalizedOptions.attachComment) optionFlags |= 8192;
+		if (normalizedOptions.annexB) optionFlags |= 16384;
 		this.optionFlags = optionFlags;
 	}
 	getScopeHandler() {
@@ -29883,6 +29991,7 @@ var Parser = class extends StatementParser {
 		const result = this.parseTopLevel(file, program);
 		result.errors = this.state.errors;
 		result.comments.length = this.state.commentsLen;
+		if (this.options.locations === "packed") result.locData = resetLocData();
 		return result;
 	}
 };
@@ -30298,849 +30407,11 @@ function resolveTemplateLiteral(node) {
 * @param {WalkHandlers<T, void>} hooks - The handlers to be applied during the walk.
 * @returns {T | null} - The modified AST node or null if the node is removed.
 */
-const walkAST = walk, A = (r) => r !== null && typeof r == "object", a = (r, t) => Object.assign(/* @__PURE__ */ new Error(`[${r}]: ${t}`), { code: r }), _ = "ERR_INVALID_PACKAGE_CONFIG", E$1 = "ERR_INVALID_PACKAGE_TARGET", I$1 = "ERR_PACKAGE_PATH_NOT_EXPORTED", R = /^\d+$/, O$1 = /^(\.{1,2}|node_modules)$/i, w = /\/|\\/;
-var h$1 = ((r) => (r.Export = "exports", r.Import = "imports", r))(h$1 || {});
-const f = (r, t, e, o, c) => {
-	if (t == null) return [];
-	if (typeof t == "string") {
-		const [n, ...i] = t.split(w);
-		if (n === ".." || i.some((l) => O$1.test(l))) throw a(E$1, `Invalid "${r}" target "${t}" defined in the package config`);
-		return [c ? t.replace(/\*/g, c) : t];
-	}
-	if (Array.isArray(t)) return t.flatMap((n) => f(r, n, e, o, c));
-	if (A(t)) {
-		for (const n of Object.keys(t)) {
-			if (R.test(n)) throw a(_, "Cannot contain numeric property keys");
-			if (n === "default" || o.includes(n)) return f(r, t[n], e, o, c);
-		}
-		return [];
-	}
-	throw a(E$1, `Invalid "${r}" target "${t}"`);
-}, s = "*", m = (r, t) => {
-	const e = r.indexOf(s), o = t.indexOf(s);
-	return e === o ? t.length > r.length : o > e;
-};
-function d(r, t) {
-	if (!t.includes(s) && r.hasOwnProperty(t)) return [t];
-	let e, o;
-	for (const c of Object.keys(r)) if (c.includes(s)) {
-		const [n, i, l] = c.split(s);
-		if (l === void 0 && t.startsWith(n) && t.endsWith(i)) {
-			const g = t.slice(n.length, -i.length || void 0);
-			g && (!e || m(e, c)) && (e = c, o = g);
-		}
-	}
-	return [e, o];
-}
-const p = (r) => Object.keys(r).reduce((t, e) => {
-	const o = e === "" || e[0] !== ".";
-	if (t === void 0 || t === o) return o;
-	throw a(_, "\"exports\" cannot contain some keys starting with \".\" and some not");
-}, void 0), u = /^\w+:/, v = (r, t, e) => {
-	if (!r) throw new Error("\"exports\" is required");
-	t = t === "" ? "." : `./${t}`, (typeof r == "string" || Array.isArray(r) || A(r) && p(r)) && (r = { ".": r });
-	const [o, c] = d(r, t), n = f(h$1.Export, r[o], t, e, c);
-	if (n.length === 0) throw a(I$1, t === "." ? "No \"exports\" main defined" : `Package subpath '${t}' is not defined by "exports"`);
-	for (const i of n) if (!i.startsWith("./") && !u.test(i)) throw a(E$1, `Invalid "exports" target "${i}" defined in the package config`);
-	return n;
-};
-//#endregion
-//#region ../../node_modules/.pnpm/get-tsconfig@4.13.6/node_modules/get-tsconfig/dist/index.mjs
-var Le = Object.defineProperty;
-var i = (e, t) => Le(e, "name", {
-	value: t,
-	configurable: !0
-});
-function h(e) {
-	return e.startsWith("\\\\?\\") ? e : e.replace(/\\/g, "/");
-}
-i(h, "slash");
-const Z = i((e) => {
-	const t = re[e];
-	return (s, ...n) => {
-		const o = `${e}:${n.join(":")}`;
-		let l = s == null ? void 0 : s.get(o);
-		return l === void 0 && (l = Reflect.apply(t, re, n), s?.set(o, l)), l;
-	};
-}, "cacheFs"), E = Z("existsSync"), $e = Z("readFileSync"), G = Z("statSync"), fe = i((e, t, s) => {
-	for (;;) {
-		const n = path.posix.join(e, t);
-		if (E(s, n)) return n;
-		const o = path.dirname(e);
-		if (o === e) return;
-		e = o;
-	}
-}, "findUp"), q = /^\.{1,2}(\/.*)?$/, K = i((e) => {
-	const t = h(e);
-	return q.test(t) ? t : `./${t}`;
-}, "normalizeRelativePath");
-function Ue(e, t = !1) {
-	const s = e.length;
-	let n = 0, o = "", l = 0, u = 16, a = 0, r = 0, g = 0, v = 0, d = 0;
-	function _(c, y) {
-		let A = 0, b = 0;
-		for (; A < c;) {
-			let k = e.charCodeAt(n);
-			if (k >= 48 && k <= 57) b = b * 16 + k - 48;
-			else if (k >= 65 && k <= 70) b = b * 16 + k - 65 + 10;
-			else if (k >= 97 && k <= 102) b = b * 16 + k - 97 + 10;
-			else break;
-			n++, A++;
-		}
-		return A < c && (b = -1), b;
-	}
-	i(_, "scanHexDigits");
-	function p(c) {
-		n = c, o = "", l = 0, u = 16, d = 0;
-	}
-	i(p, "setPosition");
-	function D() {
-		let c = n;
-		if (e.charCodeAt(n) === 48) n++;
-		else for (n++; n < e.length && N(e.charCodeAt(n));) n++;
-		if (n < e.length && e.charCodeAt(n) === 46) if (n++, n < e.length && N(e.charCodeAt(n))) for (n++; n < e.length && N(e.charCodeAt(n));) n++;
-		else return d = 3, e.substring(c, n);
-		let y = n;
-		if (n < e.length && (e.charCodeAt(n) === 69 || e.charCodeAt(n) === 101)) if (n++, (n < e.length && e.charCodeAt(n) === 43 || e.charCodeAt(n) === 45) && n++, n < e.length && N(e.charCodeAt(n))) {
-			for (n++; n < e.length && N(e.charCodeAt(n));) n++;
-			y = n;
-		} else d = 3;
-		return e.substring(c, y);
-	}
-	i(D, "scanNumber");
-	function L() {
-		let c = "", y = n;
-		for (;;) {
-			if (n >= s) {
-				c += e.substring(y, n), d = 2;
-				break;
-			}
-			const A = e.charCodeAt(n);
-			if (A === 34) {
-				c += e.substring(y, n), n++;
-				break;
-			}
-			if (A === 92) {
-				if (c += e.substring(y, n), n++, n >= s) {
-					d = 2;
-					break;
-				}
-				switch (e.charCodeAt(n++)) {
-					case 34:
-						c += "\"";
-						break;
-					case 92:
-						c += "\\";
-						break;
-					case 47:
-						c += "/";
-						break;
-					case 98:
-						c += "\b";
-						break;
-					case 102:
-						c += "\f";
-						break;
-					case 110:
-						c += `
-`;
-						break;
-					case 114:
-						c += "\r";
-						break;
-					case 116:
-						c += "	";
-						break;
-					case 117:
-						const k = _(4);
-						k >= 0 ? c += String.fromCharCode(k) : d = 4;
-						break;
-					default: d = 5;
-				}
-				y = n;
-				continue;
-			}
-			if (A >= 0 && A <= 31) if (J(A)) {
-				c += e.substring(y, n), d = 2;
-				break;
-			} else d = 6;
-			n++;
-		}
-		return c;
-	}
-	i(L, "scanString");
-	function T() {
-		if (o = "", d = 0, l = n, r = a, v = g, n >= s) return l = s, u = 17;
-		let c = e.charCodeAt(n);
-		if (O(c)) {
-			do
-				n++, o += String.fromCharCode(c), c = e.charCodeAt(n);
-			while (O(c));
-			return u = 15;
-		}
-		if (J(c)) return n++, o += String.fromCharCode(c), c === 13 && e.charCodeAt(n) === 10 && (n++, o += `
-`), a++, g = n, u = 14;
-		switch (c) {
-			case 123: return n++, u = 1;
-			case 125: return n++, u = 2;
-			case 91: return n++, u = 3;
-			case 93: return n++, u = 4;
-			case 58: return n++, u = 6;
-			case 44: return n++, u = 5;
-			case 34: return n++, o = L(), u = 10;
-			case 47:
-				const y = n - 1;
-				if (e.charCodeAt(n + 1) === 47) {
-					for (n += 2; n < s && !J(e.charCodeAt(n));) n++;
-					return o = e.substring(y, n), u = 12;
-				}
-				if (e.charCodeAt(n + 1) === 42) {
-					n += 2;
-					const A = s - 1;
-					let b = !1;
-					for (; n < A;) {
-						const k = e.charCodeAt(n);
-						if (k === 42 && e.charCodeAt(n + 1) === 47) {
-							n += 2, b = !0;
-							break;
-						}
-						n++, J(k) && (k === 13 && e.charCodeAt(n) === 10 && n++, a++, g = n);
-					}
-					return b || (n++, d = 1), o = e.substring(y, n), u = 13;
-				}
-				return o += String.fromCharCode(c), n++, u = 16;
-			case 45: if (o += String.fromCharCode(c), n++, n === s || !N(e.charCodeAt(n))) return u = 16;
-			case 48:
-			case 49:
-			case 50:
-			case 51:
-			case 52:
-			case 53:
-			case 54:
-			case 55:
-			case 56:
-			case 57: return o += D(), u = 11;
-			default:
-				for (; n < s && F(c);) n++, c = e.charCodeAt(n);
-				if (l !== n) {
-					switch (o = e.substring(l, n), o) {
-						case "true": return u = 8;
-						case "false": return u = 9;
-						case "null": return u = 7;
-					}
-					return u = 16;
-				}
-				return o += String.fromCharCode(c), n++, u = 16;
-		}
-	}
-	i(T, "scanNext");
-	function F(c) {
-		if (O(c) || J(c)) return !1;
-		switch (c) {
-			case 125:
-			case 93:
-			case 123:
-			case 91:
-			case 34:
-			case 58:
-			case 44:
-			case 47: return !1;
-		}
-		return !0;
-	}
-	i(F, "isUnknownContentCharacter");
-	function x() {
-		let c;
-		do
-			c = T();
-		while (c >= 12 && c <= 15);
-		return c;
-	}
-	return i(x, "scanNextNonTrivia"), {
-		setPosition: p,
-		getPosition: i(() => n, "getPosition"),
-		scan: t ? x : T,
-		getToken: i(() => u, "getToken"),
-		getTokenValue: i(() => o, "getTokenValue"),
-		getTokenOffset: i(() => l, "getTokenOffset"),
-		getTokenLength: i(() => n - l, "getTokenLength"),
-		getTokenStartLine: i(() => r, "getTokenStartLine"),
-		getTokenStartCharacter: i(() => l - v, "getTokenStartCharacter"),
-		getTokenError: i(() => d, "getTokenError")
-	};
-}
-i(Ue, "createScanner");
-function O(e) {
-	return e === 32 || e === 9;
-}
-i(O, "isWhiteSpace");
-function J(e) {
-	return e === 10 || e === 13;
-}
-i(J, "isLineBreak");
-function N(e) {
-	return e >= 48 && e <= 57;
-}
-i(N, "isDigit");
-var ae;
-(function(e) {
-	e[e.lineFeed = 10] = "lineFeed", e[e.carriageReturn = 13] = "carriageReturn", e[e.space = 32] = "space", e[e._0 = 48] = "_0", e[e._1 = 49] = "_1", e[e._2 = 50] = "_2", e[e._3 = 51] = "_3", e[e._4 = 52] = "_4", e[e._5 = 53] = "_5", e[e._6 = 54] = "_6", e[e._7 = 55] = "_7", e[e._8 = 56] = "_8", e[e._9 = 57] = "_9", e[e.a = 97] = "a", e[e.b = 98] = "b", e[e.c = 99] = "c", e[e.d = 100] = "d", e[e.e = 101] = "e", e[e.f = 102] = "f", e[e.g = 103] = "g", e[e.h = 104] = "h", e[e.i = 105] = "i", e[e.j = 106] = "j", e[e.k = 107] = "k", e[e.l = 108] = "l", e[e.m = 109] = "m", e[e.n = 110] = "n", e[e.o = 111] = "o", e[e.p = 112] = "p", e[e.q = 113] = "q", e[e.r = 114] = "r", e[e.s = 115] = "s", e[e.t = 116] = "t", e[e.u = 117] = "u", e[e.v = 118] = "v", e[e.w = 119] = "w", e[e.x = 120] = "x", e[e.y = 121] = "y", e[e.z = 122] = "z", e[e.A = 65] = "A", e[e.B = 66] = "B", e[e.C = 67] = "C", e[e.D = 68] = "D", e[e.E = 69] = "E", e[e.F = 70] = "F", e[e.G = 71] = "G", e[e.H = 72] = "H", e[e.I = 73] = "I", e[e.J = 74] = "J", e[e.K = 75] = "K", e[e.L = 76] = "L", e[e.M = 77] = "M", e[e.N = 78] = "N", e[e.O = 79] = "O", e[e.P = 80] = "P", e[e.Q = 81] = "Q", e[e.R = 82] = "R", e[e.S = 83] = "S", e[e.T = 84] = "T", e[e.U = 85] = "U", e[e.V = 86] = "V", e[e.W = 87] = "W", e[e.X = 88] = "X", e[e.Y = 89] = "Y", e[e.Z = 90] = "Z", e[e.asterisk = 42] = "asterisk", e[e.backslash = 92] = "backslash", e[e.closeBrace = 125] = "closeBrace", e[e.closeBracket = 93] = "closeBracket", e[e.colon = 58] = "colon", e[e.comma = 44] = "comma", e[e.dot = 46] = "dot", e[e.doubleQuote = 34] = "doubleQuote", e[e.minus = 45] = "minus", e[e.openBrace = 123] = "openBrace", e[e.openBracket = 91] = "openBracket", e[e.plus = 43] = "plus", e[e.slash = 47] = "slash", e[e.formFeed = 12] = "formFeed", e[e.tab = 9] = "tab";
-})(ae || (ae = {})), new Array(20).fill(0).map((e, t) => " ".repeat(t));
-const P = 200;
-new Array(P).fill(0).map((e, t) => `
-` + " ".repeat(t)), new Array(P).fill(0).map((e, t) => "\r" + " ".repeat(t)), new Array(P).fill(0).map((e, t) => `\r
-` + " ".repeat(t)), new Array(P).fill(0).map((e, t) => `
-` + "	".repeat(t)), new Array(P).fill(0).map((e, t) => "\r" + "	".repeat(t)), new Array(P).fill(0).map((e, t) => `\r
-` + "	".repeat(t));
-var Q;
-(function(e) {
-	e.DEFAULT = { allowTrailingComma: !1 };
-})(Q || (Q = {}));
-function Ne(e, t = [], s = Q.DEFAULT) {
-	let n = null, o = [];
-	const l = [];
-	function u(r) {
-		Array.isArray(o) ? o.push(r) : n !== null && (o[n] = r);
-	}
-	return i(u, "onValue"), Pe(e, {
-		onObjectBegin: i(() => {
-			const r = {};
-			u(r), l.push(o), o = r, n = null;
-		}, "onObjectBegin"),
-		onObjectProperty: i((r) => {
-			n = r;
-		}, "onObjectProperty"),
-		onObjectEnd: i(() => {
-			o = l.pop();
-		}, "onObjectEnd"),
-		onArrayBegin: i(() => {
-			const r = [];
-			u(r), l.push(o), o = r, n = null;
-		}, "onArrayBegin"),
-		onArrayEnd: i(() => {
-			o = l.pop();
-		}, "onArrayEnd"),
-		onLiteralValue: u,
-		onError: i((r, g, v) => {
-			t.push({
-				error: r,
-				offset: g,
-				length: v
-			});
-		}, "onError")
-	}, s), o[0];
-}
-i(Ne, "parse$1");
-function Pe(e, t, s = Q.DEFAULT) {
-	const n = Ue(e, !1), o = [];
-	let l = 0;
-	function u(w) {
-		return w ? () => l === 0 && w(n.getTokenOffset(), n.getTokenLength(), n.getTokenStartLine(), n.getTokenStartCharacter()) : () => !0;
-	}
-	i(u, "toNoArgVisit");
-	function a(w) {
-		return w ? (j) => l === 0 && w(j, n.getTokenOffset(), n.getTokenLength(), n.getTokenStartLine(), n.getTokenStartCharacter()) : () => !0;
-	}
-	i(a, "toOneArgVisit");
-	function r(w) {
-		return w ? (j) => l === 0 && w(j, n.getTokenOffset(), n.getTokenLength(), n.getTokenStartLine(), n.getTokenStartCharacter(), () => o.slice()) : () => !0;
-	}
-	i(r, "toOneArgVisitWithPath");
-	function g(w) {
-		return w ? () => {
-			l > 0 ? l++ : w(n.getTokenOffset(), n.getTokenLength(), n.getTokenStartLine(), n.getTokenStartCharacter(), () => o.slice()) === !1 && (l = 1);
-		} : () => !0;
-	}
-	i(g, "toBeginVisit");
-	function v(w) {
-		return w ? () => {
-			l > 0 && l--, l === 0 && w(n.getTokenOffset(), n.getTokenLength(), n.getTokenStartLine(), n.getTokenStartCharacter());
-		} : () => !0;
-	}
-	i(v, "toEndVisit");
-	const d = g(t.onObjectBegin), _ = r(t.onObjectProperty), p = v(t.onObjectEnd), D = g(t.onArrayBegin), L = v(t.onArrayEnd), T = r(t.onLiteralValue), F = a(t.onSeparator), x = u(t.onComment), c = a(t.onError), y = s && s.disallowComments, A = s && s.allowTrailingComma;
-	function b() {
-		for (;;) {
-			const w = n.scan();
-			switch (n.getTokenError()) {
-				case 4:
-					k(14);
-					break;
-				case 5:
-					k(15);
-					break;
-				case 3:
-					k(13);
-					break;
-				case 1:
-					y || k(11);
-					break;
-				case 2:
-					k(12);
-					break;
-				case 6:
-					k(16);
-					break;
-			}
-			switch (w) {
-				case 12:
-				case 13:
-					y ? k(10) : x();
-					break;
-				case 16:
-					k(1);
-					break;
-				case 15:
-				case 14: break;
-				default: return w;
-			}
-		}
-	}
-	i(b, "scanNext");
-	function k(w, j = [], S = []) {
-		if (c(w), j.length + S.length > 0) {
-			let $ = n.getToken();
-			for (; $ !== 17;) {
-				if (j.indexOf($) !== -1) {
-					b();
-					break;
-				} else if (S.indexOf($) !== -1) break;
-				$ = b();
-			}
-		}
-	}
-	i(k, "handleError");
-	function R(w) {
-		const j = n.getTokenValue();
-		return w ? T(j) : (_(j), o.push(j)), b(), !0;
-	}
-	i(R, "parseString");
-	function W() {
-		switch (n.getToken()) {
-			case 11:
-				const w = n.getTokenValue();
-				let j = Number(w);
-				isNaN(j) && (k(2), j = 0), T(j);
-				break;
-			case 7:
-				T(null);
-				break;
-			case 8:
-				T(!0);
-				break;
-			case 9:
-				T(!1);
-				break;
-			default: return !1;
-		}
-		return b(), !0;
-	}
-	i(W, "parseLiteral");
-	function V() {
-		return n.getToken() !== 10 ? (k(3, [], [2, 5]), !1) : (R(!1), n.getToken() === 6 ? (F(":"), b(), U() || k(4, [], [2, 5])) : k(5, [], [2, 5]), o.pop(), !0);
-	}
-	i(V, "parseProperty");
-	function M() {
-		d(), b();
-		let w = !1;
-		for (; n.getToken() !== 2 && n.getToken() !== 17;) {
-			if (n.getToken() === 5) {
-				if (w || k(4, [], []), F(","), b(), n.getToken() === 2 && A) break;
-			} else w && k(6, [], []);
-			V() || k(4, [], [2, 5]), w = !0;
-		}
-		return p(), n.getToken() !== 2 ? k(7, [2], []) : b(), !0;
-	}
-	i(M, "parseObject");
-	function z() {
-		D(), b();
-		let w = !0, j = !1;
-		for (; n.getToken() !== 4 && n.getToken() !== 17;) {
-			if (n.getToken() === 5) {
-				if (j || k(4, [], []), F(","), b(), n.getToken() === 4 && A) break;
-			} else j && k(6, [], []);
-			w ? (o.push(0), w = !1) : o[o.length - 1]++, U() || k(4, [], [4, 5]), j = !0;
-		}
-		return L(), w || o.pop(), n.getToken() !== 4 ? k(8, [4], []) : b(), !0;
-	}
-	i(z, "parseArray");
-	function U() {
-		switch (n.getToken()) {
-			case 3: return z();
-			case 1: return M();
-			case 10: return R(!0);
-			default: return W();
-		}
-	}
-	return i(U, "parseValue"), b(), n.getToken() === 17 ? s.allowEmptyContent ? !0 : (k(4, [], []), !1) : U() ? (n.getToken() !== 17 && k(9, [], []), !0) : (k(4, [], []), !1);
-}
-i(Pe, "visit");
-var ce;
-(function(e) {
-	e[e.None = 0] = "None", e[e.UnexpectedEndOfComment = 1] = "UnexpectedEndOfComment", e[e.UnexpectedEndOfString = 2] = "UnexpectedEndOfString", e[e.UnexpectedEndOfNumber = 3] = "UnexpectedEndOfNumber", e[e.InvalidUnicode = 4] = "InvalidUnicode", e[e.InvalidEscapeCharacter = 5] = "InvalidEscapeCharacter", e[e.InvalidCharacter = 6] = "InvalidCharacter";
-})(ce || (ce = {}));
-var ge;
-(function(e) {
-	e[e.OpenBraceToken = 1] = "OpenBraceToken", e[e.CloseBraceToken = 2] = "CloseBraceToken", e[e.OpenBracketToken = 3] = "OpenBracketToken", e[e.CloseBracketToken = 4] = "CloseBracketToken", e[e.CommaToken = 5] = "CommaToken", e[e.ColonToken = 6] = "ColonToken", e[e.NullKeyword = 7] = "NullKeyword", e[e.TrueKeyword = 8] = "TrueKeyword", e[e.FalseKeyword = 9] = "FalseKeyword", e[e.StringLiteral = 10] = "StringLiteral", e[e.NumericLiteral = 11] = "NumericLiteral", e[e.LineCommentTrivia = 12] = "LineCommentTrivia", e[e.BlockCommentTrivia = 13] = "BlockCommentTrivia", e[e.LineBreakTrivia = 14] = "LineBreakTrivia", e[e.Trivia = 15] = "Trivia", e[e.Unknown = 16] = "Unknown", e[e.EOF = 17] = "EOF";
-})(ge || (ge = {}));
-const Re = Ne;
-var ke;
-(function(e) {
-	e[e.InvalidSymbol = 1] = "InvalidSymbol", e[e.InvalidNumberFormat = 2] = "InvalidNumberFormat", e[e.PropertyNameExpected = 3] = "PropertyNameExpected", e[e.ValueExpected = 4] = "ValueExpected", e[e.ColonExpected = 5] = "ColonExpected", e[e.CommaExpected = 6] = "CommaExpected", e[e.CloseBraceExpected = 7] = "CloseBraceExpected", e[e.CloseBracketExpected = 8] = "CloseBracketExpected", e[e.EndOfFileExpected = 9] = "EndOfFileExpected", e[e.InvalidCommentToken = 10] = "InvalidCommentToken", e[e.UnexpectedEndOfComment = 11] = "UnexpectedEndOfComment", e[e.UnexpectedEndOfString = 12] = "UnexpectedEndOfString", e[e.UnexpectedEndOfNumber = 13] = "UnexpectedEndOfNumber", e[e.InvalidUnicode = 14] = "InvalidUnicode", e[e.InvalidEscapeCharacter = 15] = "InvalidEscapeCharacter", e[e.InvalidCharacter = 16] = "InvalidCharacter";
-})(ke || (ke = {}));
-const me = i((e, t) => Re($e(t, e, "utf8")), "readJsonc"), C = Symbol("implicitBaseUrl"), I = "${configDir}", Se = i(() => {
-	const { findPnpApi: e } = module$1;
-	return e && e(process.cwd());
-}, "getPnpApi"), ee = i((e, t, s, n) => {
-	const o = `resolveFromPackageJsonPath:${e}:${t}:${s}`;
-	if (n != null && n.has(o)) return n.get(o);
-	const l = me(e, n);
-	if (!l) return;
-	let u = t || "tsconfig.json";
-	if (!s && l.exports) try {
-		const [a] = v(l.exports, t, ["require", "types"]);
-		u = a;
-	} catch {
-		return !1;
-	}
-	else !t && l.tsconfig && (u = l.tsconfig);
-	return u = path.join(e, "..", u), n?.set(o, u), u;
-}, "resolveFromPackageJsonPath"), ne = "package.json", te = "tsconfig.json", Je = i((e, t, s) => {
-	let n = e;
-	if (e === ".." && (n = path.join(n, te)), e[0] === "." && (n = path.resolve(t, n)), path.isAbsolute(n)) {
-		if (E(s, n)) {
-			if (G(s, n).isFile()) return n;
-		} else if (!n.endsWith(".json")) {
-			const p = `${n}.json`;
-			if (E(s, p)) return p;
-		}
-		return;
-	}
-	const [o, ...l] = e.split("/"), u = o[0] === "@" ? `${o}/${l.shift()}` : o, a = l.join("/"), r = Se();
-	if (r) {
-		const { resolveRequest: p } = r;
-		try {
-			if (u === e) {
-				const D = p(path.join(u, ne), t);
-				if (D) {
-					const L = ee(D, a, !1, s);
-					if (L && E(s, L)) return L;
-				}
-			} else {
-				let D;
-				try {
-					D = p(e, t, { extensions: [".json"] });
-				} catch {
-					D = p(path.join(e, te), t);
-				}
-				if (D) return D;
-			}
-		} catch {}
-	}
-	const g = fe(path.resolve(t), path.join("node_modules", u), s);
-	if (!g || !G(s, g).isDirectory()) return;
-	const v = path.join(g, ne);
-	if (E(s, v)) {
-		const p = ee(v, a, !1, s);
-		if (p === !1) return;
-		if (p && E(s, p) && G(s, p).isFile()) return p;
-	}
-	const d = path.join(g, a), _ = d.endsWith(".json");
-	if (!_) {
-		const p = `${d}.json`;
-		if (E(s, p)) return p;
-	}
-	if (E(s, d)) {
-		if (G(s, d).isDirectory()) {
-			const p = path.join(d, ne);
-			if (E(s, p)) {
-				const L = ee(p, "", !0, s);
-				if (L && E(s, L)) return L;
-			}
-			const D = path.join(d, te);
-			if (E(s, D)) return D;
-		} else if (_) return d;
-	}
-}, "resolveExtendsPath"), se = i((e, t) => K(path.relative(e, t)), "pathRelative"), we = [
-	"files",
-	"include",
-	"exclude"
-], de = i((e, t, s) => {
-	const n = path.join(t, s);
-	return h(path.relative(e, n)) || "./";
-}, "resolveAndRelativize"), We = i((e, t, s) => {
-	const n = path.relative(e, t);
-	if (!n) return s;
-	return h(`${n}/${s.startsWith("./") ? s.slice(2) : s}`);
-}, "prefixPattern"), Ve = i((e, t, s, n) => {
-	const o = Je(e, t, n);
-	if (!o) throw new Error(`File '${e}' not found.`);
-	if (s.has(o)) throw new Error(`Circularity detected while resolving configuration: ${o}`);
-	s.add(o);
-	const l = path.dirname(o), u = ve(o, n, s);
-	delete u.references;
-	const { compilerOptions: a } = u;
-	if (a) {
-		const { baseUrl: r } = a;
-		r && !r.startsWith(I) && (a.baseUrl = de(t, l, r));
-		const { outDir: g } = a;
-		g && !g.startsWith(I) && (a.outDir = de(t, l, g));
-	}
-	for (const r of we) {
-		const g = u[r];
-		g && (u[r] = g.map((v) => v.startsWith(I) ? v : We(t, l, v)));
-	}
-	return u;
-}, "resolveExtends"), be = ["outDir", "declarationDir"], ve = i((e, t, s = /* @__PURE__ */ new Set()) => {
-	let n;
-	try {
-		n = me(e, t) || {};
-	} catch {
-		throw new Error(`Cannot resolve tsconfig at path: ${e}`);
-	}
-	if (typeof n != "object") throw new SyntaxError(`Failed to parse tsconfig at: ${e}`);
-	const o = path.dirname(e);
-	if (n.compilerOptions) {
-		const { compilerOptions: l } = n;
-		l.paths && !l.baseUrl && (l[C] = o);
-	}
-	if (n.extends) {
-		const l = Array.isArray(n.extends) ? n.extends : [n.extends];
-		delete n.extends;
-		for (const u of l.reverse()) {
-			const a = Ve(u, o, new Set(s), t), r = {
-				...a,
-				...n,
-				compilerOptions: {
-					...a.compilerOptions,
-					...n.compilerOptions
-				}
-			};
-			a.watchOptions && (r.watchOptions = {
-				...a.watchOptions,
-				...n.watchOptions
-			}), n = r;
-		}
-	}
-	if (n.compilerOptions) {
-		const { compilerOptions: l } = n;
-		for (const a of ["baseUrl", "rootDir"]) {
-			const r = l[a];
-			if (r && !r.startsWith(I)) l[a] = se(o, path.resolve(o, r));
-		}
-		for (const a of be) {
-			let r = l[a];
-			r && (Array.isArray(n.exclude) || (n.exclude = be.map((g) => l[g]).filter(Boolean)), r.startsWith(I) || (r = K(r)), l[a] = r);
-		}
-	} else n.compilerOptions = {};
-	if (n.include ? (n.include = n.include.map(h), n.files && delete n.files) : n.files && (n.files = n.files.map((l) => l.startsWith(I) ? l : K(l))), n.watchOptions) {
-		const { watchOptions: l } = n;
-		l.excludeDirectories && (l.excludeDirectories = l.excludeDirectories.map((u) => h(path.resolve(o, u)))), l.excludeFiles && (l.excludeFiles = l.excludeFiles.map((u) => h(path.resolve(o, u)))), l.watchFile && (l.watchFile = l.watchFile.toLowerCase()), l.watchDirectory && (l.watchDirectory = l.watchDirectory.toLowerCase()), l.fallbackPolling && (l.fallbackPolling = l.fallbackPolling.toLowerCase());
-	}
-	return n;
-}, "_parseTsconfig"), H = i((e, t) => {
-	if (e.startsWith(I)) return h(path.join(t, e.slice(12)));
-}, "interpolateConfigDir"), Me = [
-	"outDir",
-	"declarationDir",
-	"outFile",
-	"rootDir",
-	"baseUrl",
-	"tsBuildInfoFile"
-], ze = i((e) => {
-	if (e.strict) for (const B of [
-		"noImplicitAny",
-		"noImplicitThis",
-		"strictNullChecks",
-		"strictFunctionTypes",
-		"strictBindCallApply",
-		"strictPropertyInitialization",
-		"strictBuiltinIteratorReturn",
-		"alwaysStrict",
-		"useUnknownInCatchVariables"
-	]) e[B] === void 0 && (e[B] = !0);
-	if (e.composite && (e.declaration ??= !0, e.incremental ??= !0), e.target) {
-		let f = e.target.toLowerCase();
-		f === "es2015" && (f = "es6"), e.target = f, f === "esnext" && (e.module ??= "es6", e.useDefineForClassFields ??= !0), (f === "es6" || f === "es2016" || f === "es2017" || f === "es2018" || f === "es2019" || f === "es2020" || f === "es2021" || f === "es2022" || f === "es2023" || f === "es2024") && (e.module ??= "es6"), (f === "es2022" || f === "es2023" || f === "es2024") && (e.useDefineForClassFields ??= !0);
-	}
-	if (e.module) {
-		let f = e.module.toLowerCase();
-		if (f === "es2015" && (f = "es6"), e.module = f, (f === "es6" || f === "es2020" || f === "es2022" || f === "esnext" || f === "none" || f === "system" || f === "umd" || f === "amd") && (e.moduleResolution ??= "classic"), f === "system" && (e.allowSyntheticDefaultImports ??= !0), (f === "node16" || f === "node18" || f === "node20" || f === "nodenext" || f === "preserve") && (e.esModuleInterop ??= !0, e.allowSyntheticDefaultImports ??= !0), (f === "node16" || f === "node18" || f === "node20" || f === "nodenext") && (e.moduleDetection ??= "force"), f === "node16" && (e.target ??= "es2022", e.moduleResolution ??= "node16"), f === "node18" && (e.target ??= "es2022", e.moduleResolution ??= "node16"), f === "node20" && (e.target ??= "es2023", e.moduleResolution ??= "node16", e.resolveJsonModule ??= !0), f === "nodenext" && (e.target ??= "esnext", e.moduleResolution ??= "nodenext", e.resolveJsonModule ??= !0), f === "node16" || f === "node18" || f === "node20" || f === "nodenext") {
-			const B = e.target;
-			(B === "es3" || B === "es2022" || B === "es2023" || B === "es2024" || B === "esnext") && (e.useDefineForClassFields ??= !0);
-		}
-		f === "preserve" && (e.moduleResolution ??= "bundler");
-	}
-	if (e.moduleResolution) {
-		let f = e.moduleResolution.toLowerCase();
-		f === "node" && (f = "node10"), e.moduleResolution = f, (f === "node16" || f === "nodenext" || f === "bundler") && (e.resolvePackageJsonExports ??= !0, e.resolvePackageJsonImports ??= !0), f === "bundler" && (e.allowSyntheticDefaultImports ??= !0, e.resolveJsonModule ??= !0);
-	}
-	e.jsx && (e.jsx = e.jsx.toLowerCase()), e.moduleDetection && (e.moduleDetection = e.moduleDetection.toLowerCase()), e.importsNotUsedAsValues && (e.importsNotUsedAsValues = e.importsNotUsedAsValues.toLowerCase()), e.newLine && (e.newLine = e.newLine.toLowerCase()), e.esModuleInterop && (e.allowSyntheticDefaultImports ??= !0), e.verbatimModuleSyntax && (e.isolatedModules ??= !0, e.preserveConstEnums ??= !0), e.isolatedModules && (e.preserveConstEnums ??= !0), e.rewriteRelativeImportExtensions && (e.allowImportingTsExtensions ??= !0), e.lib && (e.lib = e.lib.map((f) => f.toLowerCase())), e.checkJs && (e.allowJs ??= !0);
-}, "normalizeCompilerOptions"), pe = i((e, t = /* @__PURE__ */ new Map()) => {
-	const s = path.resolve(e), n = ve(s, t), o = path.dirname(s), { compilerOptions: l } = n;
-	if (l) {
-		for (const a of Me) {
-			const r = l[a];
-			if (r) {
-				const g = H(r, o);
-				l[a] = g ? se(o, g) : r;
-			}
-		}
-		for (const a of ["rootDirs", "typeRoots"]) {
-			const r = l[a];
-			r && (l[a] = r.map((g) => {
-				const v = H(g, o);
-				return v ? se(o, v) : g;
-			}));
-		}
-		const { paths: u } = l;
-		if (u) for (const a of Object.keys(u)) u[a] = u[a].map((r) => {
-			var g;
-			return (g = H(r, o)) != null ? g : r;
-		});
-		ze(l);
-	}
-	for (const u of we) {
-		const a = n[u];
-		a && (n[u] = a.map((r) => {
-			var g;
-			return (g = H(r, o)) != null ? g : r;
-		}));
-	}
-	return n;
-}, "parseTsconfig"), Ge = i((e = process.cwd(), t = "tsconfig.json", s = /* @__PURE__ */ new Map()) => {
-	const n = fe(h(e), t, s);
-	if (!n) return null;
-	return {
-		path: n,
-		config: pe(n, s)
-	};
-}, "getTsconfig"), Qe = /\*/g, Te = i((e, t) => {
-	const s = e.match(Qe);
-	if (s && s.length > 1) throw new Error(t);
-}, "assertStarCount"), He = i((e) => {
-	if (e.includes("*")) {
-		const [t, s] = e.split("*");
-		return {
-			prefix: t,
-			suffix: s
-		};
-	}
-	return e;
-}, "parsePattern"), Xe = i(({ prefix: e, suffix: t }, s) => s.startsWith(e) && s.endsWith(t), "isPatternMatch"), Ye = i((e, t, s) => Object.entries(e).map(([n, o]) => (Te(n, `Pattern '${n}' can have at most one '*' character.`), {
-	pattern: He(n),
-	substitutions: o.map((l) => {
-		if (Te(l, `Substitution '${l}' in pattern '${n}' can have at most one '*' character.`), !t && !q.test(l) && !path.isAbsolute(l)) throw new Error("Non-relative paths are not allowed when 'baseUrl' is not set. Did you forget a leading './'?");
-		return path.resolve(s, l);
-	})
-})), "parsePaths");
-i((e) => {
-	const { compilerOptions: t } = e.config;
-	if (!t) return null;
-	const { baseUrl: s, paths: n } = t;
-	if (!s && !n) return null;
-	const o = C in t && t[C], l = path.resolve(path.dirname(e.path), s || o || "."), u = n ? Ye(n, s, l) : [];
-	return (a) => {
-		if (q.test(a)) return [];
-		const r = [];
-		for (const _ of u) {
-			if (_.pattern === a) return _.substitutions.map(h);
-			typeof _.pattern != "string" && r.push(_);
-		}
-		let g, v = -1;
-		for (const _ of r) Xe(_.pattern, a) && _.pattern.prefix.length > v && (v = _.pattern.prefix.length, g = _);
-		if (!g) return s ? [h(path.join(l, a))] : [];
-		const d = a.slice(g.pattern.prefix.length, a.length - g.pattern.suffix.length);
-		return g.substitutions.map((_) => h(_.replace("*", d)));
-	};
-}, "createPathsMatcher");
-var qe = Object.defineProperty, X = i((e, t) => qe(e, "name", {
-	value: t,
-	configurable: !0
-}), "s");
-const Ae = X((e) => {
-	let t = "";
-	for (let s = 0; s < e.length; s += 1) {
-		const n = e[s], o = n.toUpperCase();
-		t += n === o ? n.toLowerCase() : o;
-	}
-	return t;
-}, "invertCase"), le = /* @__PURE__ */ new Map(), _e = X((e, t) => {
-	const s = path$1.join(e, `.is-fs-case-sensitive-test-${process.pid}`);
-	try {
-		return t.writeFileSync(s, ""), !t.existsSync(Ae(s));
-	} finally {
-		try {
-			t.unlinkSync(s);
-		} catch {}
-	}
-}, "checkDirectoryCaseWithWrite"), Ke = X((e, t, s) => {
-	try {
-		return _e(e, s);
-	} catch (n) {
-		if (t === void 0) return _e(Be.tmpdir(), s);
-		throw n;
-	}
-}, "checkDirectoryCaseWithFallback"), Oe = X((e, t = nativeFs, s = !0) => {
-	const n = e != null ? e : process.cwd();
-	if (s && le.has(n)) return le.get(n);
-	let o;
-	const l = Ae(n);
-	return l !== n && t.existsSync(n) ? o = !t.existsSync(l) : o = Ke(n, e, t), s && le.set(n, o), o;
-}, "isFsCaseSensitive"), { join: ye } = path.posix, oe = {
-	ts: [
-		".ts",
-		".tsx",
-		".d.ts"
-	],
-	cts: [".cts", ".d.cts"],
-	mts: [".mts", ".d.mts"]
-}, Ce = i((e) => {
-	const t = [...oe.ts], s = [...oe.cts], n = [...oe.mts];
-	return e != null && e.allowJs && (t.push(".js", ".jsx"), s.push(".cjs"), n.push(".mjs")), [
-		...t,
-		...s,
-		...n
-	];
-}, "getSupportedExtensions"), en = i((e) => {
-	const t = [];
-	if (!e) return t;
-	const { outDir: s, declarationDir: n } = e;
-	return s && t.push(s), n && t.push(n), t;
-}, "getDefaultExcludeSpec"), je = i((e) => e.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`), "escapeForRegexp"), ie = `(?!(${[
-	"node_modules",
-	"bower_components",
-	"jspm_packages"
-].join("|")})(/|$))`, tn = /(?:^|\/)[^.*?]+$/, Fe = "**/*", Y = "[^/]", ue = "[^./]", De = process.platform === "win32";
-i(({ config: e, path: t }, s = Oe()) => {
-	if ("extends" in e) throw new Error("tsconfig#extends must be resolved. Use getTsconfig or parseTsconfig to resolve it.");
-	if (!path.isAbsolute(t)) throw new Error("The tsconfig path must be absolute");
-	De && (t = h(t));
-	const n = path.dirname(t), { files: o, include: l, exclude: u, compilerOptions: a } = e, r = i((T) => path.isAbsolute(T) ? T : ye(n, T), "resolvePattern"), g = o == null ? void 0 : o.map(r), v = Ce(a), d = s ? "" : "i", p = (u || en(a)).map((T) => {
-		const x = je(r(T)).replaceAll(String.raw`\*\*/`, "(.+/)?").replaceAll(String.raw`\*`, `${Y}*`).replaceAll(String.raw`\?`, Y);
-		return new RegExp(`^${x}($|/)`, d);
-	}), D = o || l ? l : [Fe], L = D ? D.map((T) => {
-		let F = r(T);
-		tn.test(F) && (F = ye(F, Fe));
-		const x = je(F).replaceAll(String.raw`/\*\*`, `(/${ie}${ue}${Y}*)*?`).replaceAll(/(\/)?\\\*/g, (c, y) => {
-			const A = `(${ue}|(\\.(?!min\\.js$))?)*`;
-			return y ? `/${ie}${ue}${A}` : A;
-		}).replaceAll(/(\/)?\\\?/g, (c, y) => {
-			const A = Y;
-			return y ? `/${ie}${A}` : A;
-		});
-		return new RegExp(`^${x}$`, d);
-	}) : void 0;
-	return (T) => {
-		if (!path.isAbsolute(T)) throw new Error("filePath must be absolute");
-		if (De && (T = h(T)), g != null && g.includes(T)) return e;
-		if (!(!v.some((F) => T.endsWith(F)) || p.some((F) => F.test(T))) && L && L.some((F) => F.test(T))) return e;
-	};
-}, "createFilesMatcher");
+const walkAST = walk;
 //#endregion
 //#region ../../node_modules/.pnpm/dts-resolver@2.1.3_oxc-resolver@11.14.0/node_modules/dts-resolver/dist/index.mjs
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
-function createResolver({ tsconfig, cwd = process$1.cwd(), resolveNodeModules = false, ResolverFactory } = {}) {
+function createResolver({ tsconfig, cwd = process.cwd(), resolveNodeModules = false, ResolverFactory } = {}) {
 	ResolverFactory ||= __require("oxc-resolver").ResolverFactory;
 	const resolver = new ResolverFactory({
 		mainFields: [
@@ -31249,8 +30520,7 @@ const ALLOW_EXTENSIONS = new Set([
 function ensureValue(value) {
 	return value && ALLOW_EXTENSIONS.has(extname(value)) ? value.replaceAll("\\", "/") : null;
 }
-//#endregion
-//#region ../../node_modules/.pnpm/rolldown-plugin-dts@0.22.5_@typescript+native-preview@7.0.0-dev.20260122.2_oxc-resolver_ee01c189cef60d67143f173de4d10478/node_modules/rolldown-plugin-dts/dist/index.mjs
+const picomatch = createRequire(import.meta.url)("./npm_entry_picomatch.cjs");
 function createDtsInputPlugin({ sideEffects }) {
 	return {
 		name: "rolldown-plugin-dts:dts-input",
@@ -31326,12 +30596,17 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 		}
 	};
 	function transform(code, id) {
-		const file = parse$1(code, {
-			plugins: [["typescript", { dts: true }], "decoratorAutoAccessors"],
-			sourceType: "module",
-			errorRecovery: true,
-			createParenthesizedExpressions: true
-		});
+		let file;
+		try {
+			file = parse$1(code, {
+				plugins: [["typescript", { dts: true }], "decoratorAutoAccessors"],
+				sourceType: "module",
+				errorRecovery: true,
+				createParenthesizedExpressions: true
+			});
+		} catch (error) {
+			throw new Error(`Failed to parse ${id}. This may be caused by a syntax error in the declaration file or a bug in the plugin. Please report this issue to https://github.com/sxzz/rolldown-plugin-dts\n${error}`, { cause: error });
+		}
 		const { program, comments } = file;
 		const typeOnlyIds = [];
 		const identifierMap = Object.create(null);
@@ -31447,7 +30722,12 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 			const ids = typeOnlyMap.get(module);
 			if (ids) typeOnlyIds.push(...ids);
 		}
-		const file = parse$1(code, { sourceType: "module" });
+		let file;
+		try {
+			file = parse$1(code, { sourceType: "module" });
+		} catch (error) {
+			throw new Error(`Failed to parse generated code for chunk ${chunk.fileName}. This may be caused by a bug in the plugin. Please report this issue to https://github.com/sxzz/rolldown-plugin-dts\n${error}`, { cause: error });
+		}
 		const { program } = file;
 		program.body = patchTsNamespace(program.body);
 		program.body = patchReExport(program.body);
@@ -31622,7 +30902,7 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 	}
 	function importNamespace(node, imported, source, namespaceStmts, identifierMap) {
 		const sourceText = source.value.replaceAll(/\W/g, "_");
-		let local = identifier(isIdentifierName(source.value) ? source.value : `${sourceText}${getIdentifierIndex(identifierMap, sourceText)}`);
+		let local = identifier(`_$${isIdentifierName(source.value) ? source.value : `${sourceText}${getIdentifierIndex(identifierMap, sourceText)}`}`);
 		if (namespaceStmts.has(source.value)) local = namespaceStmts.get(source.value).local;
 		else namespaceStmts.set(source.value, {
 			stmt: importDeclaration([importNamespaceSpecifier(local)], source),
@@ -31906,7 +31186,8 @@ async function runTsgo(rootDir, tsconfig, sourcemap, tsgoPath) {
 }
 const debug$2 = createDebug("rolldown-plugin-dts:generate");
 const WORKER_URL = "./tsc-worker.mjs";
-function createGeneratePlugin({ tsconfig, tsconfigRaw, build, incremental, cwd, oxc, emitDtsOnly, vue, tsMacro, parallel, eager, tsgo, newContext, emitJs, sourcemap }) {
+function createGeneratePlugin({ entry, tsconfig, tsconfigRaw, build, incremental, cwd, oxc, emitDtsOnly, vue, tsMacro, parallel, eager, tsgo, newContext, emitJs, sourcemap }) {
+	const entryMatcher = entry ? picomatch(entry, { ignore: entry.filter((p) => p.startsWith("!")).map((p) => p.slice(1)) }) : void 0;
 	const dtsMap = /* @__PURE__ */ new Map();
 	/**
 	* A map of input id to output file name
@@ -31930,12 +31211,12 @@ function createGeneratePlugin({ tsconfig, tsconfigRaw, build, incremental, cwd,
 			if (tsgo) tsgoDist = await runTsgo(rootDir, tsconfig, sourcemap, tsgo.path);
 			else if (!oxc) if (parallel) {
 				childProcess = fork(new URL(WORKER_URL, import.meta.url), { stdio: "inherit" });
-				rpc = (await import("./dist-_l70jCqI.js")).createBirpc({}, {
+				rpc = (await import("./dist-D8aGMhnG.js")).createBirpc({}, {
 					post: (data) => childProcess.send(data),
 					on: (fn) => childProcess.on("message", fn)
 				});
 			} else {
-				tscModule = await import("./tsc-ncSpKhL9.js");
+				tscModule = await import("./tsc-Cabpo8gE.js");
 				if (newContext) tscContext = createContext();
 			}
 			if (!Array.isArray(options.input)) for (const [name, id] of Object.entries(options.input)) {
@@ -31984,7 +31265,8 @@ function createGeneratePlugin({ tsconfig, tsconfigRaw, build, incremental, cwd,
 			} },
 			handler(code, id) {
 				if (!RE_JS.test(id) || emitJs) {
-					const isEntry = !!this.getModuleInfo(id)?.isEntry;
+					const mod = this.getModuleInfo(id);
+					const isEntry = entryMatcher ? entryMatcher(path.relative(cwd, id)) : !!mod?.isEntry;
 					const dtsId = filename_to_dts(id);
 					dtsMap.set(dtsId, {
 						code,
@@ -32141,7 +31423,7 @@ function collectJsonExports(code) {
 	return exports;
 }
 let warnedTsgo = false;
-function resolveOptions({ cwd = process$1.cwd(), dtsInput = false, emitDtsOnly = false, tsconfig, tsconfigRaw: overriddenTsconfigRaw = {}, compilerOptions = {}, sourcemap, resolver = "oxc", cjsDefault = false, sideEffects = false, build = false, incremental = false, vue = false, tsMacro = false, parallel = false, eager = false, newContext = false, emitJs, oxc, tsgo = false }) {
+function resolveOptions({ entry, cwd = process.cwd(), dtsInput = false, emitDtsOnly = false, tsconfig, tsconfigRaw: overriddenTsconfigRaw = {}, compilerOptions = {}, sourcemap, resolver = "oxc", cjsDefault = false, sideEffects = false, build = false, incremental = false, vue = false, tsMacro = false, parallel = false, eager = false, newContext = false, emitJs, oxc, tsgo = false }) {
 	if (tsgo === true) tsgo = {};
 	else if (typeof tsgo === "object" && tsgo.enabled === false) tsgo = false;
 	let resolvedTsconfig;
@@ -32150,7 +31432,7 @@ function resolveOptions({ cwd = process$1.cwd(), dtsInput = false, emitDtsOnly =
 		tsconfig = path;
 		resolvedTsconfig = config;
 	} else if (typeof tsconfig === "string") {
-		tsconfig = path.resolve(cwd || process$1.cwd(), tsconfig);
+		tsconfig = path.resolve(cwd || process.cwd(), tsconfig);
 		resolvedTsconfig = pe(tsconfig);
 	} else tsconfig = void 0;
 	compilerOptions = {
@@ -32184,6 +31466,7 @@ function resolveOptions({ cwd = process$1.cwd(), dtsInput = false, emitDtsOnly =
 		warnedTsgo = true;
 	}
 	return {
+		entry: entry ? Array.isArray(entry) ? entry : [entry] : void 0,
 		cwd,
 		dtsInput,
 		emitDtsOnly,
@@ -32232,7 +31515,7 @@ function createDtsResolvePlugin({ cwd, tsconfig, tsconfigRaw, resolver, sideEffe
 				debug$1("Rolldown resolution for dts import %O from %O: %O", id, importer, rolldownResolution);
 				if (rolldownResolution?.external) {
 					debug$1("Rolldown marked dts import as external:", id);
-					return external;
+					return rolldownResolution;
 				}
 				const dtsResolution = await resolveDtsPath(id, importer, rolldownResolution);
 				debug$1("Dts resolution for dts import %O from %O: %O", id, importer, dtsResolution);
@@ -32265,7 +31548,7 @@ function createDtsResolvePlugin({ cwd, tsconfig, tsconfigRaw, resolver, sideEffe
 	async function resolveDtsPath(id, importer, rolldownResolution) {
 		let dtsPath;
 		if (resolver === "tsc") {
-			const { tscResolve } = await import("./resolver-BUWpVKW_-BR1glCep.js");
+			const { tscResolve } = await import("./resolver-DkvdaW3s-CCXGyGZ3.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);