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

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

@@ -1,15 +1,13 @@
-import { n as __exportAll, r as __toESM, t as __commonJSMin } from "./chunk-N93fKeF6.js";
-import { t as createDebug } from "./node-B3Gdtau1.js";
-import { a as RE_JSON, c as RE_TS, d as filename_js_to_dts, f as filename_to_dts, i as RE_JS, l as RE_VUE, m as resolveTemplateFn, n as RE_DTS, o as RE_NODE_MODULES, p as replaceTemplateName, r as RE_DTS_MAP, s as RE_ROLLDOWN_RUNTIME, t as RE_CSS, u as filename_dts_to } from "./filename-DQnUJlio-D7-CzKqs.js";
-import { n as ee, t as at } from "./dist-Cv2Z0Bi_.js";
-import { n as globalContext, r as invalidateContextFile, t as createContext } from "./tsc-context-CANQEB9U.js";
+import { A as __commonJSMin, M as __toESM, a as createDebug, j as __exportAll } from "./main-nVIFtu2j.js";
+import { _ as filename_dts_to, b as replaceTemplateName, c as RE_CSS, d as RE_JS, f as RE_JSON, g as RE_VUE, h as RE_TS, l as RE_DTS, m as RE_ROLLDOWN_RUNTIME, o as at, p as RE_NODE_MODULES, s as ee, u as RE_DTS_MAP, v as filename_js_to_dts, x as resolveTemplateFn, y as filename_to_dts } from "./build-BZshaq8i-C7uS6x65.js";
+import { n as globalContext, r as invalidateContextFile, t as createContext } from "./tsc-context-DKufFI_s.js";
 import { createRequire } from "node:module";
 import process from "node:process";
 import { fork, spawn } from "node:child_process";
 import path, { dirname, extname } from "node:path";
+import { existsSync } from "node:fs";
 import { mkdtemp, readFile, rm } from "node:fs/promises";
 import { importerId, include } from "@voidzero-dev/vite-plus-core/rolldown/filter";
