@prismicio/cli 0.0.1 → 0.0.2-alpha.xru-fix-npx-install-warnings.2

package/dist/estree-DHLJIae3.js

@@ -0,0 +1,4486 @@
+var fa = Object.defineProperty;
+var _n = (e, t) => {
+  for (var r in t) fa(e, r, { get: t[r], enumerable: true });
+};
+var pa = {};
+_n(pa, { languages: () => Qm, options: () => aa, printers: () => Km });
+var $s = [{ name: "JavaScript", type: "programming", aceMode: "javascript", extensions: [".js", "._js", ".bones", ".cjs", ".es", ".es6", ".gs", ".jake", ".javascript", ".jsb", ".jscad", ".jsfl", ".jslib", ".jsm", ".jspre", ".jss", ".mjs", ".njs", ".pac", ".sjs", ".ssjs", ".xsjs", ".xsjslib", ".start.frag", ".end.frag", ".wxs"], filenames: ["Jakefile", "start.frag", "end.frag"], tmScope: "source.js", aliases: ["js", "node"], codemirrorMode: "javascript", codemirrorMimeType: "text/javascript", interpreters: ["chakra", "d8", "gjs", "js", "node", "nodejs", "qjs", "rhino", "v8", "v8-shell", "zx"], parsers: ["babel", "acorn", "espree", "meriyah", "babel-flow", "babel-ts", "flow", "typescript"], vscodeLanguageIds: ["javascript", "mongo"], linguistLanguageId: 183 }, { name: "Flow", type: "programming", aceMode: "javascript", extensions: [".js.flow"], filenames: [], tmScope: "source.js", aliases: [], codemirrorMode: "javascript", codemirrorMimeType: "text/javascript", interpreters: ["chakra", "d8", "gjs", "js", "node", "nodejs", "qjs", "rhino", "v8", "v8-shell"], parsers: ["flow", "babel-flow"], vscodeLanguageIds: ["javascript"], linguistLanguageId: 183 }, { name: "JSX", type: "programming", aceMode: "javascript", extensions: [".jsx"], filenames: void 0, tmScope: "source.js.jsx", aliases: void 0, codemirrorMode: "jsx", codemirrorMimeType: "text/jsx", interpreters: void 0, parsers: ["babel", "babel-flow", "babel-ts", "flow", "typescript", "espree", "meriyah"], vscodeLanguageIds: ["javascriptreact"], group: "JavaScript", linguistLanguageId: 183 }, { name: "TypeScript", type: "programming", aceMode: "typescript", extensions: [".ts", ".cts", ".mts"], tmScope: "source.ts", aliases: ["ts"], codemirrorMode: "javascript", codemirrorMimeType: "application/typescript", interpreters: ["bun", "deno", "ts-node", "tsx"], parsers: ["typescript", "babel-ts"], vscodeLanguageIds: ["typescript"], linguistLanguageId: 378 }, { name: "TSX", type: "programming", aceMode: "tsx", extensions: [".tsx"], tmScope: "source.tsx", codemirrorMode: "jsx", codemirrorMimeType: "text/typescript-jsx", group: "TypeScript", parsers: ["typescript", "babel-ts"], vscodeLanguageIds: ["typescriptreact"], linguistLanguageId: 94901924 }];
+var Ys = {};
+_n(Ys, { canAttachComment: () => Qi, embed: () => yu, features: () => Ym, getVisitorKeys: () => Lr, handleComments: () => ms, hasPrettierIgnore: () => Qt, insertPragma: () => bu, isBlockComment: () => ee, isGap: () => Zi, massageAstNode: () => gi, print: () => qs, printComment: () => rs, printPrettierIgnored: () => qs, willPrintOwnComments: () => zi });
+var Jt = (e, t) => (r, n, ...s) => r | 1 && n == null ? void 0 : (t.call(n) ?? n[e]).apply(n, s);
+var ya = String.prototype.replaceAll ?? function(e, t) {
+  return e.global ? this.replace(e, t) : this.split(e).join(t);
+}, Ea = Jt("replaceAll", function() {
+  if (typeof this == "string") return ya;
+}), G = Ea;
+function Fa(e) {
+  return this[e < 0 ? this.length + e : e];
+}
+var da = Jt("at", function() {
+  if (Array.isArray(this) || typeof this == "string") return Fa;
+}), _ = da;
+function Ca(e) {
+  return e !== null && typeof e == "object";
+}
+var Ks = Ca;
+function* Aa(e, t) {
+  let { getVisitorKeys: r, filter: n = () => true } = t, s = (i) => Ks(i) && n(i);
+  for (let i of r(e)) {
+    let u = e[i];
+    if (Array.isArray(u)) for (let o of u) s(o) && (yield o);
+    else s(u) && (yield u);
+  }
+}
+function* Ta(e, t) {
+  let r = [e];
+  for (let n = 0; n < r.length; n++) {
+    let s = r[n];
+    for (let i of Aa(s, t)) yield i, r.push(i);
+  }
+}
+function Qs(e, { getVisitorKeys: t, predicate: r }) {
+  for (let n of Ta(e, { getVisitorKeys: t })) if (r(n)) return true;
+  return false;
+}
+var zs = () => /[#*0-9]\uFE0F?\u20E3|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26AA\u26B0\u26B1\u26BD\u26BE\u26C4\u26C8\u26CF\u26D1\u26E9\u26F0-\u26F5\u26F7\u26F8\u26FA\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2757\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B55\u3030\u303D\u3297\u3299]\uFE0F?|[\u261D\u270C\u270D](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?|[\u270A\u270B](?:\uD83C[\uDFFB-\uDFFF])?|[\u23E9-\u23EC\u23F0\u23F3\u25FD\u2693\u26A1\u26AB\u26C5\u26CE\u26D4\u26EA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2795-\u2797\u27B0\u27BF\u2B50]|\u26D3\uFE0F?(?:\u200D\uD83D\uDCA5)?|\u26F9(?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|\u2764\uFE0F?(?:\u200D(?:\uD83D\uDD25|\uD83E\uDE79))?|\uD83C(?:[\uDC04\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]\uFE0F?|[\uDF85\uDFC2\uDFC7](?:\uD83C[\uDFFB-\uDFFF])?|[\uDFC4\uDFCA](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDFCB\uDFCC](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF43\uDF45-\uDF4A\uDF4C-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uDDE6\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF]|\uDDE7\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF]|\uDDE8\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF7\uDDFA-\uDDFF]|\uDDE9\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF]|\uDDEA\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA]|\uDDEB\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7]|\uDDEC\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE]|\uDDED\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA]|\uDDEE\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9]|\uDDEF\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5]|\uDDF0\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF]|\uDDF1\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE]|\uDDF2\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF]|\uDDF3\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF]|\uDDF4\uD83C\uDDF2|\uDDF5\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE]|\uDDF6\uD83C\uDDE6|\uDDF7\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC]|\uDDF8\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF]|\uDDF9\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF]|\uDDFA\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF]|\uDDFB\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA]|\uDDFC\uD83C[\uDDEB\uDDF8]|\uDDFD\uD83C\uDDF0|\uDDFE\uD83C[\uDDEA\uDDF9]|\uDDFF\uD83C[\uDDE6\uDDF2\uDDFC]|\uDF44(?:\u200D\uD83D\uDFEB)?|\uDF4B(?:\u200D\uD83D\uDFE9)?|\uDFC3(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?|\uDFF3\uFE0F?(?:\u200D(?:\u26A7\uFE0F?|\uD83C\uDF08))?|\uDFF4(?:\u200D\u2620\uFE0F?|\uDB40\uDC67\uDB40\uDC62\uDB40(?:\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDC73\uDB40\uDC63\uDB40\uDC74|\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F)?)|\uD83D(?:[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3]\uFE0F?|[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC](?:\uD83C[\uDFFB-\uDFFF])?|[\uDC6E-\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4\uDEB5](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD74\uDD90](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?|[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC25\uDC27-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE41\uDE43\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED8\uDEDC-\uDEDF\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB\uDFF0]|\uDC08(?:\u200D\u2B1B)?|\uDC15(?:\u200D\uD83E\uDDBA)?|\uDC26(?:\u200D(?:\u2B1B|\uD83D\uDD25))?|\uDC3B(?:\u200D\u2744\uFE0F?)?|\uDC41\uFE0F?(?:\u200D\uD83D\uDDE8\uFE0F?)?|\uDC68(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDC68\uDC69]\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC68\uD83C[\uDFFC-\uDFFF])|\uD83E(?:[\uDD1D\uDEEF]\u200D\uD83D\uDC68\uD83C[\uDFFC-\uDFFF]|[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFD-\uDFFF])|\uD83E(?:[\uDD1D\uDEEF]\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFD-\uDFFF]|[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|\uD83E(?:[\uDD1D\uDEEF]\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF]|[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFD\uDFFF])|\uD83E(?:[\uDD1D\uDEEF]\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFD\uDFFF]|[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFE])|\uD83E(?:[\uDD1D\uDEEF]\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFE]|[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3])))?))?|\uDC69(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?[\uDC68\uDC69]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?|\uDC69\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?))|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC69\uD83C[\uDFFC-\uDFFF])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFC-\uDFFF]|\uDEEF\u200D\uD83D\uDC69\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC69\uD83C[\uDFFB\uDFFD-\uDFFF])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFD-\uDFFF]|\uDEEF\u200D\uD83D\uDC69\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC69\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF]|\uDEEF\u200D\uD83D\uDC69\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC69\uD83C[\uDFFB-\uDFFD\uDFFF])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFD\uDFFF]|\uDEEF\u200D\uD83D\uDC69\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83D\uDC69\uD83C[\uDFFB-\uDFFE])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFE]|\uDEEF\u200D\uD83D\uDC69\uD83C[\uDFFB-\uDFFE])))?))?|\uDD75(?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDE2E(?:\u200D\uD83D\uDCA8)?|\uDE35(?:\u200D\uD83D\uDCAB)?|\uDE36(?:\u200D\uD83C\uDF2B\uFE0F?)?|\uDE42(?:\u200D[\u2194\u2195]\uFE0F?)?|\uDEB6(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?)|\uD83E(?:[\uDD0C\uDD0F\uDD18-\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5\uDEC3-\uDEC5\uDEF0\uDEF2-\uDEF8](?:\uD83C[\uDFFB-\uDFFF])?|[\uDD26\uDD35\uDD37-\uDD39\uDD3C-\uDD3E\uDDB8\uDDB9\uDDCD\uDDCF\uDDD4\uDDD6-\uDDDD](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDDDE\uDDDF](?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD0D\uDD0E\uDD10-\uDD17\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCC\uDDD0\uDDE0-\uDDFF\uDE70-\uDE7C\uDE80-\uDE8A\uDE8E-\uDEC2\uDEC6\uDEC8\uDECD-\uDEDC\uDEDF-\uDEEA\uDEEF]|\uDDCE(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?|\uDDD1(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3\uDE70]|\uDD1D\u200D\uD83E\uDDD1|\uDDD1\u200D\uD83E\uDDD2(?:\u200D\uD83E\uDDD2)?|\uDDD2(?:\u200D\uD83E\uDDD2)?))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFC-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83E\uDDD1\uD83C[\uDFFC-\uDFFF])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3\uDE70]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF]|\uDEEF\u200D\uD83E\uDDD1\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFD-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83E\uDDD1\uD83C[\uDFFB\uDFFD-\uDFFF])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3\uDE70]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF]|\uDEEF\u200D\uD83E\uDDD1\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83E\uDDD1\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3\uDE70]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF]|\uDEEF\u200D\uD83E\uDDD1\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFD\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFD\uDFFF])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3\uDE70]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF]|\uDEEF\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFE]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC30\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFE])|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3\uDE70]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF]|\uDEEF\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFE])))?))?|\uDEF1(?:\uD83C(?:\uDFFB(?:\u200D\uD83E\uDEF2\uD83C[\uDFFC-\uDFFF])?|\uDFFC(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFD-\uDFFF])?|\uDFFD(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])?|\uDFFE(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFD\uDFFF])?|\uDFFF(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFE])?))?)/g;
+function Nn(e) {
+  return e === 12288 || e >= 65281 && e <= 65376 || e >= 65504 && e <= 65510;
+}
+function vn(e) {
+  return e >= 4352 && e <= 4447 || e === 8986 || e === 8987 || e === 9001 || e === 9002 || e >= 9193 && e <= 9196 || e === 9200 || e === 9203 || e === 9725 || e === 9726 || e === 9748 || e === 9749 || e >= 9776 && e <= 9783 || e >= 9800 && e <= 9811 || e === 9855 || e >= 9866 && e <= 9871 || e === 9875 || e === 9889 || e === 9898 || e === 9899 || e === 9917 || e === 9918 || e === 9924 || e === 9925 || e === 9934 || e === 9940 || e === 9962 || e === 9970 || e === 9971 || e === 9973 || e === 9978 || e === 9981 || e === 9989 || e === 9994 || e === 9995 || e === 10024 || e === 10060 || e === 10062 || e >= 10067 && e <= 10069 || e === 10071 || e >= 10133 && e <= 10135 || e === 10160 || e === 10175 || e === 11035 || e === 11036 || e === 11088 || e === 11093 || e >= 11904 && e <= 11929 || e >= 11931 && e <= 12019 || e >= 12032 && e <= 12245 || e >= 12272 && e <= 12287 || e >= 12289 && e <= 12350 || e >= 12353 && e <= 12438 || e >= 12441 && e <= 12543 || e >= 12549 && e <= 12591 || e >= 12593 && e <= 12686 || e >= 12688 && e <= 12773 || e >= 12783 && e <= 12830 || e >= 12832 && e <= 12871 || e >= 12880 && e <= 42124 || e >= 42128 && e <= 42182 || e >= 43360 && e <= 43388 || e >= 44032 && e <= 55203 || e >= 63744 && e <= 64255 || e >= 65040 && e <= 65049 || e >= 65072 && e <= 65106 || e >= 65108 && e <= 65126 || e >= 65128 && e <= 65131 || e >= 94176 && e <= 94180 || e >= 94192 && e <= 94198 || e >= 94208 && e <= 101589 || e >= 101631 && e <= 101662 || e >= 101760 && e <= 101874 || e >= 110576 && e <= 110579 || e >= 110581 && e <= 110587 || e === 110589 || e === 110590 || e >= 110592 && e <= 110882 || e === 110898 || e >= 110928 && e <= 110930 || e === 110933 || e >= 110948 && e <= 110951 || e >= 110960 && e <= 111355 || e >= 119552 && e <= 119638 || e >= 119648 && e <= 119670 || e === 126980 || e === 127183 || e === 127374 || e >= 127377 && e <= 127386 || e >= 127488 && e <= 127490 || e >= 127504 && e <= 127547 || e >= 127552 && e <= 127560 || e === 127568 || e === 127569 || e >= 127584 && e <= 127589 || e >= 127744 && e <= 127776 || e >= 127789 && e <= 127797 || e >= 127799 && e <= 127868 || e >= 127870 && e <= 127891 || e >= 127904 && e <= 127946 || e >= 127951 && e <= 127955 || e >= 127968 && e <= 127984 || e === 127988 || e >= 127992 && e <= 128062 || e === 128064 || e >= 128066 && e <= 128252 || e >= 128255 && e <= 128317 || e >= 128331 && e <= 128334 || e >= 128336 && e <= 128359 || e === 128378 || e === 128405 || e === 128406 || e === 128420 || e >= 128507 && e <= 128591 || e >= 128640 && e <= 128709 || e === 128716 || e >= 128720 && e <= 128722 || e >= 128725 && e <= 128728 || e >= 128732 && e <= 128735 || e === 128747 || e === 128748 || e >= 128756 && e <= 128764 || e >= 128992 && e <= 129003 || e === 129008 || e >= 129292 && e <= 129338 || e >= 129340 && e <= 129349 || e >= 129351 && e <= 129535 || e >= 129648 && e <= 129660 || e >= 129664 && e <= 129674 || e >= 129678 && e <= 129734 || e === 129736 || e >= 129741 && e <= 129756 || e >= 129759 && e <= 129770 || e >= 129775 && e <= 129784 || e >= 131072 && e <= 196605 || e >= 196608 && e <= 262141;
+}
+var Zs = "©®‼⁉™ℹ↔↕↖↗↘↙↩↪⌨⏏⏱⏲⏸⏹⏺▪▫▶◀◻◼☀☁☂☃☄☎☑☘☝☠☢☣☦☪☮☯☸☹☺♀♂♟♠♣♥♦♨♻♾⚒⚔⚕⚖⚗⚙⚛⚜⚠⚧⚰⚱⛈⛏⛑⛓⛩⛱⛷⛸⛹✂✈✉✌✍✏✒✔✖✝✡✳✴❄❇❣❤➡⤴⤵⬅⬆⬇";
+var xa = /[^\x20-\x7F]/u, ga = new Set(Zs);
+function ha(e) {
+  if (!e) return 0;
+  if (!xa.test(e)) return e.length;
+  e = e.replace(zs(), (r) => ga.has(r) ? " " : "  ");
+  let t = 0;
+  for (let r of e) {
+    let n = r.codePointAt(0);
+    n <= 31 || n >= 127 && n <= 159 || n >= 768 && n <= 879 || n >= 65024 && n <= 65039 || (t += Nn(n) || vn(n) ? 2 : 1);
+  }
+  return t;
+}
+var it = ha;
+function Pr(e) {
+  return (t, r, n) => {
+    let s = !!n?.backwards;
+    if (r === false) return false;
+    let { length: i } = t, u = r;
+    for (; u >= 0 && u < i; ) {
+      let o = t.charAt(u);
+      if (e instanceof RegExp) {
+        if (!e.test(o)) return u;
+      } else if (!e.includes(o)) return u;
+      s ? u-- : u++;
+    }
+    return u === -1 || u === i ? u : false;
+  };
+}
+var Qe = Pr(" 	"), ei = Pr(",; 	"), ti = Pr(/[^\n\r]/u);
+var ri = (e) => e === `
+` || e === "\r" || e === "\u2028" || e === "\u2029";
+function Sa(e, t, r) {
+  let n = !!r?.backwards;
+  if (t === false) return false;
+  let s = e.charAt(t);
+  if (n) {
+    if (e.charAt(t - 1) === "\r" && s === `
+`) return t - 2;
+    if (ri(s)) return t - 1;
+  } else {
+    if (s === "\r" && e.charAt(t + 1) === `
+`) return t + 2;
+    if (ri(s)) return t + 1;
+  }
+  return t;
+}
+var ze = Sa;
+function Ba(e, t, r = {}) {
+  let n = Qe(e, r.backwards ? t - 1 : t, r), s = ze(e, n, r);
+  return n !== s;
+}
+var Q = Ba;
+function ba(e, t) {
+  if (t === false) return false;
+  if (e.charAt(t) === "/" && e.charAt(t + 1) === "*") {
+    for (let r = t + 2; r < e.length; ++r) if (e.charAt(r) === "*" && e.charAt(r + 1) === "/") return r + 2;
+  }
+  return t;
+}
+var Gt = ba;
+function Pa(e, t) {
+  return t === false ? false : e.charAt(t) === "/" && e.charAt(t + 1) === "/" ? ti(e, t) : t;
+}
+var Wt = Pa;
+function ka(e, t) {
+  let r = null, n = t;
+  for (; n !== r; ) r = n, n = ei(e, n), n = Gt(e, n), n = Qe(e, n);
+  return n = Wt(e, n), n = ze(e, n), n !== false && Q(e, n);
+}
+var qt = ka;
+function Ia(e) {
+  return Array.isArray(e) && e.length > 0;
+}
+var j = Ia;
+var La = () => {
+}, Pe = La;
+function Oa(e, t) {
+  let r = t === true || t === "'" ? "'" : '"', n = r === "'" ? '"' : "'", s = 0, i = 0;
+  for (let u of e) u === r ? s++ : u === n && i++;
+  return s > i ? n : r;
+}
+var kr = Oa;
+var wa = /\\?(?<quote>["'])/gu;
+function Ma(e, t) {
+  return t + G(0, e, wa, (r, n) => (n === t ? "\\" : "") + n) + t;
+}
+var ni = Ma;
+function _a(e, t) {
+  let r = e.slice(1, -1), n = t.parser === "json" || t.parser === "jsonc" || t.parser === "json5" && t.quoteProps === "preserve" && !t.singleQuote ? '"' : t.__isInHtmlAttribute ? "'" : kr(r, t.singleQuote);
+  return e.charAt(0) === n ? e : ni(r, n);
+}
+var ut = _a;
+var si = (e) => Number.isInteger(e) && e >= 0;
+function L(e) {
+  let t = e.range?.[0] ?? e.start, r = (e.declaration?.decorators ?? e.decorators)?.[0];
+  return r ? Math.min(L(r), t) : t;
+}
+function k(e) {
+  return e.range?.[1] ?? e.end;
+}
+function St(e, t) {
+  let r = L(e);
+  return si(r) && r === L(t);
+}
+function Na(e, t) {
+  let r = k(e);
+  return si(r) && r === k(t);
+}
+function ii(e, t) {
+  return St(e, t) && Na(e, t);
+}
+var cr = null;
+function lr(e) {
+  if (cr !== null && typeof cr.property) {
+    let t = cr;
+    return cr = lr.prototype = null, t;
+  }
+  return cr = lr.prototype = e ?? /* @__PURE__ */ Object.create(null), new lr();
+}
+var va = 10;
+for (let e = 0; e <= va; e++) lr();
+function Rn(e) {
+  return lr(e);
+}
+function ja(e, t = "type") {
+  Rn(e);
+  function r(n) {
+    let s = n[t], i = e[s];
+    if (!Array.isArray(i)) throw Object.assign(new Error(`Missing visitor keys for '${s}'.`), { node: n });
+    return i;
+  }
+  return r;
+}
+var Ir = ja;
+var ui = { AccessorProperty: ["decorators", "key", "typeAnnotation", "value"], AnyTypeAnnotation: [], ArgumentPlaceholder: [], ArrayExpression: ["elements"], ArrayPattern: ["elements", "typeAnnotation", "decorators"], ArrayTypeAnnotation: ["elementType"], ArrowFunctionExpression: ["typeParameters", "params", "predicate", "returnType", "body"], AsConstExpression: ["expression"], AsExpression: ["expression", "typeAnnotation"], AssignmentExpression: ["left", "right"], AssignmentPattern: ["left", "right", "decorators", "typeAnnotation"], AwaitExpression: ["argument"], BigIntLiteral: [], BigIntLiteralTypeAnnotation: [], BigIntTypeAnnotation: [], BinaryExpression: ["left", "right"], BindExpression: ["object", "callee"], BlockStatement: ["directives", "body"], BooleanLiteral: [], BooleanLiteralTypeAnnotation: [], BooleanTypeAnnotation: [], BreakStatement: ["label"], CallExpression: ["callee", "typeArguments", "arguments"], CatchClause: ["param", "body"], ChainExpression: ["expression"], ClassAccessorProperty: ["decorators", "key", "typeAnnotation", "value"], ClassBody: ["body"], ClassDeclaration: ["decorators", "id", "typeParameters", "superClass", "superTypeArguments", "mixins", "implements", "body", "superTypeParameters"], ClassExpression: ["decorators", "id", "typeParameters", "superClass", "superTypeArguments", "mixins", "implements", "body", "superTypeParameters"], ClassImplements: ["id", "typeParameters"], ClassMethod: ["decorators", "key", "typeParameters", "params", "returnType", "body"], ClassPrivateMethod: ["decorators", "key", "typeParameters", "params", "returnType", "body"], ClassPrivateProperty: ["decorators", "variance", "key", "typeAnnotation", "value"], ClassProperty: ["decorators", "variance", "key", "typeAnnotation", "value"], ComponentDeclaration: ["id", "params", "body", "typeParameters", "rendersType"], ComponentParameter: ["name", "local"], ComponentTypeAnnotation: ["params", "rest", "typeParameters", "rendersType"], ComponentTypeParameter: ["name", "typeAnnotation"], ConditionalExpression: ["test", "consequent", "alternate"], ConditionalTypeAnnotation: ["checkType", "extendsType", "trueType", "falseType"], ContinueStatement: ["label"], DebuggerStatement: [], DeclareClass: ["id", "typeParameters", "extends", "mixins", "implements", "body"], DeclareComponent: ["id", "params", "rest", "typeParameters", "rendersType"], DeclaredPredicate: ["value"], DeclareEnum: ["id", "body"], DeclareExportAllDeclaration: ["source", "attributes"], DeclareExportDeclaration: ["declaration", "specifiers", "source", "attributes"], DeclareFunction: ["id", "predicate"], DeclareHook: ["id"], DeclareInterface: ["id", "typeParameters", "extends", "body"], DeclareModule: ["id", "body"], DeclareModuleExports: ["typeAnnotation"], DeclareNamespace: ["id", "body"], DeclareOpaqueType: ["id", "typeParameters", "supertype", "lowerBound", "upperBound"], DeclareTypeAlias: ["id", "typeParameters", "right"], DeclareVariable: ["id"], Decorator: ["expression"], Directive: ["value"], DirectiveLiteral: [], DoExpression: ["body"], DoWhileStatement: ["body", "test"], EmptyStatement: [], EmptyTypeAnnotation: [], EnumBigIntBody: ["members"], EnumBigIntMember: ["id", "init"], EnumBooleanBody: ["members"], EnumBooleanMember: ["id", "init"], EnumDeclaration: ["id", "body"], EnumDefaultedMember: ["id"], EnumNumberBody: ["members"], EnumNumberMember: ["id", "init"], EnumStringBody: ["members"], EnumStringMember: ["id", "init"], EnumSymbolBody: ["members"], ExistsTypeAnnotation: [], ExperimentalRestProperty: ["argument"], ExperimentalSpreadProperty: ["argument"], ExportAllDeclaration: ["source", "attributes", "exported"], ExportDefaultDeclaration: ["declaration"], ExportDefaultSpecifier: ["exported"], ExportNamedDeclaration: ["declaration", "specifiers", "source", "attributes"], ExportNamespaceSpecifier: ["exported"], ExportSpecifier: ["local", "exported"], ExpressionStatement: ["expression"], File: ["program"], ForInStatement: ["left", "right", "body"], ForOfStatement: ["left", "right", "body"], ForStatement: ["init", "test", "update", "body"], FunctionDeclaration: ["id", "typeParameters", "params", "predicate", "returnType", "body"], FunctionExpression: ["id", "typeParameters", "params", "predicate", "returnType", "body"], FunctionTypeAnnotation: ["typeParameters", "this", "params", "rest", "returnType"], FunctionTypeParam: ["name", "typeAnnotation"], GenericTypeAnnotation: ["id", "typeParameters"], HookDeclaration: ["id", "params", "body", "typeParameters", "returnType"], HookTypeAnnotation: ["params", "returnType", "rest", "typeParameters"], Identifier: ["typeAnnotation", "decorators"], IfStatement: ["test", "consequent", "alternate"], ImportAttribute: ["key", "value"], ImportDeclaration: ["specifiers", "source", "attributes"], ImportDefaultSpecifier: ["local"], ImportExpression: ["source", "options"], ImportNamespaceSpecifier: ["local"], ImportSpecifier: ["imported", "local"], IndexedAccessType: ["objectType", "indexType"], InferredPredicate: [], InferTypeAnnotation: ["typeParameter"], InterfaceDeclaration: ["id", "typeParameters", "extends", "body"], InterfaceExtends: ["id", "typeParameters"], InterfaceTypeAnnotation: ["extends", "body"], InterpreterDirective: [], IntersectionTypeAnnotation: ["types"], JsExpressionRoot: ["node"], JsonRoot: ["node"], JSXAttribute: ["name", "value"], JSXClosingElement: ["name"], JSXClosingFragment: [], JSXElement: ["openingElement", "children", "closingElement"], JSXEmptyExpression: [], JSXExpressionContainer: ["expression"], JSXFragment: ["openingFragment", "children", "closingFragment"], JSXIdentifier: [], JSXMemberExpression: ["object", "property"], JSXNamespacedName: ["namespace", "name"], JSXOpeningElement: ["name", "typeArguments", "attributes"], JSXOpeningFragment: [], JSXSpreadAttribute: ["argument"], JSXSpreadChild: ["expression"], JSXText: [], KeyofTypeAnnotation: ["argument"], LabeledStatement: ["label", "body"], Literal: [], LogicalExpression: ["left", "right"], MatchArrayPattern: ["elements", "rest"], MatchAsPattern: ["pattern", "target"], MatchBindingPattern: ["id"], MatchExpression: ["argument", "cases"], MatchExpressionCase: ["pattern", "body", "guard"], MatchIdentifierPattern: ["id"], MatchLiteralPattern: ["literal"], MatchMemberPattern: ["base", "property"], MatchObjectPattern: ["properties", "rest"], MatchObjectPatternProperty: ["key", "pattern"], MatchOrPattern: ["patterns"], MatchRestPattern: ["argument"], MatchStatement: ["argument", "cases"], MatchStatementCase: ["pattern", "body", "guard"], MatchUnaryPattern: ["argument"], MatchWildcardPattern: [], MemberExpression: ["object", "property"], MetaProperty: ["meta", "property"], MethodDefinition: ["decorators", "key", "value"], MixedTypeAnnotation: [], ModuleExpression: ["body"], NeverTypeAnnotation: [], NewExpression: ["callee", "typeArguments", "arguments"], NGChainedExpression: ["expressions"], NGEmptyExpression: [], NGMicrosyntax: ["body"], NGMicrosyntaxAs: ["key", "alias"], NGMicrosyntaxExpression: ["expression", "alias"], NGMicrosyntaxKey: [], NGMicrosyntaxKeyedExpression: ["key", "expression"], NGMicrosyntaxLet: ["key", "value"], NGPipeExpression: ["left", "right", "arguments"], NGRoot: ["node"], NullableTypeAnnotation: ["typeAnnotation"], NullLiteral: [], NullLiteralTypeAnnotation: [], NumberLiteralTypeAnnotation: [], NumberTypeAnnotation: [], NumericLiteral: [], ObjectExpression: ["properties"], ObjectMethod: ["decorators", "key", "typeParameters", "params", "returnType", "body"], ObjectPattern: ["decorators", "properties", "typeAnnotation"], ObjectProperty: ["decorators", "key", "value"], ObjectTypeAnnotation: ["properties", "indexers", "callProperties", "internalSlots"], ObjectTypeCallProperty: ["value"], ObjectTypeIndexer: ["variance", "id", "key", "value"], ObjectTypeInternalSlot: ["id", "value"], ObjectTypeMappedTypeProperty: ["keyTparam", "propType", "sourceType", "variance"], ObjectTypeProperty: ["key", "value", "variance"], ObjectTypeSpreadProperty: ["argument"], OpaqueType: ["id", "typeParameters", "supertype", "impltype", "lowerBound", "upperBound"], OptionalCallExpression: ["callee", "typeArguments", "arguments"], OptionalIndexedAccessType: ["objectType", "indexType"], OptionalMemberExpression: ["object", "property"], ParenthesizedExpression: ["expression"], PipelineBareFunction: ["callee"], PipelinePrimaryTopicReference: [], PipelineTopicExpression: ["expression"], Placeholder: [], PrivateIdentifier: [], PrivateName: ["id"], Program: ["directives", "body"], Property: ["key", "value"], PropertyDefinition: ["decorators", "key", "typeAnnotation", "value", "variance"], QualifiedTypeIdentifier: ["qualification", "id"], QualifiedTypeofIdentifier: ["qualification", "id"], RegExpLiteral: [], RestElement: ["argument", "typeAnnotation", "decorators"], ReturnStatement: ["argument"], SatisfiesExpression: ["expression", "typeAnnotation"], SequenceExpression: ["expressions"], SpreadElement: ["argument"], StaticBlock: ["body"], StringLiteral: [], StringLiteralTypeAnnotation: [], StringTypeAnnotation: [], Super: [], SwitchCase: ["test", "consequent"], SwitchStatement: ["discriminant", "cases"], SymbolTypeAnnotation: [], TaggedTemplateExpression: ["tag", "typeArguments", "quasi"], TemplateElement: [], TemplateLiteral: ["quasis", "expressions"], ThisExpression: [], ThisTypeAnnotation: [], ThrowStatement: ["argument"], TopicReference: [], TryStatement: ["block", "handler", "finalizer"], TSAbstractAccessorProperty: ["decorators", "key", "typeAnnotation"], TSAbstractKeyword: [], TSAbstractMethodDefinition: ["key", "value"], TSAbstractPropertyDefinition: ["decorators", "key", "typeAnnotation"], TSAnyKeyword: [], TSArrayType: ["elementType"], TSAsExpression: ["expression", "typeAnnotation"], TSAsyncKeyword: [], TSBigIntKeyword: [], TSBooleanKeyword: [], TSCallSignatureDeclaration: ["typeParameters", "params", "returnType"], TSClassImplements: ["expression", "typeArguments"], TSConditionalType: ["checkType", "extendsType", "trueType", "falseType"], TSConstructorType: ["typeParameters", "params", "returnType"], TSConstructSignatureDeclaration: ["typeParameters", "params", "returnType"], TSDeclareFunction: ["id", "typeParameters", "params", "returnType", "body"], TSDeclareKeyword: [], TSDeclareMethod: ["decorators", "key", "typeParameters", "params", "returnType"], TSEmptyBodyFunctionExpression: ["id", "typeParameters", "params", "returnType"], TSEnumBody: ["members"], TSEnumDeclaration: ["id", "body"], TSEnumMember: ["id", "initializer"], TSExportAssignment: ["expression"], TSExportKeyword: [], TSExternalModuleReference: ["expression"], TSFunctionType: ["typeParameters", "params", "returnType"], TSImportEqualsDeclaration: ["id", "moduleReference"], TSImportType: ["options", "qualifier", "typeArguments", "source"], TSIndexedAccessType: ["objectType", "indexType"], TSIndexSignature: ["parameters", "typeAnnotation"], TSInferType: ["typeParameter"], TSInstantiationExpression: ["expression", "typeArguments"], TSInterfaceBody: ["body"], TSInterfaceDeclaration: ["id", "typeParameters", "extends", "body"], TSInterfaceHeritage: ["expression", "typeArguments"], TSIntersectionType: ["types"], TSIntrinsicKeyword: [], TSJSDocAllType: [], TSJSDocNonNullableType: ["typeAnnotation"], TSJSDocNullableType: ["typeAnnotation"], TSJSDocUnknownType: [], TSLiteralType: ["literal"], TSMappedType: ["key", "constraint", "nameType", "typeAnnotation"], TSMethodSignature: ["key", "typeParameters", "params", "returnType"], TSModuleBlock: ["body"], TSModuleDeclaration: ["id", "body"], TSNamedTupleMember: ["label", "elementType"], TSNamespaceExportDeclaration: ["id"], TSNeverKeyword: [], TSNonNullExpression: ["expression"], TSNullKeyword: [], TSNumberKeyword: [], TSObjectKeyword: [], TSOptionalType: ["typeAnnotation"], TSParameterProperty: ["parameter", "decorators"], TSParenthesizedType: ["typeAnnotation"], TSPrivateKeyword: [], TSPropertySignature: ["key", "typeAnnotation"], TSProtectedKeyword: [], TSPublicKeyword: [], TSQualifiedName: ["left", "right"], TSReadonlyKeyword: [], TSRestType: ["typeAnnotation"], TSSatisfiesExpression: ["expression", "typeAnnotation"], TSStaticKeyword: [], TSStringKeyword: [], TSSymbolKeyword: [], TSTemplateLiteralType: ["quasis", "types"], TSThisType: [], TSTupleType: ["elementTypes"], TSTypeAliasDeclaration: ["id", "typeParameters", "typeAnnotation"], TSTypeAnnotation: ["typeAnnotation"], TSTypeAssertion: ["typeAnnotation", "expression"], TSTypeLiteral: ["members"], TSTypeOperator: ["typeAnnotation"], TSTypeParameter: ["name", "constraint", "default"], TSTypeParameterDeclaration: ["params"], TSTypeParameterInstantiation: ["params"], TSTypePredicate: ["parameterName", "typeAnnotation"], TSTypeQuery: ["exprName", "typeArguments"], TSTypeReference: ["typeName", "typeArguments"], TSUndefinedKeyword: [], TSUnionType: ["types"], TSUnknownKeyword: [], TSVoidKeyword: [], TupleTypeAnnotation: ["types", "elementTypes"], TupleTypeLabeledElement: ["label", "elementType", "variance"], TupleTypeSpreadElement: ["label", "typeAnnotation"], TypeAlias: ["id", "typeParameters", "right"], TypeAnnotation: ["typeAnnotation"], TypeCastExpression: ["expression", "typeAnnotation"], TypeofTypeAnnotation: ["argument", "typeArguments"], TypeOperator: ["typeAnnotation"], TypeParameter: ["bound", "default", "variance"], TypeParameterDeclaration: ["params"], TypeParameterInstantiation: ["params"], TypePredicate: ["parameterName", "typeAnnotation"], UnaryExpression: ["argument"], UndefinedTypeAnnotation: [], UnionTypeAnnotation: ["types"], UnknownTypeAnnotation: [], UpdateExpression: ["argument"], V8IntrinsicIdentifier: [], VariableDeclaration: ["declarations"], VariableDeclarator: ["id", "init"], Variance: [], VoidPattern: [], VoidTypeAnnotation: [], WhileStatement: ["test", "body"], WithStatement: ["object", "body"], YieldExpression: ["argument"] };
+var Ra = Ir(ui), Lr = Ra;
+function Ja(e) {
+  let t = new Set(e);
+  return (r) => t.has(r?.type);
+}
+var b = Ja;
+function Ga(e) {
+  return e.extra?.raw ?? e.raw;
+}
+var pe = Ga;
+var Wa = b(["Block", "CommentBlock", "MultiLine"]), ee = Wa;
+var qa = b(["AnyTypeAnnotation", "ThisTypeAnnotation", "NumberTypeAnnotation", "VoidTypeAnnotation", "BooleanTypeAnnotation", "BigIntTypeAnnotation", "SymbolTypeAnnotation", "StringTypeAnnotation", "NeverTypeAnnotation", "UndefinedTypeAnnotation", "UnknownTypeAnnotation", "EmptyTypeAnnotation", "MixedTypeAnnotation"]), Or = qa;
+var Ya = b(["Line", "CommentLine", "SingleLine", "HashbangComment", "HTMLOpen", "HTMLClose", "Hashbang", "InterpreterDirective"]), Ct = Ya;
+function Ua(e, t) {
+  let r = t.split(".");
+  for (let n = r.length - 1; n >= 0; n--) {
+    let s = r[n];
+    if (n === 0) return e.type === "Identifier" && e.name === s;
+    if (n === 1 && e.type === "MetaProperty" && e.property.type === "Identifier" && e.property.name === s) {
+      e = e.meta;
+      continue;
+    }
+    if (e.type === "MemberExpression" && !e.optional && !e.computed && e.property.type === "Identifier" && e.property.name === s) {
+      e = e.object;
+      continue;
+    }
+    return false;
+  }
+}
+function Ha(e, t) {
+  return t.some((r) => Ua(e, r));
+}
+var Bt = Ha;
+function Xa({ type: e }) {
+  return e.startsWith("TS") && e.endsWith("Keyword");
+}
+var wr = Xa;
+function Va({ node: e, parent: t }) {
+  return e?.type !== "EmptyStatement" ? false : t.type === "IfStatement" ? t.consequent === e || t.alternate === e : t.type === "DoWhileStatement" || t.type === "ForInStatement" || t.type === "ForOfStatement" || t.type === "ForStatement" || t.type === "LabeledStatement" || t.type === "WithStatement" || t.type === "WhileStatement" ? t.body === e : false;
+}
+var bt = Va;
+function Dr(e, t) {
+  return t(e) || Qs(e, { getVisitorKeys: Lr, predicate: t });
+}
+function Ut(e) {
+  return e.type === "AssignmentExpression" || e.type === "BinaryExpression" || e.type === "LogicalExpression" || e.type === "NGPipeExpression" || e.type === "ConditionalExpression" || M(e) || R(e) || e.type === "SequenceExpression" || e.type === "TaggedTemplateExpression" || e.type === "BindExpression" || e.type === "UpdateExpression" && !e.prefix || Ae(e) || e.type === "TSNonNullExpression" || e.type === "ChainExpression";
+}
+function pi(e) {
+  return e.expressions ? e.expressions[0] : e.left ?? e.test ?? e.callee ?? e.object ?? e.tag ?? e.argument ?? e.expression;
+}
+function _r(e) {
+  if (e.expressions) return ["expressions", 0];
+  if (e.left) return ["left"];
+  if (e.test) return ["test"];
+  if (e.object) return ["object"];
+  if (e.callee) return ["callee"];
+  if (e.tag) return ["tag"];
+  if (e.argument) return ["argument"];
+  if (e.expression) return ["expression"];
+  throw new Error("Unexpected node has no left side.");
+}
+var ci = b(["ExportDefaultDeclaration", "DeclareExportDeclaration", "ExportNamedDeclaration", "ExportAllDeclaration", "DeclareExportAllDeclaration"]), W = b(["ArrayExpression"]), ie = b(["ObjectExpression"]);
+function li(e) {
+  return e.type === "LogicalExpression" && e.operator === "??";
+}
+function de(e) {
+  return e.type === "NumericLiteral" || e.type === "Literal" && typeof e.value == "number";
+}
+function mi(e) {
+  return e.type === "BooleanLiteral" || e.type === "Literal" && typeof e.value == "boolean";
+}
+function Yn(e) {
+  return e.type === "UnaryExpression" && (e.operator === "+" || e.operator === "-") && de(e.argument);
+}
+function X(e) {
+  return !!(e && (e.type === "StringLiteral" || e.type === "Literal" && typeof e.value == "string"));
+}
+function Un(e) {
+  return e.type === "RegExpLiteral" || e.type === "Literal" && !!e.regex;
+}
+var Nr = b(["Literal", "BooleanLiteral", "BigIntLiteral", "DirectiveLiteral", "NullLiteral", "NumericLiteral", "RegExpLiteral", "StringLiteral"]), $a = b(["Identifier", "ThisExpression", "Super", "PrivateName", "PrivateIdentifier"]), We = b(["ObjectTypeAnnotation", "TSTypeLiteral", "TSMappedType"]), Yt = b(["FunctionExpression", "ArrowFunctionExpression"]);
+function Ka(e) {
+  return e.type === "FunctionExpression" || e.type === "ArrowFunctionExpression" && e.body.type === "BlockStatement";
+}
+function Jn(e) {
+  return M(e) && e.callee.type === "Identifier" && ["async", "inject", "fakeAsync", "waitForAsync"].includes(e.callee.name);
+}
+var q = b(["JSXElement", "JSXFragment"]);
+function lt(e) {
+  return e.method && e.kind === "init" || e.kind === "get" || e.kind === "set";
+}
+function vr(e) {
+  return (e.type === "ObjectTypeProperty" || e.type === "ObjectTypeInternalSlot") && !e.static && !e.method && e.kind !== "get" && e.kind !== "set" && e.value.type === "FunctionTypeAnnotation";
+}
+function Di(e) {
+  return (e.type === "TypeAnnotation" || e.type === "TSTypeAnnotation") && e.typeAnnotation.type === "FunctionTypeAnnotation" && !e.static && !St(e, e.typeAnnotation);
+}
+var xe = b(["BinaryExpression", "LogicalExpression", "NGPipeExpression"]);
+function At(e) {
+  return R(e) || e.type === "BindExpression" && !!e.object;
+}
+var Qa = b(["TSThisType", "NullLiteralTypeAnnotation", "BooleanLiteralTypeAnnotation", "StringLiteralTypeAnnotation", "BigIntLiteralTypeAnnotation", "NumberLiteralTypeAnnotation", "TSLiteralType", "TSTemplateLiteralType"]);
+function Ht(e) {
+  return wr(e) || Or(e) || Qa(e) || e.type === "GenericTypeAnnotation" && !e.typeParameters || e.type === "TSTypeReference" && !e.typeArguments;
+}
+function za(e) {
+  return e.type === "Identifier" && (e.name === "beforeEach" || e.name === "beforeAll" || e.name === "afterEach" || e.name === "afterAll");
+}
+var Za = ["it", "it.only", "it.skip", "describe", "describe.only", "describe.skip", "test", "test.only", "test.skip", "test.fixme", "test.step", "test.describe", "test.describe.only", "test.describe.skip", "test.describe.fixme", "test.describe.parallel", "test.describe.parallel.only", "test.describe.serial", "test.describe.serial.only", "skip", "xit", "xdescribe", "xtest", "fit", "fdescribe", "ftest"];
+function ep(e) {
+  return Bt(e, Za);
+}
+function Pt(e, t) {
+  if (e?.type !== "CallExpression" || e.optional) return false;
+  let r = ce(e);
+  if (r.length === 1) {
+    if (Jn(e) && Pt(t)) return Yt(r[0]);
+    if (za(e.callee)) return Jn(r[0]);
+  } else if ((r.length === 2 || r.length === 3) && (r[0].type === "TemplateLiteral" || X(r[0])) && ep(e.callee)) return r[2] && !de(r[2]) ? false : (r.length === 2 ? Yt(r[1]) : Ka(r[1]) && K(r[1]).length <= 1) || Jn(r[1]);
+  return false;
+}
+var fi = (e) => (t) => (t?.type === "ChainExpression" && (t = t.expression), e(t)), M = fi(b(["CallExpression", "OptionalCallExpression"])), R = fi(b(["MemberExpression", "OptionalMemberExpression"]));
+function Hn(e, t = 5) {
+  return yi(e, t) <= t;
+}
+function yi(e, t) {
+  let r = 0;
+  for (let n in e) {
+    let s = e[n];
+    if (s && typeof s == "object" && typeof s.type == "string" && (r++, r += yi(s, t - r)), r > t) return r;
+  }
+  return r;
+}
+var tp = 0.25;
+function fr(e, t) {
+  let { printWidth: r } = t;
+  if (C(e)) return false;
+  let n = r * tp;
+  if (e.type === "ThisExpression" || e.type === "Identifier" && e.name.length <= n || Yn(e) && !C(e.argument)) return true;
+  let s = e.type === "Literal" && "regex" in e && e.regex.pattern || e.type === "RegExpLiteral" && e.pattern;
+  return s ? s.length <= n : X(e) ? ut(pe(e), t).length <= n : e.type === "TemplateLiteral" ? e.expressions.length === 0 && e.quasis[0].value.raw.length <= n && !e.quasis[0].value.raw.includes(`
+`) : e.type === "UnaryExpression" ? fr(e.argument, { printWidth: r }) : e.type === "CallExpression" && e.arguments.length === 0 && e.callee.type === "Identifier" ? e.callee.name.length <= n - 2 : Nr(e);
+}
+function Ce(e, t) {
+  return q(t) ? It(t) : C(t, T.Leading, (r) => Q(e, k(r)));
+}
+function oi(e) {
+  return e.quasis.some((t) => t.value.raw.includes(`
+`));
+}
+function jr(e, t) {
+  return (e.type === "TemplateLiteral" && oi(e) || e.type === "TaggedTemplateExpression" && oi(e.quasi)) && !Q(t, L(e), { backwards: true });
+}
+function Rr(e) {
+  if (!C(e)) return false;
+  let t = _(0, Ze(e, T.Dangling), -1);
+  return t && !ee(t);
+}
+function Ei(e) {
+  if (e.length <= 1) return false;
+  let t = 0;
+  for (let r of e) if (Yt(r)) {
+    if (t += 1, t > 1) return true;
+  } else if (M(r)) {
+    for (let n of ce(r)) if (Yt(n)) return true;
+  }
+  return false;
+}
+function Jr(e) {
+  let { node: t, parent: r, key: n } = e;
+  return n === "callee" && M(t) && M(r) && r.arguments.length > 0 && t.arguments.length > r.arguments.length;
+}
+var rp = /* @__PURE__ */ new Set(["!", "-", "+", "~"]);
+function je(e, t = 2) {
+  if (t <= 0) return false;
+  if (e.type === "ChainExpression" || e.type === "TSNonNullExpression") return je(e.expression, t);
+  let r = (n) => je(n, t - 1);
+  if (Un(e)) return it(e.pattern ?? e.regex.pattern) <= 5;
+  if (Nr(e) || $a(e) || e.type === "ArgumentPlaceholder") return true;
+  if (e.type === "TemplateLiteral") return e.quasis.every((n) => !n.value.raw.includes(`
+`)) && e.expressions.every(r);
+  if (ie(e)) return e.properties.every((n) => !n.computed && (n.shorthand || n.value && r(n.value)));
+  if (W(e)) return e.elements.every((n) => n === null || r(n));
+  if (mt(e)) {
+    if (e.type === "ImportExpression" || je(e.callee, t)) {
+      let n = ce(e);
+      return n.length <= t && n.every(r);
+    }
+    return false;
+  }
+  return R(e) ? je(e.object, t) && je(e.property, t) : e.type === "UnaryExpression" && rp.has(e.operator) || e.type === "UpdateExpression" ? je(e.argument, t) : false;
+}
+function ue(e, t = "es5") {
+  return e.trailingComma === "es5" && t === "es5" || e.trailingComma === "all" && (t === "all" || t === "es5");
+}
+function fe(e, t) {
+  switch (e.type) {
+    case "BinaryExpression":
+    case "LogicalExpression":
+    case "AssignmentExpression":
+    case "NGPipeExpression":
+      return fe(e.left, t);
+    case "MemberExpression":
+    case "OptionalMemberExpression":
+      return fe(e.object, t);
+    case "TaggedTemplateExpression":
+      return e.tag.type === "FunctionExpression" ? false : fe(e.tag, t);
+    case "CallExpression":
+    case "OptionalCallExpression":
+      return e.callee.type === "FunctionExpression" ? false : fe(e.callee, t);
+    case "ConditionalExpression":
+      return fe(e.test, t);
+    case "UpdateExpression":
+      return !e.prefix && fe(e.argument, t);
+    case "BindExpression":
+      return e.object && fe(e.object, t);
+    case "SequenceExpression":
+      return fe(e.expressions[0], t);
+    case "ChainExpression":
+    case "TSSatisfiesExpression":
+    case "TSAsExpression":
+    case "TSNonNullExpression":
+    case "AsExpression":
+    case "AsConstExpression":
+    case "SatisfiesExpression":
+      return fe(e.expression, t);
+    default:
+      return t(e);
+  }
+}
+var ai = { "==": true, "!=": true, "===": true, "!==": true }, Mr = { "*": true, "/": true, "%": true }, qn = { ">>": true, ">>>": true, "<<": true };
+function yr(e, t) {
+  return !(mr(t) !== mr(e) || e === "**" || ai[e] && ai[t] || t === "%" && Mr[e] || e === "%" && Mr[t] || t !== e && Mr[t] && Mr[e] || qn[e] && qn[t]);
+}
+var np = new Map([["|>"], ["??"], ["||"], ["&&"], ["|"], ["^"], ["&"], ["==", "===", "!=", "!=="], ["<", ">", "<=", ">=", "in", "instanceof"], [">>", "<<", ">>>"], ["+", "-"], ["*", "/", "%"], ["**"]].flatMap((e, t) => e.map((r) => [r, t])));
+function mr(e) {
+  return np.get(e);
+}
+function Fi(e) {
+  return !!qn[e] || e === "|" || e === "^" || e === "&";
+}
+function di(e) {
+  if (e.rest) return true;
+  let t = K(e);
+  return _(0, t, -1)?.type === "RestElement";
+}
+var Gn = /* @__PURE__ */ new WeakMap();
+function K(e) {
+  if (Gn.has(e)) return Gn.get(e);
+  let t = [];
+  return e.this && t.push(e.this), t.push(...e.params), e.rest && t.push(e.rest), Gn.set(e, t), t;
+}
+function Ci(e, t) {
+  let { node: r } = e, n = 0, s = () => t(e, n++);
+  r.this && e.call(s, "this"), e.each(s, "params"), r.rest && e.call(s, "rest");
+}
+var Wn = /* @__PURE__ */ new WeakMap();
+function ce(e) {
+  if (Wn.has(e)) return Wn.get(e);
+  if (e.type === "ChainExpression") return ce(e.expression);
+  let t;
+  return e.type === "ImportExpression" || e.type === "TSImportType" ? (t = [e.source], e.options && t.push(e.options)) : e.type === "TSExternalModuleReference" ? t = [e.expression] : t = e.arguments, Wn.set(e, t), t;
+}
+function Xt(e, t) {
+  let { node: r } = e;
+  if (r.type === "ChainExpression") return e.call(() => Xt(e, t), "expression");
+  r.type === "ImportExpression" || r.type === "TSImportType" ? (e.call(() => t(e, 0), "source"), r.options && e.call(() => t(e, 1), "options")) : r.type === "TSExternalModuleReference" ? e.call(() => t(e, 0), "expression") : e.each(t, "arguments");
+}
+function Xn(e, t) {
+  let r = [];
+  if (e.type === "ChainExpression" && (e = e.expression, r.push("expression")), e.type === "ImportExpression" || e.type === "TSImportType") {
+    if (t === 0 || t === (e.options ? -2 : -1)) return [...r, "source"];
+    if (e.options && (t === 1 || t === -1)) return [...r, "options"];
+    throw new RangeError("Invalid argument index");
+  } else if (e.type === "TSExternalModuleReference") {
+    if (t === 0 || t === -1) return [...r, "expression"];
+  } else if (t < 0 && (t = e.arguments.length + t), t >= 0 && t < e.arguments.length) return [...r, "arguments", t];
+  throw new RangeError("Invalid argument index");
+}
+function kt(e) {
+  return e.value.trim() === "prettier-ignore" && !e.unignore;
+}
+function It(e) {
+  return e?.prettierIgnore || C(e, T.PrettierIgnore);
+}
+var T = { Leading: 2, Trailing: 4, Dangling: 8, Block: 16, Line: 32, PrettierIgnore: 64, First: 128, Last: 256 }, Ai = (e, t) => {
+  if (typeof e == "function" && (t = e, e = 0), e || t) return (r, n, s) => !(e & T.Leading && !r.leading || e & T.Trailing && !r.trailing || e & T.Dangling && (r.leading || r.trailing) || e & T.Block && !ee(r) || e & T.Line && !Ct(r) || e & T.First && n !== 0 || e & T.Last && n !== s.length - 1 || e & T.PrettierIgnore && !kt(r) || t && !t(r));
+};
+function C(e, t, r) {
+  if (!j(e?.comments)) return false;
+  let n = Ai(t, r);
+  return n ? e.comments.some(n) : true;
+}
+function Ze(e, t, r) {
+  if (!Array.isArray(e?.comments)) return [];
+  let n = Ai(t, r);
+  return n ? e.comments.filter(n) : e.comments;
+}
+var oe = (e, { originalText: t }) => qt(t, k(e));
+function mt(e) {
+  return M(e) || e.type === "NewExpression" || e.type === "ImportExpression";
+}
+function ke(e) {
+  return e && (e.type === "ObjectProperty" || e.type === "Property" && !lt(e));
+}
+var Ae = b(["TSAsExpression", "TSSatisfiesExpression", "AsExpression", "AsConstExpression", "SatisfiesExpression"]), Ie = b(["TSUnionType", "UnionTypeAnnotation"]), Lt = b(["TSIntersectionType", "IntersectionTypeAnnotation"]), qe = b(["TSConditionalType", "ConditionalTypeAnnotation"]), Ti = (e) => e?.type === "TSAsExpression" && e.typeAnnotation.type === "TSTypeReference" && e.typeAnnotation.typeName.type === "Identifier" && e.typeAnnotation.typeName.name === "const", Er = b(["TSTypeAliasDeclaration", "TypeAlias"]);
+var sp = /* @__PURE__ */ new Set(["range", "raw", "comments", "leadingComments", "trailingComments", "innerComments", "extra", "start", "end", "loc", "flags", "errors", "tokens"]), Vt = (e) => {
+  for (let t of e.quasis) delete t.value;
+};
+function xi(e, t, r) {
+  if (e.type === "Program" && delete t.sourceType, (e.type === "BigIntLiteral" || e.type === "Literal") && e.bigint && (t.bigint = e.bigint.toLowerCase()), e.type === "EmptyStatement" && !bt({ node: e, parent: r }) || e.type === "JSXText" || e.type === "JSXExpressionContainer" && (e.expression.type === "Literal" || e.expression.type === "StringLiteral") && e.expression.value === " ") return null;
+  if ((e.type === "Property" || e.type === "ObjectProperty" || e.type === "MethodDefinition" || e.type === "ClassProperty" || e.type === "ClassMethod" || e.type === "PropertyDefinition" || e.type === "TSDeclareMethod" || e.type === "TSPropertySignature" || e.type === "ObjectTypeProperty" || e.type === "ImportAttribute") && e.key && !e.computed) {
+    let { key: s } = e;
+    X(s) || de(s) ? t.key = String(s.value) : s.type === "Identifier" && (t.key = s.name);
+  }
+  if (e.type === "JSXElement" && e.openingElement.name.name === "style" && e.openingElement.attributes.some((s) => s.type === "JSXAttribute" && s.name.name === "jsx")) for (let { type: s, expression: i } of t.children) s === "JSXExpressionContainer" && i.type === "TemplateLiteral" && Vt(i);
+  e.type === "JSXAttribute" && e.name.name === "css" && e.value.type === "JSXExpressionContainer" && e.value.expression.type === "TemplateLiteral" && Vt(t.value.expression), e.type === "JSXAttribute" && e.value?.type === "Literal" && /["']|&quot;|&apos;/u.test(e.value.value) && (t.value.value = G(0, e.value.value, /["']|&quot;|&apos;/gu, '"'));
+  let n = e.expression || e.callee;
+  if (e.type === "Decorator" && n.type === "CallExpression" && n.callee.name === "Component" && n.arguments.length === 1) {
+    let s = e.expression.arguments[0].properties;
+    for (let [i, u] of t.expression.arguments[0].properties.entries()) switch (s[i].key.name) {
+      case "styles":
+        W(u.value) && Vt(u.value.elements[0]);
+        break;
+      case "template":
+        u.value.type === "TemplateLiteral" && Vt(u.value);
+        break;
+    }
+  }
+  e.type === "TaggedTemplateExpression" && (e.tag.type === "MemberExpression" || e.tag.type === "Identifier" && (e.tag.name === "gql" || e.tag.name === "graphql" || e.tag.name === "css" || e.tag.name === "md" || e.tag.name === "markdown" || e.tag.name === "html") || e.tag.type === "CallExpression") && Vt(t.quasi), e.type === "TemplateLiteral" && Vt(t), e.type === "ChainExpression" && e.expression.type === "TSNonNullExpression" && (t.type = "TSNonNullExpression", t.expression.type = "ChainExpression");
+}
+xi.ignoredProperties = sp;
+var gi = xi;
+var Ye = "string", Se = "array", et = "cursor", Ue = "indent", He = "align", tt = "trim", ye = "group", Le = "fill", Be = "if-break", Xe = "indent-if-break", Ve = "line-suffix", Re = "line-suffix-boundary", le = "line", be = "label", Oe = "break-parent", Gr = /* @__PURE__ */ new Set([et, Ue, He, tt, ye, Le, Be, Xe, Ve, Re, le, be, Oe]);
+function ip(e) {
+  if (typeof e == "string") return Ye;
+  if (Array.isArray(e)) return Se;
+  if (!e) return;
+  let { type: t } = e;
+  if (Gr.has(t)) return t;
+}
+var Je = ip;
+var up = (e) => new Intl.ListFormat("en-US", { type: "disjunction" }).format(e);
+function op(e) {
+  let t = e === null ? "null" : typeof e;
+  if (t !== "string" && t !== "object") return `Unexpected doc '${t}', 
+Expected it to be 'string' or 'object'.`;
+  if (Je(e)) throw new Error("doc is valid.");
+  let r = Object.prototype.toString.call(e);
+  if (r !== "[object Object]") return `Unexpected doc '${r}'.`;
+  let n = up([...Gr].map((s) => `'${s}'`));
+  return `Unexpected doc.type '${e.type}'.
+Expected it to be ${n}.`;
+}
+var Vn = class extends Error {
+  name = "InvalidDocError";
+  constructor(t) {
+    super(op(t)), this.doc = t;
+  }
+}, Tt = Vn;
+var hi = {};
+function ap(e, t, r, n) {
+  let s = [e];
+  for (; s.length > 0; ) {
+    let i = s.pop();
+    if (i === hi) {
+      r(s.pop());
+      continue;
+    }
+    r && s.push(i, hi);
+    let u = Je(i);
+    if (!u) throw new Tt(i);
+    if (t?.(i) !== false) switch (u) {
+      case Se:
+      case Le: {
+        let o = u === Se ? i : i.parts;
+        for (let a = o.length, p = a - 1; p >= 0; --p) s.push(o[p]);
+        break;
+      }
+      case Be:
+        s.push(i.flatContents, i.breakContents);
+        break;
+      case ye:
+        if (n && i.expandedStates) for (let o = i.expandedStates.length, a = o - 1; a >= 0; --a) s.push(i.expandedStates[a]);
+        else s.push(i.contents);
+        break;
+      case He:
+      case Ue:
+      case Xe:
+      case be:
+      case Ve:
+        s.push(i.contents);
+        break;
+      case Ye:
+      case et:
+      case tt:
+      case Re:
+      case le:
+      case Oe:
+        break;
+      default:
+        throw new Tt(i);
+    }
+  }
+}
+var Wr = ap;
+function Dt(e, t) {
+  if (typeof e == "string") return t(e);
+  let r = /* @__PURE__ */ new Map();
+  return n(e);
+  function n(i) {
+    if (r.has(i)) return r.get(i);
+    let u = s(i);
+    return r.set(i, u), u;
+  }
+  function s(i) {
+    switch (Je(i)) {
+      case Se:
+        return t(i.map(n));
+      case Le:
+        return t({ ...i, parts: i.parts.map(n) });
+      case Be:
+        return t({ ...i, breakContents: n(i.breakContents), flatContents: n(i.flatContents) });
+      case ye: {
+        let { expandedStates: u, contents: o } = i;
+        return u ? (u = u.map(n), o = u[0]) : o = n(o), t({ ...i, contents: o, expandedStates: u });
+      }
+      case He:
+      case Ue:
+      case Xe:
+      case be:
+      case Ve:
+        return t({ ...i, contents: n(i.contents) });
+      case Ye:
+      case et:
+      case tt:
+      case Re:
+      case le:
+      case Oe:
+        return t(i);
+      default:
+        throw new Tt(i);
+    }
+  }
+}
+function Bi(e, t, r) {
+  let n = r, s = false;
+  function i(u) {
+    if (s) return false;
+    let o = t(u);
+    o !== void 0 && (s = true, n = o);
+  }
+  return Wr(e, i), n;
+}
+function pp(e) {
+  if (e.type === ye && e.break || e.type === le && e.hard || e.type === Oe) return true;
+}
+function se(e) {
+  return Bi(e, pp, false);
+}
+function Si(e) {
+  if (e.length > 0) {
+    let t = _(0, e, -1);
+    !t.expandedStates && !t.break && (t.break = "propagated");
+  }
+  return null;
+}
+function bi(e) {
+  let t = /* @__PURE__ */ new Set(), r = [];
+  function n(i) {
+    if (i.type === Oe && Si(r), i.type === ye) {
+      if (r.push(i), t.has(i)) return false;
+      t.add(i);
+    }
+  }
+  function s(i) {
+    i.type === ye && r.pop().break && Si(r);
+  }
+  Wr(e, n, s, true);
+}
+function cp(e) {
+  return e.type === le && !e.hard ? e.soft ? "" : " " : e.type === Be ? e.flatContents : e;
+}
+function Ot(e) {
+  return Dt(e, cp);
+}
+function lp(e) {
+  switch (Je(e)) {
+    case Le:
+      if (e.parts.every((t) => t === "")) return "";
+      break;
+    case ye:
+      if (!e.contents && !e.id && !e.break && !e.expandedStates) return "";
+      if (e.contents.type === ye && e.contents.id === e.id && e.contents.break === e.break && e.contents.expandedStates === e.expandedStates) return e.contents;
+      break;
+    case He:
+    case Ue:
+    case Xe:
+    case Ve:
+      if (!e.contents) return "";
+      break;
+    case Be:
+      if (!e.flatContents && !e.breakContents) return "";
+      break;
+    case Se: {
+      let t = [];
+      for (let r of e) {
+        if (!r) continue;
+        let [n, ...s] = Array.isArray(r) ? r : [r];
+        typeof n == "string" && typeof _(0, t, -1) == "string" ? t[t.length - 1] += n : t.push(n), t.push(...s);
+      }
+      return t.length === 0 ? "" : t.length === 1 ? t[0] : t;
+    }
+    case Ye:
+    case et:
+    case tt:
+    case Re:
+    case le:
+    case be:
+    case Oe:
+      break;
+    default:
+      throw new Tt(e);
+  }
+  return e;
+}
+function $t(e) {
+  return Dt(e, (t) => lp(t));
+}
+function Ge(e, t = qr) {
+  return Dt(e, (r) => typeof r == "string" ? I(t, r.split(`
+`)) : r);
+}
+function mp(e) {
+  if (e.type === le) return true;
+}
+function Pi(e) {
+  return Bi(e, mp, false);
+}
+function Fr(e, t) {
+  return e.type === be ? { ...e, contents: t(e.contents) } : t(e);
+}
+function ki(e) {
+  let t = true;
+  return Wr(e, (r) => {
+    switch (Je(r)) {
+      case Ye:
+        if (r === "") break;
+      case tt:
+      case Re:
+      case le:
+      case Oe:
+        return t = false, false;
+    }
+  }), t;
+}
+var Yr = Pe;
+function m(e) {
+  return { type: Ue, contents: e };
+}
+function ge(e, t) {
+  return { type: He, contents: t, n: e };
+}
+function Oi(e) {
+  return ge(Number.NEGATIVE_INFINITY, e);
+}
+function Ur(e) {
+  return ge(-1, e);
+}
+function wi(e, t, r) {
+  let n = e;
+  if (t > 0) {
+    for (let s = 0; s < Math.floor(t / r); ++s) n = m(n);
+    n = ge(t % r, n), n = ge(Number.NEGATIVE_INFINITY, n);
+  }
+  return n;
+}
+var Te = { type: Oe };
+var dr = { type: et };
+function Hr(e) {
+  return { type: Le, parts: e };
+}
+function c(e, t = {}) {
+  return Yr(t.expandedStates), { type: ye, id: t.id, contents: e, break: !!t.shouldBreak, expandedStates: t.expandedStates };
+}
+function rt(e, t) {
+  return c(e[0], { ...t, expandedStates: e });
+}
+function B(e, t = "", r = {}) {
+  return { type: Be, breakContents: e, flatContents: t, groupId: r.groupId };
+}
+function ft(e, t) {
+  return { type: Xe, contents: e, groupId: t.groupId, negate: t.negate };
+}
+function I(e, t) {
+  let r = [];
+  for (let n = 0; n < t.length; n++) n !== 0 && r.push(e), r.push(t[n]);
+  return r;
+}
+function ot(e, t) {
+  return e ? { type: be, label: e, contents: t } : t;
+}
+var A = { type: le }, f = { type: le, soft: true }, $n = { type: le, hard: true }, y = [$n, Te], Dp = { type: le, hard: true, literal: true }, qr = [Dp, Te];
+function Kn(e) {
+  return { type: Ve, contents: e };
+}
+var we = { type: Re };
+function Mi(e) {
+  switch (e) {
+    case "cr":
+      return "\r";
+    case "crlf":
+      return `\r
+`;
+    default:
+      return `
+`;
+  }
+}
+var fp = { type: 0 }, yp = { type: 1 }, Qn = { value: "", length: 0, queue: [], get root() {
+  return Qn;
+} };
+function _i(e, t, r) {
+  let n = t.type === 1 ? e.queue.slice(0, -1) : [...e.queue, t], s = "", i = 0, u = 0, o = 0;
+  for (let F of n) switch (F.type) {
+    case 0:
+      D(), r.useTabs ? a(1) : p(r.tabWidth);
+      break;
+    case 3: {
+      let { string: P } = F;
+      D(), s += P, i += P.length;
+      break;
+    }
+    case 2: {
+      let { width: P } = F;
+      u += 1, o += P;
+      break;
+    }
+    default:
+      throw new Error(`Unexpected indent comment '${F.type}'.`);
+  }
+  return E(), { ...e, value: s, length: i, queue: n };
+  function a(F) {
+    s += "	".repeat(F), i += r.tabWidth * F;
+  }
+  function p(F) {
+    s += " ".repeat(F), i += F;
+  }
+  function D() {
+    r.useTabs ? l() : E();
+  }
+  function l() {
+    u > 0 && a(u), d();
+  }
+  function E() {
+    o > 0 && p(o), d();
+  }
+  function d() {
+    u = 0, o = 0;
+  }
+}
+function Ni(e, t, r) {
+  if (!t) return e;
+  if (t.type === "root") return { ...e, root: e };
+  if (t === Number.NEGATIVE_INFINITY) return e.root;
+  let n;
+  return typeof t == "number" ? t < 0 ? n = yp : n = { type: 2, width: t } : n = { type: 3, string: t }, _i(e, n, r);
+}
+function vi(e, t) {
+  return _i(e, fp, t);
+}
+function Ep(e) {
+  let t = 0;
+  for (let r = e.length - 1; r >= 0; r--) {
+    let n = e[r];
+    if (n === " " || n === "	") t++;
+    else break;
+  }
+  return t;
+}
+function zn(e) {
+  let t = Ep(e);
+  return { text: t === 0 ? e : e.slice(0, e.length - t), count: t };
+}
+var Me = Symbol("MODE_BREAK"), at = Symbol("MODE_FLAT"), Zn = Symbol("DOC_FILL_PRINTED_LENGTH");
+function Xr(e, t, r, n, s, i) {
+  if (r === Number.POSITIVE_INFINITY) return true;
+  let u = t.length, o = false, a = [e], p = "";
+  for (; r >= 0; ) {
+    if (a.length === 0) {
+      if (u === 0) return true;
+      a.push(t[--u]);
+      continue;
+    }
+    let { mode: D, doc: l } = a.pop(), E = Je(l);
+    switch (E) {
+      case Ye:
+        l && (o && (p += " ", r -= 1, o = false), p += l, r -= it(l));
+        break;
+      case Se:
+      case Le: {
+        let d = E === Se ? l : l.parts, F = l[Zn] ?? 0;
+        for (let P = d.length - 1; P >= F; P--) a.push({ mode: D, doc: d[P] });
+        break;
+      }
+      case Ue:
+      case He:
+      case Xe:
+      case be:
+        a.push({ mode: D, doc: l.contents });
+        break;
+      case tt: {
+        let { text: d, count: F } = zn(p);
+        p = d, r += F;
+        break;
+      }
+      case ye: {
+        if (i && l.break) return false;
+        let d = l.break ? Me : D, F = l.expandedStates && d === Me ? _(0, l.expandedStates, -1) : l.contents;
+        a.push({ mode: d, doc: F });
+        break;
+      }
+      case Be: {
+        let F = (l.groupId ? s[l.groupId] || at : D) === Me ? l.breakContents : l.flatContents;
+        F && a.push({ mode: D, doc: F });
+        break;
+      }
+      case le:
+        if (D === Me || l.hard) return true;
+        l.soft || (o = true);
+        break;
+      case Ve:
+        n = true;
+        break;
+      case Re:
+        if (n) return false;
+        break;
+    }
+  }
+  return false;
+}
+function es(e, t) {
+  let r = /* @__PURE__ */ Object.create(null), n = t.printWidth, s = Mi(t.endOfLine), i = 0, u = [{ indent: Qn, mode: Me, doc: e }], o = "", a = false, p = [], D = [], l = [], E = [], d = 0;
+  for (bi(e); u.length > 0; ) {
+    let { indent: g, mode: x, doc: h } = u.pop();
+    switch (Je(h)) {
+      case Ye: {
+        let N = s !== `
+` ? G(0, h, `
+`, s) : h;
+        N && (o += N, u.length > 0 && (i += it(N)));
+        break;
+      }
+      case Se:
+        for (let N = h.length - 1; N >= 0; N--) u.push({ indent: g, mode: x, doc: h[N] });
+        break;
+      case et:
+        if (D.length >= 2) throw new Error("There are too many 'cursor' in doc.");
+        D.push(d + o.length);
+        break;
+      case Ue:
+        u.push({ indent: vi(g, t), mode: x, doc: h.contents });
+        break;
+      case He:
+        u.push({ indent: Ni(g, h.n, t), mode: x, doc: h.contents });
+        break;
+      case tt:
+        O();
+        break;
+      case ye:
+        switch (x) {
+          case at:
+            if (!a) {
+              u.push({ indent: g, mode: h.break ? Me : at, doc: h.contents });
+              break;
+            }
+          case Me: {
+            a = false;
+            let N = { indent: g, mode: at, doc: h.contents }, Y = n - i, De = p.length > 0;
+            if (!h.break && Xr(N, u, Y, De, r)) u.push(N);
+            else if (h.expandedStates) {
+              let Fe = _(0, h.expandedStates, -1);
+              if (h.break) {
+                u.push({ indent: g, mode: Me, doc: Fe });
+                break;
+              } else for (let J = 1; J < h.expandedStates.length + 1; J++) if (J >= h.expandedStates.length) {
+                u.push({ indent: g, mode: Me, doc: Fe });
+                break;
+              } else {
+                let Z = h.expandedStates[J], H = { indent: g, mode: at, doc: Z };
+                if (Xr(H, u, Y, De, r)) {
+                  u.push(H);
+                  break;
+                }
+              }
+            } else u.push({ indent: g, mode: Me, doc: h.contents });
+            break;
+          }
+        }
+        h.id && (r[h.id] = _(0, u, -1).mode);
+        break;
+      case Le: {
+        let N = n - i, Y = h[Zn] ?? 0, { parts: De } = h, Fe = De.length - Y;
+        if (Fe === 0) break;
+        let J = De[Y + 0], Z = De[Y + 1], H = { indent: g, mode: at, doc: J }, nt = { indent: g, mode: Me, doc: J }, w = Xr(H, [], N, p.length > 0, r, true);
+        if (Fe === 1) {
+          w ? u.push(H) : u.push(nt);
+          break;
+        }
+        let ne = { indent: g, mode: at, doc: Z }, ae = { indent: g, mode: Me, doc: Z };
+        if (Fe === 2) {
+          w ? u.push(ne, H) : u.push(ae, nt);
+          break;
+        }
+        let st = De[Y + 2], ht = { indent: g, mode: x, doc: { ...h, [Zn]: Y + 2 } }, Sr = Xr({ indent: g, mode: at, doc: [J, Z, st] }, [], N, p.length > 0, r, true);
+        u.push(ht), Sr ? u.push(ne, H) : w ? u.push(ae, H) : u.push(ae, nt);
+        break;
+      }
+      case Be:
+      case Xe: {
+        let N = h.groupId ? r[h.groupId] : x;
+        if (N === Me) {
+          let Y = h.type === Be ? h.breakContents : h.negate ? h.contents : m(h.contents);
+          Y && u.push({ indent: g, mode: x, doc: Y });
+        }
+        if (N === at) {
+          let Y = h.type === Be ? h.flatContents : h.negate ? m(h.contents) : h.contents;
+          Y && u.push({ indent: g, mode: x, doc: Y });
+        }
+        break;
+      }
+      case Ve:
+        p.push({ indent: g, mode: x, doc: h.contents });
+        break;
+      case Re:
+        p.length > 0 && u.push({ indent: g, mode: x, doc: $n });
+        break;
+      case le:
+        switch (x) {
+          case at:
+            if (h.hard) a = true;
+            else {
+              h.soft || (o += " ", i += 1);
+              break;
+            }
+          case Me:
+            if (p.length > 0) {
+              u.push({ indent: g, mode: x, doc: h }, ...p.reverse()), p.length = 0;
+              break;
+            }
+            h.literal ? (o += s, i = 0, g.root && (g.root.value && (o += g.root.value), i = g.root.length)) : (O(), o += s + g.value, i = g.length);
+            break;
+        }
+        break;
+      case be:
+        u.push({ indent: g, mode: x, doc: h.contents });
+        break;
+      case Oe:
+        break;
+      default:
+        throw new Tt(h);
+    }
+    u.length === 0 && p.length > 0 && (u.push(...p.reverse()), p.length = 0);
+  }
+  let F = l.join("") + o, P = [...E, ...D];
+  if (P.length !== 2) return { formatted: F };
+  let S = P[0];
+  return { formatted: F, cursorNodeStart: S, cursorNodeText: F.slice(S, _(0, P, -1)) };
+  function O() {
+    let { text: g, count: x } = zn(o);
+    g && (l.push(g), d += g.length), o = "", i -= x, D.length > 0 && (E.push(...D.map((h) => Math.min(h, d))), D.length = 0);
+  }
+}
+function Fp(e) {
+  if (!ee(e)) return false;
+  let t = `*${e.value}*`.split(`
+`);
+  return t.length > 1 && t.every((r) => r.trimStart()[0] === "*");
+}
+var ts = /* @__PURE__ */ new WeakMap();
+function dp(e) {
+  return ts.has(e) || ts.set(e, Fp(e)), ts.get(e);
+}
+var ji = dp;
+function rs(e, t) {
+  let r = e.node;
+  if (Ct(r)) return t.originalText.slice(L(r), k(r)).trimEnd();
+  if (ji(r)) return Cp(r);
+  if (ee(r)) return ["/*", Ge(r.value), "*/"];
+  throw new Error("Not a comment: " + JSON.stringify(r));
+}
+function Cp(e) {
+  let t = e.value.split(`
+`);
+  return ["/*", I(y, t.map((r, n) => n === 0 ? r.trimEnd() : " " + (n < t.length - 1 ? r.trim() : r.trimStart()))), "*/"];
+}
+function Ap(e) {
+  let t = e.type || e.kind || "(unknown type)", r = String(e.name || e.id && (typeof e.id == "object" ? e.id.name : e.id) || e.key && (typeof e.key == "object" ? e.key.name : e.key) || e.value && (typeof e.value == "object" ? "" : String(e.value)) || e.operator || "");
+  return r.length > 20 && (r = r.slice(0, 19) + "…"), t + (r ? " " + r : "");
+}
+function ns(e, t) {
+  (e.comments ?? (e.comments = [])).push(t), t.printed = false, t.nodeDescription = Ap(e);
+}
+function te(e, t) {
+  t.leading = true, t.trailing = false, ns(e, t);
+}
+function _e(e, t, r) {
+  t.leading = false, t.trailing = false, r && (t.marker = r), ns(e, t);
+}
+function V(e, t) {
+  t.leading = false, t.trailing = true, ns(e, t);
+}
+function Tp(e, t) {
+  let r = null, n = t;
+  for (; n !== r; ) r = n, n = Qe(e, n), n = Gt(e, n), n = Wt(e, n), n = ze(e, n);
+  return n;
+}
+var pt = Tp;
+function xp(e, t) {
+  let r = pt(e, t);
+  return r === false ? "" : e.charAt(r);
+}
+var Ne = xp;
+function gp(e, t, r) {
+  for (let n = t; n < r; ++n) if (e.charAt(n) === `
+`) return true;
+  return false;
+}
+var re = gp;
+var ss = /* @__PURE__ */ new WeakMap();
+function hp(e) {
+  return ss.has(e) || ss.set(e, ee(e) && e.value[0] === "*" && /@(?:type|satisfies)\b/u.test(e.value)), ss.get(e);
+}
+var Vr = hp;
+var us = (e, t) => Ct(e) || !re(t, L(e), k(e));
+function Sp(e) {
+  return [Xi, Ji, Yi, Np, kp, os, as, Ri, Gi, Gp, jp, Rp, cs, Hi, Wp, Wi, Ui, ps, Ip, $p, Vi, ls].some((t) => t(e));
+}
+function Bp(e) {
+  return [Pp, Yi, Ji, Hi, os, as, Ri, Gi, Ui, vp, Jp, cs, Up, ps, Xp, Vp, Kp, Vi, zp, Qp, ls].some((t) => t(e));
+}
+function bp(e) {
+  return [Xi, os, as, _p, Wi, cs, Mp, wp, ps, Hp, ls].some((t) => t(e));
+}
+function wt(e, t) {
+  let r = (e.body || e.properties).find(({ type: n }) => n !== "EmptyStatement");
+  r ? te(r, t) : _e(e, t);
+}
+function is(e, t) {
+  e.type === "BlockStatement" ? wt(e, t) : te(e, t);
+}
+function Pp({ comment: e, followingNode: t }) {
+  return t && Vr(e) ? (te(t, e), true) : false;
+}
+function os({ comment: e, precedingNode: t, enclosingNode: r, followingNode: n, text: s }) {
+  if (r?.type !== "IfStatement" || !n) return false;
+  if (Ne(s, k(e)) === ")") return V(t, e), true;
+  if (n.type === "BlockStatement" && n === r.consequent && L(e) >= k(t) && k(e) <= L(n)) return te(n, e), true;
+  if (t === r.consequent && n === r.alternate) {
+    let u = pt(s, k(r.consequent));
+    if (n.type === "BlockStatement" && L(e) >= u && k(e) <= L(n)) return te(n, e), true;
+    if (L(e) < u || r.alternate.type === "BlockStatement") return t.type === "BlockStatement" ? (V(t, e), true) : us(e, s) && !re(s, L(t), L(e)) ? (V(t, e), true) : (_e(r, e), true);
+  }
+  return n.type === "BlockStatement" ? (wt(n, e), true) : n.type === "IfStatement" ? (is(n.consequent, e), true) : r.consequent === n ? (te(n, e), true) : false;
+}
+function as({ comment: e, precedingNode: t, enclosingNode: r, followingNode: n, text: s }) {
+  return r?.type !== "WhileStatement" || !n ? false : Ne(s, k(e)) === ")" ? (V(t, e), true) : n.type === "BlockStatement" ? (wt(n, e), true) : r.body === n ? (te(n, e), true) : false;
+}
+function Ri({ comment: e, precedingNode: t, enclosingNode: r, followingNode: n }) {
+  return r?.type !== "TryStatement" && r?.type !== "CatchClause" || !n ? false : r.type === "CatchClause" && t ? (V(t, e), true) : n.type === "BlockStatement" ? (wt(n, e), true) : n.type === "TryStatement" ? (is(n.finalizer, e), true) : n.type === "CatchClause" ? (is(n.body, e), true) : false;
+}
+function kp({ comment: e, enclosingNode: t, followingNode: r }) {
+  return R(t) && r?.type === "Identifier" ? (te(t, e), true) : false;
+}
+function Ip({ comment: e, enclosingNode: t, followingNode: r, options: n }) {
+  return !n.experimentalTernaries || !(t?.type === "ConditionalExpression" || qe(t)) ? false : r?.type === "ConditionalExpression" || qe(r) ? (_e(t, e), true) : false;
+}
+function Ji({ comment: e, precedingNode: t, enclosingNode: r, followingNode: n, text: s, options: i }) {
+  let u = t && !re(s, k(t), L(e));
+  return (!t || !u) && (r?.type === "ConditionalExpression" || qe(r)) && n ? i.experimentalTernaries && r.alternate === n && !(ee(e) && !re(i.originalText, L(e), k(e))) ? (_e(r, e), true) : (te(n, e), true) : false;
+}
+var Lp = b(["ClassDeclaration", "ClassExpression", "DeclareClass", "DeclareInterface", "InterfaceDeclaration", "TSInterfaceDeclaration"]);
+function Gi({ comment: e, precedingNode: t, enclosingNode: r, followingNode: n }) {
+  if (Lp(r)) {
+    if (j(r.decorators) && n?.type !== "Decorator") return V(_(0, r.decorators, -1), e), true;
+    if (r.body && n === r.body) return wt(r.body, e), true;
+    if (n) {
+      if (r.superClass && n === r.superClass && t && (t === r.id || t === r.typeParameters)) return V(t, e), true;
+      for (let s of ["implements", "extends", "mixins"]) if (r[s] && n === r[s][0]) return t && (t === r.id || t === r.typeParameters || t === r.superClass) ? V(t, e) : _e(r, e, s), true;
+    }
+  }
+  return false;
+}
+var Op = b(["ClassMethod", "ClassProperty", "PropertyDefinition", "TSAbstractPropertyDefinition", "TSAbstractMethodDefinition", "TSDeclareMethod", "MethodDefinition", "ClassAccessorProperty", "AccessorProperty", "TSAbstractAccessorProperty", "TSParameterProperty"]);
+function Wi({ comment: e, precedingNode: t, enclosingNode: r, text: n }) {
+  return r && t && Ne(n, k(e)) === "(" && (r.type === "Property" || r.type === "TSDeclareMethod" || r.type === "TSAbstractMethodDefinition") && t.type === "Identifier" && r.key === t && Ne(n, k(t)) !== ":" ? (V(t, e), true) : t?.type === "Decorator" && Op(r) && (Ct(e) || e.placement === "ownLine") ? (V(t, e), true) : false;
+}
+var qi = b(["FunctionDeclaration", "FunctionExpression", "ClassMethod", "MethodDefinition", "ObjectMethod"]);
+function wp({ comment: e, precedingNode: t, enclosingNode: r, text: n }) {
+  return Ne(n, k(e)) !== "(" ? false : t && qi(r) ? (V(t, e), true) : false;
+}
+function Mp({ comment: e, enclosingNode: t, text: r }) {
+  if (t?.type !== "ArrowFunctionExpression") return false;
+  let n = pt(r, k(e));
+  return n !== false && r.slice(n, n + 2) === "=>" ? (_e(t, e), true) : false;
+}
+function _p({ comment: e, enclosingNode: t, text: r }) {
+  return Ne(r, k(e)) !== ")" ? false : t && ($i(t) && K(t).length === 0 || mt(t) && ce(t).length === 0) ? (_e(t, e), true) : (t?.type === "MethodDefinition" || t?.type === "TSAbstractMethodDefinition") && K(t.value).length === 0 ? (_e(t.value, e), true) : false;
+}
+function Np({ comment: e, precedingNode: t, enclosingNode: r, followingNode: n, text: s }) {
+  return t?.type === "ComponentTypeParameter" && (r?.type === "DeclareComponent" || r?.type === "ComponentTypeAnnotation") && n?.type !== "ComponentTypeParameter" ? (V(t, e), true) : (t?.type === "ComponentParameter" || t?.type === "RestElement") && r?.type === "ComponentDeclaration" && Ne(s, k(e)) === ")" ? (V(t, e), true) : false;
+}
+function Yi({ comment: e, precedingNode: t, enclosingNode: r, followingNode: n, text: s }) {
+  return t?.type === "FunctionTypeParam" && r?.type === "FunctionTypeAnnotation" && n?.type !== "FunctionTypeParam" ? (V(t, e), true) : (t?.type === "Identifier" || t?.type === "AssignmentPattern" || t?.type === "ObjectPattern" || t?.type === "ArrayPattern" || t?.type === "RestElement" || t?.type === "TSParameterProperty") && $i(r) && Ne(s, k(e)) === ")" ? (V(t, e), true) : !ee(e) && n?.type === "BlockStatement" && qi(r) && (r.type === "MethodDefinition" ? r.value.body : r.body) === n && pt(s, k(e)) === L(n) ? (wt(n, e), true) : false;
+}
+function Ui({ comment: e, enclosingNode: t }) {
+  return t?.type === "LabeledStatement" ? (te(t, e), true) : false;
+}
+function ps({ comment: e, enclosingNode: t }) {
+  return (t?.type === "ContinueStatement" || t?.type === "BreakStatement") && !t.label ? (V(t, e), true) : false;
+}
+function vp({ comment: e, precedingNode: t, enclosingNode: r }) {
+  return M(r) && t && r.callee === t && r.arguments.length > 0 ? (te(r.arguments[0], e), true) : false;
+}
+function jp({ comment: e, precedingNode: t, enclosingNode: r, followingNode: n }) {
+  return Ie(r) ? (kt(e) && (n.prettierIgnore = true, e.unignore = true), t ? (V(t, e), true) : false) : (Ie(n) && kt(e) && (n.types[0].prettierIgnore = true, e.unignore = true), false);
+}
+function Rp({ comment: e, precedingNode: t, enclosingNode: r, followingNode: n }) {
+  return r && r.type === "MatchOrPattern" ? (kt(e) && (n.prettierIgnore = true, e.unignore = true), t ? (V(t, e), true) : false) : (n && n.type === "MatchOrPattern" && kt(e) && (n.types[0].prettierIgnore = true, e.unignore = true), false);
+}
+function Jp({ comment: e, enclosingNode: t }) {
+  return ke(t) ? (te(t, e), true) : false;
+}
+function cs({ comment: e, enclosingNode: t, ast: r, isLastComment: n }) {
+  return r?.body?.length === 0 ? (n ? _e(r, e) : te(r, e), true) : t?.type === "Program" && t.body.length === 0 && !j(t.directives) ? (n ? _e(t, e) : te(t, e), true) : false;
+}
+function Gp({ comment: e, enclosingNode: t, followingNode: r }) {
+  return (t?.type === "ForInStatement" || t?.type === "ForOfStatement") && r !== t.body ? (te(t, e), true) : false;
+}
+function Hi({ comment: e, precedingNode: t, enclosingNode: r, text: n }) {
+  if (r?.type === "ImportSpecifier" || r?.type === "ExportSpecifier") return te(r, e), true;
+  let s = t?.type === "ImportSpecifier" && r?.type === "ImportDeclaration", i = t?.type === "ExportSpecifier" && r?.type === "ExportNamedDeclaration";
+  return (s || i) && Q(n, k(e)) ? (V(t, e), true) : false;
+}
+function Wp({ comment: e, enclosingNode: t }) {
+  return t?.type === "AssignmentPattern" ? (te(t, e), true) : false;
+}
+var qp = b(["VariableDeclarator", "AssignmentExpression", "TypeAlias", "TSTypeAliasDeclaration"]), Yp = b(["ObjectExpression", "ArrayExpression", "TemplateLiteral", "TaggedTemplateExpression", "ObjectTypeAnnotation", "TSTypeLiteral"]);
+function Up({ comment: e, enclosingNode: t, followingNode: r }) {
+  return qp(t) && r && (Yp(r) || ee(e)) ? (te(r, e), true) : false;
+}
+function Hp({ comment: e, enclosingNode: t, precedingNode: r, followingNode: n, text: s }) {
+  return !n && (t?.type === "TSMethodSignature" || t?.type === "TSDeclareFunction" || t?.type === "TSAbstractMethodDefinition") && (!r || r !== t.returnType) && Ne(s, k(e)) === ";" ? (V(t, e), true) : false;
+}
+function Xi({ comment: e, enclosingNode: t, followingNode: r }) {
+  if (kt(e) && t?.type === "TSMappedType" && r === t.key) return t.prettierIgnore = true, e.unignore = true, true;
+}
+function Vi({ comment: e, precedingNode: t, enclosingNode: r }) {
+  if (r?.type === "TSMappedType" && !t) return _e(r, e), true;
+}
+function Xp({ comment: e, enclosingNode: t, followingNode: r }) {
+  return !t || t.type !== "SwitchCase" || t.test || !r || r !== t.consequent[0] ? false : (r.type === "BlockStatement" && Ct(e) ? wt(r, e) : _e(t, e), true);
+}
+function Vp({ comment: e, precedingNode: t, enclosingNode: r, followingNode: n }) {
+  return Ie(t) && ((r.type === "TSArrayType" || r.type === "ArrayTypeAnnotation") && !n || Lt(r)) ? (V(_(0, t.types, -1), e), true) : false;
+}
+function $p({ comment: e, enclosingNode: t, precedingNode: r, followingNode: n }) {
+  if ((t?.type === "ObjectPattern" || t?.type === "ArrayPattern") && n?.type === "TSTypeAnnotation") return r ? V(r, e) : _e(t, e), true;
+}
+function Kp({ comment: e, precedingNode: t, enclosingNode: r, followingNode: n, text: s }) {
+  return !n && r?.type === "UnaryExpression" && (t?.type === "LogicalExpression" || t?.type === "BinaryExpression") && re(s, L(r.argument), L(t.right)) && us(e, s) && !re(s, L(t.right), L(e)) ? (V(t.right, e), true) : false;
+}
+function Qp({ enclosingNode: e, followingNode: t, comment: r }) {
+  if (e && (e.type === "TSPropertySignature" || e.type === "ObjectTypeProperty") && (Ie(t) || Lt(t))) return te(t, r), true;
+}
+function ls({ enclosingNode: e, precedingNode: t, followingNode: r, comment: n, text: s }) {
+  if (Ae(e) && t === e.expression && !us(n, s)) return r ? te(r, n) : V(e, n), true;
+}
+function zp({ comment: e, enclosingNode: t, followingNode: r, precedingNode: n }) {
+  return t && r && n && t.type === "ArrowFunctionExpression" && t.returnType === n && (n.type === "TSTypeAnnotation" || n.type === "TypeAnnotation") ? (te(r, e), true) : false;
+}
+var $i = b(["ArrowFunctionExpression", "FunctionExpression", "FunctionDeclaration", "ObjectMethod", "ClassMethod", "TSDeclareFunction", "TSCallSignatureDeclaration", "TSConstructSignatureDeclaration", "TSMethodSignature", "TSConstructorType", "TSFunctionType", "TSDeclareMethod"]), Zp = { endOfLine: Bp, ownLine: Sp, remaining: bp }, ms = Zp;
+var ec = b(["File", "TemplateElement", "TSEmptyBodyFunctionExpression", "ChainExpression"]), tc = (e, [t]) => t?.type === "ComponentParameter" && t.shorthand && t.name === e && t.local !== t.name || t?.type === "MatchObjectPatternProperty" && t.shorthand && t.key === e && t.value !== t.key || t?.type === "ObjectProperty" && t.shorthand && t.key === e && t.value !== t.key || t?.type === "Property" && t.shorthand && t.key === e && !lt(t) && t.value !== t.key, rc = (e, [t]) => !!(e.type === "FunctionExpression" && t.type === "MethodDefinition" && t.value === e && K(e).length === 0 && !e.returnType && !j(e.typeParameters) && e.body), Ki = (e, [t]) => t?.typeAnnotation === e && Ti(t), nc = (e, [t, ...r]) => Ki(e, [t]) || t?.typeName === e && Ki(t, r);
+function Qi(e, t) {
+  return ec(e) || tc(e, t) || rc(e, t) ? false : e.type === "EmptyStatement" ? bt({ node: e, parent: t[0] }) : !(nc(e, t) || e.type === "TSTypeAnnotation" && t[0].type === "TSPropertySignature");
+}
+var sc = b(["ClassDeclaration", "ClassExpression", "DeclareClass", "DeclareInterface", "InterfaceDeclaration", "TSInterfaceDeclaration"]);
+function zi(e) {
+  let { key: t, parent: r } = e;
+  if (t === "types" && Ie(r) || t === "argument" && r.type === "JSXSpreadAttribute" || t === "expression" && r.type === "JSXSpreadChild" || t === "superClass" && (r.type === "ClassDeclaration" || r.type === "ClassExpression") || (t === "id" || t === "typeParameters") && sc(r) || t === "patterns" && r.type === "MatchOrPattern") return true;
+  let { node: n } = e;
+  return It(n) ? false : q(n) || Ie(n);
+}
+function Zi(e, { parser: t }) {
+  if (t === "flow" || t === "hermes" || t === "babel-flow") return e = G(0, e, /[\s(]/gu, ""), e === "" || e === "/*" || e === "/*::";
+}
+function ic(e, t, r = 0) {
+  let n = 0;
+  for (let s = r; s < e.length; ++s) e[s] === "	" ? n = n + t - n % t : n++;
+  return n;
+}
+var eu = ic;
+function uc(e, t) {
+  let r = e.lastIndexOf(`
+`);
+  return r === -1 ? 0 : eu(e.slice(r + 1).match(/^[\t ]*/u)[0], t);
+}
+var tu = uc;
+function $r(e, t, r) {
+  let { node: n } = e;
+  if (n.type === "TemplateLiteral" && pc(e)) {
+    let p = oc(e, t, r);
+    if (p) return p;
+  }
+  let i = "expressions";
+  n.type === "TSTemplateLiteralType" && (i = "types");
+  let u = [], o = e.map(r, i);
+  u.push(we, "`");
+  let a = 0;
+  return e.each(({ index: p, node: D }) => {
+    if (u.push(r()), D.tail) return;
+    let { tabWidth: l } = t, E = D.value.raw, d = E.includes(`
+`) ? tu(E, l) : a;
+    a = d;
+    let F = o[p], P = n[i][p], S = re(t.originalText, k(D), L(n.quasis[p + 1]));
+    if (!S) {
+      let g = es(F, { ...t, printWidth: Number.POSITIVE_INFINITY }).formatted;
+      g.includes(`
+`) ? S = true : F = g;
+    }
+    S && (C(P) || P.type === "Identifier" || R(P) || P.type === "ConditionalExpression" || P.type === "SequenceExpression" || Ae(P) || xe(P)) && (F = [m([f, F]), f]);
+    let O = d === 0 && E.endsWith(`
+`) ? ge(Number.NEGATIVE_INFINITY, F) : wi(F, d, l);
+    u.push(c(["${", O, we, "}"]));
+  }, "quasis"), u.push("`"), u;
+}
+function ru(e, t, r) {
+  let n = r("quasi"), { node: s } = e, i = "", u = Ze(s.quasi, T.Leading)[0];
+  return u && (re(t.originalText, k(s.typeArguments ?? s.tag), L(u)) ? i = f : i = " "), ot(n.label && { tagged: true, ...n.label }, [r("tag"), r("typeArguments"), i, we, n]);
+}
+function oc(e, t, r) {
+  let { node: n } = e, s = n.quasis[0].value.raw.trim().split(/\s*\|\s*/u);
+  if (s.length > 1 || s.some((i) => i.length > 0)) {
+    t.__inJestEach = true;
+    let i = e.map(r, "expressions");
+    t.__inJestEach = false;
+    let u = i.map((l) => "${" + es(l, { ...t, printWidth: Number.POSITIVE_INFINITY, endOfLine: "lf" }).formatted + "}"), o = [{ hasLineBreak: false, cells: [] }];
+    for (let l = 1; l < n.quasis.length; l++) {
+      let E = _(0, o, -1), d = u[l - 1];
+      E.cells.push(d), d.includes(`
+`) && (E.hasLineBreak = true), n.quasis[l].value.raw.includes(`
+`) && o.push({ hasLineBreak: false, cells: [] });
+    }
+    let a = Math.max(s.length, ...o.map((l) => l.cells.length)), p = Array.from({ length: a }).fill(0), D = [{ cells: s }, ...o.filter((l) => l.cells.length > 0)];
+    for (let { cells: l } of D.filter((E) => !E.hasLineBreak)) for (let [E, d] of l.entries()) p[E] = Math.max(p[E], it(d));
+    return [we, "`", m([y, I(y, D.map((l) => I(" | ", l.cells.map((E, d) => l.hasLineBreak ? E : E + " ".repeat(p[d] - it(E))))))]), y, "`"];
+  }
+}
+function ac(e, t) {
+  let { node: r } = e, n = t();
+  return C(r) && (n = c([m([f, n]), f])), ["${", n, we, "}"];
+}
+function Kt(e, t) {
+  return e.map(() => ac(e, t), "expressions");
+}
+function Kr(e, t) {
+  return Dt(e, (r) => typeof r == "string" ? t ? G(0, r, /(\\*)`/gu, "$1$1\\`") : Ds(r) : r);
+}
+function Ds(e) {
+  return G(0, e, /([\\`]|\$\{)/gu, "\\$1");
+}
+function pc({ node: e, parent: t }) {
+  let r = /^[fx]?(?:describe|it|test)$/u;
+  return t.type === "TaggedTemplateExpression" && t.quasi === e && t.tag.type === "MemberExpression" && t.tag.property.type === "Identifier" && t.tag.property.name === "each" && (t.tag.object.type === "Identifier" && r.test(t.tag.object.name) || t.tag.object.type === "MemberExpression" && t.tag.object.property.type === "Identifier" && (t.tag.object.property.name === "only" || t.tag.object.property.name === "skip") && t.tag.object.object.type === "Identifier" && r.test(t.tag.object.object.name));
+}
+var ys = [(e, t) => e.type === "ObjectExpression" && t === "properties", (e, t) => e.type === "CallExpression" && e.callee.type === "Identifier" && e.callee.name === "Component" && t === "arguments", (e, t) => e.type === "Decorator" && t === "expression"];
+function nu(e) {
+  let t = (n) => n.type === "TemplateLiteral", r = (n, s) => ke(n) && !n.computed && n.key.type === "Identifier" && n.key.name === "styles" && s === "value";
+  return e.match(t, (n, s) => W(n) && s === "elements", r, ...ys) || e.match(t, r, ...ys);
+}
+function Es(e) {
+  return e.match((t) => t.type === "TemplateLiteral", (t, r) => ke(t) && !t.computed && t.key.type === "Identifier" && t.key.name === "template" && r === "value", ...ys);
+}
+function fs(e, t) {
+  return C(e, T.Block | T.Leading, ({ value: r }) => r === ` ${t} `);
+}
+function Qr({ node: e, parent: t }, r) {
+  return fs(e, r) || cc(t) && fs(t, r) || t.type === "ExpressionStatement" && fs(t, r);
+}
+function cc(e) {
+  return e.type === "AsConstExpression" || e.type === "TSAsExpression" && e.typeAnnotation.type === "TSTypeReference" && e.typeAnnotation.typeName.type === "Identifier" && e.typeAnnotation.typeName.name === "const";
+}
+async function iu(e, t, r) {
+  let { node: n } = r, s = "";
+  for (let [a, p] of n.quasis.entries()) {
+    let { raw: D } = p.value;
+    a > 0 && (s += "@prettier-placeholder-" + (a - 1) + "-id"), s += D;
+  }
+  let i = await e(s, { parser: "scss" }), u = Kt(r, t), o = lc(i, u);
+  if (!o) throw new Error("Couldn't insert all the expressions");
+  return ["`", m([y, o]), f, "`"];
+}
+function lc(e, t) {
+  if (!j(t)) return e;
+  let r = 0, n = Dt($t(e), (s) => typeof s != "string" || !s.includes("@prettier-placeholder") ? s : s.split(/@prettier-placeholder-(\d+)-id/u).map((i, u) => u % 2 === 0 ? Ge(i) : (r++, t[i])));
+  return t.length === r ? n : null;
+}
+function mc(e) {
+  return e.match(void 0, (t, r) => r === "quasi" && t.type === "TaggedTemplateExpression" && Bt(t.tag, ["css", "css.global", "css.resolve"])) || e.match(void 0, (t, r) => r === "expression" && t.type === "JSXExpressionContainer", (t, r) => r === "children" && t.type === "JSXElement" && t.openingElement.name.type === "JSXIdentifier" && t.openingElement.name.name === "style" && t.openingElement.attributes.some((n) => n.type === "JSXAttribute" && n.name.type === "JSXIdentifier" && n.name.name === "jsx"));
+}
+function zr(e) {
+  return e.type === "Identifier" && e.name === "styled";
+}
+function su(e) {
+  return /^[A-Z]/u.test(e.object.name) && e.property.name === "extend";
+}
+function Dc({ parent: e }) {
+  if (!e || e.type !== "TaggedTemplateExpression") return false;
+  let t = e.tag.type === "ParenthesizedExpression" ? e.tag.expression : e.tag;
+  switch (t.type) {
+    case "MemberExpression":
+      return zr(t.object) || su(t);
+    case "CallExpression":
+      return zr(t.callee) || t.callee.type === "MemberExpression" && (t.callee.object.type === "MemberExpression" && (zr(t.callee.object.object) || su(t.callee.object)) || t.callee.object.type === "CallExpression" && zr(t.callee.object.callee));
+    case "Identifier":
+      return t.name === "css";
+    default:
+      return false;
+  }
+}
+function fc({ parent: e, grandparent: t }) {
+  return t?.type === "JSXAttribute" && e.type === "JSXExpressionContainer" && t.name.type === "JSXIdentifier" && t.name.name === "css";
+}
+var uu = (e) => mc(e) || Dc(e) || fc(e) || nu(e);
+async function ou(e, t, r) {
+  let { node: n } = r, s = n.quasis.length, i = Kt(r, t), u = [];
+  for (let o = 0; o < s; o++) {
+    let a = n.quasis[o], p = o === 0, D = o === s - 1, l = a.value.cooked, E = l.split(`
+`), d = E.length, F = i[o], P = d > 2 && E[0].trim() === "" && E[1].trim() === "", S = d > 2 && E[d - 1].trim() === "" && E[d - 2].trim() === "", O = E.every((x) => /^\s*(?:#[^\n\r]*)?$/u.test(x));
+    if (!D && /#[^\n\r]*$/u.test(E[d - 1])) return null;
+    let g = null;
+    O ? g = yc(E) : g = await e(l, { parser: "graphql" }), g ? (g = Kr(g, false), !p && P && u.push(""), u.push(g), !D && S && u.push("")) : !p && !D && P && u.push(""), F && u.push(F);
+  }
+  return ["`", m([y, I(y, u)]), y, "`"];
+}
+function yc(e) {
+  let t = [], r = false, n = e.map((s) => s.trim());
+  for (let [s, i] of n.entries()) i !== "" && (n[s - 1] === "" && r ? t.push([y, i]) : t.push(i), r = true);
+  return t.length === 0 ? null : I(y, t);
+}
+function au({ node: e, parent: t }) {
+  return Qr({ node: e, parent: t }, "GraphQL") || t && (t.type === "TaggedTemplateExpression" && (t.tag.type === "MemberExpression" && t.tag.object.name === "graphql" && t.tag.property.name === "experimental" || t.tag.type === "Identifier" && (t.tag.name === "gql" || t.tag.name === "graphql")) || t.type === "CallExpression" && t.callee.type === "Identifier" && t.callee.name === "graphql");
+}
+var Fs = 0;
+async function pu(e, t, r, n, s) {
+  let { node: i } = n, u = Fs;
+  Fs = Fs + 1 >>> 0;
+  let o = (O) => `PRETTIER_HTML_PLACEHOLDER_${O}_${u}_IN_JS`, a = i.quasis.map((O, g, x) => g === x.length - 1 ? O.value.cooked : O.value.cooked + o(g)).join(""), p = Kt(n, r), D = new RegExp(o("(\\d+)"), "gu"), l = 0, E = await t(a, { parser: e, __onHtmlRoot(O) {
+    l = O.children.length;
+  } }), d = Dt(E, (O) => {
+    if (typeof O != "string") return O;
+    let g = [], x = O.split(D);
+    for (let h = 0; h < x.length; h++) {
+      let N = x[h];
+      if (h % 2 === 0) {
+        N && (N = Ds(N), s.__embeddedInHtml && (N = G(0, N, /<\/(?=script\b)/giu, "<\\/")), g.push(N));
+        continue;
+      }
+      let Y = Number(N);
+      g.push(p[Y]);
+    }
+    return g;
+  }), F = /^\s/u.test(a) ? " " : "", P = /\s$/u.test(a) ? " " : "", S = s.htmlWhitespaceSensitivity === "ignore" ? y : F && P ? A : null;
+  return S ? c(["`", m([S, c(d)]), S, "`"]) : ot({ hug: false }, c(["`", F, l > 1 ? m(c(d)) : c(d), P, "`"]));
+}
+function cu(e) {
+  return Qr(e, "HTML") || e.match((t) => t.type === "TemplateLiteral", (t, r) => t.type === "TaggedTemplateExpression" && t.tag.type === "Identifier" && t.tag.name === "html" && r === "quasi");
+}
+var lu = pu.bind(void 0, "html"), mu = pu.bind(void 0, "angular");
+async function Du(e, t, r) {
+  let { node: n } = r, s = G(0, n.quasis[0].value.raw, /((?:\\\\)*)\\`/gu, (a, p) => "\\".repeat(p.length / 2) + "`"), i = Ec(s), u = i !== "";
+  u && (s = G(0, s, new RegExp(`^${i}`, "gmu"), ""));
+  let o = Kr(await e(s, { parser: "markdown", __inJsTemplate: true }), true);
+  return ["`", u ? m([f, o]) : [qr, Oi(o)], f, "`"];
+}
+function Ec(e) {
+  let t = e.match(/^([^\S\n]*)\S/mu);
+  return t === null ? "" : t[1];
+}
+function fu({ node: e, parent: t }) {
+  return t?.type === "TaggedTemplateExpression" && e.quasis.length === 1 && t.tag.type === "Identifier" && (t.tag.name === "md" || t.tag.name === "markdown");
+}
+var Fc = [{ test: uu, print: iu }, { test: au, print: ou }, { test: cu, print: lu }, { test: Es, print: mu }, { test: fu, print: Du }].map(({ test: e, print: t }) => ({ test: e, print: Cc(t) }));
+function dc(e) {
+  let { node: t } = e;
+  if (t.type !== "TemplateLiteral" || Ac(t)) return;
+  let r = Fc.find(({ test: n }) => n(e));
+  if (r) return t.quasis.length === 1 && t.quasis[0].value.raw.trim() === "" ? "``" : r.print;
+}
+function Cc(e) {
+  return async (...t) => {
+    let r = await e(...t);
+    return r && ot({ embed: true, ...r.label }, r);
+  };
+}
+function Ac({ quasis: e }) {
+  return e.some(({ value: { cooked: t } }) => t === null);
+}
+var yu = dc;
+var Tc = /\*\/$/, xc = /^\/\*\*?/, Cu = /^\s*(\/\*\*?(.|\r?\n)*?\*\/)/, gc = /(^|\s+)\/\/([^\n\r]*)/g, Eu = /^(\r?\n)+/, hc = /(?:^|\r?\n) *(@[^\n\r]*?) *\r?\n *(?![^\n\r@]*\/\/[^]*)([^\s@][^\n\r@]+?) *\r?\n/g, Fu = /(?:^|\r?\n) *@(\S+) *([^\n\r]*)/g, Sc = /(\r?\n|^) *\* ?/g, Au = [];
+function Tu(e) {
+  let t = e.match(Cu);
+  return t ? t[0].trimStart() : "";
+}
+function xu(e) {
+  let r = e.match(Cu)?.[0];
+  return r == null ? e : e.slice(r.length);
+}
+function gu(e) {
+  e = G(0, e.replace(xc, "").replace(Tc, ""), Sc, "$1");
+  let r = "";
+  for (; r !== e; ) r = e, e = G(0, e, hc, `
+$1 $2
+`);
+  e = e.replace(Eu, "").trimEnd();
+  let n = /* @__PURE__ */ Object.create(null), s = G(0, e, Fu, "").replace(Eu, "").trimEnd(), i;
+  for (; i = Fu.exec(e); ) {
+    let u = G(0, i[2], gc, "");
+    if (typeof n[i[1]] == "string" || Array.isArray(n[i[1]])) {
+      let o = n[i[1]];
+      n[i[1]] = [...Au, ...Array.isArray(o) ? o : [o], u];
+    } else n[i[1]] = u;
+  }
+  return { comments: s, pragmas: n };
+}
+function hu({ comments: e = "", pragmas: t = {} }) {
+  let u = Object.keys(t), o = u.flatMap((p) => du(p, t[p])).map((p) => ` * ${p}
+`).join("");
+  if (!e) {
+    if (u.length === 0) return "";
+    if (u.length === 1 && !Array.isArray(t[u[0]])) {
+      let p = t[u[0]];
+      return `/** ${du(u[0], p)[0]} */`;
+    }
+  }
+  let a = e.split(`
+`).map((p) => ` * ${p}`).join(`
+`) + `
+`;
+  return `/**
+` + (e ? a : "") + (e && u.length > 0 ? ` *
+` : "") + o + " */";
+}
+function du(e, t) {
+  return [...Au, ...Array.isArray(t) ? t : [t]].map((r) => `@${e} ${r}`.trim());
+}
+var Su = "format";
+function Bc(e) {
+  if (!e.startsWith("#!")) return "";
+  let t = e.indexOf(`
+`);
+  return t === -1 ? e : e.slice(0, t);
+}
+var Bu = Bc;
+function bc(e) {
+  let t = Bu(e);
+  t && (e = e.slice(t.length + 1));
+  let r = Tu(e), { pragmas: n, comments: s } = gu(r);
+  return { shebang: t, text: e, pragmas: n, comments: s };
+}
+function bu(e) {
+  let { shebang: t, text: r, pragmas: n, comments: s } = bc(e), i = xu(r), u = hu({ pragmas: { [Su]: "", ...n }, comments: s.trimStart() });
+  return (t ? `${t}
+` : "") + u + (i.startsWith(`
+`) ? `
+` : `
+
+`) + i;
+}
+function ds(e, t) {
+  if (e.isRoot) return false;
+  let { node: r, key: n, parent: s } = e;
+  if (t.__isInHtmlInterpolation && !t.bracketSpacing && Lc(r) && Cr(e)) return true;
+  if (Pc(r)) return false;
+  if (r.type === "Identifier") {
+    if (r.extra?.parenthesized && /^PRETTIER_HTML_PLACEHOLDER_\d+_\d+_IN_JS$/u.test(r.name) || n === "left" && (r.name === "async" && !s.await || r.name === "let") && s.type === "ForOfStatement") return true;
+    if (r.name === "let") {
+      let i = e.findAncestor((u) => u.type === "ForOfStatement")?.left;
+      if (i && fe(i, (u) => u === r)) return true;
+    }
+    if (n === "object" && r.name === "let" && s.type === "MemberExpression" && s.computed && !s.optional) {
+      let i = e.findAncestor((o) => o.type === "ExpressionStatement" || o.type === "ForStatement" || o.type === "ForInStatement"), u = i ? i.type === "ExpressionStatement" ? i.expression : i.type === "ForStatement" ? i.init : i.left : void 0;
+      if (u && fe(u, (o) => o === r)) return true;
+    }
+    if (n === "expression") switch (r.name) {
+      case "await":
+      case "interface":
+      case "module":
+      case "using":
+      case "yield":
+      case "let":
+      case "component":
+      case "hook":
+      case "type": {
+        let i = e.findAncestor((u) => !Ae(u));
+        if (i !== s && i.type === "ExpressionStatement") return true;
+      }
+    }
+    return false;
+  }
+  if (r.type === "ObjectExpression" || r.type === "FunctionExpression" || r.type === "ClassExpression" || r.type === "DoExpression") {
+    let i = e.findAncestor((u) => u.type === "ExpressionStatement")?.expression;
+    if (i && fe(i, (u) => u === r)) return true;
+  }
+  if (r.type === "ObjectExpression") {
+    let i = e.findAncestor((u) => u.type === "ArrowFunctionExpression")?.body;
+    if (i && i.type !== "SequenceExpression" && i.type !== "AssignmentExpression" && fe(i, (u) => u === r)) return true;
+  }
+  switch (s.type) {
+    case "ParenthesizedExpression":
+      return false;
+    case "ClassDeclaration":
+    case "ClassExpression":
+      if (n === "superClass" && (r.type === "ArrowFunctionExpression" || r.type === "AssignmentExpression" || r.type === "AwaitExpression" || r.type === "BinaryExpression" || r.type === "ConditionalExpression" || r.type === "LogicalExpression" || r.type === "NewExpression" || r.type === "ObjectExpression" || r.type === "SequenceExpression" || r.type === "TaggedTemplateExpression" || r.type === "UnaryExpression" || r.type === "UpdateExpression" || r.type === "YieldExpression" || r.type === "TSNonNullExpression" || r.type === "ClassExpression" && j(r.decorators))) return true;
+      break;
+    case "ExportDefaultDeclaration":
+      return Pu(e, t) || r.type === "SequenceExpression";
+    case "Decorator":
+      if (n === "expression" && !wc(r)) return true;
+      break;
+    case "TypeAnnotation":
+      if (e.match(void 0, void 0, (i, u) => u === "returnType" && i.type === "ArrowFunctionExpression") && Ic(r)) return true;
+      break;
+    case "BinaryExpression":
+      if (n === "left" && (s.operator === "in" || s.operator === "instanceof") && r.type === "UnaryExpression") return true;
+      break;
+    case "VariableDeclarator":
+      if (n === "init" && e.match(void 0, void 0, (i, u) => u === "declarations" && i.type === "VariableDeclaration", (i, u) => u === "left" && i.type === "ForInStatement")) return true;
+      break;
+  }
+  switch (r.type) {
+    case "UpdateExpression":
+      if (s.type === "UnaryExpression") return r.prefix && (r.operator === "++" && s.operator === "+" || r.operator === "--" && s.operator === "-");
+    case "UnaryExpression":
+      switch (s.type) {
+        case "UnaryExpression":
+          return r.operator === s.operator && (r.operator === "+" || r.operator === "-");
+        case "BindExpression":
+          return true;
+        case "MemberExpression":
+        case "OptionalMemberExpression":
+          return n === "object";
+        case "TaggedTemplateExpression":
+          return true;
+        case "NewExpression":
+        case "CallExpression":
+        case "OptionalCallExpression":
+          return n === "callee";
+        case "BinaryExpression":
+          return n === "left" && s.operator === "**";
+        case "TSNonNullExpression":
+          return true;
+        default:
+          return false;
+      }
+    case "BinaryExpression":
+      if (s.type === "UpdateExpression" || r.operator === "in" && kc(e)) return true;
+      if (r.operator === "|>" && r.extra?.parenthesized) {
+        let i = e.grandparent;
+        if (i.type === "BinaryExpression" && i.operator === "|>") return true;
+      }
+    case "TSTypeAssertion":
+    case "TSAsExpression":
+    case "TSSatisfiesExpression":
+    case "AsExpression":
+    case "AsConstExpression":
+    case "SatisfiesExpression":
+    case "LogicalExpression":
+      switch (s.type) {
+        case "TSAsExpression":
+        case "TSSatisfiesExpression":
+        case "AsExpression":
+        case "AsConstExpression":
+        case "SatisfiesExpression":
+          return !Ae(r);
+        case "ConditionalExpression":
+          return Ae(r) || li(r);
+        case "CallExpression":
+        case "NewExpression":
+        case "OptionalCallExpression":
+          return n === "callee";
+        case "ClassExpression":
+        case "ClassDeclaration":
+          return n === "superClass";
+        case "TSTypeAssertion":
+        case "TaggedTemplateExpression":
+        case "UnaryExpression":
+        case "JSXSpreadAttribute":
+        case "SpreadElement":
+        case "BindExpression":
+        case "AwaitExpression":
+        case "TSNonNullExpression":
+        case "UpdateExpression":
+          return true;
+        case "MemberExpression":
+        case "OptionalMemberExpression":
+          return n === "object";
+        case "AssignmentExpression":
+        case "AssignmentPattern":
+          return n === "left" && (r.type === "TSTypeAssertion" || Ae(r));
+        case "LogicalExpression":
+          if (r.type === "LogicalExpression") return s.operator !== r.operator;
+        case "BinaryExpression": {
+          let { operator: i, type: u } = r;
+          if (!i && u !== "TSTypeAssertion") return true;
+          let o = mr(i), a = s.operator, p = mr(a);
+          return !!(p > o || n === "right" && p === o || p === o && !yr(a, i) || p < o && i === "%" && (a === "+" || a === "-") || Fi(a));
+        }
+        default:
+          return false;
+      }
+    case "SequenceExpression":
+      return s.type !== "ForStatement";
+    case "YieldExpression":
+      if (s.type === "AwaitExpression" || s.type === "TSTypeAssertion") return true;
+    case "AwaitExpression":
+      switch (s.type) {
+        case "TaggedTemplateExpression":
+        case "UnaryExpression":
+        case "LogicalExpression":
+        case "SpreadElement":
+        case "TSAsExpression":
+        case "TSSatisfiesExpression":
+        case "TSNonNullExpression":
+        case "AsExpression":
+        case "AsConstExpression":
+        case "SatisfiesExpression":
+        case "BindExpression":
+          return true;
+        case "MemberExpression":
+        case "OptionalMemberExpression":
+          return n === "object";
+        case "NewExpression":
+        case "CallExpression":
+        case "OptionalCallExpression":
+          return n === "callee";
+        case "ConditionalExpression":
+          return n === "test";
+        case "BinaryExpression":
+          return !(!r.argument && s.operator === "|>");
+        default:
+          return false;
+      }
+    case "TSFunctionType":
+      if (e.match((i) => i.type === "TSFunctionType", (i, u) => u === "typeAnnotation" && i.type === "TSTypeAnnotation", (i, u) => u === "returnType" && i.type === "ArrowFunctionExpression")) return true;
+    case "TSConditionalType":
+    case "TSConstructorType":
+    case "ConditionalTypeAnnotation":
+      if (n === "extendsType" && qe(r) && s.type === r.type || n === "checkType" && qe(s)) return true;
+      if (n === "extendsType" && s.type === "TSConditionalType") {
+        let { typeAnnotation: i } = r.returnType || r.typeAnnotation;
+        if (i.type === "TSTypePredicate" && i.typeAnnotation && (i = i.typeAnnotation.typeAnnotation), i.type === "TSInferType" && i.typeParameter.constraint) return true;
+      }
+    case "TSUnionType":
+    case "TSIntersectionType":
+      if ((Ie(s) || Lt(s)) && s.types.length > 1 && (!r.types || r.types.length > 1)) return true;
+    case "TSInferType":
+      if (r.type === "TSInferType") {
+        if (s.type === "TSRestType") return false;
+        if (n === "types" && (s.type === "TSUnionType" || s.type === "TSIntersectionType") && r.typeParameter.type === "TSTypeParameter" && r.typeParameter.constraint) return true;
+      }
+    case "TSTypeOperator":
+      return s.type === "TSArrayType" || s.type === "TSOptionalType" || s.type === "TSRestType" || n === "objectType" && s.type === "TSIndexedAccessType" || s.type === "TSTypeOperator" || s.type === "TSTypeAnnotation" && e.grandparent.type.startsWith("TSJSDoc");
+    case "TSTypeQuery":
+      return n === "objectType" && s.type === "TSIndexedAccessType" || n === "elementType" && s.type === "TSArrayType";
+    case "TypeOperator":
+      return s.type === "ArrayTypeAnnotation" || s.type === "NullableTypeAnnotation" || n === "objectType" && (s.type === "IndexedAccessType" || s.type === "OptionalIndexedAccessType") || s.type === "TypeOperator";
+    case "TypeofTypeAnnotation":
+      return n === "objectType" && (s.type === "IndexedAccessType" || s.type === "OptionalIndexedAccessType") || n === "elementType" && s.type === "ArrayTypeAnnotation";
+    case "ArrayTypeAnnotation":
+      return s.type === "NullableTypeAnnotation";
+    case "IntersectionTypeAnnotation":
+    case "UnionTypeAnnotation":
+      return s.type === "TypeOperator" || s.type === "KeyofTypeAnnotation" || s.type === "ArrayTypeAnnotation" || s.type === "NullableTypeAnnotation" || s.type === "IntersectionTypeAnnotation" || s.type === "UnionTypeAnnotation" || n === "objectType" && (s.type === "IndexedAccessType" || s.type === "OptionalIndexedAccessType");
+    case "InferTypeAnnotation":
+    case "NullableTypeAnnotation":
+      return s.type === "ArrayTypeAnnotation" || n === "objectType" && (s.type === "IndexedAccessType" || s.type === "OptionalIndexedAccessType");
+    case "ComponentTypeAnnotation":
+    case "FunctionTypeAnnotation": {
+      if (r.type === "ComponentTypeAnnotation" && (r.rendersType === null || r.rendersType === void 0)) return false;
+      if (e.match(void 0, (u, o) => o === "typeAnnotation" && u.type === "TypeAnnotation", (u, o) => o === "returnType" && u.type === "ArrowFunctionExpression") || e.match(void 0, (u, o) => o === "typeAnnotation" && u.type === "TypePredicate", (u, o) => o === "typeAnnotation" && u.type === "TypeAnnotation", (u, o) => o === "returnType" && u.type === "ArrowFunctionExpression")) return true;
+      let i = s.type === "NullableTypeAnnotation" ? e.grandparent : s;
+      return i.type === "UnionTypeAnnotation" || i.type === "IntersectionTypeAnnotation" || i.type === "ArrayTypeAnnotation" || n === "objectType" && (i.type === "IndexedAccessType" || i.type === "OptionalIndexedAccessType") || n === "checkType" && s.type === "ConditionalTypeAnnotation" || n === "extendsType" && s.type === "ConditionalTypeAnnotation" && r.returnType?.type === "InferTypeAnnotation" && r.returnType?.typeParameter.bound || i.type === "NullableTypeAnnotation" || s.type === "FunctionTypeParam" && s.name === null && K(r).some((u) => u.typeAnnotation?.type === "NullableTypeAnnotation");
+    }
+    case "OptionalIndexedAccessType":
+      return n === "objectType" && s.type === "IndexedAccessType";
+    case "StringLiteral":
+    case "NumericLiteral":
+    case "Literal":
+      if (typeof r.value == "string" && s.type === "ExpressionStatement" && typeof s.directive != "string") {
+        let i = e.grandparent;
+        return i.type === "Program" || i.type === "BlockStatement";
+      }
+      return n === "object" && R(s) && de(r);
+    case "AssignmentExpression":
+      return !((n === "init" || n === "update") && s.type === "ForStatement" || n === "expression" && r.left.type !== "ObjectPattern" && s.type === "ExpressionStatement" || n === "key" && s.type === "TSPropertySignature" || s.type === "AssignmentExpression" || n === "expressions" && s.type === "SequenceExpression" && e.match(void 0, void 0, (i, u) => (u === "init" || u === "update") && i.type === "ForStatement") || n === "value" && s.type === "Property" && e.match(void 0, void 0, (i, u) => u === "properties" && i.type === "ObjectPattern") || s.type === "NGChainedExpression" || n === "node" && s.type === "JsExpressionRoot");
+    case "ConditionalExpression":
+      switch (s.type) {
+        case "TaggedTemplateExpression":
+        case "UnaryExpression":
+        case "SpreadElement":
+        case "BinaryExpression":
+        case "LogicalExpression":
+        case "NGPipeExpression":
+        case "ExportDefaultDeclaration":
+        case "AwaitExpression":
+        case "JSXSpreadAttribute":
+        case "TSTypeAssertion":
+        case "TypeCastExpression":
+        case "TSAsExpression":
+        case "TSSatisfiesExpression":
+        case "AsExpression":
+        case "AsConstExpression":
+        case "SatisfiesExpression":
+        case "TSNonNullExpression":
+          return true;
+        case "NewExpression":
+        case "CallExpression":
+        case "OptionalCallExpression":
+          return n === "callee";
+        case "ConditionalExpression":
+          return t.experimentalTernaries ? false : n === "test";
+        case "MemberExpression":
+        case "OptionalMemberExpression":
+          return n === "object";
+        default:
+          return false;
+      }
+    case "FunctionExpression":
+      switch (s.type) {
+        case "NewExpression":
+        case "CallExpression":
+        case "OptionalCallExpression":
+          return n === "callee";
+        case "TaggedTemplateExpression":
+          return true;
+        default:
+          return false;
+      }
+    case "ArrowFunctionExpression":
+      switch (s.type) {
+        case "BinaryExpression":
+          return s.operator !== "|>" || r.extra?.parenthesized;
+        case "NewExpression":
+        case "CallExpression":
+        case "OptionalCallExpression":
+          return n === "callee";
+        case "MemberExpression":
+        case "OptionalMemberExpression":
+          return n === "object";
+        case "TSAsExpression":
+        case "TSSatisfiesExpression":
+        case "AsExpression":
+        case "AsConstExpression":
+        case "SatisfiesExpression":
+        case "TSNonNullExpression":
+        case "BindExpression":
+        case "TaggedTemplateExpression":
+        case "UnaryExpression":
+        case "LogicalExpression":
+        case "AwaitExpression":
+        case "TSTypeAssertion":
+        case "MatchExpressionCase":
+          return true;
+        case "TSInstantiationExpression":
+          return n === "expression";
+        case "ConditionalExpression":
+          return n === "test";
+        default:
+          return false;
+      }
+    case "ClassExpression":
+      switch (s.type) {
+        case "NewExpression":
+          return n === "callee";
+        default:
+          return false;
+      }
+    case "OptionalMemberExpression":
+    case "OptionalCallExpression":
+    case "CallExpression":
+    case "MemberExpression":
+      if (Oc(e)) return true;
+    case "TaggedTemplateExpression":
+    case "TSNonNullExpression":
+      if (n === "callee" && (s.type === "BindExpression" || s.type === "NewExpression")) {
+        let i = r;
+        for (; i; ) switch (i.type) {
+          case "CallExpression":
+          case "OptionalCallExpression":
+            return true;
+          case "MemberExpression":
+          case "OptionalMemberExpression":
+          case "BindExpression":
+            i = i.object;
+            break;
+          case "TaggedTemplateExpression":
+            i = i.tag;
+            break;
+          case "TSNonNullExpression":
+            i = i.expression;
+            break;
+          default:
+            return false;
+        }
+      }
+      return false;
+    case "BindExpression":
+      return n === "callee" && (s.type === "BindExpression" || s.type === "NewExpression") || n === "object" && R(s);
+    case "NGPipeExpression":
+      return !(s.type === "NGRoot" || s.type === "NGMicrosyntaxExpression" || s.type === "ObjectProperty" && !r.extra?.parenthesized || W(s) || n === "arguments" && M(s) || n === "right" && s.type === "NGPipeExpression" || n === "property" && s.type === "MemberExpression" || s.type === "AssignmentExpression");
+    case "JSXFragment":
+    case "JSXElement":
+      return n === "callee" || n === "left" && s.type === "BinaryExpression" && s.operator === "<" || !W(s) && s.type !== "ArrowFunctionExpression" && s.type !== "AssignmentExpression" && s.type !== "AssignmentPattern" && s.type !== "BinaryExpression" && s.type !== "NewExpression" && s.type !== "ConditionalExpression" && s.type !== "ExpressionStatement" && s.type !== "JsExpressionRoot" && s.type !== "JSXAttribute" && s.type !== "JSXElement" && s.type !== "JSXExpressionContainer" && s.type !== "JSXFragment" && s.type !== "LogicalExpression" && !M(s) && !ke(s) && s.type !== "ReturnStatement" && s.type !== "ThrowStatement" && s.type !== "TypeCastExpression" && s.type !== "VariableDeclarator" && s.type !== "YieldExpression" && s.type !== "MatchExpressionCase";
+    case "TSInstantiationExpression":
+      return n === "object" && R(s);
+    case "MatchOrPattern":
+      return s.type === "MatchAsPattern";
+  }
+  return false;
+}
+var Pc = b(["BlockStatement", "BreakStatement", "ComponentDeclaration", "ClassBody", "ClassDeclaration", "ClassMethod", "ClassProperty", "PropertyDefinition", "ClassPrivateProperty", "ContinueStatement", "DebuggerStatement", "DeclareComponent", "DeclareClass", "DeclareExportAllDeclaration", "DeclareExportDeclaration", "DeclareFunction", "DeclareHook", "DeclareInterface", "DeclareModule", "DeclareModuleExports", "DeclareNamespace", "DeclareVariable", "DeclareEnum", "DoWhileStatement", "EnumDeclaration", "ExportAllDeclaration", "ExportDefaultDeclaration", "ExportNamedDeclaration", "ExpressionStatement", "ForInStatement", "ForOfStatement", "ForStatement", "FunctionDeclaration", "HookDeclaration", "IfStatement", "ImportDeclaration", "InterfaceDeclaration", "LabeledStatement", "MethodDefinition", "ReturnStatement", "SwitchStatement", "ThrowStatement", "TryStatement", "TSDeclareFunction", "TSEnumDeclaration", "TSImportEqualsDeclaration", "TSInterfaceDeclaration", "TSModuleDeclaration", "TSNamespaceExportDeclaration", "TypeAlias", "VariableDeclaration", "WhileStatement", "WithStatement"]);
+function kc(e) {
+  let t = 0, { node: r } = e;
+  for (; r; ) {
+    let n = e.getParentNode(t++);
+    if (n?.type === "ForStatement" && n.init === r) return true;
+    r = n;
+  }
+  return false;
+}
+function Ic(e) {
+  return Dr(e, (t) => t.type === "ObjectTypeAnnotation" && Dr(t, (r) => r.type === "FunctionTypeAnnotation"));
+}
+function Lc(e) {
+  return ie(e);
+}
+function Cr(e) {
+  let { parent: t, key: r } = e;
+  switch (t.type) {
+    case "NGPipeExpression":
+      if (r === "arguments" && e.isLast) return e.callParent(Cr);
+      break;
+    case "ObjectProperty":
+      if (r === "value") return e.callParent(() => e.key === "properties" && e.isLast);
+      break;
+    case "BinaryExpression":
+    case "LogicalExpression":
+      if (r === "right") return e.callParent(Cr);
+      break;
+    case "ConditionalExpression":
+      if (r === "alternate") return e.callParent(Cr);
+      break;
+    case "UnaryExpression":
+      if (t.prefix) return e.callParent(Cr);
+      break;
+  }
+  return false;
+}
+function Pu(e, t) {
+  let { node: r, parent: n } = e;
+  return r.type === "FunctionExpression" || r.type === "ClassExpression" ? n.type === "ExportDefaultDeclaration" || !ds(e, t) : !Ut(r) || n.type !== "ExportDefaultDeclaration" && ds(e, t) ? false : e.call(() => Pu(e, t), ..._r(r));
+}
+function Oc(e) {
+  return !!(e.match(void 0, (t, r) => r === "expression" && t.type === "ChainExpression", (t, r) => r === "tag" && t.type === "TaggedTemplateExpression") || e.match((t) => t.type === "OptionalCallExpression" || t.type === "OptionalMemberExpression", (t, r) => r === "tag" && t.type === "TaggedTemplateExpression") || e.match((t) => t.type === "OptionalCallExpression" || t.type === "OptionalMemberExpression", (t, r) => r === "expression" && t.type === "TSNonNullExpression", (t, r) => r === "tag" && t.type === "TaggedTemplateExpression") || e.match(void 0, (t, r) => r === "expression" && t.type === "ChainExpression", (t, r) => r === "expression" && t.type === "TSNonNullExpression", (t, r) => r === "tag" && t.type === "TaggedTemplateExpression") || e.match(void 0, (t, r) => r === "expression" && t.type === "TSNonNullExpression", (t, r) => r === "expression" && t.type === "ChainExpression", (t, r) => r === "tag" && t.type === "TaggedTemplateExpression") || e.match((t) => t.type === "OptionalMemberExpression" || t.type === "OptionalCallExpression", (t, r) => r === "object" && t.type === "MemberExpression" || r === "callee" && (t.type === "CallExpression" || t.type === "NewExpression")) || e.match((t) => t.type === "OptionalMemberExpression" || t.type === "OptionalCallExpression", (t, r) => r === "expression" && t.type === "TSNonNullExpression", (t, r) => r === "object" && t.type === "MemberExpression" || r === "callee" && t.type === "CallExpression") || e.match((t) => t.type === "CallExpression" || t.type === "MemberExpression", (t, r) => r === "expression" && t.type === "ChainExpression") && (e.match(void 0, void 0, (t, r) => r === "callee" && (t.type === "CallExpression" && !t.optional || t.type === "NewExpression") || r === "object" && t.type === "MemberExpression" && !t.optional) || e.match(void 0, void 0, (t, r) => r === "expression" && t.type === "TSNonNullExpression", (t, r) => r === "object" && t.type === "MemberExpression" || r === "callee" && t.type === "CallExpression")) || e.match((t) => t.type === "CallExpression" || t.type === "MemberExpression", (t, r) => r === "expression" && t.type === "TSNonNullExpression", (t, r) => r === "expression" && t.type === "ChainExpression", (t, r) => r === "object" && t.type === "MemberExpression" || r === "callee" && t.type === "CallExpression"));
+}
+function Cs(e) {
+  return e.type === "Identifier" ? true : R(e) ? !e.computed && !e.optional && e.property.type === "Identifier" && Cs(e.object) : false;
+}
+function wc(e) {
+  return e.type === "ChainExpression" && (e = e.expression), Cs(e) || M(e) && !e.optional && Cs(e.callee);
+}
+var he = ds;
+function Mc(e, t) {
+  let r = t - 1;
+  r = Qe(e, r, { backwards: true }), r = ze(e, r, { backwards: true }), r = Qe(e, r, { backwards: true });
+  let n = ze(e, r, { backwards: true });
+  return r !== n;
+}
+var ku = Mc;
+var _c = () => true;
+function As(e, t) {
+  let r = e.node;
+  return r.printed = true, t.printer.printComment(e, t);
+}
+function Nc(e, t) {
+  let r = e.node, n = [As(e, t)], { printer: s, originalText: i, locStart: u, locEnd: o } = t;
+  if (s.isBlockComment?.(r)) {
+    let D = Q(i, o(r)) ? Q(i, u(r), { backwards: true }) ? y : A : " ";
+    n.push(D);
+  } else n.push(y);
+  let p = ze(i, Qe(i, o(r)));
+  return p !== false && Q(i, p) && n.push(y), n;
+}
+function vc(e, t, r) {
+  let n = e.node, s = As(e, t), { printer: i, originalText: u, locStart: o } = t, a = i.isBlockComment?.(n);
+  if (r?.hasLineSuffix && !r?.isBlock || Q(u, o(n), { backwards: true })) {
+    let p = ku(u, o(n));
+    return { doc: Kn([y, p ? y : "", s]), isBlock: a, hasLineSuffix: true };
+  }
+  return !a || r?.hasLineSuffix ? { doc: [Kn([" ", s]), Te], isBlock: a, hasLineSuffix: true } : { doc: [" ", s], isBlock: a, hasLineSuffix: false };
+}
+function v(e, t, r = {}) {
+  let { node: n } = e;
+  if (!j(n?.comments)) return "";
+  let { indent: s = false, marker: i, filter: u = _c } = r, o = [];
+  if (e.each(({ node: p }) => {
+    p.leading || p.trailing || p.marker !== i || !u(p) || o.push(As(e, t));
+  }, "comments"), o.length === 0) return "";
+  let a = I(y, o);
+  return s ? m([y, a]) : a;
+}
+function Mt(e, t) {
+  let r = e.node;
+  if (!r) return {};
+  let n = t[Symbol.for("printedComments")];
+  if ((r.comments || []).filter((a) => !n.has(a)).length === 0) return { leading: "", trailing: "" };
+  let i = [], u = [], o;
+  return e.each(() => {
+    let a = e.node;
+    if (n?.has(a)) return;
+    let { leading: p, trailing: D } = a;
+    p ? i.push(Nc(e, t)) : D && (o = vc(e, t, o), u.push(o.doc));
+  }, "comments"), { leading: i, trailing: u };
+}
+function me(e, t, r) {
+  let { leading: n, trailing: s } = Mt(e, r);
+  return !n && !s ? t : Fr(t, (i) => [n, i, s]);
+}
+var Ts = class extends Error {
+  name = "UnexpectedNodeError";
+  constructor(t, r, n = "type") {
+    super(`Unexpected ${r} node ${n}: ${JSON.stringify(t[n])}.`), this.node = t;
+  }
+}, $e = Ts;
+function xs(e) {
+  if (typeof e != "string") throw new TypeError("Expected a string");
+  return e.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
+}
+var gs = class {
+  #e;
+  constructor(t) {
+    this.#e = new Set(t);
+  }
+  getLeadingWhitespaceCount(t) {
+    let r = this.#e, n = 0;
+    for (let s = 0; s < t.length && r.has(t.charAt(s)); s++) n++;
+    return n;
+  }
+  getTrailingWhitespaceCount(t) {
+    let r = this.#e, n = 0;
+    for (let s = t.length - 1; s >= 0 && r.has(t.charAt(s)); s--) n++;
+    return n;
+  }
+  getLeadingWhitespace(t) {
+    let r = this.getLeadingWhitespaceCount(t);
+    return t.slice(0, r);
+  }
+  getTrailingWhitespace(t) {
+    let r = this.getTrailingWhitespaceCount(t);
+    return t.slice(t.length - r);
+  }
+  hasLeadingWhitespace(t) {
+    return this.#e.has(t.charAt(0));
+  }
+  hasTrailingWhitespace(t) {
+    return this.#e.has(_(0, t, -1));
+  }
+  trimStart(t) {
+    let r = this.getLeadingWhitespaceCount(t);
+    return t.slice(r);
+  }
+  trimEnd(t) {
+    let r = this.getTrailingWhitespaceCount(t);
+    return t.slice(0, t.length - r);
+  }
+  trim(t) {
+    return this.trimEnd(this.trimStart(t));
+  }
+  split(t, r = false) {
+    let n = `[${xs([...this.#e].join(""))}]+`, s = new RegExp(r ? `(${n})` : n, "u");
+    return t.split(s);
+  }
+  hasWhitespaceCharacter(t) {
+    let r = this.#e;
+    return Array.prototype.some.call(t, (n) => r.has(n));
+  }
+  hasNonWhitespaceCharacter(t) {
+    let r = this.#e;
+    return Array.prototype.some.call(t, (n) => !r.has(n));
+  }
+  isWhitespaceOnly(t) {
+    let r = this.#e;
+    return Array.prototype.every.call(t, (n) => r.has(n));
+  }
+  #t(t) {
+    let r = Number.POSITIVE_INFINITY;
+    for (let n of t.split(`
+`)) {
+      if (n.length === 0) continue;
+      let s = this.getLeadingWhitespaceCount(n);
+      if (s === 0) return 0;
+      n.length !== s && s < r && (r = s);
+    }
+    return r === Number.POSITIVE_INFINITY ? 0 : r;
+  }
+  dedentString(t) {
+    let r = this.#t(t);
+    return r === 0 ? t : t.split(`
+`).map((n) => n.slice(r)).join(`
+`);
+  }
+}, Iu = gs;
+var Zr = new Iu(` 
+\r	`), hs = (e) => e === "" || e === A || e === y || e === f;
+function jc(e, t, r) {
+  let { node: n } = e;
+  if (n.type === "JSXElement" && Zc(n)) return [r("openingElement"), r("closingElement")];
+  let s = n.type === "JSXElement" ? r("openingElement") : r("openingFragment"), i = n.type === "JSXElement" ? r("closingElement") : r("closingFragment");
+  if (n.children.length === 1 && n.children[0].type === "JSXExpressionContainer" && (n.children[0].expression.type === "TemplateLiteral" || n.children[0].expression.type === "TaggedTemplateExpression")) return [s, ...e.map(r, "children"), i];
+  n.children = n.children.map((x) => el(x) ? { type: "JSXText", value: " ", raw: " " } : x);
+  let u = n.children.some(q), o = n.children.filter((x) => x.type === "JSXExpressionContainer").length > 1, a = n.type === "JSXElement" && n.openingElement.attributes.length > 1, p = se(s) || u || a || o, D = e.parent.rootMarker === "mdx", l = t.singleQuote ? "{' '}" : '{" "}', E = D ? A : B([l, f], " "), d = n.openingElement?.name?.name === "fbt", F = Rc(e, t, r, E, d), P = n.children.some((x) => Ar(x));
+  for (let x = F.length - 2; x >= 0; x--) {
+    let h = F[x] === "" && F[x + 1] === "", N = F[x] === y && F[x + 1] === "" && F[x + 2] === y, Y = (F[x] === f || F[x] === y) && F[x + 1] === "" && F[x + 2] === E, De = F[x] === E && F[x + 1] === "" && (F[x + 2] === f || F[x + 2] === y), Fe = F[x] === E && F[x + 1] === "" && F[x + 2] === E, J = F[x] === f && F[x + 1] === "" && F[x + 2] === y || F[x] === y && F[x + 1] === "" && F[x + 2] === f;
+    N && P || h || Y || Fe || J ? F.splice(x, 2) : De && F.splice(x + 1, 2);
+  }
+  for (; F.length > 0 && hs(_(0, F, -1)); ) F.pop();
+  for (; F.length > 1 && hs(F[0]) && hs(F[1]); ) F.shift(), F.shift();
+  let S = [""];
+  for (let [x, h] of F.entries()) {
+    if (h === E) {
+      if (x === 1 && ki(F[x - 1])) {
+        if (F.length === 2) {
+          S.push([S.pop(), l]);
+          continue;
+        }
+        S.push([l, y], "");
+        continue;
+      } else if (x === F.length - 1) {
+        S.push([S.pop(), l]);
+        continue;
+      } else if (F[x - 1] === "" && F[x - 2] === y) {
+        S.push([S.pop(), l]);
+        continue;
+      }
+    }
+    x % 2 === 0 ? S.push([S.pop(), h]) : S.push(h, ""), se(h) && (p = true);
+  }
+  let O = P ? Hr(S) : c(S, { shouldBreak: true });
+  if (t.cursorNode?.type === "JSXText" && n.children.includes(t.cursorNode) ? O = [dr, O, dr] : t.nodeBeforeCursor?.type === "JSXText" && n.children.includes(t.nodeBeforeCursor) ? O = [dr, O] : t.nodeAfterCursor?.type === "JSXText" && n.children.includes(t.nodeAfterCursor) && (O = [O, dr]), D) return O;
+  let g = c([s, m([y, O]), y, i]);
+  return p ? g : rt([c([s, ...F, i]), g]);
+}
+function Rc(e, t, r, n, s) {
+  let i = "", u = [i];
+  function o(p) {
+    i = p, u.push([u.pop(), p]);
+  }
+  function a(p) {
+    p !== "" && (i = p, u.push(p, ""));
+  }
+  return e.each(({ node: p, next: D }) => {
+    if (p.type === "JSXText") {
+      let l = pe(p);
+      if (Ar(p)) {
+        let E = Zr.split(l, true);
+        E[0] === "" && (E.shift(), /\n/u.test(E[0]) ? a(Ou(s, E[1], p, D)) : a(n), E.shift());
+        let d;
+        if (_(0, E, -1) === "" && (E.pop(), d = E.pop()), E.length === 0) return;
+        for (let [F, P] of E.entries()) F % 2 === 1 ? a(A) : o(P);
+        d !== void 0 ? /\n/u.test(d) ? a(Ou(s, i, p, D)) : a(n) : a(Lu(s, i, p, D));
+      } else /\n/u.test(l) ? l.match(/\n/gu).length > 1 && a(y) : a(n);
+    } else {
+      let l = r();
+      if (o(l), D && Ar(D)) {
+        let d = Zr.trim(pe(D)), [F] = Zr.split(d);
+        a(Lu(s, F, p, D));
+      } else a(y);
+    }
+  }, "children"), u;
+}
+function Lu(e, t, r, n) {
+  return e ? "" : r.type === "JSXElement" && !r.closingElement || n?.type === "JSXElement" && !n.closingElement ? t.length === 1 ? f : y : f;
+}
+function Ou(e, t, r, n) {
+  return e ? y : t.length === 1 ? r.type === "JSXElement" && !r.closingElement || n?.type === "JSXElement" && !n.closingElement ? y : f : y;
+}
+var Jc = b(["ArrayExpression", "JSXAttribute", "JSXElement", "JSXExpressionContainer", "JSXFragment", "ExpressionStatement", "NewExpression", "CallExpression", "OptionalCallExpression", "ConditionalExpression", "JsExpressionRoot", "MatchExpressionCase"]);
+function Gc(e, t, r) {
+  let { parent: n } = e;
+  if (Jc(n)) return t;
+  let s = Wc(e), i = he(e, r);
+  return c([i ? "" : B("("), m([f, t]), f, i ? "" : B(")")], { shouldBreak: s });
+}
+function Wc(e) {
+  return e.match(void 0, (t, r) => r === "body" && t.type === "ArrowFunctionExpression", (t, r) => r === "arguments" && M(t)) && (e.match(void 0, void 0, void 0, (t, r) => r === "expression" && t.type === "JSXExpressionContainer") || e.match(void 0, void 0, void 0, (t, r) => r === "expression" && t.type === "ChainExpression", (t, r) => r === "expression" && t.type === "JSXExpressionContainer"));
+}
+function qc(e, t, r) {
+  let { node: n } = e, s = [r("name")];
+  if (n.value) {
+    let i;
+    if (X(n.value)) {
+      let u = pe(n.value), o = G(0, G(0, u.slice(1, -1), "&apos;", "'"), "&quot;", '"'), a = kr(o, t.jsxSingleQuote);
+      o = a === '"' ? G(0, o, '"', "&quot;") : G(0, o, "'", "&apos;"), i = e.call(() => me(e, Ge(a + o + a), t), "value");
+    } else i = r("value");
+    s.push("=", i);
+  }
+  return s;
+}
+function Yc(e, t, r) {
+  let { node: n } = e, s = (i, u) => i.type === "JSXEmptyExpression" || !C(i) && (W(i) || ie(i) || i.type === "ArrowFunctionExpression" || i.type === "AwaitExpression" && (s(i.argument, i) || i.argument.type === "JSXElement") || M(i) || i.type === "ChainExpression" && M(i.expression) || i.type === "FunctionExpression" || i.type === "TemplateLiteral" || i.type === "TaggedTemplateExpression" || i.type === "DoExpression" || q(u) && (i.type === "ConditionalExpression" || xe(i)));
+  return s(n.expression, e.parent) ? c(["{", r("expression"), we, "}"]) : c(["{", m([f, r("expression")]), f, we, "}"]);
+}
+function Uc(e, t, r) {
+  let { node: n } = e, s = C(n.name) || C(n.typeArguments);
+  if (n.selfClosing && n.attributes.length === 0 && !s) return ["<", r("name"), r("typeArguments"), " />"];
+  if (n.attributes?.length === 1 && X(n.attributes[0].value) && !n.attributes[0].value.value.includes(`
+`) && !s && !C(n.attributes[0])) return c(["<", r("name"), r("typeArguments"), " ", ...e.map(r, "attributes"), n.selfClosing ? " />" : ">"]);
+  let i = n.attributes?.some((o) => X(o.value) && o.value.value.includes(`
+`)), u = t.singleAttributePerLine && n.attributes.length > 1 ? y : A;
+  return c(["<", r("name"), r("typeArguments"), m(e.map(() => [u, r()], "attributes")), ...Hc(n, t, s)], { shouldBreak: i });
+}
+function Hc(e, t, r) {
+  return e.selfClosing ? [A, "/>"] : Xc(e, t, r) ? [">"] : [f, ">"];
+}
+function Xc(e, t, r) {
+  let n = e.attributes.length > 0 && C(_(0, e.attributes, -1), T.Trailing);
+  return e.attributes.length === 0 && !r || (t.bracketSameLine || t.jsxBracketSameLine) && (!r || e.attributes.length > 0) && !n;
+}
+function Vc(e, t, r) {
+  let { node: n } = e, s = ["</"], i = r("name");
+  return C(n.name, T.Leading | T.Line) ? s.push(m([y, i]), y) : C(n.name, T.Leading | T.Block) ? s.push(" ", i) : s.push(i), s.push(">"), s;
+}
+function $c(e, t) {
+  let { node: r } = e, n = C(r), s = C(r, T.Line), i = r.type === "JSXOpeningFragment";
+  return [i ? "<" : "</", m([s ? y : n && !i ? " " : "", v(e, t)]), s ? y : "", ">"];
+}
+function Kc(e, t, r) {
+  let n = me(e, jc(e, t, r), t);
+  return Gc(e, n, t);
+}
+function Qc(e, t) {
+  let { node: r } = e, n = C(r, T.Line);
+  return [v(e, t, { indent: n }), n ? y : ""];
+}
+function zc(e, t, r) {
+  let { node: n } = e;
+  return ["{", e.call(({ node: s }) => {
+    let i = ["...", r()];
+    return C(s) ? [m([f, me(e, i, t)]), f] : i;
+  }, n.type === "JSXSpreadAttribute" ? "argument" : "expression"), "}"];
+}
+function wu(e, t, r) {
+  let { node: n } = e;
+  if (n.type.startsWith("JSX")) switch (n.type) {
+    case "JSXAttribute":
+      return qc(e, t, r);
+    case "JSXIdentifier":
+      return n.name;
+    case "JSXNamespacedName":
+      return I(":", [r("namespace"), r("name")]);
+    case "JSXMemberExpression":
+      return I(".", [r("object"), r("property")]);
+    case "JSXSpreadAttribute":
+    case "JSXSpreadChild":
+      return zc(e, t, r);
+    case "JSXExpressionContainer":
+      return Yc(e, t, r);
+    case "JSXFragment":
+    case "JSXElement":
+      return Kc(e, t, r);
+    case "JSXOpeningElement":
+      return Uc(e, t, r);
+    case "JSXClosingElement":
+      return Vc(e, t, r);
+    case "JSXOpeningFragment":
+    case "JSXClosingFragment":
+      return $c(e, t);
+    case "JSXEmptyExpression":
+      return Qc(e, t);
+    case "JSXText":
+      throw new Error("JSXText should be handled by JSXElement");
+    default:
+      throw new $e(n, "JSX");
+  }
+}
+function Zc(e) {
+  if (e.children.length === 0) return true;
+  if (e.children.length > 1) return false;
+  let t = e.children[0];
+  return t.type === "JSXText" && !Ar(t);
+}
+function Ar(e) {
+  return e.type === "JSXText" && (Zr.hasNonWhitespaceCharacter(pe(e)) || !/\n/u.test(pe(e)));
+}
+function el(e) {
+  return e.type === "JSXExpressionContainer" && X(e.expression) && e.expression.value === " " && !C(e.expression);
+}
+function Mu(e) {
+  let { node: t, parent: r } = e;
+  if (!q(t) || !q(r)) return false;
+  let { index: n, siblings: s } = e, i;
+  for (let u = n; u > 0; u--) {
+    let o = s[u - 1];
+    if (!(o.type === "JSXText" && !Ar(o))) {
+      i = o;
+      break;
+    }
+  }
+  return i?.type === "JSXExpressionContainer" && i.expression.type === "JSXEmptyExpression" && It(i.expression);
+}
+function tl(e) {
+  return It(e.node) || Mu(e);
+}
+var Qt = tl;
+var rl = 0;
+function en(e, t, r) {
+  let { node: n, parent: s, grandparent: i, key: u } = e, o = u !== "body" && (s.type === "IfStatement" || s.type === "WhileStatement" || s.type === "SwitchStatement" || s.type === "DoWhileStatement"), a = n.operator === "|>" && e.root.extra?.__isUsingHackPipeline, p = Ss(e, t, r, false, o);
+  if (o) return p;
+  if (a) return c(p);
+  if (u === "callee" && (M(s) || s.type === "NewExpression") || s.type === "UnaryExpression" || R(s) && !s.computed) return c([m([f, ...p]), f]);
+  let D = s.type === "ReturnStatement" || s.type === "ThrowStatement" || s.type === "JSXExpressionContainer" && i.type === "JSXAttribute" || n.operator !== "|" && s.type === "JsExpressionRoot" || n.type !== "NGPipeExpression" && (s.type === "NGRoot" && t.parser === "__ng_binding" || s.type === "NGMicrosyntaxExpression" && i.type === "NGMicrosyntax" && i.body.length === 1) || n === s.body && s.type === "ArrowFunctionExpression" || n !== s.body && s.type === "ForStatement" || s.type === "ConditionalExpression" && i.type !== "ReturnStatement" && i.type !== "ThrowStatement" && !M(i) && i.type !== "NewExpression" || s.type === "TemplateLiteral" || sl(e), l = s.type === "AssignmentExpression" || s.type === "VariableDeclarator" || s.type === "ClassProperty" || s.type === "PropertyDefinition" || s.type === "TSAbstractPropertyDefinition" || s.type === "ClassPrivateProperty" || ke(s), E = xe(n.left) && yr(n.operator, n.left.operator);
+  if (D || zt(n) && !E || !zt(n) && l) return c(p);
+  if (p.length === 0) return "";
+  let d = q(n.right), F = p.findIndex((h) => typeof h != "string" && !Array.isArray(h) && h.type === ye), P = p.slice(0, F === -1 ? 1 : F + 1), S = p.slice(P.length, d ? -1 : void 0), O = Symbol("logicalChain-" + ++rl), g = c([...P, m(S)], { id: O });
+  if (!d) return g;
+  let x = _(0, p, -1);
+  return c([g, ft(x, { groupId: O })]);
+}
+function Ss(e, t, r, n, s) {
+  let { node: i } = e;
+  if (!xe(i)) return [c(r())];
+  let u = [];
+  yr(i.operator, i.left.operator) ? u = e.call(() => Ss(e, t, r, true, s), "left") : u.push(c(r("left")));
+  let o = zt(i), a = i.right.type === "ChainExpression" ? i.right.expression : i.right, p = (i.operator === "|>" || i.type === "NGPipeExpression" || nl(e, t)) && !Ce(t.originalText, a), l = !C(a, T.Leading, Vr) && Ce(t.originalText, a), E = i.type === "NGPipeExpression" ? "|" : i.operator, d = i.type === "NGPipeExpression" && i.arguments.length > 0 ? c(m([f, ": ", I([A, ": "], e.map(() => ge(2, c(r())), "arguments"))])) : "", F;
+  if (o) F = [E, Ce(t.originalText, a) ? m([A, r("right"), d]) : [" ", r("right"), d]];
+  else {
+    let x = E === "|>" && e.root.extra?.__isUsingHackPipeline ? e.call(() => Ss(e, t, r, true, s), "right") : r("right");
+    if (t.experimentalOperatorPosition === "start") {
+      let h = "";
+      if (l) switch (Je(x)) {
+        case Se:
+          h = x.splice(0, 1)[0];
+          break;
+        case be:
+          h = x.contents.splice(0, 1)[0];
+          break;
+      }
+      F = [A, h, E, " ", x, d];
+    } else F = [p ? A : "", E, p ? " " : A, x, d];
+  }
+  let { parent: P } = e, S = C(i.left, T.Trailing | T.Line);
+  if ((S || !(s && i.type === "LogicalExpression") && P.type !== i.type && i.left.type !== i.type && i.right.type !== i.type) && (F = c(F, { shouldBreak: S })), t.experimentalOperatorPosition === "start" ? u.push(o || l ? " " : "", F) : u.push(p ? "" : " ", F), n && C(i)) {
+    let g = $t(me(e, u, t));
+    return g.type === Le ? g.parts : Array.isArray(g) ? g : [g];
+  }
+  return u;
+}
+function zt(e) {
+  return e.type !== "LogicalExpression" ? false : !!(ie(e.right) && e.right.properties.length > 0 || W(e.right) && e.right.elements.length > 0 || q(e.right));
+}
+var _u = (e) => e.type === "BinaryExpression" && e.operator === "|";
+function nl(e, t) {
+  return (t.parser === "__vue_expression" || t.parser === "__vue_ts_expression") && _u(e.node) && !e.hasAncestor((r) => !_u(r) && r.type !== "JsExpressionRoot");
+}
+function sl(e) {
+  if (e.key !== "arguments") return false;
+  let { parent: t } = e;
+  if (!(M(t) && !t.optional && t.arguments.length === 1)) return false;
+  let { callee: r } = t;
+  return r.type === "Identifier" && r.name === "Boolean";
+}
+function vu(e, t, r) {
+  let { node: n } = e;
+  if (n.type.startsWith("NG")) switch (n.type) {
+    case "NGRoot":
+      return r("node");
+    case "NGPipeExpression":
+      return en(e, t, r);
+    case "NGChainedExpression":
+      return c(I([";", A], e.map(() => ol(e) ? r() : ["(", r(), ")"], "expressions")));
+    case "NGEmptyExpression":
+      return "";
+    case "NGMicrosyntax":
+      return e.map(() => [e.isFirst ? "" : Nu(e) ? " " : [";", A], r()], "body");
+    case "NGMicrosyntaxKey":
+      return /^[$_a-z][\w$]*(?:-[$_a-z][\w$])*$/iu.test(n.name) ? n.name : JSON.stringify(n.name);
+    case "NGMicrosyntaxExpression":
+      return [r("expression"), n.alias === null ? "" : [" as ", r("alias")]];
+    case "NGMicrosyntaxKeyedExpression": {
+      let { index: s, parent: i } = e, u = Nu(e) || il(e) || (s === 1 && (n.key.name === "then" || n.key.name === "else" || n.key.name === "as") || s === 2 && (n.key.name === "else" && i.body[s - 1].type === "NGMicrosyntaxKeyedExpression" && i.body[s - 1].key.name === "then" || n.key.name === "track")) && i.body[0].type === "NGMicrosyntaxExpression";
+      return [r("key"), u ? " " : ": ", r("expression")];
+    }
+    case "NGMicrosyntaxLet":
+      return ["let ", r("key"), n.value === null ? "" : [" = ", r("value")]];
+    case "NGMicrosyntaxAs":
+      return [r("key"), " as ", r("alias")];
+    default:
+      throw new $e(n, "Angular");
+  }
+}
+function Nu({ node: e, index: t }) {
+  return e.type === "NGMicrosyntaxKeyedExpression" && e.key.name === "of" && t === 1;
+}
+function il(e) {
+  let { node: t } = e;
+  return e.parent.body[1].key.name === "of" && t.type === "NGMicrosyntaxKeyedExpression" && t.key.name === "track" && t.key.type === "NGMicrosyntaxKey";
+}
+var ul = b(["CallExpression", "OptionalCallExpression", "AssignmentExpression"]);
+function ol({ node: e }) {
+  return Dr(e, ul);
+}
+function Bs(e, t, r) {
+  let { node: n } = e;
+  return c([I(A, e.map(r, "decorators")), Ju(n, t) ? y : A]);
+}
+function ju(e, t, r) {
+  return Gu(e.node) ? [I(y, e.map(r, "declaration", "decorators")), y] : "";
+}
+function Ru(e, t, r) {
+  let { node: n, parent: s } = e, { decorators: i } = n;
+  if (!j(i) || Gu(s) || Qt(e)) return "";
+  let u = n.type === "ClassExpression" || n.type === "ClassDeclaration" || Ju(n, t);
+  return [e.key === "declaration" && ci(s) ? y : u ? Te : "", I(A, e.map(r, "decorators")), A];
+}
+function Ju(e, t) {
+  return e.decorators.some((r) => Q(t.originalText, k(r)));
+}
+function Gu(e) {
+  if (e.type !== "ExportDefaultDeclaration" && e.type !== "ExportNamedDeclaration" && e.type !== "DeclareExportDeclaration") return false;
+  let t = e.declaration?.decorators;
+  return j(t) && St(e, t[0]);
+}
+var yt = class extends Error {
+  name = "ArgExpansionBailout";
+};
+function al(e, t, r) {
+  let { node: n } = e, s = ce(n);
+  if (s.length === 0) return ["(", v(e, t), ")"];
+  let i = s.length - 1;
+  if (ll(s)) {
+    let l = ["("];
+    return Xt(e, (E, d) => {
+      l.push(r()), d !== i && l.push(", ");
+    }), l.push(")"), l;
+  }
+  let u = false, o = [];
+  Xt(e, ({ node: l }, E) => {
+    let d = r();
+    E === i || (oe(l, t) ? (u = true, d = [d, ",", y, y]) : d = [d, ",", A]), o.push(d);
+  });
+  let a = !t.parser.startsWith("__ng_") && n.type !== "ImportExpression" && n.type !== "TSImportType" && n.type !== "TSExternalModuleReference" && ue(t, "all") ? "," : "";
+  function p() {
+    return c(["(", m([A, ...o]), a, A, ")"], { shouldBreak: true });
+  }
+  if (u || e.parent.type !== "Decorator" && Ei(s)) return p();
+  if (cl(s)) {
+    let l = o.slice(1);
+    if (l.some(se)) return p();
+    let E;
+    try {
+      E = r(Xn(n, 0), { expandFirstArg: true });
+    } catch (d) {
+      if (d instanceof yt) return p();
+      throw d;
+    }
+    return se(E) ? [Te, rt([["(", c(E, { shouldBreak: true }), ", ", ...l, ")"], p()])] : rt([["(", E, ", ", ...l, ")"], ["(", c(E, { shouldBreak: true }), ", ", ...l, ")"], p()]);
+  }
+  if (pl(s, o, t)) {
+    let l = o.slice(0, -1);
+    if (l.some(se)) return p();
+    let E;
+    try {
+      E = r(Xn(n, -1), { expandLastArg: true });
+    } catch (d) {
+      if (d instanceof yt) return p();
+      throw d;
+    }
+    return se(E) ? [Te, rt([["(", ...l, c(E, { shouldBreak: true }), ")"], p()])] : rt([["(", ...l, E, ")"], ["(", ...l, c(E, { shouldBreak: true }), ")"], p()]);
+  }
+  let D = ["(", m([f, ...o]), B(a), f, ")"];
+  return Jr(e) ? D : c(D, { shouldBreak: o.some(se) || u });
+}
+function Tr(e, t = false) {
+  return ie(e) && (e.properties.length > 0 || C(e)) || W(e) && (e.elements.length > 0 || C(e)) || e.type === "TSTypeAssertion" && Tr(e.expression) || Ae(e) && Tr(e.expression) || e.type === "FunctionExpression" || e.type === "ArrowFunctionExpression" && (!e.returnType || !e.returnType.typeAnnotation || e.returnType.typeAnnotation.type !== "TSTypeReference" || ml(e.body)) && (e.body.type === "BlockStatement" || e.body.type === "ArrowFunctionExpression" && Tr(e.body, true) || ie(e.body) || W(e.body) || !t && (M(e.body) || e.body.type === "ConditionalExpression") || q(e.body)) || e.type === "DoExpression" || e.type === "ModuleExpression";
+}
+function pl(e, t, r) {
+  let n = _(0, e, -1);
+  if (e.length === 1) {
+    let i = _(0, t, -1);
+    if (i.label?.embed && i.label?.hug !== false) return true;
+  }
+  let s = _(0, e, -2);
+  return !C(n, T.Leading) && !C(n, T.Trailing) && Tr(n) && (!s || s.type !== n.type) && (e.length !== 2 || s.type !== "ArrowFunctionExpression" || !W(n)) && !(e.length > 1 && bs(n, r));
+}
+function cl(e) {
+  if (e.length !== 2) return false;
+  let [t, r] = e;
+  return t.type === "ModuleExpression" && Dl(r) ? true : !C(t) && (t.type === "FunctionExpression" || t.type === "ArrowFunctionExpression" && t.body.type === "BlockStatement") && r.type !== "FunctionExpression" && r.type !== "ArrowFunctionExpression" && r.type !== "ConditionalExpression" && qu(r) && !Tr(r);
+}
+function qu(e) {
+  if (e.type === "ParenthesizedExpression") return qu(e.expression);
+  if (Ae(e) || e.type === "TypeCastExpression") {
+    let { typeAnnotation: t } = e;
+    if (t.type === "TypeAnnotation" && (t = t.typeAnnotation), t.type === "TSArrayType" && (t = t.elementType, t.type === "TSArrayType" && (t = t.elementType)), t.type === "GenericTypeAnnotation" || t.type === "TSTypeReference") {
+      let r = t.type === "GenericTypeAnnotation" ? t.typeParameters : t.typeArguments;
+      r?.params.length === 1 && (t = r.params[0]);
+    }
+    return Ht(t) && je(e.expression, 1);
+  }
+  return mt(e) && ce(e).length > 1 ? false : xe(e) ? je(e.left, 1) && je(e.right, 1) : Un(e) || je(e);
+}
+function ll(e) {
+  return e.length === 2 ? Wu(e, 0) : e.length === 3 ? e[0].type === "Identifier" && Wu(e, 1) : false;
+}
+function Wu(e, t) {
+  let r = e[t], n = e[t + 1];
+  return r.type === "ArrowFunctionExpression" && K(r).length === 0 && r.body.type === "BlockStatement" && n.type === "ArrayExpression" && !e.some((s) => C(s));
+}
+function ml(e) {
+  return e.type === "BlockStatement" && (e.body.some((t) => t.type !== "EmptyStatement") || C(e, T.Dangling));
+}
+function Dl(e) {
+  if (!(e.type === "ObjectExpression" && e.properties.length === 1)) return false;
+  let [t] = e.properties;
+  return ke(t) ? !t.computed && (t.key.type === "Identifier" && t.key.name === "type" || X(t.key) && t.key.value === "type") && X(t.value) && t.value.value === "module" : false;
+}
+var xr = al;
+var fl = (e) => ((e.type === "ChainExpression" || e.type === "TSNonNullExpression") && (e = e.expression), M(e) && ce(e).length > 0);
+function yl(e) {
+  let { node: t, ancestors: r } = e;
+  for (let n of r) {
+    if (!(R(n) && n.object === t || n.type === "TSNonNullExpression" && n.expression === t)) return n.type === "NewExpression" && n.callee === t;
+    t = n;
+  }
+  return false;
+}
+function Yu(e, t, r) {
+  let n = r("object"), s = Ps(e, t, r), { node: i } = e, u = e.findAncestor((p) => !(R(p) || p.type === "TSNonNullExpression")), o = e.findAncestor((p) => !(p.type === "ChainExpression" || p.type === "TSNonNullExpression")), a = u.type === "BindExpression" || u.type === "AssignmentExpression" && u.left.type !== "Identifier" || yl(e) || i.computed || i.object.type === "Identifier" && i.property.type === "Identifier" && !R(o) || (o.type === "AssignmentExpression" || o.type === "VariableDeclarator") && (fl(i.object) || n.label?.memberChain);
+  return ot(n.label, [n, a ? s : c(m([f, s]))]);
+}
+function Ps(e, t, r) {
+  let n = r("property"), { node: s } = e, i = $(e);
+  return s.computed ? !s.property || de(s.property) ? [i, "[", n, "]"] : c([i, "[", m([f, n]), f, "]"]) : [i, ".", n];
+}
+function Uu(e, t, r) {
+  if (e.node.type === "ChainExpression") return e.call(() => Uu(e, t, r), "expression");
+  let n = (e.parent.type === "ChainExpression" ? e.grandparent : e.parent).type === "ExpressionStatement", s = [];
+  function i(w) {
+    let { originalText: ne } = t, ae = pt(ne, k(w));
+    return ne.charAt(ae) === ")" ? ae !== false && qt(ne, ae + 1) : oe(w, t);
+  }
+  function u() {
+    let { node: w } = e;
+    if (w.type === "ChainExpression") return e.call(u, "expression");
+    if (M(w) && (At(w.callee) || M(w.callee))) {
+      let ne = i(w);
+      s.unshift({ node: w, hasTrailingEmptyLine: ne, printed: [me(e, [$(e), r("typeArguments"), xr(e, t, r)], t), ne ? y : ""] }), e.call(u, "callee");
+    } else At(w) ? (s.unshift({ node: w, needsParens: he(e, t), printed: me(e, R(w) ? Ps(e, t, r) : tn(e, t, r), t) }), e.call(u, "object")) : w.type === "TSNonNullExpression" ? (s.unshift({ node: w, printed: me(e, "!", t) }), e.call(u, "expression")) : s.unshift({ node: w, printed: r() });
+  }
+  let { node: o } = e;
+  s.unshift({ node: o, printed: [$(e), r("typeArguments"), xr(e, t, r)] }), o.callee && e.call(u, "callee");
+  let a = [], p = [s[0]], D = 1;
+  for (; D < s.length && (s[D].node.type === "TSNonNullExpression" || M(s[D].node) || R(s[D].node) && s[D].node.computed && de(s[D].node.property)); ++D) p.push(s[D]);
+  if (!M(s[0].node)) for (; D + 1 < s.length && (At(s[D].node) && At(s[D + 1].node)); ++D) p.push(s[D]);
+  a.push(p), p = [];
+  let l = false;
+  for (; D < s.length; ++D) {
+    if (l && At(s[D].node)) {
+      if (s[D].node.computed && de(s[D].node.property)) {
+        p.push(s[D]);
+        continue;
+      }
+      a.push(p), p = [], l = false;
+    }
+    (M(s[D].node) || s[D].node.type === "ImportExpression") && (l = true), p.push(s[D]), C(s[D].node, T.Trailing) && (a.push(p), p = [], l = false);
+  }
+  p.length > 0 && a.push(p);
+  function E(w) {
+    return /^[A-Z]|^[$_]+$/u.test(w);
+  }
+  function d(w) {
+    return w.length <= t.tabWidth;
+  }
+  function F(w) {
+    let ne = w[1][0]?.node.computed;
+    if (w[0].length === 1) {
+      let st = w[0][0].node;
+      return st.type === "ThisExpression" || st.type === "Identifier" && (E(st.name) || n && d(st.name) || ne);
+    }
+    let ae = _(0, w[0], -1).node;
+    return R(ae) && ae.property.type === "Identifier" && (E(ae.property.name) || ne);
+  }
+  let P = a.length >= 2 && !C(a[1][0].node) && F(a);
+  function S(w) {
+    let ne = w.map((ae) => ae.printed);
+    return w.length > 0 && _(0, w, -1).needsParens ? ["(", ...ne, ")"] : ne;
+  }
+  function O(w) {
+    return w.length === 0 ? "" : m([y, I(y, w.map(S))]);
+  }
+  let g = a.map(S), x = g, h = P ? 3 : 2, N = a.flat(), Y = N.slice(1, -1).some((w) => C(w.node, T.Leading)) || N.slice(0, -1).some((w) => C(w.node, T.Trailing)) || a[h] && C(a[h][0].node, T.Leading);
+  if (a.length <= h && !Y && !a.some((w) => _(0, w, -1).hasTrailingEmptyLine)) return Jr(e) ? x : c(x);
+  let De = _(0, a[P ? 1 : 0], -1).node, Fe = !M(De) && i(De), J = [S(a[0]), P ? a.slice(1, 2).map(S) : "", Fe ? y : "", O(a.slice(P ? 2 : 1))], Z = s.map(({ node: w }) => w).filter(M);
+  function H() {
+    let w = _(0, _(0, a, -1), -1).node, ne = _(0, g, -1);
+    return M(w) && se(ne) && Z.slice(0, -1).some((ae) => ae.arguments.some(Yt));
+  }
+  let nt;
+  return Y || Z.length > 2 && Z.some((w) => !w.arguments.every((ne) => je(ne))) || g.slice(0, -1).some(se) || H() ? nt = c(J) : nt = [se(x) || Fe ? Te : "", rt([x, J])], ot({ memberChain: true }, nt);
+}
+var Hu = Uu;
+function _t(e, t, r) {
+  let { node: n } = e, s = n.type === "NewExpression", i = $(e), u = ce(n), o = n.type !== "TSImportType" && n.typeArguments ? r("typeArguments") : "", a = u.length === 1 && jr(u[0], t.originalText);
+  if (a || Fl(e) || dl(e) || Pt(n, e.parent)) {
+    let l = [];
+    if (Xt(e, () => {
+      l.push(r());
+    }), !(a && l[0].label?.embed)) return [s ? "new " : "", Xu(e, r), i, o, "(", I(", ", l), ")"];
+  }
+  let p = n.type === "ImportExpression" || n.type === "TSImportType" || n.type === "TSExternalModuleReference";
+  if (!p && !s && At(n.callee) && !e.call(() => he(e, t), "callee", ...n.callee.type === "ChainExpression" ? ["expression"] : [])) return Hu(e, t, r);
+  let D = [s ? "new " : "", Xu(e, r), i, o, xr(e, t, r)];
+  return p || M(n.callee) ? c(D) : D;
+}
+function Xu(e, t) {
+  let { node: r } = e;
+  return r.type === "ImportExpression" ? `import${r.phase ? `.${r.phase}` : ""}` : r.type === "TSImportType" ? "import" : r.type === "TSExternalModuleReference" ? "require" : t("callee");
+}
+var El = ["require", "require.resolve", "require.resolve.paths", "import.meta.resolve"];
+function Fl(e) {
+  let { node: t } = e;
+  if (!(t.type === "ImportExpression" || t.type === "TSImportType" || t.type === "TSExternalModuleReference" || t.type === "CallExpression" && !t.optional && Bt(t.callee, El))) return false;
+  let r = ce(t);
+  return r.length === 1 && X(r[0]) && !C(r[0]);
+}
+function dl(e) {
+  let { node: t } = e;
+  if (t.type !== "CallExpression" || t.optional || t.callee.type !== "Identifier") return false;
+  let r = ce(t);
+  return t.callee.name === "require" ? (r.length === 1 && X(r[0]) || r.length > 1) && !C(r[0]) : t.callee.name === "define" && e.parent.type === "ExpressionStatement" ? r.length === 1 || r.length === 2 && r[0].type === "ArrayExpression" || r.length === 3 && X(r[0]) && r[1].type === "ArrayExpression" : false;
+}
+function xt(e, t, r, n, s, i) {
+  let u = Cl(e, t, r, n, i), o = i ? r(i, { assignmentLayout: u }) : "";
+  switch (u) {
+    case "break-after-operator":
+      return c([c(n), s, c(m([A, o]))]);
+    case "never-break-after-operator":
+      return c([c(n), s, " ", o]);
+    case "fluid": {
+      let a = Symbol("assignment");
+      return c([c(n), s, c(m(A), { id: a }), we, ft(o, { groupId: a })]);
+    }
+    case "break-lhs":
+      return c([n, s, " ", c(o)]);
+    case "chain":
+      return [c(n), s, A, o];
+    case "chain-tail":
+      return [c(n), s, m([A, o])];
+    case "chain-tail-arrow-chain":
+      return [c(n), s, o];
+    case "only-left":
+      return n;
+  }
+}
+function Ku(e, t, r) {
+  let { node: n } = e;
+  return xt(e, t, r, r("left"), [" ", n.operator], "right");
+}
+function Qu(e, t, r) {
+  return xt(e, t, r, r("id"), " =", "init");
+}
+function Cl(e, t, r, n, s) {
+  let { node: i } = e, u = i[s];
+  if (!u) return "only-left";
+  let o = !rn(u);
+  if (e.match(rn, zu, (E) => !o || E.type !== "ExpressionStatement" && E.type !== "VariableDeclaration")) return o ? u.type === "ArrowFunctionExpression" && u.body.type === "ArrowFunctionExpression" ? "chain-tail-arrow-chain" : "chain-tail" : "chain";
+  if (!o && rn(u.right) || Ce(t.originalText, u)) return "break-after-operator";
+  if (i.type === "ImportAttribute" || u.type === "CallExpression" && u.callee.name === "require" || t.parser === "json5" || t.parser === "jsonc" || t.parser === "json") return "never-break-after-operator";
+  let D = Pi(n);
+  if (Tl(i) || hl(i) || ks(i) && D) return "break-lhs";
+  let l = Sl(i, n, t);
+  return e.call(() => Al(e, t, r, l), s) ? "break-after-operator" : xl(i) ? "break-lhs" : !D && (l || u.type === "TemplateLiteral" || u.type === "TaggedTemplateExpression" || mi(u) || de(u) || u.type === "ClassExpression") ? "never-break-after-operator" : "fluid";
+}
+function Al(e, t, r, n) {
+  let s = e.node;
+  if (xe(s) && !zt(s)) return true;
+  switch (s.type) {
+    case "StringLiteralTypeAnnotation":
+    case "SequenceExpression":
+      return true;
+    case "TSConditionalType":
+    case "ConditionalTypeAnnotation":
+      if (!t.experimentalTernaries && !Pl(s)) break;
+      return true;
+    case "ConditionalExpression": {
+      if (!t.experimentalTernaries) {
+        let { test: p } = s;
+        return xe(p) && !zt(p);
+      }
+      let { consequent: o, alternate: a } = s;
+      return o.type === "ConditionalExpression" || a.type === "ConditionalExpression";
+    }
+    case "ClassExpression":
+      return j(s.decorators);
+  }
+  if (n) return false;
+  let i = s, u = [];
+  for (; ; ) if (i.type === "UnaryExpression" || i.type === "AwaitExpression" || i.type === "YieldExpression" && i.argument !== null) i = i.argument, u.push("argument");
+  else if (i.type === "TSNonNullExpression") i = i.expression, u.push("expression");
+  else break;
+  return !!(X(i) || e.call(() => Zu(e, t, r), ...u));
+}
+function Tl(e) {
+  if (zu(e)) {
+    let t = e.left || e.id;
+    return t.type === "ObjectPattern" && t.properties.length > 2 && t.properties.some((r) => ke(r) && (!r.shorthand || r.value?.type === "AssignmentPattern"));
+  }
+  return false;
+}
+function rn(e) {
+  return e.type === "AssignmentExpression";
+}
+function zu(e) {
+  return rn(e) || e.type === "VariableDeclarator";
+}
+function xl(e) {
+  let t = gl(e);
+  if (j(t)) {
+    let r = e.type === "TSTypeAliasDeclaration" ? "constraint" : "bound";
+    if (t.length > 1 && t.some((n) => n[r] || n.default)) return true;
+  }
+  return false;
+}
+function gl(e) {
+  if (Er(e)) return e.typeParameters?.params;
+}
+function hl(e) {
+  if (e.type !== "VariableDeclarator") return false;
+  let { typeAnnotation: t } = e.id;
+  if (!t || !t.typeAnnotation) return false;
+  let r = Vu(t.typeAnnotation);
+  return j(r) && r.length > 1 && r.some((n) => j(Vu(n)) || n.type === "TSConditionalType");
+}
+function ks(e) {
+  return e.type === "VariableDeclarator" && e.init?.type === "ArrowFunctionExpression";
+}
+function Vu(e) {
+  let t;
+  switch (e.type) {
+    case "GenericTypeAnnotation":
+      t = e.typeParameters;
+      break;
+    case "TSTypeReference":
+      t = e.typeArguments;
+      break;
+  }
+  return t?.params;
+}
+function Zu(e, t, r, n = false) {
+  let { node: s } = e, i = () => Zu(e, t, r, true);
+  if (s.type === "ChainExpression" || s.type === "TSNonNullExpression") return e.call(i, "expression");
+  if (M(s)) {
+    if (_t(e, t, r).label?.memberChain) return false;
+    let o = ce(s);
+    return !(o.length === 0 || o.length === 1 && fr(o[0], t)) || Bl(s, r) ? false : e.call(i, "callee");
+  }
+  return R(s) ? e.call(i, "object") : n && (s.type === "Identifier" || s.type === "ThisExpression");
+}
+function Sl(e, t, r) {
+  return ke(e) ? (t = $t(t), typeof t == "string" && it(t) < r.tabWidth + 3) : false;
+}
+function Bl(e, t) {
+  let r = bl(e);
+  if (j(r)) {
+    if (r.length > 1) return true;
+    if (r.length === 1) {
+      let s = r[0];
+      if (Ie(s) || Lt(s) || s.type === "TSTypeLiteral" || s.type === "ObjectTypeAnnotation") return true;
+    }
+    let n = e.typeParameters ? "typeParameters" : "typeArguments";
+    if (se(t(n))) return true;
+  }
+  return false;
+}
+function bl(e) {
+  return (e.typeParameters ?? e.typeArguments)?.params;
+}
+function $u(e) {
+  switch (e.type) {
+    case "FunctionTypeAnnotation":
+    case "GenericTypeAnnotation":
+    case "TSFunctionType":
+      return !!e.typeParameters;
+    case "TSTypeReference":
+      return !!e.typeArguments;
+    default:
+      return false;
+  }
+}
+function Pl(e) {
+  return $u(e.checkType) || $u(e.extendsType);
+}
+function kl(e) {
+  let t = /* @__PURE__ */ new WeakMap();
+  return function(r) {
+    return t.has(r) || t.set(r, Symbol(e)), t.get(r);
+  };
+}
+var eo = kl;
+function Ke(e, t, r, n, s) {
+  let i = e.node, u = K(i), o = s && i.typeParameters ? r("typeParameters") : "";
+  if (u.length === 0) return [o, "(", v(e, t, { filter: (F) => Ne(t.originalText, k(F)) === ")" }), ")"];
+  let { parent: a } = e, p = Pt(a), D = to(i), l = [];
+  if (Ci(e, (F, P) => {
+    let S = P === u.length - 1;
+    S && i.rest && l.push("..."), l.push(r()), !S && (l.push(","), p || D ? l.push(" ") : oe(u[P], t) ? l.push(y, y) : l.push(A));
+  }), n && !Ll(e)) {
+    if (se(o) || se(l)) throw new yt();
+    return c([Ot(o), "(", Ot(l), ")"]);
+  }
+  let E = u.every((F) => !j(F.decorators));
+  return D && E ? [o, "(", ...l, ")"] : p ? [o, "(", ...l, ")"] : (vr(a) || Di(a) || a.type === "TypeAlias" || a.type === "UnionTypeAnnotation" || a.type === "IntersectionTypeAnnotation" || a.type === "FunctionTypeAnnotation" && a.returnType === i) && u.length === 1 && u[0].name === null && i.this !== u[0] && u[0].typeAnnotation && i.typeParameters === null && Ht(u[0].typeAnnotation) && !i.rest ? t.arrowParens === "always" || i.type === "HookTypeAnnotation" ? ["(", ...l, ")"] : l : [o, "(", m([f, ...l]), B(!di(i) && ue(t, "all") ? "," : ""), f, ")"];
+}
+function to(e) {
+  if (!e) return false;
+  let t = K(e);
+  if (t.length !== 1) return false;
+  let [r] = t;
+  return !C(r) && (r.type === "ObjectPattern" || r.type === "ArrayPattern" || r.type === "Identifier" && r.typeAnnotation && (r.typeAnnotation.type === "TypeAnnotation" || r.typeAnnotation.type === "TSTypeAnnotation") && We(r.typeAnnotation.typeAnnotation) || r.type === "FunctionTypeParam" && We(r.typeAnnotation) && r !== e.rest || r.type === "AssignmentPattern" && (r.left.type === "ObjectPattern" || r.left.type === "ArrayPattern") && (r.right.type === "Identifier" || ie(r.right) && r.right.properties.length === 0 || W(r.right) && r.right.elements.length === 0));
+}
+function Il(e) {
+  let t;
+  return e.returnType ? (t = e.returnType, t.typeAnnotation && (t = t.typeAnnotation)) : e.typeAnnotation && (t = e.typeAnnotation), t;
+}
+function ct(e, t) {
+  let r = Il(e);
+  if (!r) return false;
+  let n = e.typeParameters?.params;
+  if (n) {
+    if (n.length > 1) return false;
+    if (n.length === 1) {
+      let s = n[0];
+      if (s.constraint || s.default) return false;
+    }
+  }
+  return K(e).length === 1 && (We(r) || se(t));
+}
+function Ll(e) {
+  return e.match((t) => t.type === "ArrowFunctionExpression" && t.body.type === "BlockStatement", (t, r) => {
+    if (t.type === "CallExpression" && r === "arguments" && t.arguments.length === 1 && t.callee.type === "CallExpression") {
+      let n = t.callee.callee;
+      return n.type === "Identifier" || n.type === "MemberExpression" && !n.computed && n.object.type === "Identifier" && n.property.type === "Identifier";
+    }
+    return false;
+  }, (t, r) => t.type === "VariableDeclarator" && r === "init" || t.type === "ExportDefaultDeclaration" && r === "declaration" || t.type === "TSExportAssignment" && r === "expression" || t.type === "AssignmentExpression" && r === "right" && t.left.type === "MemberExpression" && t.left.object.type === "Identifier" && t.left.object.name === "module" && t.left.property.type === "Identifier" && t.left.property.name === "exports", (t) => t.type !== "VariableDeclaration" || t.kind === "const" && t.declarations.length === 1);
+}
+function ro(e) {
+  let t = K(e);
+  return t.length > 1 && t.some((r) => r.type === "TSParameterProperty");
+}
+function Nt(e, t) {
+  return (t === "params" || t === "this" || t === "rest") && to(e);
+}
+var Ol = /^[\$A-Z_a-z\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B4\u08B6-\u08BD\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC][\$0-9A-Z_a-z\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B4\u08B6-\u08BD\u08D4-\u08E1\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C80-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D54-\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1C80-\u1C88\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFB-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]*$/, wl = (e) => Ol.test(e), no = wl;
+function Ml(e) {
+  return e.length === 1 ? e : e.toLowerCase().replace(/^([+-]?[\d.]+e)(?:\+|(-))?0*(?=\d)/u, "$1$2").replace(/^([+-]?[\d.]+)e[+-]?0+$/u, "$1").replace(/^([+-])?\./u, "$10.").replace(/(\.\d+?)0+(?=e|$)/u, "$1").replace(/\.(?=e|$)/u, "");
+}
+var Et = Ml;
+var nn = /* @__PURE__ */ new WeakMap();
+function io(e) {
+  return /^(?:\d+|\d+\.\d+)$/u.test(e);
+}
+function so(e, t) {
+  return t.parser === "json" || t.parser === "jsonc" || !X(e.key) || ut(pe(e.key), t).slice(1, -1) !== e.key.value ? false : !!(no(e.key.value) && !(t.parser === "babel-ts" && e.type === "ClassProperty" || (t.parser === "typescript" || t.parser === "oxc-ts") && e.type === "PropertyDefinition") || io(e.key.value) && String(Number(e.key.value)) === e.key.value && e.type !== "ImportAttribute" && (t.parser === "babel" || t.parser === "acorn" || t.parser === "oxc" || t.parser === "espree" || t.parser === "meriyah" || t.parser === "__babel_estree"));
+}
+function _l(e, t) {
+  let { key: r } = e.node;
+  return (r.type === "Identifier" || de(r) && io(Et(pe(r))) && String(r.value) === Et(pe(r)) && !(t.parser === "typescript" || t.parser === "babel-ts" || t.parser === "oxc-ts")) && (t.parser === "json" || t.parser === "jsonc" || t.quoteProps === "consistent" && nn.get(e.parent));
+}
+function Ft(e, t, r) {
+  let { node: n } = e;
+  if (n.computed) return ["[", r("key"), "]"];
+  let { parent: s } = e, { key: i } = n;
+  if (t.quoteProps === "consistent" && !nn.has(s)) {
+    let u = e.siblings.some((o) => !o.computed && X(o.key) && !so(o, t));
+    nn.set(s, u);
+  }
+  if (_l(e, t)) {
+    let u = ut(JSON.stringify(i.type === "Identifier" ? i.name : i.value.toString()), t);
+    return e.call(() => me(e, u, t), "key");
+  }
+  return so(n, t) && (t.quoteProps === "as-needed" || t.quoteProps === "consistent" && !nn.get(s)) ? e.call(() => me(e, /^\d/u.test(i.value) ? Et(i.value) : i.value, t), "key") : r("key");
+}
+function sn(e, t, r) {
+  let { node: n } = e;
+  return n.shorthand ? r("value") : xt(e, t, r, Ft(e, t, r), ":", "value");
+}
+var Nl = ({ node: e, key: t, parent: r }) => t === "value" && e.type === "FunctionExpression" && (r.type === "ObjectMethod" || r.type === "ClassMethod" || r.type === "ClassPrivateMethod" || r.type === "MethodDefinition" || r.type === "TSAbstractMethodDefinition" || r.type === "TSDeclareMethod" || r.type === "Property" && lt(r));
+function un(e, t, r, n) {
+  if (Nl(e)) return on(e, t, r);
+  let { node: s } = e, i = false;
+  if ((s.type === "FunctionDeclaration" || s.type === "FunctionExpression") && n?.expandLastArg) {
+    let { parent: D } = e;
+    M(D) && (ce(D).length > 1 || K(s).every((l) => l.type === "Identifier" && !l.typeAnnotation)) && (i = true);
+  }
+  let u = [z(e), s.async ? "async " : "", `function${s.generator ? "*" : ""} `, s.id ? r("id") : ""], o = Ke(e, t, r, i), a = Zt(e, r), p = ct(s, a);
+  return u.push(r("typeParameters"), c([p ? c(o) : o, a]), s.body ? " " : "", r("body")), t.semi && (s.declare || !s.body) && u.push(";"), u;
+}
+function gr(e, t, r) {
+  let { node: n } = e, { kind: s } = n, i = n.value || n, u = [];
+  return !s || s === "init" || s === "method" || s === "constructor" ? i.async && u.push("async ") : u.push(s, " "), i.generator && u.push("*"), u.push(Ft(e, t, r), n.optional ? "?" : "", n === i ? on(e, t, r) : r("value")), u;
+}
+function on(e, t, r) {
+  let { node: n } = e, s = Ke(e, t, r), i = Zt(e, r), u = ro(n), o = ct(n, i), a = [r("typeParameters"), c([u ? c(s, { shouldBreak: true }) : o ? c(s) : s, i])];
+  return n.body ? a.push(" ", r("body")) : a.push(t.semi ? ";" : ""), a;
+}
+function vl(e) {
+  let t = K(e);
+  return t.length === 1 && !e.typeParameters && !C(e, T.Dangling) && t[0].type === "Identifier" && !t[0].typeAnnotation && !C(t[0]) && !t[0].optional && !e.predicate && !e.returnType;
+}
+function an(e, t) {
+  if (t.arrowParens === "always") return false;
+  if (t.arrowParens === "avoid") {
+    let { node: r } = e;
+    return vl(r);
+  }
+  return false;
+}
+function Zt(e, t) {
+  let { node: r } = e, s = [U(e, t, "returnType")];
+  return r.predicate && s.push(t("predicate")), s;
+}
+function uo(e, t, r) {
+  let { node: n } = e, s = [];
+  if (n.argument) {
+    let o = r("argument");
+    jl(t, n.argument) ? o = ["(", m([y, o]), y, ")"] : (xe(n.argument) || t.experimentalTernaries && n.argument.type === "ConditionalExpression" && (n.argument.consequent.type === "ConditionalExpression" || n.argument.alternate.type === "ConditionalExpression")) && (o = c([B("("), m([f, o]), f, B(")")])), s.push(" ", o);
+  }
+  let i = C(n, T.Dangling), u = t.semi && i && C(n, T.Last | T.Line);
+  return u && s.push(";"), i && s.push(" ", v(e, t)), !u && t.semi && s.push(";"), s;
+}
+function oo(e, t, r) {
+  return ["return", uo(e, t, r)];
+}
+function ao(e, t, r) {
+  return ["throw", uo(e, t, r)];
+}
+function jl(e, t) {
+  if (Ce(e.originalText, t) || C(t, T.Leading, (r) => re(e.originalText, L(r), k(r))) && !q(t)) return true;
+  if (Ut(t)) {
+    let r = t, n;
+    for (; n = pi(r); ) if (r = n, Ce(e.originalText, r)) return true;
+  }
+  return false;
+}
+function vt(e, t, r) {
+  let { node: n } = e, s = [], i = n.type === "ObjectTypeAnnotation", u = !co(e), o = u ? A : y, [a, p] = i && n.exact ? ["{|", "|}"] : "{}", D;
+  if (Rl(e, ({ node: l, next: E, isLast: d }) => {
+    if (D ?? (D = l), s.push(r()), u && i) {
+      let { parent: F } = e;
+      F.inexact || !d ? s.push(",") : ue(t) && s.push(B(","));
+    }
+    !u && (Jl({ node: l, next: E }, t) || mo({ node: l, next: E }, t)) && s.push(";"), d || (s.push(o), oe(l, t) && s.push(y));
+  }), C(n, T.Dangling) && s.push(v(e, t)), n.type === "ObjectTypeAnnotation" && n.inexact) {
+    let l;
+    C(n, T.Dangling) ? l = [C(n, T.Line) || Q(t.originalText, k(_(0, Ze(n), -1))) ? y : A, "..."] : l = [D ? A : "", "..."], s.push(l);
+  }
+  if (u) {
+    let l = t.objectWrap === "preserve" && D && re(t.originalText, L(n), L(D)), E;
+    if (s.length === 0) E = a + p;
+    else {
+      let d = t.bracketSpacing ? A : f;
+      E = [a, m([d, ...s]), d, p];
+    }
+    return e.match(void 0, (d, F) => F === "typeAnnotation", (d, F) => F === "typeAnnotation", Nt) || e.match(void 0, (d, F) => d.type === "FunctionTypeParam" && F === "typeAnnotation", Nt) ? E : c(E, { shouldBreak: l });
+  }
+  return [a, s.length > 0 ? [m([y, s]), y] : "", p];
+}
+function co(e) {
+  let { node: t } = e;
+  if (t.type === "ObjectTypeAnnotation") {
+    let { key: r, parent: n } = e;
+    return r === "body" && (n.type === "InterfaceDeclaration" || n.type === "DeclareInterface" || n.type === "DeclareClass");
+  }
+  return t.type === "ClassBody" || t.type === "TSInterfaceBody";
+}
+function Rl(e, t) {
+  let { node: r } = e;
+  if (r.type === "ClassBody" || r.type === "TSInterfaceBody") {
+    e.each(t, "body");
+    return;
+  }
+  if (r.type === "TSTypeLiteral") {
+    e.each(t, "members");
+    return;
+  }
+  if (r.type === "ObjectTypeAnnotation") {
+    let n = ["properties", "indexers", "callProperties", "internalSlots"].flatMap((s) => e.map(({ node: i, index: u }) => ({ node: i, loc: L(i), selector: [s, u] }), s)).sort((s, i) => s.loc - i.loc);
+    for (let [s, { node: i, selector: u }] of n.entries()) e.call(() => t({ node: i, next: n[s + 1]?.node, isLast: s === n.length - 1 }), ...u);
+  }
+}
+function ve(e, t) {
+  let { parent: r } = e;
+  return e.callParent(co) ? t.semi || r.type === "ObjectTypeAnnotation" ? ";" : "" : r.type === "TSTypeLiteral" ? e.isLast ? t.semi ? B(";") : "" : t.semi || mo({ node: e.node, next: e.next }, t) ? ";" : B("", ";") : "";
+}
+var po = b(["ClassProperty", "PropertyDefinition", "ClassPrivateProperty", "ClassAccessorProperty", "AccessorProperty", "TSAbstractPropertyDefinition", "TSAbstractAccessorProperty"]), lo = (e) => {
+  if (e.computed || e.typeAnnotation) return false;
+  let { type: t, name: r } = e.key;
+  return t === "Identifier" && (r === "static" || r === "get" || r === "set");
+};
+function Jl({ node: e, next: t }, r) {
+  if (r.semi || !po(e)) return false;
+  if (!e.value && lo(e)) return true;
+  if (!t || t.static || t.accessibility || t.readonly) return false;
+  if (!t.computed) {
+    let n = t.key?.name;
+    if (n === "in" || n === "instanceof") return true;
+  }
+  if (po(t) && t.variance && !t.static && !t.declare) return true;
+  switch (t.type) {
+    case "ClassProperty":
+    case "PropertyDefinition":
+    case "TSAbstractPropertyDefinition":
+      return t.computed;
+    case "MethodDefinition":
+    case "TSAbstractMethodDefinition":
+    case "ClassMethod":
+    case "ClassPrivateMethod": {
+      if ((t.value ? t.value.async : t.async) || t.kind === "get" || t.kind === "set") return false;
+      let s = t.value ? t.value.generator : t.generator;
+      return !!(t.computed || s);
+    }
+    case "TSIndexSignature":
+      return true;
+  }
+  return false;
+}
+var Gl = b(["TSPropertySignature"]);
+function mo({ node: e, next: t }, r) {
+  if (r.semi || !Gl(e)) return false;
+  if (lo(e)) return true;
+  if (!t) return false;
+  switch (t.type) {
+    case "TSCallSignatureDeclaration":
+      return true;
+  }
+  return false;
+}
+var Wl = eo("heritageGroup"), ql = b(["TSInterfaceDeclaration", "DeclareInterface", "InterfaceDeclaration", "InterfaceTypeAnnotation"]);
+function er(e, t, r) {
+  let { node: n } = e, s = ql(n), i = [z(e), tr(e), s ? "interface" : "class"], u = fo(e), o = [], a = [];
+  if (n.type !== "InterfaceTypeAnnotation") {
+    n.id && o.push(" ");
+    for (let D of ["id", "typeParameters"]) if (n[D]) {
+      let { leading: l, trailing: E } = e.call(() => Mt(e, t), D);
+      o.push(l, r(D), m(E));
+    }
+  }
+  if (n.superClass) {
+    let D = [Hl(e, t, r), r(n.superTypeArguments ? "superTypeArguments" : "superTypeParameters")], l = e.call(() => ["extends ", me(e, D, t)], "superClass");
+    u ? a.push(A, c(l)) : a.push(" ", l);
+  } else a.push(Ls(e, t, r, "extends"));
+  a.push(Ls(e, t, r, "mixins"), Ls(e, t, r, "implements"));
+  let p;
+  return u ? (p = Wl(n), i.push(c([...o, m(a)], { id: p }))) : i.push(...o, ...a), !s && u && Yl(n.body) ? i.push(B(y, " ", { groupId: p })) : i.push(" "), i.push(r("body")), i;
+}
+function Yl(e) {
+  return e.type === "ObjectTypeAnnotation" ? ["properties", "indexers", "callProperties", "internalSlots"].some((t) => j(e[t])) : j(e.body);
+}
+function Do(e) {
+  let t = e.superClass ? 1 : 0;
+  for (let r of ["extends", "mixins", "implements"]) if (Array.isArray(e[r]) && (t += e[r].length), t > 1) return true;
+  return t > 1;
+}
+function Ul(e) {
+  let { node: t } = e;
+  if (C(t.id, T.Trailing) || C(t.typeParameters, T.Trailing) || C(t.superClass) || Do(t)) return true;
+  if (t.superClass) return e.parent.type === "AssignmentExpression" ? false : !(t.superTypeArguments ?? t.superTypeParameters) && R(t.superClass);
+  let r = t.extends?.[0] ?? t.mixins?.[0] ?? t.implements?.[0];
+  return r ? r.type === "InterfaceExtends" && r.id.type === "QualifiedTypeIdentifier" && !r.typeParameters || (r.type === "TSClassImplements" || r.type === "TSInterfaceHeritage") && R(r.expression) && !r.typeArguments : false;
+}
+var Is = /* @__PURE__ */ new WeakMap();
+function fo(e) {
+  let { node: t } = e;
+  return Is.has(t) || Is.set(t, Ul(e)), Is.get(t);
+}
+function Ls(e, t, r, n) {
+  let { node: s } = e;
+  if (!j(s[n])) return "";
+  let i = v(e, t, { marker: n }), u = I([",", A], e.map(r, n));
+  if (!Do(s)) {
+    let o = [`${n} `, i, u];
+    return fo(e) ? [A, c(o)] : [" ", o];
+  }
+  return [A, i, i && y, n, c(m([A, u]))];
+}
+function Hl(e, t, r) {
+  let n = r("superClass"), { parent: s } = e;
+  return s.type === "AssignmentExpression" ? c(B(["(", m([f, n]), f, ")"], n)) : n;
+}
+function pn(e, t, r) {
+  let { node: n } = e, s = [];
+  return j(n.decorators) && s.push(Bs(e, t, r)), s.push(rr(n)), n.static && s.push("static "), s.push(tr(e)), n.override && s.push("override "), s.push(gr(e, t, r)), s;
+}
+function cn(e, t, r) {
+  let { node: n } = e, s = [];
+  j(n.decorators) && s.push(Bs(e, t, r)), s.push(z(e), rr(n)), n.static && s.push("static "), s.push(tr(e)), n.override && s.push("override "), n.readonly && s.push("readonly "), n.variance && s.push(r("variance")), (n.type === "ClassAccessorProperty" || n.type === "AccessorProperty" || n.type === "TSAbstractAccessorProperty") && s.push("accessor "), s.push(Ft(e, t, r), $(e), ln(e), U(e, r));
+  let i = n.type === "TSAbstractPropertyDefinition" || n.type === "TSAbstractAccessorProperty";
+  return [xt(e, t, r, s, " =", i ? void 0 : "value"), t.semi ? ";" : ""];
+}
+var Xl = b(["VoidTypeAnnotation", "TSVoidKeyword", "NullLiteralTypeAnnotation", "TSNullKeyword"]), Vl = b(["ObjectTypeAnnotation", "TSTypeLiteral", "GenericTypeAnnotation", "TSTypeReference"]);
+function $l(e) {
+  let { types: t } = e;
+  if (t.some((n) => C(n))) return false;
+  let r = t.find((n) => Vl(n));
+  return r ? t.every((n) => n === r || Xl(n)) : false;
+}
+function Os(e) {
+  return Ht(e) || We(e) ? true : Ie(e) ? $l(e) : false;
+}
+function yo(e, t, r) {
+  let { node: n } = e, s = [z(e), "opaque type ", r("id"), r("typeParameters")];
+  if (n.supertype && s.push(": ", r("supertype")), n.lowerBound || n.upperBound) {
+    let i = [];
+    n.lowerBound && i.push(m([A, "super ", r("lowerBound")])), n.upperBound && i.push(m([A, "extends ", r("upperBound")])), s.push(c(i));
+  }
+  return n.impltype && s.push(" = ", r("impltype")), s.push(t.semi ? ";" : ""), s;
+}
+function mn(e, t, r) {
+  let { node: n } = e, s = [z(e), "type ", r("id"), r("typeParameters")], i = n.type === "TSTypeAliasDeclaration" ? "typeAnnotation" : "right";
+  return [xt(e, t, r, s, " =", i), t.semi ? ";" : ""];
+}
+function Dn(e, t, r) {
+  let n = false;
+  return c(e.map(({ isFirst: s, previous: i, node: u, index: o }) => {
+    let a = r();
+    if (s) return a;
+    let p = We(u), D = We(i);
+    return D && p ? [" & ", n ? m(a) : a] : !D && !p || Ce(t.originalText, u) ? t.experimentalOperatorPosition === "start" ? m([A, "& ", a]) : m([" &", A, a]) : (o > 1 && (n = true), [" & ", o > 1 ? m(a) : a]);
+  }, "types"));
+}
+function fn(e, t, r) {
+  let { node: n } = e, { parent: s } = e, i = s.type !== "TypeParameterInstantiation" && (!qe(s) || !t.experimentalTernaries) && s.type !== "TSTypeParameterInstantiation" && s.type !== "GenericTypeAnnotation" && s.type !== "TSTypeReference" && s.type !== "TSTypeAssertion" && s.type !== "TupleTypeAnnotation" && s.type !== "TSTupleType" && !(s.type === "FunctionTypeParam" && !s.name && e.grandparent.this !== s) && !((Er(s) || s.type === "VariableDeclarator") && Ce(t.originalText, n)) && !(Er(s) && C(s.id, T.Trailing | T.Line)), u = Os(n), o = e.map(() => {
+    let d = r();
+    return u || (d = ge(2, d)), me(e, d, t);
+  }, "types"), { leading: a, trailing: p } = Mt(e, t);
+  if (u) return [a, I(" | ", o), p];
+  let D = i && !Ce(t.originalText, n), l = [B([D ? A : "", "| "]), I([A, "| "], o)];
+  if (he(e, t)) return [a, c([m(l), f]), p];
+  let E = [a, c(l)];
+  return (s.type === "TupleTypeAnnotation" || s.type === "TSTupleType") && s[s.type === "TupleTypeAnnotation" && s.types ? "types" : "elementTypes"].length > 1 ? [c([m([B(["(", f]), E]), f, B(")")]), p] : [c(i ? m(E) : E), p];
+}
+function Kl(e) {
+  let { node: t, parent: r } = e;
+  return t.type === "FunctionTypeAnnotation" && (vr(r) || !((r.type === "ObjectTypeProperty" || r.type === "ObjectTypeInternalSlot") && !r.variance && !r.optional && St(r, t) || r.type === "ObjectTypeCallProperty" || e.getParentNode(2)?.type === "DeclareFunction"));
+}
+function yn(e, t, r) {
+  let { node: n } = e, s = [tr(e)];
+  (n.type === "TSConstructorType" || n.type === "TSConstructSignatureDeclaration") && s.push("new ");
+  let i = Ke(e, t, r, false, true), u = [];
+  return n.type === "FunctionTypeAnnotation" ? u.push(Kl(e) ? " => " : ": ", r("returnType")) : u.push(U(e, r, "returnType")), ct(n, u) && (i = c(i)), s.push(i, u), [c(s), n.type === "TSConstructSignatureDeclaration" || n.type === "TSCallSignatureDeclaration" ? ve(e, t) : ""];
+}
+function En(e, t, r) {
+  return [r("objectType"), $(e), "[", r("indexType"), "]"];
+}
+function Fn(e, t, r) {
+  return ["infer ", r("typeParameter")];
+}
+function ws(e, t, r) {
+  let { node: n } = e;
+  return [n.postfix ? "" : r, U(e, t), n.postfix ? r : ""];
+}
+function dn(e, t, r) {
+  let { node: n } = e;
+  return ["...", ...n.type === "TupleTypeSpreadElement" && n.label ? [r("label"), ": "] : [], r("typeAnnotation")];
+}
+function Cn(e, t, r) {
+  let { node: n } = e;
+  return [n.variance ? r("variance") : "", r("label"), n.optional ? "?" : "", ": ", r("elementType")];
+}
+var Ql = /* @__PURE__ */ new WeakSet();
+function U(e, t, r = "typeAnnotation") {
+  let { node: { [r]: n } } = e;
+  if (!n) return "";
+  let s = false;
+  if (n.type === "TSTypeAnnotation" || n.type === "TypeAnnotation") {
+    let i = e.call(Eo, r);
+    (i === "=>" || i === ":" && C(n, T.Leading)) && (s = true), Ql.add(n);
+  }
+  return s ? [" ", t(r)] : t(r);
+}
+var Eo = (e) => e.match((t) => t.type === "TSTypeAnnotation", (t, r) => (r === "returnType" || r === "typeAnnotation") && (t.type === "TSFunctionType" || t.type === "TSConstructorType")) ? "=>" : e.match((t) => t.type === "TSTypeAnnotation", (t, r) => r === "typeAnnotation" && (t.type === "TSJSDocNullableType" || t.type === "TSJSDocNonNullableType" || t.type === "TSTypePredicate")) || e.match((t) => t.type === "TypeAnnotation", (t, r) => r === "typeAnnotation" && t.type === "Identifier", (t, r) => r === "id" && t.type === "DeclareFunction") || e.match((t) => t.type === "TypeAnnotation", (t, r) => r === "typeAnnotation" && t.type === "Identifier", (t, r) => r === "id" && t.type === "DeclareHook") || e.match((t) => t.type === "TypeAnnotation", (t, r) => r === "bound" && t.type === "TypeParameter" && t.usesExtendsBound) ? "" : ":";
+function An(e, t, r) {
+  let n = Eo(e);
+  return n ? [n, " ", r("typeAnnotation")] : r("typeAnnotation");
+}
+function Tn(e) {
+  return [e("elementType"), "[]"];
+}
+function xn({ node: e }, t) {
+  let r = e.type === "TSTypeQuery" ? "exprName" : "argument";
+  return ["typeof ", t(r), t("typeArguments")];
+}
+function gn(e, t) {
+  let { node: r } = e;
+  return [r.type === "TSTypePredicate" && r.asserts ? "asserts " : r.type === "TypePredicate" && r.kind ? `${r.kind} ` : "", t("parameterName"), r.typeAnnotation ? [" is ", U(e, t)] : ""];
+}
+function $(e) {
+  let { node: t } = e;
+  return !t.optional || t.type === "Identifier" && t === e.parent.key ? "" : M(t) || R(t) && t.computed || t.type === "OptionalIndexedAccessType" ? "?." : "?";
+}
+function ln(e) {
+  return e.node.definite || e.match(void 0, (t, r) => r === "id" && t.type === "VariableDeclarator" && t.definite) ? "!" : "";
+}
+var zl = b(["DeclareClass", "DeclareComponent", "DeclareFunction", "DeclareHook", "DeclareVariable", "DeclareExportDeclaration", "DeclareExportAllDeclaration", "DeclareOpaqueType", "DeclareTypeAlias", "DeclareEnum", "DeclareInterface"]);
+function z(e) {
+  let { node: t } = e;
+  return t.declare || zl(t) && e.parent.type !== "DeclareExportDeclaration" ? "declare " : "";
+}
+var Zl = b(["TSAbstractMethodDefinition", "TSAbstractPropertyDefinition", "TSAbstractAccessorProperty"]);
+function tr({ node: e }) {
+  return e.abstract || Zl(e) ? "abstract " : "";
+}
+function tn(e, t, r) {
+  return ["::", r("callee")];
+}
+function dt(e, t, r) {
+  return e.type === "EmptyStatement" ? C(e, T.Leading) ? [" ", t] : t : e.type === "BlockStatement" || r ? [" ", t] : m([A, t]);
+}
+function hn(e, t) {
+  return ["...", t("argument"), U(e, t)];
+}
+function rr(e) {
+  return e.accessibility ? e.accessibility + " " : "";
+}
+function em(e, t, r, n) {
+  let { node: s } = e, i = s.inexact ? "..." : "";
+  return C(s, T.Dangling) ? c([r, i, v(e, t, { indent: true }), f, n]) : [r, i, n];
+}
+function nr(e, t, r) {
+  let { node: n } = e, s = [], i = "[", u = "]", o = n.type === "TupleTypeAnnotation" && n.types ? "types" : n.type === "TSTupleType" || n.type === "TupleTypeAnnotation" ? "elementTypes" : "elements", a = n[o];
+  if (a.length === 0) s.push(em(e, t, i, u));
+  else {
+    let p = _(0, a, -1), D = p?.type !== "RestElement" && !n.inexact, l = p === null, E = Symbol("array"), d = !t.__inJestEach && a.length > 1 && a.every((S, O, g) => {
+      let x = S?.type;
+      if (!W(S) && !ie(S)) return false;
+      let h = g[O + 1];
+      if (h && x !== h.type) return false;
+      let N = W(S) ? "elements" : "properties";
+      return S[N] && S[N].length > 1;
+    }), F = bs(n, t), P = D ? l ? "," : ue(t) ? F ? B(",", "", { groupId: E }) : B(",") : "" : "";
+    s.push(c([i, m([f, F ? rm(e, t, r, P) : [tm(e, t, r, o, n.inexact), P], v(e, t)]), f, u], { shouldBreak: d, id: E }));
+  }
+  return s.push($(e), U(e, r)), s;
+}
+function bs(e, t) {
+  return W(e) && e.elements.length > 0 && e.elements.every((r) => r && (de(r) || Yn(r) && !C(r.argument)) && !C(r, T.Trailing | T.Line, (n) => !Q(t.originalText, L(n), { backwards: true })));
+}
+function Fo({ node: e }, { originalText: t }) {
+  let r = k(e);
+  if (r === L(e)) return false;
+  let { length: n } = t;
+  for (; r < n && t[r] !== ","; ) r = Gt(t, Wt(t, r + 1));
+  return qt(t, r);
+}
+function tm(e, t, r, n, s) {
+  let i = [];
+  return e.each(({ node: u, isLast: o }) => {
+    i.push(u ? c(r()) : ""), (!o || s) && i.push([",", A, u && Fo(e, t) ? f : ""]);
+  }, n), s && i.push("..."), i;
+}
+function rm(e, t, r, n) {
+  let s = [];
+  return e.each(({ isLast: i, next: u }) => {
+    s.push([r(), i ? n : ","]), i || s.push(Fo(e, t) ? [y, y] : C(u, T.Leading | T.Line) ? y : A);
+  }, "elements"), Hr(s);
+}
+var Ms = /* @__PURE__ */ new WeakMap();
+function Co(e) {
+  return Ms.has(e) || Ms.set(e, e.type === "ConditionalExpression" && !fe(e, (t) => t.type === "ObjectExpression")), Ms.get(e);
+}
+var nm = (e) => e.type === "SequenceExpression";
+function Ao(e, t, r, n = {}) {
+  let s = [], i, u = [], o = false, a = !n.expandLastArg && e.node.body.type === "ArrowFunctionExpression", p;
+  (function O() {
+    let { node: g } = e, x = sm(e, t, r, n);
+    if (s.length === 0) s.push(x);
+    else {
+      let { leading: h, trailing: N } = Mt(e, t);
+      s.push([h, x]), u.unshift(N);
+    }
+    a && (o || (o = g.returnType && K(g).length > 0 || g.typeParameters || K(g).some((h) => h.type !== "Identifier"))), !a || g.body.type !== "ArrowFunctionExpression" ? (i = r("body", n), p = g.body) : e.call(O, "body");
+  })();
+  let D = !Ce(t.originalText, p) && (nm(p) || im(p, i, t) || !o && Co(p)), l = e.key === "callee" && mt(e.parent), E = Symbol("arrow-chain"), d = um(e, n, { signatureDocs: s, shouldBreak: o }), F = false, P = false, S = false;
+  return a && (l || n.assignmentLayout) && (P = true, S = !C(e.node, T.Leading & T.Line), F = n.assignmentLayout === "chain-tail-arrow-chain" || l && !D), i = om(e, t, n, { bodyDoc: i, bodyComments: u, functionBody: p, shouldPutBodyOnSameLine: D }), c([c(P ? m([S ? f : "", d]) : d, { shouldBreak: F, id: E }), " =>", a ? ft(i, { groupId: E }) : c(i), a && l ? B(f, "", { groupId: E }) : ""]);
+}
+function sm(e, t, r, n) {
+  let { node: s } = e, i = [];
+  if (s.async && i.push("async "), an(e, t)) i.push(r(["params", 0]));
+  else {
+    let o = n.expandLastArg || n.expandFirstArg, a = Zt(e, r);
+    if (o) {
+      if (se(a)) throw new yt();
+      a = c(Ot(a));
+    }
+    i.push(c([Ke(e, t, r, o, true), a]));
+  }
+  let u = v(e, t, { filter(o) {
+    let a = pt(t.originalText, k(o));
+    return a !== false && t.originalText.slice(a, a + 2) === "=>";
+  } });
+  return u && i.push(" ", u), i;
+}
+function im(e, t, r) {
+  return W(e) || ie(e) || e.type === "ArrowFunctionExpression" || e.type === "DoExpression" || e.type === "BlockStatement" || q(e) || t.label?.hug !== false && (t.label?.embed || jr(e, r.originalText));
+}
+function um(e, t, { signatureDocs: r, shouldBreak: n }) {
+  if (r.length === 1) return r[0];
+  let { parent: s, key: i } = e;
+  return i !== "callee" && mt(s) || xe(s) ? c([r[0], " =>", m([A, I([" =>", A], r.slice(1))])], { shouldBreak: n }) : i === "callee" && mt(s) || t.assignmentLayout ? c(I([" =>", A], r), { shouldBreak: n }) : c(m(I([" =>", A], r)), { shouldBreak: n });
+}
+function om(e, t, r, { bodyDoc: n, bodyComments: s, functionBody: i, shouldPutBodyOnSameLine: u }) {
+  let { node: o, parent: a } = e, p = r.expandLastArg && ue(t, "all") ? B(",") : "", D = (r.expandLastArg || a.type === "JSXExpressionContainer") && !C(o) ? f : "";
+  return u && Co(i) ? [" ", c([B("", "("), m([f, n]), B("", ")"), p, D]), s] : u ? [" ", n, s] : [m([A, n, s]), p, D];
+}
+var am = Array.prototype.findLast ?? function(e) {
+  for (let t = this.length - 1; t >= 0; t--) {
+    let r = this[t];
+    if (e(r, t, this)) return r;
+  }
+}, pm = Jt("findLast", function() {
+  if (Array.isArray(this)) return am;
+}), To = pm;
+function hr(e, t, r, n) {
+  let { node: s } = e, i = [], u = To(0, s[n], (o) => o.type !== "EmptyStatement");
+  return e.each(({ node: o }) => {
+    o.type !== "EmptyStatement" && (i.push(r()), o !== u && (i.push(y), oe(o, t) && i.push(y)));
+  }, n), i;
+}
+function Sn(e, t, r) {
+  let n = cm(e, t, r), { node: s, parent: i } = e;
+  if (s.type === "Program" && i?.type !== "ModuleExpression") return n ? [n, y] : "";
+  let u = [];
+  if (s.type === "StaticBlock" && u.push("static "), u.push("{"), n) u.push(m([y, n]), y);
+  else {
+    let o = e.grandparent;
+    i.type === "ArrowFunctionExpression" || i.type === "FunctionExpression" || i.type === "FunctionDeclaration" || i.type === "ComponentDeclaration" || i.type === "HookDeclaration" || i.type === "ObjectMethod" || i.type === "ClassMethod" || i.type === "ClassPrivateMethod" || i.type === "ForStatement" || i.type === "WhileStatement" || i.type === "DoWhileStatement" || i.type === "DoExpression" || i.type === "ModuleExpression" || i.type === "CatchClause" && !o.finalizer || i.type === "TSModuleDeclaration" || i.type === "MatchStatementCase" || s.type === "StaticBlock" || u.push(y);
+  }
+  return u.push("}"), u;
+}
+function cm(e, t, r) {
+  let { node: n } = e, s = j(n.directives), i = n.body.some((a) => a.type !== "EmptyStatement"), u = C(n, T.Dangling);
+  if (!s && !i && !u) return "";
+  let o = [];
+  return s && (o.push(hr(e, t, r, "directives")), (i || u) && (o.push(y), oe(_(0, n.directives, -1), t) && o.push(y))), i && o.push(hr(e, t, r, "body")), u && o.push(v(e, t)), o;
+}
+var lm = b(["TSAsExpression", "TSTypeAssertion", "TSNonNullExpression", "TSInstantiationExpression", "TSSatisfiesExpression"]);
+function _s(e) {
+  return lm(e) ? _s(e.expression) : e;
+}
+var xo = b(["FunctionExpression", "ArrowFunctionExpression"]);
+function go(e) {
+  return e.type === "MemberExpression" || e.type === "OptionalMemberExpression" || e.type === "Identifier" && e.name !== "undefined";
+}
+function ho(e, t) {
+  if (t.semi || vs(e, t) || Rs(e, t) || js(e, t)) return false;
+  let { node: r, key: n, parent: s } = e;
+  return !!(r.type === "ExpressionStatement" && (n === "body" && (s.type === "Program" || s.type === "BlockStatement" || s.type === "StaticBlock" || s.type === "TSModuleBlock") || n === "consequent" && s.type === "SwitchCase") && e.call(() => So(e, t), "expression"));
+}
+function So(e, t) {
+  let { node: r } = e;
+  switch (r.type) {
+    case "ParenthesizedExpression":
+    case "TypeCastExpression":
+    case "ArrayExpression":
+    case "ArrayPattern":
+    case "TemplateLiteral":
+    case "TemplateElement":
+    case "RegExpLiteral":
+      return true;
+    case "ArrowFunctionExpression":
+      if (!an(e, t)) return true;
+      break;
+    case "UnaryExpression": {
+      let { prefix: n, operator: s } = r;
+      if (n && (s === "+" || s === "-")) return true;
+      break;
+    }
+    case "BindExpression":
+      if (!r.object) return true;
+      break;
+    case "Literal":
+      if (r.regex) return true;
+      break;
+    default:
+      if (q(r)) return true;
+  }
+  return he(e, t) ? true : Ut(r) ? e.call(() => So(e, t), ..._r(r)) : false;
+}
+var Ns = ({ node: e, parent: t }) => e.type === "ExpressionStatement" && t.type === "Program" && t.body.length === 1 && (Array.isArray(t.directives) && t.directives.length === 0 || !t.directives);
+function vs(e, t) {
+  return (t.parentParser === "markdown" || t.parentParser === "mdx") && Ns(e) && q(e.node.expression);
+}
+function js(e, t) {
+  return t.__isHtmlInlineEventHandler && Ns(e);
+}
+function Rs(e, t) {
+  return (t.parser === "__vue_event_binding" || t.parser === "__vue_ts_event_binding") && Ns(e);
+}
+function mm(e, t) {
+  if (Rs(e, t)) {
+    let r = _s(e.node.expression);
+    return xo(r) || go(r);
+  }
+  return !(!t.semi || vs(e, t) || js(e, t));
+}
+function Bo(e, t, r) {
+  return [r("expression"), mm(e, t) ? ";" : ""];
+}
+function bo(e, t, r) {
+  if (t.__isVueBindings || t.__isVueForBindingLeft) {
+    let n = e.map(r, "program", "body", 0, "params");
+    if (n.length === 1) return n[0];
+    let s = I([",", A], n);
+    return t.__isVueForBindingLeft ? ["(", m([f, c(s)]), f, ")"] : s;
+  }
+  if (t.__isEmbeddedTypescriptGenericParameters) {
+    let n = e.map(r, "program", "body", 0, "typeParameters", "params");
+    return I([",", A], n);
+  }
+}
+function Io(e, t) {
+  let { node: r } = e;
+  switch (r.type) {
+    case "RegExpLiteral":
+      return Po(r);
+    case "BigIntLiteral":
+      return Bn(r.extra.raw);
+    case "NumericLiteral":
+      return Et(r.extra.raw);
+    case "StringLiteral":
+      return Ge(ut(r.extra.raw, t));
+    case "NullLiteral":
+      return "null";
+    case "BooleanLiteral":
+      return String(r.value);
+    case "DirectiveLiteral":
+      return ko(r.extra.raw, t);
+    case "Literal": {
+      if (r.regex) return Po(r.regex);
+      if (r.bigint) return Bn(r.raw);
+      let { value: n } = r;
+      return typeof n == "number" ? Et(r.raw) : typeof n == "string" ? Dm(e) ? ko(r.raw, t) : Ge(ut(r.raw, t)) : String(n);
+    }
+  }
+}
+function Dm(e) {
+  if (e.key !== "expression") return;
+  let { parent: t } = e;
+  return t.type === "ExpressionStatement" && typeof t.directive == "string";
+}
+function Bn(e) {
+  return e.toLowerCase();
+}
+function Po({ pattern: e, flags: t }) {
+  return t = [...t].sort().join(""), `/${e}/${t}`;
+}
+function ko(e, t) {
+  let r = e.slice(1, -1);
+  if (r.includes('"') || r.includes("'")) return e;
+  let n = t.singleQuote ? "'" : '"';
+  return n + r + n;
+}
+function fm(e, t, r) {
+  let n = e.originalText.slice(t, r);
+  for (let s of e[Symbol.for("comments")]) {
+    let i = L(s);
+    if (i > r) break;
+    let u = k(s);
+    if (u < t) continue;
+    let o = i - t, a = u - t;
+    n = n.slice(0, o) + G(0, n.slice(o, a), /[^\n]/gu, " ") + n.slice(a);
+  }
+  return n;
+}
+var jt = fm;
+var Lo = b(["ImportDeclaration", "ExportDefaultDeclaration", "ExportNamedDeclaration", "ExportAllDeclaration", "DeclareExportDeclaration", "DeclareExportAllDeclaration"]), ym = b(["EnumBooleanBody", "EnumNumberBody", "EnumBigIntBody", "EnumStringBody", "EnumSymbolBody"]);
+function sr(e, t, r) {
+  let { node: n, parent: s } = e, i = ym(n), u = n.type === "TSEnumBody" || i, o = Lo(n), a = i && n.hasUnknownMembers, p = u ? "members" : o ? "attributes" : "properties", D = n[p], l = u || n.type === "ObjectPattern" && s.type !== "FunctionDeclaration" && s.type !== "FunctionExpression" && s.type !== "ArrowFunctionExpression" && s.type !== "ObjectMethod" && s.type !== "ClassMethod" && s.type !== "ClassPrivateMethod" && s.type !== "AssignmentPattern" && s.type !== "CatchClause" && n.properties.some((S) => S.value && (S.value.type === "ObjectPattern" || S.value.type === "ArrayPattern")) || n.type !== "ObjectPattern" && t.objectWrap === "preserve" && D.length > 0 && Em(n, D[0], t), E = [], d = e.map(({ node: S }) => {
+    let O = [...E, c(r())];
+    return E = [",", A], oe(S, t) && E.push(y), O;
+  }, p);
+  if (a) {
+    let S;
+    if (C(n, T.Dangling)) {
+      let O = C(n, T.Line);
+      S = [v(e, t), O || Q(t.originalText, k(_(0, Ze(n), -1))) ? y : A, "..."];
+    } else S = ["..."];
+    d.push([...E, ...S]);
+  }
+  let F = !(a || _(0, D, -1)?.type === "RestElement"), P;
+  if (d.length === 0) {
+    if (!C(n, T.Dangling)) return ["{}", U(e, r)];
+    P = c(["{", v(e, t, { indent: true }), f, "}", $(e), U(e, r)]);
+  } else {
+    let S = t.bracketSpacing ? A : f;
+    P = ["{", m([S, ...d]), B(F && ue(t) ? "," : ""), S, "}", $(e), U(e, r)];
+  }
+  return e.match((S) => S.type === "ObjectPattern" && !j(S.decorators), Nt) || We(n) && (e.match(void 0, (S, O) => O === "typeAnnotation", (S, O) => O === "typeAnnotation", Nt) || e.match(void 0, (S, O) => S.type === "FunctionTypeParam" && O === "typeAnnotation", Nt)) || !l && e.match((S) => S.type === "ObjectPattern", (S) => S.type === "AssignmentExpression" || S.type === "VariableDeclarator") ? P : c(P, { shouldBreak: l });
+}
+function Em(e, t, r) {
+  let n = r.originalText, s = L(e), i = L(t);
+  if (Lo(e)) {
+    let u = L(e), o = jt(r, u, i);
+    s = u + o.lastIndexOf("{");
+  }
+  return re(n, s, i);
+}
+function Oo(e, t, r) {
+  let { node: n } = e;
+  return ["import", n.phase ? ` ${n.phase}` : "", Gs(n), _o(e, t, r), Mo(e, t, r), vo(e, t, r), t.semi ? ";" : ""];
+}
+var wo = (e) => e.type === "ExportDefaultDeclaration" || e.type === "DeclareExportDeclaration" && e.default;
+function bn(e, t, r) {
+  let { node: n } = e, s = [ju(e, t, r), z(e), "export", wo(n) ? " default" : ""], { declaration: i, exported: u } = n;
+  return C(n, T.Dangling) && (s.push(" ", v(e, t)), Rr(n) && s.push(y)), i ? s.push(" ", r("declaration")) : (s.push(Cm(n)), n.type === "ExportAllDeclaration" || n.type === "DeclareExportAllDeclaration" ? (s.push(" *"), u && s.push(" as ", r("exported"))) : s.push(_o(e, t, r)), s.push(Mo(e, t, r), vo(e, t, r))), s.push(dm(n, t)), s;
+}
+var Fm = b(["ClassDeclaration", "ComponentDeclaration", "FunctionDeclaration", "TSInterfaceDeclaration", "DeclareClass", "DeclareComponent", "DeclareFunction", "DeclareHook", "HookDeclaration", "TSDeclareFunction", "EnumDeclaration"]);
+function dm(e, t) {
+  return t.semi && (!e.declaration || wo(e) && !Fm(e.declaration)) ? ";" : "";
+}
+function Js(e, t = true) {
+  return e && e !== "value" ? `${t ? " " : ""}${e}${t ? "" : " "}` : "";
+}
+function Gs(e, t) {
+  return Js(e.importKind, t);
+}
+function Cm(e) {
+  return Js(e.exportKind);
+}
+function Mo(e, t, r) {
+  let { node: n } = e;
+  return n.source ? [No(n, t) ? " from" : "", " ", r("source")] : "";
+}
+function _o(e, t, r) {
+  let { node: n } = e;
+  if (!No(n, t)) return "";
+  let s = [" "];
+  if (j(n.specifiers)) {
+    let i = [], u = [];
+    e.each(() => {
+      let o = e.node.type;
+      if (o === "ExportNamespaceSpecifier" || o === "ExportDefaultSpecifier" || o === "ImportNamespaceSpecifier" || o === "ImportDefaultSpecifier") i.push(r());
+      else if (o === "ExportSpecifier" || o === "ImportSpecifier") u.push(r());
+      else throw new $e(n, "specifier");
+    }, "specifiers"), s.push(I(", ", i)), u.length > 0 && (i.length > 0 && s.push(", "), u.length > 1 || i.length > 0 || n.specifiers.some((a) => C(a)) ? s.push(c(["{", m([t.bracketSpacing ? A : f, I([",", A], u)]), B(ue(t) ? "," : ""), t.bracketSpacing ? A : f, "}"])) : s.push(["{", t.bracketSpacing ? " " : "", ...u, t.bracketSpacing ? " " : "", "}"]));
+  } else s.push("{}");
+  return s;
+}
+function No(e, t) {
+  return e.type !== "ImportDeclaration" || j(e.specifiers) || e.importKind === "type" ? true : jt(t, L(e), L(e.source)).trimEnd().endsWith("from");
+}
+function Am(e, t) {
+  if (e.extra?.deprecatedAssertSyntax) return "assert";
+  let r = jt(t, k(e.source), e.attributes?.[0] ? L(e.attributes[0]) : k(e)).trimStart();
+  return r.startsWith("assert") ? "assert" : r.startsWith("with") || j(e.attributes) ? "with" : void 0;
+}
+var Tm = (e) => {
+  let { attributes: t } = e;
+  if (t.length !== 1) return false;
+  let [r] = t, { type: n, key: s, value: i } = r;
+  return n === "ImportAttribute" && (s.type === "Identifier" && s.name === "type" || X(s) && s.value === "type") && X(i) && !C(r) && !C(s) && !C(i);
+};
+function vo(e, t, r) {
+  let { node: n } = e;
+  if (!n.source) return "";
+  let s = Am(n, t);
+  if (!s) return "";
+  let i = sr(e, t, r);
+  return Tm(n) && (i = Ot(i)), [` ${s} `, i];
+}
+function jo(e, t, r) {
+  let { node: n } = e, { type: s } = n, i = s.startsWith("Import"), u = i ? "imported" : "local", o = i ? "local" : "exported", a = n[u], p = n[o], D = "", l = "";
+  return s === "ExportNamespaceSpecifier" || s === "ImportNamespaceSpecifier" ? D = "*" : a && (D = r(u)), p && !xm(n) && (l = r(o)), [Js(s === "ImportSpecifier" ? n.importKind : n.exportKind, false), D, D && l ? " as " : "", l];
+}
+function xm(e) {
+  if (e.type !== "ImportSpecifier" && e.type !== "ExportSpecifier") return false;
+  let { local: t, [e.type === "ImportSpecifier" ? "imported" : "exported"]: r } = e;
+  if (t.type !== r.type || !ii(t, r)) return false;
+  if (X(t)) return t.value === r.value && pe(t) === pe(r);
+  switch (t.type) {
+    case "Identifier":
+      return t.name === r.name;
+    default:
+      return false;
+  }
+}
+function gm(e) {
+  let t = [e];
+  for (let r = 0; r < t.length; r++) {
+    let n = t[r];
+    for (let s of ["test", "consequent", "alternate"]) {
+      let i = n[s];
+      if (q(i)) return true;
+      i.type === "ConditionalExpression" && t.push(i);
+    }
+  }
+  return false;
+}
+function hm(e, t, r) {
+  let { node: n } = e, s = n.type === "ConditionalExpression", i = s ? "alternate" : "falseType", { parent: u } = e, o = s ? r("test") : [r("checkType"), " ", "extends", " ", r("extendsType")];
+  return u.type === n.type && u[i] === n ? ge(2, o) : o;
+}
+var Sm = /* @__PURE__ */ new Map([["AssignmentExpression", "right"], ["VariableDeclarator", "init"], ["ReturnStatement", "argument"], ["ThrowStatement", "argument"], ["UnaryExpression", "argument"], ["YieldExpression", "argument"], ["AwaitExpression", "argument"]]);
+function Bm(e) {
+  let { node: t } = e;
+  if (t.type !== "ConditionalExpression") return false;
+  let r, n = t;
+  for (let s = 0; !r; s++) {
+    let i = e.getParentNode(s);
+    if (i.type === "ChainExpression" && i.expression === n || M(i) && i.callee === n || R(i) && i.object === n || i.type === "TSNonNullExpression" && i.expression === n) {
+      n = i;
+      continue;
+    }
+    i.type === "NewExpression" && i.callee === n || Ae(i) && i.expression === n ? (r = e.getParentNode(s + 1), n = i) : r = i;
+  }
+  return n === t ? false : r[Sm.get(r.type)] === n;
+}
+function Ro(e, t, r) {
+  let { node: n } = e, s = n.type === "ConditionalExpression", i = s ? "consequent" : "trueType", u = s ? "alternate" : "falseType", o = s ? ["test"] : ["checkType", "extendsType"], a = n[i], p = n[u], D = [], l = false, { parent: E } = e, d = E.type === n.type && o.some((J) => E[J] === n), F = E.type === n.type && !d, P, S, O = 0;
+  do
+    S = P || n, P = e.getParentNode(O), O++;
+  while (P && P.type === n.type && o.every((J) => P[J] !== S));
+  let g = P || E, x = S;
+  if (s && (q(n[o[0]]) || q(a) || q(p) || gm(x))) {
+    l = true, F = true;
+    let J = (H) => [B("("), m([f, H]), f, B(")")], Z = (H) => H.type === "NullLiteral" || H.type === "Literal" && H.value === null || H.type === "Identifier" && H.name === "undefined";
+    D.push(" ? ", Z(a) ? r(i) : J(r(i)), " : ", p.type === n.type || Z(p) ? r(u) : J(r(u)));
+  } else {
+    let J = (H) => t.useTabs ? m(r(H)) : ge(2, r(H)), Z = [A, "? ", a.type === n.type ? B("", "(") : "", J(i), a.type === n.type ? B("", ")") : "", A, ": ", J(u)];
+    D.push(E.type !== n.type || E[u] === n || d ? Z : t.useTabs ? Ur(m(Z)) : ge(Math.max(0, t.tabWidth - 2), Z));
+  }
+  let h = [i, u, ...o].some((J) => C(n[J], (Z) => ee(Z) && re(t.originalText, L(Z), k(Z)))), N = (J) => E === g ? c(J, { shouldBreak: h }) : h ? [J, Te] : J, Y = !l && (R(E) || E.type === "NGPipeExpression" && E.left === n) && !E.computed, De = Bm(e), Fe = N([hm(e, t, r), F ? D : m(D), s && Y && !De ? f : ""]);
+  return d || De ? c([m([f, Fe]), f]) : Fe;
+}
+function bm(e, t) {
+  return (R(t) || t.type === "NGPipeExpression" && t.left === e) && !t.computed;
+}
+function Pm(e, t, r, n) {
+  return [...e.map((i) => Ze(i)), Ze(t), Ze(r)].flat().some((i) => ee(i) && re(n.originalText, L(i), k(i)));
+}
+var km = /* @__PURE__ */ new Map([["AssignmentExpression", "right"], ["VariableDeclarator", "init"], ["ReturnStatement", "argument"], ["ThrowStatement", "argument"], ["UnaryExpression", "argument"], ["YieldExpression", "argument"], ["AwaitExpression", "argument"]]);
+function Im(e) {
+  let { node: t } = e;
+  if (t.type !== "ConditionalExpression") return false;
+  let r, n = t;
+  for (let s = 0; !r; s++) {
+    let i = e.getParentNode(s);
+    if (i.type === "ChainExpression" && i.expression === n || M(i) && i.callee === n || R(i) && i.object === n || i.type === "TSNonNullExpression" && i.expression === n) {
+      n = i;
+      continue;
+    }
+    i.type === "NewExpression" && i.callee === n || Ae(i) && i.expression === n ? (r = e.getParentNode(s + 1), n = i) : r = i;
+  }
+  return n === t ? false : r[km.get(r.type)] === n;
+}
+var Ws = (e) => [B("("), m([f, e]), f, B(")")];
+function ir(e, t, r, n) {
+  if (!t.experimentalTernaries) return Ro(e, t, r);
+  let { node: s } = e, i = s.type === "ConditionalExpression", u = qe(s), o = i ? "consequent" : "trueType", a = i ? "alternate" : "falseType", p = i ? ["test"] : ["checkType", "extendsType"], D = s[o], l = s[a], E = p.map((pr) => s[pr]), { parent: d } = e, F = d.type === s.type, P = F && p.some((pr) => d[pr] === s), S = F && d[a] === s, O = D.type === s.type, g = l.type === s.type, x = g || S, h = t.tabWidth > 2 || t.useTabs, N, Y, De = 0;
+  do
+    Y = N || s, N = e.getParentNode(De), De++;
+  while (N && N.type === s.type && p.every((pr) => N[pr] !== Y));
+  let Fe = N || d, J = n && n.assignmentLayout && n.assignmentLayout !== "break-after-operator" && (d.type === "AssignmentExpression" || d.type === "VariableDeclarator" || d.type === "ClassProperty" || d.type === "PropertyDefinition" || d.type === "ClassPrivateProperty" || d.type === "ObjectProperty" || d.type === "Property"), Z = (d.type === "ReturnStatement" || d.type === "ThrowStatement") && !(O || g), H = i && Fe.type === "JSXExpressionContainer" && e.grandparent.type !== "JSXAttribute", nt = Im(e), w = bm(s, d), ne = u && he(e, t), ae = h ? t.useTabs ? "	" : " ".repeat(t.tabWidth - 1) : "", st = Pm(E, D, l, t) || O || g, ht = !x && !F && !u && (H ? D.type === "NullLiteral" || D.type === "Literal" && D.value === null : fr(D, t) && Hn(s.test, 3)), wn = x || S || u && !F || F && i && Hn(s.test, 1) || ht, Sr = [];
+  !O && C(D, T.Dangling) && e.call(() => {
+    Sr.push(v(e, t), y);
+  }, "consequent");
+  let or = [];
+  C(s.test, T.Dangling) && e.call(() => {
+    or.push(v(e, t));
+  }, "test"), !g && C(l, T.Dangling) && e.call(() => {
+    or.push(v(e, t));
+  }, "alternate"), C(s, T.Dangling) && or.push(v(e, t));
+  let Hs = Symbol("test"), ca = Symbol("consequent"), Br = Symbol("test-and-consequent"), la = i ? [Ws(r("test")), s.test.type === "ConditionalExpression" ? Te : ""] : [r("checkType"), " ", "extends", " ", qe(s.extendsType) || s.extendsType.type === "TSMappedType" ? r("extendsType") : c(Ws(r("extendsType")))], Xs = c([la, " ?"], { id: Hs }), ma = r(o), br = m([O || H && (q(D) || F || x) ? y : A, Sr, ma]), Da = wn ? c([Xs, x ? br : B(br, c(br, { id: ca }), { groupId: Hs })], { id: Br }) : [Xs, br], Mn = r(a), Vs = ht ? B(Mn, Ur(Ws(Mn)), { groupId: Br }) : Mn, ar = [Da, or.length > 0 ? [m([y, or]), y] : g ? y : ht ? B(A, " ", { groupId: Br }) : A, ":", g ? " " : h ? wn ? B(ae, B(x || ht ? " " : ae, " "), { groupId: Br }) : B(ae, " ") : " ", g ? Vs : c([m(Vs), H && !ht ? f : ""]), w && !nt ? f : "", st ? Te : ""];
+  return J && !st ? c(m([f, c(ar)])) : J || Z ? c(m(ar)) : nt || u && P ? c([m([f, ar]), ne ? f : ""]) : d === Fe ? c(ar) : ar;
+}
+function Jo(e, t, r, n) {
+  let { node: s } = e;
+  if (Nr(s)) return Io(e, t);
+  switch (s.type) {
+    case "JsExpressionRoot":
+      return r("node");
+    case "JsonRoot":
+      return [v(e, t), r("node"), y];
+    case "File":
+      return bo(e, t, r) ?? r("program");
+    case "ExpressionStatement":
+      return Bo(e, t, r);
+    case "ChainExpression":
+      return r("expression");
+    case "ParenthesizedExpression":
+      return !C(s.expression) && (ie(s.expression) || W(s.expression)) ? ["(", r("expression"), ")"] : c(["(", m([f, r("expression")]), f, ")"]);
+    case "AssignmentExpression":
+      return Ku(e, t, r);
+    case "VariableDeclarator":
+      return Qu(e, t, r);
+    case "BinaryExpression":
+    case "LogicalExpression":
+      return en(e, t, r);
+    case "AssignmentPattern":
+      return [r("left"), " = ", r("right")];
+    case "OptionalMemberExpression":
+    case "MemberExpression":
+      return Yu(e, t, r);
+    case "MetaProperty":
+      return [r("meta"), ".", r("property")];
+    case "BindExpression":
+      return [r("object"), c(m([f, tn(e, t, r)]))];
+    case "Identifier":
+      return [s.name, $(e), ln(e), U(e, r)];
+    case "V8IntrinsicIdentifier":
+      return ["%", s.name];
+    case "SpreadElement":
+    case "SpreadElementPattern":
+    case "SpreadPropertyPattern":
+    case "RestElement":
+      return hn(e, r);
+    case "FunctionDeclaration":
+    case "FunctionExpression":
+      return un(e, t, r, n);
+    case "ArrowFunctionExpression":
+      return Ao(e, t, r, n);
+    case "YieldExpression":
+      return [`yield${s.delegate ? "*" : ""}`, s.argument ? [" ", r("argument")] : ""];
+    case "AwaitExpression": {
+      let i = ["await"];
+      if (s.argument) {
+        i.push(" ", r("argument"));
+        let { parent: u } = e;
+        if (M(u) && u.callee === s || R(u) && u.object === s) {
+          i = [m([f, ...i]), f];
+          let o = e.findAncestor((a) => a.type === "AwaitExpression" || a.type === "BlockStatement");
+          if (o?.type !== "AwaitExpression" || !fe(o.argument, (a) => a === s)) return c(i);
+        }
+      }
+      return i;
+    }
+    case "ExportDefaultDeclaration":
+    case "ExportNamedDeclaration":
+    case "ExportAllDeclaration":
+      return bn(e, t, r);
+    case "ImportDeclaration":
+      return Oo(e, t, r);
+    case "ImportSpecifier":
+    case "ExportSpecifier":
+    case "ImportNamespaceSpecifier":
+    case "ExportNamespaceSpecifier":
+    case "ImportDefaultSpecifier":
+    case "ExportDefaultSpecifier":
+      return jo(e, t, r);
+    case "ImportAttribute":
+      return sn(e, t, r);
+    case "Program":
+    case "BlockStatement":
+    case "StaticBlock":
+      return Sn(e, t, r);
+    case "ClassBody":
+      return vt(e, t, r);
+    case "ThrowStatement":
+      return ao(e, t, r);
+    case "ReturnStatement":
+      return oo(e, t, r);
+    case "NewExpression":
+    case "ImportExpression":
+    case "OptionalCallExpression":
+    case "CallExpression":
+      return _t(e, t, r);
+    case "ObjectExpression":
+    case "ObjectPattern":
+      return sr(e, t, r);
+    case "Property":
+      return lt(s) ? gr(e, t, r) : sn(e, t, r);
+    case "ObjectProperty":
+      return sn(e, t, r);
+    case "ObjectMethod":
+      return gr(e, t, r);
+    case "Decorator":
+      return ["@", r("expression")];
+    case "ArrayExpression":
+    case "ArrayPattern":
+      return nr(e, t, r);
+    case "SequenceExpression": {
+      let { parent: i } = e;
+      if (i.type === "ExpressionStatement" || i.type === "ForStatement") {
+        let o = [];
+        return e.each(({ isFirst: a }) => {
+          a ? o.push(r()) : o.push(",", m([A, r()]));
+        }, "expressions"), c(o);
+      }
+      let u = I([",", A], e.map(r, "expressions"));
+      return (i.type === "ReturnStatement" || i.type === "ThrowStatement") && e.key === "argument" || i.type === "ArrowFunctionExpression" && e.key === "body" ? c(B([m([f, u]), f], u)) : c(u);
+    }
+    case "ThisExpression":
+      return "this";
+    case "Super":
+      return "super";
+    case "Directive":
+      return [r("value"), t.semi ? ";" : ""];
+    case "UnaryExpression": {
+      let i = [s.operator];
+      return /[a-z]$/u.test(s.operator) && i.push(" "), C(s.argument) ? i.push(c(["(", m([f, r("argument")]), f, ")"])) : i.push(r("argument")), i;
+    }
+    case "UpdateExpression":
+      return [s.prefix ? s.operator : "", r("argument"), s.prefix ? "" : s.operator];
+    case "ConditionalExpression":
+      return ir(e, t, r, n);
+    case "VariableDeclaration": {
+      let i = e.map(r, "declarations"), u = e.parent, o = u.type === "ForStatement" || u.type === "ForInStatement" || u.type === "ForOfStatement", a = s.declarations.some((D) => D.init), p;
+      return i.length === 1 && !C(s.declarations[0]) ? p = i[0] : i.length > 0 && (p = m(i[0])), c([z(e), s.kind, p ? [" ", p] : "", m(i.slice(1).map((D) => [",", a && !o ? y : A, D])), t.semi && !(o && u.body !== s) ? ";" : ""]);
+    }
+    case "WithStatement":
+      return c(["with (", r("object"), ")", dt(s.body, r("body"))]);
+    case "IfStatement": {
+      let i = dt(s.consequent, r("consequent")), o = [c(["if (", c([m([f, r("test")]), f]), ")", i])];
+      if (s.alternate) {
+        let a = C(s.consequent, T.Trailing | T.Line) || Rr(s), p = s.consequent.type === "BlockStatement" && !a;
+        o.push(p ? " " : y), C(s, T.Dangling) && o.push(v(e, t), a ? y : " "), o.push("else", c(dt(s.alternate, r("alternate"), s.alternate.type === "IfStatement")));
+      }
+      return o;
+    }
+    case "ForStatement": {
+      let i = dt(s.body, r("body")), u = v(e, t), o = u ? [u, f] : "";
+      return !s.init && !s.test && !s.update ? [o, c(["for (;;)", i])] : [o, c(["for (", c([m([f, r("init"), ";", A, r("test"), ";", s.update ? [A, r("update")] : B("", A)]), f]), ")", i])];
+    }
+    case "WhileStatement":
+      return c(["while (", c([m([f, r("test")]), f]), ")", dt(s.body, r("body"))]);
+    case "ForInStatement":
+      return c(["for (", r("left"), " in ", r("right"), ")", dt(s.body, r("body"))]);
+    case "ForOfStatement":
+      return c(["for", s.await ? " await" : "", " (", r("left"), " of ", r("right"), ")", dt(s.body, r("body"))]);
+    case "DoWhileStatement": {
+      let i = dt(s.body, r("body"));
+      return [c(["do", i]), s.body.type === "BlockStatement" ? " " : y, "while (", c([m([f, r("test")]), f]), ")", t.semi ? ";" : ""];
+    }
+    case "DoExpression":
+      return [s.async ? "async " : "", "do ", r("body")];
+    case "BreakStatement":
+    case "ContinueStatement":
+      return [s.type === "BreakStatement" ? "break" : "continue", s.label ? [" ", r("label")] : "", t.semi ? ";" : ""];
+    case "LabeledStatement":
+      return [r("label"), `:${s.body.type === "EmptyStatement" && !C(s.body, T.Leading) ? "" : " "}`, r("body")];
+    case "TryStatement":
+      return ["try ", r("block"), s.handler ? [" ", r("handler")] : "", s.finalizer ? [" finally ", r("finalizer")] : ""];
+    case "CatchClause":
+      if (s.param) {
+        let i = C(s.param, (o) => !ee(o) || o.leading && Q(t.originalText, k(o)) || o.trailing && Q(t.originalText, L(o), { backwards: true })), u = r("param");
+        return ["catch ", i ? ["(", m([f, u]), f, ") "] : ["(", u, ") "], r("body")];
+      }
+      return ["catch ", r("body")];
+    case "SwitchStatement":
+      return [c(["switch (", m([f, r("discriminant")]), f, ")"]), " {", s.cases.length > 0 ? m([y, I(y, e.map(({ node: i, isLast: u }) => [r(), !u && oe(i, t) ? y : ""], "cases"))]) : "", y, "}"];
+    case "SwitchCase": {
+      let i = [];
+      s.test ? i.push("case ", r("test"), ":") : i.push("default:"), C(s, T.Dangling) && i.push(" ", v(e, t));
+      let u = s.consequent.filter((o) => o.type !== "EmptyStatement");
+      if (u.length > 0) {
+        let o = hr(e, t, r, "consequent");
+        i.push(u.length === 1 && u[0].type === "BlockStatement" ? [" ", o] : m([y, o]));
+      }
+      return i;
+    }
+    case "DebuggerStatement":
+      return ["debugger", t.semi ? ";" : ""];
+    case "ClassDeclaration":
+    case "ClassExpression":
+      return er(e, t, r);
+    case "ClassMethod":
+    case "ClassPrivateMethod":
+    case "MethodDefinition":
+      return pn(e, t, r);
+    case "ClassProperty":
+    case "PropertyDefinition":
+    case "ClassPrivateProperty":
+    case "ClassAccessorProperty":
+    case "AccessorProperty":
+      return cn(e, t, r);
+    case "TemplateElement":
+      return Ge(s.value.raw);
+    case "TemplateLiteral":
+      return $r(e, t, r);
+    case "TaggedTemplateExpression":
+      return ru(e, t, r);
+    case "PrivateIdentifier":
+      return ["#", s.name];
+    case "PrivateName":
+      return ["#", r("id")];
+    case "TopicReference":
+      return "%";
+    case "ArgumentPlaceholder":
+      return "?";
+    case "ModuleExpression":
+      return ["module ", r("body")];
+    case "VoidPattern":
+      return "void";
+    case "EmptyStatement":
+      if (bt(e)) return ";";
+    case "InterpreterDirective":
+    default:
+      throw new $e(s, "ESTree");
+  }
+}
+var Lm = b(["SatisfiesExpression", "TSSatisfiesExpression"]);
+function Pn(e, t, r) {
+  let { parent: n, node: s, key: i } = e, o = s.type === "AsConstExpression" ? "const" : r("typeAnnotation"), a = [r("expression"), " ", Lm(s) ? "satisfies" : "as", " ", o];
+  return i === "callee" && M(n) || i === "object" && R(n) ? c([m([f, ...a]), f]) : a;
+}
+function Go(e, t, r) {
+  let { node: n } = e, s = [z(e), "component"];
+  n.id && s.push(" ", r("id")), s.push(r("typeParameters"));
+  let i = Om(e, t, r);
+  return n.rendersType ? s.push(c([i, " ", r("rendersType")])) : s.push(c([i])), n.body && s.push(" ", r("body")), t.semi && n.type === "DeclareComponent" && s.push(";"), s;
+}
+function Om(e, t, r) {
+  let { node: n } = e, s = n.params;
+  if (n.rest && (s = [...s, n.rest]), s.length === 0) return ["(", v(e, t, { filter: (u) => Ne(t.originalText, k(u)) === ")" }), ")"];
+  let i = [];
+  return Mm(e, (u, o) => {
+    let a = o === s.length - 1;
+    a && n.rest && i.push("..."), i.push(r()), !a && (i.push(","), oe(s[o], t) ? i.push(y, y) : i.push(A));
+  }), ["(", m([f, ...i]), B(ue(t, "all") && !wm(n, s) ? "," : ""), f, ")"];
+}
+function wm(e, t) {
+  return e.rest || _(0, t, -1)?.type === "RestElement";
+}
+function Mm(e, t) {
+  let { node: r } = e, n = 0, s = (i) => t(i, n++);
+  e.each(s, "params"), r.rest && e.call(s, "rest");
+}
+function Wo(e, t, r) {
+  let { node: n } = e;
+  return n.shorthand ? r("local") : [r("name"), " as ", r("local")];
+}
+function qo(e, t, r) {
+  let { node: n } = e, s = [];
+  return n.name && s.push(r("name"), n.optional ? "?: " : ": "), s.push(r("typeAnnotation")), s;
+}
+function kn(e, t, r) {
+  return sr(e, t, r);
+}
+function In(e, t) {
+  let { node: r } = e, n = t("id");
+  r.computed && (n = ["[", n, "]"]);
+  let s = "";
+  return r.initializer && (s = t("initializer")), r.init && (s = t("init")), s ? [n, " = ", s] : n;
+}
+function Ln(e, t) {
+  let { node: r } = e;
+  return [z(e), r.const ? "const " : "", "enum ", t("id"), " ", t("body")];
+}
+function Uo(e, t, r) {
+  let { node: n } = e, s = ["hook"];
+  n.id && s.push(" ", r("id"));
+  let i = Ke(e, t, r, false, true), u = Zt(e, r), o = ct(n, u);
+  return s.push(c([o ? c(i) : i, u]), n.body ? " " : "", r("body")), s;
+}
+function Ho(e, t, r) {
+  let { node: n } = e, s = [z(e), "hook"];
+  return n.id && s.push(" ", r("id")), t.semi && s.push(";"), s;
+}
+function Yo(e) {
+  let { node: t } = e;
+  return t.type === "HookTypeAnnotation" && e.getParentNode(2)?.type === "DeclareHook";
+}
+function Xo(e, t, r) {
+  let { node: n } = e, s = Ke(e, t, r, false, true), i = [Yo(e) ? ": " : " => ", r("returnType")];
+  return c([Yo(e) ? "" : "hook ", ct(n, i) ? c(s) : s, i]);
+}
+function _m(e) {
+  switch (e) {
+    case null:
+      return "";
+    case "PlusOptional":
+      return "+?";
+    case "MinusOptional":
+      return "-?";
+    case "Optional":
+      return "?";
+  }
+}
+function $o(e, t, r) {
+  let { node: n } = e;
+  return [c([n.variance ? r("variance") : "", "[", m([r("keyTparam"), " in ", r("sourceType")]), "]", _m(n.optional), ": ", r("propType")]), ve(e, t)];
+}
+function Vo(e, t) {
+  return e === "+" || e === "-" ? e + t : t;
+}
+function Ko(e, t, r) {
+  let { node: n } = e, s = false;
+  if (t.objectWrap === "preserve") {
+    let i = L(n), u = jt(t, i + 1, L(n.key)), o = i + 1 + u.search(/\S/u);
+    re(t.originalText, i, o) && (s = true);
+  }
+  return c(["{", m([t.bracketSpacing ? A : f, C(n, T.Dangling) ? c([v(e, t), y]) : "", c([n.readonly ? [Vo(n.readonly, "readonly"), " "] : "", "[", r("key"), " in ", r("constraint"), n.nameType ? [" as ", r("nameType")] : "", "]", n.optional ? Vo(n.optional, "?") : "", n.typeAnnotation ? ": " : "", r("typeAnnotation")]), t.semi ? B(";") : ""]), t.bracketSpacing ? A : f, "}"], { shouldBreak: s });
+}
+function Qo(e, t, r) {
+  let { node: n } = e;
+  return [c(["match (", m([f, r("argument")]), f, ")"]), " {", n.cases.length > 0 ? m([y, I(y, e.map(({ node: s, isLast: i }) => [r(), !i && oe(s, t) ? y : ""], "cases"))]) : "", y, "}"];
+}
+function zo(e, t, r) {
+  let { node: n } = e, s = C(n, T.Dangling) ? [" ", v(e, t)] : [], i = n.type === "MatchStatementCase" ? [" ", r("body")] : m([A, r("body"), ","]);
+  return [r("pattern"), n.guard ? c([m([A, "if (", r("guard"), ")"])]) : "", c([" =>", s, i])];
+}
+function Zo(e, t, r) {
+  let { node: n } = e;
+  switch (n.type) {
+    case "MatchOrPattern":
+      return jm(e, t, r);
+    case "MatchAsPattern":
+      return [r("pattern"), " as ", r("target")];
+    case "MatchWildcardPattern":
+      return ["_"];
+    case "MatchLiteralPattern":
+      return r("literal");
+    case "MatchUnaryPattern":
+      return [n.operator, r("argument")];
+    case "MatchIdentifierPattern":
+      return r("id");
+    case "MatchMemberPattern": {
+      let s = n.property.type === "Identifier" ? [".", r("property")] : ["[", m([f, r("property")]), f, "]"];
+      return c([r("base"), s]);
+    }
+    case "MatchBindingPattern":
+      return [n.kind, " ", r("id")];
+    case "MatchObjectPattern": {
+      let s = e.map(r, "properties");
+      return n.rest && s.push(r("rest")), c(["{", m([f, I([",", A], s)]), n.rest ? "" : B(","), f, "}"]);
+    }
+    case "MatchArrayPattern": {
+      let s = e.map(r, "elements");
+      return n.rest && s.push(r("rest")), c(["[", m([f, I([",", A], s)]), n.rest ? "" : B(","), f, "]"]);
+    }
+    case "MatchObjectPatternProperty":
+      return n.shorthand ? r("pattern") : c([r("key"), ":", m([A, r("pattern")])]);
+    case "MatchRestPattern": {
+      let s = ["..."];
+      return n.argument && s.push(r("argument")), s;
+    }
+  }
+}
+var ea = b(["MatchWildcardPattern", "MatchLiteralPattern", "MatchUnaryPattern", "MatchIdentifierPattern"]);
+function Nm(e) {
+  let { patterns: t } = e;
+  if (t.some((n) => C(n))) return false;
+  let r = t.find((n) => n.type === "MatchObjectPattern");
+  return r ? t.every((n) => n === r || ea(n)) : false;
+}
+function vm(e) {
+  return ea(e) || e.type === "MatchObjectPattern" ? true : e.type === "MatchOrPattern" ? Nm(e) : false;
+}
+function jm(e, t, r) {
+  let { node: n } = e, { parent: s } = e, i = s.type !== "MatchStatementCase" && s.type !== "MatchExpressionCase" && s.type !== "MatchArrayPattern" && s.type !== "MatchObjectPatternProperty" && !Ce(t.originalText, n), u = vm(n), o = e.map(() => {
+    let p = r();
+    return u || (p = ge(2, p)), me(e, p, t);
+  }, "patterns");
+  if (u) return I(" | ", o);
+  let a = [B(["| "]), I([A, "| "], o)];
+  return he(e, t) ? c([m([B([f]), a]), f]) : s.type === "MatchArrayPattern" && s.elements.length > 1 ? c([m([B(["(", f]), a]), f, B(")")]) : c(i ? m(a) : a);
+}
+function Rm(e, t, r) {
+  let { node: n } = e;
+  return K(n).length === 1 && n.type.startsWith("TS") && !n[r][0].constraint && e.parent.type === "ArrowFunctionExpression" && !(t.filepath && /\.ts$/u.test(t.filepath));
+}
+function Rt(e, t, r, n) {
+  let { node: s } = e;
+  if (!s[n]) return "";
+  if (!Array.isArray(s[n])) return r(n);
+  let i = Pt(e.grandparent), u = e.match((p) => !(p[n].length === 1 && We(p[n][0])), void 0, (p, D) => D === "typeAnnotation", (p) => p.type === "Identifier", ks);
+  if (s[n].length === 0 || !u && (i || s[n].length === 1 && (s[n][0].type === "NullableTypeAnnotation" || Os(s[n][0])))) return ["<", I(", ", e.map(r, n)), Jm(e, t), ">"];
+  let a = s.type === "TSTypeParameterInstantiation" ? "" : Rm(e, t, n) ? "," : ue(t) ? B(",") : "";
+  return c(["<", m([f, I([",", A], e.map(r, n))]), a, f, ">"]);
+}
+function Jm(e, t) {
+  let { node: r } = e;
+  if (!C(r, T.Dangling)) return "";
+  let n = !C(r, T.Line), s = v(e, t, { indent: !n });
+  return n ? s : [s, y];
+}
+function On(e, t, r) {
+  let { node: n } = e, s = [n.const ? "const " : ""], i = n.type === "TSTypeParameter" ? r("name") : n.name;
+  if (n.variance && s.push(r("variance")), n.in && s.push("in "), n.out && s.push("out "), s.push(i), n.bound && (n.usesExtendsBound && s.push(" extends "), s.push(U(e, r, "bound"))), n.constraint) {
+    let u = Symbol("constraint");
+    s.push(" extends", c(m(A), { id: u }), we, ft(r("constraint"), { groupId: u }));
+  }
+  if (n.default) {
+    let u = Symbol("default");
+    s.push(" =", c(m(A), { id: u }), we, ft(r("default"), { groupId: u }));
+  }
+  return c(s);
+}
+function ta(e, t, r) {
+  let { node: n } = e;
+  if (Or(n)) return n.type.slice(0, -14).toLowerCase();
+  switch (n.type) {
+    case "ComponentDeclaration":
+    case "DeclareComponent":
+    case "ComponentTypeAnnotation":
+      return Go(e, t, r);
+    case "ComponentParameter":
+      return Wo(e, t, r);
+    case "ComponentTypeParameter":
+      return qo(e, t, r);
+    case "HookDeclaration":
+      return Uo(e, t, r);
+    case "DeclareHook":
+      return Ho(e, t, r);
+    case "HookTypeAnnotation":
+      return Xo(e, t, r);
+    case "DeclareFunction":
+      return [z(e), "function ", r("id"), r("predicate"), t.semi ? ";" : ""];
+    case "DeclareModule":
+      return ["declare module ", r("id"), " ", r("body")];
+    case "DeclareModuleExports":
+      return ["declare module.exports", U(e, r), t.semi ? ";" : ""];
+    case "DeclareNamespace":
+      return ["declare namespace ", r("id"), " ", r("body")];
+    case "DeclareVariable":
+      return [z(e), n.kind ?? "var", " ", r("id"), t.semi ? ";" : ""];
+    case "DeclareExportDeclaration":
+    case "DeclareExportAllDeclaration":
+      return bn(e, t, r);
+    case "DeclareOpaqueType":
+    case "OpaqueType":
+      return yo(e, t, r);
+    case "DeclareTypeAlias":
+    case "TypeAlias":
+      return mn(e, t, r);
+    case "IntersectionTypeAnnotation":
+      return Dn(e, t, r);
+    case "UnionTypeAnnotation":
+      return fn(e, t, r);
+    case "ConditionalTypeAnnotation":
+      return ir(e, t, r);
+    case "InferTypeAnnotation":
+      return Fn(e, t, r);
+    case "FunctionTypeAnnotation":
+      return yn(e, t, r);
+    case "TupleTypeAnnotation":
+      return nr(e, t, r);
+    case "TupleTypeLabeledElement":
+      return Cn(e, t, r);
+    case "TupleTypeSpreadElement":
+      return dn(e, t, r);
+    case "GenericTypeAnnotation":
+      return [r("id"), Rt(e, t, r, "typeParameters")];
+    case "IndexedAccessType":
+    case "OptionalIndexedAccessType":
+      return En(e, t, r);
+    case "TypeAnnotation":
+      return An(e, t, r);
+    case "TypeParameter":
+      return On(e, t, r);
+    case "TypeofTypeAnnotation":
+      return xn(e, r);
+    case "ExistsTypeAnnotation":
+      return "*";
+    case "ArrayTypeAnnotation":
+      return Tn(r);
+    case "DeclareEnum":
+    case "EnumDeclaration":
+      return Ln(e, r);
+    case "EnumBooleanBody":
+    case "EnumNumberBody":
+    case "EnumBigIntBody":
+    case "EnumStringBody":
+    case "EnumSymbolBody":
+      return [n.type === "EnumSymbolBody" || n.explicitType ? `of ${n.type.slice(4, -4).toLowerCase()} ` : "", kn(e, t, r)];
+    case "EnumBooleanMember":
+    case "EnumNumberMember":
+    case "EnumBigIntMember":
+    case "EnumStringMember":
+    case "EnumDefaultedMember":
+      return In(e, r);
+    case "FunctionTypeParam": {
+      let s = n.name ? r("name") : e.parent.this === n ? "this" : "";
+      return [s, $(e), s ? ": " : "", r("typeAnnotation")];
+    }
+    case "DeclareClass":
+    case "DeclareInterface":
+    case "InterfaceDeclaration":
+    case "InterfaceTypeAnnotation":
+      return er(e, t, r);
+    case "ObjectTypeAnnotation":
+      return vt(e, t, r);
+    case "ClassImplements":
+    case "InterfaceExtends":
+      return [r("id"), r("typeParameters")];
+    case "NullableTypeAnnotation":
+      return ["?", r("typeAnnotation")];
+    case "Variance": {
+      let { kind: s } = n;
+      return s === "plus" ? "+" : "-";
+    }
+    case "KeyofTypeAnnotation":
+      return ["keyof ", r("argument")];
+    case "ObjectTypeCallProperty":
+      return [n.static ? "static " : "", r("value"), ve(e, t)];
+    case "ObjectTypeMappedTypeProperty":
+      return $o(e, t, r);
+    case "ObjectTypeIndexer":
+      return [n.static ? "static " : "", n.variance ? r("variance") : "", "[", r("id"), n.id ? ": " : "", r("key"), "]: ", r("value"), ve(e, t)];
+    case "ObjectTypeProperty": {
+      let s = "";
+      return n.proto ? s = "proto " : n.static && (s = "static "), [s, n.kind !== "init" ? n.kind + " " : "", n.variance ? r("variance") : "", Ft(e, t, r), $(e), lt(n) ? "" : ": ", r("value"), ve(e, t)];
+    }
+    case "ObjectTypeInternalSlot":
+      return [n.static ? "static " : "", "[[", r("id"), "]]", $(e), n.method ? "" : ": ", r("value"), ve(e, t)];
+    case "ObjectTypeSpreadProperty":
+      return hn(e, r);
+    case "QualifiedTypeofIdentifier":
+    case "QualifiedTypeIdentifier":
+      return [r("qualification"), ".", r("id")];
+    case "NullLiteralTypeAnnotation":
+      return "null";
+    case "BooleanLiteralTypeAnnotation":
+      return String(n.value);
+    case "StringLiteralTypeAnnotation":
+      return Ge(ut(pe(n), t));
+    case "NumberLiteralTypeAnnotation":
+      return Et(pe(n));
+    case "BigIntLiteralTypeAnnotation":
+      return Bn(pe(n));
+    case "TypeCastExpression":
+      return ["(", r("expression"), U(e, r), ")"];
+    case "TypePredicate":
+      return gn(e, r);
+    case "TypeOperator":
+      return [n.operator, " ", r("typeAnnotation")];
+    case "TypeParameterDeclaration":
+    case "TypeParameterInstantiation":
+      return Rt(e, t, r, "params");
+    case "InferredPredicate":
+    case "DeclaredPredicate":
+      return [e.key === "predicate" && e.parent.type !== "DeclareFunction" && !e.parent.returnType ? ": " : " ", "%checks", ...n.type === "DeclaredPredicate" ? ["(", r("value"), ")"] : []];
+    case "AsExpression":
+    case "AsConstExpression":
+    case "SatisfiesExpression":
+      return Pn(e, t, r);
+    case "MatchExpression":
+    case "MatchStatement":
+      return Qo(e, t, r);
+    case "MatchExpressionCase":
+    case "MatchStatementCase":
+      return zo(e, t, r);
+    case "MatchOrPattern":
+    case "MatchAsPattern":
+    case "MatchWildcardPattern":
+    case "MatchLiteralPattern":
+    case "MatchUnaryPattern":
+    case "MatchIdentifierPattern":
+    case "MatchMemberPattern":
+    case "MatchBindingPattern":
+    case "MatchObjectPattern":
+    case "MatchObjectPatternProperty":
+    case "MatchRestPattern":
+    case "MatchArrayPattern":
+      return Zo(e, t, r);
+  }
+}
+function ra(e, t, r) {
+  let { node: n } = e;
+  if (n.type.startsWith("TS")) {
+    if (wr(n)) return n.type.slice(2, -7).toLowerCase();
+    switch (n.type) {
+      case "TSThisType":
+        return "this";
+      case "TSTypeAssertion": {
+        let s = !(W(n.expression) || ie(n.expression)), i = c(["<", m([f, r("typeAnnotation")]), f, ">"]), u = [B("("), m([f, r("expression")]), f, B(")")];
+        return s ? rt([[i, r("expression")], [i, c(u, { shouldBreak: true })], [i, r("expression")]]) : c([i, r("expression")]);
+      }
+      case "TSDeclareFunction":
+        return un(e, t, r);
+      case "TSExportAssignment":
+        return ["export = ", r("expression"), t.semi ? ";" : ""];
+      case "TSModuleBlock":
+        return Sn(e, t, r);
+      case "TSInterfaceBody":
+      case "TSTypeLiteral":
+        return vt(e, t, r);
+      case "TSTypeAliasDeclaration":
+        return mn(e, t, r);
+      case "TSQualifiedName":
+        return [r("left"), ".", r("right")];
+      case "TSAbstractMethodDefinition":
+      case "TSDeclareMethod":
+        return pn(e, t, r);
+      case "TSAbstractAccessorProperty":
+      case "TSAbstractPropertyDefinition":
+        return cn(e, t, r);
+      case "TSInterfaceHeritage":
+      case "TSClassImplements":
+      case "TSInstantiationExpression":
+        return [r("expression"), r("typeArguments")];
+      case "TSTemplateLiteralType":
+        return $r(e, t, r);
+      case "TSNamedTupleMember":
+        return Cn(e, t, r);
+      case "TSRestType":
+        return dn(e, t, r);
+      case "TSOptionalType":
+        return [r("typeAnnotation"), "?"];
+      case "TSInterfaceDeclaration":
+        return er(e, t, r);
+      case "TSTypeParameterDeclaration":
+      case "TSTypeParameterInstantiation":
+        return Rt(e, t, r, "params");
+      case "TSTypeParameter":
+        return On(e, t, r);
+      case "TSAsExpression":
+      case "TSSatisfiesExpression":
+        return Pn(e, t, r);
+      case "TSArrayType":
+        return Tn(r);
+      case "TSPropertySignature":
+        return [n.readonly ? "readonly " : "", Ft(e, t, r), $(e), U(e, r), ve(e, t)];
+      case "TSParameterProperty":
+        return [rr(n), n.static ? "static " : "", n.override ? "override " : "", n.readonly ? "readonly " : "", r("parameter")];
+      case "TSTypeQuery":
+        return xn(e, r);
+      case "TSIndexSignature": {
+        let s = n.parameters.length > 1 ? B(ue(t) ? "," : "") : "", i = c([m([f, I([", ", f], e.map(r, "parameters"))]), s, f]);
+        return [e.key === "body" && e.parent.type === "ClassBody" && n.static ? "static " : "", n.readonly ? "readonly " : "", "[", n.parameters ? i : "", "]", U(e, r), ve(e, t)];
+      }
+      case "TSTypePredicate":
+        return gn(e, r);
+      case "TSNonNullExpression":
+        return [r("expression"), "!"];
+      case "TSImportType":
+        return [_t(e, t, r), n.qualifier ? [".", r("qualifier")] : "", Rt(e, t, r, "typeArguments")];
+      case "TSLiteralType":
+        return r("literal");
+      case "TSIndexedAccessType":
+        return En(e, t, r);
+      case "TSTypeOperator":
+        return [n.operator, " ", r("typeAnnotation")];
+      case "TSMappedType":
+        return Ko(e, t, r);
+      case "TSMethodSignature": {
+        let s = [], i = n.kind && n.kind !== "method" ? `${n.kind} ` : "";
+        s.push(rr(n), i, n.computed ? "[" : "", r("key"), n.computed ? "]" : "", $(e));
+        let u = Ke(e, t, r, false, true), o = U(e, r, "returnType"), a = ct(n, o);
+        return s.push(a ? c(u) : u), n.returnType && s.push(c(o)), [c(s), ve(e, t)];
+      }
+      case "TSNamespaceExportDeclaration":
+        return ["export as namespace ", r("id"), t.semi ? ";" : ""];
+      case "TSEnumDeclaration":
+        return Ln(e, r);
+      case "TSEnumBody":
+        return kn(e, t, r);
+      case "TSEnumMember":
+        return In(e, r);
+      case "TSImportEqualsDeclaration":
+        return ["import ", Gs(n, false), r("id"), " = ", r("moduleReference"), t.semi ? ";" : ""];
+      case "TSExternalModuleReference":
+        return _t(e, t, r);
+      case "TSModuleDeclaration":
+        return [z(e), n.kind === "global" ? "" : `${n.kind} `, r("id"), n.body ? [" ", c(r("body"))] : t.semi ? ";" : ""];
+      case "TSConditionalType":
+        return ir(e, t, r);
+      case "TSInferType":
+        return Fn(e, t, r);
+      case "TSIntersectionType":
+        return Dn(e, t, r);
+      case "TSUnionType":
+        return fn(e, t, r);
+      case "TSFunctionType":
+      case "TSCallSignatureDeclaration":
+      case "TSConstructorType":
+      case "TSConstructSignatureDeclaration":
+        return yn(e, t, r);
+      case "TSTupleType":
+        return nr(e, t, r);
+      case "TSTypeReference":
+        return [r("typeName"), Rt(e, t, r, "typeArguments")];
+      case "TSTypeAnnotation":
+        return An(e, t, r);
+      case "TSEmptyBodyFunctionExpression":
+        return on(e, t, r);
+      case "TSJSDocAllType":
+        return "*";
+      case "TSJSDocUnknownType":
+        return "?";
+      case "TSJSDocNullableType":
+        return ws(e, r, "?");
+      case "TSJSDocNonNullableType":
+        return ws(e, r, "!");
+      case "TSParenthesizedType":
+      default:
+        throw new $e(n, "TypeScript");
+    }
+  }
+}
+function Gm(e, t, r, n) {
+  for (let s of [vu, wu, ta, ra, Jo]) {
+    let i = s(e, t, r, n);
+    if (i !== void 0) return i;
+  }
+}
+var Wm = b(["ClassMethod", "ClassPrivateMethod", "ClassProperty", "ClassAccessorProperty", "AccessorProperty", "TSAbstractAccessorProperty", "PropertyDefinition", "TSAbstractPropertyDefinition", "ClassPrivateProperty", "MethodDefinition", "TSAbstractMethodDefinition", "TSDeclareMethod"]);
+function qm(e, t, r, n) {
+  e.isRoot && t.__onHtmlBindingRoot?.(e.node, t);
+  let { node: s } = e, i = Qt(e) ? t.originalText.slice(L(s), k(s)) : Gm(e, t, r, n);
+  if (!i) return "";
+  if (Wm(s)) return i;
+  let u = j(s.decorators), o = Ru(e, t, r), a = s.type === "ClassExpression";
+  if (u && !a) return Fr(i, (l) => c([o, l]));
+  let p = he(e, t), D = ho(e, t);
+  return !o && !p && !D ? i : Fr(i, (l) => [D ? ";" : "", p ? "(" : "", p && a && u ? [m([A, o, l]), A] : [o, l], p ? ")" : ""]);
+}
+var qs = qm;
+var Ym = { experimental_avoidAstMutation: true };
+var na = [{ name: "JSON.stringify", type: "data", aceMode: "json", extensions: [".importmap"], filenames: ["package.json", "package-lock.json", "composer.json"], tmScope: "source.json", aliases: ["geojson", "jsonl", "sarif", "topojson"], codemirrorMode: "javascript", codemirrorMimeType: "application/json", parsers: ["json-stringify"], vscodeLanguageIds: ["json"], linguistLanguageId: 174 }, { name: "JSON", type: "data", aceMode: "json", extensions: [".json", ".4DForm", ".4DProject", ".avsc", ".geojson", ".gltf", ".har", ".ice", ".JSON-tmLanguage", ".json.example", ".mcmeta", ".sarif", ".tact", ".tfstate", ".tfstate.backup", ".topojson", ".webapp", ".webmanifest", ".yy", ".yyp"], filenames: [".all-contributorsrc", ".arcconfig", ".auto-changelog", ".c8rc", ".htmlhintrc", ".imgbotconfig", ".nycrc", ".tern-config", ".tern-project", ".watchmanconfig", ".babelrc", ".jscsrc", ".jshintrc", ".jslintrc", ".swcrc"], tmScope: "source.json", aliases: ["geojson", "jsonl", "sarif", "topojson"], codemirrorMode: "javascript", codemirrorMimeType: "application/json", parsers: ["json"], vscodeLanguageIds: ["json"], linguistLanguageId: 174 }, { name: "JSON with Comments", type: "data", aceMode: "javascript", extensions: [".jsonc", ".code-snippets", ".code-workspace", ".sublime-build", ".sublime-color-scheme", ".sublime-commands", ".sublime-completions", ".sublime-keymap", ".sublime-macro", ".sublime-menu", ".sublime-mousemap", ".sublime-project", ".sublime-settings", ".sublime-theme", ".sublime-workspace", ".sublime_metrics", ".sublime_session"], filenames: [], tmScope: "source.json.comments", aliases: ["jsonc"], codemirrorMode: "javascript", codemirrorMimeType: "text/javascript", group: "JSON", parsers: ["jsonc"], vscodeLanguageIds: ["jsonc"], linguistLanguageId: 423 }, { name: "JSON5", type: "data", aceMode: "json5", extensions: [".json5"], tmScope: "source.js", codemirrorMode: "javascript", codemirrorMimeType: "application/json", parsers: ["json5"], vscodeLanguageIds: ["json5"], linguistLanguageId: 175 }];
+var Us = {};
+_n(Us, { getVisitorKeys: () => ia, massageAstNode: () => oa, print: () => Xm });
+var Um = { JsonRoot: ["node"], ArrayExpression: ["elements"], ObjectExpression: ["properties"], ObjectProperty: ["key", "value"], UnaryExpression: ["argument"], NullLiteral: [], BooleanLiteral: [], StringLiteral: [], NumericLiteral: [], Identifier: [], TemplateLiteral: ["quasis"], TemplateElement: [] }, sa = Um;
+var Hm = Ir(sa), ia = Hm;
+function Xm(e, t, r) {
+  let { node: n } = e;
+  switch (n.type) {
+    case "JsonRoot":
+      return [r("node"), y];
+    case "ArrayExpression": {
+      if (n.elements.length === 0) return "[]";
+      let s = e.map(() => e.node === null ? "null" : r(), "elements");
+      return ["[", m([y, I([",", y], s)]), y, "]"];
+    }
+    case "ObjectExpression":
+      return n.properties.length === 0 ? "{}" : ["{", m([y, I([",", y], e.map(r, "properties"))]), y, "}"];
+    case "ObjectProperty":
+      return [r("key"), ": ", r("value")];
+    case "UnaryExpression":
+      return [n.operator === "+" ? "" : n.operator, r("argument")];
+    case "NullLiteral":
+      return "null";
+    case "BooleanLiteral":
+      return n.value ? "true" : "false";
+    case "StringLiteral":
+      return JSON.stringify(n.value);
+    case "NumericLiteral":
+      return ua(e) ? JSON.stringify(String(n.value)) : JSON.stringify(n.value);
+    case "Identifier":
+      return ua(e) ? JSON.stringify(n.name) : n.name;
+    case "TemplateLiteral":
+      return r(["quasis", 0]);
+    case "TemplateElement":
+      return JSON.stringify(n.value.cooked);
+    default:
+      throw new $e(n, "JSON");
+  }
+}
+function ua(e) {
+  return e.key === "key" && e.parent.type === "ObjectProperty";
+}
+var Vm = /* @__PURE__ */ new Set(["start", "end", "extra", "loc", "comments", "leadingComments", "trailingComments", "innerComments", "errors", "range", "tokens"]);
+function oa(e, t) {
+  let { type: r } = e;
+  if (r === "ObjectProperty") {
+    let { key: n } = e;
+    n.type === "Identifier" ? t.key = { type: "StringLiteral", value: n.name } : n.type === "NumericLiteral" && (t.key = { type: "StringLiteral", value: String(n.value) });
+    return;
+  }
+  if (r === "UnaryExpression" && e.operator === "+") return t.argument;
+  if (r === "ArrayExpression") {
+    for (let [n, s] of e.elements.entries()) s === null && t.elements.splice(n, 0, { type: "NullLiteral" });
+    return;
+  }
+  if (r === "TemplateLiteral") return { type: "StringLiteral", value: e.quasis[0].value.cooked };
+}
+oa.ignoredProperties = Vm;
+var ur = { bracketSpacing: { category: "Common", type: "boolean", default: true, description: "Print spaces between brackets.", oppositeDescription: "Do not print spaces between brackets." }, objectWrap: { category: "Common", type: "choice", default: "preserve", description: "How to wrap object literals.", choices: [{ value: "preserve", description: "Keep as multi-line, if there is a newline between the opening brace and first property." }, { value: "collapse", description: "Fit to a single line when possible." }] }, singleQuote: { category: "Common", type: "boolean", default: false, description: "Use single quotes instead of double quotes." }, bracketSameLine: { category: "Common", type: "boolean", default: false, description: "Put > of opening tags on the last line instead of on a new line." }, singleAttributePerLine: { category: "Common", type: "boolean", default: false, description: "Enforce single attribute per line in HTML, Vue and JSX." } };
+var gt = "JavaScript", $m = { arrowParens: { category: gt, type: "choice", default: "always", description: "Include parentheses around a sole arrow function parameter.", choices: [{ value: "always", description: "Always include parens. Example: `(x) => x`" }, { value: "avoid", description: "Omit parens when possible. Example: `x => x`" }] }, bracketSameLine: ur.bracketSameLine, objectWrap: ur.objectWrap, bracketSpacing: ur.bracketSpacing, jsxBracketSameLine: { category: gt, type: "boolean", description: "Put > on the last line instead of at a new line.", deprecated: "2.4.0" }, semi: { category: gt, type: "boolean", default: true, description: "Print semicolons.", oppositeDescription: "Do not print semicolons, except at the beginning of lines which may need them." }, experimentalOperatorPosition: { category: gt, type: "choice", default: "end", description: "Where to print operators when binary expressions wrap lines.", choices: [{ value: "start", description: "Print operators at the start of new lines." }, { value: "end", description: "Print operators at the end of previous lines." }] }, experimentalTernaries: { category: gt, type: "boolean", default: false, description: "Use curious ternaries, with the question mark after the condition.", oppositeDescription: "Default behavior of ternaries; keep question marks on the same line as the consequent." }, singleQuote: ur.singleQuote, jsxSingleQuote: { category: gt, type: "boolean", default: false, description: "Use single quotes in JSX." }, quoteProps: { category: gt, type: "choice", default: "as-needed", description: "Change when properties in objects are quoted.", choices: [{ value: "as-needed", description: "Only add quotes around object properties where required." }, { value: "consistent", description: "If at least one property in an object requires quotes, quote all properties." }, { value: "preserve", description: "Respect the input use of quotes in object properties." }] }, trailingComma: { category: gt, type: "choice", default: "all", description: "Print trailing commas wherever possible when multi-line.", choices: [{ value: "all", description: "Trailing commas wherever possible (including function arguments)." }, { value: "es5", description: "Trailing commas where valid in ES5 (objects, arrays, etc.)" }, { value: "none", description: "No trailing commas." }] }, singleAttributePerLine: ur.singleAttributePerLine }, aa = $m;
+var Km = { estree: Ys, "estree-json": Us }, Qm = [...$s, ...na];
+export {
+  pa as default,
+  Qm as languages,
+  aa as options,
+  Km as printers
+};
+//# sourceMappingURL=estree-DHLJIae3.js.map