@stylex-variants/core 0.0.1

package/dist/babel.js

@@ -0,0 +1,5060 @@
+//#region ../../node_modules/.pnpm/@babel+helper-validator-identifier@8.0.6/node_modules/@babel/helper-validator-identifier/lib/identifier-browser.js
+var e = "ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆ՘ՙՠ-ֈ֋֌א-תׯ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࡠ-ࡪࡰ-ࢇࢉ-࢏ࢠ-ࣉऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱৼਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚ౜ౝౠౡಀಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ೜-ೞೠೡೱೲഄ-ഌഎ-ഐഒ-ഺഽൎൔ-ൖൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄຆ-ຊຌ-ຣລວ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜑᜟ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡸᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭌᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᲀ-ᲊᲐ-ᲺᲽ-Ჿᳩ-ᳬᳮ-ᳳᳵᳶᳺᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿ₏-₟ℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄯㄱ-ㆎㆠ-ㆿㇰ-ㇿ㐀-䶿一-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-꟝꟢꟱-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꣾꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭩ꭬꭭ꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ", t = "·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄ-׉ؐ-ًؚ-٩ٰۖ-ۜ۟-۪ۤۧۨ-ۭ۰-۹ܑܰ-݊ަ-ް߀-߉߫-߽߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛ࢗ-࢟࣊-ࣣ࣡-ःऺ-़ा-ॏ॑-ॗॢॣ०-९ঁ-ঃ়া-ৄেৈো-্ৗৢৣ০-৯৾ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑ੦-ੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣ૦-૯ૺ-૿ଁ-ଃ଼ା-ୄେୈୋ-୍୓-ୗୢୣ୦-୯ஂா-ூெ-ைொ-்ௗ௦-௯ఀ-ఄ఼ా-ౄె-ైొ-్ౕౖౢౣ౦-౯ಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣ೦-೯ೳഀ-ഃ഻഼ാ-ൄെ-ൈൊ-്ൗൢൣ൦-൯ඁ-ඃ්ා-ුූෘ-ෟ෦-෯ෲෳัิ-ฺ็-๎๐-๙ັິ-ຼ່-໎໐-໙༘༙༠-༩༹༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှ၀-၉ၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏ-ႝ፝-፟፩-፱ᜒ-᜕ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝០-៩᠋-᠍᠏-᠙ᢩᤠ-ᤫᤰ-᤻᥆-᥏᧐-᧚ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼-᪉᪐-᪙᪰-᪽ᪿ-᫰ᬀ-ᬄ᬴-᭄᭐-᭙᭫-᭳ᮀ-ᮂᮡ-ᮭ᮰-᮹᯦-᯳ᰤ-᰷᱀-᱉᱐-᱙᳐-᳔᳒-᳨᳭᳴᳷-᳹᷀-᷿‌‍‿⁀⁔⃐-⃥⃜⃡-⃰⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯・꘠-꘩꙯ꙴ-꙽ꚞꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧ꠬ꢀꢁꢴ-ꣅ꣐-꣙꣠-꣱ꣿ-꤉ꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀꧐-꧙ꧥ꧰-꧹ꨩ-ꨶꩃꩌꩍ꩐-꩙ꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭꯰-꯹ﬞ︀-️︠-︯︳︴﹍-﹏０-９＿･", n = RegExp("[" + e + "]"), r = RegExp("[" + e + t + "]"), i = [
+	0,
+	11,
+	2,
+	25,
+	2,
+	18,
+	2,
+	1,
+	2,
+	14,
+	3,
+	13,
+	35,
+	122,
+	70,
+	52,
+	268,
+	28,
+	4,
+	48,
+	48,
+	31,
+	14,
+	29,
+	6,
+	37,
+	11,
+	29,
+	3,
+	35,
+	5,
+	7,
+	2,
+	4,
+	43,
+	157,
+	19,
+	35,
+	5,
+	35,
+	5,
+	39,
+	9,
+	51,
+	13,
+	10,
+	2,
+	14,
+	2,
+	6,
+	2,
+	1,
+	2,
+	10,
+	2,
+	14,
+	2,
+	6,
+	2,
+	1,
+	4,
+	51,
+	13,
+	310,
+	10,
+	21,
+	11,
+	7,
+	25,
+	5,
+	2,
+	41,
+	2,
+	13,
+	65,
+	5,
+	3,
+	0,
+	2,
+	43,
+	2,
+	1,
+	4,
+	0,
+	3,
+	22,
+	11,
+	22,
+	10,
+	30,
+	66,
+	18,
+	2,
+	1,
+	11,
+	21,
+	11,
+	25,
+	7,
+	25,
+	39,
+	55,
+	7,
+	1,
+	65,
+	0,
+	16,
+	3,
+	2,
+	2,
+	2,
+	28,
+	43,
+	28,
+	4,
+	28,
+	36,
+	7,
+	2,
+	27,
+	28,
+	53,
+	11,
+	21,
+	11,
+	18,
+	14,
+	17,
+	111,
+	72,
+	56,
+	50,
+	14,
+	50,
+	14,
+	35,
+	39,
+	27,
+	10,
+	22,
+	251,
+	41,
+	7,
+	1,
+	17,
+	5,
+	18,
+	21,
+	18,
+	28,
+	11,
+	0,
+	9,
+	21,
+	43,
+	17,
+	47,
+	20,
+	28,
+	22,
+	13,
+	52,
+	58,
+	1,
+	3,
+	0,
+	14,
+	44,
+	33,
+	24,
+	27,
+	35,
+	30,
+	0,
+	3,
+	0,
+	9,
+	34,
+	4,
+	0,
+	13,
+	47,
+	15,
+	3,
+	22,
+	0,
+	2,
+	0,
+	36,
+	17,
+	2,
+	24,
+	20,
+	1,
+	64,
+	6,
+	2,
+	0,
+	2,
+	3,
+	2,
+	14,
+	2,
+	9,
+	8,
+	46,
+	39,
+	7,
+	3,
+	1,
+	3,
+	21,
+	2,
+	6,
+	2,
+	1,
+	2,
+	4,
+	4,
+	0,
+	19,
+	0,
+	13,
+	4,
+	31,
+	9,
+	2,
+	0,
+	3,
+	0,
+	2,
+	37,
+	2,
+	0,
+	26,
+	0,
+	2,
+	0,
+	45,
+	52,
+	19,
+	3,
+	21,
+	2,
+	31,
+	47,
+	21,
+	1,
+	2,
+	0,
+	185,
+	46,
+	42,
+	3,
+	37,
+	47,
+	21,
+	0,
+	60,
+	42,
+	14,
+	0,
+	72,
+	26,
+	38,
+	6,
+	186,
+	43,
+	117,
+	63,
+	32,
+	7,
+	3,
+	0,
+	3,
+	7,
+	2,
+	1,
+	2,
+	23,
+	16,
+	0,
+	2,
+	0,
+	95,
+	7,
+	3,
+	38,
+	17,
+	0,
+	2,
+	0,
+	29,
+	0,
+	11,
+	39,
+	8,
+	0,
+	22,
+	0,
+	12,
+	45,
+	20,
+	0,
+	19,
+	72,
+	18,
+	0,
+	182,
+	32,
+	32,
+	8,
+	2,
+	36,
+	18,
+	0,
+	50,
+	29,
+	113,
+	6,
+	2,
+	1,
+	2,
+	37,
+	22,
+	0,
+	26,
+	5,
+	2,
+	1,
+	2,
+	31,
+	15,
+	0,
+	24,
+	43,
+	22,
+	0,
+	239,
+	18,
+	16,
+	0,
+	2,
+	12,
+	2,
+	33,
+	125,
+	0,
+	80,
+	921,
+	103,
+	111,
+	6,
+	206,
+	13,
+	310,
+	2314,
+	96,
+	16,
+	1071,
+	18,
+	5,
+	26,
+	3994,
+	6,
+	582,
+	6842,
+	29,
+	1763,
+	568,
+	8,
+	30,
+	18,
+	78,
+	18,
+	29,
+	19,
+	47,
+	17,
+	3,
+	32,
+	20,
+	6,
+	18,
+	433,
+	44,
+	212,
+	63,
+	33,
+	24,
+	3,
+	24,
+	45,
+	74,
+	6,
+	0,
+	67,
+	12,
+	65,
+	1,
+	2,
+	0,
+	15,
+	4,
+	10,
+	7386,
+	37,
+	33,
+	96,
+	114,
+	14,
+	913,
+	15,
+	50,
+	7710,
+	3,
+	2,
+	6,
+	2,
+	1,
+	2,
+	296,
+	10,
+	0,
+	30,
+	2,
+	3,
+	0,
+	15,
+	4,
+	8,
+	395,
+	2309,
+	106,
+	6,
+	12,
+	4,
+	8,
+	8,
+	9,
+	5991,
+	84,
+	2,
+	70,
+	2,
+	1,
+	3,
+	0,
+	3,
+	1,
+	3,
+	3,
+	2,
+	11,
+	2,
+	0,
+	2,
+	6,
+	2,
+	64,
+	2,
+	3,
+	3,
+	7,
+	2,
+	6,
+	2,
+	27,
+	2,
+	3,
+	2,
+	4,
+	2,
+	0,
+	4,
+	6,
+	2,
+	340,
+	2,
+	24,
+	2,
+	24,
+	2,
+	30,
+	2,
+	24,
+	2,
+	30,
+	2,
+	24,
+	2,
+	30,
+	2,
+	24,
+	2,
+	30,
+	2,
+	24,
+	2,
+	7,
+	1845,
+	129,
+	15,
+	6,
+	55,
+	50,
+	49,
+	61,
+	147,
+	44,
+	11,
+	6,
+	17,
+	0,
+	322,
+	29,
+	19,
+	43,
+	485,
+	27,
+	229,
+	29,
+	3,
+	0,
+	208,
+	30,
+	2,
+	2,
+	2,
+	1,
+	2,
+	6,
+	3,
+	4,
+	10,
+	1,
+	225,
+	6,
+	2,
+	3,
+	2,
+	1,
+	2,
+	14,
+	2,
+	196,
+	60,
+	67,
+	8,
+	0,
+	1205,
+	3,
+	2,
+	26,
+	2,
+	1,
+	2,
+	0,
+	3,
+	0,
+	2,
+	9,
+	2,
+	3,
+	2,
+	0,
+	2,
+	0,
+	7,
+	0,
+	5,
+	0,
+	2,
+	0,
+	2,
+	0,
+	2,
+	2,
+	2,
+	1,
+	2,
+	0,
+	3,
+	0,
+	2,
+	0,
+	2,
+	0,
+	2,
+	0,
+	2,
+	0,
+	2,
+	1,
+	2,
+	0,
+	3,
+	3,
+	2,
+	6,
+	2,
+	3,
+	2,
+	3,
+	2,
+	0,
+	2,
+	9,
+	2,
+	16,
+	6,
+	2,
+	2,
+	4,
+	2,
+	16,
+	4421,
+	42719,
+	33,
+	4382,
+	2,
+	5773,
+	3,
+	7472,
+	16,
+	621,
+	2467,
+	541,
+	1507,
+	4938,
+	6,
+	8489,
+	39815,
+	11327
+], a = [
+	509,
+	0,
+	227,
+	0,
+	150,
+	4,
+	294,
+	9,
+	1368,
+	2,
+	2,
+	1,
+	6,
+	3,
+	41,
+	2,
+	5,
+	0,
+	166,
+	1,
+	574,
+	3,
+	9,
+	9,
+	7,
+	9,
+	32,
+	4,
+	318,
+	1,
+	31,
+	4,
+	33,
+	15,
+	71,
+	10,
+	50,
+	3,
+	123,
+	2,
+	54,
+	14,
+	32,
+	10,
+	3,
+	1,
+	11,
+	3,
+	46,
+	10,
+	8,
+	0,
+	46,
+	9,
+	7,
+	2,
+	37,
+	13,
+	2,
+	9,
+	6,
+	1,
+	45,
+	0,
+	13,
+	2,
+	49,
+	13,
+	9,
+	3,
+	2,
+	11,
+	83,
+	11,
+	7,
+	0,
+	3,
+	0,
+	158,
+	11,
+	6,
+	9,
+	7,
+	3,
+	56,
+	1,
+	2,
+	6,
+	3,
+	1,
+	3,
+	2,
+	10,
+	0,
+	11,
+	1,
+	3,
+	6,
+	4,
+	4,
+	68,
+	8,
+	2,
+	0,
+	3,
+	0,
+	2,
+	3,
+	2,
+	4,
+	2,
+	0,
+	15,
+	1,
+	83,
+	17,
+	10,
+	9,
+	5,
+	0,
+	82,
+	19,
+	13,
+	9,
+	214,
+	6,
+	3,
+	8,
+	28,
+	1,
+	83,
+	16,
+	16,
+	9,
+	82,
+	12,
+	9,
+	9,
+	7,
+	19,
+	58,
+	14,
+	5,
+	9,
+	243,
+	14,
+	166,
+	9,
+	71,
+	5,
+	2,
+	1,
+	3,
+	3,
+	2,
+	0,
+	2,
+	1,
+	13,
+	9,
+	120,
+	6,
+	3,
+	6,
+	4,
+	0,
+	29,
+	9,
+	41,
+	6,
+	2,
+	3,
+	9,
+	0,
+	10,
+	10,
+	47,
+	15,
+	199,
+	7,
+	137,
+	9,
+	54,
+	7,
+	2,
+	7,
+	17,
+	9,
+	57,
+	21,
+	2,
+	13,
+	123,
+	5,
+	4,
+	0,
+	2,
+	1,
+	2,
+	6,
+	2,
+	0,
+	9,
+	9,
+	49,
+	4,
+	2,
+	1,
+	2,
+	4,
+	9,
+	9,
+	55,
+	9,
+	7,
+	0,
+	259,
+	3,
+	10,
+	1,
+	2,
+	0,
+	49,
+	6,
+	4,
+	4,
+	14,
+	10,
+	5350,
+	0,
+	7,
+	14,
+	11465,
+	27,
+	2343,
+	9,
+	87,
+	9,
+	39,
+	4,
+	60,
+	6,
+	26,
+	9,
+	535,
+	9,
+	470,
+	0,
+	2,
+	54,
+	8,
+	3,
+	82,
+	0,
+	12,
+	1,
+	19628,
+	1,
+	4178,
+	9,
+	519,
+	45,
+	3,
+	22,
+	481,
+	1,
+	61,
+	4,
+	4,
+	5,
+	9,
+	7,
+	3,
+	6,
+	31,
+	3,
+	149,
+	2,
+	12,
+	2,
+	9,
+	1,
+	3,
+	0,
+	33,
+	1,
+	1357,
+	49,
+	513,
+	54,
+	5,
+	49,
+	9,
+	0,
+	15,
+	0,
+	23,
+	4,
+	2,
+	14,
+	1361,
+	6,
+	2,
+	16,
+	3,
+	6,
+	2,
+	1,
+	2,
+	4,
+	101,
+	0,
+	161,
+	6,
+	10,
+	9,
+	357,
+	0,
+	62,
+	13,
+	499,
+	13,
+	245,
+	1,
+	2,
+	9,
+	233,
+	0,
+	3,
+	0,
+	8,
+	1,
+	6,
+	0,
+	475,
+	6,
+	110,
+	6,
+	6,
+	9,
+	4759,
+	9,
+	787719,
+	239
+];
+function o(e, t) {
+	let n = 65536;
+	for (let r = 0, i = t.length; r < i; r += 2) {
+		if (n += t[r], n > e) return !1;
+		if (n += t[r + 1], n >= e) return !0;
+	}
+	return !1;
+}
+function s(e) {
+	return e < 65 ? e === 36 : e <= 90 ? !0 : e < 97 ? e === 95 : e <= 122 ? !0 : e <= 65535 ? e >= 170 && n.test(String.fromCharCode(e)) : o(e, i);
+}
+function c(e) {
+	return e < 48 ? e === 36 : e < 58 ? !0 : e < 65 ? !1 : e <= 90 ? !0 : e < 97 ? e === 95 : e <= 122 ? !0 : e <= 65535 ? e >= 170 && r.test(String.fromCharCode(e)) : o(e, i) || o(e, a);
+}
+function l(e) {
+	let t = !0;
+	for (let n = 0; n < e.length; n++) {
+		let r = e.charCodeAt(n);
+		if ((r & 64512) == 55296 && n + 1 < e.length) {
+			let t = e.charCodeAt(++n);
+			(t & 64512) == 56320 && (r = 65536 + ((r & 1023) << 10) + (t & 1023));
+		}
+		if (t) {
+			if (t = !1, !s(r)) return !1;
+		} else if (!c(r)) return !1;
+	}
+	return !t;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@babel+helper-validator-identifier@8.0.6/node_modules/@babel/helper-validator-identifier/lib/index.js
+var u = {
+	keyword: /* @__PURE__ */ "break.case.catch.continue.debugger.default.do.else.finally.for.function.if.return.switch.throw.try.var.const.while.with.new.this.super.class.extends.export.import.null.true.false.in.instanceof.typeof.void.delete".split("."),
+	strict: [
+		"implements",
+		"interface",
+		"let",
+		"package",
+		"private",
+		"protected",
+		"public",
+		"static",
+		"yield"
+	],
+	strictBind: ["eval", "arguments"]
+}, d = new Set(u.keyword), f = new Set(u.strict);
+new Set(u.strictBind);
+function p(e, t) {
+	return t && e === "await" || e === "enum";
+}
+function m(e, t) {
+	return p(e, t) || f.has(e);
+}
+function ee(e) {
+	return d.has(e);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@babel+helper-string-parser@8.0.6/node_modules/@babel/helper-string-parser/lib/index.js
+var te = function(e) {
+	return e >= 48 && e <= 57;
+}, ne = {
+	decBinOct: /* @__PURE__ */ new Set([
+		46,
+		66,
+		69,
+		79,
+		95,
+		98,
+		101,
+		111
+	]),
+	hex: /* @__PURE__ */ new Set([
+		46,
+		88,
+		95,
+		120
+	])
+}, h = {
+	bin: (e) => e === 48 || e === 49,
+	oct: (e) => e >= 48 && e <= 55,
+	dec: (e) => e >= 48 && e <= 57,
+	hex: (e) => e >= 48 && e <= 57 || e >= 65 && e <= 70 || e >= 97 && e <= 102
+};
+function g(e, t, n, r, i, a) {
+	let o = n, s = r, c = i, l = "", u = null, d = n, { length: f } = t;
+	for (;;) {
+		if (n >= f) {
+			a.unterminated(o, s, c), l += t.slice(d, n);
+			break;
+		}
+		let p = t.charCodeAt(n);
+		if (_(e, p, t, n)) {
+			l += t.slice(d, n);
+			break;
+		}
+		if (p === 92) {
+			l += t.slice(d, n);
+			let o = re(t, n, r, i, e === "template", a);
+			o.ch === null && !u ? u = {
+				pos: n,
+				lineStart: r,
+				curLine: i
+			} : l += o.ch, {pos: n, lineStart: r, curLine: i} = o, d = n;
+		} else p === 8232 || p === 8233 ? (++n, ++i, r = n) : p === 10 || p === 13 ? e === "template" ? (l += t.slice(d, n) + "\n", ++n, p === 13 && t.charCodeAt(n) === 10 && ++n, ++i, d = r = n) : a.unterminated(o, s, c) : ++n;
+	}
+	return {
+		pos: n,
+		str: l,
+		firstInvalidLoc: u,
+		lineStart: r,
+		curLine: i
+	};
+}
+function _(e, t, n, r) {
+	return e === "template" ? t === 96 || t === 36 && n.charCodeAt(r + 1) === 123 : t === (e === "double" ? 34 : 39);
+}
+function re(e, t, n, r, i, a) {
+	let o = !i;
+	t++;
+	let s = (e) => ({
+		pos: t,
+		ch: e,
+		lineStart: n,
+		curLine: r
+	}), c = e.charCodeAt(t++);
+	switch (c) {
+		case 110: return s("\n");
+		case 114: return s("\r");
+		case 120: {
+			let i;
+			return {code: i, pos: t} = ie(e, t, n, r, 2, !1, o, a), s(i === null ? null : String.fromCharCode(i));
+		}
+		case 117: {
+			let i;
+			return {code: i, pos: t} = ae(e, t, n, r, o, a), s(i === null ? null : String.fromCodePoint(i));
+		}
+		case 116: return s("	");
+		case 98: return s("\b");
+		case 118: return s("\v");
+		case 102: return s("\f");
+		case 13: e.charCodeAt(t) === 10 && ++t;
+		case 10: n = t, ++r;
+		case 8232:
+		case 8233: return s("");
+		case 56:
+		case 57:
+			if (i) return s(null);
+			a.strictNumericEscape(t - 1, n, r);
+		default:
+			if (c >= 48 && c <= 55) {
+				let o = t - 1, c = /^[0-7]+/.exec(e.slice(o, t + 2))[0], l = parseInt(c, 8);
+				l > 255 && (c = c.slice(0, -1), l = parseInt(c, 8)), t += c.length - 1;
+				let u = e.charCodeAt(t);
+				if (c !== "0" || u === 56 || u === 57) {
+					if (i) return s(null);
+					a.strictNumericEscape(o, n, r);
+				}
+				return s(String.fromCharCode(l));
+			}
+			return s(String.fromCharCode(c));
+	}
+}
+function ie(e, t, n, r, i, a, o, s) {
+	let c = t, l;
+	return {n: l, pos: t} = v(e, t, n, r, 16, i, a, !1, s, !o), l === null && (o ? s.invalidEscapeSequence(c, n, r) : t = c - 1), {
+		code: l,
+		pos: t
+	};
+}
+function v(e, t, n, r, i, a, o, s, c, l) {
+	let u = t, d = i === 16 ? ne.hex : ne.decBinOct, f = i === 16 ? h.hex : i === 10 ? h.dec : i === 8 ? h.oct : h.bin, p = !1, m = 0;
+	for (let u = 0, ee = a ?? Infinity; u < ee; ++u) {
+		let a = e.charCodeAt(t), u;
+		if (a === 95 && s !== "bail") {
+			let i = e.charCodeAt(t - 1), a = e.charCodeAt(t + 1);
+			if (!s) {
+				if (l) return {
+					n: null,
+					pos: t
+				};
+				c.numericSeparatorInEscapeSequence(t, n, r);
+			} else if (Number.isNaN(a) || !f(a) || d.has(i) || d.has(a)) {
+				if (l) return {
+					n: null,
+					pos: t
+				};
+				c.unexpectedNumericSeparator(t, n, r);
+			}
+			++t;
+			continue;
+		}
+		if (u = a >= 97 ? a - 97 + 10 : a >= 65 ? a - 65 + 10 : te(a) ? a - 48 : Infinity, u >= i) {
+			if (u <= 9) {
+				if (l) return {
+					n: null,
+					pos: t
+				};
+				c.invalidDigit(t, n, r, i), u = 0;
+			} else if (o) u = 0, p = !0;
+			else break;
+		}
+		++t, m = m * i + u;
+	}
+	return t === u || a != null && t - u !== a || p ? {
+		n: null,
+		pos: t
+	} : {
+		n: m,
+		pos: t
+	};
+}
+function ae(e, t, n, r, i, a) {
+	let o = e.charCodeAt(t), s;
+	if (o === 123) {
+		if (++t, {code: s, pos: t} = ie(e, t, n, r, e.indexOf("}", t) - t, !0, i, a), ++t, s !== null && s > 1114111) {
+			if (i) a.invalidCodePoint(t, n, r);
+			else return {
+				code: null,
+				pos: t
+			};
+		}
+	} else ({code: s, pos: t} = ie(e, t, n, r, 4, !1, i, a));
+	return {
+		code: s,
+		pos: t
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@babel+types@8.0.6/node_modules/@babel/types/lib/index.js
+function y(e, t) {
+	let n = Object.keys(t);
+	for (let r of n) if (e[r] !== t[r]) return !1;
+	return !0;
+}
+function b(e, t, n) {
+	return t?.type === e && (n == null || y(t, n));
+}
+function oe(e, t) {
+	return b("ArrayExpression", e, t);
+}
+function se(e, t) {
+	return b("AssignmentExpression", e, t);
+}
+function ce(e, t) {
+	return b("File", e, t);
+}
+function le(e, t) {
+	return b("FunctionDeclaration", e, t);
+}
+function ue(e, t) {
+	return b("FunctionExpression", e, t);
+}
+function x(e, t) {
+	return b("Identifier", e, t);
+}
+function de(e, t) {
+	return b("StringLiteral", e, t);
+}
+function fe(e, t) {
+	return b("NumericLiteral", e, t);
+}
+function pe(e, t) {
+	return b("MemberExpression", e, t);
+}
+function S(e, t) {
+	return b("ObjectExpression", e, t);
+}
+function C(e, t) {
+	return b("ObjectProperty", e, t);
+}
+function me(e, t) {
+	return b("ThisExpression", e, t);
+}
+function he(e, t) {
+	return b("UnaryExpression", e, t);
+}
+function ge(e, t) {
+	return b("UpdateExpression", e, t);
+}
+function _e(e, t) {
+	return b("ClassExpression", e, t);
+}
+function ve(e, t) {
+	return b("ExportAllDeclaration", e, t);
+}
+function ye(e, t) {
+	return b("ImportNamespaceSpecifier", e, t);
+}
+function be(e, t) {
+	return b("MetaProperty", e, t);
+}
+function xe(e, t) {
+	return b("Super", e, t);
+}
+function Se(e, t) {
+	return b("PrivateName", e, t);
+}
+function Ce(e, t) {
+	if (!e) return !1;
+	switch (e.type) {
+		case "ArrayExpression":
+		case "AssignmentExpression":
+		case "BinaryExpression":
+		case "CallExpression":
+		case "ConditionalExpression":
+		case "FunctionExpression":
+		case "Identifier":
+		case "StringLiteral":
+		case "NumericLiteral":
+		case "NullLiteral":
+		case "BooleanLiteral":
+		case "RegExpLiteral":
+		case "LogicalExpression":
+		case "MemberExpression":
+		case "NewExpression":
+		case "ObjectExpression":
+		case "SequenceExpression":
+		case "ParenthesizedExpression":
+		case "ThisExpression":
+		case "UnaryExpression":
+		case "UpdateExpression":
+		case "ArrowFunctionExpression":
+		case "ClassExpression":
+		case "MetaProperty":
+		case "TaggedTemplateExpression":
+		case "TemplateLiteral":
+		case "YieldExpression":
+		case "AwaitExpression":
+		case "ImportExpression":
+		case "BigIntLiteral":
+		case "OptionalMemberExpression":
+		case "OptionalCallExpression":
+		case "TypeCastExpression":
+		case "JSXElement":
+		case "JSXFragment":
+		case "BindExpression":
+		case "DoExpression":
+		case "ModuleExpression":
+		case "TopicReference":
+		case "TSInstantiationExpression":
+		case "TSAsExpression":
+		case "TSSatisfiesExpression":
+		case "TSTypeAssertion":
+		case "TSNonNullExpression": break;
+		case "Placeholder":
+			switch (e.expectedNode) {
+				case "Expression":
+				case "Identifier":
+				case "StringLiteral": break;
+				default: return !1;
+			}
+			break;
+		default: return !1;
+	}
+	return t == null || y(e, t);
+}
+function we(e, t) {
+	if (!e) return !1;
+	switch (e.type) {
+		case "FunctionDeclaration":
+		case "VariableDeclaration":
+		case "ClassDeclaration":
+		case "ExportAllDeclaration":
+		case "ExportDefaultDeclaration":
+		case "ExportNamedDeclaration":
+		case "ImportDeclaration":
+		case "DeclareClass":
+		case "DeclareFunction":
+		case "DeclareInterface":
+		case "DeclareModule":
+		case "DeclareModuleExports":
+		case "DeclareTypeAlias":
+		case "DeclareOpaqueType":
+		case "DeclareVariable":
+		case "DeclareExportDeclaration":
+		case "DeclareExportAllDeclaration":
+		case "InterfaceDeclaration":
+		case "OpaqueType":
+		case "TypeAlias":
+		case "EnumDeclaration":
+		case "TSDeclareFunction":
+		case "TSInterfaceDeclaration":
+		case "TSTypeAliasDeclaration":
+		case "TSEnumDeclaration":
+		case "TSModuleDeclaration":
+		case "TSImportEqualsDeclaration": break;
+		case "Placeholder": if (e.expectedNode === "Declaration") break;
+		default: return !1;
+	}
+	return t == null || y(e, t);
+}
+function Te(e, t) {
+	if (!e) return !1;
+	switch (e.type) {
+		case "ExportAllDeclaration":
+		case "ExportDefaultDeclaration":
+		case "ExportNamedDeclaration": break;
+		default: return !1;
+	}
+	return t == null || y(e, t);
+}
+function Ee(e) {
+	return pe(e) || be(e);
+}
+function De(e, t, n) {
+	if (!Ee(e)) return !1;
+	let r = Array.isArray(t) ? t : t.split("."), i = [], a;
+	for (a = e; Ee(a); a = a.object ?? a.meta) i.push(a.property);
+	if (i.push(a), i.length < r.length || !n && i.length > r.length) return !1;
+	for (let e = 0, t = i.length - 1; e < r.length; e++, t--) {
+		let n = i[t], a;
+		if (x(n)) a = n.name;
+		else if (de(n)) a = n.value;
+		else if (me(n)) a = "this";
+		else if (xe(n)) a = "super";
+		else if (Se(n)) a = "#" + n.id.name;
+		else return !1;
+		if (r[e] !== a) return !1;
+	}
+	return !0;
+}
+function Oe(e, t) {
+	let n = e.split(".");
+	return (e) => De(e, n, t);
+}
+Oe("React.Component");
+function ke(e, t) {
+	return e === t ? !0 : e == null || We[t] ? !1 : !!T[t]?.includes(e);
+}
+function Ae(e, t) {
+	return !!(e === t || _t[e]?.includes(t));
+}
+function w(e, t, n) {
+	return t ? ke(t.type, e) ? n === void 0 || y(t, n) : !n && t.type === "Placeholder" && e in T && Ae(t.expectedNode, e) : !1;
+}
+function je(e, t = !0) {
+	return typeof e != "string" || t && (ee(e) || m(e, !0)) ? !1 : l(e);
+}
+var Me = [
+	"leadingComments",
+	"trailingComments",
+	"innerComments"
+], Ne = [
+	"||",
+	"&&",
+	"??"
+], Pe = ["++", "--"], Fe = [
+	"==",
+	"===",
+	"!=",
+	"!==",
+	"in",
+	"instanceof",
+	">",
+	"<",
+	">=",
+	"<="
+], Ie = [
+	"-",
+	"/",
+	"%",
+	"*",
+	"**",
+	"&",
+	"|",
+	">>",
+	">>>",
+	"<<",
+	"^"
+], Le = [
+	"+",
+	...Ie,
+	...Fe,
+	"|>"
+], Re = [
+	"=",
+	"+=",
+	...Ie.map((e) => e + "="),
+	...Ne.map((e) => e + "=")
+], ze = ["delete", "!"], Be = [
+	"+",
+	"-",
+	"~"
+], Ve = ["typeof"], He = [
+	"void",
+	"throw",
+	...ze,
+	...Be,
+	...Ve
+], Ue = {}, We = {}, T = {}, Ge = {}, Ke = {}, qe = {}, Je = {}, Ye = {};
+function Xe(e) {
+	return Array.isArray(e) ? "array" : e === null ? "null" : typeof e;
+}
+function E(e, ...t) {
+	return Object.assign(e, ...t);
+}
+function D(e) {
+	return { validate: e };
+}
+function O(...e) {
+	return D(I(...e));
+}
+function k(e) {
+	return {
+		validate: e,
+		optional: !0
+	};
+}
+function A(e, t) {
+	return {
+		validate: e,
+		default: t,
+		optional: !1
+	};
+}
+function j(...e) {
+	return {
+		validate: I(...e),
+		optional: !0
+	};
+}
+function Ze(e) {
+	return R(L("array"), P(e));
+}
+function M(...e) {
+	return Ze(I(...e));
+}
+function N(...e) {
+	return D(M(...e));
+}
+function P(e) {
+	let t = jt;
+	function n(n, r, i) {
+		if (!Array.isArray(i)) return;
+		let a = 0, o = { toString() {
+			return `${r}[${a}]`;
+		} };
+		for (; a < i.length; a++) {
+			let r = i[a];
+			e(n, o, r), t(n, o, r);
+		}
+	}
+	return n.each = e, n;
+}
+function F(...e) {
+	function t(t, n, r) {
+		if (!e.includes(r)) throw TypeError(`Property ${n} expected value to be one of ${JSON.stringify(e)} but got ${JSON.stringify(r)}`);
+	}
+	return t.oneOf = e, t;
+}
+var Qe = [];
+function I(...e) {
+	let t = /* @__PURE__ */ new Set();
+	Qe.push({
+		types: e,
+		set: t
+	});
+	function n(n, r, i) {
+		let a = i?.type;
+		if (a != null) {
+			if (t.has(a)) {
+				jt(n, r, i);
+				return;
+			}
+			if (a === "Placeholder") {
+				for (let t of e) if (w(t, i)) {
+					jt(n, r, i);
+					return;
+				}
+			}
+		}
+		throw TypeError(`Property ${r} of ${n.type} expected node to be of a type ${JSON.stringify(e)} but instead got ${JSON.stringify(a)}`);
+	}
+	return n.oneOfNodeTypes = e, n;
+}
+function $e(...e) {
+	function t(t, n, r) {
+		let i = Xe(r);
+		for (let a of e) if (i === a || w(a, r)) {
+			jt(t, n, r);
+			return;
+		}
+		throw TypeError(`Property ${n} of ${t.type} expected node to be of a type ${JSON.stringify(e)} but instead got ${JSON.stringify(r?.type)}`);
+	}
+	return t.oneOfNodeOrValueTypes = e, t;
+}
+function L(e) {
+	function t(t, n, r) {
+		if (Xe(r) !== e) throw TypeError(`Property ${n} expected type of ${e} but got ${Xe(r)}`);
+	}
+	return t.type = e, t;
+}
+function et(e) {
+	let t = Object.keys(e);
+	function n(n, r, i) {
+		let a = [];
+		for (let r of t) try {
+			At(n, r, i[r], e[r]);
+		} catch (e) {
+			if (e instanceof TypeError) {
+				a.push(e.message);
+				continue;
+			}
+			throw e;
+		}
+		if (a.length) throw TypeError(`Property ${r} of ${n.type} expected to have the following:\n${a.join("\n")}`);
+	}
+	return n.shapeOf = e, n;
+}
+function tt() {
+	function e(e) {
+		let t = e;
+		for (; e;) {
+			let { type: e } = t;
+			if (e === "OptionalCallExpression") {
+				if (t.optional) return;
+				t = t.callee;
+				continue;
+			}
+			if (e === "OptionalMemberExpression") {
+				if (t.optional) return;
+				t = t.object;
+				continue;
+			}
+			break;
+		}
+		throw TypeError(`Non-optional ${e.type} must chain from an optional OptionalMemberExpression or OptionalCallExpression. Found chain from ${t?.type}`);
+	}
+	return e;
+}
+function R(...e) {
+	function t(...t) {
+		for (let n of e) n(...t);
+	}
+	if (t.chainOf = e, e.length >= 2 && "type" in e[0] && e[0].type === "array" && !("each" in e[1])) throw Error("An assertValueType(\"array\") validator can only be followed by an assertEach(...) validator.");
+	return t;
+}
+var nt = /* @__PURE__ */ new Set([
+	"aliases",
+	"builder",
+	"deprecatedAlias",
+	"fields",
+	"inherits",
+	"visitor",
+	"validate",
+	"unionShape"
+]), rt = /* @__PURE__ */ new Set([
+	"default",
+	"optional",
+	"deprecated",
+	"validate"
+]), it = {};
+function z(...e) {
+	return (t, n = {}) => {
+		let r = n.aliases;
+		r || (n.inherits && (r = it[n.inherits].aliases?.slice()), r ??= [], n.aliases = r);
+		let i = e.filter((e) => !r.includes(e));
+		r.unshift(...i), B(t, n);
+	};
+}
+function B(e, t = {}) {
+	let n = t.inherits && it[t.inherits] || {}, r = t.visitor || n.visitor || [], i = t.aliases || n.aliases || [], a = t.builder || n.builder || t.visitor || [], o = t.fields;
+	if (!o && (o = {}, n.fields)) {
+		let e = Object.getOwnPropertyNames(n.fields);
+		for (let t of e) {
+			let e = n.fields[t], r = e.default;
+			if (Array.isArray(r) ? r.length > 0 : r && typeof r == "object") throw Error("field defaults can only be primitives or empty arrays currently");
+			o[t] = {
+				default: Array.isArray(r) ? [] : r,
+				optional: e.optional,
+				deprecated: e.deprecated,
+				validate: e.validate
+			};
+		}
+	}
+	for (let n of Object.keys(t)) if (!nt.has(n)) throw Error(`Unknown type option "${n}" on ${e}`);
+	t.deprecatedAlias && (qe[t.deprecatedAlias] = e);
+	for (let e of r.concat(a)) o[e] = o[e] || {};
+	for (let t of Object.keys(o)) {
+		let n = o[t];
+		n.default === null && (n.optional ??= !0), n.default === void 0 ? (n.default = null, n.optional ??= !1) : !n.validate && n.default != null && (n.validate = L(Xe(n.default)));
+		for (let r of Object.keys(n)) if (!rt.has(r)) throw Error(`Unknown field key "${r}" on ${e}.${t}`);
+	}
+	Ue[e] = t.visitor = r, Ke[e] = t.builder = a, Ge[e] = t.fields = o, We[e] = t.aliases = i, i.forEach((t) => {
+		T[t] = T[t] || [], T[t].push(e);
+	}), t.validate && (Je[e] = t.validate), t.unionShape && (Ye[e] = t.unionShape), it[e] = t;
+}
+var at = /*#__PURE__*/ Object.defineProperty({
+	__proto__: null,
+	ALIAS_KEYS: We,
+	BUILDER_KEYS: Ke,
+	DEPRECATED_KEYS: qe,
+	FLIPPED_ALIAS_KEYS: T,
+	NODE_FIELDS: Ge,
+	NODE_PARENT_VALIDATIONS: Je,
+	NODE_UNION_SHAPES__PRIVATE: Ye,
+	VISITOR_KEYS: Ue,
+	allExpandedTypes: Qe,
+	arrayOf: Ze,
+	arrayOfType: M,
+	assertEach: P,
+	assertNodeOrValueType: $e,
+	assertNodeType: I,
+	assertOneOf: F,
+	assertOptionalChainStart: tt,
+	assertShape: et,
+	assertValueType: L,
+	chain: R,
+	combine: E,
+	default: B,
+	defineAliasedType: z,
+	validate: D,
+	validateArrayOfType: N,
+	validateDefault: A,
+	validateOptional: k,
+	validateOptionalType: j,
+	validateType: O
+}, Symbol.toStringTag, { value: "Module" }), V = (e = !1) => ({ unionShape: {
+	discriminator: "computed",
+	shapes: [{
+		name: "computed",
+		value: [!0],
+		properties: { key: { validate: I("Expression") } }
+	}, {
+		name: "nonComputed",
+		value: [!1],
+		properties: { key: { validate: e ? I("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "PrivateName") : I("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral") } }
+	}]
+} }), ot = { unionShape: {
+	discriminator: "computed",
+	shapes: [{
+		name: "computed",
+		value: [!0],
+		properties: { property: { validate: I("Expression") } }
+	}, {
+		name: "nonComputed",
+		value: [!1],
+		properties: { property: { validate: I("Identifier", "PrivateName") } }
+	}]
+} }, H = z("Standardized");
+H("ArrayExpression", {
+	fields: { elements: {
+		validate: Ze($e("null", "Expression", "SpreadElement")),
+		default: void 0
+	} },
+	visitor: ["elements"],
+	aliases: ["Expression"]
+}), H("AssignmentExpression", {
+	fields: {
+		operator: { validate: E(function() {
+			let e = F(...Re), t = F("=");
+			return function(n, r, i) {
+				(w("Pattern", n.left) ? t : e)(n, r, i);
+			};
+		}(), { oneOf: Re }) },
+		left: { validate: I("Identifier", "MemberExpression", "OptionalMemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression") },
+		right: { validate: I("Expression") }
+	},
+	builder: [
+		"operator",
+		"left",
+		"right"
+	],
+	visitor: ["left", "right"],
+	aliases: ["Expression"]
+}), H("BinaryExpression", {
+	builder: [
+		"operator",
+		"left",
+		"right"
+	],
+	fields: {
+		operator: { validate: F(...Le) },
+		left: { validate: function() {
+			let e = I("Expression"), t = I("Expression", "PrivateName");
+			return E(function(n, r, i) {
+				(n.operator === "in" ? t : e)(n, r, i);
+			}, { oneOfNodeTypes: ["Expression", "PrivateName"] });
+		}() },
+		right: { validate: I("Expression") }
+	},
+	unionShape: {
+		discriminator: "operator",
+		shapes: [{
+			name: "in",
+			value: ["in"],
+			properties: { left: { validate: I("Expression", "PrivateName") } }
+		}, {
+			name: "notIn",
+			value: Le.filter((e) => e !== "in"),
+			properties: { left: { validate: I("Expression") } }
+		}]
+	},
+	visitor: ["left", "right"],
+	aliases: ["Binary", "Expression"]
+}), H("InterpreterDirective", {
+	builder: ["value"],
+	fields: { value: { validate: L("string") } }
+}), H("Directive", {
+	visitor: ["value"],
+	fields: { value: { validate: I("DirectiveLiteral") } }
+}), H("DirectiveLiteral", {
+	builder: ["value"],
+	fields: { value: { validate: L("string") } }
+}), H("BlockStatement", {
+	builder: ["body", "directives"],
+	visitor: ["directives", "body"],
+	fields: {
+		directives: {
+			validate: M("Directive"),
+			default: []
+		},
+		body: N("Statement")
+	},
+	aliases: [
+		"Scopable",
+		"BlockParent",
+		"Block",
+		"Statement"
+	]
+}), H("BreakStatement", {
+	visitor: ["label"],
+	fields: { label: {
+		validate: I("Identifier"),
+		optional: !0
+	} },
+	aliases: [
+		"Statement",
+		"Terminatorless",
+		"CompletionStatement"
+	]
+}), H("CallExpression", {
+	visitor: [
+		"callee",
+		"typeArguments",
+		"arguments"
+	],
+	builder: ["callee", "arguments"],
+	aliases: ["Expression"],
+	fields: {
+		callee: { validate: I("Expression", "Super", "Import", "V8IntrinsicIdentifier") },
+		arguments: N("Expression", "SpreadElement", "ArgumentPlaceholder"),
+		typeArguments: {
+			validate: I("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
+			optional: !0
+		}
+	}
+}), H("CatchClause", {
+	visitor: ["param", "body"],
+	fields: {
+		param: {
+			validate: I("Identifier", "ArrayPattern", "ObjectPattern"),
+			optional: !0
+		},
+		body: { validate: I("BlockStatement") }
+	},
+	aliases: ["Scopable", "BlockParent"]
+}), H("ConditionalExpression", {
+	visitor: [
+		"test",
+		"consequent",
+		"alternate"
+	],
+	fields: {
+		test: { validate: I("Expression") },
+		consequent: { validate: I("Expression") },
+		alternate: { validate: I("Expression") }
+	},
+	aliases: ["Expression", "Conditional"]
+}), H("ContinueStatement", {
+	visitor: ["label"],
+	fields: { label: {
+		validate: I("Identifier"),
+		optional: !0
+	} },
+	aliases: [
+		"Statement",
+		"Terminatorless",
+		"CompletionStatement"
+	]
+}), H("DebuggerStatement", { aliases: ["Statement"] }), H("DoWhileStatement", {
+	builder: ["test", "body"],
+	visitor: ["body", "test"],
+	fields: {
+		test: { validate: I("Expression") },
+		body: { validate: I("Statement") }
+	},
+	aliases: [
+		"Statement",
+		"BlockParent",
+		"Loop",
+		"While",
+		"Scopable"
+	]
+}), H("EmptyStatement", { aliases: ["Statement"] }), H("ExpressionStatement", {
+	visitor: ["expression"],
+	fields: { expression: { validate: I("Expression") } },
+	aliases: ["Statement", "ExpressionWrapper"]
+}), H("File", {
+	builder: [
+		"program",
+		"comments",
+		"tokens"
+	],
+	visitor: ["program"],
+	fields: {
+		program: { validate: I("Program") },
+		comments: {
+			validate: P(I("CommentBlock", "CommentLine")),
+			optional: !0
+		},
+		tokens: {
+			validate: P(Object.assign(() => {}, { type: "any" })),
+			optional: !0
+		}
+	}
+}), H("ForInStatement", {
+	visitor: [
+		"left",
+		"right",
+		"body"
+	],
+	aliases: [
+		"Scopable",
+		"Statement",
+		"For",
+		"BlockParent",
+		"Loop",
+		"ForXStatement"
+	],
+	fields: {
+		left: { validate: I("VariableDeclaration", "Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression") },
+		right: { validate: I("Expression") },
+		body: { validate: I("Statement") }
+	}
+}), H("ForStatement", {
+	visitor: [
+		"init",
+		"test",
+		"update",
+		"body"
+	],
+	aliases: [
+		"Scopable",
+		"Statement",
+		"For",
+		"BlockParent",
+		"Loop"
+	],
+	fields: {
+		init: {
+			validate: I("VariableDeclaration", "Expression"),
+			optional: !0
+		},
+		test: {
+			validate: I("Expression"),
+			optional: !0
+		},
+		update: {
+			validate: I("Expression"),
+			optional: !0
+		},
+		body: { validate: I("Statement") }
+	}
+});
+var st = () => ({
+	params: N("FunctionParameter"),
+	generator: { default: !1 },
+	async: { default: !1 }
+}), ct = () => ({
+	returnType: {
+		validate: I("TypeAnnotation", "TSTypeAnnotation"),
+		optional: !0
+	},
+	typeParameters: {
+		validate: I("TypeParameterDeclaration", "TSTypeParameterDeclaration"),
+		optional: !0
+	}
+}), lt = () => ({
+	...st(),
+	declare: {
+		validate: L("boolean"),
+		optional: !0
+	},
+	id: {
+		validate: I("Identifier"),
+		optional: !0
+	}
+});
+H("FunctionDeclaration", {
+	builder: [
+		"id",
+		"params",
+		"body",
+		"generator",
+		"async"
+	],
+	visitor: [
+		"id",
+		"typeParameters",
+		"params",
+		"predicate",
+		"returnType",
+		"body"
+	],
+	fields: {
+		...lt(),
+		...ct(),
+		body: { validate: I("BlockStatement") },
+		predicate: {
+			validate: I("FlowPredicate"),
+			optional: !0
+		}
+	},
+	aliases: [
+		"Scopable",
+		"Function",
+		"BlockParent",
+		"FunctionParent",
+		"Statement",
+		"Pureish",
+		"Declaration"
+	],
+	validate: function() {
+		let e = I("Identifier");
+		return function(t, n, r) {
+			w("ExportDefaultDeclaration", t) || e(r, "id", r.id);
+		};
+	}()
+}), H("FunctionExpression", {
+	inherits: "FunctionDeclaration",
+	aliases: [
+		"Scopable",
+		"Function",
+		"BlockParent",
+		"FunctionParent",
+		"Expression",
+		"Pureish"
+	],
+	fields: {
+		...st(),
+		...ct(),
+		id: {
+			validate: I("Identifier"),
+			optional: !0
+		},
+		body: { validate: I("BlockStatement") },
+		predicate: {
+			validate: I("FlowPredicate"),
+			optional: !0
+		}
+	}
+});
+var ut = () => ({
+	typeAnnotation: {
+		validate: I("TypeAnnotation", "TSTypeAnnotation"),
+		optional: !0
+	},
+	optional: {
+		validate: L("boolean"),
+		optional: !0
+	},
+	decorators: {
+		validate: M("Decorator"),
+		optional: !0
+	}
+});
+H("Identifier", {
+	builder: ["name"],
+	visitor: ["typeAnnotation", "decorators"],
+	aliases: [
+		"Expression",
+		"FunctionParameter",
+		"PatternLike",
+		"LVal",
+		"TSEntityName"
+	],
+	fields: {
+		...ut(),
+		name: { validate: R(L("string"), E(function(e, t, n) {
+			if (!je(n, !1)) throw TypeError(`"${n}" is not a valid identifier name`);
+		}, { type: "string" })) }
+	},
+	validate: function(e, t, n) {
+		let r = /\.(\w+)$/.exec(t.toString());
+		if (!r) return;
+		let [, i] = r, a = { computed: !1 };
+		if (i === "property") {
+			if (w("MemberExpression", e, a) || w("OptionalMemberExpression", e, a)) return;
+		} else if (i === "key") {
+			if (w("Property", e, a) || w("Method", e, a)) return;
+		} else if (i === "exported") {
+			if (w("ExportSpecifier", e)) return;
+		} else if (i === "imported") {
+			if (w("ImportSpecifier", e, { imported: n })) return;
+		} else if (i === "meta" && w("MetaProperty", e, { meta: n })) return;
+		if ((ee(n.name) || p(n.name, !1)) && n.name !== "this") throw TypeError(`"${n.name}" is not a valid identifier`);
+	}
+}), H("IfStatement", {
+	visitor: [
+		"test",
+		"consequent",
+		"alternate"
+	],
+	aliases: ["Statement", "Conditional"],
+	fields: {
+		test: { validate: I("Expression") },
+		consequent: { validate: I("Statement") },
+		alternate: {
+			optional: !0,
+			validate: I("Statement")
+		}
+	}
+}), H("LabeledStatement", {
+	visitor: ["label", "body"],
+	aliases: ["Statement"],
+	fields: {
+		label: { validate: I("Identifier") },
+		body: { validate: I("Statement") }
+	}
+}), H("StringLiteral", {
+	builder: ["value"],
+	fields: { value: { validate: L("string") } },
+	aliases: [
+		"Expression",
+		"Pureish",
+		"Literal",
+		"Immutable"
+	]
+}), H("NumericLiteral", {
+	builder: ["value"],
+	deprecatedAlias: "NumberLiteral",
+	fields: { value: { validate: R(L("number"), E(function(e, t, n) {
+		if (1 / n < 0 || !Number.isFinite(n)) {
+			let e = /* @__PURE__ */ Error(`NumericLiterals must be non-negative finite numbers. You can use t.valueToNode(${n}) instead.`);
+			if (!(/* @__PURE__ */ Error()).stack.includes("regenerator")) throw e;
+		}
+	}, { type: "number" })) } },
+	aliases: [
+		"Expression",
+		"Pureish",
+		"Literal",
+		"Immutable"
+	]
+}), H("NullLiteral", { aliases: [
+	"Expression",
+	"Pureish",
+	"Literal",
+	"Immutable"
+] }), H("BooleanLiteral", {
+	builder: ["value"],
+	fields: { value: { validate: L("boolean") } },
+	aliases: [
+		"Expression",
+		"Pureish",
+		"Literal",
+		"Immutable"
+	]
+}), H("RegExpLiteral", {
+	builder: ["pattern", "flags"],
+	deprecatedAlias: "RegexLiteral",
+	aliases: [
+		"Expression",
+		"Pureish",
+		"Literal"
+	],
+	fields: {
+		pattern: { validate: L("string") },
+		flags: {
+			validate: R(L("string"), E(function(e, t, n) {
+				let r = /[^dgimsuvy]/.exec(n);
+				if (r) throw TypeError(`"${r[0]}" is not a valid RegExp flag`);
+			}, { type: "string" })),
+			default: ""
+		}
+	}
+}), H("LogicalExpression", {
+	builder: [
+		"operator",
+		"left",
+		"right"
+	],
+	visitor: ["left", "right"],
+	aliases: ["Binary", "Expression"],
+	fields: {
+		operator: { validate: F(...Ne) },
+		left: { validate: I("Expression") },
+		right: { validate: I("Expression") }
+	}
+}), H("MemberExpression", {
+	builder: [
+		"object",
+		"property",
+		"computed"
+	],
+	visitor: ["object", "property"],
+	aliases: [
+		"Expression",
+		"LVal",
+		"PatternLike"
+	],
+	...ot,
+	fields: {
+		object: { validate: I("Expression", "Super") },
+		property: { validate: function() {
+			let e = I("Identifier", "PrivateName"), t = I("Expression");
+			return E(function(n, r, i) {
+				(n.computed ? t : e)(n, r, i);
+			}, { oneOfNodeTypes: [
+				"Expression",
+				"Identifier",
+				"PrivateName"
+			] });
+		}() },
+		computed: { default: !1 }
+	}
+}), H("NewExpression", {
+	inherits: "CallExpression",
+	fields: {
+		callee: { validate: I("Expression", "V8IntrinsicIdentifier") },
+		arguments: N("Expression", "SpreadElement", "ArgumentPlaceholder"),
+		typeArguments: {
+			validate: I("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
+			optional: !0
+		}
+	}
+}), H("Program", {
+	visitor: ["directives", "body"],
+	builder: [
+		"body",
+		"directives",
+		"sourceType",
+		"interpreter"
+	],
+	fields: {
+		sourceType: {
+			validate: F("script", "module"),
+			default: "script"
+		},
+		interpreter: {
+			validate: I("InterpreterDirective"),
+			default: null,
+			optional: !0
+		},
+		directives: {
+			validate: M("Directive"),
+			default: []
+		},
+		body: N("Statement")
+	},
+	aliases: [
+		"Scopable",
+		"BlockParent",
+		"Block"
+	]
+}), H("ObjectExpression", {
+	visitor: ["properties"],
+	aliases: ["Expression"],
+	fields: { properties: N("ObjectMethod", "ObjectProperty", "SpreadElement") }
+}), H("ObjectMethod", {
+	builder: [
+		"kind",
+		"key",
+		"params",
+		"body",
+		"computed",
+		"generator",
+		"async"
+	],
+	visitor: [
+		"decorators",
+		"key",
+		"typeParameters",
+		"params",
+		"returnType",
+		"body"
+	],
+	...V(),
+	fields: {
+		...st(),
+		...ct(),
+		kind: { validate: F("method", "get", "set") },
+		computed: { default: !1 },
+		key: { validate: function() {
+			let e = I("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral"), t = I("Expression");
+			return E(function(n, r, i) {
+				(n.computed ? t : e)(n, r, i);
+			}, { oneOfNodeTypes: [
+				"Expression",
+				"Identifier",
+				"StringLiteral",
+				"NumericLiteral",
+				"BigIntLiteral"
+			] });
+		}() },
+		decorators: {
+			validate: M("Decorator"),
+			optional: !0
+		},
+		body: { validate: I("BlockStatement") }
+	},
+	aliases: [
+		"UserWhitespacable",
+		"Function",
+		"Scopable",
+		"BlockParent",
+		"FunctionParent",
+		"Method",
+		"ObjectMember"
+	]
+}), H("ObjectProperty", {
+	builder: [
+		"key",
+		"value",
+		"computed",
+		"shorthand"
+	],
+	...V(!0),
+	fields: {
+		computed: { default: !1 },
+		key: { validate: function() {
+			let e = I("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "PrivateName"), t = I("Expression");
+			return E(function(n, r, i) {
+				(n.computed ? t : e)(n, r, i);
+			}, { oneOfNodeTypes: [
+				"Expression",
+				"Identifier",
+				"StringLiteral",
+				"NumericLiteral",
+				"BigIntLiteral",
+				"PrivateName"
+			] });
+		}() },
+		value: { validate: I("Expression", "PatternLike") },
+		shorthand: {
+			validate: R(L("boolean"), E(function(e, t, n) {
+				if (n) {
+					if (e.computed) throw TypeError("Property shorthand of ObjectProperty cannot be true if computed is true");
+					if (!w("Identifier", e.key)) throw TypeError("Property shorthand of ObjectProperty cannot be true if key is not an Identifier");
+				}
+			}, { type: "boolean" })),
+			default: !1
+		},
+		decorators: {
+			validate: M("Decorator"),
+			optional: !0
+		}
+	},
+	visitor: [
+		"decorators",
+		"key",
+		"value"
+	],
+	aliases: [
+		"UserWhitespacable",
+		"Property",
+		"ObjectMember"
+	],
+	validate: function() {
+		let e = I("Identifier", "Pattern", "TSAsExpression", "TSSatisfiesExpression", "TSNonNullExpression", "TSTypeAssertion"), t = I("Expression");
+		return function(n, r, i) {
+			(w("ObjectPattern", n) ? e : t)(i, "value", i.value);
+		};
+	}()
+}), H("RestElement", {
+	visitor: ["argument", "typeAnnotation"],
+	builder: ["argument"],
+	aliases: ["FunctionParameter", "PatternLike"],
+	deprecatedAlias: "RestProperty",
+	fields: {
+		...ut(),
+		argument: { validate: I("Identifier", "ArrayPattern", "ObjectPattern", "MemberExpression", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression") }
+	},
+	validate: function(e, t) {
+		let n = /(\w+)\[(\d+)\]/.exec(t.toString());
+		if (!n) throw Error("Internal Babel error: malformed key.");
+		let [, r, i] = n;
+		if (e[r].length > +i + 1) throw TypeError(`RestElement must be last element of ${r}`);
+	}
+}), H("ReturnStatement", {
+	visitor: ["argument"],
+	aliases: [
+		"Statement",
+		"Terminatorless",
+		"CompletionStatement"
+	],
+	fields: { argument: {
+		validate: I("Expression"),
+		optional: !0
+	} }
+}), H("SequenceExpression", {
+	visitor: ["expressions"],
+	fields: { expressions: N("Expression") },
+	aliases: ["Expression"]
+}), H("ParenthesizedExpression", {
+	visitor: ["expression"],
+	aliases: ["Expression", "ExpressionWrapper"],
+	fields: { expression: { validate: I("Expression") } }
+}), H("SwitchCase", {
+	visitor: ["test", "consequent"],
+	fields: {
+		test: {
+			validate: I("Expression"),
+			optional: !0
+		},
+		consequent: N("Statement")
+	}
+}), H("SwitchStatement", {
+	visitor: ["discriminant", "cases"],
+	aliases: [
+		"Statement",
+		"BlockParent",
+		"Scopable"
+	],
+	fields: {
+		discriminant: { validate: I("Expression") },
+		cases: N("SwitchCase")
+	}
+}), H("ThisExpression", { aliases: ["Expression", "TSEntityName"] }), H("ThrowStatement", {
+	visitor: ["argument"],
+	aliases: [
+		"Statement",
+		"Terminatorless",
+		"CompletionStatement"
+	],
+	fields: { argument: { validate: I("Expression") } }
+}), H("TryStatement", {
+	visitor: [
+		"block",
+		"handler",
+		"finalizer"
+	],
+	aliases: ["Statement"],
+	fields: {
+		block: { validate: R(I("BlockStatement"), E(function(e) {
+			if (!e.handler && !e.finalizer) throw TypeError("TryStatement expects either a handler or finalizer, or both");
+		}, { oneOfNodeTypes: ["BlockStatement"] })) },
+		handler: {
+			optional: !0,
+			validate: I("CatchClause")
+		},
+		finalizer: {
+			optional: !0,
+			validate: I("BlockStatement")
+		}
+	}
+}), H("UnaryExpression", {
+	builder: [
+		"operator",
+		"argument",
+		"prefix"
+	],
+	fields: {
+		prefix: { default: !0 },
+		argument: { validate: I("Expression") },
+		operator: { validate: F(...He) }
+	},
+	visitor: ["argument"],
+	aliases: ["UnaryLike", "Expression"]
+}), H("UpdateExpression", {
+	builder: [
+		"operator",
+		"argument",
+		"prefix"
+	],
+	fields: {
+		prefix: { default: !1 },
+		argument: { validate: I("Identifier", "MemberExpression") },
+		operator: { validate: F(...Pe) }
+	},
+	visitor: ["argument"],
+	aliases: ["Expression"]
+}), H("VariableDeclaration", {
+	builder: ["kind", "declarations"],
+	visitor: ["declarations"],
+	aliases: ["Statement", "Declaration"],
+	fields: {
+		declare: {
+			validate: L("boolean"),
+			optional: !0
+		},
+		kind: { validate: F("var", "let", "const", "using", "await using") },
+		declarations: N("VariableDeclarator")
+	},
+	validate: (() => {
+		let e = I("Identifier", "Placeholder"), t = I("Identifier", "ArrayPattern", "ObjectPattern", "Placeholder"), n = I("Identifier", "VoidPattern", "Placeholder");
+		return function(r, i, a) {
+			let { kind: o, declarations: s } = a, c = w("ForXStatement", r, { left: a });
+			if (c && s.length !== 1) throw TypeError(`Exactly one VariableDeclarator is required in the VariableDeclaration of a ${r.type}`);
+			for (let r of s) o === "const" || o === "let" || o === "var" ? !c && !r.init ? e(r, "id", r.id) : t(r, "id", r.id) : n(r, "id", r.id);
+		};
+	})()
+}), H("VariableDeclarator", {
+	visitor: ["id", "init"],
+	fields: {
+		id: { validate: I("Identifier", "ArrayPattern", "ObjectPattern", "VoidPattern") },
+		definite: {
+			optional: !0,
+			validate: L("boolean")
+		},
+		init: {
+			optional: !0,
+			validate: I("Expression")
+		}
+	}
+}), H("WhileStatement", {
+	visitor: ["test", "body"],
+	aliases: [
+		"Statement",
+		"BlockParent",
+		"Loop",
+		"While",
+		"Scopable"
+	],
+	fields: {
+		test: { validate: I("Expression") },
+		body: { validate: I("Statement") }
+	}
+}), H("WithStatement", {
+	visitor: ["object", "body"],
+	aliases: ["Statement"],
+	fields: {
+		object: { validate: I("Expression") },
+		body: { validate: I("Statement") }
+	}
+}), H("AssignmentPattern", {
+	visitor: [
+		"left",
+		"right",
+		"decorators"
+	],
+	builder: ["left", "right"],
+	aliases: [
+		"FunctionParameter",
+		"Pattern",
+		"PatternLike"
+	],
+	fields: {
+		...ut(),
+		left: { validate: I("Identifier", "ObjectPattern", "ArrayPattern", "MemberExpression", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression") },
+		right: { validate: I("Expression") }
+	}
+}), H("ArrayPattern", {
+	visitor: ["elements", "typeAnnotation"],
+	builder: ["elements"],
+	aliases: [
+		"FunctionParameter",
+		"Pattern",
+		"PatternLike",
+		"LVal"
+	],
+	fields: {
+		...ut(),
+		elements: { validate: R(L("array"), P($e("null", "PatternLike"))) }
+	}
+}), H("ArrowFunctionExpression", {
+	builder: [
+		"params",
+		"body",
+		"async"
+	],
+	visitor: [
+		"typeParameters",
+		"params",
+		"predicate",
+		"returnType",
+		"body"
+	],
+	aliases: [
+		"Scopable",
+		"Function",
+		"BlockParent",
+		"FunctionParent",
+		"Expression",
+		"Pureish"
+	],
+	fields: {
+		...st(),
+		generator: {
+			default: null,
+			optional: !0,
+			validate: E((e, t, n) => {
+				if (n) throw TypeError("ArrowFunctionExpression cannot be a generator");
+			}, { type: "boolean" })
+		},
+		...ct(),
+		expression: {
+			optional: !0,
+			validate: L("boolean")
+		},
+		body: { validate: I("BlockStatement", "Expression") },
+		predicate: {
+			validate: I("FlowPredicate"),
+			optional: !0
+		}
+	}
+}), H("ClassBody", {
+	visitor: ["body"],
+	fields: { body: N("ClassMethod", "ClassPrivateMethod", "ClassProperty", "ClassPrivateProperty", "ClassAccessorProperty", "TSDeclareMethod", "TSIndexSignature", "StaticBlock") }
+}), H("ClassExpression", {
+	builder: [
+		"id",
+		"superClass",
+		"body",
+		"decorators"
+	],
+	visitor: [
+		"decorators",
+		"id",
+		"typeParameters",
+		"superClass",
+		"superTypeArguments",
+		"mixins",
+		"implements",
+		"body"
+	],
+	aliases: [
+		"Scopable",
+		"Class",
+		"Expression"
+	],
+	fields: {
+		id: {
+			validate: I("Identifier"),
+			optional: !0
+		},
+		typeParameters: {
+			validate: I("TypeParameterDeclaration", "TSTypeParameterDeclaration"),
+			optional: !0
+		},
+		body: { validate: I("ClassBody") },
+		superClass: {
+			optional: !0,
+			validate: I("Expression")
+		},
+		superTypeArguments: {
+			validate: I("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
+			optional: !0
+		},
+		implements: {
+			validate: M("TSClassImplements", "ClassImplements"),
+			optional: !0
+		},
+		decorators: {
+			validate: M("Decorator"),
+			optional: !0
+		},
+		mixins: {
+			validate: I("InterfaceExtends"),
+			optional: !0
+		}
+	}
+}), H("ClassDeclaration", {
+	inherits: "ClassExpression",
+	aliases: [
+		"Scopable",
+		"Class",
+		"Statement",
+		"Declaration"
+	],
+	fields: {
+		id: {
+			validate: I("Identifier"),
+			optional: !0
+		},
+		typeParameters: {
+			validate: I("TypeParameterDeclaration", "TSTypeParameterDeclaration"),
+			optional: !0
+		},
+		body: { validate: I("ClassBody") },
+		superClass: {
+			optional: !0,
+			validate: I("Expression")
+		},
+		superTypeArguments: {
+			validate: I("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
+			optional: !0
+		},
+		implements: {
+			validate: M("TSClassImplements", "ClassImplements"),
+			optional: !0
+		},
+		decorators: {
+			validate: M("Decorator"),
+			optional: !0
+		},
+		mixins: {
+			validate: I("InterfaceExtends"),
+			optional: !0
+		},
+		declare: {
+			validate: L("boolean"),
+			optional: !0
+		},
+		abstract: {
+			validate: L("boolean"),
+			optional: !0
+		}
+	},
+	validate: function() {
+		let e = I("Identifier");
+		return function(t, n, r) {
+			w("ExportDefaultDeclaration", t) || e(r, "id", r.id);
+		};
+	}()
+});
+var dt = { attributes: {
+	optional: !0,
+	validate: M("ImportAttribute")
+} };
+H("ExportAllDeclaration", {
+	visitor: ["source", "attributes"],
+	aliases: [
+		"Statement",
+		"Declaration",
+		"ImportOrExportDeclaration",
+		"ExportDeclaration"
+	],
+	fields: {
+		source: { validate: I("StringLiteral") },
+		exportKind: k(F("type", "value")),
+		...dt
+	}
+}), H("ExportDefaultDeclaration", {
+	visitor: ["declaration"],
+	aliases: [
+		"Statement",
+		"Declaration",
+		"ImportOrExportDeclaration",
+		"ExportDeclaration"
+	],
+	fields: {
+		declaration: O("FunctionDeclaration", "ClassDeclaration", "Expression", "TSDeclareFunction", "TSInterfaceDeclaration", "EnumDeclaration"),
+		exportKind: k(F("value"))
+	}
+}), H("ExportNamedDeclaration", {
+	builder: [
+		"declaration",
+		"specifiers",
+		"source",
+		"attributes"
+	],
+	visitor: [
+		"declaration",
+		"specifiers",
+		"source",
+		"attributes"
+	],
+	aliases: [
+		"Statement",
+		"Declaration",
+		"ImportOrExportDeclaration",
+		"ExportDeclaration"
+	],
+	fields: {
+		declaration: {
+			optional: !0,
+			validate: R(I("Declaration"), E(function(e, t, n) {
+				if (n && e.specifiers.length) throw TypeError("Only declaration or specifiers is allowed on ExportNamedDeclaration");
+				if (n && e.source) throw TypeError("Cannot export a declaration from a source");
+			}, { oneOfNodeTypes: [
+				"VariableDeclaration",
+				"FunctionDeclaration",
+				"ClassDeclaration",
+				"TSDeclareFunction",
+				"TSEnumDeclaration",
+				"TSImportEqualsDeclaration",
+				"TSInterfaceDeclaration",
+				"TSModuleDeclaration",
+				"TSTypeAliasDeclaration",
+				"EnumDeclaration",
+				"InterfaceDeclaration",
+				"OpaqueType",
+				"TypeAlias"
+			] }))
+		},
+		...dt,
+		specifiers: {
+			default: [],
+			validate: Ze(function() {
+				let e = I("ExportSpecifier", "ExportDefaultSpecifier", "ExportNamespaceSpecifier"), t = I("ExportSpecifier");
+				return E(function(n, r, i) {
+					(n.source ? e : t)(n, r, i);
+				}, { oneOfNodeTypes: [
+					"ExportSpecifier",
+					"ExportDefaultSpecifier",
+					"ExportNamespaceSpecifier"
+				] });
+			}())
+		},
+		source: {
+			validate: I("StringLiteral"),
+			optional: !0
+		},
+		exportKind: k(F("type", "value"))
+	}
+}), H("ExportSpecifier", {
+	visitor: ["local", "exported"],
+	aliases: ["ModuleSpecifier"],
+	fields: {
+		local: { validate: I("Identifier", "StringLiteral") },
+		exported: { validate: I("Identifier", "StringLiteral") },
+		exportKind: {
+			validate: F("type", "value"),
+			optional: !0
+		}
+	}
+}), H("ForOfStatement", {
+	visitor: [
+		"left",
+		"right",
+		"body"
+	],
+	builder: [
+		"left",
+		"right",
+		"body",
+		"await"
+	],
+	aliases: [
+		"Scopable",
+		"Statement",
+		"For",
+		"BlockParent",
+		"Loop",
+		"ForXStatement"
+	],
+	fields: {
+		left: { validate: function() {
+			let e = I("VariableDeclaration"), t = I("Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern", "TSAsExpression", "TSSatisfiesExpression", "TSTypeAssertion", "TSNonNullExpression");
+			return E(function(n, r, i) {
+				w("VariableDeclaration", i) ? e(n, r, i) : t(n, r, i);
+			}, { oneOfNodeTypes: [
+				"VariableDeclaration",
+				"Identifier",
+				"MemberExpression",
+				"ArrayPattern",
+				"ObjectPattern",
+				"TSAsExpression",
+				"TSSatisfiesExpression",
+				"TSTypeAssertion",
+				"TSNonNullExpression"
+			] });
+		}() },
+		right: { validate: I("Expression") },
+		body: { validate: I("Statement") },
+		await: { default: !1 }
+	}
+}), H("ImportDeclaration", {
+	builder: [
+		"specifiers",
+		"source",
+		"attributes"
+	],
+	visitor: [
+		"specifiers",
+		"source",
+		"attributes"
+	],
+	aliases: [
+		"Statement",
+		"Declaration",
+		"ImportOrExportDeclaration"
+	],
+	fields: {
+		...dt,
+		module: {
+			optional: !0,
+			validate: L("boolean")
+		},
+		phase: {
+			default: null,
+			validate: F("source", "defer")
+		},
+		specifiers: N("ImportSpecifier", "ImportDefaultSpecifier", "ImportNamespaceSpecifier"),
+		source: { validate: I("StringLiteral") },
+		importKind: {
+			validate: F("type", "typeof", "value"),
+			optional: !0
+		}
+	}
+}), H("ImportDefaultSpecifier", {
+	visitor: ["local"],
+	aliases: ["ModuleSpecifier"],
+	fields: { local: { validate: I("Identifier") } }
+}), H("ImportNamespaceSpecifier", {
+	visitor: ["local"],
+	aliases: ["ModuleSpecifier"],
+	fields: { local: { validate: I("Identifier") } }
+}), H("ImportSpecifier", {
+	visitor: ["imported", "local"],
+	builder: ["local", "imported"],
+	aliases: ["ModuleSpecifier"],
+	fields: {
+		local: { validate: I("Identifier") },
+		imported: { validate: I("Identifier", "StringLiteral") },
+		importKind: {
+			validate: F("type", "typeof", "value"),
+			optional: !0
+		}
+	}
+}), H("MetaProperty", {
+	visitor: ["meta", "property"],
+	aliases: ["Expression"],
+	fields: {
+		meta: { validate: R(I("Identifier"), E(function(e, t, n) {
+			let r;
+			switch (n.name) {
+				case "function":
+					r = "sent";
+					break;
+				case "new":
+					r = "target";
+					break;
+				case "import": r = "meta";
+			}
+			if (!w("Identifier", e.property, { name: r })) throw TypeError("Unrecognised MetaProperty");
+		}, { oneOfNodeTypes: ["Identifier"] })) },
+		property: { validate: I("Identifier") }
+	}
+});
+var ft = () => ({
+	abstract: {
+		validate: L("boolean"),
+		default: !1,
+		optional: !0
+	},
+	accessibility: {
+		validate: F("public", "private", "protected"),
+		optional: !0
+	},
+	static: { default: !1 },
+	override: {
+		optional: !0,
+		validate: L("boolean"),
+		default: !1
+	},
+	computed: { default: !1 },
+	optional: {
+		validate: L("boolean"),
+		optional: !0
+	},
+	key: { validate: R(function() {
+		let e = I("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral"), t = I("Expression", "PrivateName");
+		return function(n, r, i) {
+			(n.computed ? t : e)(n, r, i);
+		};
+	}(), I("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "Expression", "PrivateName")) }
+}), pt = (e = !0) => ({
+	...st(),
+	...ft(),
+	params: N("FunctionParameter", "TSParameterProperty"),
+	kind: {
+		validate: F("get", "set", "method", "constructor"),
+		default: "method"
+	},
+	access: {
+		validate: R(L("string"), F("public", "private", "protected")),
+		optional: !0
+	},
+	...e ? { decorators: {
+		validate: M("Decorator"),
+		optional: !0
+	} } : {}
+});
+H("ClassMethod", {
+	aliases: [
+		"Function",
+		"Scopable",
+		"BlockParent",
+		"FunctionParent",
+		"Method"
+	],
+	builder: [
+		"kind",
+		"key",
+		"params",
+		"body",
+		"computed",
+		"static",
+		"generator",
+		"async"
+	],
+	visitor: [
+		"decorators",
+		"key",
+		"typeParameters",
+		"params",
+		"returnType",
+		"body"
+	],
+	...V(),
+	fields: {
+		...pt(),
+		...ct(),
+		body: { validate: I("BlockStatement") }
+	}
+}), H("ObjectPattern", {
+	visitor: [
+		"decorators",
+		"properties",
+		"typeAnnotation"
+	],
+	builder: ["properties"],
+	aliases: [
+		"FunctionParameter",
+		"Pattern",
+		"PatternLike",
+		"LVal"
+	],
+	fields: {
+		...ut(),
+		properties: N("RestElement", "ObjectProperty")
+	}
+}), H("SpreadElement", {
+	visitor: ["argument"],
+	aliases: ["UnaryLike"],
+	deprecatedAlias: "SpreadProperty",
+	fields: { argument: { validate: I("Expression") } }
+}), H("Super"), H("TaggedTemplateExpression", {
+	visitor: [
+		"tag",
+		"typeArguments",
+		"quasi"
+	],
+	builder: ["tag", "quasi"],
+	aliases: ["Expression"],
+	fields: {
+		tag: { validate: I("Expression") },
+		quasi: { validate: I("TemplateLiteral") },
+		typeArguments: {
+			validate: I("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
+			optional: !0
+		}
+	}
+}), H("TemplateElement", {
+	builder: ["value", "tail"],
+	fields: {
+		value: { validate: R(et({
+			raw: { validate: L("string") },
+			cooked: {
+				validate: L("string"),
+				optional: !0
+			}
+		}), function(e) {
+			let t = e.value.raw, n = !1, r = () => {
+				throw Error("Internal @babel/types error.");
+			}, { str: i, firstInvalidLoc: a } = g("template", t, 0, 0, 0, {
+				unterminated() {
+					n = !0;
+				},
+				strictNumericEscape: r,
+				invalidEscapeSequence: r,
+				numericSeparatorInEscapeSequence: r,
+				unexpectedNumericSeparator: r,
+				invalidDigit: r,
+				invalidCodePoint: r
+			});
+			if (!n) throw Error("Invalid raw");
+			e.value.cooked = a ? null : i;
+		}) },
+		tail: { default: !1 }
+	}
+}), H("TemplateLiteral", {
+	visitor: ["quasis", "expressions"],
+	aliases: ["Expression", "Literal"],
+	fields: {
+		quasis: N("TemplateElement"),
+		expressions: { validate: R(L("array"), P(I("Expression", "TSType")), function(e, t, n) {
+			if (e.quasis.length !== n.length + 1) throw TypeError(`Number of ${e.type} quasis should be exactly one more than the number of expressions.\nExpected ${n.length + 1} quasis but got ${e.quasis.length}`);
+		}) }
+	}
+}), H("YieldExpression", {
+	builder: ["argument", "delegate"],
+	visitor: ["argument"],
+	aliases: ["Expression", "Terminatorless"],
+	fields: {
+		delegate: {
+			validate: R(L("boolean"), E(function(e, t, n) {
+				if (n && !e.argument) throw TypeError("Property delegate of YieldExpression cannot be true if there is no argument");
+			}, { type: "boolean" })),
+			default: !1
+		},
+		argument: {
+			optional: !0,
+			validate: I("Expression")
+		}
+	}
+}), H("AwaitExpression", {
+	builder: ["argument"],
+	visitor: ["argument"],
+	aliases: ["Expression", "Terminatorless"],
+	fields: { argument: { validate: I("Expression") } }
+}), H("ImportExpression", {
+	visitor: ["source", "options"],
+	aliases: ["Expression"],
+	fields: {
+		phase: {
+			default: null,
+			validate: F("source", "defer")
+		},
+		source: { validate: I("Expression") },
+		options: {
+			validate: I("Expression"),
+			optional: !0
+		}
+	}
+}), H("Import"), H("BigIntLiteral", {
+	builder: ["value"],
+	fields: { value: { validate: L("bigint") } },
+	aliases: [
+		"Expression",
+		"Pureish",
+		"Literal",
+		"Immutable"
+	]
+}), H("ExportNamespaceSpecifier", {
+	visitor: ["exported"],
+	aliases: ["ModuleSpecifier"],
+	fields: { exported: { validate: I("Identifier", "StringLiteral") } }
+}), H("OptionalMemberExpression", {
+	builder: [
+		"object",
+		"property",
+		"computed",
+		"optional"
+	],
+	visitor: ["object", "property"],
+	aliases: ["Expression"],
+	...ot,
+	fields: {
+		object: { validate: I("Expression") },
+		property: { validate: function() {
+			let e = I("Identifier", "PrivateName"), t = I("Expression");
+			return E(function(n, r, i) {
+				(n.computed ? t : e)(n, r, i);
+			}, { oneOfNodeTypes: ["Expression", "PrivateName"] });
+		}() },
+		computed: { default: !1 },
+		optional: { validate: R(L("boolean"), tt()) }
+	}
+}), H("OptionalCallExpression", {
+	visitor: [
+		"callee",
+		"typeArguments",
+		"arguments"
+	],
+	builder: [
+		"callee",
+		"arguments",
+		"optional"
+	],
+	aliases: ["Expression"],
+	fields: {
+		callee: { validate: I("Expression") },
+		arguments: N("Expression", "SpreadElement", "ArgumentPlaceholder"),
+		optional: { validate: R(L("boolean"), tt()) },
+		typeArguments: {
+			validate: I("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
+			optional: !0
+		}
+	}
+}), H("ClassProperty", {
+	visitor: [
+		"decorators",
+		"variance",
+		"key",
+		"typeAnnotation",
+		"value"
+	],
+	builder: [
+		"key",
+		"value",
+		"typeAnnotation",
+		"decorators",
+		"computed",
+		"static"
+	],
+	aliases: ["Property"],
+	...V(),
+	fields: {
+		...ft(),
+		value: {
+			validate: I("Expression"),
+			optional: !0
+		},
+		definite: {
+			validate: L("boolean"),
+			optional: !0
+		},
+		typeAnnotation: {
+			validate: I("TypeAnnotation", "TSTypeAnnotation"),
+			optional: !0
+		},
+		decorators: {
+			validate: M("Decorator"),
+			optional: !0
+		},
+		readonly: {
+			validate: L("boolean"),
+			optional: !0
+		},
+		declare: {
+			validate: L("boolean"),
+			optional: !0
+		},
+		variance: {
+			validate: I("Variance"),
+			optional: !0
+		}
+	}
+}), H("ClassPrivateProperty", {
+	visitor: [
+		"decorators",
+		"variance",
+		"key",
+		"typeAnnotation",
+		"value"
+	],
+	builder: [
+		"key",
+		"value",
+		"decorators",
+		"static"
+	],
+	aliases: ["Property", "Private"],
+	fields: {
+		key: { validate: I("PrivateName") },
+		value: {
+			validate: I("Expression"),
+			optional: !0
+		},
+		typeAnnotation: {
+			validate: I("TypeAnnotation", "TSTypeAnnotation"),
+			optional: !0
+		},
+		decorators: {
+			validate: M("Decorator"),
+			optional: !0
+		},
+		static: {
+			validate: L("boolean"),
+			default: !1
+		},
+		readonly: {
+			validate: L("boolean"),
+			optional: !0
+		},
+		optional: {
+			validate: L("boolean"),
+			optional: !0
+		},
+		definite: {
+			validate: L("boolean"),
+			optional: !0
+		},
+		variance: {
+			validate: I("Variance"),
+			optional: !0
+		}
+	}
+}), H("ClassPrivateMethod", {
+	builder: [
+		"kind",
+		"key",
+		"params",
+		"body",
+		"static"
+	],
+	visitor: [
+		"decorators",
+		"key",
+		"typeParameters",
+		"params",
+		"returnType",
+		"body"
+	],
+	aliases: [
+		"Function",
+		"Scopable",
+		"BlockParent",
+		"FunctionParent",
+		"Method",
+		"Private"
+	],
+	fields: {
+		...pt(),
+		...ct(),
+		kind: {
+			validate: F("get", "set", "method"),
+			default: "method"
+		},
+		key: { validate: I("PrivateName") },
+		body: { validate: I("BlockStatement") }
+	}
+}), H("PrivateName", {
+	visitor: ["id"],
+	aliases: ["Private"],
+	fields: { id: { validate: I("Identifier") } }
+}), H("StaticBlock", {
+	visitor: ["body"],
+	fields: { body: N("Statement") },
+	aliases: [
+		"Scopable",
+		"BlockParent",
+		"FunctionParent"
+	]
+}), H("ImportAttribute", {
+	visitor: ["key", "value"],
+	fields: {
+		key: { validate: I("Identifier", "StringLiteral") },
+		value: { validate: I("StringLiteral") }
+	}
+});
+var U = z("Flow"), mt = (e) => {
+	let t = e === "DeclareClass";
+	U(e, {
+		builder: [
+			"id",
+			"typeParameters",
+			"extends",
+			"body"
+		],
+		visitor: [
+			"id",
+			"typeParameters",
+			"extends",
+			...t ? ["mixins", "implements"] : [],
+			"body"
+		],
+		aliases: [
+			"FlowDeclaration",
+			"Statement",
+			"Declaration"
+		],
+		fields: {
+			id: O("Identifier"),
+			typeParameters: j("TypeParameterDeclaration"),
+			extends: k(M("InterfaceExtends")),
+			...t ? {
+				mixins: k(M("InterfaceExtends")),
+				implements: k(M("ClassImplements"))
+			} : {},
+			body: O("ObjectTypeAnnotation")
+		}
+	});
+};
+U("AnyTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }), U("ArrayTypeAnnotation", {
+	visitor: ["elementType"],
+	aliases: ["FlowType"],
+	fields: { elementType: O("FlowType") }
+}), U("BooleanTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }), U("BooleanLiteralTypeAnnotation", {
+	builder: ["value"],
+	aliases: ["FlowType"],
+	fields: { value: D(L("boolean")) }
+}), U("NullLiteralTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }), U("ClassImplements", {
+	visitor: ["id", "typeParameters"],
+	fields: {
+		id: O("Identifier"),
+		typeParameters: j("TypeParameterInstantiation")
+	}
+}), mt("DeclareClass"), U("DeclareFunction", {
+	builder: ["id"],
+	visitor: ["id", "predicate"],
+	aliases: [
+		"FlowDeclaration",
+		"Statement",
+		"Declaration"
+	],
+	fields: {
+		id: O("Identifier"),
+		predicate: j("FlowPredicate")
+	}
+}), mt("DeclareInterface"), U("DeclareModule", {
+	builder: [
+		"id",
+		"body",
+		"kind"
+	],
+	visitor: ["id", "body"],
+	aliases: [
+		"FlowDeclaration",
+		"Statement",
+		"Declaration"
+	],
+	fields: {
+		id: O("Identifier", "StringLiteral"),
+		body: O("BlockStatement"),
+		kind: k(F("CommonJS", "ES"))
+	}
+}), U("DeclareModuleExports", {
+	visitor: ["typeAnnotation"],
+	aliases: [
+		"FlowDeclaration",
+		"Statement",
+		"Declaration"
+	],
+	fields: { typeAnnotation: O("TypeAnnotation") }
+}), U("DeclareTypeAlias", {
+	visitor: [
+		"id",
+		"typeParameters",
+		"right"
+	],
+	aliases: [
+		"FlowDeclaration",
+		"Statement",
+		"Declaration"
+	],
+	fields: {
+		id: O("Identifier"),
+		typeParameters: j("TypeParameterDeclaration"),
+		right: O("FlowType")
+	}
+}), U("DeclareOpaqueType", {
+	visitor: [
+		"id",
+		"typeParameters",
+		"supertype"
+	],
+	aliases: [
+		"FlowDeclaration",
+		"Statement",
+		"Declaration"
+	],
+	fields: {
+		id: O("Identifier"),
+		typeParameters: j("TypeParameterDeclaration"),
+		supertype: j("FlowType"),
+		impltype: j("FlowType")
+	}
+}), U("DeclareVariable", {
+	visitor: ["id"],
+	aliases: [
+		"FlowDeclaration",
+		"Statement",
+		"Declaration"
+	],
+	fields: { id: O("Identifier") }
+}), U("DeclareExportDeclaration", {
+	visitor: [
+		"declaration",
+		"specifiers",
+		"source",
+		"attributes"
+	],
+	aliases: [
+		"FlowDeclaration",
+		"Statement",
+		"Declaration"
+	],
+	fields: {
+		declaration: j("Flow"),
+		specifiers: k(M("ExportSpecifier", "ExportNamespaceSpecifier")),
+		source: j("StringLiteral"),
+		default: k(L("boolean")),
+		...dt
+	}
+}), U("DeclareExportAllDeclaration", {
+	visitor: ["source", "attributes"],
+	aliases: [
+		"FlowDeclaration",
+		"Statement",
+		"Declaration"
+	],
+	fields: {
+		source: O("StringLiteral"),
+		exportKind: k(F("type", "value")),
+		...dt
+	}
+}), U("DeclaredPredicate", {
+	visitor: ["value"],
+	aliases: ["FlowPredicate"],
+	fields: { value: O("Expression") }
+}), U("ExistsTypeAnnotation", { aliases: ["FlowType"] }), U("FunctionTypeAnnotation", {
+	builder: [
+		"typeParameters",
+		"params",
+		"rest",
+		"returnType"
+	],
+	visitor: [
+		"typeParameters",
+		"this",
+		"params",
+		"rest",
+		"returnType"
+	],
+	aliases: ["FlowType"],
+	fields: {
+		typeParameters: j("TypeParameterDeclaration"),
+		params: N("FunctionTypeParam"),
+		rest: j("FunctionTypeParam"),
+		this: j("FunctionTypeParam"),
+		returnType: O("FlowType")
+	}
+}), U("FunctionTypeParam", {
+	visitor: ["name", "typeAnnotation"],
+	fields: {
+		name: j("Identifier"),
+		typeAnnotation: O("FlowType"),
+		optional: k(L("boolean"))
+	}
+}), U("GenericTypeAnnotation", {
+	visitor: ["id", "typeParameters"],
+	aliases: ["FlowType"],
+	fields: {
+		id: O("Identifier", "QualifiedTypeIdentifier"),
+		typeParameters: j("TypeParameterInstantiation")
+	}
+}), U("InferredPredicate", { aliases: ["FlowPredicate"] }), U("InterfaceExtends", {
+	visitor: ["id", "typeParameters"],
+	fields: {
+		id: O("Identifier", "QualifiedTypeIdentifier"),
+		typeParameters: j("TypeParameterInstantiation")
+	}
+}), mt("InterfaceDeclaration"), U("InterfaceTypeAnnotation", {
+	visitor: ["extends", "body"],
+	aliases: ["FlowType"],
+	fields: {
+		extends: k(M("InterfaceExtends")),
+		body: O("ObjectTypeAnnotation")
+	}
+}), U("IntersectionTypeAnnotation", {
+	visitor: ["types"],
+	aliases: ["FlowType"],
+	fields: { types: D(M("FlowType")) }
+}), U("MixedTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }), U("EmptyTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }), U("NullableTypeAnnotation", {
+	visitor: ["typeAnnotation"],
+	aliases: ["FlowType"],
+	fields: { typeAnnotation: O("FlowType") }
+}), U("NumberLiteralTypeAnnotation", {
+	builder: ["value"],
+	aliases: ["FlowType"],
+	fields: { value: D(L("number")) }
+}), U("BigIntLiteralTypeAnnotation", {
+	builder: ["value"],
+	aliases: ["FlowType"],
+	fields: { value: D(L("bigint")) }
+}), U("NumberTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }), U("ObjectTypeAnnotation", {
+	visitor: [
+		"properties",
+		"indexers",
+		"callProperties",
+		"internalSlots"
+	],
+	aliases: ["FlowType"],
+	builder: [
+		"properties",
+		"indexers",
+		"callProperties",
+		"internalSlots",
+		"exact"
+	],
+	fields: {
+		properties: D(M("ObjectTypeProperty", "ObjectTypeSpreadProperty")),
+		indexers: {
+			validate: M("ObjectTypeIndexer"),
+			optional: !1,
+			default: []
+		},
+		callProperties: {
+			validate: M("ObjectTypeCallProperty"),
+			optional: !1,
+			default: []
+		},
+		internalSlots: {
+			validate: M("ObjectTypeInternalSlot"),
+			optional: !1,
+			default: []
+		},
+		exact: {
+			validate: L("boolean"),
+			default: !1
+		},
+		inexact: k(L("boolean"))
+	}
+}), U("ObjectTypeInternalSlot", {
+	visitor: ["id", "value"],
+	builder: [
+		"id",
+		"value",
+		"optional",
+		"static",
+		"method"
+	],
+	aliases: ["UserWhitespacable"],
+	fields: {
+		id: O("Identifier"),
+		value: O("FlowType"),
+		optional: D(L("boolean")),
+		static: D(L("boolean")),
+		method: D(L("boolean"))
+	}
+}), U("ObjectTypeCallProperty", {
+	visitor: ["value"],
+	aliases: ["UserWhitespacable"],
+	fields: {
+		value: O("FlowType"),
+		static: A(L("boolean"), !1)
+	}
+}), U("ObjectTypeIndexer", {
+	visitor: [
+		"variance",
+		"id",
+		"key",
+		"value"
+	],
+	builder: [
+		"id",
+		"key",
+		"value",
+		"variance"
+	],
+	aliases: ["UserWhitespacable"],
+	fields: {
+		id: j("Identifier"),
+		key: O("FlowType"),
+		value: O("FlowType"),
+		static: A(L("boolean"), !1),
+		variance: j("Variance")
+	}
+}), U("ObjectTypeProperty", {
+	visitor: [
+		"key",
+		"value",
+		"variance"
+	],
+	aliases: ["UserWhitespacable"],
+	fields: {
+		key: O("Identifier", "StringLiteral", "NumericLiteral"),
+		value: O("FlowType"),
+		kind: {
+			validate: F("init", "get", "set"),
+			default: "init",
+			optional: !1
+		},
+		static: A(L("boolean"), !1),
+		proto: A(L("boolean"), !1),
+		optional: A(L("boolean"), !1),
+		variance: j("Variance"),
+		method: A(L("boolean"), !1)
+	}
+}), U("ObjectTypeSpreadProperty", {
+	visitor: ["argument"],
+	aliases: ["UserWhitespacable"],
+	fields: { argument: O("FlowType") }
+}), U("OpaqueType", {
+	visitor: [
+		"id",
+		"typeParameters",
+		"supertype",
+		"impltype"
+	],
+	aliases: [
+		"FlowDeclaration",
+		"Statement",
+		"Declaration"
+	],
+	fields: {
+		id: O("Identifier"),
+		typeParameters: j("TypeParameterDeclaration"),
+		supertype: j("FlowType"),
+		impltype: O("FlowType")
+	}
+}), U("QualifiedTypeIdentifier", {
+	visitor: ["qualification", "id"],
+	builder: ["id", "qualification"],
+	fields: {
+		id: O("Identifier"),
+		qualification: O("Identifier", "QualifiedTypeIdentifier")
+	}
+}), U("StringLiteralTypeAnnotation", {
+	builder: ["value"],
+	aliases: ["FlowType"],
+	fields: { value: D(L("string")) }
+}), U("StringTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }), U("SymbolTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }), U("ThisTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }), U("TupleTypeAnnotation", {
+	visitor: ["types"],
+	aliases: ["FlowType"],
+	fields: { types: D(M("FlowType")) }
+}), U("TypeofTypeAnnotation", {
+	visitor: ["argument"],
+	aliases: ["FlowType"],
+	fields: { argument: O("FlowType", "Identifier") }
+}), U("TypeAlias", {
+	visitor: [
+		"id",
+		"typeParameters",
+		"right"
+	],
+	aliases: [
+		"FlowDeclaration",
+		"Statement",
+		"Declaration"
+	],
+	fields: {
+		id: O("Identifier"),
+		typeParameters: j("TypeParameterDeclaration"),
+		right: O("FlowType")
+	}
+}), U("TypeAnnotation", {
+	visitor: ["typeAnnotation"],
+	fields: { typeAnnotation: O("FlowType", "Identifier") }
+}), U("TypeCastExpression", {
+	visitor: ["expression", "typeAnnotation"],
+	aliases: ["ExpressionWrapper", "Expression"],
+	fields: {
+		expression: O("Expression"),
+		typeAnnotation: O("TypeAnnotation")
+	}
+}), U("TypeParameter", {
+	builder: [
+		"name",
+		"bound",
+		"default",
+		"variance"
+	],
+	visitor: [
+		"bound",
+		"default",
+		"variance"
+	],
+	fields: {
+		name: D(L("string")),
+		bound: j("TypeAnnotation"),
+		default: j("FlowType"),
+		variance: j("Variance")
+	}
+}), U("TypeParameterDeclaration", {
+	visitor: ["params"],
+	fields: { params: D(M("TypeParameter")) }
+}), U("TypeParameterInstantiation", {
+	visitor: ["params"],
+	fields: { params: D(M("FlowType")) }
+}), U("UnionTypeAnnotation", {
+	visitor: ["types"],
+	aliases: ["FlowType"],
+	fields: { types: D(M("FlowType")) }
+}), U("Variance", {
+	builder: ["kind"],
+	fields: { kind: D(F("minus", "plus")) }
+}), U("VoidTypeAnnotation", { aliases: ["FlowType", "FlowBaseAnnotation"] }), U("EnumDeclaration", {
+	aliases: ["Statement", "Declaration"],
+	visitor: ["id", "body"],
+	fields: {
+		id: O("Identifier"),
+		body: O("EnumBooleanBody", "EnumNumberBody", "EnumStringBody", "EnumSymbolBody")
+	}
+});
+var ht = {
+	explicitType: A(L("boolean"), !1),
+	hasUnknownMembers: A(L("boolean"), !1)
+};
+U("EnumBooleanBody", {
+	aliases: ["EnumBody"],
+	visitor: ["members"],
+	fields: {
+		...ht,
+		members: N("EnumBooleanMember")
+	}
+}), U("EnumNumberBody", {
+	aliases: ["EnumBody"],
+	visitor: ["members"],
+	fields: {
+		...ht,
+		members: N("EnumNumberMember")
+	}
+}), U("EnumStringBody", {
+	aliases: ["EnumBody"],
+	visitor: ["members"],
+	fields: {
+		...ht,
+		members: N("EnumStringMember", "EnumDefaultedMember")
+	}
+}), U("EnumSymbolBody", {
+	aliases: ["EnumBody"],
+	visitor: ["members"],
+	fields: {
+		members: N("EnumDefaultedMember"),
+		hasUnknownMembers: A(L("boolean"), !1)
+	}
+}), U("EnumBooleanMember", {
+	aliases: ["EnumMember"],
+	visitor: ["id", "init"],
+	fields: {
+		id: O("Identifier"),
+		init: O("BooleanLiteral")
+	}
+}), U("EnumNumberMember", {
+	aliases: ["EnumMember"],
+	visitor: ["id", "init"],
+	fields: {
+		id: O("Identifier"),
+		init: O("NumericLiteral")
+	}
+}), U("EnumStringMember", {
+	aliases: ["EnumMember"],
+	visitor: ["id", "init"],
+	fields: {
+		id: O("Identifier"),
+		init: O("StringLiteral")
+	}
+}), U("EnumDefaultedMember", {
+	aliases: ["EnumMember"],
+	visitor: ["id"],
+	fields: { id: O("Identifier") }
+}), U("IndexedAccessType", {
+	visitor: ["objectType", "indexType"],
+	aliases: ["FlowType"],
+	fields: {
+		objectType: O("FlowType"),
+		indexType: O("FlowType")
+	}
+}), U("OptionalIndexedAccessType", {
+	visitor: ["objectType", "indexType"],
+	aliases: ["FlowType"],
+	fields: {
+		objectType: O("FlowType"),
+		indexType: O("FlowType"),
+		optional: A(L("boolean"), !1)
+	}
+});
+var W = z("JSX");
+W("JSXAttribute", {
+	visitor: ["name", "value"],
+	aliases: ["Immutable"],
+	fields: {
+		name: { validate: I("JSXIdentifier", "JSXNamespacedName") },
+		value: {
+			optional: !0,
+			validate: I("JSXElement", "JSXFragment", "StringLiteral", "JSXExpressionContainer")
+		}
+	}
+}), W("JSXClosingElement", {
+	visitor: ["name"],
+	aliases: ["Immutable"],
+	fields: { name: { validate: I("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName") } }
+}), W("JSXElement", {
+	builder: [
+		"openingElement",
+		"closingElement",
+		"children"
+	],
+	visitor: [
+		"openingElement",
+		"children",
+		"closingElement"
+	],
+	aliases: ["Immutable", "Expression"],
+	fields: {
+		openingElement: { validate: I("JSXOpeningElement") },
+		closingElement: {
+			optional: !0,
+			validate: I("JSXClosingElement")
+		},
+		children: N("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment")
+	}
+}), W("JSXEmptyExpression", {}), W("JSXExpressionContainer", {
+	visitor: ["expression"],
+	aliases: ["Immutable"],
+	fields: { expression: { validate: I("Expression", "JSXEmptyExpression") } }
+}), W("JSXSpreadChild", {
+	visitor: ["expression"],
+	aliases: ["Immutable"],
+	fields: { expression: { validate: I("Expression") } }
+}), W("JSXIdentifier", {
+	builder: ["name"],
+	fields: { name: { validate: L("string") } }
+}), W("JSXMemberExpression", {
+	visitor: ["object", "property"],
+	fields: {
+		object: { validate: I("JSXMemberExpression", "JSXIdentifier") },
+		property: { validate: I("JSXIdentifier") }
+	}
+}), W("JSXNamespacedName", {
+	visitor: ["namespace", "name"],
+	fields: {
+		namespace: { validate: I("JSXIdentifier") },
+		name: { validate: I("JSXIdentifier") }
+	}
+}), W("JSXOpeningElement", {
+	builder: [
+		"name",
+		"attributes",
+		"selfClosing"
+	],
+	visitor: [
+		"name",
+		"typeArguments",
+		"attributes"
+	],
+	aliases: ["Immutable"],
+	fields: {
+		name: { validate: I("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName") },
+		selfClosing: { default: !1 },
+		attributes: N("JSXAttribute", "JSXSpreadAttribute"),
+		typeArguments: {
+			validate: I("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
+			optional: !0
+		}
+	}
+}), W("JSXSpreadAttribute", {
+	visitor: ["argument"],
+	fields: { argument: { validate: I("Expression") } }
+}), W("JSXText", {
+	aliases: ["Immutable"],
+	builder: ["value"],
+	fields: { value: { validate: L("string") } }
+}), W("JSXFragment", {
+	builder: [
+		"openingFragment",
+		"closingFragment",
+		"children"
+	],
+	visitor: [
+		"openingFragment",
+		"children",
+		"closingFragment"
+	],
+	aliases: ["Immutable", "Expression"],
+	fields: {
+		openingFragment: { validate: I("JSXOpeningFragment") },
+		closingFragment: { validate: I("JSXClosingFragment") },
+		children: N("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment")
+	}
+}), W("JSXOpeningFragment", { aliases: ["Immutable"] }), W("JSXClosingFragment", { aliases: ["Immutable"] });
+var gt = [
+	"Identifier",
+	"StringLiteral",
+	"Expression",
+	"Statement",
+	"Declaration",
+	"BlockStatement",
+	"ClassBody",
+	"Pattern"
+], _t = {
+	Declaration: ["Statement"],
+	Pattern: ["PatternLike", "LVal"]
+};
+for (let e of gt) {
+	let t = We[e];
+	t?.length && (_t[e] = t);
+}
+var vt = {};
+Object.keys(_t).forEach((e) => {
+	_t[e].forEach((t) => {
+		Object.hasOwn(vt, t) || (vt[t] = []), vt[t].push(e);
+	});
+});
+var yt = z("Miscellaneous");
+yt("Placeholder", {
+	visitor: [],
+	builder: ["expectedNode", "name"],
+	fields: {
+		name: { validate: I("Identifier") },
+		expectedNode: { validate: F(...gt) },
+		...ut()
+	}
+}), yt("V8IntrinsicIdentifier", {
+	builder: ["name"],
+	fields: { name: { validate: L("string") } }
+}), B("ArgumentPlaceholder", {}), B("BindExpression", {
+	visitor: ["object", "callee"],
+	aliases: ["Expression"],
+	fields: {
+		object: { validate: $e("null", "Expression") },
+		callee: { validate: I("Expression") }
+	}
+}), B("ClassAccessorProperty", {
+	visitor: [
+		"decorators",
+		"key",
+		"typeAnnotation",
+		"value"
+	],
+	builder: [
+		"key",
+		"value",
+		"typeAnnotation",
+		"decorators",
+		"computed",
+		"static"
+	],
+	aliases: ["Property", "Accessor"],
+	...V(!0),
+	fields: {
+		...ft(),
+		key: { validate: R(function() {
+			let e = I("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "PrivateName"), t = I("Expression");
+			return function(n, r, i) {
+				(n.computed ? t : e)(n, r, i);
+			};
+		}(), I("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "Expression", "PrivateName")) },
+		value: {
+			validate: I("Expression"),
+			optional: !0
+		},
+		definite: {
+			validate: L("boolean"),
+			optional: !0
+		},
+		typeAnnotation: {
+			validate: I("TypeAnnotation", "TSTypeAnnotation"),
+			optional: !0
+		},
+		decorators: {
+			validate: M("Decorator"),
+			optional: !0
+		},
+		readonly: {
+			validate: L("boolean"),
+			optional: !0
+		},
+		declare: {
+			validate: L("boolean"),
+			optional: !0
+		},
+		variance: {
+			validate: I("Variance"),
+			optional: !0
+		}
+	}
+}), B("Decorator", {
+	visitor: ["expression"],
+	fields: { expression: { validate: I("Expression") } }
+}), B("DoExpression", {
+	visitor: ["body"],
+	builder: ["body", "async"],
+	aliases: ["Expression"],
+	fields: {
+		body: { validate: I("BlockStatement") },
+		async: {
+			validate: L("boolean"),
+			default: !1
+		}
+	}
+}), B("ExportDefaultSpecifier", {
+	visitor: ["exported"],
+	aliases: ["ModuleSpecifier"],
+	fields: { exported: { validate: I("Identifier") } }
+}), B("ModuleExpression", {
+	visitor: ["body"],
+	fields: { body: { validate: I("Program") } },
+	aliases: ["Expression"]
+}), B("TopicReference", { aliases: ["Expression"] }), B("VoidPattern", { aliases: [
+	"Pattern",
+	"PatternLike",
+	"FunctionParameter"
+] });
+var G = z("TypeScript"), K = L("boolean"), bt = () => ({
+	returnType: {
+		validate: I("TSTypeAnnotation"),
+		optional: !0
+	},
+	typeParameters: {
+		validate: I("TSTypeParameterDeclaration"),
+		optional: !0
+	}
+});
+G("TSParameterProperty", {
+	aliases: [],
+	visitor: ["parameter"],
+	fields: {
+		accessibility: {
+			validate: F("public", "private", "protected"),
+			optional: !0
+		},
+		readonly: {
+			validate: L("boolean"),
+			optional: !0
+		},
+		parameter: { validate: I("Identifier", "AssignmentPattern") },
+		override: {
+			validate: L("boolean"),
+			optional: !0
+		},
+		decorators: {
+			validate: M("Decorator"),
+			optional: !0
+		}
+	}
+}), G("TSDeclareFunction", {
+	aliases: ["Statement", "Declaration"],
+	visitor: [
+		"id",
+		"typeParameters",
+		"params",
+		"returnType"
+	],
+	fields: {
+		...lt(),
+		...bt()
+	}
+}), G("TSDeclareMethod", {
+	visitor: [
+		"key",
+		"typeParameters",
+		"params",
+		"returnType"
+	],
+	...V(!0),
+	fields: {
+		...pt(!1),
+		...bt()
+	}
+}), G("TSQualifiedName", {
+	aliases: ["TSEntityName"],
+	visitor: ["left", "right"],
+	fields: {
+		left: O("TSEntityName"),
+		right: O("Identifier")
+	}
+});
+var xt = () => ({
+	typeParameters: j("TSTypeParameterDeclaration"),
+	params: N("ArrayPattern", "Identifier", "ObjectPattern", "RestElement"),
+	returnType: j("TSTypeAnnotation")
+}), St = {
+	aliases: ["TSTypeElement"],
+	visitor: [
+		"typeParameters",
+		"params",
+		"returnType"
+	],
+	fields: xt()
+};
+G("TSCallSignatureDeclaration", St), G("TSConstructSignatureDeclaration", St);
+var Ct = () => ({
+	key: O("Expression"),
+	computed: { default: !1 },
+	optional: k(K)
+});
+G("TSPropertySignature", {
+	aliases: ["TSTypeElement"],
+	visitor: ["key", "typeAnnotation"],
+	fields: {
+		...Ct(),
+		readonly: k(K),
+		typeAnnotation: j("TSTypeAnnotation"),
+		kind: {
+			optional: !0,
+			validate: F("get", "set")
+		}
+	}
+}), G("TSMethodSignature", {
+	aliases: ["TSTypeElement"],
+	visitor: [
+		"key",
+		"typeParameters",
+		"params",
+		"returnType"
+	],
+	fields: {
+		...xt(),
+		...Ct(),
+		kind: {
+			validate: F("method", "get", "set"),
+			default: "method"
+		}
+	}
+}), G("TSIndexSignature", {
+	aliases: ["TSTypeElement"],
+	visitor: ["parameters", "typeAnnotation"],
+	fields: {
+		readonly: k(K),
+		static: k(K),
+		parameters: N("Identifier"),
+		typeAnnotation: j("TSTypeAnnotation")
+	}
+});
+for (let e of [
+	"TSAnyKeyword",
+	"TSBooleanKeyword",
+	"TSBigIntKeyword",
+	"TSIntrinsicKeyword",
+	"TSNeverKeyword",
+	"TSNullKeyword",
+	"TSNumberKeyword",
+	"TSObjectKeyword",
+	"TSStringKeyword",
+	"TSSymbolKeyword",
+	"TSUndefinedKeyword",
+	"TSUnknownKeyword",
+	"TSVoidKeyword"
+]) G(e, {
+	aliases: ["TSType", "TSBaseType"],
+	visitor: [],
+	fields: {}
+});
+G("TSThisType", {
+	aliases: ["TSType", "TSBaseType"],
+	visitor: [],
+	fields: {}
+});
+var wt = {
+	aliases: ["TSType"],
+	visitor: [
+		"typeParameters",
+		"params",
+		"returnType"
+	]
+};
+G("TSFunctionType", {
+	...wt,
+	fields: xt()
+}), G("TSConstructorType", {
+	...wt,
+	fields: {
+		...xt(),
+		abstract: k(K)
+	}
+}), G("TSTypeReference", {
+	aliases: ["TSType"],
+	visitor: ["typeName", "typeArguments"],
+	fields: {
+		typeName: O("TSEntityName"),
+		typeArguments: j("TSTypeParameterInstantiation")
+	}
+}), G("TSTypePredicate", {
+	aliases: ["TSType"],
+	visitor: ["parameterName", "typeAnnotation"],
+	builder: [
+		"parameterName",
+		"typeAnnotation",
+		"asserts"
+	],
+	fields: {
+		parameterName: O("Identifier", "TSThisType"),
+		typeAnnotation: j("TSTypeAnnotation"),
+		asserts: k(K)
+	}
+}), G("TSTypeQuery", {
+	aliases: ["TSType"],
+	visitor: ["exprName", "typeArguments"],
+	fields: {
+		exprName: O("TSEntityName", "TSImportType"),
+		typeArguments: j("TSTypeParameterInstantiation")
+	}
+}), G("TSTypeLiteral", {
+	aliases: ["TSType"],
+	visitor: ["members"],
+	fields: { members: N("TSTypeElement") }
+}), G("TSArrayType", {
+	aliases: ["TSType"],
+	visitor: ["elementType"],
+	fields: { elementType: O("TSType") }
+}), G("TSTupleType", {
+	aliases: ["TSType"],
+	visitor: ["elementTypes"],
+	fields: { elementTypes: N("TSType", "TSNamedTupleMember") }
+}), G("TSOptionalType", {
+	aliases: ["TSType"],
+	visitor: ["typeAnnotation"],
+	fields: { typeAnnotation: O("TSType") }
+}), G("TSRestType", {
+	aliases: ["TSType"],
+	visitor: ["typeAnnotation"],
+	fields: { typeAnnotation: O("TSType") }
+}), G("TSNamedTupleMember", {
+	aliases: ["TSType"],
+	visitor: ["label", "elementType"],
+	builder: [
+		"label",
+		"elementType",
+		"optional"
+	],
+	fields: {
+		label: O("Identifier"),
+		optional: {
+			validate: K,
+			default: !1
+		},
+		elementType: O("TSType")
+	}
+});
+var Tt = {
+	aliases: ["TSType"],
+	visitor: ["types"],
+	fields: { types: N("TSType") }
+};
+G("TSUnionType", Tt), G("TSIntersectionType", Tt), G("TSConditionalType", {
+	aliases: ["TSType"],
+	visitor: [
+		"checkType",
+		"extendsType",
+		"trueType",
+		"falseType"
+	],
+	fields: {
+		checkType: O("TSType"),
+		extendsType: O("TSType"),
+		trueType: O("TSType"),
+		falseType: O("TSType")
+	}
+}), G("TSInferType", {
+	aliases: ["TSType"],
+	visitor: ["typeParameter"],
+	fields: { typeParameter: O("TSTypeParameter") }
+}), G("TSParenthesizedType", {
+	aliases: ["TSType"],
+	visitor: ["typeAnnotation"],
+	fields: { typeAnnotation: O("TSType") }
+}), G("TSTypeOperator", {
+	aliases: ["TSType"],
+	visitor: ["typeAnnotation"],
+	builder: ["typeAnnotation", "operator"],
+	fields: {
+		operator: {
+			validate: F("keyof", "readonly", "unique"),
+			default: void 0
+		},
+		typeAnnotation: O("TSType")
+	}
+}), G("TSIndexedAccessType", {
+	aliases: ["TSType"],
+	visitor: ["objectType", "indexType"],
+	fields: {
+		objectType: O("TSType"),
+		indexType: O("TSType")
+	}
+}), G("TSMappedType", {
+	aliases: ["TSType"],
+	visitor: [
+		"key",
+		"constraint",
+		"nameType",
+		"typeAnnotation"
+	],
+	builder: [
+		"key",
+		"constraint",
+		"nameType",
+		"typeAnnotation"
+	],
+	fields: {
+		key: O("Identifier"),
+		constraint: O("TSType"),
+		readonly: k(F(!0, !1, "+", "-")),
+		optional: k(F(!0, !1, "+", "-")),
+		typeAnnotation: j("TSType"),
+		nameType: j("TSType")
+	}
+}), G("TSTemplateLiteralType", {
+	aliases: ["TSType", "TSBaseType"],
+	visitor: ["quasis", "types"],
+	fields: {
+		quasis: N("TemplateElement"),
+		types: { validate: R(L("array"), P(I("TSType")), function(e, t, n) {
+			if (e.quasis.length !== n.length + 1) throw TypeError(`Number of ${e.type} quasis should be exactly one more than the number of types.\nExpected ${n.length + 1} quasis but got ${e.quasis.length}`);
+		}) }
+	}
+}), G("TSLiteralType", {
+	aliases: ["TSType", "TSBaseType"],
+	visitor: ["literal"],
+	fields: { literal: { validate: function() {
+		let e = I("NumericLiteral", "BigIntLiteral"), t = F("-"), n = I("NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "TemplateLiteral");
+		return E(function(r, i, a) {
+			w("UnaryExpression", a) ? (t(a, "operator", a.operator), e(a, "argument", a.argument)) : n(r, i, a);
+		}, { oneOfNodeTypes: [
+			"NumericLiteral",
+			"StringLiteral",
+			"BooleanLiteral",
+			"BigIntLiteral",
+			"TemplateLiteral",
+			"UnaryExpression"
+		] });
+	}() } }
+}), G("TSClassImplements", {
+	aliases: ["TSType"],
+	visitor: ["expression", "typeArguments"],
+	fields: {
+		expression: O("Expression"),
+		typeArguments: j("TSTypeParameterInstantiation")
+	}
+}), G("TSInterfaceHeritage", {
+	aliases: ["TSType"],
+	visitor: ["expression", "typeArguments"],
+	fields: {
+		expression: O("Expression"),
+		typeArguments: j("TSTypeParameterInstantiation")
+	}
+}), G("TSInterfaceDeclaration", {
+	aliases: ["Statement", "Declaration"],
+	visitor: [
+		"id",
+		"typeParameters",
+		"extends",
+		"body"
+	],
+	fields: {
+		declare: k(K),
+		id: O("Identifier"),
+		typeParameters: j("TSTypeParameterDeclaration"),
+		extends: k(M("TSInterfaceHeritage")),
+		body: O("TSInterfaceBody")
+	}
+}), G("TSInterfaceBody", {
+	visitor: ["body"],
+	fields: { body: N("TSTypeElement") }
+}), G("TSTypeAliasDeclaration", {
+	aliases: ["Statement", "Declaration"],
+	visitor: [
+		"id",
+		"typeParameters",
+		"typeAnnotation"
+	],
+	fields: {
+		declare: k(K),
+		id: O("Identifier"),
+		typeParameters: j("TSTypeParameterDeclaration"),
+		typeAnnotation: O("TSType")
+	}
+}), G("TSInstantiationExpression", {
+	aliases: ["Expression"],
+	visitor: ["expression", "typeArguments"],
+	fields: {
+		expression: O("Expression"),
+		typeArguments: j("TSTypeParameterInstantiation")
+	}
+});
+var Et = {
+	aliases: [
+		"Expression",
+		"LVal",
+		"PatternLike"
+	],
+	visitor: ["expression", "typeAnnotation"],
+	fields: {
+		expression: O("Expression"),
+		typeAnnotation: O("TSType")
+	}
+};
+G("TSAsExpression", Et), G("TSSatisfiesExpression", Et), G("TSTypeAssertion", {
+	aliases: [
+		"Expression",
+		"LVal",
+		"PatternLike"
+	],
+	visitor: ["typeAnnotation", "expression"],
+	fields: {
+		typeAnnotation: O("TSType"),
+		expression: O("Expression")
+	}
+}), G("TSEnumBody", {
+	visitor: ["members"],
+	fields: { members: N("TSEnumMember") }
+}), G("TSEnumDeclaration", {
+	aliases: ["Statement", "Declaration"],
+	visitor: ["id", "body"],
+	fields: {
+		declare: k(K),
+		const: k(K),
+		id: O("Identifier"),
+		body: O("TSEnumBody")
+	}
+}), G("TSEnumMember", {
+	visitor: ["id", "initializer"],
+	fields: {
+		id: O("Identifier", "StringLiteral"),
+		initializer: j("Expression")
+	}
+}), G("TSModuleDeclaration", {
+	aliases: ["Statement", "Declaration"],
+	visitor: ["id", "body"],
+	fields: {
+		kind: {
+			validate: F("global", "namespace", "module"),
+			default: "namespace"
+		},
+		declare: k(K),
+		id: { validate: R(I("TSEntityName", "StringLiteral"), E(function(e, t, n) {
+			if (e.kind === "namespace" && w("StringLiteral", n)) throw TypeError("TSModuleDeclaration of kind 'namespace' cannot have a StringLiteral id.");
+		}, { oneOfNodeTypes: ["TSEntityName", "StringLiteral"] })) },
+		body: O("TSModuleBlock")
+	}
+}), G("TSModuleBlock", {
+	aliases: [
+		"Scopable",
+		"Block",
+		"BlockParent",
+		"FunctionParent"
+	],
+	visitor: ["body"],
+	fields: { body: N("Statement") }
+}), G("TSImportType", {
+	aliases: ["TSType"],
+	builder: [
+		"source",
+		"qualifier",
+		"typeArguments"
+	],
+	visitor: [
+		"source",
+		"options",
+		"qualifier",
+		"typeArguments"
+	],
+	fields: {
+		source: O("StringLiteral"),
+		qualifier: j("TSEntityName"),
+		typeArguments: j("TSTypeParameterInstantiation"),
+		options: {
+			validate: I("ObjectExpression"),
+			optional: !0
+		}
+	}
+}), G("TSImportEqualsDeclaration", {
+	aliases: ["Statement", "Declaration"],
+	visitor: ["id", "moduleReference"],
+	fields: {
+		id: O("Identifier"),
+		moduleReference: O("TSEntityName", "TSExternalModuleReference"),
+		importKind: {
+			validate: F("type", "value"),
+			optional: !0
+		}
+	}
+}), G("TSExternalModuleReference", {
+	visitor: ["expression"],
+	fields: { expression: O("StringLiteral") }
+}), G("TSNonNullExpression", {
+	aliases: [
+		"Expression",
+		"LVal",
+		"PatternLike"
+	],
+	visitor: ["expression"],
+	fields: { expression: O("Expression") }
+}), G("TSExportAssignment", {
+	aliases: ["Statement"],
+	visitor: ["expression"],
+	fields: { expression: O("Expression") }
+}), G("TSNamespaceExportDeclaration", {
+	aliases: ["Statement"],
+	visitor: ["id"],
+	fields: { id: O("Identifier") }
+}), G("TSTypeAnnotation", {
+	visitor: ["typeAnnotation"],
+	fields: { typeAnnotation: { validate: I("TSType") } }
+}), G("TSTypeParameterInstantiation", {
+	visitor: ["params"],
+	fields: { params: N("TSType") }
+}), G("TSTypeParameterDeclaration", {
+	visitor: ["params"],
+	fields: { params: N("TSTypeParameter") }
+}), G("TSTypeParameter", {
+	builder: [
+		"constraint",
+		"default",
+		"name"
+	],
+	visitor: [
+		"name",
+		"constraint",
+		"default"
+	],
+	fields: {
+		name: { validate: I("Identifier") },
+		in: {
+			validate: L("boolean"),
+			optional: !0
+		},
+		out: {
+			validate: L("boolean"),
+			optional: !0
+		},
+		const: {
+			validate: L("boolean"),
+			optional: !0
+		},
+		constraint: {
+			validate: I("TSType"),
+			optional: !0
+		},
+		default: {
+			validate: I("TSType"),
+			optional: !0
+		}
+	}
+});
+var Dt = { ModuleDeclaration: "ImportOrExportDeclaration" };
+Object.keys(Dt).forEach((e) => {
+	T[e] = T[Dt[e]];
+});
+for (let { types: e, set: t } of Qe) for (let n of e) {
+	let e = T[n];
+	e ? e.forEach(t.add, t) : t.add(n);
+}
+[].concat(Object.keys(Ue), Object.keys(T), Object.keys(qe));
+function Ot(e, t, n) {
+	if (!e) return;
+	let r = Ge[e.type];
+	if (!r) return;
+	let i = r[t];
+	At(e, t, n, i), jt(e, t, n);
+}
+function kt(e, t, n, r, i) {
+	if (e?.validate && !(e.optional && r == null) && (e.validate(t, n, r), i)) {
+		let e = r.type;
+		if (e == null) return;
+		Je[e]?.(t, n, r);
+	}
+}
+function At(e, t, n, r) {
+	r?.validate && (r.optional && n == null || r.validate(e, t, n));
+}
+function jt(e, t, n) {
+	let r = n?.type;
+	r != null && Je[r]?.(e, t, n);
+}
+var { validateInternal: q } = /* @__PURE__ */ Object.defineProperty({
+	__proto__: null,
+	default: Ot,
+	validateChild: jt,
+	validateField: At,
+	validateInternal: kt
+}, Symbol.toStringTag, { value: "Module" }), { NODE_FIELDS: J } = at;
+function Mt(e, t, n) {
+	let r = {
+		type: "BinaryExpression",
+		operator: e,
+		left: t,
+		right: n
+	}, i = J.BinaryExpression;
+	return q(i.operator, r, "operator", e), q(i.left, r, "left", t, 1), q(i.right, r, "right", n, 1), r;
+}
+function Nt(e, t = []) {
+	let n = {
+		type: "BlockStatement",
+		body: e,
+		directives: t
+	}, r = J.BlockStatement;
+	return q(r.body, n, "body", e, 1), q(r.directives, n, "directives", t, 1), n;
+}
+function Pt(e, t) {
+	let n = {
+		type: "CallExpression",
+		callee: e,
+		arguments: t
+	}, r = J.CallExpression;
+	return q(r.callee, n, "callee", e, 1), q(r.arguments, n, "arguments", t, 1), n;
+}
+function Ft(e, t, n) {
+	let r = {
+		type: "ConditionalExpression",
+		test: e,
+		consequent: t,
+		alternate: n
+	}, i = J.ConditionalExpression;
+	return q(i.test, r, "test", e, 1), q(i.consequent, r, "consequent", t, 1), q(i.alternate, r, "alternate", n, 1), r;
+}
+function Y(e) {
+	let t = {
+		type: "Identifier",
+		name: e
+	}, n = J.Identifier;
+	return q(n.name, t, "name", e), t;
+}
+function X(e) {
+	let t = {
+		type: "StringLiteral",
+		value: e
+	}, n = J.StringLiteral;
+	return q(n.value, t, "value", e), t;
+}
+function It(e, t, n) {
+	let r = {
+		type: "LogicalExpression",
+		operator: e,
+		left: t,
+		right: n
+	}, i = J.LogicalExpression;
+	return q(i.operator, r, "operator", e), q(i.left, r, "left", t, 1), q(i.right, r, "right", n, 1), r;
+}
+function Z(e, t, n = !1) {
+	let r = {
+		type: "MemberExpression",
+		object: e,
+		property: t,
+		computed: n
+	}, i = J.MemberExpression;
+	return q(i.object, r, "object", e, 1), q(i.property, r, "property", t, 1), q(i.computed, r, "computed", n), r;
+}
+function Lt(e) {
+	let t = {
+		type: "ObjectExpression",
+		properties: e
+	}, n = J.ObjectExpression;
+	return q(n.properties, t, "properties", e, 1), t;
+}
+function Rt(e, t, n = !1, r = !1) {
+	let i = {
+		type: "ObjectProperty",
+		key: e,
+		value: t,
+		computed: n,
+		shorthand: r
+	}, a = J.ObjectProperty;
+	return q(a.key, i, "key", e, 1), q(a.value, i, "value", t, 1), q(a.computed, i, "computed", n), q(a.shorthand, i, "shorthand", r), i;
+}
+function zt(e = null) {
+	let t = {
+		type: "ReturnStatement",
+		argument: e
+	}, n = J.ReturnStatement;
+	return q(n.argument, t, "argument", e, 1), t;
+}
+function Bt(e, t) {
+	let n = {
+		type: "VariableDeclaration",
+		kind: e,
+		declarations: t
+	}, r = J.VariableDeclaration;
+	return q(r.kind, n, "kind", e), q(r.declarations, n, "declarations", t, 1), n;
+}
+function Vt(e, t = null) {
+	let n = {
+		type: "VariableDeclarator",
+		id: e,
+		init: t
+	}, r = J.VariableDeclarator;
+	return q(r.id, n, "id", e, 1), q(r.init, n, "init", t, 1), n;
+}
+function Ht(e, t) {
+	let n = {
+		type: "AssignmentPattern",
+		left: e,
+		right: t
+	}, r = J.AssignmentPattern;
+	return q(r.left, n, "left", e, 1), q(r.right, n, "right", t, 1), n;
+}
+function Ut(e, t, n = !1) {
+	let r = {
+		type: "ArrowFunctionExpression",
+		params: e,
+		body: t,
+		async: n
+	}, i = J.ArrowFunctionExpression;
+	return q(i.params, r, "params", e, 1), q(i.body, r, "body", t, 1), q(i.async, r, "async", n), r;
+}
+function Wt(e, t, n = null) {
+	let r = {
+		type: "ImportDeclaration",
+		specifiers: e,
+		source: t,
+		attributes: n
+	}, i = J.ImportDeclaration;
+	return q(i.specifiers, r, "specifiers", e, 1), q(i.source, r, "source", t, 1), q(i.attributes, r, "attributes", n, 1), r;
+}
+function Gt(e) {
+	let t = {
+		type: "ImportNamespaceSpecifier",
+		local: e
+	}, n = J.ImportNamespaceSpecifier;
+	return q(n.local, t, "local", e, 1), t;
+}
+function Kt(e) {
+	let t = {
+		type: "SpreadElement",
+		argument: e
+	}, n = J.SpreadElement;
+	return q(n.argument, t, "argument", e, 1), t;
+}
+var { hasOwn: Q } = Object;
+function qt(e, t, n, r) {
+	return e && typeof e.type == "string" ? Xt(e, t, n, r) : e;
+}
+function Jt(e, t, n, r) {
+	return Array.isArray(e) ? e.map((e) => qt(e, t, n, r)) : qt(e, t, n, r);
+}
+function Yt(e, t = !0, n = !1) {
+	return e && Xt(e, t, n, /* @__PURE__ */ new Map());
+}
+function Xt(e, t = !0, n = !1, r) {
+	if (!e) return e;
+	let { type: i } = e, a = { type: e.type };
+	if (x(e)) a.name = e.name, Q(e, "optional") && typeof e.optional == "boolean" && (a.optional = e.optional), Q(e, "typeAnnotation") && (a.typeAnnotation = t ? Jt(e.typeAnnotation, !0, n, r) : e.typeAnnotation), Q(e, "decorators") && (a.decorators = t ? Jt(e.decorators, !0, n, r) : e.decorators);
+	else if (Q(Ge, i)) for (let o of Object.keys(Ge[i])) Q(e, o) && (a[o] = t ? ce(e) && o === "comments" ? Zt(e.comments, t, n, r) : Jt(e[o], !0, n, r) : e[o]);
+	else throw Error(`Unknown node type: "${i}"`);
+	return Q(e, "loc") && (a.loc = n ? null : e.loc), Q(e, "leadingComments") && (a.leadingComments = Zt(e.leadingComments, t, n, r)), Q(e, "innerComments") && (a.innerComments = Zt(e.innerComments, t, n, r)), Q(e, "trailingComments") && (a.trailingComments = Zt(e.trailingComments, t, n, r)), Q(e, "extra") && (a.extra = { ...e.extra }), a;
+}
+function Zt(e, t, n, r) {
+	return !e || !t ? e : e.map((e) => {
+		let t = r.get(e);
+		if (t) return t;
+		let { type: i, value: a, loc: o } = e, s = {
+			type: i,
+			value: a,
+			loc: o
+		};
+		return n && (s.loc = void 0), r.set(e, s), s;
+	});
+}
+T.Standardized, T.Expression, T.Binary, T.Scopable, T.BlockParent, T.Block, T.Statement, T.Terminatorless, T.CompletionStatement, T.Conditional, T.Loop, T.While, T.ExpressionWrapper, T.For, T.ForXStatement, T.Function, T.FunctionParent, T.Pureish, T.Declaration, T.FunctionParameter, T.PatternLike, T.LVal, T.TSEntityName, T.Literal, T.Immutable, T.UserWhitespacable, T.Method, T.ObjectMember, T.Property, T.UnaryLike, T.Pattern, T.Class, T.ImportOrExportDeclaration, T.ExportDeclaration, T.ModuleSpecifier, T.Private, T.Flow, T.FlowType, T.FlowBaseAnnotation, T.FlowDeclaration, T.FlowPredicate, T.EnumBody, T.EnumMember, T.JSX, T.Miscellaneous, T.Accessor, T.TypeScript, T.TSTypeElement, T.TSType, T.TSBaseType;
+var Qt = Symbol(), $t = Symbol();
+function en(e, t, n) {
+	if (!e) return !1;
+	let r = Ue[e.type];
+	if (!r) return !1;
+	n ||= {};
+	let i = t(e, n);
+	if (i !== void 0) switch (i) {
+		case Qt: return !1;
+		case $t: return !0;
+	}
+	for (let i of r) {
+		let r = e[i];
+		if (r) {
+			if (Array.isArray(r)) {
+				for (let e of r) if (en(e, t, n)) return !0;
+			} else if (en(r, t, n)) return !0;
+		}
+	}
+	return !1;
+}
+en.skip = Qt, en.stop = $t;
+var tn = [
+	"tokens",
+	"start",
+	"end",
+	"loc",
+	"raw",
+	"rawValue"
+], nn = [
+	...Me,
+	"comments",
+	...tn
+];
+function rn(e, t = {}) {
+	let n = t.preserveComments ? tn : nn;
+	for (let t of n) e[t] != null && (e[t] = void 0);
+	for (let t of Object.keys(e)) t.startsWith("_") && e[t] != null && (e[t] = void 0);
+	let r = Object.getOwnPropertySymbols(e);
+	for (let t of r) e[t] = null;
+}
+function an(e, t) {
+	return en(e, rn, t), e;
+}
+function on(e, t = e.key) {
+	let n;
+	return e.kind === "method" ? on.increment() + "" : (n = x(t) ? t.name : de(t) ? JSON.stringify(t.value) : JSON.stringify(an(Yt(t))), e.computed && (n = `[${n}]`), e.static && (n = `static:${n}`), n);
+}
+on.uid = 0, on.increment = function() {
+	return on.uid >= 2 ** 53 - 1 ? on.uid = 0 : on.uid++;
+}, Function.call.bind(Object.prototype.toString);
+function sn(e, t, n, r) {
+	let i = [].concat(e), a = Object.create(null);
+	for (; i.length;) {
+		let e = i.shift();
+		if (!e || r && (se(e) || he(e) || ge(e))) continue;
+		if (x(e)) {
+			t ? (a[e.name] = a[e.name] || []).push(e) : a[e.name] = e;
+			continue;
+		}
+		if (Te(e) && !ve(e)) {
+			we(e.declaration) && i.push(e.declaration);
+			continue;
+		}
+		if (n) {
+			if (le(e)) {
+				i.push(e.id);
+				continue;
+			}
+			if (ue(e) || _e(e)) continue;
+		}
+		let o = sn.keys[e.type];
+		if (o) for (let t = 0; t < o.length; t++) {
+			let n = e[o[t]];
+			n && (Array.isArray(n) ? i.push(...n) : i.push(n));
+		}
+	}
+	return a;
+}
+sn.keys = {
+	DeclareClass: ["id"],
+	DeclareFunction: ["id"],
+	DeclareModule: ["id"],
+	DeclareVariable: ["id"],
+	DeclareInterface: ["id"],
+	DeclareTypeAlias: ["id"],
+	DeclareOpaqueType: ["id"],
+	InterfaceDeclaration: ["id"],
+	TypeAlias: ["id"],
+	OpaqueType: ["id"],
+	CatchClause: ["param"],
+	LabeledStatement: ["label"],
+	UnaryExpression: ["argument"],
+	AssignmentExpression: ["left"],
+	ImportSpecifier: ["local"],
+	ImportNamespaceSpecifier: ["local"],
+	ImportDefaultSpecifier: ["local"],
+	ImportDeclaration: ["specifiers"],
+	TSImportEqualsDeclaration: ["id"],
+	ExportSpecifier: ["exported"],
+	ExportNamespaceSpecifier: ["exported"],
+	ExportDefaultSpecifier: ["exported"],
+	FunctionDeclaration: ["id", "params"],
+	FunctionExpression: ["id", "params"],
+	ArrowFunctionExpression: ["params"],
+	ObjectMethod: ["params"],
+	ClassMethod: ["params"],
+	ClassPrivateMethod: ["params"],
+	ForInStatement: ["left"],
+	ForOfStatement: ["left"],
+	ClassDeclaration: ["id"],
+	ClassExpression: ["id"],
+	RestElement: ["argument"],
+	UpdateExpression: ["argument"],
+	ObjectProperty: ["value"],
+	AssignmentPattern: ["left"],
+	ArrayPattern: ["elements"],
+	ObjectPattern: ["properties"],
+	VariableDeclaration: ["declarations"],
+	VariableDeclarator: ["id"]
+};
+//#endregion
+//#region src/babel/index.ts
+function $(e, t) {
+	return e.properties.find((e) => C(e) && (x(e.key) && e.key.name === t || de(e.key) && e.key.value === t));
+}
+function cn(e) {
+	if (x(e.key)) return e.key.name;
+	if (de(e.key) || fe(e.key)) return String(e.key.value);
+}
+function ln(e) {
+	return Pt(Y("String"), [e]);
+}
+function un(e, t, n) {
+	let r = Z(e, X(t), !0), i = n.get(t);
+	return i ? It("??", r, Yt(i, !0)) : r;
+}
+function dn(e, t, n) {
+	return Mt("===", un(e, t.groupName, n), Yt(t.value, !0));
+}
+function fn() {
+	return {
+		name: "stylex-variants",
+		visitor: {
+			ImportDeclaration(e, t) {
+				if (e.node.source.value === "@stylex-variants/core") {
+					let n = e.get("specifiers");
+					for (let r of n) r.isImportSpecifier() && x(r.node.imported, { name: "sxv" }) && r.node.importKind !== "type" && e.node.importKind !== "type" && (t.sxvImports ??= []).push(r);
+					return;
+				}
+				if (e.node.source.value === "@stylexjs/stylex") {
+					let n = e.node.specifiers.find((e) => ye(e));
+					n && (t.stylexLocalName = n.local.name);
+				}
+			},
+			CallExpression(e, t) {
+				if (!x(e.node.callee)) return;
+				let n = e.scope.getBinding(e.node.callee.name);
+				if (!n?.path.isImportSpecifier() || !x(n.path.node.imported, { name: "sxv" }) || !n.path.parentPath.isImportDeclaration() || n.path.parentPath.node.source.value !== "@stylex-variants/core") return;
+				let [r] = e.node.arguments;
+				if (e.node.arguments.length !== 1 || !S(r)) throw e.buildCodeFrameError("sxv requires one inline object configuration.");
+				let i = (t) => {
+					for (let n of t.properties) if (!C(n) || n.computed || cn(n) === void 0 || !Ce(n.value)) throw e.buildCodeFrameError("sxv configuration requires static properties; spreads, methods and computed keys are not supported.");
+				}, a = (t) => {
+					if (!S(t)) throw e.buildCodeFrameError("sxv styles must be inline objects; dynamic style functions are not supported in this release.");
+				};
+				i(r);
+				for (let t of r.properties) {
+					if (!C(t)) continue;
+					let n = cn(t);
+					if (n === "base" && a(t.value), n === "variants" || n === "defaultVariants") {
+						if (!S(t.value)) throw e.buildCodeFrameError("sxv variants and defaultVariants must be inline objects.");
+						if (i(t.value), n === "variants") for (let n of t.value.properties) {
+							if (!C(n) || !S(n.value)) throw e.buildCodeFrameError("sxv variant groups must be inline objects.");
+							i(n.value);
+							for (let e of n.value.properties) C(e) && a(e.value);
+						}
+					}
+					if (n === "compoundVariants") {
+						if (!oe(t.value)) throw e.buildCodeFrameError("sxv compoundVariants must be an inline array.");
+						for (let n of t.value.elements) {
+							if (!S(n)) throw e.buildCodeFrameError("sxv compound variants must be inline objects.");
+							i(n);
+							let t = $(n, "style");
+							if (t && a(t.value), !t) throw e.buildCodeFrameError("sxv compound variants require a style property.");
+						}
+					}
+				}
+				let o = $(r, "base"), s = $(r, "variants"), c = $(r, "defaultVariants"), l = $(r, "compoundVariants"), u = e.findParent((e) => e.isProgram());
+				if (!u || !u.isProgram()) return;
+				t.stylexLocalName = void 0;
+				for (let n of u.get("body")) if (n.isImportDeclaration() && n.node.source.value === "@stylexjs/stylex" && n.node.importKind !== "type") for (let r of n.get("specifiers")) r.isImportNamespaceSpecifier() && e.scope.getBinding(r.node.local.name)?.path === r && (t.stylexLocalName = r.node.local.name);
+				if (!t.stylexLocalName) {
+					let e = u.scope.generateUidIdentifier("stylex"), n = Wt([Gt(e)], X("@stylexjs/stylex")), [r] = u.unshiftContainer("body", n);
+					r && u.scope.registerDeclaration(r), t.stylexLocalName = e.name;
+				}
+				let d = Y(t.stylexLocalName), f = e.scope.generateUidIdentifier("styles"), p = [];
+				o && Ce(o.value) && p.push(Rt(Y("base"), o.value));
+				let m = [];
+				if (s && S(s.value)) for (let e of s.value.properties) {
+					if (!C(e) || !S(e.value)) continue;
+					let t = cn(e);
+					if (t !== void 0) for (let n of e.value.properties) {
+						if (!C(n) || !Ce(n.value)) continue;
+						let e = cn(n);
+						if (e === void 0) continue;
+						let r = `variant_${t.length}_${t}_${e}`;
+						p.push(Rt(X(r), n.value)), m.push({
+							groupName: t,
+							valueName: e,
+							styleName: r
+						});
+					}
+				}
+				let ee = [];
+				l && oe(l.value) && l.value.elements.forEach((e, t) => {
+					if (!e || !S(e)) return;
+					let n = $(e, "style");
+					if (!n || !Ce(n.value)) return;
+					let r = `compound_${t}`, i = [];
+					for (let t of e.properties) {
+						if (!C(t)) continue;
+						let e = cn(t);
+						e !== void 0 && e !== "style" && Ce(t.value) && i.push({
+							groupName: e,
+							value: t.value
+						});
+					}
+					p.push(Rt(X(r), n.value)), ee.push({
+						styleName: r,
+						conditions: i
+					});
+				});
+				let te = Bt("const", [Vt(f, Pt(Z(d, Y("create")), [Lt(p)]))]), ne = e.getStatementParent();
+				if (!ne) return;
+				ne.insertBefore(te);
+				let h = /* @__PURE__ */ new Map();
+				if (c && S(c.value)) for (let e of c.value.properties) {
+					if (!C(e) || !Ce(e.value)) continue;
+					let t = cn(e);
+					t !== void 0 && h.set(t, e.value);
+				}
+				let g = e.scope.generateUidIdentifier("props"), _ = [];
+				o && _.push(Z(f, Y("base")));
+				let re = /* @__PURE__ */ new Map();
+				for (let e of m) {
+					let t = re.get(e.groupName) ?? [];
+					t.push(e), re.set(e.groupName, t);
+				}
+				for (let [e] of re) {
+					let t = ln(un(g, e, h)), n = Mt("+", X(`variant_${e.length}_${e}_`), t);
+					_.push(Z(f, n, !0));
+				}
+				for (let e of ee) {
+					if (e.conditions.length === 0) {
+						_.push(Z(f, X(e.styleName), !0));
+						continue;
+					}
+					let t = e.conditions.map((e) => dn(g, e, h)).reduce((e, t) => It("&&", e, t)), n = Z(f, X(e.styleName), !0);
+					_.push(It("&&", t, n));
+				}
+				let ie = Pt(Z(d, Y("props")), _), v = e.scope.generateUidIdentifier("result"), ae = Ft(Z(g, Y("className")), Ft(Z(v, Y("className")), Mt("+", Mt("+", Z(v, Y("className")), X(" ")), Z(g, Y("className"))), Z(g, Y("className"))), Z(v, Y("className"))), y = Ft(Z(g, Y("style")), Pt(Z(Y("Object"), Y("assign")), [
+					Lt([]),
+					Z(v, Y("style")),
+					Z(g, Y("style"))
+				]), Z(v, Y("style"))), b = Ut([Ht(g, Lt([]))], Nt([Bt("const", [Vt(v, ie)]), zt(Lt([
+					Kt(v),
+					Rt(Y("className"), ae),
+					Rt(Y("style"), y)
+				]))]));
+				e.replaceWith(b);
+			},
+			Program: { exit(e, t) {
+				e.scope.crawl();
+				for (let n of t.sxvImports ?? []) {
+					if (e.scope.getBinding(n.node.local.name)?.referenced) continue;
+					let t = n.parentPath;
+					n.remove(), t.isImportDeclaration() && t.node.specifiers.length === 0 && t.remove();
+				}
+			} }
+		}
+	};
+}
+//#endregion
+export { fn as default };