-import { existsSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { ResolverFactory, isolatedDeclarationSync } from "@voidzero-dev/vite-plus-core/rolldown/experimental";
 //#region ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.5/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
@@ -654,11 +652,9 @@ function addMappingInternal(skipable, map, mapping) {
 	return addSegmentInternal(skipable, map, generated.line - 1, generated.column, source, original.line - 1, original.column, name, content);
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@babel+helper-validator-identifier@8.0.0-rc.4/node_modules/@babel/helper-validator-identifier/lib/index.js
-const nonASCIIidentifierStartChars$1 = "ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙՠ-ֈא-תׯ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࡠ-ࡪࡰ-ࢇࢉ-࢏ࢠ-ࣉऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱৼਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚ౜ౝౠౡಀಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ೜-ೞೠೡೱೲഄ-ഌഎ-ഐഒ-ഺഽൎൔ-ൖൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄຆ-ຊຌ-ຣລວ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜑᜟ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡸᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭌᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᲀ-ᲊᲐ-ᲺᲽ-Ჿᳩ-ᳬᳮ-ᳳᳵᳶᳺᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄯㄱ-ㆎㆠ-ㆿㇰ-ㇿ㐀-䶿一-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-Ƛ꟱-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꣾꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭩꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ";
-const nonASCIIidentifierChars$1 = "·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-٩ٰۖ-ۜ۟-۪ۤۧۨ-ۭ۰-۹ܑܰ-݊ަ-ް߀-߉߫-߽߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛ࢗ-࢟࣊-ࣣ࣡-ःऺ-़ा-ॏ॑-ॗॢॣ०-९ঁ-ঃ়া-ৄেৈো-্ৗৢৣ০-৯৾ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑ੦-ੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣ૦-૯ૺ-૿ଁ-ଃ଼ା-ୄେୈୋ-୍୕-ୗୢୣ୦-୯ஂா-ூெ-ைொ-்ௗ௦-௯ఀ-ఄ఼ా-ౄె-ైొ-్ౕౖౢౣ౦-౯ಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣ೦-೯ೳഀ-ഃ഻഼ാ-ൄെ-ൈൊ-്ൗൢൣ൦-൯ඁ-ඃ්ා-ුූෘ-ෟ෦-෯ෲෳัิ-ฺ็-๎๐-๙ັິ-ຼ່-໎໐-໙༘༙༠-༩༹༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှ၀-၉ၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏ-ႝ፝-፟፩-፱ᜒ-᜕ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝០-៩᠋-᠍᠏-᠙ᢩᤠ-ᤫᤰ-᤻᥆-᥏᧐-᧚ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼-᪉᪐-᪙᪰-᪽ᪿ-᫝᫠-᫫ᬀ-ᬄ᬴-᭄᭐-᭙᭫-᭳ᮀ-ᮂᮡ-ᮭ᮰-᮹᯦-᯳ᰤ-᰷᱀-᱉᱐-᱙᳐-᳔᳒-᳨᳭᳴᳷-᳹᷀-᷿‌‍‿⁀⁔⃐-⃥⃜⃡-⃰⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯・꘠-꘩꙯ꙴ-꙽ꚞꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧ꠬ꢀꢁꢴ-ꣅ꣐-꣙꣠-꣱ꣿ-꤉ꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀꧐-꧙ꧥ꧰-꧹ꨩ-ꨶꩃꩌꩍ꩐-꩙ꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭꯰-꯹ﬞ︀-️︠-︯︳︴﹍-﹏０-９＿･";
-const nonASCIIidentifierStart$1 = new RegExp("[" + nonASCIIidentifierStartChars$1 + "]");
-const nonASCIIidentifier$1 = new RegExp("[" + nonASCIIidentifierStartChars$1 + nonASCIIidentifierChars$1 + "]");
+//#region ../../node_modules/.pnpm/@babel+helper-validator-identifier@8.0.0-rc.6/node_modules/@babel/helper-validator-identifier/lib/index.js
+const nonASCIIidentifierStart$1 = /* @__PURE__ */ new RegExp("[ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙՠ-ֈא-תׯ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࡠ-ࡪࡰ-ࢇࢉ-࢏ࢠ-ࣉऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱৼਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚ౜ౝౠౡಀಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ೜-ೞೠೡೱೲഄ-ഌഎ-ഐഒ-ഺഽൎൔ-ൖൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄຆ-ຊຌ-ຣລວ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜑᜟ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡸᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭌᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᲀ-ᲊᲐ-ᲺᲽ-Ჿᳩ-ᳬᳮ-ᳳᳵᳶᳺᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄯㄱ-ㆎㆠ-ㆿㇰ-ㇿ㐀-䶿一-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-Ƛ꟱-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꣾꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭩꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ]");
+const nonASCIIidentifier$1 = /* @__PURE__ */ new RegExp("[ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙՠ-ֈא-תׯ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࡠ-ࡪࡰ-ࢇࢉ-࢏ࢠ-ࣉऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱৼਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚ౜ౝౠౡಀಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ೜-ೞೠೡೱೲഄ-ഌഎ-ഐഒ-ഺഽൎൔ-ൖൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄຆ-ຊຌ-ຣລວ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜑᜟ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡸᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭌᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᲀ-ᲊᲐ-ᲺᲽ-Ჿᳩ-ᳬᳮ-ᳳᳵᳶᳺᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄯㄱ-ㆎㆠ-ㆿㇰ-ㇿ㐀-䶿一-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-Ƛ꟱-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꣾꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭩꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-٩ٰۖ-ۜ۟-۪ۤۧۨ-ۭ۰-۹ܑܰ-݊ަ-ް߀-߉߫-߽߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛ࢗ-࢟࣊-ࣣ࣡-ःऺ-़ा-ॏ॑-ॗॢॣ०-९ঁ-ঃ়া-ৄেৈো-্ৗৢৣ০-৯৾ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑ੦-ੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣ૦-૯ૺ-૿ଁ-ଃ଼ା-ୄେୈୋ-୍୕-ୗୢୣ୦-୯ஂா-ூெ-ைொ-்ௗ௦-௯ఀ-ఄ఼ా-ౄె-ైొ-్ౕౖౢౣ౦-౯ಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣ೦-೯ೳഀ-ഃ഻഼ാ-ൄെ-ൈൊ-്ൗൢൣ൦-൯ඁ-ඃ්ා-ුූෘ-ෟ෦-෯ෲෳัิ-ฺ็-๎๐-๙ັິ-ຼ່-໎໐-໙༘༙༠-༩༹༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှ၀-၉ၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏ-ႝ፝-፟፩-፱ᜒ-᜕ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝០-៩᠋-᠍᠏-᠙ᢩᤠ-ᤫᤰ-᤻᥆-᥏᧐-᧚ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼-᪉᪐-᪙᪰-᪽ᪿ-᫝᫠-᫫ᬀ-ᬄ᬴-᭄᭐-᭙᭫-᭳ᮀ-ᮂᮡ-ᮭ᮰-᮹᯦-᯳ᰤ-᰷᱀-᱉᱐-᱙᳐-᳔᳒-᳨᳭᳴᳷-᳹᷀-᷿‌‍‿⁀⁔⃐-⃥⃜⃡-⃰⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯・꘠-꘩꙯ꙴ-꙽ꚞꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧ꠬ꢀꢁꢴ-ꣅ꣐-꣙꣠-꣱ꣿ-꤉ꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀꧐-꧙ꧥ꧰-꧹ꨩ-ꨶꩃꩌꩍ꩐-꩙ꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭꯰-꯹ﬞ︀-️︠-︯︳︴﹍-﹏０-９＿･]");
 const astralIdentifierStartCodes$1 = [
 	0,
 	11,
@@ -1718,7 +1714,7 @@ function isKeyword$1(word) {
 	return keywords$2.has(word);
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@babel+helper-string-parser@8.0.0-rc.4/node_modules/@babel/helper-string-parser/lib/index.js
+//#region ../../node_modules/.pnpm/@babel+helper-string-parser@8.0.0-rc.6/node_modules/@babel/helper-string-parser/lib/index.js
 var _isDigit$1 = function isDigit(code) {
 	return code >= 48 && code <= 57;
 };
@@ -1938,7 +1934,7 @@ function readCodePoint$1(input, pos, lineStart, curLine, throwOnInvalid, errors)
 	};
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@babel+types@8.0.0-rc.4/node_modules/@babel/types/lib/index.js
+//#region ../../node_modules/.pnpm/@babel+types@8.0.0-rc.6/node_modules/@babel/types/lib/index.js
 var lib_exports = /* @__PURE__ */ __exportAll({
 	ACCESSOR_TYPES: () => ACCESSOR_TYPES,
 	ALIAS_KEYS: () => ALIAS_KEYS,
@@ -2842,7 +2838,7 @@ var lib_exports = /* @__PURE__ */ __exportAll({
 	isModuleExpression: () => isModuleExpression,
 	isModuleSpecifier: () => isModuleSpecifier,
 	isNewExpression: () => isNewExpression$1,
-	isNode: () => isNode$1,
+	isNode: () => isNode$2,
 	isNodesEquivalent: () => isNodesEquivalent,
 	isNullLiteral: () => isNullLiteral,
 	isNullLiteralTypeAnnotation: () => isNullLiteralTypeAnnotation,
@@ -5914,7 +5910,7 @@ function defineType$5(type, opts = {}) {
 	if (opts.unionShape) NODE_UNION_SHAPES__PRIVATE[type] = opts.unionShape;
 	store[type] = opts;
 }
-const utils = /* @__PURE__ */ Object.defineProperty({
+const utils = /*#__PURE__*/ Object.defineProperty({
 	__proto__: null,
 	ALIAS_KEYS,
 	BUILDER_KEYS,
@@ -11641,7 +11637,7 @@ function SpreadProperty(argument) {
 	deprecationWarning("SpreadProperty", "SpreadElement", "The node type ");
 	return spreadElement(argument);
 }
-const b = /* @__PURE__ */ Object.defineProperty({
+const b = /*#__PURE__*/ Object.defineProperty({
 	__proto__: null,
 	anyTypeAnnotation,
 	argumentPlaceholder,
@@ -11937,11 +11933,11 @@ function buildChildren(node) {
 	}
 	return elements;
 }
-function isNode$1(node) {
+function isNode$2(node) {
 	return !!(node && VISITOR_KEYS$2[node.type]);
 }
 function assertNode(node) {
-	if (!isNode$1(node)) {
+	if (!isNode$2(node)) {
 		const type = node?.type ?? JSON.stringify(node);
 		throw new TypeError(`Not a valid node of type "${type}"`);
 	}
@@ -13653,7 +13649,7 @@ const react = {
 	buildChildren
 };
 //#endregion
-//#region ../../node_modules/.pnpm/@babel+generator@8.0.0-rc.4/node_modules/@babel/generator/lib/index.js
+//#region ../../node_modules/.pnpm/@babel+generator@8.0.0-rc.6/node_modules/@babel/generator/lib/index.js
 var import_jsesc = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const object = {};
 	const hasOwnProperty = object.hasOwnProperty;
@@ -13884,7 +13880,7 @@ var SourceMap = class {
 	getRawMappings() {
 		return this._rawMappings ||= allMappings(this._map);
 	}
-	mark(generated, line, column, identifierName, identifierNamePos, filename) {
+	mark(generated, generatedIdentifierName, line, column, identifierName, identifierNamePos, filename) {
 		this._rawMappings = void 0;
 		let originalMapping;
 		if (line != null) if (this._inputMap) {
@@ -13892,7 +13888,8 @@ var SourceMap = class {
 				line,
 				column
 			});
-			if (!originalMapping.name && identifierNamePos) {
+			if (originalMapping.name && (identifierNamePos || identifierName != null && originalMapping.column === column)) identifierName = originalMapping.name;
+			else if (identifierNamePos) {
 				const originalIdentifierMapping = originalPositionFor(this._inputMap, identifierNamePos);
 				if (originalIdentifierMapping.name) identifierName = originalIdentifierMapping.name;
 			}
@@ -13902,6 +13899,7 @@ var SourceMap = class {
 			line,
 			column
 		};
+		if (identifierName != null && identifierName === generatedIdentifierName) identifierName = null;
 		maybeAddMapping(this._map, {
 			name: identifierName,
 			generated,
@@ -13974,9 +13972,9 @@ var Buffer$1 = class {
 		};
 		return result;
 	}
-	append(str, maybeNewline) {
+	append(str, maybeNewline, ignoreMapping = false) {
 		this._flush();
-		this._append(str, maybeNewline);
+		this._append(str, maybeNewline, ignoreMapping);
 	}
 	appendChar(char) {
 		this._flush();
@@ -14005,12 +14003,12 @@ var Buffer$1 = class {
 			if (this._map) {
 				const sourcePos = this._sourcePosition;
 				if (useSourcePos && sourcePos) {
-					this._map.mark(position, sourcePos.line, sourcePos.column, isSpace ? void 0 : sourcePos.identifierName, isSpace ? void 0 : sourcePos.identifierNamePos, sourcePos.filename);
+					this._map.mark(position, null, sourcePos.line, sourcePos.column, isSpace ? void 0 : sourcePos.identifierName, isSpace ? void 0 : sourcePos.identifierNamePos, sourcePos.filename);
 					if (!isSpace && this._canMarkIdName) {
 						sourcePos.identifierName = void 0;
 						sourcePos.identifierNamePos = void 0;
 					}
-				} else this._map.mark(position);
+				} else this._map.mark(position, null);
 			}
 			position.column += repeat;
 		} else {
@@ -14018,7 +14016,7 @@ var Buffer$1 = class {
 			position.column = 0;
 		}
 	}
-	_append(str, maybeNewline) {
+	_append(str, maybeNewline, ignoreMapping) {
 		const len = str.length;
 		const position = this._position;
 		const sourcePos = this._sourcePosition;
@@ -14029,7 +14027,7 @@ var Buffer$1 = class {
 			this._str = str;
 			this._appendCount = 0;
 		} else this._str += str;
-		const hasMap = this._map !== null;
+		const hasMap = !ignoreMapping && this._map !== null;
 		if (!maybeNewline && !hasMap) {
 			position.column += len;
 			return;
@@ -14042,14 +14040,14 @@ var Buffer$1 = class {
 		}
 		let i = str.indexOf("\n");
 		let last = 0;
-		if (hasMap && i !== 0) this._map.mark(position, line, column, identifierName, identifierNamePos, filename);
+		if (hasMap && i !== 0) this._map.mark(position, str, line, column, identifierName, identifierNamePos, filename);
 		while (i !== -1) {
 			position.line++;
 			position.column = 0;
 			last = i + 1;
 			if (last < len && line !== void 0) {
 				line++;
-				if (hasMap) this._map.mark(position, line, 0, void 0, void 0, filename);
+				if (hasMap) this._map.mark(position, str, line, 0, void 0, void 0, filename);
 			}
 			i = str.indexOf("\n", last);
 		}
@@ -14100,13 +14098,16 @@ var Buffer$1 = class {
 	_normalizePosition(prop, loc, columnOffset) {
 		this._flush();
 		const pos = loc[prop];
-		const target = this._sourcePosition;
 		if (pos) {
-			target.line = pos.line;
-			target.column = Math.max(pos.column + columnOffset, 0);
-			target.filename = loc.filename;
+			this.setSourcePosition(pos.line, Math.max(pos.column + columnOffset, 0));
+			this._sourcePosition.filename = loc.filename;
 		}
 	}
+	setSourcePosition(line, column) {
+		const target = this._sourcePosition;
+		target.line = line;
+		target.column = column;
+	}
 	getCurrentColumn() {
 		return this._position.column + (this._queuedChar ? 1 : 0);
 	}
@@ -14337,7 +14338,7 @@ function Identifier$1(node, parent, parentId, tokenContext, getRawIdentifier) {
 	}
 	return parentId === 69 && parent.left === node && node.name === "async" && !parent.await;
 }
-const parens = /* @__PURE__ */ Object.defineProperty({
+const parens = /*#__PURE__*/ Object.defineProperty({
 	__proto__: null,
 	ArrowFunctionExpression: ConditionalExpression$1,
 	AssignmentExpression: AssignmentExpression$1,
@@ -14969,6 +14970,9 @@ function _shouldPrintArrowParamsParens(node) {
 	if (this.format.retainLines) return true;
 	return false;
 }
+function isRenamedIdentifier(id) {
+	return !!id.loc?.identifierName && id.loc.identifierName !== id.name;
+}
 function _getFuncIdName(idNode, parent) {
 	let id = idNode;
 	if (!id && parent) {
@@ -14979,18 +14983,22 @@ function _getFuncIdName(idNode, parent) {
 			if (!parent.computed || parent.key.type === "StringLiteral") id = parent.key;
 		} else if (parentType === "ClassPrivateProperty" || parentType === "ClassAccessorProperty") id = parent.key;
 	}
-	if (!id) return;
+	if (!id?.loc) return;
 	let nameInfo;
-	if (id.type === "Identifier") nameInfo = {
-		pos: id.loc?.start,
-		name: id.loc?.identifierName || id.name
-	};
-	else if (id.type === "PrivateName") nameInfo = {
-		pos: id.loc?.start,
-		name: "#" + id.id.name
-	};
-	else if (id.type === "StringLiteral") nameInfo = {
-		pos: id.loc?.start,
+	if (id.type === "Identifier") {
+		if (!isRenamedIdentifier(id)) return;
+		nameInfo = {
+			pos: id.loc.start,
+			name: id.loc.identifierName
+		};
+	} else if (id.type === "PrivateName") {
+		if (!isRenamedIdentifier(id.id)) return;
+		nameInfo = {
+			pos: id.loc.start,
+			name: "#" + id.id.loc.identifierName
+		};
+	} else if (id.type === "StringLiteral") nameInfo = {
+		pos: id.loc.start,
 		name: id.value
 	};
 	return nameInfo;
@@ -15792,7 +15800,7 @@ function _getRawIdentifier(node) {
 	return lastRawIdentResult = node.name;
 }
 function Identifier(node) {
-	if (this._buf._map) this.sourceIdentifierName(node.loc?.identifierName || node.name);
+	if (this._buf._map && node.loc?.identifierName && node.loc.identifierName !== node.name) this.sourceIdentifierName(node.loc.identifierName);
 	this.word(this.tokenMap ? lastRawIdentResult : node.name);
 }
 function ArgumentPlaceholder() {
@@ -16758,7 +16766,7 @@ function JSXClosingFragment() {
 	this.token("</");
 	this.tokenChar(62);
 }
-const generatorFunctions = /* @__PURE__ */ Object.defineProperty({
+const generatorFunctions = /*#__PURE__*/ Object.defineProperty({
 	__proto__: null,
 	AnyTypeAnnotation,
 	ArgumentPlaceholder,
@@ -17479,7 +17487,8 @@ var Printer = class {
 		const spacesCount = count > 0 ? column : column - this._buf.getCurrentColumn();
 		if (spacesCount > 0) {
 			const spaces = this._originalCode ? this._originalCode.slice(index - spacesCount, index).replace(/[^\t\v\f\uFEFF\p{Space_Separator}]/gu, " ") : " ".repeat(spacesCount);
-			this._append(spaces, false);
+			this._buf.append(spaces, false, true);
+			this._buf.setSourcePosition(line, column);
 			this.setLastChar(32);
 		}
 	}
@@ -17857,7 +17866,7 @@ function generate(ast, opts = {}, code) {
 	return new Printer(normalizeOptions(code, opts, ast), opts.sourceMaps ? new SourceMap(opts, code) : null, ast.tokens, typeof code === "string" ? code : null).generate(ast);
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@babel+parser@8.0.0-rc.4/node_modules/@babel/parser/lib/index.js
+//#region ../../node_modules/.pnpm/@babel+parser@8.0.0-rc.6/node_modules/@babel/parser/lib/index.js
 var Position = class {
 	constructor(line, col, index) {
 		this.line = void 0;
@@ -17937,7 +17946,6 @@ const StandardErrors = {
 	ConstructorIsAsync: "Constructor can't be an async function.",
 	ConstructorIsGenerator: "Constructor can't be a generator.",
 	DeclarationMissingInitializer: ({ kind }) => `Missing initializer in ${kind} declaration.`,
-	DecoratorAbstractMethod: "Decorators can't be used with an abstract method.",
 	DecoratorArgumentsOutsideParentheses: "Decorator arguments must be moved inside parentheses: use '@(decorator(args))' instead of '@(decorator)(args)'.",
 	DecoratorsBeforeAfterExport: "Decorators can be placed *either* before or after the 'export' keyword, but not in both locations at the same time.",
 	DecoratorConstructor: "Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?",
@@ -18875,10 +18883,8 @@ const types = {
 	j_cTag: new TokContext("</tag"),
 	j_expr: new TokContext("<tag>...</tag>", true)
 };
-const nonASCIIidentifierStartChars = "ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙՠ-ֈא-תׯ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࡠ-ࡪࡰ-ࢇࢉ-࢏ࢠ-ࣉऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱৼਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚ౜ౝౠౡಀಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ೜-ೞೠೡೱೲഄ-ഌഎ-ഐഒ-ഺഽൎൔ-ൖൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄຆ-ຊຌ-ຣລວ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜑᜟ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡸᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭌᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᲀ-ᲊᲐ-ᲺᲽ-Ჿᳩ-ᳬᳮ-ᳳᳵᳶᳺᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄯㄱ-ㆎㆠ-ㆿㇰ-ㇿ㐀-䶿一-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-Ƛ꟱-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꣾꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭩꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ";
-const nonASCIIidentifierChars = "·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-٩ٰۖ-ۜ۟-۪ۤۧۨ-ۭ۰-۹ܑܰ-݊ަ-ް߀-߉߫-߽߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛ࢗ-࢟࣊-ࣣ࣡-ःऺ-़ा-ॏ॑-ॗॢॣ०-९ঁ-ঃ়া-ৄেৈো-্ৗৢৣ০-৯৾ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑ੦-ੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣ૦-૯ૺ-૿ଁ-ଃ଼ା-ୄେୈୋ-୍୕-ୗୢୣ୦-୯ஂா-ூெ-ைொ-்ௗ௦-௯ఀ-ఄ఼ా-ౄె-ైొ-్ౕౖౢౣ౦-౯ಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣ೦-೯ೳഀ-ഃ഻഼ാ-ൄെ-ൈൊ-്ൗൢൣ൦-൯ඁ-ඃ්ා-ුූෘ-ෟ෦-෯ෲෳัิ-ฺ็-๎๐-๙ັິ-ຼ່-໎໐-໙༘༙༠-༩༹༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှ၀-၉ၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏ-ႝ፝-፟፩-፱ᜒ-᜕ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝០-៩᠋-᠍᠏-᠙ᢩᤠ-ᤫᤰ-᤻᥆-᥏᧐-᧚ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼-᪉᪐-᪙᪰-᪽ᪿ-᫝᫠-᫫ᬀ-ᬄ᬴-᭄᭐-᭙᭫-᭳ᮀ-ᮂᮡ-ᮭ᮰-᮹᯦-᯳ᰤ-᰷᱀-᱉᱐-᱙᳐-᳔᳒-᳨᳭᳴᳷-᳹᷀-᷿‌‍‿⁀⁔⃐-⃥⃜⃡-⃰⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯・꘠-꘩꙯ꙴ-꙽ꚞꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧ꠬ꢀꢁꢴ-ꣅ꣐-꣙꣠-꣱ꣿ-꤉ꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀꧐-꧙ꧥ꧰-꧹ꨩ-ꨶꩃꩌꩍ꩐-꩙ꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭꯰-꯹ﬞ︀-️︠-︯︳︴﹍-﹏０-９＿･";
-const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
-const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+const nonASCIIidentifierStart = /* @__PURE__ */ new RegExp("[ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙՠ-ֈא-תׯ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࡠ-ࡪࡰ-ࢇࢉ-࢏ࢠ-ࣉऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱৼਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚ౜ౝౠౡಀಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ೜-ೞೠೡೱೲഄ-ഌഎ-ഐഒ-ഺഽൎൔ-ൖൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄຆ-ຊຌ-ຣລວ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜑᜟ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡸᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭌᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᲀ-ᲊᲐ-ᲺᲽ-Ჿᳩ-ᳬᳮ-ᳳᳵᳶᳺᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄯㄱ-ㆎㆠ-ㆿㇰ-ㇿ㐀-䶿一-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-Ƛ꟱-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꣾꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭩꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ]");
+const nonASCIIidentifier = /* @__PURE__ */ new RegExp("[ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙՠ-ֈא-תׯ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࡠ-ࡪࡰ-ࢇࢉ-࢏ࢠ-ࣉऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱৼਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚ౜ౝౠౡಀಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ೜-ೞೠೡೱೲഄ-ഌഎ-ഐഒ-ഺഽൎൔ-ൖൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄຆ-ຊຌ-ຣລວ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜑᜟ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡸᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭌᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᲀ-ᲊᲐ-ᲺᲽ-Ჿᳩ-ᳬᳮ-ᳳᳵᳶᳺᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄯㄱ-ㆎㆠ-ㆿㇰ-ㇿ㐀-䶿一-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-Ƛ꟱-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꣾꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭩꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-٩ٰۖ-ۜ۟-۪ۤۧۨ-ۭ۰-۹ܑܰ-݊ަ-ް߀-߉߫-߽߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛ࢗ-࢟࣊-ࣣ࣡-ःऺ-़ा-ॏ॑-ॗॢॣ०-९ঁ-ঃ়া-ৄেৈো-্ৗৢৣ০-৯৾ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑ੦-ੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣ૦-૯ૺ-૿ଁ-ଃ଼ା-ୄେୈୋ-୍୕-ୗୢୣ୦-୯ஂா-ூெ-ைொ-்ௗ௦-௯ఀ-ఄ఼ా-ౄె-ైొ-్ౕౖౢౣ౦-౯ಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣ೦-೯ೳഀ-ഃ഻഼ാ-ൄെ-ൈൊ-്ൗൢൣ൦-൯ඁ-ඃ්ා-ුූෘ-ෟ෦-෯ෲෳัิ-ฺ็-๎๐-๙ັິ-ຼ່-໎໐-໙༘༙༠-༩༹༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှ၀-၉ၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏ-ႝ፝-፟፩-፱ᜒ-᜕ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝០-៩᠋-᠍᠏-᠙ᢩᤠ-ᤫᤰ-᤻᥆-᥏᧐-᧚ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼-᪉᪐-᪙᪰-᪽ᪿ-᫝᫠-᫫ᬀ-ᬄ᬴-᭄᭐-᭙᭫-᭳ᮀ-ᮂᮡ-ᮭ᮰-᮹᯦-᯳ᰤ-᰷᱀-᱉᱐-᱙᳐-᳔᳒-᳨᳭᳴᳷-᳹᷀-᷿‌‍‿⁀⁔⃐-⃥⃜⃡-⃰⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯・꘠-꘩꙯ꙴ-꙽ꚞꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧ꠬ꢀꢁꢴ-ꣅ꣐-꣙꣠-꣱ꣿ-꤉ꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀꧐-꧙ꧥ꧰-꧹ꨩ-ꨶꩃꩌꩍ꩐-꩙ꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭꯰-꯹ﬞ︀-️︠-︯︳︴﹍-﹏０-９＿･]");
 const astralIdentifierStartCodes = [
 	0,
 	11,
@@ -26818,10 +26824,6 @@ var StatementParser = class extends ExpressionParser {
 				decorators = [];
 			}
 			this.parseClassMember(classBody, member, state);
-			if (member.decorators && member.decorators.length > 0) {
-				if (this.hasPlugin("typescript") && (this.hasPlugin("estree") ? member.type === "TSAbstractMethodDefinition" : member.type === "TSDeclareMethod")) this.raise(Errors.DecoratorAbstractMethod, member);
-				if (member.kind === "constructor") this.raise(Errors.DecoratorConstructor, member);
-			}
 		}
 		this.state.strict = oldStrict;
 		this.next();
@@ -26900,6 +26902,7 @@ var StatementParser = class extends ExpressionParser {
 			let allowsDirectSuper = false;
 			if (isConstructor) {
 				publicMethod.kind = "constructor";
+				if (publicMethod.decorators && publicMethod.decorators.length > 0) this.raise(Errors.DecoratorConstructor, member);
 				if (state.hadConstructor && !this.hasPlugin("typescript")) this.raise(Errors.DuplicateConstructor, key);
 				if (isConstructor && this.hasPlugin("typescript") && member.override) this.raise(Errors.OverrideOnConstructor, key);
 				state.hadConstructor = true;
@@ -27076,7 +27079,7 @@ var StatementParser = class extends ExpressionParser {
 		}
 		throw this.unexpected(null, 2);
 	}
-	eatExportStar(node) {
+	eatExportStar(_) {
 		return this.eat(51);
 	}
 	maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier) {
@@ -27457,6 +27460,7 @@ const TSErrors = ParseErrorEnum`typescript`({
 	DeclareAccessor: ({ kind }) => `'declare' is not allowed in ${kind}ters.`,
 	DeclareClassFieldHasInitializer: "Initializers are not allowed in ambient contexts.",
 	DeclareFunctionHasImplementation: "An implementation cannot be declared in ambient contexts.",
+	DecoratorAbstractMethod: ({ kind }) => `Decorators can't be used with ${kind.startsWith("a") ? "an" : "a"} ${kind}.`,
 	DuplicateAccessibilityModifier: ({ modifier }) => `Accessibility modifier already seen: '${modifier}'.`,
 	DuplicateModifier: ({ modifier }) => `Duplicate modifier: '${modifier}'.`,
 	EmptyHeritageClauseType: ({ token }) => `'${token}' list cannot be empty.`,
@@ -29078,6 +29082,10 @@ const typescript = (superClass) => class TypeScriptParserMixin extends superClas
 		};
 		if (member.declare) this.tsInAmbientContext(callParseClassMemberWithIsStatic);
 		else callParseClassMemberWithIsStatic();
+		if (member.decorators && member.decorators.length > 0 && !this.hasPlugin("decorators-legacy")) {
+			if (member.type === "TSAbstractMethodDefinition" || member.type === "TSDeclareMethod") this.raise(TSErrors.DecoratorAbstractMethod, member, { kind: "abstract method" });
+			else if (member.type === "ClassProperty" && member.abstract || member.type === "ClassProperty" && member.declare || member.type === "TSAbstractPropertyDefinition" || member.type === "PropertyDefinition" && member.declare) this.raise(TSErrors.DecoratorAbstractMethod, member, { kind: member.declare ? "declare field" : "abstract field" });
+		}
 	}
 	parseClassMemberWithIsStatic(classBody, member, state, isStatic) {
 		const idx = this.tsTryParseIndexSignature(member);
@@ -30241,11 +30249,11 @@ var SyncWalker = class extends WalkerBase {
 						const nodes = value;
 						for (let i = 0; i < nodes.length; i += 1) {
 							const item = nodes[i];
-							if (isNode(item)) {
+							if (isNode$1(item)) {
 								if (!this.visit(item, node, key, i)) i--;
 							}
 						}
-					} else if (isNode(value)) this.visit(value, node, key, null);
+					} else if (isNode$1(value)) this.visit(value, node, key, null);
 				}
 			}
 			if (this.leave) {
@@ -30274,6 +30282,121 @@ var SyncWalker = class extends WalkerBase {
 * @param {unknown} value
 * @returns {value is Node}
 */
+function isNode$1(value) {
+	return value !== null && typeof value === "object" && "type" in value && typeof value.type === "string";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/async.js
+/**
+* @typedef { import('estree').Node} Node
+* @typedef { import('./walker.js').WalkerContext} WalkerContext
+* @typedef {(
+*    this: WalkerContext,
+*    node: Node,
+*    parent: Node | null,
+*    key: string | number | symbol | null | undefined,
+*    index: number | null | undefined
+* ) => Promise<void>} AsyncHandler
+*/
+var AsyncWalker = class extends WalkerBase {
+	/**
+	*
+	* @param {AsyncHandler} [enter]
+	* @param {AsyncHandler} [leave]
+	*/
+	constructor(enter, leave) {
+		super();
+		/** @type {boolean} */
+		this.should_skip = false;
+		/** @type {boolean} */
+		this.should_remove = false;
+		/** @type {Node | null} */
+		this.replacement = null;
+		/** @type {WalkerContext} */
+		this.context = {
+			skip: () => this.should_skip = true,
+			remove: () => this.should_remove = true,
+			replace: (node) => this.replacement = node
+		};
+		/** @type {AsyncHandler | undefined} */
+		this.enter = enter;
+		/** @type {AsyncHandler | undefined} */
+		this.leave = leave;
+	}
+	/**
+	* @template {Node} Parent
+	* @param {Node} node
+	* @param {Parent | null} parent
+	* @param {keyof Parent} [prop]
+	* @param {number | null} [index]
+	* @returns {Promise<Node | null>}
+	*/
+	async visit(node, parent, prop, index) {
+		if (node) {
+			if (this.enter) {
+				const _should_skip = this.should_skip;
+				const _should_remove = this.should_remove;
+				const _replacement = this.replacement;
+				this.should_skip = false;
+				this.should_remove = false;
+				this.replacement = null;
+				await this.enter.call(this.context, node, parent, prop, index);
+				if (this.replacement) {
+					node = this.replacement;
+					this.replace(parent, prop, index, node);
+				}
+				if (this.should_remove) this.remove(parent, prop, index);
+				const skipped = this.should_skip;
+				const removed = this.should_remove;
+				this.should_skip = _should_skip;
+				this.should_remove = _should_remove;
+				this.replacement = _replacement;
+				if (skipped) return node;
+				if (removed) return null;
+			}
+			/** @type {keyof Node} */
+			let key;
+			for (key in node) {
+				/** @type {unknown} */
+				const value = node[key];
+				if (value && typeof value === "object") {
+					if (Array.isArray(value)) {
+						const nodes = value;
+						for (let i = 0; i < nodes.length; i += 1) {
+							const item = nodes[i];
+							if (isNode(item)) {
+								if (!await this.visit(item, node, key, i)) i--;
+							}
+						}
+					} else if (isNode(value)) await this.visit(value, node, key, null);
+				}
+			}
+			if (this.leave) {
+				const _replacement = this.replacement;
+				const _should_remove = this.should_remove;
+				this.replacement = null;
+				this.should_remove = false;
+				await this.leave.call(this.context, node, parent, prop, index);
+				if (this.replacement) {
+					node = this.replacement;
+					this.replace(parent, prop, index, node);
+				}
+				if (this.should_remove) this.remove(parent, prop, index);
+				const removed = this.should_remove;
+				this.replacement = _replacement;
+				this.should_remove = _should_remove;
+				if (removed) return null;
+			}
+		}
+		return node;
+	}
+};
+/**
+* Ducktype a node.
+*
+* @param {unknown} value
+* @returns {value is Node}
+*/
 function isNode(value) {
 	return value !== null && typeof value === "object" && "type" in value && typeof value.type === "string";
 }
@@ -30295,6 +30418,17 @@ function isNode(value) {
 function walk(ast, { enter, leave }) {
 	return new SyncWalker(enter, leave).visit(ast, null);
 }
+/**
+* @param {Node} ast
+* @param {{
+*   enter?: AsyncHandler
+*   leave?: AsyncHandler
+* }} walker
+* @returns {Promise<Node | null>}
+*/
+async function asyncWalk(ast, { enter, leave }) {
+	return await new AsyncWalker(enter, leave).visit(ast, null);
+}
 //#endregion
 //#region ../../node_modules/.pnpm/ast-kit@3.0.0-beta.1/node_modules/ast-kit/dist/index.js
 /**
@@ -30468,6 +30602,16 @@ function resolveTemplateLiteral(node) {
 * @returns {T | null} - The modified AST node or null if the node is removed.
 */
 const walkAST = walk;
+/**
+* Asynchronously walks the AST starting from the given node,
+* applying the provided handlers to each node encountered.
+*
+* @template T - The type of the AST node.
+* @param {T} node - The root node of the AST.
+* @param {WalkHandlers<T, Promise<void>>} handlers - The handlers to be applied to each node.
+* @returns {Promise<T | null>} - A promise that resolves to the modified AST or null if the AST is empty.
+*/
+const walkASTAsync = asyncWalk;
 //#endregion
 //#region ../../node_modules/.pnpm/dts-resolver@3.0.0_oxc-resolver@11.19.1_@emnapi+core@1.10.0_@emnapi+runtime@1.10.0_/node_modules/dts-resolver/dist/index.mjs
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
@@ -30581,7 +30725,7 @@ function ensureValue(value) {
 	return value && ALLOW_EXTENSIONS.has(extname(value)) ? value.replaceAll("\\", "/") : null;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/rolldown-plugin-dts@0.25.0_@typescript+native-preview@7.0.0-dev.20260122.2_oxc-resolver_b3cc7660f16ac76b66135f298381de19/node_modules/rolldown-plugin-dts/dist/index.mjs
+//#region ../../node_modules/.pnpm/rolldown-plugin-dts@0.25.2_@typescript+native-preview@7.0.0-dev.20260122.2_oxc-resolver_8152cf0e534aee518f40abeb59f8494a/node_modules/rolldown-plugin-dts/dist/index.mjs
 function createDtsInputPlugin({ sideEffects }) {
 	return {
 		name: "rolldown-plugin-dts:dts-input",
@@ -30618,7 +30762,8 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 	let declarationIdx = 0;
 	const declarationMap = /* @__PURE__ */ new Map();
 	const commentsMap = /* @__PURE__ */ new Map();
-	const typeOnlyMap = /* @__PURE__ */ new Map();
+	const moduleExportsMap = /* @__PURE__ */ new Map();
+	const warnedCjsDtsInputs = /* @__PURE__ */ new Set();
 	return {
 		name: "rolldown-plugin-dts:fake-js",
 		outputOptions(options) {
@@ -30656,7 +30801,7 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 			}
 		}
 	};
-	function transform(code, id) {
+	async function transform(code, id) {
 		let file;
 		try {
 			file = parse$1(code, {
@@ -30669,8 +30814,12 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 			throw new Error(`Failed to parse ${id}. This may be caused by a syntax error in the declaration file or a bug in the plugin. Please report this issue to https://github.com/sxzz/rolldown-plugin-dts\n${error}`, { cause: error });
 		}
 		const { program, comments } = file;
-		const typeOnlyIds = [];
+		moduleExportsMap.set(id, await collectModuleExports(this, program.body, id));
 		const identifierMap = Object.create(null);
+		if (!warnedCjsDtsInputs.has(id) && program.body.some(isCjsDtsInputSyntax)) {
+			warnedCjsDtsInputs.add(id);
+			this.warn(RE_NODE_MODULES.test(id) ? `${id} uses CommonJS dts syntax. CommonJS dts modules cannot be reliably bundled by rolldown-plugin-dts. Please mark this module as external in your Rolldown config.` : `${id} uses CommonJS dts syntax. rolldown-plugin-dts does not support reliably bundling CommonJS dts input.`);
+		}
 		if (comments) {
 			const directives = collectReferenceDirectives(comments);
 			commentsMap.set(id, directives);
@@ -30679,7 +30828,7 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 		const namespaceStmts = /* @__PURE__ */ new Map();
 		for (const [i, stmt] of program.body.entries()) {
 			const setStmt = (stmt) => program.body[i] = stmt;
-			if (rewriteImportExport(stmt, setStmt, typeOnlyIds)) continue;
+			if (rewriteImportExport(stmt, setStmt)) continue;
 			const sideEffect = stmt.type === "TSModuleDeclaration" && stmt.kind !== "namespace";
 			if (sideEffect && stmt.id.type === "StringLiteral" && stmt.id.value[0] === ".") this.warn(`\`declare module ${JSON.stringify(stmt.id.value)}\` will be kept as-is in the output. Relative module declaration may cause unexpected issues. Found in ${id}.`);
 			if (sideEffect && id.endsWith(".vue.d.ts") && code.slice(stmt.start, stmt.end).includes("__VLS_")) continue;
@@ -30717,7 +30866,7 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 			}
 			const params = collectParams(decl);
 			const childrenSet = /* @__PURE__ */ new Set();
-			const deps = collectDependencies(decl, namespaceStmts, childrenSet, identifierMap);
+			const deps = await collectDependencies(this, decl, id, namespaceStmts, childrenSet, identifierMap);
 			const children = Array.from(childrenSet).filter((child) => bindings.every((b) => child !== b));
 			if (decl !== stmt) decl.leadingComments = stmt.leadingComments;
 			const declarationIdNode = {
@@ -30820,7 +30969,6 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 			...program.body,
 			...appendStmts
 		];
-		typeOnlyMap.set(id, typeOnlyIds);
 		const result = generate(file, {
 			comments: false,
 			sourceMaps: sourcemap,
@@ -30833,11 +30981,7 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 	}
 	function renderChunk(code, chunk) {
 		if (!RE_DTS.test(chunk.fileName)) return;
-		const typeOnlyIds = [];
-		for (const module of chunk.moduleIds) {
-			const ids = typeOnlyMap.get(module);
-			if (ids) typeOnlyIds.push(...ids);
-		}
+		const exportInfo = collectChunkExportInfo(chunk, moduleExportsMap);
 		let file;
 		try {
 			file = parse$1(code, { sourceType: "module" });
@@ -30850,7 +30994,7 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 		program.body = program.body.map((node) => {
 			if (isHelperImport(node)) return null;
 			if (node.type === "ExpressionStatement") return null;
-			const newNode = patchImportExport(node, typeOnlyIds, cjsDefault);
+			const newNode = patchImportExport(node, exportInfo, cjsDefault);
 			if (newNode || newNode === false) return newNode;
 			if (node.type !== "VariableDeclaration") return node;
 			if (!isRuntimeBindingVariableDeclaration(node)) return null;
@@ -30918,10 +31062,6 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 			map: result.map
 		};
 	}
-	function getIdentifierIndex(identifierMap, name) {
-		if (name in identifierMap) return ++identifierMap[name];
-		return identifierMap[name] = 0;
-	}
 	function registerDeclaration(info) {
 		const declarationId = declarationIdx++;
 		declarationMap.set(declarationId, info);
@@ -30930,141 +31070,289 @@ function createFakeJsPlugin({ sourcemap, cjsDefault, sideEffects }) {
 	function getDeclaration(declarationId) {
 		return declarationMap.get(declarationId);
 	}
-	/**
-	* Collects all TSTypeParameter nodes from the given node and groups them by
-	* their name. One name can associate with one or more type parameters. These
-	* names will be used as the parameter name in the generated JavaScript
-	* dependency function.
-	*/
-	function collectParams(node) {
-		const typeParams = [];
-		walkAST(node, { leave(node) {
-			if ("typeParameters" in node && node.typeParameters?.type === "TSTypeParameterDeclaration") typeParams.push(...node.typeParameters.params.map(({ name }) => typeof name === "string" ? {
-				type: "Identifier",
-				name
-			} : name));
-		} });
-		const paramMap = /* @__PURE__ */ new Map();
-		for (const typeParam of typeParams) {
-			const name = typeParam.name;
-			const group = paramMap.get(name);
-			if (group) group.push(typeParam);
-			else paramMap.set(name, [typeParam]);
-		}
-		return Array.from(paramMap.entries()).map(([name, typeParams]) => ({
-			name,
-			typeParams
-		}));
+}
+async function collectModuleExports(context, nodes, id) {
+	const info = {
+		typeOnlyLocals: /* @__PURE__ */ new Set(),
+		exports: /* @__PURE__ */ new Map(),
+		reExports: [],
+		exportAlls: []
+	};
+	for (const node of nodes) collectTypeOnlyLocals(node, info.typeOnlyLocals);
+	for (const node of nodes) await collectExportInfo(context, node, id, info);
+	return info;
+}
+function collectTypeOnlyLocals(node, typeOnlyLocals) {
+	if (node.type !== "ImportDeclaration") return;
+	for (const specifier of node.specifiers) if (node.importKind === "type" || "importKind" in specifier && specifier.importKind === "type") typeOnlyLocals.add(specifier.local.name);
+}
+function collectDeclarationNames(node) {
+	if (node.type === "VariableDeclaration") return node.declarations.flatMap((decl) => collectPatternNames(decl.id));
+	if ("id" in node && node.id) {
+		if (node.id.type !== "Identifier" && node.id.type !== "TSQualifiedName") return [];
+		const id = getIdFromTSEntityName(node.id);
+		return id.type === "Identifier" ? [id.name] : [];
+	}
+	return [];
+}
+function collectPatternNames(node) {
+	if (!node) return [];
+	if (node.type === "Identifier") return [node.name];
+	if (node.type === "RestElement") return collectPatternNames(node.argument);
+	if (node.type === "AssignmentPattern") return collectPatternNames(node.left);
+	if (node.type === "ArrayPattern") return node.elements.flatMap((element) => collectPatternNames(element));
+	if (node.type === "ObjectPattern") return node.properties.flatMap((property) => {
+		if (property.type === "RestElement") return collectPatternNames(property.argument);
+		return collectPatternNames(property.value);
+	});
+	return [];
+}
+function isTypeOnlyExport(node, specifier) {
+	return node.exportKind === "type" || "exportKind" in specifier && specifier.exportKind === "type";
+}
+async function collectExportInfo(context, node, id, info) {
+	if (node.type === "ExportNamedDeclaration") {
+		if (node.declaration) {
+			for (const name of collectDeclarationNames(node.declaration)) info.exports.set(name, false);
+			return;
+		}
+		const source = await resolveExportSource(context, node.source, id);
+		for (const specifier of node.specifiers) {
+			const typeOnly = isTypeOnlyExport(node, specifier);
+			if (specifier.type === "ExportSpecifier") {
+				const exported = resolveString(specifier.exported);
+				const local = resolveString(specifier.local);
+				if (source) info.reExports.push({
+					source,
+					local,
+					exported,
+					typeOnly
+				});
+				else info.exports.set(exported, typeOnly || info.typeOnlyLocals.has(local));
+			} else {
+				const exported = resolveString(specifier.exported);
+				info.exports.set(exported, typeOnly);
+			}
+		}
+		return;
 	}
-	function collectDependencies(node, namespaceStmts, children, identifierMap) {
-		const deps = /* @__PURE__ */ new Set();
-		const seen = /* @__PURE__ */ new Set();
-		const inferredStack = [];
-		let currentInferred = /* @__PURE__ */ new Set();
-		function isInferred(node) {
-			return node.type === "Identifier" && currentInferred.has(node.name);
-		}
-		walkAST(node, {
-			enter(node) {
-				if (node.type === "TSConditionalType") {
-					const inferred = collectInferredNames(node.extendsType);
-					inferredStack.push(inferred);
-				}
-			},
-			leave(node, parent) {
-				if (node.type === "TSConditionalType") inferredStack.pop();
-				else if (parent?.type === "TSConditionalType") {
-					const trueBranch = parent.trueType === node;
-					currentInferred = new Set((trueBranch ? inferredStack : inferredStack.slice(0, -1)).flat());
-				} else currentInferred = /* @__PURE__ */ new Set();
-				if (node.type === "ExportNamedDeclaration") {
-					for (const specifier of node.specifiers) if (specifier.type === "ExportSpecifier") addDependency(specifier.local);
-				} else if (node.type === "TSInterfaceDeclaration" && node.extends) for (const heritage of node.extends || []) addDependency(heritage.expression);
-				else if (node.type === "ClassDeclaration") {
-					if (node.superClass) addDependency(node.superClass);
-					if (node.implements) for (const implement of node.implements) {
-						if (implement.type === "ClassImplements") throw new Error("Unexpected Flow syntax");
-						addDependency(implement.expression);
-					}
-				} else if (isTypeOf(node, [
-					"ObjectMethod",
-					"ObjectProperty",
-					"ClassProperty",
-					"TSPropertySignature",
-					"TSDeclareMethod"
-				])) {
-					if (node.computed && isReferenceId(node.key)) addDependency(node.key);
-					if ("value" in node && isReferenceId(node.value)) addDependency(node.value);
-				} else switch (node.type) {
-					case "TSTypeReference":
-						addDependency(TSEntityNameToRuntime(node.typeName));
-						break;
-					case "TSTypeQuery":
-						if (seen.has(node.exprName)) return;
-						if (node.exprName.type === "TSImportType") break;
-						addDependency(TSEntityNameToRuntime(node.exprName));
-						break;
-					case "TSImportType": {
-						seen.add(node);
-						const { source, qualifier } = node;
-						addDependency(importNamespace(node, qualifier, source, namespaceStmts, identifierMap));
-						break;
-					}
+	if (node.type === "ExportDefaultDeclaration") {
+		info.exports.set("default", false);
+		return;
+	}
+	if (node.type === "ExportAllDeclaration") info.exportAlls.push({
+		source: await resolveExportSource(context, node.source, id),
+		rawSource: node.source.value,
+		typeOnly: node.exportKind === "type"
+	});
+}
+async function resolveExportSource(context, source, importer) {
+	if (!source) return;
+	const resolved = await context.resolve(source.value, importer);
+	if (!resolved || resolved.external) return;
+	return resolved.id;
+}
+function collectChunkExportInfo(chunk, moduleExportsMap) {
+	const exportsByModule = resolveAllModuleExports(moduleExportsMap);
+	const roots = chunk.facadeModuleId && moduleExportsMap.has(chunk.facadeModuleId) ? [chunk.facadeModuleId] : chunk.moduleIds;
+	const mergedExports = /* @__PURE__ */ new Map();
+	const typeOnlyExportAllSources = /* @__PURE__ */ new Set();
+	for (const root of roots) {
+		const exports = exportsByModule.get(root);
+		if (exports) for (const [name, typeOnly] of exports) setExportTypeOnly(mergedExports, name, typeOnly);
+		const moduleExports = moduleExportsMap.get(root);
+		if (!moduleExports) continue;
+		for (const exportAll of moduleExports.exportAlls) {
+			if (!exportAll.typeOnly || exportAll.source) continue;
+			typeOnlyExportAllSources.add(exportAll.rawSource);
+		}
+	}
+	const typeOnlyNames = /* @__PURE__ */ new Set();
+	for (const [name, typeOnly] of mergedExports) if (typeOnly) typeOnlyNames.add(name);
+	return {
+		typeOnlyNames,
+		typeOnlyExportAllSources
+	};
+}
+function resolveAllModuleExports(moduleExportsMap) {
+	const exportsByModule = /* @__PURE__ */ new Map();
+	for (const [id, info] of moduleExportsMap) exportsByModule.set(id, new Map(info.exports));
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const [id, info] of moduleExportsMap) {
+			const exports = exportsByModule.get(id);
+			for (const reExport of info.reExports) {
+				const sourceTypeOnly = (reExport.source ? exportsByModule.get(reExport.source) : void 0)?.get(reExport.local) ?? false;
+				if (setExportTypeOnly(exports, reExport.exported, reExport.typeOnly || sourceTypeOnly)) changed = true;
+			}
+			for (const exportAll of info.exportAlls) {
+				if (!exportAll.source) continue;
+				const sourceExports = exportsByModule.get(exportAll.source);
+				if (!sourceExports) continue;
+				for (const [name, typeOnly] of sourceExports) {
+					if (name === "default") continue;
+					if (setExportTypeOnly(exports, name, exportAll.typeOnly || typeOnly)) changed = true;
 				}
-				if (parent && !deps.has(node) && isChildSymbol(node, parent)) children.add(node);
 			}
-		});
-		return Array.from(deps);
-		function addDependency(node) {
-			if (isThisExpression(node) || isInferred(node)) return;
-			deps.add(node);
 		}
 	}
-	function importNamespace(node, imported, source, namespaceStmts, identifierMap) {
-		const sourceText = source.value.replaceAll(/\W/g, "_");
-		let local = {
+	return exportsByModule;
+}
+function setExportTypeOnly(exports, name, typeOnly) {
+	const current = exports.get(name);
+	if (current === false || current === typeOnly) return false;
+	if (current === void 0 || !typeOnly) {
+		exports.set(name, typeOnly);
+		return true;
+	}
+	return false;
+}
+/**
+* Collects all TSTypeParameter nodes from the given node and groups them by
+* their name. One name can associate with one or more type parameters. These
+* names will be used as the parameter name in the generated JavaScript
+* dependency function.
+*/
+function collectParams(node) {
+	const typeParams = [];
+	walkAST(node, { leave(node) {
+		if ("typeParameters" in node && node.typeParameters?.type === "TSTypeParameterDeclaration") typeParams.push(...node.typeParameters.params.map(({ name }) => typeof name === "string" ? {
 			type: "Identifier",
-			name: `_$${isIdentifierName(source.value) ? source.value : `${sourceText}${getIdentifierIndex(identifierMap, sourceText)}`}`
-		};
-		if (namespaceStmts.has(source.value)) local = namespaceStmts.get(source.value).local;
-		else namespaceStmts.set(source.value, {
-			stmt: {
-				type: "ImportDeclaration",
-				specifiers: [{
-					type: "ImportNamespaceSpecifier",
-					local
-				}],
-				source,
-				attributes: null
-			},
-			local
-		});
-		if (imported) {
-			const importedLeft = getIdFromTSEntityName(imported);
-			if (imported.type === "ThisExpression" || importedLeft.type === "ThisExpression") throw new Error("Cannot import `this` from module.");
-			overwriteNode(importedLeft, {
-				type: "TSQualifiedName",
-				left: local,
-				right: { ...importedLeft }
-			});
-			local = imported;
-		}
-		let replacement = node;
-		if (node.typeArguments) {
-			overwriteNode(node, {
-				type: "TSTypeReference",
-				typeName: local,
-				typeArguments: node.typeArguments
-			});
-			replacement = local;
-		} else overwriteNode(node, local);
-		return {
-			...TSEntityNameToRuntime(local),
-			replace(newNode) {
-				overwriteNode(replacement, newNode);
+			name
+		} : name));
+	} });
+	const paramMap = /* @__PURE__ */ new Map();
+	for (const typeParam of typeParams) {
+		const name = typeParam.name;
+		const group = paramMap.get(name);
+		if (group) group.push(typeParam);
+		else paramMap.set(name, [typeParam]);
+	}
+	return Array.from(paramMap.entries()).map(([name, typeParams]) => ({
+		name,
+		typeParams
+	}));
+}
+async function collectDependencies(context, node, importer, namespaceStmts, children, identifierMap) {
+	const deps = /* @__PURE__ */ new Set();
+	const seen = /* @__PURE__ */ new Set();
+	const preserveImportTypeCache = /* @__PURE__ */ new Map();
+	const inferredStack = [];
+	let currentInferred = /* @__PURE__ */ new Set();
+	function isInferred(node) {
+		return node.type === "Identifier" && currentInferred.has(node.name);
+	}
+	await walkASTAsync(node, {
+		enter(node) {
+			if (node.type === "TSConditionalType") {
+				const inferred = collectInferredNames(node.extendsType);
+				inferredStack.push(inferred);
 			}
-		};
+			return Promise.resolve();
+		},
+		async leave(node, parent) {
+			if (node.type === "TSConditionalType") inferredStack.pop();
+			else if (parent?.type === "TSConditionalType") {
+				const trueBranch = parent.trueType === node;
+				currentInferred = new Set((trueBranch ? inferredStack : inferredStack.slice(0, -1)).flat());
+			} else currentInferred = /* @__PURE__ */ new Set();
+			if (node.type === "ExportNamedDeclaration") {
+				for (const specifier of node.specifiers) if (specifier.type === "ExportSpecifier") addDependency(specifier.local);
+			} else if (node.type === "TSInterfaceDeclaration" && node.extends) for (const heritage of node.extends || []) addDependency(heritage.expression);
+			else if (node.type === "ClassDeclaration") {
+				if (node.superClass) addDependency(node.superClass);
+				if (node.implements) for (const implement of node.implements) {
+					if (implement.type === "ClassImplements") throw new Error("Unexpected Flow syntax");
+					addDependency(implement.expression);
+				}
+			} else if (isTypeOf(node, [
+				"ObjectMethod",
+				"ObjectProperty",
+				"ClassProperty",
+				"TSPropertySignature",
+				"TSDeclareMethod",
+				"TSMethodSignature"
+			])) {
+				if (node.computed && isReferenceId(node.key)) addDependency(node.key);
+				if ("value" in node && isReferenceId(node.value)) addDependency(node.value);
+			} else switch (node.type) {
+				case "TSTypeReference":
+					addDependency(TSEntityNameToRuntime(node.typeName));
+					break;
+				case "TSTypeQuery":
+					if (seen.has(node.exprName)) return;
+					if (node.exprName.type === "TSImportType") break;
+					addDependency(TSEntityNameToRuntime(node.exprName));
+					break;
+				case "TSImportType": {
+					seen.add(node);
+					const { source, qualifier } = node;
+					const dep = await importNamespace(context, importer, node, qualifier, source, namespaceStmts, identifierMap, preserveImportTypeCache);
+					if (dep) addDependency(dep);
+					break;
+				}
+			}
+			if (parent && !deps.has(node) && isChildSymbol(node, parent)) children.add(node);
+		}
+	});
+	return Array.from(deps);
+	function addDependency(node) {
+		if (isThisExpression(node) || isInferred(node)) return;
+		deps.add(node);
+	}
+}
+async function importNamespace(context, importer, node, imported, source, namespaceStmts, identifierMap, preserveCache) {
+	let preserve = preserveCache.get(source.value);
+	if (preserve === void 0) {
+		const resolved = await context.resolve(source.value, importer);
+		preserve = !resolved || !!resolved.external;
+		preserveCache.set(source.value, preserve);
+	}
+	if (preserve) return;
+	const sourceText = source.value.replaceAll(/\W/g, "_");
+	let local = {
+		type: "Identifier",
+		name: `_$${isIdentifierName(source.value) ? source.value : `${sourceText}${getIdentifierIndex(identifierMap, sourceText)}`}`
+	};
+	if (namespaceStmts.has(source.value)) local = namespaceStmts.get(source.value).local;
+	else namespaceStmts.set(source.value, {
+		stmt: {
+			type: "ImportDeclaration",
+			specifiers: [{
+				type: "ImportNamespaceSpecifier",
+				local
+			}],
+			source,
+			attributes: null
+		},
+		local
+	});
+	if (imported) {
+		const importedLeft = getIdFromTSEntityName(imported);
+		if (imported.type === "ThisExpression" || importedLeft.type === "ThisExpression") throw new Error("Cannot import `this` from module.");
+		overwriteNode(importedLeft, {
+			type: "TSQualifiedName",
+			left: local,
+			right: { ...importedLeft }
+		});
+		local = imported;
 	}
+	let replacement = node;
+	if (node.typeArguments) {
+		overwriteNode(node, {
+			type: "TSTypeReference",
+			typeName: local,
+			typeArguments: node.typeArguments
+		});
+		replacement = local;
+	} else overwriteNode(node, local);
+	return {
+		...TSEntityNameToRuntime(local),
+		replace(newNode) {
+			overwriteNode(replacement, newNode);
+		}
+	};
 }
 function isChildSymbol(node, parent) {
 	if (node.type === "Identifier") return true;
@@ -31082,6 +31370,9 @@ const REFERENCE_RE = /\/\s*<reference\s+(?:path|types)=/;
 function collectReferenceDirectives(comment, negative = false) {
 	return comment.filter((c) => REFERENCE_RE.test(c.value) !== negative);
 }
+function isCjsDtsInputSyntax(node) {
+	return node.type === "TSExportAssignment" || node.type === "TSImportEqualsDeclaration" && node.moduleReference.type === "TSExternalModuleReference";
+}
 /**
 * Check if the given node is a {@link RuntimeBindingVariableDeclration}
 */
@@ -31136,7 +31427,7 @@ function isHelperImport(node) {
 /**
 * patch `.d.ts` suffix in import source to `.js`
 */
-function patchImportExport(node, typeOnlyIds, cjsDefault) {
+function patchImportExport(node, exportInfo, cjsDefault) {
 	if (node.type === "ExportNamedDeclaration" && !node.declaration && !node.source && !node.specifiers.length && !node.attributes?.length) return false;
 	if (node.type === "ImportDeclaration" && node.specifiers.length) {
 		for (const specifier of node.specifiers) if (isInfer(specifier.local)) specifier.local.name = "__Infer";
@@ -31146,10 +31437,14 @@ function patchImportExport(node, typeOnlyIds, cjsDefault) {
 		"ExportAllDeclaration",
 		"ExportNamedDeclaration"
 	])) {
-		if (node.type === "ExportNamedDeclaration" && typeOnlyIds.length) for (const spec of node.specifiers) {
-			const name = resolveString(spec.exported);
-			if (typeOnlyIds.includes(name)) if (spec.type === "ExportSpecifier") spec.exportKind = "type";
-			else node.exportKind = "type";
+		if (node.type === "ExportAllDeclaration" && node.source && exportInfo.typeOnlyExportAllSources.has(node.source.value)) node.exportKind = "type";
+		if (node.type === "ExportNamedDeclaration" && exportInfo.typeOnlyNames.size) {
+			for (const spec of node.specifiers) {
+				const name = resolveString(spec.exported);
+				if (exportInfo.typeOnlyNames.has(name)) if (spec.type === "ExportSpecifier") spec.exportKind = "type";
+				else node.exportKind = "type";
+			}
+			normalizeTypeOnlyExport(node);
 		}
 		if (node.source?.value && RE_DTS.test(node.source.value)) {
 			node.source.value = filename_dts_to(node.source.value, "js");
@@ -31161,13 +31456,19 @@ function patchImportExport(node, typeOnlyIds, cjsDefault) {
 		};
 	}
 }
+function normalizeTypeOnlyExport(node) {
+	if (node.declaration || !node.specifiers.length) return;
+	for (const specifier of node.specifiers) if (specifier.type !== "ExportSpecifier" || specifier.exportKind !== "type") return;
+	node.exportKind = "type";
+	for (const specifier of node.specifiers) if (specifier.type === "ExportSpecifier") specifier.exportKind = "value";
+}
 /**
 * Handle `__exportAll` call
 */
 function patchTsNamespace(nodes) {
 	const removed = /* @__PURE__ */ new Set();
 	for (const [i, node] of nodes.entries()) {
-		const result = handleExport(node);
+		const result = getExportAllNamespace(node);
 		if (!result) continue;
 		const [binding, exports] = result;
 		if (!exports.properties.length) continue;
@@ -31194,10 +31495,10 @@ function patchTsNamespace(nodes) {
 		};
 	}
 	return nodes.filter((node) => !removed.has(node));
-	function handleExport(node) {
-		if (node.type !== "VariableDeclaration" || node.declarations.length !== 1 || node.declarations[0].id.type !== "Identifier" || node.declarations[0].init?.type !== "CallExpression" || node.declarations[0].init.callee.type !== "Identifier" || node.declarations[0].init.callee.name !== "__exportAll" || node.declarations[0].init.arguments.length !== 1 || node.declarations[0].init.arguments[0].type !== "ObjectExpression") return false;
-		return [node.declarations[0].id, node.declarations[0].init.arguments[0]];
-	}
+}
+function getExportAllNamespace(node) {
+	if (node.type !== "VariableDeclaration" || node.declarations.length !== 1 || node.declarations[0].id.type !== "Identifier" || node.declarations[0].init?.type !== "CallExpression" || node.declarations[0].init.callee.type !== "Identifier" || node.declarations[0].init.callee.name !== "__exportAll" || node.declarations[0].init.arguments.length !== 1 || node.declarations[0].init.arguments[0].type !== "ObjectExpression") return false;
+	return [node.declarations[0].id, node.declarations[0].init.arguments[0]];
 }
 /**
 * Handle `__reExport` call
@@ -31232,13 +31533,10 @@ function patchReExport(nodes) {
 	else if (node.type === "ExportNamedDeclaration" && node.specifiers.length === 1 && node.specifiers[0].type === "ExportSpecifier" && node.specifiers[0].local.type === "Identifier" && exportsNames.has(node.specifiers[0].local.name)) node.specifiers[0].local.name = exportsNames.get(node.specifiers[0].local.name);
 	return nodes;
 }
-function rewriteImportExport(node, set, typeOnlyIds) {
+function rewriteImportExport(node, set) {
 	if (node.type === "ImportDeclaration" || node.type === "ExportNamedDeclaration" && !node.declaration) {
-		for (const specifier of node.specifiers) {
-			if ("exportKind" in specifier && specifier.exportKind === "type" || "exportKind" in node && node.exportKind === "type") typeOnlyIds.push(resolveString(specifier.exported));
-			if (specifier.type === "ImportSpecifier") specifier.importKind = "value";
-			else if (specifier.type === "ExportSpecifier") specifier.exportKind = "value";
-		}
+		for (const specifier of node.specifiers) if (specifier.type === "ImportSpecifier") specifier.importKind = "value";
+		else if (specifier.type === "ExportSpecifier") specifier.exportKind = "value";
 		if (node.type === "ImportDeclaration") node.importKind = "value";
 		else if (node.type === "ExportNamedDeclaration") node.exportKind = "value";
 		return true;
@@ -31296,6 +31594,10 @@ function inheritNodeComments(oldNode, newNode) {
 	newNode.leadingComments = collectReferenceDirectives(newNode.leadingComments, true);
 	return newNode;
 }
+function getIdentifierIndex(identifierMap, name) {
+	if (name in identifierMap) return ++identifierMap[name];
+	return identifierMap[name] = 0;
+}
 const debug$3 = createDebug("rolldown-plugin-dts:tsgo");
 const spawnAsync = (...args) => new Promise((resolve, reject) => {
 	const child = spawn(...args);
@@ -31365,12 +31667,12 @@ function createGeneratePlugin({ entry, tsconfig, tsconfigRaw, build, incremental
 			if (tsgo) tsgoDist = await runTsgo(rootDir, tsconfig, sourcemap, tsgo.path);
 			else if (!oxc) if (parallel) {
 				childProcess = fork(new URL(WORKER_URL, import.meta.url), { stdio: "inherit" });
-				rpc = (await import("./dist-JaOach5K.js")).createBirpc({}, {
+				rpc = (await import("./dist-CZtGyfn3.js")).createBirpc({}, {
 					post: (data) => childProcess.send(data),
 					on: (fn) => childProcess.on("message", fn)
 				});
 			} else {
-				tscModule = await import("./tsc-Dr9kCkDm.js");
+				tscModule = await import("./tsc-WMktM0FW.js");
 				if (newContext) tscContext = createContext();
 			}
 			if (!Array.isArray(options.input)) for (const [name, id] of Object.entries(options.input)) {
@@ -31702,7 +32004,7 @@ function createDtsResolvePlugin({ cwd, tsconfig, tsconfigRaw, resolver, sideEffe
 	async function resolveDtsPath(id, importer, rolldownResolution) {
 		let dtsPath;
 		if (resolver === "tsc") {
-			const { tscResolve } = await import("./resolver-DkvdaW3s-BeVUoOo-.js");
+			const { tscResolve } = await import("./resolver-DtsKFXi2-QB-x8j3e.js");
 			dtsPath = tscResolve(id, importer, cwd, tsconfig, tsconfigRaw);
 		} else dtsPath = baseDtsResolver(id, importer);
 		debug$1("Using %s for dts import: %O -> %O", resolver, id, dtsPath);