eddyter 1.3.43 → 1.3.51

package/dist/estree-a7dc9ac5.js

@@ -0,0 +1,4647 @@
+var to = Object.defineProperty;
+var no = (e, t, n) => t in e ? to(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var qt = (e, t, n) => (no(e, typeof t != "symbol" ? t + "" : t, n), n);
+var ro = Object.defineProperty, $r = (e) => {
+  throw TypeError(e);
+}, en = (e, t) => {
+  for (var n in t)
+    ro(e, n, { get: t[n], enumerable: !0 });
+}, Wr = (e, t, n) => t.has(e) || $r("Cannot " + n), Je = (e, t, n) => (Wr(e, t, "read from private field"), n ? n.call(e) : t.get(e)), uo = (e, t, n) => t.has(e) ? $r("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, n), ao = (e, t, n, r) => (Wr(e, t, "write to private field"), r ? r.call(e, n) : t.set(e, n), n), Rr = {};
+en(Rr, { languages: () => hD, options: () => gD, printers: () => xD });
+var oo = [{ name: "JavaScript", type: "programming", 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"], tmScope: "source.js", aceMode: "javascript", aliases: ["js", "node"], codemirrorMode: "javascript", codemirrorMimeType: "text/javascript", interpreters: ["chakra", "d8", "gjs", "js", "node", "nodejs", "qjs", "rhino", "v8", "v8-shell", "zx"], filenames: ["Jakefile", "start.frag", "end.frag"], parsers: ["babel", "acorn", "espree", "meriyah", "babel-flow", "babel-ts", "flow", "typescript"], vscodeLanguageIds: ["javascript", "mongo"], linguistLanguageId: 183 }, { name: "Flow", type: "programming", extensions: [".js.flow"], tmScope: "source.js", aceMode: "javascript", aliases: [], codemirrorMode: "javascript", codemirrorMimeType: "text/javascript", interpreters: ["chakra", "d8", "gjs", "js", "node", "nodejs", "qjs", "rhino", "v8", "v8-shell"], filenames: [], parsers: ["flow", "babel-flow"], vscodeLanguageIds: ["javascript"], linguistLanguageId: 183 }, { name: "JSX", type: "programming", extensions: [".jsx"], tmScope: "source.js.jsx", aceMode: "javascript", aliases: void 0, codemirrorMode: "jsx", codemirrorMimeType: "text/jsx", interpreters: void 0, filenames: void 0, parsers: ["babel", "babel-flow", "babel-ts", "flow", "typescript", "espree", "meriyah"], vscodeLanguageIds: ["javascriptreact"], group: "JavaScript", linguistLanguageId: 183 }, { name: "TypeScript", type: "programming", extensions: [".ts", ".cts", ".mts"], tmScope: "source.ts", aceMode: "typescript", 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", extensions: [".tsx"], tmScope: "source.tsx", aceMode: "javascript", codemirrorMode: "jsx", codemirrorMimeType: "text/jsx", group: "TypeScript", parsers: ["typescript", "babel-ts"], vscodeLanguageIds: ["typescriptreact"], linguistLanguageId: 94901924 }], Ur = {};
+en(Ur, { canAttachComment: () => Es, embed: () => up, experimentalFeatures: () => cD, getCommentChildNodes: () => Fs, getVisitorKeys: () => zr, handleComments: () => fu, insertPragma: () => Fp, isBlockComment: () => ye, isGap: () => As, massageAstNode: () => mi, print: () => lD, printComment: () => Mi, willPrintOwnComments: () => ku });
+var io = (e, t, n, r) => {
+  if (!(e && t == null))
+    return t.replaceAll ? t.replaceAll(n, r) : n.global ? t.replace(n, r) : t.split(n).join(r);
+}, H = io, so = (e, t, n) => {
+  if (!(e && t == null))
+    return Array.isArray(t) || typeof t == "string" ? t[n < 0 ? t.length + n : n] : t.at(n);
+}, X = so;
+function po(e) {
+  return e !== null && typeof e == "object";
+}
+var lo = po;
+function* co(e, t) {
+  let { getVisitorKeys: n, filter: r = () => !0 } = t, u = (a) => lo(a) && r(a);
+  for (let a of n(e)) {
+    let o = e[a];
+    if (Array.isArray(o))
+      for (let i of o)
+        u(i) && (yield i);
+    else
+      u(o) && (yield o);
+  }
+}
+function* Do(e, t) {
+  let n = [e];
+  for (let r = 0; r < n.length; r++) {
+    let u = n[r];
+    for (let a of co(u, t))
+      yield a, n.push(a);
+  }
+}
+function yo(e, { getVisitorKeys: t, predicate: n }) {
+  for (let r of Do(e, { getVisitorKeys: t }))
+    if (n(r))
+      return !0;
+  return !1;
+}
+var mo = () => /[#*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\uDC70\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-\uDED7\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]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFC-\uDFFF])))?|\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]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\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]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\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]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\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]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFE])))?))?|\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]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\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]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\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]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\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]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\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]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFE])))?))?|\uDC6F(?:\u200D[\u2640\u2642]\uFE0F?)?|\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\uDD3D\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-\uDE89\uDE8F-\uDEC2\uDEC6\uDECE-\uDEDC\uDEDF-\uDEE9]|\uDD3C(?:\u200D[\u2640\u2642]\uFE0F?|\uD83C[\uDFFB-\uDFFF])?|\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]|\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]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\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]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\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]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\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]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\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]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?))?|\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 fo(e) {
+  return e === 12288 || e >= 65281 && e <= 65376 || e >= 65504 && e <= 65510;
+}
+function Eo(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 === 94193 || e >= 94208 && e <= 100343 || e >= 100352 && e <= 101589 || e >= 101631 && e <= 101640 || 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 <= 128727 || 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 <= 129673 || e >= 129679 && e <= 129734 || e >= 129742 && e <= 129756 || e >= 129759 && e <= 129769 || e >= 129776 && e <= 129784 || e >= 131072 && e <= 196605 || e >= 196608 && e <= 262141;
+}
+var Fo = (e) => !(fo(e) || Eo(e)), Ao = /[^\x20-\x7F]/u;
+function go(e) {
+  if (!e)
+    return 0;
+  if (!Ao.test(e))
+    return e.length;
+  e = e.replace(mo(), "  ");
+  let t = 0;
+  for (let n of e) {
+    let r = n.codePointAt(0);
+    r <= 31 || r >= 127 && r <= 159 || r >= 768 && r <= 879 || (t += Fo(r) ? 1 : 2);
+  }
+  return t;
+}
+var lt = go;
+function qn(e) {
+  return (t, n, r) => {
+    let u = !!(r != null && r.backwards);
+    if (n === !1)
+      return !1;
+    let { length: a } = t, o = n;
+    for (; o >= 0 && o < a; ) {
+      let i = t.charAt(o);
+      if (e instanceof RegExp) {
+        if (!e.test(i))
+          return o;
+      } else if (!e.includes(i))
+        return o;
+      u ? o-- : o++;
+    }
+    return o === -1 || o === a ? o : !1;
+  };
+}
+var ct = qn(" 	"), xo = qn(",; 	"), ho = qn(/[^\n\r]/u);
+function Co(e, t, n) {
+  let r = !!(n != null && n.backwards);
+  if (t === !1)
+    return !1;
+  let u = e.charAt(t);
+  if (r) {
+    if (e.charAt(t - 1) === "\r" && u === `
+`)
+      return t - 2;
+    if (u === `
+` || u === "\r" || u === "\u2028" || u === "\u2029")
+      return t - 1;
+  } else {
+    if (u === "\r" && e.charAt(t + 1) === `
+`)
+      return t + 2;
+    if (u === `
+` || u === "\r" || u === "\u2028" || u === "\u2029")
+      return t + 1;
+  }
+  return t;
+}
+var Dt = Co;
+function To(e, t, n = {}) {
+  let r = ct(e, n.backwards ? t - 1 : t, n), u = Dt(e, r, n);
+  return r !== u;
+}
+var pe = To;
+function So(e, t) {
+  if (t === !1)
+    return !1;
+  if (e.charAt(t) === "/" && e.charAt(t + 1) === "*") {
+    for (let n = t + 2; n < e.length; ++n)
+      if (e.charAt(n) === "*" && e.charAt(n + 1) === "/")
+        return n + 2;
+  }
+  return t;
+}
+var _n = So;
+function bo(e, t) {
+  return t === !1 ? !1 : e.charAt(t) === "/" && e.charAt(t + 1) === "/" ? ho(e, t) : t;
+}
+var Xn = bo;
+function Bo(e, t) {
+  let n = null, r = t;
+  for (; r !== n; )
+    n = r, r = xo(e, r), r = _n(e, r), r = ct(e, r);
+  return r = Xn(e, r), r = Dt(e, r), r !== !1 && pe(e, r);
+}
+var $n = Bo;
+function vo(e) {
+  return Array.isArray(e) && e.length > 0;
+}
+var J = vo, Gr = new Proxy(() => {
+}, { get: () => Gr }), Wn = Gr, _t = "'", fr = '"';
+function ko(e, t) {
+  let n = t === !0 || t === _t ? _t : fr, r = n === _t ? fr : _t, u = 0, a = 0;
+  for (let o of e)
+    o === n ? u++ : o === r && a++;
+  return u > a ? r : n;
+}
+var Vr = ko;
+function Po(e, t, n) {
+  let r = t === '"' ? "'" : '"', u = H(!1, e, /\\(.)|(["'])/gsu, (a, o, i) => o === r ? o : i === t ? "\\" + i : i || (n && /^[^\n\r"'0-7\\bfnrt-vx\u2028\u2029]$/u.test(o) ? o : "\\" + o));
+  return t + u + t;
+}
+var wo = Po;
+function Io(e, t) {
+  Wn.ok(/^(?<quote>["']).*\k<quote>$/su.test(e));
+  let n = e.slice(1, -1), r = t.parser === "json" || t.parser === "jsonc" || t.parser === "json5" && t.quoteProps === "preserve" && !t.singleQuote ? '"' : t.__isInHtmlAttribute ? "'" : Vr(n, t.singleQuote);
+  return e.charAt(0) === r ? e : wo(n, r, !1);
+}
+var yt = Io, Kr = (e) => Number.isInteger(e) && e >= 0;
+function q(e) {
+  var t, n, r;
+  let u = ((t = e.range) == null ? void 0 : t[0]) ?? e.start, a = (r = ((n = e.declaration) == null ? void 0 : n.decorators) ?? e.decorators) == null ? void 0 : r[0];
+  return a ? Math.min(q(a), u) : u;
+}
+function I(e) {
+  var t;
+  return ((t = e.range) == null ? void 0 : t[1]) ?? e.end;
+}
+function tn(e, t) {
+  let n = q(e);
+  return Kr(n) && n === q(t);
+}
+function No(e, t) {
+  let n = I(e);
+  return Kr(n) && n === I(t);
+}
+function jo(e, t) {
+  return tn(e, t) && No(e, t);
+}
+var Ct = null;
+function bt(e) {
+  if (Ct !== null && typeof Ct.property) {
+    let t = Ct;
+    return Ct = bt.prototype = null, t;
+  }
+  return Ct = bt.prototype = e ?? /* @__PURE__ */ Object.create(null), new bt();
+}
+var Lo = 10;
+for (let e = 0; e <= Lo; e++)
+  bt();
+function Mo(e) {
+  return bt(e);
+}
+function Oo(e, t = "type") {
+  Mo(e);
+  function n(r) {
+    let u = r[t], a = e[u];
+    if (!Array.isArray(a))
+      throw Object.assign(new Error(`Missing visitor keys for '${u}'.`), { node: r });
+    return a;
+  }
+  return n;
+}
+var Hr = Oo, Jo = { ArrayExpression: ["elements"], AssignmentExpression: ["left", "right"], BinaryExpression: ["left", "right"], InterpreterDirective: [], Directive: ["value"], DirectiveLiteral: [], BlockStatement: ["directives", "body"], BreakStatement: ["label"], CallExpression: ["callee", "typeParameters", "typeArguments", "arguments"], CatchClause: ["param", "body"], ConditionalExpression: ["test", "consequent", "alternate"], ContinueStatement: ["label"], DebuggerStatement: [], DoWhileStatement: ["body", "test"], EmptyStatement: [], ExpressionStatement: ["expression"], File: ["program"], ForInStatement: ["left", "right", "body"], ForStatement: ["init", "test", "update", "body"], FunctionDeclaration: ["id", "typeParameters", "params", "predicate", "returnType", "body"], FunctionExpression: ["id", "typeParameters", "params", "returnType", "body"], Identifier: ["typeAnnotation", "decorators"], IfStatement: ["test", "consequent", "alternate"], LabeledStatement: ["label", "body"], StringLiteral: [], NumericLiteral: [], NullLiteral: [], BooleanLiteral: [], RegExpLiteral: [], LogicalExpression: ["left", "right"], MemberExpression: ["object", "property"], NewExpression: ["callee", "typeParameters", "typeArguments", "arguments"], Program: ["directives", "body"], ObjectExpression: ["properties"], ObjectMethod: ["decorators", "key", "typeParameters", "params", "returnType", "body"], ObjectProperty: ["decorators", "key", "value"], RestElement: ["argument", "typeAnnotation", "decorators"], ReturnStatement: ["argument"], SequenceExpression: ["expressions"], ParenthesizedExpression: ["expression"], SwitchCase: ["test", "consequent"], SwitchStatement: ["discriminant", "cases"], ThisExpression: [], ThrowStatement: ["argument"], TryStatement: ["block", "handler", "finalizer"], UnaryExpression: ["argument"], UpdateExpression: ["argument"], VariableDeclaration: ["declarations"], VariableDeclarator: ["id", "init"], WhileStatement: ["test", "body"], WithStatement: ["object", "body"], AssignmentPattern: ["left", "right", "decorators", "typeAnnotation"], ArrayPattern: ["elements", "typeAnnotation", "decorators"], ArrowFunctionExpression: ["typeParameters", "params", "predicate", "returnType", "body"], ClassBody: ["body"], ClassExpression: ["decorators", "id", "typeParameters", "superClass", "superTypeParameters", "mixins", "implements", "body", "superTypeArguments"], ClassDeclaration: ["decorators", "id", "typeParameters", "superClass", "superTypeParameters", "mixins", "implements", "body", "superTypeArguments"], ExportAllDeclaration: ["source", "attributes", "exported"], ExportDefaultDeclaration: ["declaration"], ExportNamedDeclaration: ["declaration", "specifiers", "source", "attributes"], ExportSpecifier: ["local", "exported"], ForOfStatement: ["left", "right", "body"], ImportDeclaration: ["specifiers", "source", "attributes"], ImportDefaultSpecifier: ["local"], ImportNamespaceSpecifier: ["local"], ImportSpecifier: ["imported", "local"], ImportExpression: ["source", "options"], MetaProperty: ["meta", "property"], ClassMethod: ["decorators", "key", "typeParameters", "params", "returnType", "body"], ObjectPattern: ["decorators", "properties", "typeAnnotation"], SpreadElement: ["argument"], Super: [], TaggedTemplateExpression: ["tag", "typeParameters", "quasi", "typeArguments"], TemplateElement: [], TemplateLiteral: ["quasis", "expressions"], YieldExpression: ["argument"], AwaitExpression: ["argument"], BigIntLiteral: [], ExportNamespaceSpecifier: ["exported"], OptionalMemberExpression: ["object", "property"], OptionalCallExpression: ["callee", "typeParameters", "typeArguments", "arguments"], ClassProperty: ["decorators", "variance", "key", "typeAnnotation", "value"], ClassAccessorProperty: ["decorators", "key", "typeAnnotation", "value"], ClassPrivateProperty: ["decorators", "variance", "key", "typeAnnotation", "value"], ClassPrivateMethod: ["decorators", "key", "typeParameters", "params", "returnType", "body"], PrivateName: ["id"], StaticBlock: ["body"], ImportAttribute: ["key", "value"], AnyTypeAnnotation: [], ArrayTypeAnnotation: ["elementType"], BooleanTypeAnnotation: [], BooleanLiteralTypeAnnotation: [], NullLiteralTypeAnnotation: [], ClassImplements: ["id", "typeParameters"], DeclareClass: ["id", "typeParameters", "extends", "mixins", "implements", "body"], DeclareFunction: ["id", "predicate"], DeclareInterface: ["id", "typeParameters", "extends", "body"], DeclareModule: ["id", "body"], DeclareModuleExports: ["typeAnnotation"], DeclareTypeAlias: ["id", "typeParameters", "right"], DeclareOpaqueType: ["id", "typeParameters", "supertype"], DeclareVariable: ["id"], DeclareExportDeclaration: ["declaration", "specifiers", "source", "attributes"], DeclareExportAllDeclaration: ["source", "attributes"], DeclaredPredicate: ["value"], ExistsTypeAnnotation: [], FunctionTypeAnnotation: ["typeParameters", "this", "params", "rest", "returnType"], FunctionTypeParam: ["name", "typeAnnotation"], GenericTypeAnnotation: ["id", "typeParameters"], InferredPredicate: [], InterfaceExtends: ["id", "typeParameters"], InterfaceDeclaration: ["id", "typeParameters", "extends", "body"], InterfaceTypeAnnotation: ["extends", "body"], IntersectionTypeAnnotation: ["types"], MixedTypeAnnotation: [], EmptyTypeAnnotation: [], NullableTypeAnnotation: ["typeAnnotation"], NumberLiteralTypeAnnotation: [], NumberTypeAnnotation: [], ObjectTypeAnnotation: ["properties", "indexers", "callProperties", "internalSlots"], ObjectTypeInternalSlot: ["id", "value"], ObjectTypeCallProperty: ["value"], ObjectTypeIndexer: ["variance", "id", "key", "value"], ObjectTypeProperty: ["key", "value", "variance"], ObjectTypeSpreadProperty: ["argument"], OpaqueType: ["id", "typeParameters", "supertype", "impltype"], QualifiedTypeIdentifier: ["qualification", "id"], StringLiteralTypeAnnotation: [], StringTypeAnnotation: [], SymbolTypeAnnotation: [], ThisTypeAnnotation: [], TupleTypeAnnotation: ["types", "elementTypes"], TypeofTypeAnnotation: ["argument", "typeArguments"], TypeAlias: ["id", "typeParameters", "right"], TypeAnnotation: ["typeAnnotation"], TypeCastExpression: ["expression", "typeAnnotation"], TypeParameter: ["bound", "default", "variance"], TypeParameterDeclaration: ["params"], TypeParameterInstantiation: ["params"], UnionTypeAnnotation: ["types"], Variance: [], VoidTypeAnnotation: [], EnumDeclaration: ["id", "body"], EnumBooleanBody: ["members"], EnumNumberBody: ["members"], EnumStringBody: ["members"], EnumSymbolBody: ["members"], EnumBooleanMember: ["id", "init"], EnumNumberMember: ["id", "init"], EnumStringMember: ["id", "init"], EnumDefaultedMember: ["id"], IndexedAccessType: ["objectType", "indexType"], OptionalIndexedAccessType: ["objectType", "indexType"], JSXAttribute: ["name", "value"], JSXClosingElement: ["name"], JSXElement: ["openingElement", "children", "closingElement"], JSXEmptyExpression: [], JSXExpressionContainer: ["expression"], JSXSpreadChild: ["expression"], JSXIdentifier: [], JSXMemberExpression: ["object", "property"], JSXNamespacedName: ["namespace", "name"], JSXOpeningElement: ["name", "typeParameters", "typeArguments", "attributes"], JSXSpreadAttribute: ["argument"], JSXText: [], JSXFragment: ["openingFragment", "children", "closingFragment"], JSXOpeningFragment: [], JSXClosingFragment: [], Noop: [], Placeholder: [], V8IntrinsicIdentifier: [], ArgumentPlaceholder: [], BindExpression: ["object", "callee"], Decorator: ["expression"], DoExpression: ["body"], ExportDefaultSpecifier: ["exported"], ModuleExpression: ["body"], TopicReference: [], PipelineTopicExpression: ["expression"], PipelineBareFunction: ["callee"], PipelinePrimaryTopicReference: [], TSParameterProperty: ["parameter", "decorators"], TSDeclareFunction: ["id", "typeParameters", "params", "returnType", "body"], TSDeclareMethod: ["decorators", "key", "typeParameters", "params", "returnType"], TSQualifiedName: ["left", "right"], TSCallSignatureDeclaration: ["typeParameters", "parameters", "typeAnnotation", "params", "returnType"], TSConstructSignatureDeclaration: ["typeParameters", "parameters", "typeAnnotation", "params", "returnType"], TSPropertySignature: ["key", "typeAnnotation"], TSMethodSignature: ["key", "typeParameters", "parameters", "typeAnnotation", "params", "returnType"], TSIndexSignature: ["parameters", "typeAnnotation"], TSAnyKeyword: [], TSBooleanKeyword: [], TSBigIntKeyword: [], TSIntrinsicKeyword: [], TSNeverKeyword: [], TSNullKeyword: [], TSNumberKeyword: [], TSObjectKeyword: [], TSStringKeyword: [], TSSymbolKeyword: [], TSUndefinedKeyword: [], TSUnknownKeyword: [], TSVoidKeyword: [], TSThisType: [], TSFunctionType: ["typeParameters", "parameters", "typeAnnotation", "params", "returnType"], TSConstructorType: ["typeParameters", "parameters", "typeAnnotation", "params", "returnType"], TSTypeReference: ["typeName", "typeParameters", "typeArguments"], TSTypePredicate: ["parameterName", "typeAnnotation"], TSTypeQuery: ["exprName", "typeParameters", "typeArguments"], TSTypeLiteral: ["members"], TSArrayType: ["elementType"], TSTupleType: ["elementTypes"], TSOptionalType: ["typeAnnotation"], TSRestType: ["typeAnnotation"], TSNamedTupleMember: ["label", "elementType"], TSUnionType: ["types"], TSIntersectionType: ["types"], TSConditionalType: ["checkType", "extendsType", "trueType", "falseType"], TSInferType: ["typeParameter"], TSParenthesizedType: ["typeAnnotation"], TSTypeOperator: ["typeAnnotation"], TSIndexedAccessType: ["objectType", "indexType"], TSMappedType: ["nameType", "typeAnnotation", "key", "constraint"], TSTemplateLiteralType: ["quasis", "types"], TSLiteralType: ["literal"], TSExpressionWithTypeArguments: ["expression", "typeParameters"], TSInterfaceDeclaration: ["id", "typeParameters", "extends", "body"], TSInterfaceBody: ["body"], TSTypeAliasDeclaration: ["id", "typeParameters", "typeAnnotation"], TSInstantiationExpression: ["expression", "typeParameters", "typeArguments"], TSAsExpression: ["expression", "typeAnnotation"], TSSatisfiesExpression: ["expression", "typeAnnotation"], TSTypeAssertion: ["typeAnnotation", "expression"], TSEnumBody: ["members"], TSEnumDeclaration: ["id", "body"], TSEnumMember: ["id", "initializer"], TSModuleDeclaration: ["id", "body"], TSModuleBlock: ["body"], TSImportType: ["argument", "options", "qualifier", "typeParameters", "typeArguments"], TSImportEqualsDeclaration: ["id", "moduleReference"], TSExternalModuleReference: ["expression"], TSNonNullExpression: ["expression"], TSExportAssignment: ["expression"], TSNamespaceExportDeclaration: ["id"], TSTypeAnnotation: ["typeAnnotation"], TSTypeParameterInstantiation: ["params"], TSTypeParameterDeclaration: ["params"], TSTypeParameter: ["constraint", "default", "name"], ChainExpression: ["expression"], ExperimentalRestProperty: ["argument"], ExperimentalSpreadProperty: ["argument"], Literal: [], MethodDefinition: ["decorators", "key", "value"], PrivateIdentifier: [], Property: ["key", "value"], PropertyDefinition: ["decorators", "key", "typeAnnotation", "value", "variance"], AccessorProperty: ["decorators", "key", "typeAnnotation", "value"], TSAbstractAccessorProperty: ["decorators", "key", "typeAnnotation"], TSAbstractKeyword: [], TSAbstractMethodDefinition: ["key", "value"], TSAbstractPropertyDefinition: ["decorators", "key", "typeAnnotation"], TSAsyncKeyword: [], TSClassImplements: ["expression", "typeArguments", "typeParameters"], TSDeclareKeyword: [], TSEmptyBodyFunctionExpression: ["id", "typeParameters", "params", "returnType"], TSExportKeyword: [], TSInterfaceHeritage: ["expression", "typeArguments", "typeParameters"], TSPrivateKeyword: [], TSProtectedKeyword: [], TSPublicKeyword: [], TSReadonlyKeyword: [], TSStaticKeyword: [], AsConstExpression: ["expression"], AsExpression: ["expression", "typeAnnotation"], BigIntLiteralTypeAnnotation: [], BigIntTypeAnnotation: [], ComponentDeclaration: ["id", "params", "body", "typeParameters", "rendersType"], ComponentParameter: ["name", "local"], ComponentTypeAnnotation: ["params", "rest", "typeParameters", "rendersType"], ComponentTypeParameter: ["name", "typeAnnotation"], ConditionalTypeAnnotation: ["checkType", "extendsType", "trueType", "falseType"], DeclareComponent: ["id", "params", "rest", "typeParameters", "rendersType"], DeclareEnum: ["id", "body"], DeclareHook: ["id"], DeclareNamespace: ["id", "body"], EnumBigIntBody: ["members"], EnumBigIntMember: ["id", "init"], HookDeclaration: ["id", "params", "body", "typeParameters", "returnType"], HookTypeAnnotation: ["params", "returnType", "rest", "typeParameters"], InferTypeAnnotation: ["typeParameter"], KeyofTypeAnnotation: ["argument"], ObjectTypeMappedTypeProperty: ["keyTparam", "propType", "sourceType", "variance"], QualifiedTypeofIdentifier: ["qualification", "id"], TupleTypeLabeledElement: ["label", "elementType", "variance"], TupleTypeSpreadElement: ["label", "typeAnnotation"], TypeOperator: ["typeAnnotation"], TypePredicate: ["parameterName", "typeAnnotation", "asserts"], NGChainedExpression: ["expressions"], NGEmptyExpression: [], NGPipeExpression: ["left", "right", "arguments"], NGMicrosyntax: ["body"], NGMicrosyntaxAs: ["key", "alias"], NGMicrosyntaxExpression: ["expression", "alias"], NGMicrosyntaxKey: [], NGMicrosyntaxKeyedExpression: ["key", "expression"], NGMicrosyntaxLet: ["key", "value"], NGRoot: ["node"], JsExpressionRoot: ["node"], JsonRoot: ["node"], TSJSDocAllType: [], TSJSDocUnknownType: [], TSJSDocNullableType: ["typeAnnotation"], TSJSDocNonNullableType: ["typeAnnotation"], NeverTypeAnnotation: [], SatisfiesExpression: ["expression", "typeAnnotation"], UndefinedTypeAnnotation: [], UnknownTypeAnnotation: [] }, qo = Hr(Jo), zr = qo;
+function _o(e) {
+  let t = new Set(e);
+  return (n) => t.has(n == null ? void 0 : n.type);
+}
+var _ = _o;
+function Xo(e) {
+  var t;
+  return ((t = e.extra) == null ? void 0 : t.raw) ?? e.raw;
+}
+var oe = Xo, $o = _(["Block", "CommentBlock", "MultiLine"]), ye = $o, Wo = _(["AnyTypeAnnotation", "ThisTypeAnnotation", "NumberTypeAnnotation", "VoidTypeAnnotation", "BooleanTypeAnnotation", "BigIntTypeAnnotation", "SymbolTypeAnnotation", "StringTypeAnnotation", "NeverTypeAnnotation", "UndefinedTypeAnnotation", "UnknownTypeAnnotation", "EmptyTypeAnnotation", "MixedTypeAnnotation"]), Qr = Wo, Ro = _(["Line", "CommentLine", "SingleLine", "HashbangComment", "HTMLOpen", "HTMLClose", "Hashbang", "InterpreterDirective"]), Nt = Ro;
+function Uo(e, t) {
+  let n = t.split(".");
+  for (let r = n.length - 1; r >= 0; r--) {
+    let u = n[r];
+    if (r === 0)
+      return e.type === "Identifier" && e.name === u;
+    if (e.type !== "MemberExpression" || e.optional || e.computed || e.property.type !== "Identifier" || e.property.name !== u)
+      return !1;
+    e = e.object;
+  }
+}
+function Go(e, t) {
+  return t.some((n) => Uo(e, n));
+}
+var Vo = Go;
+function Ko({ type: e }) {
+  return e.startsWith("TS") && e.endsWith("Keyword");
+}
+var Yr = Ko;
+function Tn(e, t) {
+  return t(e) || yo(e, { getVisitorKeys: zr, predicate: t });
+}
+function Rn(e) {
+  return e.type === "AssignmentExpression" || e.type === "BinaryExpression" || e.type === "LogicalExpression" || e.type === "NGPipeExpression" || e.type === "ConditionalExpression" || L(e) || W(e) || e.type === "SequenceExpression" || e.type === "TaggedTemplateExpression" || e.type === "BindExpression" || e.type === "UpdateExpression" && !e.prefix || Ce(e) || e.type === "TSNonNullExpression" || e.type === "ChainExpression";
+}
+function Ho(e) {
+  return e.expressions ? e.expressions[0] : e.left ?? e.test ?? e.callee ?? e.object ?? e.tag ?? e.argument ?? e.expression;
+}
+function Zr(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 zo = _(["ExportDefaultDeclaration", "DeclareExportDeclaration", "ExportNamedDeclaration", "ExportAllDeclaration", "DeclareExportAllDeclaration"]), Q = _(["ArrayExpression"]), Ae = _(["ObjectExpression"]);
+function Qo(e) {
+  return e.type === "LogicalExpression" && e.operator === "??";
+}
+function be(e) {
+  return e.type === "NumericLiteral" || e.type === "Literal" && typeof e.value == "number";
+}
+function Yo(e) {
+  return e.type === "BooleanLiteral" || e.type === "Literal" && typeof e.value == "boolean";
+}
+function eu(e) {
+  return e.type === "UnaryExpression" && (e.operator === "+" || e.operator === "-") && be(e.argument);
+}
+function Y(e) {
+  return !!(e && (e.type === "StringLiteral" || e.type === "Literal" && typeof e.value == "string"));
+}
+function tu(e) {
+  return e.type === "RegExpLiteral" || e.type === "Literal" && !!e.regex;
+}
+var Un = _(["Literal", "BooleanLiteral", "BigIntLiteral", "DirectiveLiteral", "NullLiteral", "NumericLiteral", "RegExpLiteral", "StringLiteral"]), Zo = _(["Identifier", "ThisExpression", "Super", "PrivateName", "PrivateIdentifier"]), Xe = _(["ObjectTypeAnnotation", "TSTypeLiteral", "TSMappedType"]), kt = _(["FunctionExpression", "ArrowFunctionExpression"]);
+function ei(e) {
+  return e.type === "FunctionExpression" || e.type === "ArrowFunctionExpression" && e.body.type === "BlockStatement";
+}
+function cn(e) {
+  return L(e) && e.callee.type === "Identifier" && ["async", "inject", "fakeAsync", "waitForAsync"].includes(e.callee.name);
+}
+var K = _(["JSXElement", "JSXFragment"]);
+function nn(e) {
+  return e.method && e.kind === "init" || e.kind === "get" || e.kind === "set";
+}
+function nu(e) {
+  return (e.type === "ObjectTypeProperty" || e.type === "ObjectTypeInternalSlot") && !e.static && !e.method && e.kind !== "get" && e.kind !== "set" && e.value.type === "FunctionTypeAnnotation";
+}
+function ti(e) {
+  return (e.type === "TypeAnnotation" || e.type === "TSTypeAnnotation") && e.typeAnnotation.type === "FunctionTypeAnnotation" && !e.static && !tn(e, e.typeAnnotation);
+}
+var ke = _(["BinaryExpression", "LogicalExpression", "NGPipeExpression"]);
+function st(e) {
+  return W(e) || e.type === "BindExpression" && !!e.object;
+}
+var ni = _(["TSThisType", "NullLiteralTypeAnnotation", "BooleanLiteralTypeAnnotation", "StringLiteralTypeAnnotation", "BigIntLiteralTypeAnnotation", "NumberLiteralTypeAnnotation", "TSLiteralType", "TSTemplateLiteralType"]);
+function Gn(e) {
+  return Yr(e) || Qr(e) || ni(e) || (e.type === "GenericTypeAnnotation" || e.type === "TSTypeReference") && !e.typeParameters && !e.typeArguments;
+}
+function ri(e) {
+  return e.type === "Identifier" && (e.name === "beforeEach" || e.name === "beforeAll" || e.name === "afterEach" || e.name === "afterAll");
+}
+var ui = ["it", "it.only", "it.skip", "describe", "describe.only", "describe.skip", "test", "test.only", "test.skip", "test.step", "test.describe", "test.describe.only", "test.describe.parallel", "test.describe.parallel.only", "test.describe.serial", "test.describe.serial.only", "skip", "xit", "xdescribe", "xtest", "fit", "fdescribe", "ftest"];
+function ai(e) {
+  return Vo(e, ui);
+}
+function rn(e, t) {
+  if ((e == null ? void 0 : e.type) !== "CallExpression" || e.optional)
+    return !1;
+  let n = de(e);
+  if (n.length === 1) {
+    if (cn(e) && rn(t))
+      return kt(n[0]);
+    if (ri(e.callee))
+      return cn(n[0]);
+  } else if ((n.length === 2 || n.length === 3) && (n[0].type === "TemplateLiteral" || Y(n[0])) && ai(e.callee))
+    return n[2] && !be(n[2]) ? !1 : (n.length === 2 ? kt(n[1]) : ei(n[1]) && Z(n[1]).length <= 1) || cn(n[1]);
+  return !1;
+}
+var ru = (e) => (t) => ((t == null ? void 0 : t.type) === "ChainExpression" && (t = t.expression), e(t)), L = ru(_(["CallExpression", "OptionalCallExpression"])), W = ru(_(["MemberExpression", "OptionalMemberExpression"]));
+function Er(e, t = 5) {
+  return uu(e, t) <= t;
+}
+function uu(e, t) {
+  let n = 0;
+  for (let r in e) {
+    let u = e[r];
+    if (u && typeof u == "object" && typeof u.type == "string" && (n++, n += uu(u, t - n)), n > t)
+      return n;
+  }
+  return n;
+}
+var oi = 0.25;
+function Vn(e, t) {
+  let { printWidth: n } = t;
+  if (h(e))
+    return !1;
+  let r = n * oi;
+  if (e.type === "ThisExpression" || e.type === "Identifier" && e.name.length <= r || eu(e) && !h(e.argument))
+    return !0;
+  let u = e.type === "Literal" && "regex" in e && e.regex.pattern || e.type === "RegExpLiteral" && e.pattern;
+  return u ? u.length <= r : Y(e) ? yt(oe(e), t).length <= r : e.type === "TemplateLiteral" ? e.expressions.length === 0 && e.quasis[0].value.raw.length <= r && !e.quasis[0].value.raw.includes(`
+`) : e.type === "UnaryExpression" ? Vn(e.argument, { printWidth: n }) : e.type === "CallExpression" && e.arguments.length === 0 && e.callee.type === "Identifier" ? e.callee.name.length <= r - 2 : Un(e);
+}
+function Te(e, t) {
+  return K(t) ? un(t) : h(t, T.Leading, (n) => pe(e, I(n)));
+}
+function Fr(e) {
+  return e.quasis.some((t) => t.value.raw.includes(`
+`));
+}
+function au(e, t) {
+  return (e.type === "TemplateLiteral" && Fr(e) || e.type === "TaggedTemplateExpression" && Fr(e.quasi)) && !pe(t, q(e), { backwards: !0 });
+}
+function ou(e) {
+  if (!h(e))
+    return !1;
+  let t = X(!1, Ke(e, T.Dangling), -1);
+  return t && !ye(t);
+}
+function ii(e) {
+  if (e.length <= 1)
+    return !1;
+  let t = 0;
+  for (let n of e)
+    if (kt(n)) {
+      if (t += 1, t > 1)
+        return !0;
+    } else if (L(n)) {
+      for (let r of de(n))
+        if (kt(r))
+          return !0;
+    }
+  return !1;
+}
+function iu(e) {
+  let { node: t, parent: n, key: r } = e;
+  return r === "callee" && L(t) && L(n) && n.arguments.length > 0 && t.arguments.length > n.arguments.length;
+}
+var si = /* @__PURE__ */ new Set(["!", "-", "+", "~"]);
+function Ee(e, t = 2) {
+  if (t <= 0)
+    return !1;
+  if (e.type === "ChainExpression" || e.type === "TSNonNullExpression")
+    return Ee(e.expression, t);
+  let n = (r) => Ee(r, t - 1);
+  if (tu(e))
+    return lt(e.pattern ?? e.regex.pattern) <= 5;
+  if (Un(e) || Zo(e) || e.type === "ArgumentPlaceholder")
+    return !0;
+  if (e.type === "TemplateLiteral")
+    return e.quasis.every((r) => !r.value.raw.includes(`
+`)) && e.expressions.every(n);
+  if (Ae(e))
+    return e.properties.every((r) => !r.computed && (r.shorthand || r.value && n(r.value)));
+  if (Q(e))
+    return e.elements.every((r) => r === null || n(r));
+  if (dt(e)) {
+    if (e.type === "ImportExpression" || Ee(e.callee, t)) {
+      let r = de(e);
+      return r.length <= t && r.every(n);
+    }
+    return !1;
+  }
+  return W(e) ? Ee(e.object, t) && Ee(e.property, t) : e.type === "UnaryExpression" && si.has(e.operator) || e.type === "UpdateExpression" ? Ee(e.argument, t) : !1;
+}
+function pi(e) {
+  return e;
+}
+function Ie(e, t = "es5") {
+  return e.trailingComma === "es5" && t === "es5" || e.trailingComma === "all" && (t === "all" || t === "es5");
+}
+function te(e, t) {
+  switch (e.type) {
+    case "BinaryExpression":
+    case "LogicalExpression":
+    case "AssignmentExpression":
+    case "NGPipeExpression":
+      return te(e.left, t);
+    case "MemberExpression":
+    case "OptionalMemberExpression":
+      return te(e.object, t);
+    case "TaggedTemplateExpression":
+      return e.tag.type === "FunctionExpression" ? !1 : te(e.tag, t);
+    case "CallExpression":
+    case "OptionalCallExpression":
+      return e.callee.type === "FunctionExpression" ? !1 : te(e.callee, t);
+    case "ConditionalExpression":
+      return te(e.test, t);
+    case "UpdateExpression":
+      return !e.prefix && te(e.argument, t);
+    case "BindExpression":
+      return e.object && te(e.object, t);
+    case "SequenceExpression":
+      return te(e.expressions[0], t);
+    case "ChainExpression":
+    case "TSSatisfiesExpression":
+    case "TSAsExpression":
+    case "TSNonNullExpression":
+    case "AsExpression":
+    case "AsConstExpression":
+    case "SatisfiesExpression":
+      return te(e.expression, t);
+    default:
+      return t(e);
+  }
+}
+var Ar = { "==": !0, "!=": !0, "===": !0, "!==": !0 }, Xt = { "*": !0, "/": !0, "%": !0 }, Sn = { ">>": !0, ">>>": !0, "<<": !0 };
+function Kn(e, t) {
+  return !(Kt(t) !== Kt(e) || e === "**" || Ar[e] && Ar[t] || t === "%" && Xt[e] || e === "%" && Xt[t] || t !== e && Xt[t] && Xt[e] || Sn[e] && Sn[t]);
+}
+var li = new Map([["|>"], ["??"], ["||"], ["&&"], ["|"], ["^"], ["&"], ["==", "===", "!=", "!=="], ["<", ">", "<=", ">=", "in", "instanceof"], [">>", "<<", ">>>"], ["+", "-"], ["*", "/", "%"], ["**"]].flatMap((e, t) => e.map((n) => [n, t])));
+function Kt(e) {
+  return li.get(e);
+}
+function ci(e) {
+  return !!Sn[e] || e === "|" || e === "^" || e === "&";
+}
+function Di(e) {
+  var t;
+  if (e.rest)
+    return !0;
+  let n = Z(e);
+  return ((t = X(!1, n, -1)) == null ? void 0 : t.type) === "RestElement";
+}
+var Dn = /* @__PURE__ */ new WeakMap();
+function Z(e) {
+  if (Dn.has(e))
+    return Dn.get(e);
+  let t = [];
+  return e.this && t.push(e.this), Array.isArray(e.parameters) ? t.push(...e.parameters) : Array.isArray(e.params) && t.push(...e.params), e.rest && t.push(e.rest), Dn.set(e, t), t;
+}
+function yi(e, t) {
+  let { node: n } = e, r = 0, u = (a) => t(a, r++);
+  n.this && e.call(u, "this"), Array.isArray(n.parameters) ? e.each(u, "parameters") : Array.isArray(n.params) && e.each(u, "params"), n.rest && e.call(u, "rest");
+}
+var yn = /* @__PURE__ */ new WeakMap();
+function de(e) {
+  if (yn.has(e))
+    return yn.get(e);
+  if (e.type === "ChainExpression")
+    return de(e.expression);
+  let t = e.arguments;
+  return (e.type === "ImportExpression" || e.type === "TSImportType") && (t = [e.type === "ImportExpression" ? e.source : e.argument], e.options && t.push(e.options)), yn.set(e, t), t;
+}
+function Ht(e, t) {
+  let { node: n } = e;
+  if (n.type === "ChainExpression")
+    return e.call(() => Ht(e, t), "expression");
+  n.type === "ImportExpression" || n.type === "TSImportType" ? (e.call((r) => t(r, 0), n.type === "ImportExpression" ? "source" : "argument"), n.options && e.call((r) => t(r, 1), "options")) : e.each(t, "arguments");
+}
+function gr(e, t) {
+  let n = [];
+  if (e.type === "ChainExpression" && (e = e.expression, n.push("expression")), e.type === "ImportExpression" || e.type === "TSImportType") {
+    if (t === 0 || t === (e.options ? -2 : -1))
+      return [...n, e.type === "ImportExpression" ? "source" : "argument"];
+    if (e.options && (t === 1 || t === -1))
+      return [...n, "options"];
+    throw new RangeError("Invalid argument index");
+  }
+  if (t < 0 && (t = e.arguments.length + t), t < 0 || t >= e.arguments.length)
+    throw new RangeError("Invalid argument index");
+  return [...n, "arguments", t];
+}
+function zt(e) {
+  return e.value.trim() === "prettier-ignore" && !e.unignore;
+}
+function un(e) {
+  return (e == null ? void 0 : e.prettierIgnore) || h(e, T.PrettierIgnore);
+}
+var T = { Leading: 2, Trailing: 4, Dangling: 8, Block: 16, Line: 32, PrettierIgnore: 64, First: 128, Last: 256 }, su = (e, t) => {
+  if (typeof e == "function" && (t = e, e = 0), e || t)
+    return (n, r, u) => !(e & T.Leading && !n.leading || e & T.Trailing && !n.trailing || e & T.Dangling && (n.leading || n.trailing) || e & T.Block && !ye(n) || e & T.Line && !Nt(n) || e & T.First && r !== 0 || e & T.Last && r !== u.length - 1 || e & T.PrettierIgnore && !zt(n) || t && !t(n));
+};
+function h(e, t, n) {
+  if (!J(e == null ? void 0 : e.comments))
+    return !1;
+  let r = su(t, n);
+  return r ? e.comments.some(r) : !0;
+}
+function Ke(e, t, n) {
+  if (!Array.isArray(e == null ? void 0 : e.comments))
+    return [];
+  let r = su(t, n);
+  return r ? e.comments.filter(r) : e.comments;
+}
+var Ne = (e, { originalText: t }) => $n(t, I(e));
+function dt(e) {
+  return L(e) || e.type === "NewExpression" || e.type === "ImportExpression";
+}
+function je(e) {
+  return e && (e.type === "ObjectProperty" || e.type === "Property" && !nn(e));
+}
+var Ce = _(["TSAsExpression", "TSSatisfiesExpression", "AsExpression", "AsConstExpression", "SatisfiesExpression"]), $e = _(["TSUnionType", "UnionTypeAnnotation"]), Hn = _(["TSIntersectionType", "IntersectionTypeAnnotation"]), We = _(["TSConditionalType", "ConditionalTypeAnnotation"]), di = /* @__PURE__ */ new Set(["range", "raw", "comments", "leadingComments", "trailingComments", "innerComments", "extra", "start", "end", "loc", "flags", "errors", "tokens"]), it = (e) => {
+  for (let t of e.quasis)
+    delete t.value;
+};
+function pu(e, t) {
+  var n;
+  if (e.type === "Program" && delete t.sourceType, (e.type === "BigIntLiteral" || e.type === "BigIntLiteralTypeAnnotation") && e.value && (t.value = e.value.toLowerCase()), (e.type === "BigIntLiteral" || e.type === "Literal") && e.bigint && (t.bigint = e.bigint.toLowerCase()), e.type === "EmptyStatement" || 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: u } = e;
+    Y(u) || be(u) ? t.key = String(u.value) : u.type === "Identifier" && (t.key = u.name);
+  }
+  if (e.type === "JSXElement" && e.openingElement.name.name === "style" && e.openingElement.attributes.some((u) => u.type === "JSXAttribute" && u.name.name === "jsx"))
+    for (let { type: u, expression: a } of t.children)
+      u === "JSXExpressionContainer" && a.type === "TemplateLiteral" && it(a);
+  e.type === "JSXAttribute" && e.name.name === "css" && e.value.type === "JSXExpressionContainer" && e.value.expression.type === "TemplateLiteral" && it(t.value.expression), e.type === "JSXAttribute" && ((n = e.value) == null ? void 0 : n.type) === "Literal" && /["']|&quot;|&apos;/u.test(e.value.value) && (t.value.value = H(!1, e.value.value, /["']|&quot;|&apos;/gu, '"'));
+  let r = e.expression || e.callee;
+  if (e.type === "Decorator" && r.type === "CallExpression" && r.callee.name === "Component" && r.arguments.length === 1) {
+    let u = e.expression.arguments[0].properties;
+    for (let [a, o] of t.expression.arguments[0].properties.entries())
+      switch (u[a].key.name) {
+        case "styles":
+          Q(o.value) && it(o.value.elements[0]);
+          break;
+        case "template":
+          o.value.type === "TemplateLiteral" && it(o.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") && it(t.quasi), e.type === "TemplateLiteral" && it(t), e.type === "ChainExpression" && e.expression.type === "TSNonNullExpression" && (t.type = "TSNonNullExpression", t.expression.type = "ChainExpression");
+}
+pu.ignoredProperties = di;
+var mi = pu, Qe = "string", Pe = "array", ft = "cursor", Ye = "indent", Ze = "align", et = "trim", De = "group", Re = "fill", Se = "if-break", tt = "indent-if-break", nt = "line-suffix", Ue = "line-suffix-boundary", se = "line", Le = "label", Me = "break-parent", lu = /* @__PURE__ */ new Set([ft, Ye, Ze, et, De, Re, Se, tt, nt, Ue, se, Le, Me]);
+function fi(e) {
+  if (typeof e == "string")
+    return Qe;
+  if (Array.isArray(e))
+    return Pe;
+  if (!e)
+    return;
+  let { type: t } = e;
+  if (lu.has(t))
+    return t;
+}
+var Ge = fi, Ei = (e) => new Intl.ListFormat("en-US", { type: "disjunction" }).format(e);
+function Fi(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 (Ge(e))
+    throw new Error("doc is valid.");
+  let n = Object.prototype.toString.call(e);
+  if (n !== "[object Object]")
+    return `Unexpected doc '${n}'.`;
+  let r = Ei([...lu].map((u) => `'${u}'`));
+  return `Unexpected doc.type '${e.type}'.
+Expected it to be ${r}.`;
+}
+var Ai = class extends Error {
+  constructor(t) {
+    super(Fi(t));
+    qt(this, "name", "InvalidDocError");
+    this.doc = t;
+  }
+}, Pt = Ai, xr = {};
+function gi(e, t, n, r) {
+  let u = [e];
+  for (; u.length > 0; ) {
+    let a = u.pop();
+    if (a === xr) {
+      n(u.pop());
+      continue;
+    }
+    n && u.push(a, xr);
+    let o = Ge(a);
+    if (!o)
+      throw new Pt(a);
+    if ((t == null ? void 0 : t(a)) !== !1)
+      switch (o) {
+        case Pe:
+        case Re: {
+          let i = o === Pe ? a : a.parts;
+          for (let s = i.length, l = s - 1; l >= 0; --l)
+            u.push(i[l]);
+          break;
+        }
+        case Se:
+          u.push(a.flatContents, a.breakContents);
+          break;
+        case De:
+          if (r && a.expandedStates)
+            for (let i = a.expandedStates.length, s = i - 1; s >= 0; --s)
+              u.push(a.expandedStates[s]);
+          else
+            u.push(a.contents);
+          break;
+        case Ze:
+        case Ye:
+        case tt:
+        case Le:
+        case nt:
+          u.push(a.contents);
+          break;
+        case Qe:
+        case ft:
+        case et:
+        case Ue:
+        case se:
+        case Me:
+          break;
+        default:
+          throw new Pt(a);
+      }
+  }
+}
+var zn = gi;
+function Et(e, t) {
+  if (typeof e == "string")
+    return t(e);
+  let n = /* @__PURE__ */ new Map();
+  return r(e);
+  function r(a) {
+    if (n.has(a))
+      return n.get(a);
+    let o = u(a);
+    return n.set(a, o), o;
+  }
+  function u(a) {
+    switch (Ge(a)) {
+      case Pe:
+        return t(a.map(r));
+      case Re:
+        return t({ ...a, parts: a.parts.map(r) });
+      case Se:
+        return t({ ...a, breakContents: r(a.breakContents), flatContents: r(a.flatContents) });
+      case De: {
+        let { expandedStates: o, contents: i } = a;
+        return o ? (o = o.map(r), i = o[0]) : i = r(i), t({ ...a, contents: i, expandedStates: o });
+      }
+      case Ze:
+      case Ye:
+      case tt:
+      case Le:
+      case nt:
+        return t({ ...a, contents: r(a.contents) });
+      case Qe:
+      case ft:
+      case et:
+      case Ue:
+      case se:
+      case Me:
+        return t(a);
+      default:
+        throw new Pt(a);
+    }
+  }
+}
+function cu(e, t, n) {
+  let r = n, u = !1;
+  function a(o) {
+    if (u)
+      return !1;
+    let i = t(o);
+    i !== void 0 && (u = !0, r = i);
+  }
+  return zn(e, a), r;
+}
+function xi(e) {
+  if (e.type === De && e.break || e.type === se && e.hard || e.type === Me)
+    return !0;
+}
+function ne(e) {
+  return cu(e, xi, !1);
+}
+function hr(e) {
+  if (e.length > 0) {
+    let t = X(!1, e, -1);
+    !t.expandedStates && !t.break && (t.break = "propagated");
+  }
+  return null;
+}
+function hi(e) {
+  let t = /* @__PURE__ */ new Set(), n = [];
+  function r(a) {
+    if (a.type === Me && hr(n), a.type === De) {
+      if (n.push(a), t.has(a))
+        return !1;
+      t.add(a);
+    }
+  }
+  function u(a) {
+    a.type === De && n.pop().break && hr(n);
+  }
+  zn(e, r, u, !0);
+}
+function Ci(e) {
+  return e.type === se && !e.hard ? e.soft ? "" : " " : e.type === Se ? e.flatContents : e;
+}
+function bn(e) {
+  return Et(e, Ci);
+}
+function Ti(e) {
+  switch (Ge(e)) {
+    case Re:
+      if (e.parts.every((t) => t === ""))
+        return "";
+      break;
+    case De:
+      if (!e.contents && !e.id && !e.break && !e.expandedStates)
+        return "";
+      if (e.contents.type === De && e.contents.id === e.id && e.contents.break === e.break && e.contents.expandedStates === e.expandedStates)
+        return e.contents;
+      break;
+    case Ze:
+    case Ye:
+    case tt:
+    case nt:
+      if (!e.contents)
+        return "";
+      break;
+    case Se:
+      if (!e.flatContents && !e.breakContents)
+        return "";
+      break;
+    case Pe: {
+      let t = [];
+      for (let n of e) {
+        if (!n)
+          continue;
+        let [r, ...u] = Array.isArray(n) ? n : [n];
+        typeof r == "string" && typeof X(!1, t, -1) == "string" ? t[t.length - 1] += r : t.push(r), t.push(...u);
+      }
+      return t.length === 0 ? "" : t.length === 1 ? t[0] : t;
+    }
+    case Qe:
+    case ft:
+    case et:
+    case Ue:
+    case se:
+    case Le:
+    case Me:
+      break;
+    default:
+      throw new Pt(e);
+  }
+  return e;
+}
+function Qn(e) {
+  return Et(e, (t) => Ti(t));
+}
+function He(e, t = mu) {
+  return Et(e, (n) => typeof n == "string" ? N(t, n.split(`
+`)) : n);
+}
+function Si(e) {
+  if (e.type === se)
+    return !0;
+}
+function bi(e) {
+  return cu(e, Si, !1);
+}
+function Bn(e, t) {
+  return e.type === Le ? { ...e, contents: t(e.contents) } : t(e);
+}
+function Bi(e) {
+  let t = !0;
+  return zn(e, (n) => {
+    switch (Ge(n)) {
+      case Qe:
+        if (n === "")
+          break;
+      case et:
+      case Ue:
+      case se:
+      case Me:
+        return t = !1, !1;
+    }
+  }), t;
+}
+var vi = () => {
+}, ki = vi;
+function A(e) {
+  return { type: Ye, contents: e };
+}
+function Be(e, t) {
+  return { type: Ze, contents: t, n: e };
+}
+function m(e, t = {}) {
+  return ki(t.expandedStates), { type: De, id: t.id, contents: e, break: !!t.shouldBreak, expandedStates: t.expandedStates };
+}
+function Pi(e) {
+  return Be(Number.NEGATIVE_INFINITY, e);
+}
+function Du(e) {
+  return Be(-1, e);
+}
+function Ve(e, t) {
+  return m(e[0], { ...t, expandedStates: e });
+}
+function yu(e) {
+  return { type: Re, parts: e };
+}
+function w(e, t = "", n = {}) {
+  return { type: Se, breakContents: e, flatContents: t, groupId: n.groupId };
+}
+function an(e, t) {
+  return { type: tt, contents: e, groupId: t.groupId, negate: t.negate };
+}
+function Cr(e) {
+  return { type: nt, contents: e };
+}
+var we = { type: Ue }, ve = { type: Me }, du = { type: se, hard: !0 }, wi = { type: se, hard: !0, literal: !0 }, C = { type: se }, E = { type: se, soft: !0 }, F = [du, ve], mu = [wi, ve], $t = { type: ft };
+function N(e, t) {
+  let n = [];
+  for (let r = 0; r < t.length; r++)
+    r !== 0 && n.push(e), n.push(t[r]);
+  return n;
+}
+function Ii(e, t, n) {
+  let r = e;
+  if (t > 0) {
+    for (let u = 0; u < Math.floor(t / n); ++u)
+      r = A(r);
+    r = Be(t % n, r), r = Be(Number.NEGATIVE_INFINITY, r);
+  }
+  return r;
+}
+function jt(e, t) {
+  return e ? { type: Le, label: e, contents: t } : t;
+}
+function Ni(e) {
+  if (!ye(e))
+    return !1;
+  let t = `*${e.value}*`.split(`
+`);
+  return t.length > 1 && t.every((n) => n.trimStart()[0] === "*");
+}
+var dn = /* @__PURE__ */ new WeakMap();
+function ji(e) {
+  return dn.has(e) || dn.set(e, Ni(e)), dn.get(e);
+}
+var Li = ji;
+function Mi(e, t) {
+  let n = e.node;
+  if (Nt(n))
+    return t.originalText.slice(q(n), I(n)).trimEnd();
+  if (Li(n))
+    return Oi(n);
+  if (ye(n))
+    return ["/*", He(n.value), "*/"];
+  throw new Error("Not a comment: " + JSON.stringify(n));
+}
+function Oi(e) {
+  let t = e.value.split(`
+`);
+  return ["/*", N(F, t.map((n, r) => r === 0 ? n.trimEnd() : " " + (r < t.length - 1 ? n.trim() : n.trimStart()))), "*/"];
+}
+var fu = {};
+en(fu, { endOfLine: () => Ri, ownLine: () => Wi, remaining: () => Ui });
+function Ji(e) {
+  let t = e.type || e.kind || "(unknown type)", n = 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 n.length > 20 && (n = n.slice(0, 19) + "…"), t + (n ? " " + n : "");
+}
+function Yn(e, t) {
+  (e.comments ?? (e.comments = [])).push(t), t.printed = !1, t.nodeDescription = Ji(e);
+}
+function ee(e, t) {
+  t.leading = !0, t.trailing = !1, Yn(e, t);
+}
+function le(e, t, n) {
+  t.leading = !1, t.trailing = !1, n && (t.marker = n), Yn(e, t);
+}
+function R(e, t) {
+  t.leading = !1, t.trailing = !0, Yn(e, t);
+}
+function qi(e, t) {
+  let n = null, r = t;
+  for (; r !== n; )
+    n = r, r = ct(e, r), r = _n(e, r), r = Xn(e, r), r = Dt(e, r);
+  return r;
+}
+var Ft = qi;
+function _i(e, t) {
+  let n = Ft(e, t);
+  return n === !1 ? "" : e.charAt(n);
+}
+var ge = _i;
+function Xi(e, t, n) {
+  for (let r = t; r < n; ++r)
+    if (e.charAt(r) === `
+`)
+      return !0;
+  return !1;
+}
+var ce = Xi, mn = /* @__PURE__ */ new WeakMap();
+function $i(e) {
+  return mn.has(e) || mn.set(e, ye(e) && e.value[0] === "*" && /@(?:type|satisfies)\b/u.test(e.value)), mn.get(e);
+}
+var Eu = $i, Fu = (e, t) => Nt(e) || !ce(t, q(e), I(e));
+function Wi(e) {
+  return [bu, gu, Cu, ns, Vi, Zn, er, Au, xu, os, us, nr, Su, is, hu, Tu, tr, Ki, ds, Bu].some((t) => t(e));
+}
+function Ri(e) {
+  return [Gi, Cu, gu, Su, Zn, er, Au, xu, Tu, rs, as, nr, ls, tr, Ds, ys, ms, Bu].some((t) => t(e));
+}
+function Ui(e) {
+  return [bu, Zn, er, Hi, ts, hu, nr, es, Zi, tr, cs].some((t) => t(e));
+}
+function rt(e, t) {
+  let n = (e.body || e.properties).find(({ type: r }) => r !== "EmptyStatement");
+  n ? ee(n, t) : le(e, t);
+}
+function vn(e, t) {
+  e.type === "BlockStatement" ? rt(e, t) : ee(e, t);
+}
+function Gi({ comment: e, followingNode: t }) {
+  return t && Eu(e) ? (ee(t, e), !0) : !1;
+}
+function Zn({ comment: e, precedingNode: t, enclosingNode: n, followingNode: r, text: u }) {
+  if ((n == null ? void 0 : n.type) !== "IfStatement" || !r)
+    return !1;
+  if (ge(u, I(e)) === ")")
+    return R(t, e), !0;
+  if (t === n.consequent && r === n.alternate) {
+    let a = Ft(u, I(n.consequent));
+    if (q(e) < a || n.alternate.type === "BlockStatement")
+      return t.type === "BlockStatement" || Fu(e, u) && !ce(u, q(t), q(e)) ? (R(t, e), !0) : (le(n, e), !0);
+  }
+  return r.type === "BlockStatement" ? (rt(r, e), !0) : r.type === "IfStatement" ? (vn(r.consequent, e), !0) : n.consequent === r ? (ee(r, e), !0) : !1;
+}
+function er({ comment: e, precedingNode: t, enclosingNode: n, followingNode: r, text: u }) {
+  return (n == null ? void 0 : n.type) !== "WhileStatement" || !r ? !1 : ge(u, I(e)) === ")" ? (R(t, e), !0) : r.type === "BlockStatement" ? (rt(r, e), !0) : n.body === r ? (ee(r, e), !0) : !1;
+}
+function Au({ comment: e, precedingNode: t, enclosingNode: n, followingNode: r }) {
+  return (n == null ? void 0 : n.type) !== "TryStatement" && (n == null ? void 0 : n.type) !== "CatchClause" || !r ? !1 : n.type === "CatchClause" && t ? (R(t, e), !0) : r.type === "BlockStatement" ? (rt(r, e), !0) : r.type === "TryStatement" ? (vn(r.finalizer, e), !0) : r.type === "CatchClause" ? (vn(r.body, e), !0) : !1;
+}
+function Vi({ comment: e, enclosingNode: t, followingNode: n }) {
+  return W(t) && (n == null ? void 0 : n.type) === "Identifier" ? (ee(t, e), !0) : !1;
+}
+function Ki({ comment: e, enclosingNode: t, followingNode: n, options: r }) {
+  return !r.experimentalTernaries || !((t == null ? void 0 : t.type) === "ConditionalExpression" || We(t)) ? !1 : (n == null ? void 0 : n.type) === "ConditionalExpression" || We(n) ? (le(t, e), !0) : !1;
+}
+function gu({ comment: e, precedingNode: t, enclosingNode: n, followingNode: r, text: u, options: a }) {
+  let o = t && !ce(u, I(t), q(e));
+  return (!t || !o) && ((n == null ? void 0 : n.type) === "ConditionalExpression" || We(n)) && r ? a.experimentalTernaries && n.alternate === r && !(ye(e) && !ce(a.originalText, q(e), I(e))) ? (le(n, e), !0) : (ee(r, e), !0) : !1;
+}
+function Hi({ comment: e, precedingNode: t, enclosingNode: n }) {
+  return je(n) && n.shorthand && n.key === t && n.value.type === "AssignmentPattern" ? (R(n.value.left, e), !0) : !1;
+}
+var zi = /* @__PURE__ */ new Set(["ClassDeclaration", "ClassExpression", "DeclareClass", "DeclareInterface", "InterfaceDeclaration", "TSInterfaceDeclaration"]);
+function xu({ comment: e, precedingNode: t, enclosingNode: n, followingNode: r }) {
+  if (zi.has(n == null ? void 0 : n.type)) {
+    if (J(n.decorators) && (r == null ? void 0 : r.type) !== "Decorator")
+      return R(X(!1, n.decorators, -1), e), !0;
+    if (n.body && r === n.body)
+      return rt(n.body, e), !0;
+    if (r) {
+      if (n.superClass && r === n.superClass && t && (t === n.id || t === n.typeParameters))
+        return R(t, e), !0;
+      for (let u of ["implements", "extends", "mixins"])
+        if (n[u] && r === n[u][0])
+          return t && (t === n.id || t === n.typeParameters || t === n.superClass) ? R(t, e) : le(n, e, u), !0;
+    }
+  }
+  return !1;
+}
+var Qi = /* @__PURE__ */ new Set(["ClassMethod", "ClassProperty", "PropertyDefinition", "TSAbstractPropertyDefinition", "TSAbstractMethodDefinition", "TSDeclareMethod", "MethodDefinition", "ClassAccessorProperty", "AccessorProperty", "TSAbstractAccessorProperty", "TSParameterProperty"]);
+function hu({ comment: e, precedingNode: t, enclosingNode: n, text: r }) {
+  return n && t && ge(r, I(e)) === "(" && (n.type === "Property" || n.type === "TSDeclareMethod" || n.type === "TSAbstractMethodDefinition") && t.type === "Identifier" && n.key === t && ge(r, I(t)) !== ":" || (t == null ? void 0 : t.type) === "Decorator" && Qi.has(n == null ? void 0 : n.type) && (Nt(e) || e.placement === "ownLine") ? (R(t, e), !0) : !1;
+}
+var Yi = /* @__PURE__ */ new Set(["FunctionDeclaration", "FunctionExpression", "ClassMethod", "MethodDefinition", "ObjectMethod"]);
+function Zi({ comment: e, precedingNode: t, enclosingNode: n, text: r }) {
+  return ge(r, I(e)) !== "(" ? !1 : t && Yi.has(n == null ? void 0 : n.type) ? (R(t, e), !0) : !1;
+}
+function es({ comment: e, enclosingNode: t, text: n }) {
+  if ((t == null ? void 0 : t.type) !== "ArrowFunctionExpression")
+    return !1;
+  let r = Ft(n, I(e));
+  return r !== !1 && n.slice(r, r + 2) === "=>" ? (le(t, e), !0) : !1;
+}
+function ts({ comment: e, enclosingNode: t, text: n }) {
+  return ge(n, I(e)) !== ")" ? !1 : t && (vu(t) && Z(t).length === 0 || dt(t) && de(t).length === 0) ? (le(t, e), !0) : ((t == null ? void 0 : t.type) === "MethodDefinition" || (t == null ? void 0 : t.type) === "TSAbstractMethodDefinition") && Z(t.value).length === 0 ? (le(t.value, e), !0) : !1;
+}
+function ns({ comment: e, precedingNode: t, enclosingNode: n, followingNode: r, text: u }) {
+  return (t == null ? void 0 : t.type) === "ComponentTypeParameter" && ((n == null ? void 0 : n.type) === "DeclareComponent" || (n == null ? void 0 : n.type) === "ComponentTypeAnnotation") && (r == null ? void 0 : r.type) !== "ComponentTypeParameter" || ((t == null ? void 0 : t.type) === "ComponentParameter" || (t == null ? void 0 : t.type) === "RestElement") && (n == null ? void 0 : n.type) === "ComponentDeclaration" && ge(u, I(e)) === ")" ? (R(t, e), !0) : !1;
+}
+function Cu({ comment: e, precedingNode: t, enclosingNode: n, followingNode: r, text: u }) {
+  return (t == null ? void 0 : t.type) === "FunctionTypeParam" && (n == null ? void 0 : n.type) === "FunctionTypeAnnotation" && (r == null ? void 0 : r.type) !== "FunctionTypeParam" || ((t == null ? void 0 : t.type) === "Identifier" || (t == null ? void 0 : t.type) === "AssignmentPattern" || (t == null ? void 0 : t.type) === "ObjectPattern" || (t == null ? void 0 : t.type) === "ArrayPattern" || (t == null ? void 0 : t.type) === "RestElement" || (t == null ? void 0 : t.type) === "TSParameterProperty") && vu(n) && ge(u, I(e)) === ")" ? (R(t, e), !0) : !ye(e) && ((n == null ? void 0 : n.type) === "FunctionDeclaration" || (n == null ? void 0 : n.type) === "FunctionExpression" || (n == null ? void 0 : n.type) === "ObjectMethod") && (r == null ? void 0 : r.type) === "BlockStatement" && n.body === r && Ft(u, I(e)) === q(r) ? (rt(r, e), !0) : !1;
+}
+function Tu({ comment: e, enclosingNode: t }) {
+  return (t == null ? void 0 : t.type) === "LabeledStatement" ? (ee(t, e), !0) : !1;
+}
+function tr({ comment: e, enclosingNode: t }) {
+  return ((t == null ? void 0 : t.type) === "ContinueStatement" || (t == null ? void 0 : t.type) === "BreakStatement") && !t.label ? (R(t, e), !0) : !1;
+}
+function rs({ comment: e, precedingNode: t, enclosingNode: n }) {
+  return L(n) && t && n.callee === t && n.arguments.length > 0 ? (ee(n.arguments[0], e), !0) : !1;
+}
+function us({ comment: e, precedingNode: t, enclosingNode: n, followingNode: r }) {
+  return $e(n) ? (zt(e) && (r.prettierIgnore = !0, e.unignore = !0), t ? (R(t, e), !0) : !1) : ($e(r) && zt(e) && (r.types[0].prettierIgnore = !0, e.unignore = !0), !1);
+}
+function as({ comment: e, enclosingNode: t }) {
+  return je(t) ? (ee(t, e), !0) : !1;
+}
+function nr({ comment: e, enclosingNode: t, ast: n, isLastComment: r }) {
+  var u;
+  return ((u = n == null ? void 0 : n.body) == null ? void 0 : u.length) === 0 ? (r ? le(n, e) : ee(n, e), !0) : (t == null ? void 0 : t.type) === "Program" && t.body.length === 0 && !J(t.directives) ? (r ? le(t, e) : ee(t, e), !0) : !1;
+}
+function os({ comment: e, enclosingNode: t }) {
+  return (t == null ? void 0 : t.type) === "ForInStatement" || (t == null ? void 0 : t.type) === "ForOfStatement" ? (ee(t, e), !0) : !1;
+}
+function Su({ comment: e, precedingNode: t, enclosingNode: n, text: r }) {
+  if ((n == null ? void 0 : n.type) === "ImportSpecifier" || (n == null ? void 0 : n.type) === "ExportSpecifier")
+    return ee(n, e), !0;
+  let u = (t == null ? void 0 : t.type) === "ImportSpecifier" && (n == null ? void 0 : n.type) === "ImportDeclaration", a = (t == null ? void 0 : t.type) === "ExportSpecifier" && (n == null ? void 0 : n.type) === "ExportNamedDeclaration";
+  return (u || a) && pe(r, I(e)) ? (R(t, e), !0) : !1;
+}
+function is({ comment: e, enclosingNode: t }) {
+  return (t == null ? void 0 : t.type) === "AssignmentPattern" ? (ee(t, e), !0) : !1;
+}
+var ss = /* @__PURE__ */ new Set(["VariableDeclarator", "AssignmentExpression", "TypeAlias", "TSTypeAliasDeclaration"]), ps = /* @__PURE__ */ new Set(["ObjectExpression", "ArrayExpression", "TemplateLiteral", "TaggedTemplateExpression", "ObjectTypeAnnotation", "TSTypeLiteral"]);
+function ls({ comment: e, enclosingNode: t, followingNode: n }) {
+  return ss.has(t == null ? void 0 : t.type) && n && (ps.has(n.type) || ye(e)) ? (ee(n, e), !0) : !1;
+}
+function cs({ comment: e, enclosingNode: t, followingNode: n, text: r }) {
+  return !n && ((t == null ? void 0 : t.type) === "TSMethodSignature" || (t == null ? void 0 : t.type) === "TSDeclareFunction" || (t == null ? void 0 : t.type) === "TSAbstractMethodDefinition") && ge(r, I(e)) === ";" ? (R(t, e), !0) : !1;
+}
+function bu({ comment: e, enclosingNode: t, followingNode: n }) {
+  if (zt(e) && (t == null ? void 0 : t.type) === "TSMappedType" && n === t.key)
+    return t.prettierIgnore = !0, e.unignore = !0, !0;
+}
+function Bu({ comment: e, precedingNode: t, enclosingNode: n }) {
+  if ((n == null ? void 0 : n.type) === "TSMappedType" && !t)
+    return le(n, e), !0;
+}
+function Ds({ comment: e, enclosingNode: t, followingNode: n }) {
+  return !t || t.type !== "SwitchCase" || t.test || !n || n !== t.consequent[0] ? !1 : (n.type === "BlockStatement" && Nt(e) ? rt(n, e) : le(t, e), !0);
+}
+function ys({ comment: e, precedingNode: t, enclosingNode: n, followingNode: r }) {
+  return $e(t) && ((n.type === "TSArrayType" || n.type === "ArrayTypeAnnotation") && !r || Hn(n)) ? (R(X(!1, t.types, -1), e), !0) : !1;
+}
+function ds({ comment: e, enclosingNode: t, precedingNode: n, followingNode: r }) {
+  if (((t == null ? void 0 : t.type) === "ObjectPattern" || (t == null ? void 0 : t.type) === "ArrayPattern") && (r == null ? void 0 : r.type) === "TSTypeAnnotation")
+    return n ? R(n, e) : le(t, e), !0;
+}
+function ms({ comment: e, precedingNode: t, enclosingNode: n, followingNode: r, text: u }) {
+  return !r && (n == null ? void 0 : n.type) === "UnaryExpression" && ((t == null ? void 0 : t.type) === "LogicalExpression" || (t == null ? void 0 : t.type) === "BinaryExpression") && ce(u, q(n.argument), q(t.right)) && Fu(e, u) && !ce(u, q(t.right), q(e)) ? (R(t.right, e), !0) : !1;
+}
+var vu = _(["ArrowFunctionExpression", "FunctionExpression", "FunctionDeclaration", "ObjectMethod", "ClassMethod", "TSDeclareFunction", "TSCallSignatureDeclaration", "TSConstructSignatureDeclaration", "TSMethodSignature", "TSConstructorType", "TSFunctionType", "TSDeclareMethod"]), fs = /* @__PURE__ */ new Set(["EmptyStatement", "TemplateElement", "TSEmptyBodyFunctionExpression", "ChainExpression"]);
+function Es(e) {
+  return !fs.has(e.type);
+}
+function Fs(e, t) {
+  var n;
+  if ((t.parser === "typescript" || t.parser === "flow" || t.parser === "hermes" || t.parser === "acorn" || t.parser === "oxc" || t.parser === "oxc-ts" || t.parser === "espree" || t.parser === "meriyah" || t.parser === "__babel_estree") && e.type === "MethodDefinition" && ((n = e.value) == null ? void 0 : n.type) === "FunctionExpression" && Z(e.value).length === 0 && !e.value.returnType && !J(e.value.typeParameters) && e.value.body)
+    return [...e.decorators || [], e.key, e.value.body];
+}
+function ku(e) {
+  let { node: t, parent: n } = e;
+  return (K(t) || n && (n.type === "JSXSpreadAttribute" || n.type === "JSXSpreadChild" || $e(n) || (n.type === "ClassDeclaration" || n.type === "ClassExpression") && n.superClass === t)) && (!un(t) || $e(n));
+}
+function As(e, { parser: t }) {
+  if (t === "flow" || t === "hermes" || t === "babel-flow")
+    return e = H(!1, e, /[\s(]/gu, ""), e === "" || e === "/*" || e === "/*::";
+}
+function gs(e) {
+  switch (e) {
+    case "cr":
+      return "\r";
+    case "crlf":
+      return `\r
+`;
+    default:
+      return `
+`;
+  }
+}
+var ae = Symbol("MODE_BREAK"), he = Symbol("MODE_FLAT"), pt = Symbol("cursor"), kn = Symbol("DOC_FILL_PRINTED_LENGTH");
+function Pu() {
+  return { value: "", length: 0, queue: [] };
+}
+function xs(e, t) {
+  return Pn(e, { type: "indent" }, t);
+}
+function hs(e, t, n) {
+  return t === Number.NEGATIVE_INFINITY ? e.root || Pu() : t < 0 ? Pn(e, { type: "dedent" }, n) : t ? t.type === "root" ? { ...e, root: e } : Pn(e, { type: typeof t == "string" ? "stringAlign" : "numberAlign", n: t }, n) : e;
+}
+function Pn(e, t, n) {
+  let r = t.type === "dedent" ? e.queue.slice(0, -1) : [...e.queue, t], u = "", a = 0, o = 0, i = 0;
+  for (let y of r)
+    switch (y.type) {
+      case "indent":
+        d(), n.useTabs ? s(1) : l(n.tabWidth);
+        break;
+      case "stringAlign":
+        d(), u += y.n, a += y.n.length;
+        break;
+      case "numberAlign":
+        o += 1, i += y.n;
+        break;
+      default:
+        throw new Error(`Unexpected type '${y.type}'`);
+    }
+  return c(), { ...e, value: u, length: a, queue: r };
+  function s(y) {
+    u += "	".repeat(y), a += n.tabWidth * y;
+  }
+  function l(y) {
+    u += " ".repeat(y), a += y;
+  }
+  function d() {
+    n.useTabs ? D() : c();
+  }
+  function D() {
+    o > 0 && s(o), p();
+  }
+  function c() {
+    i > 0 && l(i), p();
+  }
+  function p() {
+    o = 0, i = 0;
+  }
+}
+function wn(e) {
+  let t = 0, n = 0, r = e.length;
+  e:
+    for (; r--; ) {
+      let u = e[r];
+      if (u === pt) {
+        n++;
+        continue;
+      }
+      for (let a = u.length - 1; a >= 0; a--) {
+        let o = u[a];
+        if (o === " " || o === "	")
+          t++;
+        else {
+          e[r] = u.slice(0, a + 1);
+          break e;
+        }
+      }
+    }
+  if (t > 0 || n > 0)
+    for (e.length = r + 1; n-- > 0; )
+      e.push(pt);
+  return t;
+}
+function Wt(e, t, n, r, u, a) {
+  if (n === Number.POSITIVE_INFINITY)
+    return !0;
+  let o = t.length, i = [e], s = [];
+  for (; n >= 0; ) {
+    if (i.length === 0) {
+      if (o === 0)
+        return !0;
+      i.push(t[--o]);
+      continue;
+    }
+    let { mode: l, doc: d } = i.pop(), D = Ge(d);
+    switch (D) {
+      case Qe:
+        s.push(d), n -= lt(d);
+        break;
+      case Pe:
+      case Re: {
+        let c = D === Pe ? d : d.parts, p = d[kn] ?? 0;
+        for (let y = c.length - 1; y >= p; y--)
+          i.push({ mode: l, doc: c[y] });
+        break;
+      }
+      case Ye:
+      case Ze:
+      case tt:
+      case Le:
+        i.push({ mode: l, doc: d.contents });
+        break;
+      case et:
+        n += wn(s);
+        break;
+      case De: {
+        if (a && d.break)
+          return !1;
+        let c = d.break ? ae : l, p = d.expandedStates && c === ae ? X(!1, d.expandedStates, -1) : d.contents;
+        i.push({ mode: c, doc: p });
+        break;
+      }
+      case Se: {
+        let c = (d.groupId ? u[d.groupId] || he : l) === ae ? d.breakContents : d.flatContents;
+        c && i.push({ mode: l, doc: c });
+        break;
+      }
+      case se:
+        if (l === ae || d.hard)
+          return !0;
+        d.soft || (s.push(" "), n--);
+        break;
+      case nt:
+        r = !0;
+        break;
+      case Ue:
+        if (r)
+          return !1;
+        break;
+    }
+  }
+  return !1;
+}
+function wu(e, t) {
+  let n = {}, r = t.printWidth, u = gs(t.endOfLine), a = 0, o = [{ ind: Pu(), mode: ae, doc: e }], i = [], s = !1, l = [], d = 0;
+  for (hi(e); o.length > 0; ) {
+    let { ind: c, mode: p, doc: y } = o.pop();
+    switch (Ge(y)) {
+      case Qe: {
+        let f = u !== `
+` ? H(!1, y, `
+`, u) : y;
+        i.push(f), o.length > 0 && (a += lt(f));
+        break;
+      }
+      case Pe:
+        for (let f = y.length - 1; f >= 0; f--)
+          o.push({ ind: c, mode: p, doc: y[f] });
+        break;
+      case ft:
+        if (d >= 2)
+          throw new Error("There are too many 'cursor' in doc.");
+        i.push(pt), d++;
+        break;
+      case Ye:
+        o.push({ ind: xs(c, t), mode: p, doc: y.contents });
+        break;
+      case Ze:
+        o.push({ ind: hs(c, y.n, t), mode: p, doc: y.contents });
+        break;
+      case et:
+        a -= wn(i);
+        break;
+      case De:
+        switch (p) {
+          case he:
+            if (!s) {
+              o.push({ ind: c, mode: y.break ? ae : he, doc: y.contents });
+              break;
+            }
+          case ae: {
+            s = !1;
+            let f = { ind: c, mode: he, doc: y.contents }, g = r - a, S = l.length > 0;
+            if (!y.break && Wt(f, o, g, S, n))
+              o.push(f);
+            else if (y.expandedStates) {
+              let b = X(!1, y.expandedStates, -1);
+              if (y.break) {
+                o.push({ ind: c, mode: ae, doc: b });
+                break;
+              } else
+                for (let x = 1; x < y.expandedStates.length + 1; x++)
+                  if (x >= y.expandedStates.length) {
+                    o.push({ ind: c, mode: ae, doc: b });
+                    break;
+                  } else {
+                    let j = y.expandedStates[x], v = { ind: c, mode: he, doc: j };
+                    if (Wt(v, o, g, S, n)) {
+                      o.push(v);
+                      break;
+                    }
+                  }
+            } else
+              o.push({ ind: c, mode: ae, doc: y.contents });
+            break;
+          }
+        }
+        y.id && (n[y.id] = X(!1, o, -1).mode);
+        break;
+      case Re: {
+        let f = r - a, g = y[kn] ?? 0, { parts: S } = y, b = S.length - g;
+        if (b === 0)
+          break;
+        let x = S[g + 0], j = S[g + 1], v = { ind: c, mode: he, doc: x }, B = { ind: c, mode: ae, doc: x }, M = Wt(v, [], f, l.length > 0, n, !0);
+        if (b === 1) {
+          M ? o.push(v) : o.push(B);
+          break;
+        }
+        let k = { ind: c, mode: he, doc: j }, O = { ind: c, mode: ae, doc: j };
+        if (b === 2) {
+          M ? o.push(k, v) : o.push(O, B);
+          break;
+        }
+        let G = S[g + 2], U = { ind: c, mode: p, doc: { ...y, [kn]: g + 2 } };
+        Wt({ ind: c, mode: he, doc: [x, j, G] }, [], f, l.length > 0, n, !0) ? o.push(U, k, v) : M ? o.push(U, O, v) : o.push(U, O, B);
+        break;
+      }
+      case Se:
+      case tt: {
+        let f = y.groupId ? n[y.groupId] : p;
+        if (f === ae) {
+          let g = y.type === Se ? y.breakContents : y.negate ? y.contents : A(y.contents);
+          g && o.push({ ind: c, mode: p, doc: g });
+        }
+        if (f === he) {
+          let g = y.type === Se ? y.flatContents : y.negate ? A(y.contents) : y.contents;
+          g && o.push({ ind: c, mode: p, doc: g });
+        }
+        break;
+      }
+      case nt:
+        l.push({ ind: c, mode: p, doc: y.contents });
+        break;
+      case Ue:
+        l.length > 0 && o.push({ ind: c, mode: p, doc: du });
+        break;
+      case se:
+        switch (p) {
+          case he:
+            if (y.hard)
+              s = !0;
+            else {
+              y.soft || (i.push(" "), a += 1);
+              break;
+            }
+          case ae:
+            if (l.length > 0) {
+              o.push({ ind: c, mode: p, doc: y }, ...l.reverse()), l.length = 0;
+              break;
+            }
+            y.literal ? c.root ? (i.push(u, c.root.value), a = c.root.length) : (i.push(u), a = 0) : (a -= wn(i), i.push(u + c.value), a = c.length);
+            break;
+        }
+        break;
+      case Le:
+        o.push({ ind: c, mode: p, doc: y.contents });
+        break;
+      case Me:
+        break;
+      default:
+        throw new Pt(y);
+    }
+    o.length === 0 && l.length > 0 && (o.push(...l.reverse()), l.length = 0);
+  }
+  let D = i.indexOf(pt);
+  if (D !== -1) {
+    let c = i.indexOf(pt, D + 1);
+    if (c === -1)
+      return { formatted: i.filter((g) => g !== pt).join("") };
+    let p = i.slice(0, D).join(""), y = i.slice(D + 1, c).join(""), f = i.slice(c + 1).join("");
+    return { formatted: p + y + f, cursorNodeStart: p.length, cursorNodeText: y };
+  }
+  return { formatted: i.join("") };
+}
+function Cs(e, t, n = 0) {
+  let r = 0;
+  for (let u = n; u < e.length; ++u)
+    e[u] === "	" ? r = r + t - r % t : r++;
+  return r;
+}
+var Ts = Cs;
+function Ss(e, t) {
+  let n = e.lastIndexOf(`
+`);
+  return n === -1 ? 0 : Ts(e.slice(n + 1).match(/^[\t ]*/u)[0], t);
+}
+var bs = Ss;
+function Iu(e, t, n) {
+  let { node: r } = e;
+  if (r.type === "TemplateLiteral" && Ps(e)) {
+    let s = vs(e, t, n);
+    if (s)
+      return s;
+  }
+  let u = "expressions";
+  r.type === "TSTemplateLiteralType" && (u = "types");
+  let a = [], o = e.map(n, u);
+  a.push(we, "`");
+  let i = 0;
+  return e.each(({ index: s, node: l }) => {
+    if (a.push(n()), l.tail)
+      return;
+    let { tabWidth: d } = t, D = l.value.raw, c = D.includes(`
+`) ? bs(D, d) : i;
+    i = c;
+    let p = o[s], y = r[u][s], f = ce(t.originalText, I(l), q(r.quasis[s + 1]));
+    if (!f) {
+      let S = wu(p, { ...t, printWidth: Number.POSITIVE_INFINITY }).formatted;
+      S.includes(`
+`) ? f = !0 : p = S;
+    }
+    f && (h(y) || y.type === "Identifier" || W(y) || y.type === "ConditionalExpression" || y.type === "SequenceExpression" || Ce(y) || ke(y)) && (p = [A([E, p]), E]);
+    let g = c === 0 && D.endsWith(`
+`) ? Be(Number.NEGATIVE_INFINITY, p) : Ii(p, c, d);
+    a.push(m(["${", g, we, "}"]));
+  }, "quasis"), a.push("`"), a;
+}
+function Bs(e, t, n) {
+  let r = n("quasi"), { node: u } = e, a = "", o = Ke(u.quasi, T.Leading)[0];
+  return o && (ce(t.originalText, I(u.typeArguments ?? u.typeParameters ?? u.tag), q(o)) ? a = E : a = " "), jt(r.label && { tagged: !0, ...r.label }, [n("tag"), n(u.typeArguments ? "typeArguments" : "typeParameters"), a, we, r]);
+}
+function vs(e, t, n) {
+  let { node: r } = e, u = r.quasis[0].value.raw.trim().split(/\s*\|\s*/u);
+  if (u.length > 1 || u.some((a) => a.length > 0)) {
+    t.__inJestEach = !0;
+    let a = e.map(n, "expressions");
+    t.__inJestEach = !1;
+    let o = [], i = a.map((c) => "${" + wu(c, { ...t, printWidth: Number.POSITIVE_INFINITY, endOfLine: "lf" }).formatted + "}"), s = [{ hasLineBreak: !1, cells: [] }];
+    for (let c = 1; c < r.quasis.length; c++) {
+      let p = X(!1, s, -1), y = i[c - 1];
+      p.cells.push(y), y.includes(`
+`) && (p.hasLineBreak = !0), r.quasis[c].value.raw.includes(`
+`) && s.push({ hasLineBreak: !1, cells: [] });
+    }
+    let l = Math.max(u.length, ...s.map((c) => c.cells.length)), d = Array.from({ length: l }).fill(0), D = [{ cells: u }, ...s.filter((c) => c.cells.length > 0)];
+    for (let { cells: c } of D.filter((p) => !p.hasLineBreak))
+      for (let [p, y] of c.entries())
+        d[p] = Math.max(d[p], lt(y));
+    return o.push(we, "`", A([F, N(F, D.map((c) => N(" | ", c.cells.map((p, y) => c.hasLineBreak ? p : p + " ".repeat(d[y] - lt(p))))))]), F, "`"), o;
+  }
+}
+function ks(e, t) {
+  let { node: n } = e, r = t();
+  return h(n) && (r = m([A([E, r]), E])), ["${", r, we, "}"];
+}
+function rr(e, t) {
+  return e.map((n) => ks(n, t), "expressions");
+}
+function Nu(e, t) {
+  return Et(e, (n) => typeof n == "string" ? t ? H(!1, n, /(\\*)`/gu, "$1$1\\`") : ju(n) : n);
+}
+function ju(e) {
+  return H(!1, e, /([\\`]|\$\{)/gu, String.raw`\$1`);
+}
+function Ps({ node: e, parent: t }) {
+  let n = /^[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" && n.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" && n.test(t.tag.object.object.name));
+}
+var In = [(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 ws(e) {
+  let t = (r) => r.type === "TemplateLiteral", n = (r, u) => je(r) && !r.computed && r.key.type === "Identifier" && r.key.name === "styles" && u === "value";
+  return e.match(t, (r, u) => Q(r) && u === "elements", n, ...In) || e.match(t, n, ...In);
+}
+function Is(e) {
+  return e.match((t) => t.type === "TemplateLiteral", (t, n) => je(t) && !t.computed && t.key.type === "Identifier" && t.key.name === "template" && n === "value", ...In);
+}
+function fn(e, t) {
+  return h(e, T.Block | T.Leading, ({ value: n }) => n === ` ${t} `);
+}
+function Lu({ node: e, parent: t }, n) {
+  return fn(e, n) || Ns(t) && fn(t, n) || t.type === "ExpressionStatement" && fn(t, n);
+}
+function Ns(e) {
+  return e.type === "AsConstExpression" || e.type === "TSAsExpression" && e.typeAnnotation.type === "TSTypeReference" && e.typeAnnotation.typeName.type === "Identifier" && e.typeAnnotation.typeName.name === "const";
+}
+async function js(e, t, n) {
+  let { node: r } = n, u = r.quasis.map((d) => d.value.raw), a = 0, o = u.reduce((d, D, c) => c === 0 ? D : d + "@prettier-placeholder-" + a++ + "-id" + D, ""), i = await e(o, { parser: "scss" }), s = rr(n, t), l = Ls(i, s);
+  if (!l)
+    throw new Error("Couldn't insert all the expressions");
+  return ["`", A([F, l]), E, "`"];
+}
+function Ls(e, t) {
+  if (!J(t))
+    return e;
+  let n = 0, r = Et(Qn(e), (u) => typeof u != "string" || !u.includes("@prettier-placeholder") ? u : u.split(/@prettier-placeholder-(\d+)-id/u).map((a, o) => o % 2 === 0 ? He(a) : (n++, t[a])));
+  return t.length === n ? r : null;
+}
+function Ms({ node: e, parent: t, grandparent: n }) {
+  return n && e.quasis && t.type === "JSXExpressionContainer" && n.type === "JSXElement" && n.openingElement.name.name === "style" && n.openingElement.attributes.some((r) => r.type === "JSXAttribute" && r.name.name === "jsx") || (t == null ? void 0 : t.type) === "TaggedTemplateExpression" && t.tag.type === "Identifier" && t.tag.name === "css" || (t == null ? void 0 : t.type) === "TaggedTemplateExpression" && t.tag.type === "MemberExpression" && t.tag.object.name === "css" && (t.tag.property.name === "global" || t.tag.property.name === "resolve");
+}
+function Rt(e) {
+  return e.type === "Identifier" && e.name === "styled";
+}
+function Tr(e) {
+  return /^[A-Z]/u.test(e.object.name) && e.property.name === "extend";
+}
+function Os({ parent: e }) {
+  if (!e || e.type !== "TaggedTemplateExpression")
+    return !1;
+  let t = e.tag.type === "ParenthesizedExpression" ? e.tag.expression : e.tag;
+  switch (t.type) {
+    case "MemberExpression":
+      return Rt(t.object) || Tr(t);
+    case "CallExpression":
+      return Rt(t.callee) || t.callee.type === "MemberExpression" && (t.callee.object.type === "MemberExpression" && (Rt(t.callee.object.object) || Tr(t.callee.object)) || t.callee.object.type === "CallExpression" && Rt(t.callee.object.callee));
+    case "Identifier":
+      return t.name === "css";
+    default:
+      return !1;
+  }
+}
+function Js({ parent: e, grandparent: t }) {
+  return (t == null ? void 0 : t.type) === "JSXAttribute" && e.type === "JSXExpressionContainer" && t.name.type === "JSXIdentifier" && t.name.name === "css";
+}
+function qs(e) {
+  if (Ms(e) || Os(e) || Js(e) || ws(e))
+    return js;
+}
+var _s = qs;
+async function Xs(e, t, n) {
+  let { node: r } = n, u = r.quasis.length, a = rr(n, t), o = [];
+  for (let i = 0; i < u; i++) {
+    let s = r.quasis[i], l = i === 0, d = i === u - 1, D = s.value.cooked, c = D.split(`
+`), p = c.length, y = a[i], f = p > 2 && c[0].trim() === "" && c[1].trim() === "", g = p > 2 && c[p - 1].trim() === "" && c[p - 2].trim() === "", S = c.every((x) => /^\s*(?:#[^\n\r]*)?$/u.test(x));
+    if (!d && /#[^\n\r]*$/u.test(c[p - 1]))
+      return null;
+    let b = null;
+    S ? b = $s(c) : b = await e(D, { parser: "graphql" }), b ? (b = Nu(b, !1), !l && f && o.push(""), o.push(b), !d && g && o.push("")) : !l && !d && f && o.push(""), y && o.push(y);
+  }
+  return ["`", A([F, N(F, o)]), F, "`"];
+}
+function $s(e) {
+  let t = [], n = !1, r = e.map((u) => u.trim());
+  for (let [u, a] of r.entries())
+    a !== "" && (r[u - 1] === "" && n ? t.push([F, a]) : t.push(a), n = !0);
+  return t.length === 0 ? null : N(F, t);
+}
+function Ws({ node: e, parent: t }) {
+  return Lu({ 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");
+}
+function Rs(e) {
+  if (Ws(e))
+    return Xs;
+}
+var Us = Rs, En = 0;
+async function Mu(e, t, n, r, u) {
+  let { node: a } = r, o = En;
+  En = En + 1 >>> 0;
+  let i = (S) => `PRETTIER_HTML_PLACEHOLDER_${S}_${o}_IN_JS`, s = a.quasis.map((S, b, x) => b === x.length - 1 ? S.value.cooked : S.value.cooked + i(b)).join(""), l = rr(r, n), d = new RegExp(i(String.raw`(\d+)`), "gu"), D = 0, c = await t(s, { parser: e, __onHtmlRoot(S) {
+    D = S.children.length;
+  } }), p = Et(c, (S) => {
+    if (typeof S != "string")
+      return S;
+    let b = [], x = S.split(d);
+    for (let j = 0; j < x.length; j++) {
+      let v = x[j];
+      if (j % 2 === 0) {
+        v && (v = ju(v), u.__embeddedInHtml && (v = H(!1, v, /<\/(?=script\b)/giu, String.raw`<\/`)), b.push(v));
+        continue;
+      }
+      let B = Number(v);
+      b.push(l[B]);
+    }
+    return b;
+  }), y = /^\s/u.test(s) ? " " : "", f = /\s$/u.test(s) ? " " : "", g = u.htmlWhitespaceSensitivity === "ignore" ? F : y && f ? C : null;
+  return g ? m(["`", A([g, m(p)]), g, "`"]) : jt({ hug: !1 }, m(["`", y, D > 1 ? A(m(p)) : m(p), f, "`"]));
+}
+function Gs(e) {
+  return Lu(e, "HTML") || e.match((t) => t.type === "TemplateLiteral", (t, n) => t.type === "TaggedTemplateExpression" && t.tag.type === "Identifier" && t.tag.name === "html" && n === "quasi");
+}
+var Vs = Mu.bind(void 0, "html"), Ks = Mu.bind(void 0, "angular");
+function Hs(e) {
+  if (Gs(e))
+    return Vs;
+  if (Is(e))
+    return Ks;
+}
+var zs = Hs;
+async function Qs(e, t, n) {
+  let { node: r } = n, u = H(!1, r.quasis[0].value.raw, /((?:\\\\)*)\\`/gu, (s, l) => "\\".repeat(l.length / 2) + "`"), a = Ys(u), o = a !== "";
+  o && (u = H(!1, u, new RegExp(`^${a}`, "gmu"), ""));
+  let i = Nu(await e(u, { parser: "markdown", __inJsTemplate: !0 }), !0);
+  return ["`", o ? A([E, i]) : [mu, Pi(i)], E, "`"];
+}
+function Ys(e) {
+  let t = e.match(/^([^\S\n]*)\S/mu);
+  return t === null ? "" : t[1];
+}
+function Zs(e) {
+  if (ep(e))
+    return Qs;
+}
+function ep({ node: e, parent: t }) {
+  return (t == null ? void 0 : t.type) === "TaggedTemplateExpression" && e.quasis.length === 1 && t.tag.type === "Identifier" && (t.tag.name === "md" || t.tag.name === "markdown");
+}
+var tp = Zs;
+function np(e) {
+  let { node: t } = e;
+  if (t.type !== "TemplateLiteral" || rp(t))
+    return;
+  let n;
+  for (let r of [_s, Us, zs, tp])
+    if (n = r(e), !!n)
+      return t.quasis.length === 1 && t.quasis[0].value.raw.trim() === "" ? "``" : async (...u) => {
+        let a = await n(...u);
+        return a && jt({ embed: !0, ...a.label }, a);
+      };
+}
+function rp({ quasis: e }) {
+  return e.some(({ value: { cooked: t } }) => t === null);
+}
+var up = np, ap = /\*\/$/, op = /^\/\*\*?/, Ou = /^\s*(\/\*\*?(.|\r?\n)*?\*\/)/, ip = /(^|\s+)\/\/([^\n\r]*)/g, Sr = /^(\r?\n)+/, sp = /(?:^|\r?\n) *(@[^\n\r]*?) *\r?\n *(?![^\n\r@]*\/\/[^]*)([^\s@][^\n\r@]+?) *\r?\n/g, br = /(?:^|\r?\n) *@(\S+) *([^\n\r]*)/g, pp = /(\r?\n|^) *\* ?/g, Ju = [];
+function lp(e) {
+  let t = e.match(Ou);
+  return t ? t[0].trimStart() : "";
+}
+function cp(e) {
+  let t = e.match(Ou), n = t == null ? void 0 : t[0];
+  return n == null ? e : e.slice(n.length);
+}
+function Dp(e) {
+  let t = `
+`;
+  e = H(!1, e.replace(op, "").replace(ap, ""), pp, "$1");
+  let n = "";
+  for (; n !== e; )
+    n = e, e = H(!1, e, sp, `${t}$1 $2${t}`);
+  e = e.replace(Sr, "").trimEnd();
+  let r = /* @__PURE__ */ Object.create(null), u = H(!1, e, br, "").replace(Sr, "").trimEnd(), a;
+  for (; a = br.exec(e); ) {
+    let o = H(!1, a[2], ip, "");
+    if (typeof r[a[1]] == "string" || Array.isArray(r[a[1]])) {
+      let i = r[a[1]];
+      r[a[1]] = [...Ju, ...Array.isArray(i) ? i : [i], o];
+    } else
+      r[a[1]] = o;
+  }
+  return { comments: u, pragmas: r };
+}
+function yp({ comments: e = "", pragmas: t = {} }) {
+  let n = `
+`, r = "/**", u = " *", a = " */", o = Object.keys(t), i = o.flatMap((l) => Br(l, t[l])).map((l) => `${u} ${l}${n}`).join("");
+  if (!e) {
+    if (o.length === 0)
+      return "";
+    if (o.length === 1 && !Array.isArray(t[o[0]])) {
+      let l = t[o[0]];
+      return `${r} ${Br(o[0], l)[0]}${a}`;
+    }
+  }
+  let s = e.split(n).map((l) => `${u} ${l}`).join(n) + n;
+  return r + n + (e ? s : "") + (e && o.length > 0 ? u + n : "") + i + a;
+}
+function Br(e, t) {
+  return [...Ju, ...Array.isArray(t) ? t : [t]].map((n) => `@${e} ${n}`.trim());
+}
+var dp = "format";
+function mp(e) {
+  if (!e.startsWith("#!"))
+    return "";
+  let t = e.indexOf(`
+`);
+  return t === -1 ? e : e.slice(0, t);
+}
+var fp = mp;
+function Ep(e) {
+  let t = fp(e);
+  t && (e = e.slice(t.length + 1));
+  let n = lp(e), { pragmas: r, comments: u } = Dp(n);
+  return { shebang: t, text: e, pragmas: r, comments: u };
+}
+function Fp(e) {
+  let { shebang: t, text: n, pragmas: r, comments: u } = Ep(e), a = cp(n), o = yp({ pragmas: { [dp]: "", ...r }, comments: u.trimStart() });
+  return (t ? `${t}
+` : "") + o + (a.startsWith(`
+`) ? `
+` : `
+
+`) + a;
+}
+function Ap(e, t) {
+  let { originalText: n, [Symbol.for("comments")]: r, locStart: u, locEnd: a, [Symbol.for("printedComments")]: o } = t, { node: i } = e, s = u(i), l = a(i);
+  for (let d of r)
+    u(d) >= s && a(d) <= l && o.add(d);
+  return n.slice(s, l);
+}
+var gp = Ap;
+function Nn(e, t) {
+  var n, r, u, a, o, i, s, l, d;
+  if (e.isRoot)
+    return !1;
+  let { node: D, key: c, parent: p } = e;
+  if (t.__isInHtmlInterpolation && !t.bracketSpacing && Tp(D) && St(e))
+    return !0;
+  if (xp(D))
+    return !1;
+  if (D.type === "Identifier") {
+    if ((n = D.extra) != null && n.parenthesized && /^PRETTIER_HTML_PLACEHOLDER_\d+_\d+_IN_JS$/u.test(D.name) || c === "left" && (D.name === "async" && !p.await || D.name === "let") && p.type === "ForOfStatement")
+      return !0;
+    if (D.name === "let") {
+      let y = (r = e.findAncestor((f) => f.type === "ForOfStatement")) == null ? void 0 : r.left;
+      if (y && te(y, (f) => f === D))
+        return !0;
+    }
+    if (c === "object" && D.name === "let" && p.type === "MemberExpression" && p.computed && !p.optional) {
+      let y = e.findAncestor((g) => g.type === "ExpressionStatement" || g.type === "ForStatement" || g.type === "ForInStatement"), f = y ? y.type === "ExpressionStatement" ? y.expression : y.type === "ForStatement" ? y.init : y.left : void 0;
+      if (f && te(f, (g) => g === D))
+        return !0;
+    }
+    if (c === "expression")
+      switch (D.name) {
+        case "await":
+        case "interface":
+        case "module":
+        case "using":
+        case "yield":
+        case "let":
+        case "component":
+        case "hook":
+        case "type": {
+          let y = e.findAncestor((f) => !Ce(f));
+          if (y !== p && y.type === "ExpressionStatement")
+            return !0;
+        }
+      }
+    return !1;
+  }
+  if (D.type === "ObjectExpression" || D.type === "FunctionExpression" || D.type === "ClassExpression" || D.type === "DoExpression") {
+    let y = (u = e.findAncestor((f) => f.type === "ExpressionStatement")) == null ? void 0 : u.expression;
+    if (y && te(y, (f) => f === D))
+      return !0;
+  }
+  if (D.type === "ObjectExpression") {
+    let y = (a = e.findAncestor((f) => f.type === "ArrowFunctionExpression")) == null ? void 0 : a.body;
+    if (y && y.type !== "SequenceExpression" && y.type !== "AssignmentExpression" && te(y, (f) => f === D))
+      return !0;
+  }
+  switch (p.type) {
+    case "ParenthesizedExpression":
+      return !1;
+    case "ClassDeclaration":
+    case "ClassExpression":
+      if (c === "superClass" && (D.type === "ArrowFunctionExpression" || D.type === "AssignmentExpression" || D.type === "AwaitExpression" || D.type === "BinaryExpression" || D.type === "ConditionalExpression" || D.type === "LogicalExpression" || D.type === "NewExpression" || D.type === "ObjectExpression" || D.type === "SequenceExpression" || D.type === "TaggedTemplateExpression" || D.type === "UnaryExpression" || D.type === "UpdateExpression" || D.type === "YieldExpression" || D.type === "TSNonNullExpression" || D.type === "ClassExpression" && J(D.decorators)))
+        return !0;
+      break;
+    case "ExportDefaultDeclaration":
+      return qu(e, t) || D.type === "SequenceExpression";
+    case "Decorator":
+      if (c === "expression" && !bp(D))
+        return !0;
+      break;
+    case "TypeAnnotation":
+      if (e.match(void 0, void 0, (y, f) => f === "returnType" && y.type === "ArrowFunctionExpression") && Cp(D))
+        return !0;
+      break;
+    case "BinaryExpression":
+      if (c === "left" && (p.operator === "in" || p.operator === "instanceof") && D.type === "UnaryExpression")
+        return !0;
+      break;
+    case "VariableDeclarator":
+      if (c === "init" && e.match(void 0, void 0, (y, f) => f === "declarations" && y.type === "VariableDeclaration", (y, f) => f === "left" && y.type === "ForInStatement"))
+        return !0;
+      break;
+  }
+  switch (D.type) {
+    case "UpdateExpression":
+      if (p.type === "UnaryExpression")
+        return D.prefix && (D.operator === "++" && p.operator === "+" || D.operator === "--" && p.operator === "-");
+    case "UnaryExpression":
+      switch (p.type) {
+        case "UnaryExpression":
+          return D.operator === p.operator && (D.operator === "+" || D.operator === "-");
+        case "BindExpression":
+          return !0;
+        case "MemberExpression":
+        case "OptionalMemberExpression":
+          return c === "object";
+        case "TaggedTemplateExpression":
+          return !0;
+        case "NewExpression":
+        case "CallExpression":
+        case "OptionalCallExpression":
+          return c === "callee";
+        case "BinaryExpression":
+          return c === "left" && p.operator === "**";
+        case "TSNonNullExpression":
+          return !0;
+        default:
+          return !1;
+      }
+    case "BinaryExpression":
+      if (p.type === "UpdateExpression" || D.operator === "in" && hp(e))
+        return !0;
+      if (D.operator === "|>" && (o = D.extra) != null && o.parenthesized) {
+        let y = e.grandparent;
+        if (y.type === "BinaryExpression" && y.operator === "|>")
+          return !0;
+      }
+    case "TSTypeAssertion":
+    case "TSAsExpression":
+    case "TSSatisfiesExpression":
+    case "AsExpression":
+    case "AsConstExpression":
+    case "SatisfiesExpression":
+    case "LogicalExpression":
+      switch (p.type) {
+        case "TSAsExpression":
+        case "TSSatisfiesExpression":
+        case "AsExpression":
+        case "AsConstExpression":
+        case "SatisfiesExpression":
+          return !Ce(D);
+        case "ConditionalExpression":
+          return Ce(D) || Qo(D);
+        case "CallExpression":
+        case "NewExpression":
+        case "OptionalCallExpression":
+          return c === "callee";
+        case "ClassExpression":
+        case "ClassDeclaration":
+          return c === "superClass";
+        case "TSTypeAssertion":
+        case "TaggedTemplateExpression":
+        case "UnaryExpression":
+        case "JSXSpreadAttribute":
+        case "SpreadElement":
+        case "BindExpression":
+        case "AwaitExpression":
+        case "TSNonNullExpression":
+        case "UpdateExpression":
+          return !0;
+        case "MemberExpression":
+        case "OptionalMemberExpression":
+          return c === "object";
+        case "AssignmentExpression":
+        case "AssignmentPattern":
+          return c === "left" && (D.type === "TSTypeAssertion" || Ce(D));
+        case "LogicalExpression":
+          if (D.type === "LogicalExpression")
+            return p.operator !== D.operator;
+        case "BinaryExpression": {
+          let { operator: y, type: f } = D;
+          if (!y && f !== "TSTypeAssertion")
+            return !0;
+          let g = Kt(y), S = p.operator, b = Kt(S);
+          return b > g || c === "right" && b === g || b === g && !Kn(S, y) ? !0 : b < g && y === "%" ? S === "+" || S === "-" : !!ci(S);
+        }
+        default:
+          return !1;
+      }
+    case "SequenceExpression":
+      return p.type !== "ForStatement";
+    case "YieldExpression":
+      if (p.type === "AwaitExpression" || p.type === "TSTypeAssertion")
+        return !0;
+    case "AwaitExpression":
+      switch (p.type) {
+        case "TaggedTemplateExpression":
+        case "UnaryExpression":
+        case "LogicalExpression":
+        case "SpreadElement":
+        case "TSAsExpression":
+        case "TSSatisfiesExpression":
+        case "TSNonNullExpression":
+        case "AsExpression":
+        case "AsConstExpression":
+        case "SatisfiesExpression":
+        case "BindExpression":
+          return !0;
+        case "MemberExpression":
+        case "OptionalMemberExpression":
+          return c === "object";
+        case "NewExpression":
+        case "CallExpression":
+        case "OptionalCallExpression":
+          return c === "callee";
+        case "ConditionalExpression":
+          return c === "test";
+        case "BinaryExpression":
+          return !(!D.argument && p.operator === "|>");
+        default:
+          return !1;
+      }
+    case "TSFunctionType":
+      if (e.match((y) => y.type === "TSFunctionType", (y, f) => f === "typeAnnotation" && y.type === "TSTypeAnnotation", (y, f) => f === "returnType" && y.type === "ArrowFunctionExpression"))
+        return !0;
+    case "TSConditionalType":
+    case "TSConstructorType":
+    case "ConditionalTypeAnnotation":
+      if (c === "extendsType" && We(D) && p.type === D.type || c === "checkType" && We(p))
+        return !0;
+      if (c === "extendsType" && p.type === "TSConditionalType") {
+        let { typeAnnotation: y } = D.returnType || D.typeAnnotation;
+        if (y.type === "TSTypePredicate" && y.typeAnnotation && (y = y.typeAnnotation.typeAnnotation), y.type === "TSInferType" && y.typeParameter.constraint)
+          return !0;
+      }
+    case "TSUnionType":
+    case "TSIntersectionType":
+      if (($e(p) || Hn(p)) && p.types.length > 1 && (!D.types || D.types.length > 1))
+        return !0;
+    case "TSInferType":
+      if (D.type === "TSInferType") {
+        if (p.type === "TSRestType")
+          return !1;
+        if (c === "types" && (p.type === "TSUnionType" || p.type === "TSIntersectionType") && D.typeParameter.type === "TSTypeParameter" && D.typeParameter.constraint)
+          return !0;
+      }
+    case "TSTypeOperator":
+      return p.type === "TSArrayType" || p.type === "TSOptionalType" || p.type === "TSRestType" || c === "objectType" && p.type === "TSIndexedAccessType" || p.type === "TSTypeOperator" || p.type === "TSTypeAnnotation" && e.grandparent.type.startsWith("TSJSDoc");
+    case "TSTypeQuery":
+      return c === "objectType" && p.type === "TSIndexedAccessType" || c === "elementType" && p.type === "TSArrayType";
+    case "TypeOperator":
+      return p.type === "ArrayTypeAnnotation" || p.type === "NullableTypeAnnotation" || c === "objectType" && (p.type === "IndexedAccessType" || p.type === "OptionalIndexedAccessType") || p.type === "TypeOperator";
+    case "TypeofTypeAnnotation":
+      return c === "objectType" && (p.type === "IndexedAccessType" || p.type === "OptionalIndexedAccessType") || c === "elementType" && p.type === "ArrayTypeAnnotation";
+    case "ArrayTypeAnnotation":
+      return p.type === "NullableTypeAnnotation";
+    case "IntersectionTypeAnnotation":
+    case "UnionTypeAnnotation":
+      return p.type === "TypeOperator" || p.type === "ArrayTypeAnnotation" || p.type === "NullableTypeAnnotation" || p.type === "IntersectionTypeAnnotation" || p.type === "UnionTypeAnnotation" || c === "objectType" && (p.type === "IndexedAccessType" || p.type === "OptionalIndexedAccessType");
+    case "InferTypeAnnotation":
+    case "NullableTypeAnnotation":
+      return p.type === "ArrayTypeAnnotation" || c === "objectType" && (p.type === "IndexedAccessType" || p.type === "OptionalIndexedAccessType");
+    case "ComponentTypeAnnotation":
+    case "FunctionTypeAnnotation": {
+      if (D.type === "ComponentTypeAnnotation" && (D.rendersType === null || D.rendersType === void 0))
+        return !1;
+      if (e.match(void 0, (f, g) => g === "typeAnnotation" && f.type === "TypeAnnotation", (f, g) => g === "returnType" && f.type === "ArrowFunctionExpression") || e.match(void 0, (f, g) => g === "typeAnnotation" && f.type === "TypePredicate", (f, g) => g === "typeAnnotation" && f.type === "TypeAnnotation", (f, g) => g === "returnType" && f.type === "ArrowFunctionExpression"))
+        return !0;
+      let y = p.type === "NullableTypeAnnotation" ? e.grandparent : p;
+      return y.type === "UnionTypeAnnotation" || y.type === "IntersectionTypeAnnotation" || y.type === "ArrayTypeAnnotation" || c === "objectType" && (y.type === "IndexedAccessType" || y.type === "OptionalIndexedAccessType") || c === "checkType" && p.type === "ConditionalTypeAnnotation" || c === "extendsType" && p.type === "ConditionalTypeAnnotation" && ((i = D.returnType) == null ? void 0 : i.type) === "InferTypeAnnotation" && ((s = D.returnType) == null ? void 0 : s.typeParameter.bound) || y.type === "NullableTypeAnnotation" || p.type === "FunctionTypeParam" && p.name === null && Z(D).some((f) => {
+        var g;
+        return ((g = f.typeAnnotation) == null ? void 0 : g.type) === "NullableTypeAnnotation";
+      });
+    }
+    case "OptionalIndexedAccessType":
+      return c === "objectType" && p.type === "IndexedAccessType";
+    case "StringLiteral":
+    case "NumericLiteral":
+    case "Literal":
+      if (typeof D.value == "string" && p.type === "ExpressionStatement" && typeof p.directive != "string") {
+        let y = e.grandparent;
+        return y.type === "Program" || y.type === "BlockStatement";
+      }
+      return c === "object" && W(p) && be(D);
+    case "AssignmentExpression":
+      return !((c === "init" || c === "update") && p.type === "ForStatement" || c === "expression" && D.left.type !== "ObjectPattern" && p.type === "ExpressionStatement" || c === "key" && p.type === "TSPropertySignature" || p.type === "AssignmentExpression" || c === "expressions" && p.type === "SequenceExpression" && e.match(void 0, void 0, (y, f) => (f === "init" || f === "update") && y.type === "ForStatement") || c === "value" && p.type === "Property" && e.match(void 0, void 0, (y, f) => f === "properties" && y.type === "ObjectPattern") || p.type === "NGChainedExpression" || c === "node" && p.type === "JsExpressionRoot");
+    case "ConditionalExpression":
+      switch (p.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 !0;
+        case "NewExpression":
+        case "CallExpression":
+        case "OptionalCallExpression":
+          return c === "callee";
+        case "ConditionalExpression":
+          return t.experimentalTernaries ? !1 : c === "test";
+        case "MemberExpression":
+        case "OptionalMemberExpression":
+          return c === "object";
+        default:
+          return !1;
+      }
+    case "FunctionExpression":
+      switch (p.type) {
+        case "NewExpression":
+        case "CallExpression":
+        case "OptionalCallExpression":
+          return c === "callee";
+        case "TaggedTemplateExpression":
+          return !0;
+        default:
+          return !1;
+      }
+    case "ArrowFunctionExpression":
+      switch (p.type) {
+        case "BinaryExpression":
+          return p.operator !== "|>" || ((l = D.extra) == null ? void 0 : l.parenthesized);
+        case "NewExpression":
+        case "CallExpression":
+        case "OptionalCallExpression":
+          return c === "callee";
+        case "MemberExpression":
+        case "OptionalMemberExpression":
+          return c === "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":
+          return !0;
+        case "ConditionalExpression":
+          return c === "test";
+        default:
+          return !1;
+      }
+    case "ClassExpression":
+      switch (p.type) {
+        case "NewExpression":
+          return c === "callee";
+        default:
+          return !1;
+      }
+    case "OptionalMemberExpression":
+    case "OptionalCallExpression":
+    case "CallExpression":
+    case "MemberExpression":
+      if (Sp(e))
+        return !0;
+    case "TaggedTemplateExpression":
+    case "TSNonNullExpression":
+      if (c === "callee" && (p.type === "BindExpression" || p.type === "NewExpression")) {
+        let y = D;
+        for (; y; )
+          switch (y.type) {
+            case "CallExpression":
+            case "OptionalCallExpression":
+              return !0;
+            case "MemberExpression":
+            case "OptionalMemberExpression":
+            case "BindExpression":
+              y = y.object;
+              break;
+            case "TaggedTemplateExpression":
+              y = y.tag;
+              break;
+            case "TSNonNullExpression":
+              y = y.expression;
+              break;
+            default:
+              return !1;
+          }
+      }
+      return !1;
+    case "BindExpression":
+      return c === "callee" && (p.type === "BindExpression" || p.type === "NewExpression") || c === "object" && W(p);
+    case "NGPipeExpression":
+      return !(p.type === "NGRoot" || p.type === "NGMicrosyntaxExpression" || p.type === "ObjectProperty" && !((d = D.extra) != null && d.parenthesized) || Q(p) || c === "arguments" && L(p) || c === "right" && p.type === "NGPipeExpression" || c === "property" && p.type === "MemberExpression" || p.type === "AssignmentExpression");
+    case "JSXFragment":
+    case "JSXElement":
+      return c === "callee" || c === "left" && p.type === "BinaryExpression" && p.operator === "<" || !Q(p) && p.type !== "ArrowFunctionExpression" && p.type !== "AssignmentExpression" && p.type !== "AssignmentPattern" && p.type !== "BinaryExpression" && p.type !== "NewExpression" && p.type !== "ConditionalExpression" && p.type !== "ExpressionStatement" && p.type !== "JsExpressionRoot" && p.type !== "JSXAttribute" && p.type !== "JSXElement" && p.type !== "JSXExpressionContainer" && p.type !== "JSXFragment" && p.type !== "LogicalExpression" && !L(p) && !je(p) && p.type !== "ReturnStatement" && p.type !== "ThrowStatement" && p.type !== "TypeCastExpression" && p.type !== "VariableDeclarator" && p.type !== "YieldExpression";
+    case "TSInstantiationExpression":
+      return c === "object" && W(p);
+  }
+  return !1;
+}
+var xp = _(["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 hp(e) {
+  let t = 0, { node: n } = e;
+  for (; n; ) {
+    let r = e.getParentNode(t++);
+    if ((r == null ? void 0 : r.type) === "ForStatement" && r.init === n)
+      return !0;
+    n = r;
+  }
+  return !1;
+}
+function Cp(e) {
+  return Tn(e, (t) => t.type === "ObjectTypeAnnotation" && Tn(t, (n) => n.type === "FunctionTypeAnnotation"));
+}
+function Tp(e) {
+  return Ae(e);
+}
+function St(e) {
+  let { parent: t, key: n } = e;
+  switch (t.type) {
+    case "NGPipeExpression":
+      if (n === "arguments" && e.isLast)
+        return e.callParent(St);
+      break;
+    case "ObjectProperty":
+      if (n === "value")
+        return e.callParent(() => e.key === "properties" && e.isLast);
+      break;
+    case "BinaryExpression":
+    case "LogicalExpression":
+      if (n === "right")
+        return e.callParent(St);
+      break;
+    case "ConditionalExpression":
+      if (n === "alternate")
+        return e.callParent(St);
+      break;
+    case "UnaryExpression":
+      if (t.prefix)
+        return e.callParent(St);
+      break;
+  }
+  return !1;
+}
+function qu(e, t) {
+  let { node: n, parent: r } = e;
+  return n.type === "FunctionExpression" || n.type === "ClassExpression" ? r.type === "ExportDefaultDeclaration" || !Nn(e, t) : !Rn(n) || r.type !== "ExportDefaultDeclaration" && Nn(e, t) ? !1 : e.call(() => qu(e, t), ...Zr(n));
+}
+function Sp(e) {
+  return !!(e.match(void 0, (t, n) => n === "expression" && t.type === "ChainExpression", (t, n) => n === "tag" && t.type === "TaggedTemplateExpression") || e.match((t) => t.type === "OptionalCallExpression" || t.type === "OptionalMemberExpression", (t, n) => n === "tag" && t.type === "TaggedTemplateExpression") || e.match((t) => t.type === "OptionalCallExpression" || t.type === "OptionalMemberExpression", (t, n) => n === "expression" && t.type === "TSNonNullExpression", (t, n) => n === "tag" && t.type === "TaggedTemplateExpression") || e.match(void 0, (t, n) => n === "expression" && t.type === "ChainExpression", (t, n) => n === "expression" && t.type === "TSNonNullExpression", (t, n) => n === "tag" && t.type === "TaggedTemplateExpression") || e.match(void 0, (t, n) => n === "expression" && t.type === "TSNonNullExpression", (t, n) => n === "expression" && t.type === "ChainExpression", (t, n) => n === "tag" && t.type === "TaggedTemplateExpression") || e.match((t) => t.type === "OptionalMemberExpression" || t.type === "OptionalCallExpression", (t, n) => n === "object" && t.type === "MemberExpression" || n === "callee" && (t.type === "CallExpression" || t.type === "NewExpression")) || e.match((t) => t.type === "OptionalMemberExpression" || t.type === "OptionalCallExpression", (t, n) => n === "expression" && t.type === "TSNonNullExpression", (t, n) => n === "object" && t.type === "MemberExpression" || n === "callee" && t.type === "CallExpression") || e.match((t) => t.type === "CallExpression" || t.type === "MemberExpression", (t, n) => n === "expression" && t.type === "ChainExpression") && (e.match(void 0, void 0, (t, n) => n === "callee" && (t.type === "CallExpression" && !t.optional || t.type === "NewExpression") || n === "object" && t.type === "MemberExpression" && !t.optional) || e.match(void 0, void 0, (t, n) => n === "expression" && t.type === "TSNonNullExpression", (t, n) => n === "object" && t.type === "MemberExpression" || n === "callee" && t.type === "CallExpression")) || e.match((t) => t.type === "CallExpression" || t.type === "MemberExpression", (t, n) => n === "expression" && t.type === "TSNonNullExpression", (t, n) => n === "expression" && t.type === "ChainExpression", (t, n) => n === "object" && t.type === "MemberExpression" || n === "callee" && t.type === "CallExpression"));
+}
+function jn(e) {
+  return e.type === "Identifier" ? !0 : W(e) ? !e.computed && !e.optional && e.property.type === "Identifier" && jn(e.object) : !1;
+}
+function bp(e) {
+  return e.type === "ChainExpression" && (e = e.expression), jn(e) || L(e) && !e.optional && jn(e.callee);
+}
+var ut = Nn;
+function Bp(e, t) {
+  let n = t - 1;
+  n = ct(e, n, { backwards: !0 }), n = Dt(e, n, { backwards: !0 }), n = ct(e, n, { backwards: !0 });
+  let r = Dt(e, n, { backwards: !0 });
+  return n !== r;
+}
+var vp = Bp, kp = () => !0;
+function ur(e, t) {
+  let n = e.node;
+  return n.printed = !0, t.printer.printComment(e, t);
+}
+function Pp(e, t) {
+  var n;
+  let r = e.node, u = [ur(e, t)], { printer: a, originalText: o, locStart: i, locEnd: s } = t;
+  if ((n = a.isBlockComment) != null && n.call(a, r)) {
+    let d = pe(o, s(r)) ? pe(o, i(r), { backwards: !0 }) ? F : C : " ";
+    u.push(d);
+  } else
+    u.push(F);
+  let l = Dt(o, ct(o, s(r)));
+  return l !== !1 && pe(o, l) && u.push(F), u;
+}
+function wp(e, t, n) {
+  var r;
+  let u = e.node, a = ur(e, t), { printer: o, originalText: i, locStart: s } = t, l = (r = o.isBlockComment) == null ? void 0 : r.call(o, u);
+  if (n != null && n.hasLineSuffix && !(n != null && n.isBlock) || pe(i, s(u), { backwards: !0 })) {
+    let d = vp(i, s(u));
+    return { doc: Cr([F, d ? F : "", a]), isBlock: l, hasLineSuffix: !0 };
+  }
+  return !l || n != null && n.hasLineSuffix ? { doc: [Cr([" ", a]), ve], isBlock: l, hasLineSuffix: !0 } : { doc: [" ", a], isBlock: l, hasLineSuffix: !1 };
+}
+function $(e, t, n = {}) {
+  let { node: r } = e;
+  if (!J(r == null ? void 0 : r.comments))
+    return "";
+  let { indent: u = !1, marker: a, filter: o = kp } = n, i = [];
+  if (e.each(({ node: l }) => {
+    l.leading || l.trailing || l.marker !== a || !o(l) || i.push(ur(e, t));
+  }, "comments"), i.length === 0)
+    return "";
+  let s = N(F, i);
+  return u ? A([F, s]) : s;
+}
+function _u(e, t) {
+  let n = e.node;
+  if (!n)
+    return {};
+  let r = t[Symbol.for("printedComments")];
+  if ((n.comments || []).filter((i) => !r.has(i)).length === 0)
+    return { leading: "", trailing: "" };
+  let u = [], a = [], o;
+  return e.each(() => {
+    let i = e.node;
+    if (r != null && r.has(i))
+      return;
+    let { leading: s, trailing: l } = i;
+    s ? u.push(Pp(e, t)) : l && (o = wp(e, t, o), a.push(o.doc));
+  }, "comments"), { leading: u, trailing: a };
+}
+function Fe(e, t, n) {
+  let { leading: r, trailing: u } = _u(e, n);
+  return !r && !u ? t : Bn(t, (a) => [r, a, u]);
+}
+var Ip = class extends Error {
+  constructor(t, n, r = "type") {
+    super(`Unexpected ${n} node ${r}: ${JSON.stringify(t[r])}.`);
+    qt(this, "name", "UnexpectedNodeError");
+    this.node = t;
+  }
+}, At = Ip;
+function Np(e) {
+  if (typeof e != "string")
+    throw new TypeError("Expected a string");
+  return e.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
+}
+var fe, jp = class {
+  constructor(e) {
+    uo(this, fe), ao(this, fe, new Set(e));
+  }
+  getLeadingWhitespaceCount(e) {
+    let t = Je(this, fe), n = 0;
+    for (let r = 0; r < e.length && t.has(e.charAt(r)); r++)
+      n++;
+    return n;
+  }
+  getTrailingWhitespaceCount(e) {
+    let t = Je(this, fe), n = 0;
+    for (let r = e.length - 1; r >= 0 && t.has(e.charAt(r)); r--)
+      n++;
+    return n;
+  }
+  getLeadingWhitespace(e) {
+    let t = this.getLeadingWhitespaceCount(e);
+    return e.slice(0, t);
+  }
+  getTrailingWhitespace(e) {
+    let t = this.getTrailingWhitespaceCount(e);
+    return e.slice(e.length - t);
+  }
+  hasLeadingWhitespace(e) {
+    return Je(this, fe).has(e.charAt(0));
+  }
+  hasTrailingWhitespace(e) {
+    return Je(this, fe).has(X(!1, e, -1));
+  }
+  trimStart(e) {
+    let t = this.getLeadingWhitespaceCount(e);
+    return e.slice(t);
+  }
+  trimEnd(e) {
+    let t = this.getTrailingWhitespaceCount(e);
+    return e.slice(0, e.length - t);
+  }
+  trim(e) {
+    return this.trimEnd(this.trimStart(e));
+  }
+  split(e, t = !1) {
+    let n = `[${Np([...Je(this, fe)].join(""))}]+`, r = new RegExp(t ? `(${n})` : n, "u");
+    return e.split(r);
+  }
+  hasWhitespaceCharacter(e) {
+    let t = Je(this, fe);
+    return Array.prototype.some.call(e, (n) => t.has(n));
+  }
+  hasNonWhitespaceCharacter(e) {
+    let t = Je(this, fe);
+    return Array.prototype.some.call(e, (n) => !t.has(n));
+  }
+  isWhitespaceOnly(e) {
+    let t = Je(this, fe);
+    return Array.prototype.every.call(e, (n) => t.has(n));
+  }
+};
+fe = /* @__PURE__ */ new WeakMap();
+var Lp = jp, Ut = new Lp(` 
+\r	`), Fn = (e) => e === "" || e === C || e === F || e === E;
+function Mp(e, t, n) {
+  var r, u, a, o, i;
+  let { node: s } = e;
+  if (s.type === "JSXElement" && Yp(s))
+    return [n("openingElement"), n("closingElement")];
+  let l = s.type === "JSXElement" ? n("openingElement") : n("openingFragment"), d = s.type === "JSXElement" ? n("closingElement") : n("closingFragment");
+  if (s.children.length === 1 && s.children[0].type === "JSXExpressionContainer" && (s.children[0].expression.type === "TemplateLiteral" || s.children[0].expression.type === "TaggedTemplateExpression"))
+    return [l, ...e.map(n, "children"), d];
+  s.children = s.children.map((k) => Zp(k) ? { type: "JSXText", value: " ", raw: " " } : k);
+  let D = s.children.some(K), c = s.children.filter((k) => k.type === "JSXExpressionContainer").length > 1, p = s.type === "JSXElement" && s.openingElement.attributes.length > 1, y = ne(l) || D || p || c, f = e.parent.rootMarker === "mdx", g = t.singleQuote ? "{' '}" : '{" "}', S = f ? C : w([g, E], " "), b = ((u = (r = s.openingElement) == null ? void 0 : r.name) == null ? void 0 : u.name) === "fbt", x = Op(e, t, n, S, b), j = s.children.some((k) => wt(k));
+  for (let k = x.length - 2; k >= 0; k--) {
+    let O = x[k] === "" && x[k + 1] === "", G = x[k] === F && x[k + 1] === "" && x[k + 2] === F, U = (x[k] === E || x[k] === F) && x[k + 1] === "" && x[k + 2] === S, Oe = x[k] === S && x[k + 1] === "" && (x[k + 2] === E || x[k + 2] === F), P = x[k] === S && x[k + 1] === "" && x[k + 2] === S, V = x[k] === E && x[k + 1] === "" && x[k + 2] === F || x[k] === F && x[k + 1] === "" && x[k + 2] === E;
+    G && j || O || U || P || V ? x.splice(k, 2) : Oe && x.splice(k + 1, 2);
+  }
+  for (; x.length > 0 && Fn(X(!1, x, -1)); )
+    x.pop();
+  for (; x.length > 1 && Fn(x[0]) && Fn(x[1]); )
+    x.shift(), x.shift();
+  let v = [""];
+  for (let [k, O] of x.entries()) {
+    if (O === S) {
+      if (k === 1 && Bi(x[k - 1])) {
+        if (x.length === 2) {
+          v.push([v.pop(), g]);
+          continue;
+        }
+        v.push([g, F], "");
+        continue;
+      } else if (k === x.length - 1) {
+        v.push([v.pop(), g]);
+        continue;
+      } else if (x[k - 1] === "" && x[k - 2] === F) {
+        v.push([v.pop(), g]);
+        continue;
+      }
+    }
+    k % 2 === 0 ? v.push([v.pop(), O]) : v.push(O, ""), ne(O) && (y = !0);
+  }
+  let B = j ? yu(v) : m(v, { shouldBreak: !0 });
+  if (((a = t.cursorNode) == null ? void 0 : a.type) === "JSXText" && s.children.includes(t.cursorNode) ? B = [$t, B, $t] : ((o = t.nodeBeforeCursor) == null ? void 0 : o.type) === "JSXText" && s.children.includes(t.nodeBeforeCursor) ? B = [$t, B] : ((i = t.nodeAfterCursor) == null ? void 0 : i.type) === "JSXText" && s.children.includes(t.nodeAfterCursor) && (B = [B, $t]), f)
+    return B;
+  let M = m([l, A([F, B]), F, d]);
+  return y ? M : Ve([m([l, ...x, d]), M]);
+}
+function Op(e, t, n, r, u) {
+  let a = "", o = [a];
+  function i(l) {
+    a = l, o.push([o.pop(), l]);
+  }
+  function s(l) {
+    l !== "" && (a = l, o.push(l, ""));
+  }
+  return e.each(({ node: l, next: d }) => {
+    if (l.type === "JSXText") {
+      let D = oe(l);
+      if (wt(l)) {
+        let c = Ut.split(D, !0);
+        c[0] === "" && (c.shift(), /\n/u.test(c[0]) ? s(kr(u, c[1], l, d)) : s(r), c.shift());
+        let p;
+        if (X(!1, c, -1) === "" && (c.pop(), p = c.pop()), c.length === 0)
+          return;
+        for (let [y, f] of c.entries())
+          y % 2 === 1 ? s(C) : i(f);
+        p !== void 0 ? /\n/u.test(p) ? s(kr(u, a, l, d)) : s(r) : s(vr(u, a, l, d));
+      } else
+        /\n/u.test(D) ? D.match(/\n/gu).length > 1 && s(F) : s(r);
+    } else {
+      let D = n();
+      if (i(D), d && wt(d)) {
+        let c = Ut.trim(oe(d)), [p] = Ut.split(c);
+        s(vr(u, p, l, d));
+      } else
+        s(F);
+    }
+  }, "children"), o;
+}
+function vr(e, t, n, r) {
+  return e ? "" : n.type === "JSXElement" && !n.closingElement || (r == null ? void 0 : r.type) === "JSXElement" && !r.closingElement ? t.length === 1 ? E : F : E;
+}
+function kr(e, t, n, r) {
+  return e ? F : t.length === 1 ? n.type === "JSXElement" && !n.closingElement || (r == null ? void 0 : r.type) === "JSXElement" && !r.closingElement ? F : E : F;
+}
+var Jp = /* @__PURE__ */ new Set(["ArrayExpression", "JSXAttribute", "JSXElement", "JSXExpressionContainer", "JSXFragment", "ExpressionStatement", "CallExpression", "OptionalCallExpression", "ConditionalExpression", "JsExpressionRoot"]);
+function qp(e, t, n) {
+  let { parent: r } = e;
+  if (Jp.has(r.type))
+    return t;
+  let u = _p(e), a = ut(e, n);
+  return m([a ? "" : w("("), A([E, t]), E, a ? "" : w(")")], { shouldBreak: u });
+}
+function _p(e) {
+  return e.match(void 0, (t) => t.type === "ArrowFunctionExpression", L) && (e.match(void 0, void 0, void 0, (t) => t.type === "JSXExpressionContainer") || e.match(void 0, void 0, void 0, (t) => t.type === "ChainExpression", (t) => t.type === "JSXExpressionContainer"));
+}
+function Xp(e, t, n) {
+  let { node: r } = e, u = [];
+  if (u.push(n("name")), r.value) {
+    let a;
+    if (Y(r.value)) {
+      let o = oe(r.value), i = H(!1, H(!1, o.slice(1, -1), "&apos;", "'"), "&quot;", '"'), s = Vr(i, t.jsxSingleQuote);
+      i = s === '"' ? H(!1, i, '"', "&quot;") : H(!1, i, "'", "&apos;"), a = e.call(() => Fe(e, He(s + i + s), t), "value");
+    } else
+      a = n("value");
+    u.push("=", a);
+  }
+  return u;
+}
+function $p(e, t, n) {
+  let { node: r } = e, u = (a, o) => a.type === "JSXEmptyExpression" || !h(a) && (Q(a) || Ae(a) || a.type === "ArrowFunctionExpression" || a.type === "AwaitExpression" && (u(a.argument, a) || a.argument.type === "JSXElement") || L(a) || a.type === "ChainExpression" && L(a.expression) || a.type === "FunctionExpression" || a.type === "TemplateLiteral" || a.type === "TaggedTemplateExpression" || a.type === "DoExpression" || K(o) && (a.type === "ConditionalExpression" || ke(a)));
+  return u(r.expression, e.parent) ? m(["{", n("expression"), we, "}"]) : m(["{", A([E, n("expression")]), E, we, "}"]);
+}
+function Wp(e, t, n) {
+  var r, u;
+  let { node: a } = e, o = h(a.name) || h(a.typeParameters) || h(a.typeArguments);
+  if (a.selfClosing && a.attributes.length === 0 && !o)
+    return ["<", n("name"), a.typeArguments ? n("typeArguments") : n("typeParameters"), " />"];
+  if (((r = a.attributes) == null ? void 0 : r.length) === 1 && Y(a.attributes[0].value) && !a.attributes[0].value.value.includes(`
+`) && !o && !h(a.attributes[0]))
+    return m(["<", n("name"), a.typeArguments ? n("typeArguments") : n("typeParameters"), " ", ...e.map(n, "attributes"), a.selfClosing ? " />" : ">"]);
+  let i = (u = a.attributes) == null ? void 0 : u.some((l) => Y(l.value) && l.value.value.includes(`
+`)), s = t.singleAttributePerLine && a.attributes.length > 1 ? F : C;
+  return m(["<", n("name"), a.typeArguments ? n("typeArguments") : n("typeParameters"), A(e.map(() => [s, n()], "attributes")), ...Rp(a, t, o)], { shouldBreak: i });
+}
+function Rp(e, t, n) {
+  return e.selfClosing ? [C, "/>"] : Up(e, t, n) ? [">"] : [E, ">"];
+}
+function Up(e, t, n) {
+  let r = e.attributes.length > 0 && h(X(!1, e.attributes, -1), T.Trailing);
+  return e.attributes.length === 0 && !n || (t.bracketSameLine || t.jsxBracketSameLine) && (!n || e.attributes.length > 0) && !r;
+}
+function Gp(e, t, n) {
+  let { node: r } = e, u = [];
+  u.push("</");
+  let a = n("name");
+  return h(r.name, T.Leading | T.Line) ? u.push(A([F, a]), F) : h(r.name, T.Leading | T.Block) ? u.push(" ", a) : u.push(a), u.push(">"), u;
+}
+function Vp(e, t) {
+  let { node: n } = e, r = h(n), u = h(n, T.Line), a = n.type === "JSXOpeningFragment";
+  return [a ? "<" : "</", A([u ? F : r && !a ? " " : "", $(e, t)]), u ? F : "", ">"];
+}
+function Kp(e, t, n) {
+  let r = Fe(e, Mp(e, t, n), t);
+  return qp(e, r, t);
+}
+function Hp(e, t) {
+  let { node: n } = e, r = h(n, T.Line);
+  return [$(e, t, { indent: r }), r ? F : ""];
+}
+function zp(e, t, n) {
+  let { node: r } = e;
+  return ["{", e.call(({ node: u }) => {
+    let a = ["...", n()];
+    return !h(u) || !ku(e) ? a : [A([E, Fe(e, a, t)]), E];
+  }, r.type === "JSXSpreadAttribute" ? "argument" : "expression"), "}"];
+}
+function Qp(e, t, n) {
+  let { node: r } = e;
+  if (r.type.startsWith("JSX"))
+    switch (r.type) {
+      case "JSXAttribute":
+        return Xp(e, t, n);
+      case "JSXIdentifier":
+        return r.name;
+      case "JSXNamespacedName":
+        return N(":", [n("namespace"), n("name")]);
+      case "JSXMemberExpression":
+        return N(".", [n("object"), n("property")]);
+      case "JSXSpreadAttribute":
+      case "JSXSpreadChild":
+        return zp(e, t, n);
+      case "JSXExpressionContainer":
+        return $p(e, t, n);
+      case "JSXFragment":
+      case "JSXElement":
+        return Kp(e, t, n);
+      case "JSXOpeningElement":
+        return Wp(e, t, n);
+      case "JSXClosingElement":
+        return Gp(e, t, n);
+      case "JSXOpeningFragment":
+      case "JSXClosingFragment":
+        return Vp(e, t);
+      case "JSXEmptyExpression":
+        return Hp(e, t);
+      case "JSXText":
+        throw new Error("JSXText should be handled by JSXElement");
+      default:
+        throw new At(r, "JSX");
+    }
+}
+function Yp(e) {
+  if (e.children.length === 0)
+    return !0;
+  if (e.children.length > 1)
+    return !1;
+  let t = e.children[0];
+  return t.type === "JSXText" && !wt(t);
+}
+function wt(e) {
+  return e.type === "JSXText" && (Ut.hasNonWhitespaceCharacter(oe(e)) || !/\n/u.test(oe(e)));
+}
+function Zp(e) {
+  return e.type === "JSXExpressionContainer" && Y(e.expression) && e.expression.value === " " && !h(e.expression);
+}
+function el(e) {
+  let { node: t, parent: n } = e;
+  if (!K(t) || !K(n))
+    return !1;
+  let { index: r, siblings: u } = e, a;
+  for (let o = r; o > 0; o--) {
+    let i = u[o - 1];
+    if (!(i.type === "JSXText" && !wt(i))) {
+      a = i;
+      break;
+    }
+  }
+  return (a == null ? void 0 : a.type) === "JSXExpressionContainer" && a.expression.type === "JSXEmptyExpression" && un(a.expression);
+}
+function tl(e) {
+  return un(e.node) || el(e);
+}
+var Xu = tl, nl = 0;
+function $u(e, t, n) {
+  var r;
+  let { node: u, parent: a, grandparent: o, key: i } = e, s = i !== "body" && (a.type === "IfStatement" || a.type === "WhileStatement" || a.type === "SwitchStatement" || a.type === "DoWhileStatement"), l = u.operator === "|>" && ((r = e.root.extra) == null ? void 0 : r.__isUsingHackPipeline), d = Ln(e, t, n, !1, s);
+  if (s)
+    return d;
+  if (l)
+    return m(d);
+  if (L(a) && a.callee === u || a.type === "UnaryExpression" || W(a) && !a.computed)
+    return m([A([E, ...d]), E]);
+  let D = a.type === "ReturnStatement" || a.type === "ThrowStatement" || a.type === "JSXExpressionContainer" && o.type === "JSXAttribute" || u.operator !== "|" && a.type === "JsExpressionRoot" || u.type !== "NGPipeExpression" && (a.type === "NGRoot" && t.parser === "__ng_binding" || a.type === "NGMicrosyntaxExpression" && o.type === "NGMicrosyntax" && o.body.length === 1) || u === a.body && a.type === "ArrowFunctionExpression" || u !== a.body && a.type === "ForStatement" || a.type === "ConditionalExpression" && o.type !== "ReturnStatement" && o.type !== "ThrowStatement" && !L(o) || a.type === "TemplateLiteral", c = a.type === "AssignmentExpression" || a.type === "VariableDeclarator" || a.type === "ClassProperty" || a.type === "PropertyDefinition" || a.type === "TSAbstractPropertyDefinition" || a.type === "ClassPrivateProperty" || je(a), p = ke(u.left) && Kn(u.operator, u.left.operator);
+  if (D || It(u) && !p || !It(u) && c)
+    return m(d);
+  if (d.length === 0)
+    return "";
+  let y = K(u.right), f = d.findIndex((v) => typeof v != "string" && !Array.isArray(v) && v.type === De), g = d.slice(0, f === -1 ? 1 : f + 1), S = d.slice(g.length, y ? -1 : void 0), b = Symbol("logicalChain-" + ++nl), x = m([...g, A(S)], { id: b });
+  if (!y)
+    return x;
+  let j = X(!1, d, -1);
+  return m([x, an(j, { groupId: b })]);
+}
+function Ln(e, t, n, r, u) {
+  var a;
+  let { node: o } = e;
+  if (!ke(o))
+    return [m(n())];
+  let i = [];
+  Kn(o.operator, o.left.operator) ? i = e.call((g) => Ln(g, t, n, !0, u), "left") : i.push(m(n("left")));
+  let s = It(o), l = (o.operator === "|>" || o.type === "NGPipeExpression" || rl(e, t)) && !Te(t.originalText, o.right), d = !h(o.right, T.Leading, Eu) && Te(t.originalText, o.right), D = o.type === "NGPipeExpression" ? "|" : o.operator, c = o.type === "NGPipeExpression" && o.arguments.length > 0 ? m(A([E, ": ", N([C, ": "], e.map(() => Be(2, m(n())), "arguments"))])) : "", p;
+  if (s)
+    p = [D, Te(t.originalText, o.right) ? A([C, n("right"), c]) : [" ", n("right"), c]];
+  else {
+    let g = D === "|>" && ((a = e.root.extra) != null && a.__isUsingHackPipeline) ? e.call((S) => Ln(S, t, n, !0, u), "right") : n("right");
+    if (t.experimentalOperatorPosition === "start") {
+      let S = "";
+      if (d)
+        switch (Ge(g)) {
+          case Pe:
+            S = g.splice(0, 1)[0];
+            break;
+          case Le:
+            S = g.contents.splice(0, 1)[0];
+            break;
+        }
+      p = [C, S, D, " ", g, c];
+    } else
+      p = [l ? C : "", D, l ? " " : C, g, c];
+  }
+  let { parent: y } = e, f = h(o.left, T.Trailing | T.Line);
+  if ((f || !(u && o.type === "LogicalExpression") && y.type !== o.type && o.left.type !== o.type && o.right.type !== o.type) && (p = m(p, { shouldBreak: f })), t.experimentalOperatorPosition === "start" ? i.push(s || d ? " " : "", p) : i.push(l ? "" : " ", p), r && h(o)) {
+    let g = Qn(Fe(e, i, t));
+    return g.type === Re ? g.parts : Array.isArray(g) ? g : [g];
+  }
+  return i;
+}
+function It(e) {
+  return e.type !== "LogicalExpression" ? !1 : !!(Ae(e.right) && e.right.properties.length > 0 || Q(e.right) && e.right.elements.length > 0 || K(e.right));
+}
+var Pr = (e) => e.type === "BinaryExpression" && e.operator === "|";
+function rl(e, t) {
+  return (t.parser === "__vue_expression" || t.parser === "__vue_ts_expression") && Pr(e.node) && !e.hasAncestor((n) => !Pr(n) && n.type !== "JsExpressionRoot");
+}
+function ul(e, t, n) {
+  let { node: r } = e;
+  if (r.type.startsWith("NG"))
+    switch (r.type) {
+      case "NGRoot":
+        return [n("node"), h(r.node) ? " //" + Ke(r.node)[0].value.trimEnd() : ""];
+      case "NGPipeExpression":
+        return $u(e, t, n);
+      case "NGChainedExpression":
+        return m(N([";", C], e.map(() => il(e) ? n() : ["(", n(), ")"], "expressions")));
+      case "NGEmptyExpression":
+        return "";
+      case "NGMicrosyntax":
+        return e.map(() => [e.isFirst ? "" : wr(e) ? " " : [";", C], n()], "body");
+      case "NGMicrosyntaxKey":
+        return /^[$_a-z][\w$]*(?:-[$_a-z][\w$])*$/iu.test(r.name) ? r.name : JSON.stringify(r.name);
+      case "NGMicrosyntaxExpression":
+        return [n("expression"), r.alias === null ? "" : [" as ", n("alias")]];
+      case "NGMicrosyntaxKeyedExpression": {
+        let { index: u, parent: a } = e, o = wr(e) || al(e) || (u === 1 && (r.key.name === "then" || r.key.name === "else" || r.key.name === "as") || u === 2 && (r.key.name === "else" && a.body[u - 1].type === "NGMicrosyntaxKeyedExpression" && a.body[u - 1].key.name === "then" || r.key.name === "track")) && a.body[0].type === "NGMicrosyntaxExpression";
+        return [n("key"), o ? " " : ": ", n("expression")];
+      }
+      case "NGMicrosyntaxLet":
+        return ["let ", n("key"), r.value === null ? "" : [" = ", n("value")]];
+      case "NGMicrosyntaxAs":
+        return [n("key"), " as ", n("alias")];
+      default:
+        throw new At(r, "Angular");
+    }
+}
+function wr({ node: e, index: t }) {
+  return e.type === "NGMicrosyntaxKeyedExpression" && e.key.name === "of" && t === 1;
+}
+function al(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 ol = _(["CallExpression", "OptionalCallExpression", "AssignmentExpression"]);
+function il({ node: e }) {
+  return Tn(e, ol);
+}
+function Wu(e, t, n) {
+  let { node: r } = e;
+  return m([N(C, e.map(n, "decorators")), Ru(r, t) ? F : C]);
+}
+function sl(e, t, n) {
+  return Uu(e.node) ? [N(F, e.map(n, "declaration", "decorators")), F] : "";
+}
+function pl(e, t, n) {
+  let { node: r, parent: u } = e, { decorators: a } = r;
+  if (!J(a) || Uu(u) || Xu(e))
+    return "";
+  let o = r.type === "ClassExpression" || r.type === "ClassDeclaration" || Ru(r, t);
+  return [e.key === "declaration" && zo(u) ? F : o ? ve : "", N(C, e.map(n, "decorators")), C];
+}
+function Ru(e, t) {
+  return e.decorators.some((n) => pe(t.originalText, I(n)));
+}
+function Uu(e) {
+  var t;
+  if (e.type !== "ExportDefaultDeclaration" && e.type !== "ExportNamedDeclaration" && e.type !== "DeclareExportDeclaration")
+    return !1;
+  let n = (t = e.declaration) == null ? void 0 : t.decorators;
+  return J(n) && tn(e, n[0]);
+}
+var Qt = class extends Error {
+  constructor() {
+    super(...arguments);
+    qt(this, "name", "ArgExpansionBailout");
+  }
+};
+function ll(e, t, n) {
+  let { node: r } = e, u = de(r);
+  if (u.length === 0)
+    return ["(", $(e, t), ")"];
+  let a = u.length - 1;
+  if (yl(u)) {
+    let D = ["("];
+    return Ht(e, (c, p) => {
+      D.push(n()), p !== a && D.push(", ");
+    }), D.push(")"), D;
+  }
+  let o = !1, i = [];
+  Ht(e, ({ node: D }, c) => {
+    let p = n();
+    c === a || (Ne(D, t) ? (o = !0, p = [p, ",", F, F]) : p = [p, ",", C]), i.push(p);
+  });
+  let s = !t.parser.startsWith("__ng_") && r.type !== "ImportExpression" && r.type !== "TSImportType" && Ie(t, "all") ? "," : "";
+  if (r.type === "TSImportType" && u.length === 1 && (u[0].type === "TSLiteralType" && Y(u[0].literal) || Y(u[0])) && !h(u[0]))
+    return m(["(", ...i, w(s), ")"]);
+  function l() {
+    return m(["(", A([C, ...i]), s, C, ")"], { shouldBreak: !0 });
+  }
+  if (o || e.parent.type !== "Decorator" && ii(u))
+    return l();
+  if (Dl(u)) {
+    let D = i.slice(1);
+    if (D.some(ne))
+      return l();
+    let c;
+    try {
+      c = n(gr(r, 0), { expandFirstArg: !0 });
+    } catch (p) {
+      if (p instanceof Qt)
+        return l();
+      throw p;
+    }
+    return ne(c) ? [ve, Ve([["(", m(c, { shouldBreak: !0 }), ", ", ...D, ")"], l()])] : Ve([["(", c, ", ", ...D, ")"], ["(", m(c, { shouldBreak: !0 }), ", ", ...D, ")"], l()]);
+  }
+  if (cl(u, i, t)) {
+    let D = i.slice(0, -1);
+    if (D.some(ne))
+      return l();
+    let c;
+    try {
+      c = n(gr(r, -1), { expandLastArg: !0 });
+    } catch (p) {
+      if (p instanceof Qt)
+        return l();
+      throw p;
+    }
+    return ne(c) ? [ve, Ve([["(", ...D, m(c, { shouldBreak: !0 }), ")"], l()])] : Ve([["(", ...D, c, ")"], ["(", ...D, m(c, { shouldBreak: !0 }), ")"], l()]);
+  }
+  let d = ["(", A([E, ...i]), w(s), E, ")"];
+  return iu(e) ? d : m(d, { shouldBreak: i.some(ne) || o });
+}
+function Bt(e, t = !1) {
+  return Ae(e) && (e.properties.length > 0 || h(e)) || Q(e) && (e.elements.length > 0 || h(e)) || e.type === "TSTypeAssertion" && Bt(e.expression) || Ce(e) && Bt(e.expression) || e.type === "FunctionExpression" || e.type === "ArrowFunctionExpression" && (!e.returnType || !e.returnType.typeAnnotation || e.returnType.typeAnnotation.type !== "TSTypeReference" || dl(e.body)) && (e.body.type === "BlockStatement" || e.body.type === "ArrowFunctionExpression" && Bt(e.body, !0) || Ae(e.body) || Q(e.body) || !t && (L(e.body) || e.body.type === "ConditionalExpression") || K(e.body)) || e.type === "DoExpression" || e.type === "ModuleExpression";
+}
+function cl(e, t, n) {
+  var r, u;
+  let a = X(!1, e, -1);
+  if (e.length === 1) {
+    let i = X(!1, t, -1);
+    if ((r = i.label) != null && r.embed && ((u = i.label) == null ? void 0 : u.hug) !== !1)
+      return !0;
+  }
+  let o = X(!1, e, -2);
+  return !h(a, T.Leading) && !h(a, T.Trailing) && Bt(a) && (!o || o.type !== a.type) && (e.length !== 2 || o.type !== "ArrowFunctionExpression" || !Q(a)) && !(e.length > 1 && Ea(a, n));
+}
+function Dl(e) {
+  if (e.length !== 2)
+    return !1;
+  let [t, n] = e;
+  return t.type === "ModuleExpression" && ml(n) ? !0 : !h(t) && (t.type === "FunctionExpression" || t.type === "ArrowFunctionExpression" && t.body.type === "BlockStatement") && n.type !== "FunctionExpression" && n.type !== "ArrowFunctionExpression" && n.type !== "ConditionalExpression" && Gu(n) && !Bt(n);
+}
+function Gu(e) {
+  if (e.type === "ParenthesizedExpression")
+    return Gu(e.expression);
+  if (Ce(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 n = t.typeArguments ?? t.typeParameters;
+      (n == null ? void 0 : n.params.length) === 1 && (t = n.params[0]);
+    }
+    return Gn(t) && Ee(e.expression, 1);
+  }
+  return dt(e) && de(e).length > 1 ? !1 : ke(e) ? Ee(e.left, 1) && Ee(e.right, 1) : tu(e) || Ee(e);
+}
+function yl(e) {
+  return e.length === 2 ? Ir(e, 0) : e.length === 3 ? e[0].type === "Identifier" && Ir(e, 1) : !1;
+}
+function Ir(e, t) {
+  let n = e[t], r = e[t + 1];
+  return n.type === "ArrowFunctionExpression" && Z(n).length === 0 && n.body.type === "BlockStatement" && r.type === "ArrayExpression" && !e.some((u) => h(u));
+}
+function dl(e) {
+  return e.type === "BlockStatement" && (e.body.some((t) => t.type !== "EmptyStatement") || h(e, T.Dangling));
+}
+function ml(e) {
+  if (!(e.type === "ObjectExpression" && e.properties.length === 1))
+    return !1;
+  let [t] = e.properties;
+  return je(t) ? !t.computed && (t.key.type === "Identifier" && t.key.name === "type" || Y(t.key) && t.key.value === "type") && Y(t.value) && t.value.value === "module" : !1;
+}
+var Yt = ll, fl = (e) => ((e.type === "ChainExpression" || e.type === "TSNonNullExpression") && (e = e.expression), L(e) && de(e).length > 0);
+function El(e, t, n) {
+  var r;
+  let u = n("object"), a = Vu(e, t, n), { node: o } = e, i = e.findAncestor((d) => !(W(d) || d.type === "TSNonNullExpression")), s = e.findAncestor((d) => !(d.type === "ChainExpression" || d.type === "TSNonNullExpression")), l = i && (i.type === "NewExpression" || i.type === "BindExpression" || i.type === "AssignmentExpression" && i.left.type !== "Identifier") || o.computed || o.object.type === "Identifier" && o.property.type === "Identifier" && !W(s) || (s.type === "AssignmentExpression" || s.type === "VariableDeclarator") && (fl(o.object) || ((r = u.label) == null ? void 0 : r.memberChain));
+  return jt(u.label, [u, l ? a : m(A([E, a]))]);
+}
+function Vu(e, t, n) {
+  let r = n("property"), { node: u } = e, a = re(e);
+  return u.computed ? !u.property || be(u.property) ? [a, "[", r, "]"] : m([a, "[", A([E, r]), E, "]"]) : [a, ".", r];
+}
+function Ku(e, t, n) {
+  if (e.node.type === "ChainExpression")
+    return e.call(() => Ku(e, t, n), "expression");
+  let r = (e.parent.type === "ChainExpression" ? e.grandparent : e.parent).type === "ExpressionStatement", u = [];
+  function a(P) {
+    let { originalText: V } = t, ue = Ft(V, I(P));
+    return V.charAt(ue) === ")" ? ue !== !1 && $n(V, ue + 1) : Ne(P, t);
+  }
+  function o() {
+    let { node: P } = e;
+    if (P.type === "ChainExpression")
+      return e.call(o, "expression");
+    if (L(P) && (st(P.callee) || L(P.callee))) {
+      let V = a(P);
+      u.unshift({ node: P, hasTrailingEmptyLine: V, printed: [Fe(e, [re(e), ze(e, t, n), Yt(e, t, n)], t), V ? F : ""] }), e.call(o, "callee");
+    } else
+      st(P) ? (u.unshift({ node: P, needsParens: ut(e, t), printed: Fe(e, W(P) ? Vu(e, t, n) : ma(e, t, n), t) }), e.call(o, "object")) : P.type === "TSNonNullExpression" ? (u.unshift({ node: P, printed: Fe(e, "!", t) }), e.call(o, "expression")) : u.unshift({ node: P, printed: n() });
+  }
+  let { node: i } = e;
+  u.unshift({ node: i, printed: [re(e), ze(e, t, n), Yt(e, t, n)] }), i.callee && e.call(o, "callee");
+  let s = [], l = [u[0]], d = 1;
+  for (; d < u.length && (u[d].node.type === "TSNonNullExpression" || L(u[d].node) || W(u[d].node) && u[d].node.computed && be(u[d].node.property)); ++d)
+    l.push(u[d]);
+  if (!L(u[0].node))
+    for (; d + 1 < u.length && st(u[d].node) && st(u[d + 1].node); ++d)
+      l.push(u[d]);
+  s.push(l), l = [];
+  let D = !1;
+  for (; d < u.length; ++d) {
+    if (D && st(u[d].node)) {
+      if (u[d].node.computed && be(u[d].node.property)) {
+        l.push(u[d]);
+        continue;
+      }
+      s.push(l), l = [], D = !1;
+    }
+    (L(u[d].node) || u[d].node.type === "ImportExpression") && (D = !0), l.push(u[d]), h(u[d].node, T.Trailing) && (s.push(l), l = [], D = !1);
+  }
+  l.length > 0 && s.push(l);
+  function c(P) {
+    return /^[A-Z]|^[$_]+$/u.test(P);
+  }
+  function p(P) {
+    return P.length <= t.tabWidth;
+  }
+  function y(P) {
+    var V;
+    let ue = (V = P[1][0]) == null ? void 0 : V.node.computed;
+    if (P[0].length === 1) {
+      let xe = P[0][0].node;
+      return xe.type === "ThisExpression" || xe.type === "Identifier" && (c(xe.name) || r && p(xe.name) || ue);
+    }
+    let ot = X(!1, P[0], -1).node;
+    return W(ot) && ot.property.type === "Identifier" && (c(ot.property.name) || ue);
+  }
+  let f = s.length >= 2 && !h(s[1][0].node) && y(s);
+  function g(P) {
+    let V = P.map((ue) => ue.printed);
+    return P.length > 0 && X(!1, P, -1).needsParens ? ["(", ...V, ")"] : V;
+  }
+  function S(P) {
+    return P.length === 0 ? "" : A([F, N(F, P.map(g))]);
+  }
+  let b = s.map(g), x = b, j = f ? 3 : 2, v = s.flat(), B = v.slice(1, -1).some((P) => h(P.node, T.Leading)) || v.slice(0, -1).some((P) => h(P.node, T.Trailing)) || s[j] && h(s[j][0].node, T.Leading);
+  if (s.length <= j && !B && !s.some((P) => X(!1, P, -1).hasTrailingEmptyLine))
+    return iu(e) ? x : m(x);
+  let M = X(!1, s[f ? 1 : 0], -1).node, k = !L(M) && a(M), O = [g(s[0]), f ? s.slice(1, 2).map(g) : "", k ? F : "", S(s.slice(f ? 2 : 1))], G = u.map(({ node: P }) => P).filter(L);
+  function U() {
+    let P = X(!1, X(!1, s, -1), -1).node, V = X(!1, b, -1);
+    return L(P) && ne(V) && G.slice(0, -1).some((ue) => ue.arguments.some(kt));
+  }
+  let Oe;
+  return B || G.length > 2 && G.some((P) => !P.arguments.every((V) => Ee(V))) || b.slice(0, -1).some(ne) || U() ? Oe = m(O) : Oe = [ne(x) || k ? ve : "", Ve([x, O])], jt({ memberChain: !0 }, Oe);
+}
+var Fl = Ku;
+function Hu(e, t, n) {
+  var r;
+  let { node: u } = e, a = u.type === "NewExpression", o = u.type === "ImportExpression", i = re(e), s = de(u), l = s.length === 1 && au(s[0], t.originalText);
+  if (l || Al(e) || rn(u, e.parent)) {
+    let D = [];
+    if (Ht(e, () => {
+      D.push(n());
+    }), !(l && (r = D[0].label) != null && r.embed))
+      return [a ? "new " : "", Nr(e, n), i, ze(e, t, n), "(", N(", ", D), ")"];
+  }
+  if (!o && !a && st(u.callee) && !e.call((D) => ut(D, t), "callee", ...u.callee.type === "ChainExpression" ? ["expression"] : []))
+    return Fl(e, t, n);
+  let d = [a ? "new " : "", Nr(e, n), i, ze(e, t, n), Yt(e, t, n)];
+  return o || L(u.callee) ? m(d) : d;
+}
+function Nr(e, t) {
+  let { node: n } = e;
+  return n.type === "ImportExpression" ? `import${n.phase ? `.${n.phase}` : ""}` : t("callee");
+}
+function Al(e) {
+  let { node: t } = e;
+  if (t.type !== "CallExpression" || t.optional || t.callee.type !== "Identifier")
+    return !1;
+  let n = de(t);
+  return t.callee.name === "require" ? n.length === 1 && Y(n[0]) || n.length > 1 : t.callee.name === "define" && e.parent.type === "ExpressionStatement" ? n.length === 1 || n.length === 2 && n[0].type === "ArrayExpression" || n.length === 3 && Y(n[0]) && n[1].type === "ArrayExpression" : !1;
+}
+function Lt(e, t, n, r, u, a) {
+  let o = hl(e, t, n, r, a), i = a ? n(a, { assignmentLayout: o }) : "";
+  switch (o) {
+    case "break-after-operator":
+      return m([m(r), u, m(A([C, i]))]);
+    case "never-break-after-operator":
+      return m([m(r), u, " ", i]);
+    case "fluid": {
+      let s = Symbol("assignment");
+      return m([m(r), u, m(A(C), { id: s }), we, an(i, { groupId: s })]);
+    }
+    case "break-lhs":
+      return m([r, u, " ", m(i)]);
+    case "chain":
+      return [m(r), u, C, i];
+    case "chain-tail":
+      return [m(r), u, A([C, i])];
+    case "chain-tail-arrow-chain":
+      return [m(r), u, i];
+    case "only-left":
+      return r;
+  }
+}
+function gl(e, t, n) {
+  let { node: r } = e;
+  return Lt(e, t, n, n("left"), [" ", r.operator], "right");
+}
+function xl(e, t, n) {
+  return Lt(e, t, n, n("id"), " =", "init");
+}
+function hl(e, t, n, r, u) {
+  let { node: a } = e, o = a[u];
+  if (!o)
+    return "only-left";
+  let i = !Gt(o);
+  if (e.match(Gt, zu, (d) => !i || d.type !== "ExpressionStatement" && d.type !== "VariableDeclaration"))
+    return i ? o.type === "ArrowFunctionExpression" && o.body.type === "ArrowFunctionExpression" ? "chain-tail-arrow-chain" : "chain-tail" : "chain";
+  if (!i && Gt(o.right) || Te(t.originalText, o))
+    return "break-after-operator";
+  if (a.type === "ImportAttribute" || o.type === "CallExpression" && o.callee.name === "require" || t.parser === "json5" || t.parser === "jsonc" || t.parser === "json")
+    return "never-break-after-operator";
+  let s = bi(r);
+  if (Tl(a) || vl(a) || Qu(a) && s)
+    return "break-lhs";
+  let l = Pl(a, r, t);
+  return e.call(() => Cl(e, t, n, l), u) ? "break-after-operator" : Sl(a) ? "break-lhs" : !s && (l || o.type === "TemplateLiteral" || o.type === "TaggedTemplateExpression" || Yo(o) || be(o) || o.type === "ClassExpression") ? "never-break-after-operator" : "fluid";
+}
+function Cl(e, t, n, r) {
+  let u = e.node;
+  if (ke(u) && !It(u))
+    return !0;
+  switch (u.type) {
+    case "StringLiteralTypeAnnotation":
+    case "SequenceExpression":
+      return !0;
+    case "TSConditionalType":
+    case "ConditionalTypeAnnotation":
+      if (!t.experimentalTernaries && !Nl(u))
+        break;
+      return !0;
+    case "ConditionalExpression": {
+      if (!t.experimentalTernaries) {
+        let { test: l } = u;
+        return ke(l) && !It(l);
+      }
+      let { consequent: i, alternate: s } = u;
+      return i.type === "ConditionalExpression" || s.type === "ConditionalExpression";
+    }
+    case "ClassExpression":
+      return J(u.decorators);
+  }
+  if (r)
+    return !1;
+  let a = u, o = [];
+  for (; ; )
+    if (a.type === "UnaryExpression" || a.type === "AwaitExpression" || a.type === "YieldExpression" && a.argument !== null)
+      a = a.argument, o.push("argument");
+    else if (a.type === "TSNonNullExpression")
+      a = a.expression, o.push("expression");
+    else
+      break;
+  return !!(Y(a) || e.call(() => Yu(e, t, n), ...o));
+}
+function Tl(e) {
+  if (zu(e)) {
+    let t = e.left || e.id;
+    return t.type === "ObjectPattern" && t.properties.length > 2 && t.properties.some((n) => {
+      var r;
+      return je(n) && (!n.shorthand || ((r = n.value) == null ? void 0 : r.type) === "AssignmentPattern");
+    });
+  }
+  return !1;
+}
+function Gt(e) {
+  return e.type === "AssignmentExpression";
+}
+function zu(e) {
+  return Gt(e) || e.type === "VariableDeclarator";
+}
+function Sl(e) {
+  let t = Bl(e);
+  if (J(t)) {
+    let n = e.type === "TSTypeAliasDeclaration" ? "constraint" : "bound";
+    if (t.length > 1 && t.some((r) => r[n] || r.default))
+      return !0;
+  }
+  return !1;
+}
+var bl = _(["TSTypeAliasDeclaration", "TypeAlias"]);
+function Bl(e) {
+  var t;
+  if (bl(e))
+    return (t = e.typeParameters) == null ? void 0 : t.params;
+}
+function vl(e) {
+  if (e.type !== "VariableDeclarator")
+    return !1;
+  let { typeAnnotation: t } = e.id;
+  if (!t || !t.typeAnnotation)
+    return !1;
+  let n = jr(t.typeAnnotation);
+  return J(n) && n.length > 1 && n.some((r) => J(jr(r)) || r.type === "TSConditionalType");
+}
+function Qu(e) {
+  var t;
+  return e.type === "VariableDeclarator" && ((t = e.init) == null ? void 0 : t.type) === "ArrowFunctionExpression";
+}
+var kl = _(["TSTypeReference", "GenericTypeAnnotation"]);
+function jr(e) {
+  var t;
+  if (kl(e))
+    return (t = e.typeArguments ?? e.typeParameters) == null ? void 0 : t.params;
+}
+function Yu(e, t, n, r = !1) {
+  var u;
+  let { node: a } = e, o = () => Yu(e, t, n, !0);
+  if (a.type === "ChainExpression" || a.type === "TSNonNullExpression")
+    return e.call(o, "expression");
+  if (L(a)) {
+    if ((u = Hu(e, t, n).label) != null && u.memberChain)
+      return !1;
+    let i = de(a);
+    return !(i.length === 0 || i.length === 1 && Vn(i[0], t)) || wl(a, n) ? !1 : e.call(o, "callee");
+  }
+  return W(a) ? e.call(o, "object") : r && (a.type === "Identifier" || a.type === "ThisExpression");
+}
+function Pl(e, t, n) {
+  return je(e) ? (t = Qn(t), typeof t == "string" && lt(t) < n.tabWidth + 3) : !1;
+}
+function wl(e, t) {
+  let n = Il(e);
+  if (J(n)) {
+    if (n.length > 1)
+      return !0;
+    if (n.length === 1) {
+      let u = n[0];
+      if ($e(u) || Hn(u) || u.type === "TSTypeLiteral" || u.type === "ObjectTypeAnnotation")
+        return !0;
+    }
+    let r = e.typeParameters ? "typeParameters" : "typeArguments";
+    if (ne(t(r)))
+      return !0;
+  }
+  return !1;
+}
+function Il(e) {
+  var t;
+  return (t = e.typeParameters ?? e.typeArguments) == null ? void 0 : t.params;
+}
+function Nl(e) {
+  function t(n) {
+    switch (n.type) {
+      case "FunctionTypeAnnotation":
+      case "GenericTypeAnnotation":
+      case "TSFunctionType":
+        return !!n.typeParameters;
+      case "TSTypeReference":
+        return !!(n.typeArguments ?? n.typeParameters);
+      default:
+        return !1;
+    }
+  }
+  return t(e.checkType) || t(e.extendsType);
+}
+function at(e, t, n, r, u) {
+  let a = e.node, o = Z(a), i = u ? ze(e, t, n) : "";
+  if (o.length === 0)
+    return [i, "(", $(e, t, { filter: (p) => ge(t.originalText, I(p)) === ")" }), ")"];
+  let { parent: s } = e, l = rn(s), d = Zu(a), D = [];
+  if (yi(e, (p, y) => {
+    let f = y === o.length - 1;
+    f && a.rest && D.push("..."), D.push(n()), !f && (D.push(","), l || d ? D.push(" ") : Ne(o[y], t) ? D.push(F, F) : D.push(C));
+  }), r && !Ll(e)) {
+    if (ne(i) || ne(D))
+      throw new Qt();
+    return m([bn(i), "(", bn(D), ")"]);
+  }
+  let c = o.every((p) => !J(p.decorators));
+  return d && c ? [i, "(", ...D, ")"] : l ? [i, "(", ...D, ")"] : (nu(s) || ti(s) || s.type === "TypeAlias" || s.type === "UnionTypeAnnotation" || s.type === "IntersectionTypeAnnotation" || s.type === "FunctionTypeAnnotation" && s.returnType === a) && o.length === 1 && o[0].name === null && a.this !== o[0] && o[0].typeAnnotation && a.typeParameters === null && Gn(o[0].typeAnnotation) && !a.rest ? t.arrowParens === "always" || a.type === "HookTypeAnnotation" ? ["(", ...D, ")"] : D : [i, "(", A([E, ...D]), w(!Di(a) && Ie(t, "all") ? "," : ""), E, ")"];
+}
+function Zu(e) {
+  if (!e)
+    return !1;
+  let t = Z(e);
+  if (t.length !== 1)
+    return !1;
+  let [n] = t;
+  return !h(n) && (n.type === "ObjectPattern" || n.type === "ArrayPattern" || n.type === "Identifier" && n.typeAnnotation && (n.typeAnnotation.type === "TypeAnnotation" || n.typeAnnotation.type === "TSTypeAnnotation") && Xe(n.typeAnnotation.typeAnnotation) || n.type === "FunctionTypeParam" && Xe(n.typeAnnotation) && n !== e.rest || n.type === "AssignmentPattern" && (n.left.type === "ObjectPattern" || n.left.type === "ArrayPattern") && (n.right.type === "Identifier" || Ae(n.right) && n.right.properties.length === 0 || Q(n.right) && n.right.elements.length === 0));
+}
+function jl(e) {
+  let t;
+  return e.returnType ? (t = e.returnType, t.typeAnnotation && (t = t.typeAnnotation)) : e.typeAnnotation && (t = e.typeAnnotation), t;
+}
+function gt(e, t) {
+  var n;
+  let r = jl(e);
+  if (!r)
+    return !1;
+  let u = (n = e.typeParameters) == null ? void 0 : n.params;
+  if (u) {
+    if (u.length > 1)
+      return !1;
+    if (u.length === 1) {
+      let a = u[0];
+      if (a.constraint || a.default)
+        return !1;
+    }
+  }
+  return Z(e).length === 1 && (Xe(r) || ne(t));
+}
+function Ll(e) {
+  return e.match((t) => t.type === "ArrowFunctionExpression" && t.body.type === "BlockStatement", (t, n) => {
+    if (t.type === "CallExpression" && n === "arguments" && t.arguments.length === 1 && t.callee.type === "CallExpression") {
+      let r = t.callee.callee;
+      return r.type === "Identifier" || r.type === "MemberExpression" && !r.computed && r.object.type === "Identifier" && r.property.type === "Identifier";
+    }
+    return !1;
+  }, (t, n) => t.type === "VariableDeclarator" && n === "init" || t.type === "ExportDefaultDeclaration" && n === "declaration" || t.type === "TSExportAssignment" && n === "expression" || t.type === "AssignmentExpression" && n === "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 Ml(e) {
+  let t = Z(e);
+  return t.length > 1 && t.some((n) => n.type === "TSParameterProperty");
+}
+var Ol = _(["VoidTypeAnnotation", "TSVoidKeyword", "NullLiteralTypeAnnotation", "TSNullKeyword"]), Jl = _(["ObjectTypeAnnotation", "TSTypeLiteral", "GenericTypeAnnotation", "TSTypeReference"]);
+function ql(e) {
+  let { types: t } = e;
+  if (t.some((r) => h(r)))
+    return !1;
+  let n = t.find((r) => Jl(r));
+  return n ? t.every((r) => r === n || Ol(r)) : !1;
+}
+function ea(e) {
+  return Gn(e) || Xe(e) ? !0 : $e(e) ? ql(e) : !1;
+}
+function _l(e, t, n) {
+  let r = t.semi ? ";" : "", { node: u } = e, a = [ie(e), "opaque type ", n("id"), n("typeParameters")];
+  return u.supertype && a.push(": ", n("supertype")), u.impltype && a.push(" = ", n("impltype")), a.push(r), a;
+}
+function ta(e, t, n) {
+  let r = t.semi ? ";" : "", { node: u } = e, a = [ie(e)];
+  a.push("type ", n("id"), n("typeParameters"));
+  let o = u.type === "TSTypeAliasDeclaration" ? "typeAnnotation" : "right";
+  return [Lt(e, t, n, a, " =", o), r];
+}
+function na(e, t, n) {
+  let r = !1;
+  return m(e.map(({ isFirst: u, previous: a, node: o, index: i }) => {
+    let s = n();
+    if (u)
+      return s;
+    let l = Xe(o), d = Xe(a);
+    return d && l ? [" & ", r ? A(s) : s] : !d && !l || Te(t.originalText, o) ? t.experimentalOperatorPosition === "start" ? A([C, "& ", s]) : A([" &", C, s]) : (i > 1 && (r = !0), [" & ", i > 1 ? A(s) : s]);
+  }, "types"));
+}
+function ra(e, t, n) {
+  let { node: r } = e, { parent: u } = e, a = u.type !== "TypeParameterInstantiation" && (!We(u) || !t.experimentalTernaries) && u.type !== "TSTypeParameterInstantiation" && u.type !== "GenericTypeAnnotation" && u.type !== "TSTypeReference" && u.type !== "TSTypeAssertion" && u.type !== "TupleTypeAnnotation" && u.type !== "TSTupleType" && !(u.type === "FunctionTypeParam" && !u.name && e.grandparent.this !== u) && !((u.type === "TypeAlias" || u.type === "VariableDeclarator" || u.type === "TSTypeAliasDeclaration") && Te(t.originalText, r)), o = ea(r), i = e.map((d) => {
+    let D = n();
+    return o || (D = Be(2, D)), Fe(d, D, t);
+  }, "types");
+  if (o)
+    return N(" | ", i);
+  let s = a && !Te(t.originalText, r), l = [w([s ? C : "", "| "]), N([C, "| "], i)];
+  return ut(e, t) ? m([A(l), E]) : (u.type === "TupleTypeAnnotation" || u.type === "TSTupleType") && u[u.type === "TupleTypeAnnotation" && u.types ? "types" : "elementTypes"].length > 1 ? m([A([w(["(", E]), l]), E, w(")")]) : m(a ? A(l) : l);
+}
+function Xl(e) {
+  var t;
+  let { node: n, parent: r } = e;
+  return n.type === "FunctionTypeAnnotation" && (nu(r) || !((r.type === "ObjectTypeProperty" || r.type === "ObjectTypeInternalSlot") && !r.variance && !r.optional && tn(r, n) || r.type === "ObjectTypeCallProperty" || ((t = e.getParentNode(2)) == null ? void 0 : t.type) === "DeclareFunction"));
+}
+function ua(e, t, n) {
+  let { node: r } = e, u = [on(e)];
+  (r.type === "TSConstructorType" || r.type === "TSConstructSignatureDeclaration") && u.push("new ");
+  let a = at(e, t, n, !1, !0), o = [];
+  return r.type === "FunctionTypeAnnotation" ? o.push(Xl(e) ? " => " : ": ", n("returnType")) : o.push(z(e, n, r.returnType ? "returnType" : "typeAnnotation")), gt(r, o) && (a = m(a)), u.push(a, o), m(u);
+}
+function aa(e, t, n) {
+  return [n("objectType"), re(e), "[", n("indexType"), "]"];
+}
+function oa(e, t, n) {
+  return ["infer ", n("typeParameter")];
+}
+function Lr(e, t, n) {
+  let { node: r } = e;
+  return [r.postfix ? "" : n, z(e, t), r.postfix ? n : ""];
+}
+function ia(e, t, n) {
+  let { node: r } = e;
+  return ["...", ...r.type === "TupleTypeSpreadElement" && r.label ? [n("label"), ": "] : [], n("typeAnnotation")];
+}
+function sa(e, t, n) {
+  let { node: r } = e;
+  return [r.variance ? n("variance") : "", n("label"), r.optional ? "?" : "", ": ", n("elementType")];
+}
+var $l = /* @__PURE__ */ new WeakSet();
+function z(e, t, n = "typeAnnotation") {
+  let { node: { [n]: r } } = e;
+  if (!r)
+    return "";
+  let u = !1;
+  if (r.type === "TSTypeAnnotation" || r.type === "TypeAnnotation") {
+    let a = e.call(pa, n);
+    (a === "=>" || a === ":" && h(r, T.Leading)) && (u = !0), $l.add(r);
+  }
+  return u ? [" ", t(n)] : t(n);
+}
+var pa = (e) => e.match((t) => t.type === "TSTypeAnnotation", (t, n) => (n === "returnType" || n === "typeAnnotation") && (t.type === "TSFunctionType" || t.type === "TSConstructorType")) ? "=>" : e.match((t) => t.type === "TSTypeAnnotation", (t, n) => n === "typeAnnotation" && (t.type === "TSJSDocNullableType" || t.type === "TSJSDocNonNullableType" || t.type === "TSTypePredicate")) || e.match((t) => t.type === "TypeAnnotation", (t, n) => n === "typeAnnotation" && t.type === "Identifier", (t, n) => n === "id" && t.type === "DeclareFunction") || e.match((t) => t.type === "TypeAnnotation", (t, n) => n === "typeAnnotation" && t.type === "Identifier", (t, n) => n === "id" && t.type === "DeclareHook") || e.match((t) => t.type === "TypeAnnotation", (t, n) => n === "bound" && t.type === "TypeParameter" && t.usesExtendsBound) ? "" : ":";
+function la(e, t, n) {
+  let r = pa(e);
+  return r ? [r, " ", n("typeAnnotation")] : n("typeAnnotation");
+}
+function ca(e) {
+  return [e("elementType"), "[]"];
+}
+function Da({ node: e }, t) {
+  let n = e.type === "TSTypeQuery" ? "exprName" : "argument", r = e.type === "TypeofTypeAnnotation" || e.typeArguments ? "typeArguments" : "typeParameters";
+  return ["typeof ", t(n), t(r)];
+}
+function ya(e, t) {
+  let { node: n } = e;
+  return [n.type === "TSTypePredicate" && n.asserts ? "asserts " : n.type === "TypePredicate" && n.kind ? `${n.kind} ` : "", t("parameterName"), n.typeAnnotation ? [" is ", z(e, t)] : ""];
+}
+function re(e) {
+  let { node: t } = e;
+  return !t.optional || t.type === "Identifier" && t === e.parent.key ? "" : L(t) || W(t) && t.computed || t.type === "OptionalIndexedAccessType" ? "?." : "?";
+}
+function da(e) {
+  return e.node.definite || e.match(void 0, (t, n) => n === "id" && t.type === "VariableDeclarator" && t.definite) ? "!" : "";
+}
+var Wl = /* @__PURE__ */ new Set(["DeclareClass", "DeclareComponent", "DeclareFunction", "DeclareHook", "DeclareVariable", "DeclareExportDeclaration", "DeclareExportAllDeclaration", "DeclareOpaqueType", "DeclareTypeAlias", "DeclareEnum", "DeclareInterface"]);
+function ie(e) {
+  let { node: t } = e;
+  return t.declare || Wl.has(t.type) && e.parent.type !== "DeclareExportDeclaration" ? "declare " : "";
+}
+var Rl = /* @__PURE__ */ new Set(["TSAbstractMethodDefinition", "TSAbstractPropertyDefinition", "TSAbstractAccessorProperty"]);
+function on({ node: e }) {
+  return e.abstract || Rl.has(e.type) ? "abstract " : "";
+}
+function ze(e, t, n) {
+  let r = e.node;
+  return r.typeArguments ? n("typeArguments") : r.typeParameters ? n("typeParameters") : "";
+}
+function ma(e, t, n) {
+  return ["::", n("callee")];
+}
+function qe(e, t, n) {
+  return e.type === "EmptyStatement" ? ";" : e.type === "BlockStatement" || n ? [" ", t] : A([C, t]);
+}
+function fa(e, t) {
+  return ["...", t("argument"), z(e, t)];
+}
+function Zt(e) {
+  return e.accessibility ? e.accessibility + " " : "";
+}
+function Ul(e, t, n, r) {
+  let { node: u } = e, a = u.inexact ? "..." : "";
+  return h(u, T.Dangling) ? m([n, a, $(e, t, { indent: !0 }), E, r]) : [n, a, r];
+}
+function ar(e, t, n) {
+  let { node: r } = e, u = [], a = "[", o = "]", i = r.type === "TupleTypeAnnotation" && r.types ? "types" : r.type === "TSTupleType" || r.type === "TupleTypeAnnotation" ? "elementTypes" : "elements", s = r[i];
+  if (s.length === 0)
+    u.push(Ul(e, t, a, o));
+  else {
+    let l = X(!1, s, -1), d = (l == null ? void 0 : l.type) !== "RestElement" && !r.inexact, D = l === null, c = Symbol("array"), p = !t.__inJestEach && s.length > 1 && s.every((g, S, b) => {
+      let x = g == null ? void 0 : g.type;
+      if (!Q(g) && !Ae(g))
+        return !1;
+      let j = b[S + 1];
+      if (j && x !== j.type)
+        return !1;
+      let v = Q(g) ? "elements" : "properties";
+      return g[v] && g[v].length > 1;
+    }), y = Ea(r, t), f = d ? D ? "," : Ie(t) ? y ? w(",", "", { groupId: c }) : w(",") : "" : "";
+    u.push(m([a, A([E, y ? Vl(e, t, n, f) : [Gl(e, t, n, i, r.inexact), f], $(e, t)]), E, o], { shouldBreak: p, id: c }));
+  }
+  return u.push(re(e), z(e, n)), u;
+}
+function Ea(e, t) {
+  return Q(e) && e.elements.length > 1 && e.elements.every((n) => n && (be(n) || eu(n) && !h(n.argument)) && !h(n, T.Trailing | T.Line, (r) => !pe(t.originalText, q(r), { backwards: !0 })));
+}
+function Fa({ node: e }, { originalText: t }) {
+  let n = (u) => _n(t, Xn(t, u)), r = (u) => t[u] === "," ? u : r(n(u + 1));
+  return $n(t, r(I(e)));
+}
+function Gl(e, t, n, r, u) {
+  let a = [];
+  return e.each(({ node: o, isLast: i }) => {
+    a.push(o ? m(n()) : ""), (!i || u) && a.push([",", C, o && Fa(e, t) ? E : ""]);
+  }, r), u && a.push("..."), a;
+}
+function Vl(e, t, n, r) {
+  let u = [];
+  return e.each(({ isLast: a, next: o }) => {
+    u.push([n(), a ? r : ","]), a || u.push(Fa(e, t) ? [F, F] : h(o, T.Leading | T.Line) ? F : C);
+  }, "elements"), yu(u);
+}
+var Kl = /^[\$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]*$/, Hl = (e) => Kl.test(e), zl = Hl;
+function Ql(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 mt = Ql, Vt = /* @__PURE__ */ new WeakMap();
+function Aa(e) {
+  return /^(?:\d+|\d+\.\d+)$/u.test(e);
+}
+function Mr(e, t) {
+  return t.parser === "json" || t.parser === "jsonc" || !Y(e.key) || yt(oe(e.key), t).slice(1, -1) !== e.key.value ? !1 : !!(zl(e.key.value) && !(t.parser === "babel-ts" && e.type === "ClassProperty" || (t.parser === "typescript" || t.parser === "oxc-ts") && e.type === "PropertyDefinition") || Aa(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 Yl(e, t) {
+  let { key: n } = e.node;
+  return (n.type === "Identifier" || be(n) && Aa(mt(oe(n))) && String(n.value) === mt(oe(n)) && !(t.parser === "typescript" || t.parser === "babel-ts" || t.parser === "oxc-ts")) && (t.parser === "json" || t.parser === "jsonc" || t.quoteProps === "consistent" && Vt.get(e.parent));
+}
+function Mt(e, t, n) {
+  let { node: r } = e;
+  if (r.computed)
+    return ["[", n("key"), "]"];
+  let { parent: u } = e, { key: a } = r;
+  if (t.quoteProps === "consistent" && !Vt.has(u)) {
+    let o = e.siblings.some((i) => !i.computed && Y(i.key) && !Mr(i, t));
+    Vt.set(u, o);
+  }
+  if (Yl(e, t)) {
+    let o = yt(JSON.stringify(a.type === "Identifier" ? a.name : a.value.toString()), t);
+    return e.call((i) => Fe(i, o, t), "key");
+  }
+  return Mr(r, t) && (t.quoteProps === "as-needed" || t.quoteProps === "consistent" && !Vt.get(u)) ? e.call((o) => Fe(o, /^\d/u.test(a.value) ? mt(a.value) : a.value, t), "key") : n("key");
+}
+function An(e, t, n) {
+  let { node: r } = e;
+  return r.shorthand ? n("value") : Lt(e, t, n, Mt(e, t, n), ":", "value");
+}
+var Zl = ({ node: e, key: t, parent: n }) => t === "value" && e.type === "FunctionExpression" && (n.type === "ObjectMethod" || n.type === "ClassMethod" || n.type === "ClassPrivateMethod" || n.type === "MethodDefinition" || n.type === "TSAbstractMethodDefinition" || n.type === "TSDeclareMethod" || n.type === "Property" && nn(n));
+function ga(e, t, n, r) {
+  if (Zl(e))
+    return or(e, t, n);
+  let { node: u } = e, a = !1;
+  if ((u.type === "FunctionDeclaration" || u.type === "FunctionExpression") && r != null && r.expandLastArg) {
+    let { parent: d } = e;
+    L(d) && (de(d).length > 1 || Z(u).every((D) => D.type === "Identifier" && !D.typeAnnotation)) && (a = !0);
+  }
+  let o = [ie(e), u.async ? "async " : "", `function${u.generator ? "*" : ""} `, u.id ? n("id") : ""], i = at(e, t, n, a), s = sn(e, n), l = gt(u, s);
+  return o.push(ze(e, t, n), m([l ? m(i) : i, s]), u.body ? " " : "", n("body")), t.semi && (u.declare || !u.body) && o.push(";"), o;
+}
+function Mn(e, t, n) {
+  let { node: r } = e, { kind: u } = r, a = r.value || r, o = [];
+  return !u || u === "init" || u === "method" || u === "constructor" ? a.async && o.push("async ") : (Wn.ok(u === "get" || u === "set"), o.push(u, " ")), a.generator && o.push("*"), o.push(Mt(e, t, n), r.optional ? "?" : "", r === a ? or(e, t, n) : n("value")), o;
+}
+function or(e, t, n) {
+  let { node: r } = e, u = at(e, t, n), a = sn(e, n), o = Ml(r), i = gt(r, a), s = [ze(e, t, n), m([o ? m(u, { shouldBreak: !0 }) : i ? m(u) : u, a])];
+  return r.body ? s.push(" ", n("body")) : s.push(t.semi ? ";" : ""), s;
+}
+function ec(e) {
+  let t = Z(e);
+  return t.length === 1 && !e.typeParameters && !h(e, T.Dangling) && t[0].type === "Identifier" && !t[0].typeAnnotation && !h(t[0]) && !t[0].optional && !e.predicate && !e.returnType;
+}
+function xa(e, t) {
+  if (t.arrowParens === "always")
+    return !1;
+  if (t.arrowParens === "avoid") {
+    let { node: n } = e;
+    return ec(n);
+  }
+  return !1;
+}
+function sn(e, t) {
+  let { node: n } = e, r = [z(e, t, "returnType")];
+  return n.predicate && r.push(t("predicate")), r;
+}
+function ha(e, t, n) {
+  let { node: r } = e, u = t.semi ? ";" : "", a = [];
+  if (r.argument) {
+    let s = n("argument");
+    rc(t, r.argument) ? s = ["(", A([F, s]), F, ")"] : (ke(r.argument) || t.experimentalTernaries && r.argument.type === "ConditionalExpression" && (r.argument.consequent.type === "ConditionalExpression" || r.argument.alternate.type === "ConditionalExpression")) && (s = m([w("("), A([E, s]), E, w(")")])), a.push(" ", s);
+  }
+  let o = h(r, T.Dangling), i = u && o && h(r, T.Last | T.Line);
+  return i && a.push(u), o && a.push(" ", $(e, t)), i || a.push(u), a;
+}
+function tc(e, t, n) {
+  return ["return", ha(e, t, n)];
+}
+function nc(e, t, n) {
+  return ["throw", ha(e, t, n)];
+}
+function rc(e, t) {
+  if (Te(e.originalText, t) || h(t, T.Leading, (n) => ce(e.originalText, q(n), I(n))) && !K(t))
+    return !0;
+  if (Rn(t)) {
+    let n = t, r;
+    for (; r = Ho(n); )
+      if (n = r, Te(e.originalText, n))
+        return !0;
+  }
+  return !1;
+}
+var gn = /* @__PURE__ */ new WeakMap();
+function Ca(e) {
+  return gn.has(e) || gn.set(e, e.type === "ConditionalExpression" && !te(e, (t) => t.type === "ObjectExpression")), gn.get(e);
+}
+var uc = (e) => e.type === "SequenceExpression";
+function ac(e, t, n, r = {}) {
+  let u = [], a, o = [], i = !1, s = !r.expandLastArg && e.node.body.type === "ArrowFunctionExpression", l;
+  (function S() {
+    let { node: b } = e, x = oc(e, t, n, r);
+    if (u.length === 0)
+      u.push(x);
+    else {
+      let { leading: j, trailing: v } = _u(e, t);
+      u.push([j, x]), o.unshift(v);
+    }
+    s && (i || (i = b.returnType && Z(b).length > 0 || b.typeParameters || Z(b).some((j) => j.type !== "Identifier"))), !s || b.body.type !== "ArrowFunctionExpression" ? (a = n("body", r), l = b.body) : e.call(S, "body");
+  })();
+  let d = !Te(t.originalText, l) && (uc(l) || ic(l, a, t) || !i && Ca(l)), D = e.key === "callee" && dt(e.parent), c = Symbol("arrow-chain"), p = sc(e, r, { signatureDocs: u, shouldBreak: i }), y = !1, f = !1, g = !1;
+  return s && (D || r.assignmentLayout) && (f = !0, g = !h(e.node, T.Leading & T.Line), y = r.assignmentLayout === "chain-tail-arrow-chain" || D && !d), a = pc(e, t, r, { bodyDoc: a, bodyComments: o, functionBody: l, shouldPutBodyOnSameLine: d }), m([m(f ? A([g ? E : "", p]) : p, { shouldBreak: y, id: c }), " =>", s ? an(a, { groupId: c }) : m(a), s && D ? w(E, "", { groupId: c }) : ""]);
+}
+function oc(e, t, n, r) {
+  let { node: u } = e, a = [];
+  if (u.async && a.push("async "), xa(e, t))
+    a.push(n(["params", 0]));
+  else {
+    let i = r.expandLastArg || r.expandFirstArg, s = sn(e, n);
+    if (i) {
+      if (ne(s))
+        throw new Qt();
+      s = m(bn(s));
+    }
+    a.push(m([at(e, t, n, i, !0), s]));
+  }
+  let o = $(e, t, { filter(i) {
+    let s = Ft(t.originalText, I(i));
+    return s !== !1 && t.originalText.slice(s, s + 2) === "=>";
+  } });
+  return o && a.push(" ", o), a;
+}
+function ic(e, t, n) {
+  var r, u;
+  return Q(e) || Ae(e) || e.type === "ArrowFunctionExpression" || e.type === "DoExpression" || e.type === "BlockStatement" || K(e) || ((r = t.label) == null ? void 0 : r.hug) !== !1 && (((u = t.label) == null ? void 0 : u.embed) || au(e, n.originalText));
+}
+function sc(e, t, { signatureDocs: n, shouldBreak: r }) {
+  if (n.length === 1)
+    return n[0];
+  let { parent: u, key: a } = e;
+  return a !== "callee" && dt(u) || ke(u) ? m([n[0], " =>", A([C, N([" =>", C], n.slice(1))])], { shouldBreak: r }) : a === "callee" && dt(u) || t.assignmentLayout ? m(N([" =>", C], n), { shouldBreak: r }) : m(A(N([" =>", C], n)), { shouldBreak: r });
+}
+function pc(e, t, n, { bodyDoc: r, bodyComments: u, functionBody: a, shouldPutBodyOnSameLine: o }) {
+  let { node: i, parent: s } = e, l = n.expandLastArg && Ie(t, "all") ? w(",") : "", d = (n.expandLastArg || s.type === "JSXExpressionContainer") && !h(i) ? E : "";
+  return o && Ca(a) ? [" ", m([w("", "("), A([E, r]), w("", ")"), l, d]), u] : o ? [" ", r, u] : [A([C, r, u]), l, d];
+}
+var lc = (e, t, n) => {
+  if (!(e && t == null)) {
+    if (t.findLast)
+      return t.findLast(n);
+    for (let r = t.length - 1; r >= 0; r--) {
+      let u = t[r];
+      if (n(u, r, t))
+        return u;
+    }
+  }
+}, cc = lc;
+function On(e, t, n, r) {
+  let { node: u } = e, a = [], o = cc(!1, u[r], (i) => i.type !== "EmptyStatement");
+  return e.each(({ node: i }) => {
+    i.type !== "EmptyStatement" && (a.push(n()), i !== o && (a.push(F), Ne(i, t) && a.push(F)));
+  }, r), a;
+}
+function Ta(e, t, n) {
+  let r = Dc(e, t, n), { node: u, parent: a } = e;
+  if (u.type === "Program" && (a == null ? void 0 : a.type) !== "ModuleExpression")
+    return r ? [r, F] : "";
+  let o = [];
+  if (u.type === "StaticBlock" && o.push("static "), o.push("{"), r)
+    o.push(A([F, r]), F);
+  else {
+    let i = e.grandparent;
+    a.type === "ArrowFunctionExpression" || a.type === "FunctionExpression" || a.type === "FunctionDeclaration" || a.type === "ComponentDeclaration" || a.type === "HookDeclaration" || a.type === "ObjectMethod" || a.type === "ClassMethod" || a.type === "ClassPrivateMethod" || a.type === "ForStatement" || a.type === "WhileStatement" || a.type === "DoWhileStatement" || a.type === "DoExpression" || a.type === "ModuleExpression" || a.type === "CatchClause" && !i.finalizer || a.type === "TSModuleDeclaration" || u.type === "StaticBlock" || o.push(F);
+  }
+  return o.push("}"), o;
+}
+function Dc(e, t, n) {
+  let { node: r } = e, u = J(r.directives), a = r.body.some((s) => s.type !== "EmptyStatement"), o = h(r, T.Dangling);
+  if (!u && !a && !o)
+    return "";
+  let i = [];
+  return u && (i.push(On(e, t, n, "directives")), (a || o) && (i.push(F), Ne(X(!1, r.directives, -1), t) && i.push(F))), a && i.push(On(e, t, n, "body")), o && i.push($(e, t)), i;
+}
+function yc(e) {
+  let t = /* @__PURE__ */ new WeakMap();
+  return function(n) {
+    return t.has(n) || t.set(n, Symbol(e)), t.get(n);
+  };
+}
+var Sa = yc, ir = Sa("typeParameters");
+function dc(e, t, n) {
+  let { node: r } = e;
+  return Z(r).length === 1 && r.type.startsWith("TS") && !r[n][0].constraint && e.parent.type === "ArrowFunctionExpression" && !(t.filepath && /\.ts$/u.test(t.filepath));
+}
+function vt(e, t, n, r) {
+  let { node: u } = e;
+  if (!u[r])
+    return "";
+  if (!Array.isArray(u[r]))
+    return n(r);
+  let a = rn(e.grandparent), o = e.match((s) => !(s[r].length === 1 && Xe(s[r][0])), void 0, (s, l) => l === "typeAnnotation", (s) => s.type === "Identifier", Qu);
+  if (u[r].length === 0 || !o && (a || u[r].length === 1 && (u[r][0].type === "NullableTypeAnnotation" || ea(u[r][0]))))
+    return ["<", N(", ", e.map(n, r)), mc(e, t), ">"];
+  let i = u.type === "TSTypeParameterInstantiation" ? "" : dc(e, t, r) ? "," : Ie(t) ? w(",") : "";
+  return m(["<", A([E, N([",", C], e.map(n, r))]), i, E, ">"], { id: ir(u) });
+}
+function mc(e, t) {
+  let { node: n } = e;
+  if (!h(n, T.Dangling))
+    return "";
+  let r = !h(n, T.Line), u = $(e, t, { indent: !r });
+  return r ? u : [u, F];
+}
+function ba(e, t, n) {
+  let { node: r } = e, u = [r.const ? "const " : ""], a = r.type === "TSTypeParameter" ? n("name") : r.name;
+  if (r.variance && u.push(n("variance")), r.in && u.push("in "), r.out && u.push("out "), u.push(a), r.bound && (r.usesExtendsBound && u.push(" extends "), u.push(z(e, n, "bound"))), r.constraint) {
+    let o = Symbol("constraint");
+    u.push(" extends", m(A(C), { id: o }), we, an(n("constraint"), { groupId: o }));
+  }
+  return r.default && u.push(" = ", n("default")), m(u);
+}
+var Ba = _(["ClassProperty", "PropertyDefinition", "ClassPrivateProperty", "ClassAccessorProperty", "AccessorProperty", "TSAbstractPropertyDefinition", "TSAbstractAccessorProperty"]);
+function va(e, t, n) {
+  let { node: r } = e, u = [ie(e), on(e), "class"], a = h(r.id, T.Trailing) || h(r.typeParameters, T.Trailing) || h(r.superClass) || J(r.extends) || J(r.mixins) || J(r.implements), o = [], i = [];
+  if (r.id && o.push(" ", n("id")), o.push(n("typeParameters")), r.superClass) {
+    let d = [Fc(e, t, n), n(r.superTypeArguments ? "superTypeArguments" : "superTypeParameters")], D = e.call((c) => ["extends ", Fe(c, d, t)], "superClass");
+    a ? i.push(C, m(D)) : i.push(" ", D);
+  } else
+    i.push(xn(e, t, n, "extends"));
+  i.push(xn(e, t, n, "mixins"), xn(e, t, n, "implements"));
+  let s;
+  if (a) {
+    let d;
+    Pa(r) ? d = [...o, A(i)] : d = A([...o, i]), s = ka(r), u.push(m(d, { id: s }));
+  } else
+    u.push(...o, ...i);
+  let l = r.body;
+  return a && J(l.body) ? u.push(w(F, " ", { groupId: s })) : u.push(" "), u.push(n("body")), u;
+}
+var ka = Sa("heritageGroup");
+function fc(e) {
+  return w(F, "", { groupId: ka(e) });
+}
+function Ec(e) {
+  return ["extends", "mixins", "implements"].reduce((t, n) => t + (Array.isArray(e[n]) ? e[n].length : 0), e.superClass ? 1 : 0) > 1;
+}
+function Pa(e) {
+  return e.typeParameters && !h(e.typeParameters, T.Trailing | T.Line) && !Ec(e);
+}
+function xn(e, t, n, r) {
+  let { node: u } = e;
+  if (!J(u[r]))
+    return "";
+  let a = $(e, t, { marker: r });
+  return [Pa(u) ? w(" ", C, { groupId: ir(u.typeParameters) }) : C, a, a && F, r, m(A([C, N([",", C], e.map(n, r))]))];
+}
+function Fc(e, t, n) {
+  let r = n("superClass"), { parent: u } = e;
+  return u.type === "AssignmentExpression" ? m(w(["(", A([E, r]), E, ")"], r)) : r;
+}
+function wa(e, t, n) {
+  let { node: r } = e, u = [];
+  return J(r.decorators) && u.push(Wu(e, t, n)), u.push(Zt(r)), r.static && u.push("static "), u.push(on(e)), r.override && u.push("override "), u.push(Mn(e, t, n)), u;
+}
+function Ia(e, t, n) {
+  let { node: r } = e, u = [], a = t.semi ? ";" : "";
+  J(r.decorators) && u.push(Wu(e, t, n)), u.push(ie(e), Zt(r)), r.static && u.push("static "), u.push(on(e)), r.override && u.push("override "), r.readonly && u.push("readonly "), r.variance && u.push(n("variance")), (r.type === "ClassAccessorProperty" || r.type === "AccessorProperty" || r.type === "TSAbstractAccessorProperty") && u.push("accessor "), u.push(Mt(e, t, n), re(e), da(e), z(e, n));
+  let o = r.type === "TSAbstractPropertyDefinition" || r.type === "TSAbstractAccessorProperty";
+  return [Lt(e, t, n, u, " =", o ? void 0 : "value"), a];
+}
+function Ac(e, t, n) {
+  let { node: r } = e, u = [];
+  return e.each(({ node: a, next: o, isLast: i }) => {
+    u.push(n()), !t.semi && Ba(a) && gc(a, o) && u.push(";"), i || (u.push(F), Ne(a, t) && u.push(F));
+  }, "body"), h(r, T.Dangling) && u.push($(e, t)), ["{", u.length > 0 ? [A([F, u]), F] : "", "}"];
+}
+function gc(e, t) {
+  var n;
+  let { type: r, name: u } = e.key;
+  if (!e.computed && r === "Identifier" && (u === "static" || u === "get" || u === "set") && !e.value && !e.typeAnnotation)
+    return !0;
+  if (!t || t.static || t.accessibility || t.readonly)
+    return !1;
+  if (!t.computed) {
+    let a = (n = t.key) == null ? void 0 : n.name;
+    if (a === "in" || a === "instanceof")
+      return !0;
+  }
+  if (Ba(t) && t.variance && !t.static && !t.declare)
+    return !0;
+  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 !1;
+      let a = t.value ? t.value.generator : t.generator;
+      return !!(t.computed || a);
+    }
+    case "TSIndexSignature":
+      return !0;
+  }
+  return !1;
+}
+var xc = _(["TSAsExpression", "TSTypeAssertion", "TSNonNullExpression", "TSInstantiationExpression", "TSSatisfiesExpression"]);
+function Na(e) {
+  return xc(e) ? Na(e.expression) : e;
+}
+var hc = _(["FunctionExpression", "ArrowFunctionExpression"]);
+function Cc(e) {
+  return e.type === "MemberExpression" || e.type === "OptionalMemberExpression" || e.type === "Identifier" && e.name !== "undefined";
+}
+function Tc(e, t) {
+  if (t.semi || La(e, t) || Ma(e, t))
+    return !1;
+  let { node: n, key: r, parent: u } = e;
+  return !!(n.type === "ExpressionStatement" && (r === "body" && (u.type === "Program" || u.type === "BlockStatement" || u.type === "StaticBlock" || u.type === "TSModuleBlock") || r === "consequent" && u.type === "SwitchCase") && e.call(() => ja(e, t), "expression"));
+}
+function ja(e, t) {
+  let { node: n } = e;
+  switch (n.type) {
+    case "ParenthesizedExpression":
+    case "TypeCastExpression":
+    case "ArrayExpression":
+    case "ArrayPattern":
+    case "TemplateLiteral":
+    case "TemplateElement":
+    case "RegExpLiteral":
+      return !0;
+    case "ArrowFunctionExpression":
+      if (!xa(e, t))
+        return !0;
+      break;
+    case "UnaryExpression": {
+      let { prefix: r, operator: u } = n;
+      if (r && (u === "+" || u === "-"))
+        return !0;
+      break;
+    }
+    case "BindExpression":
+      if (!n.object)
+        return !0;
+      break;
+    case "Literal":
+      if (n.regex)
+        return !0;
+      break;
+    default:
+      if (K(n))
+        return !0;
+  }
+  return ut(e, t) ? !0 : Rn(n) ? e.call(() => ja(e, t), ...Zr(n)) : !1;
+}
+function La({ node: e, parent: t }, n) {
+  return (n.parentParser === "markdown" || n.parentParser === "mdx") && e.type === "ExpressionStatement" && K(e.expression) && t.type === "Program" && t.body.length === 1;
+}
+function Ma({ node: e, parent: t }, n) {
+  return (n.parser === "__vue_event_binding" || n.parser === "__vue_ts_event_binding") && e.type === "ExpressionStatement" && t.type === "Program" && t.body.length === 1;
+}
+function Sc(e, t, n) {
+  let r = [n("expression")];
+  if (Ma(e, t)) {
+    let u = Na(e.node.expression);
+    (hc(u) || Cc(u)) && r.push(";");
+  } else
+    La(e, t) || t.semi && r.push(";");
+  return r;
+}
+function bc(e, t, n) {
+  if (t.__isVueBindings || t.__isVueForBindingLeft) {
+    let r = e.map(n, "program", "body", 0, "params");
+    if (r.length === 1)
+      return r[0];
+    let u = N([",", C], r);
+    return t.__isVueForBindingLeft ? ["(", A([E, m(u)]), E, ")"] : u;
+  }
+  if (t.__isEmbeddedTypescriptGenericParameters) {
+    let r = e.map(n, "program", "body", 0, "typeParameters", "params");
+    return N([",", C], r);
+  }
+}
+function Bc(e, t) {
+  let { node: n } = e;
+  switch (n.type) {
+    case "RegExpLiteral":
+      return Or(n);
+    case "BigIntLiteral":
+      return Jn(n.extra.raw);
+    case "NumericLiteral":
+      return mt(n.extra.raw);
+    case "StringLiteral":
+      return He(yt(n.extra.raw, t));
+    case "NullLiteral":
+      return "null";
+    case "BooleanLiteral":
+      return String(n.value);
+    case "DirectiveLiteral":
+      return Jr(n.extra.raw, t);
+    case "Literal": {
+      if (n.regex)
+        return Or(n.regex);
+      if (n.bigint)
+        return Jn(n.raw);
+      let { value: r } = n;
+      return typeof r == "number" ? mt(n.raw) : typeof r == "string" ? vc(e) ? Jr(n.raw, t) : He(yt(n.raw, t)) : String(r);
+    }
+  }
+}
+function vc(e) {
+  if (e.key !== "expression")
+    return;
+  let { parent: t } = e;
+  return t.type === "ExpressionStatement" && typeof t.directive == "string";
+}
+function Jn(e) {
+  return e.toLowerCase();
+}
+function Or({ pattern: e, flags: t }) {
+  return t = [...t].sort().join(""), `/${e}/${t}`;
+}
+function Jr(e, t) {
+  let n = e.slice(1, -1);
+  if (n.includes('"') || n.includes("'"))
+    return e;
+  let r = t.singleQuote ? "'" : '"';
+  return r + n + r;
+}
+function kc(e, t, n) {
+  let r = e.originalText.slice(t, n);
+  for (let u of e[Symbol.for("comments")]) {
+    let a = q(u);
+    if (a > n)
+      break;
+    let o = I(u);
+    if (o < t)
+      continue;
+    let i = o - a;
+    r = r.slice(0, a - t) + " ".repeat(i) + r.slice(o - t);
+  }
+  return r;
+}
+var sr = kc;
+function Pc(e, t, n) {
+  let { node: r } = e;
+  return ["import", r.phase ? ` ${r.phase}` : "", qa(r), Xa(e, t, n), _a(e, t, n), Wa(e, t, n), t.semi ? ";" : ""];
+}
+var Oa = (e) => e.type === "ExportDefaultDeclaration" || e.type === "DeclareExportDeclaration" && e.default;
+function Ja(e, t, n) {
+  let { node: r } = e, u = [sl(e, t, n), ie(e), "export", Oa(r) ? " default" : ""], { declaration: a, exported: o } = r;
+  return h(r, T.Dangling) && (u.push(" ", $(e, t)), ou(r) && u.push(F)), a ? u.push(" ", n("declaration")) : (u.push(Nc(r)), r.type === "ExportAllDeclaration" || r.type === "DeclareExportAllDeclaration" ? (u.push(" *"), o && u.push(" as ", n("exported"))) : u.push(Xa(e, t, n)), u.push(_a(e, t, n), Wa(e, t, n))), u.push(Ic(r, t)), u;
+}
+var wc = _(["ClassDeclaration", "ComponentDeclaration", "FunctionDeclaration", "TSInterfaceDeclaration", "DeclareClass", "DeclareComponent", "DeclareFunction", "DeclareHook", "HookDeclaration", "TSDeclareFunction", "EnumDeclaration"]);
+function Ic(e, t) {
+  return t.semi && (!e.declaration || Oa(e) && !wc(e.declaration)) ? ";" : "";
+}
+function pr(e, t = !0) {
+  return e && e !== "value" ? `${t ? " " : ""}${e}${t ? "" : " "}` : "";
+}
+function qa(e, t) {
+  return pr(e.importKind, t);
+}
+function Nc(e) {
+  return pr(e.exportKind);
+}
+function _a(e, t, n) {
+  let { node: r } = e;
+  if (!r.source)
+    return "";
+  let u = [];
+  return $a(r, t) && u.push(" from"), u.push(" ", n("source")), u;
+}
+function Xa(e, t, n) {
+  let { node: r } = e;
+  if (!$a(r, t))
+    return "";
+  let u = [" "];
+  if (J(r.specifiers)) {
+    let a = [], o = [];
+    e.each(() => {
+      let i = e.node.type;
+      if (i === "ExportNamespaceSpecifier" || i === "ExportDefaultSpecifier" || i === "ImportNamespaceSpecifier" || i === "ImportDefaultSpecifier")
+        a.push(n());
+      else if (i === "ExportSpecifier" || i === "ImportSpecifier")
+        o.push(n());
+      else
+        throw new At(r, "specifier");
+    }, "specifiers"), u.push(N(", ", a)), o.length > 0 && (a.length > 0 && u.push(", "), o.length > 1 || a.length > 0 || r.specifiers.some((i) => h(i)) ? u.push(m(["{", A([t.bracketSpacing ? C : E, N([",", C], o)]), w(Ie(t) ? "," : ""), t.bracketSpacing ? C : E, "}"])) : u.push(["{", t.bracketSpacing ? " " : "", ...o, t.bracketSpacing ? " " : "", "}"]));
+  } else
+    u.push("{}");
+  return u;
+}
+function $a(e, t) {
+  return e.type !== "ImportDeclaration" || J(e.specifiers) || e.importKind === "type" ? !0 : sr(t, q(e), q(e.source)).trimEnd().endsWith("from");
+}
+function jc(e, t) {
+  var n, r;
+  if ((n = e.extra) != null && n.deprecatedAssertSyntax)
+    return "assert";
+  let u = sr(t, I(e.source), (r = e.attributes) != null && r[0] ? q(e.attributes[0]) : I(e)).trimStart();
+  return u.startsWith("assert") ? "assert" : u.startsWith("with") || J(e.attributes) ? "with" : void 0;
+}
+function Wa(e, t, n) {
+  let { node: r } = e;
+  if (!r.source)
+    return "";
+  let u = jc(r, t);
+  if (!u)
+    return "";
+  let a = [` ${u} {`];
+  return J(r.attributes) && (t.bracketSpacing && a.push(" "), a.push(N(", ", e.map(n, "attributes"))), t.bracketSpacing && a.push(" ")), a.push("}"), a;
+}
+function Lc(e, t, n) {
+  let { node: r } = e, { type: u } = r, a = u.startsWith("Import"), o = a ? "imported" : "local", i = a ? "local" : "exported", s = r[o], l = r[i], d = "", D = "";
+  return u === "ExportNamespaceSpecifier" || u === "ImportNamespaceSpecifier" ? d = "*" : s && (d = n(o)), l && !Mc(r) && (D = n(i)), [pr(u === "ImportSpecifier" ? r.importKind : r.exportKind, !1), d, d && D ? " as " : "", D];
+}
+function Mc(e) {
+  if (e.type !== "ImportSpecifier" && e.type !== "ExportSpecifier")
+    return !1;
+  let { local: t, [e.type === "ImportSpecifier" ? "imported" : "exported"]: n } = e;
+  if (t.type !== n.type || !jo(t, n))
+    return !1;
+  if (Y(t))
+    return t.value === n.value && oe(t) === oe(n);
+  switch (t.type) {
+    case "Identifier":
+      return t.name === n.name;
+    default:
+      return !1;
+  }
+}
+function pn(e, t, n) {
+  var r;
+  let u = t.semi ? ";" : "", { node: a } = e, o = a.type === "ObjectTypeAnnotation", i = a.type === "TSEnumBody" || a.type === "EnumBooleanBody" || a.type === "EnumNumberBody" || a.type === "EnumBigIntBody" || a.type === "EnumStringBody" || a.type === "EnumSymbolBody", s = [a.type === "TSTypeLiteral" || i ? "members" : a.type === "TSInterfaceBody" ? "body" : "properties"];
+  o && s.push("indexers", "callProperties", "internalSlots");
+  let l = s.flatMap((B) => e.map(({ node: M }) => ({ node: M, printed: n(), loc: q(M) }), B));
+  s.length > 1 && l.sort((B, M) => B.loc - M.loc);
+  let { parent: d, key: D } = e, c = o && D === "body" && (d.type === "InterfaceDeclaration" || d.type === "DeclareInterface" || d.type === "DeclareClass"), p = a.type === "TSInterfaceBody" || i || c || a.type === "ObjectPattern" && d.type !== "FunctionDeclaration" && d.type !== "FunctionExpression" && d.type !== "ArrowFunctionExpression" && d.type !== "ObjectMethod" && d.type !== "ClassMethod" && d.type !== "ClassPrivateMethod" && d.type !== "AssignmentPattern" && d.type !== "CatchClause" && a.properties.some((B) => B.value && (B.value.type === "ObjectPattern" || B.value.type === "ArrayPattern")) || a.type !== "ObjectPattern" && t.objectWrap === "preserve" && l.length > 0 && ce(t.originalText, q(a), l[0].loc), y = c ? ";" : a.type === "TSInterfaceBody" || a.type === "TSTypeLiteral" ? w(u, ";") : ",", f = a.exact ? "{|" : "{", g = a.exact ? "|}" : "}", S = [], b = l.map((B) => {
+    let M = [...S, m(B.printed)];
+    return S = [y, C], (B.node.type === "TSPropertySignature" || B.node.type === "TSMethodSignature" || B.node.type === "TSConstructSignatureDeclaration" || B.node.type === "TSCallSignatureDeclaration") && h(B.node, T.PrettierIgnore) && S.shift(), Ne(B.node, t) && S.push(F), M;
+  });
+  if (a.inexact || a.hasUnknownMembers) {
+    let B;
+    if (h(a, T.Dangling)) {
+      let M = h(a, T.Line);
+      B = [$(e, t), M || pe(t.originalText, I(X(!1, Ke(a), -1))) ? F : C, "..."];
+    } else
+      B = ["..."];
+    b.push([...S, ...B]);
+  }
+  let x = (r = X(!1, l, -1)) == null ? void 0 : r.node, j = !(a.inexact || a.hasUnknownMembers || x && (x.type === "RestElement" || (x.type === "TSPropertySignature" || x.type === "TSCallSignatureDeclaration" || x.type === "TSMethodSignature" || x.type === "TSConstructSignatureDeclaration" || x.type === "TSIndexSignature") && h(x, T.PrettierIgnore)) || e.match(void 0, (B, M) => B.type === "TSImportType" && M === "options")), v;
+  if (b.length === 0) {
+    if (!h(a, T.Dangling))
+      return [f, g, z(e, n)];
+    v = m([f, $(e, t, { indent: !0 }), E, g, re(e), z(e, n)]);
+  } else
+    v = [c && J(a.properties) ? fc(d) : "", f, A([t.bracketSpacing ? C : E, ...b]), w(j && (y !== "," || Ie(t)) ? y : ""), t.bracketSpacing ? C : E, g, re(e), z(e, n)];
+  return e.match((B) => B.type === "ObjectPattern" && !J(B.decorators), hn) || Xe(a) && (e.match(void 0, (B, M) => M === "typeAnnotation", (B, M) => M === "typeAnnotation", hn) || e.match(void 0, (B, M) => B.type === "FunctionTypeParam" && M === "typeAnnotation", hn)) || !p && e.match((B) => B.type === "ObjectPattern", (B) => B.type === "AssignmentExpression" || B.type === "VariableDeclarator") ? v : m(v, { shouldBreak: p });
+}
+function hn(e, t) {
+  return (t === "params" || t === "parameters" || t === "this" || t === "rest") && Zu(e);
+}
+function Oc(e) {
+  let t = [e];
+  for (let n = 0; n < t.length; n++) {
+    let r = t[n];
+    for (let u of ["test", "consequent", "alternate"]) {
+      let a = r[u];
+      if (K(a))
+        return !0;
+      a.type === "ConditionalExpression" && t.push(a);
+    }
+  }
+  return !1;
+}
+function Jc(e, t, n) {
+  let { node: r } = e, u = r.type === "ConditionalExpression", a = u ? "alternate" : "falseType", { parent: o } = e, i = u ? n("test") : [n("checkType"), " ", "extends", " ", n("extendsType")];
+  return o.type === r.type && o[a] === r ? Be(2, i) : i;
+}
+var qc = /* @__PURE__ */ new Map([["AssignmentExpression", "right"], ["VariableDeclarator", "init"], ["ReturnStatement", "argument"], ["ThrowStatement", "argument"], ["UnaryExpression", "argument"], ["YieldExpression", "argument"], ["AwaitExpression", "argument"]]);
+function _c(e) {
+  let { node: t } = e;
+  if (t.type !== "ConditionalExpression")
+    return !1;
+  let n, r = t;
+  for (let u = 0; !n; u++) {
+    let a = e.getParentNode(u);
+    if (a.type === "ChainExpression" && a.expression === r || L(a) && a.callee === r || W(a) && a.object === r || a.type === "TSNonNullExpression" && a.expression === r) {
+      r = a;
+      continue;
+    }
+    a.type === "NewExpression" && a.callee === r || Ce(a) && a.expression === r ? (n = e.getParentNode(u + 1), r = a) : n = a;
+  }
+  return r === t ? !1 : n[qc.get(n.type)] === r;
+}
+function Xc(e, t, n) {
+  let { node: r } = e, u = r.type === "ConditionalExpression", a = u ? "consequent" : "trueType", o = u ? "alternate" : "falseType", i = u ? ["test"] : ["checkType", "extendsType"], s = r[a], l = r[o], d = [], D = !1, { parent: c } = e, p = c.type === r.type && i.some((O) => c[O] === r), y = c.type === r.type && !p, f, g, S = 0;
+  do
+    g = f || r, f = e.getParentNode(S), S++;
+  while (f && f.type === r.type && i.every((O) => f[O] !== g));
+  let b = f || c, x = g;
+  if (u && (K(r[i[0]]) || K(s) || K(l) || Oc(x))) {
+    D = !0, y = !0;
+    let O = (U) => [w("("), A([E, U]), E, w(")")], G = (U) => U.type === "NullLiteral" || U.type === "Literal" && U.value === null || U.type === "Identifier" && U.name === "undefined";
+    d.push(" ? ", G(s) ? n(a) : O(n(a)), " : ", l.type === r.type || G(l) ? n(o) : O(n(o)));
+  } else {
+    let O = (U) => t.useTabs ? A(n(U)) : Be(2, n(U)), G = [C, "? ", s.type === r.type ? w("", "(") : "", O(a), s.type === r.type ? w("", ")") : "", C, ": ", O(o)];
+    d.push(c.type !== r.type || c[o] === r || p ? G : t.useTabs ? Du(A(G)) : Be(Math.max(0, t.tabWidth - 2), G));
+  }
+  let j = [a, o, ...i].some((O) => h(r[O], (G) => ye(G) && ce(t.originalText, q(G), I(G)))), v = (O) => c === b ? m(O, { shouldBreak: j }) : j ? [O, ve] : O, B = !D && (W(c) || c.type === "NGPipeExpression" && c.left === r) && !c.computed, M = _c(e), k = v([Jc(e, t, n), y ? d : A(d), u && B && !M ? E : ""]);
+  return p || M ? m([A([E, k]), E]) : k;
+}
+function $c(e, t) {
+  return (W(t) || t.type === "NGPipeExpression" && t.left === e) && !t.computed;
+}
+function Wc(e, t, n, r) {
+  return [...e.map((u) => Ke(u)), Ke(t), Ke(n)].flat().some((u) => ye(u) && ce(r.originalText, q(u), I(u)));
+}
+var Rc = /* @__PURE__ */ new Map([["AssignmentExpression", "right"], ["VariableDeclarator", "init"], ["ReturnStatement", "argument"], ["ThrowStatement", "argument"], ["UnaryExpression", "argument"], ["YieldExpression", "argument"], ["AwaitExpression", "argument"]]);
+function Uc(e) {
+  let { node: t } = e;
+  if (t.type !== "ConditionalExpression")
+    return !1;
+  let n, r = t;
+  for (let u = 0; !n; u++) {
+    let a = e.getParentNode(u);
+    if (a.type === "ChainExpression" && a.expression === r || L(a) && a.callee === r || W(a) && a.object === r || a.type === "TSNonNullExpression" && a.expression === r) {
+      r = a;
+      continue;
+    }
+    a.type === "NewExpression" && a.callee === r || Ce(a) && a.expression === r ? (n = e.getParentNode(u + 1), r = a) : n = a;
+  }
+  return r === t ? !1 : n[Rc.get(n.type)] === r;
+}
+var Cn = (e) => [w("("), A([E, e]), E, w(")")];
+function lr(e, t, n, r) {
+  if (!t.experimentalTernaries)
+    return Xc(e, t, n);
+  let { node: u } = e, a = u.type === "ConditionalExpression", o = We(u), i = a ? "consequent" : "trueType", s = a ? "alternate" : "falseType", l = a ? ["test"] : ["checkType", "extendsType"], d = u[i], D = u[s], c = l.map((me) => u[me]), { parent: p } = e, y = p.type === u.type, f = y && l.some((me) => p[me] === u), g = y && p[s] === u, S = d.type === u.type, b = D.type === u.type, x = b || g, j = t.tabWidth > 2 || t.useTabs, v, B, M = 0;
+  do
+    B = v || u, v = e.getParentNode(M), M++;
+  while (v && v.type === u.type && l.every((me) => v[me] !== B));
+  let k = v || p, O = r && r.assignmentLayout && r.assignmentLayout !== "break-after-operator" && (p.type === "AssignmentExpression" || p.type === "VariableDeclarator" || p.type === "ClassProperty" || p.type === "PropertyDefinition" || p.type === "ClassPrivateProperty" || p.type === "ObjectProperty" || p.type === "Property"), G = (p.type === "ReturnStatement" || p.type === "ThrowStatement") && !(S || b), U = a && k.type === "JSXExpressionContainer" && e.grandparent.type !== "JSXAttribute", Oe = Uc(e), P = $c(u, p), V = o && ut(e, t), ue = j ? t.useTabs ? "	" : " ".repeat(t.tabWidth - 1) : "", ot = Wc(c, d, D, t) || S || b, xe = !x && !y && !o && (U ? d.type === "NullLiteral" || d.type === "Literal" && d.value === null : Vn(d, t) && Er(u.test, 3)), cr = x || g || o && !y || y && a && Er(u.test, 1) || xe, Dr = [];
+  !S && h(d, T.Dangling) && e.call((me) => {
+    Dr.push($(me, t), F);
+  }, "consequent");
+  let xt = [];
+  h(u.test, T.Dangling) && e.call((me) => {
+    xt.push($(me, t));
+  }, "test"), !b && h(D, T.Dangling) && e.call((me) => {
+    xt.push($(me, t));
+  }, "alternate"), h(u, T.Dangling) && xt.push($(e, t));
+  let yr = Symbol("test"), Qa = Symbol("consequent"), Ot = Symbol("test-and-consequent"), Ya = a ? [Cn(n("test")), u.test.type === "ConditionalExpression" ? ve : ""] : [n("checkType"), " ", "extends", " ", We(u.extendsType) || u.extendsType.type === "TSMappedType" ? n("extendsType") : m(Cn(n("extendsType")))], dr = m([Ya, " ?"], { id: yr }), Za = n(i), Jt = A([S || U && (K(d) || y || x) ? F : C, Dr, Za]), eo = cr ? m([dr, x ? Jt : w(Jt, m(Jt, { id: Qa }), { groupId: yr })], { id: Ot }) : [dr, Jt], ln = n(s), mr = xe ? w(ln, Du(Cn(ln)), { groupId: Ot }) : ln, ht = [eo, xt.length > 0 ? [A([F, xt]), F] : b ? F : xe ? w(C, " ", { groupId: Ot }) : C, ":", b ? " " : j ? cr ? w(ue, w(x || xe ? " " : ue, " "), { groupId: Ot }) : w(ue, " ") : " ", b ? mr : m([A(mr), U && !xe ? E : ""]), P && !Oe ? E : "", ot ? ve : ""];
+  return O && !ot ? m(A([E, m(ht)])) : O || G ? m(A(ht)) : Oe || o && f ? m([A([E, ht]), V ? E : ""]) : p === k ? m(ht) : ht;
+}
+function Gc(e, t, n, r) {
+  let { node: u } = e;
+  if (Un(u))
+    return Bc(e, t);
+  let a = t.semi ? ";" : "", o = [];
+  switch (u.type) {
+    case "JsExpressionRoot":
+      return n("node");
+    case "JsonRoot":
+      return [$(e, t), n("node"), F];
+    case "File":
+      return bc(e, t, n) ?? n("program");
+    case "EmptyStatement":
+      return "";
+    case "ExpressionStatement":
+      return Sc(e, t, n);
+    case "ChainExpression":
+      return n("expression");
+    case "ParenthesizedExpression":
+      return !h(u.expression) && (Ae(u.expression) || Q(u.expression)) ? ["(", n("expression"), ")"] : m(["(", A([E, n("expression")]), E, ")"]);
+    case "AssignmentExpression":
+      return gl(e, t, n);
+    case "VariableDeclarator":
+      return xl(e, t, n);
+    case "BinaryExpression":
+    case "LogicalExpression":
+      return $u(e, t, n);
+    case "AssignmentPattern":
+      return [n("left"), " = ", n("right")];
+    case "OptionalMemberExpression":
+    case "MemberExpression":
+      return El(e, t, n);
+    case "MetaProperty":
+      return [n("meta"), ".", n("property")];
+    case "BindExpression":
+      return u.object && o.push(n("object")), o.push(m(A([E, ma(e, t, n)]))), o;
+    case "Identifier":
+      return [u.name, re(e), da(e), z(e, n)];
+    case "V8IntrinsicIdentifier":
+      return ["%", u.name];
+    case "SpreadElement":
+    case "SpreadElementPattern":
+    case "SpreadPropertyPattern":
+    case "RestElement":
+      return fa(e, n);
+    case "FunctionDeclaration":
+    case "FunctionExpression":
+      return ga(e, t, n, r);
+    case "ArrowFunctionExpression":
+      return ac(e, t, n, r);
+    case "YieldExpression":
+      return o.push("yield"), u.delegate && o.push("*"), u.argument && o.push(" ", n("argument")), o;
+    case "AwaitExpression":
+      if (o.push("await"), u.argument) {
+        o.push(" ", n("argument"));
+        let { parent: i } = e;
+        if (L(i) && i.callee === u || W(i) && i.object === u) {
+          o = [A([E, ...o]), E];
+          let s = e.findAncestor((l) => l.type === "AwaitExpression" || l.type === "BlockStatement");
+          if ((s == null ? void 0 : s.type) !== "AwaitExpression" || !te(s.argument, (l) => l === u))
+            return m(o);
+        }
+      }
+      return o;
+    case "ExportDefaultDeclaration":
+    case "ExportNamedDeclaration":
+    case "ExportAllDeclaration":
+      return Ja(e, t, n);
+    case "ImportDeclaration":
+      return Pc(e, t, n);
+    case "ImportSpecifier":
+    case "ExportSpecifier":
+    case "ImportNamespaceSpecifier":
+    case "ExportNamespaceSpecifier":
+    case "ImportDefaultSpecifier":
+    case "ExportDefaultSpecifier":
+      return Lc(e, t, n);
+    case "ImportAttribute":
+      return An(e, t, n);
+    case "Program":
+    case "BlockStatement":
+    case "StaticBlock":
+      return Ta(e, t, n);
+    case "ClassBody":
+      return Ac(e, t, n);
+    case "ThrowStatement":
+      return nc(e, t, n);
+    case "ReturnStatement":
+      return tc(e, t, n);
+    case "NewExpression":
+    case "ImportExpression":
+    case "OptionalCallExpression":
+    case "CallExpression":
+      return Hu(e, t, n);
+    case "ObjectExpression":
+    case "ObjectPattern":
+      return pn(e, t, n);
+    case "Property":
+      return nn(u) ? Mn(e, t, n) : An(e, t, n);
+    case "ObjectProperty":
+      return An(e, t, n);
+    case "ObjectMethod":
+      return Mn(e, t, n);
+    case "Decorator":
+      return ["@", n("expression")];
+    case "ArrayExpression":
+    case "ArrayPattern":
+      return ar(e, t, n);
+    case "SequenceExpression": {
+      let { parent: i } = e;
+      if (i.type === "ExpressionStatement" || i.type === "ForStatement") {
+        let l = [];
+        return e.each(({ isFirst: d }) => {
+          d ? l.push(n()) : l.push(",", A([C, n()]));
+        }, "expressions"), m(l);
+      }
+      let s = N([",", C], e.map(n, "expressions"));
+      return (i.type === "ReturnStatement" || i.type === "ThrowStatement") && e.key === "argument" || i.type === "ArrowFunctionExpression" && e.key === "body" ? m(w([A([E, s]), E], s)) : m(s);
+    }
+    case "ThisExpression":
+      return "this";
+    case "Super":
+      return "super";
+    case "Directive":
+      return [n("value"), a];
+    case "UnaryExpression":
+      return o.push(u.operator), /[a-z]$/u.test(u.operator) && o.push(" "), h(u.argument) ? o.push(m(["(", A([E, n("argument")]), E, ")"])) : o.push(n("argument")), o;
+    case "UpdateExpression":
+      return [u.prefix ? u.operator : "", n("argument"), u.prefix ? "" : u.operator];
+    case "ConditionalExpression":
+      return lr(e, t, n, r);
+    case "VariableDeclaration": {
+      let i = e.map(n, "declarations"), s = e.parent, l = s.type === "ForStatement" || s.type === "ForInStatement" || s.type === "ForOfStatement", d = u.declarations.some((c) => c.init), D;
+      return i.length === 1 && !h(u.declarations[0]) ? D = i[0] : i.length > 0 && (D = A(i[0])), o = [ie(e), u.kind, D ? [" ", D] : "", A(i.slice(1).map((c) => [",", d && !l ? F : C, c]))], l && s.body !== u || o.push(a), m(o);
+    }
+    case "WithStatement":
+      return m(["with (", n("object"), ")", qe(u.body, n("body"))]);
+    case "IfStatement": {
+      let i = qe(u.consequent, n("consequent")), s = m(["if (", m([A([E, n("test")]), E]), ")", i]);
+      if (o.push(s), u.alternate) {
+        let l = h(u.consequent, T.Trailing | T.Line) || ou(u), d = u.consequent.type === "BlockStatement" && !l;
+        o.push(d ? " " : F), h(u, T.Dangling) && o.push($(e, t), l ? F : " "), o.push("else", m(qe(u.alternate, n("alternate"), u.alternate.type === "IfStatement")));
+      }
+      return o;
+    }
+    case "ForStatement": {
+      let i = qe(u.body, n("body")), s = $(e, t), l = s ? [s, E] : "";
+      return !u.init && !u.test && !u.update ? [l, m(["for (;;)", i])] : [l, m(["for (", m([A([E, n("init"), ";", C, n("test"), ";", C, n("update")]), E]), ")", i])];
+    }
+    case "WhileStatement":
+      return m(["while (", m([A([E, n("test")]), E]), ")", qe(u.body, n("body"))]);
+    case "ForInStatement":
+      return m(["for (", n("left"), " in ", n("right"), ")", qe(u.body, n("body"))]);
+    case "ForOfStatement":
+      return m(["for", u.await ? " await" : "", " (", n("left"), " of ", n("right"), ")", qe(u.body, n("body"))]);
+    case "DoWhileStatement": {
+      let i = qe(u.body, n("body"));
+      return o = [m(["do", i])], u.body.type === "BlockStatement" ? o.push(" ") : o.push(F), o.push("while (", m([A([E, n("test")]), E]), ")", a), o;
+    }
+    case "DoExpression":
+      return [u.async ? "async " : "", "do ", n("body")];
+    case "BreakStatement":
+    case "ContinueStatement":
+      return o.push(u.type === "BreakStatement" ? "break" : "continue"), u.label && o.push(" ", n("label")), o.push(a), o;
+    case "LabeledStatement":
+      return u.body.type === "EmptyStatement" ? [n("label"), ":;"] : [n("label"), ": ", n("body")];
+    case "TryStatement":
+      return ["try ", n("block"), u.handler ? [" ", n("handler")] : "", u.finalizer ? [" finally ", n("finalizer")] : ""];
+    case "CatchClause":
+      if (u.param) {
+        let i = h(u.param, (l) => !ye(l) || l.leading && pe(t.originalText, I(l)) || l.trailing && pe(t.originalText, q(l), { backwards: !0 })), s = n("param");
+        return ["catch ", i ? ["(", A([E, s]), E, ") "] : ["(", s, ") "], n("body")];
+      }
+      return ["catch ", n("body")];
+    case "SwitchStatement":
+      return [m(["switch (", A([E, n("discriminant")]), E, ")"]), " {", u.cases.length > 0 ? A([F, N(F, e.map(({ node: i, isLast: s }) => [n(), !s && Ne(i, t) ? F : ""], "cases"))]) : "", F, "}"];
+    case "SwitchCase": {
+      u.test ? o.push("case ", n("test"), ":") : o.push("default:"), h(u, T.Dangling) && o.push(" ", $(e, t));
+      let i = u.consequent.filter((s) => s.type !== "EmptyStatement");
+      if (i.length > 0) {
+        let s = On(e, t, n, "consequent");
+        o.push(i.length === 1 && i[0].type === "BlockStatement" ? [" ", s] : A([F, s]));
+      }
+      return o;
+    }
+    case "DebuggerStatement":
+      return ["debugger", a];
+    case "ClassDeclaration":
+    case "ClassExpression":
+      return va(e, t, n);
+    case "ClassMethod":
+    case "ClassPrivateMethod":
+    case "MethodDefinition":
+      return wa(e, t, n);
+    case "ClassProperty":
+    case "PropertyDefinition":
+    case "ClassPrivateProperty":
+    case "ClassAccessorProperty":
+    case "AccessorProperty":
+      return Ia(e, t, n);
+    case "TemplateElement":
+      return He(u.value.raw);
+    case "TemplateLiteral":
+      return Iu(e, t, n);
+    case "TaggedTemplateExpression":
+      return Bs(e, t, n);
+    case "PrivateIdentifier":
+      return ["#", u.name];
+    case "PrivateName":
+      return ["#", n("id")];
+    case "TopicReference":
+      return "%";
+    case "ArgumentPlaceholder":
+      return "?";
+    case "ModuleExpression":
+      return ["module ", n("body")];
+    case "InterpreterDirective":
+    default:
+      throw new At(u, "ESTree");
+  }
+}
+function Ra(e, t, n) {
+  let { parent: r, node: u, key: a } = e, o = [n("expression")];
+  switch (u.type) {
+    case "AsConstExpression":
+      o.push(" as const");
+      break;
+    case "AsExpression":
+    case "TSAsExpression":
+      o.push(" as ", n("typeAnnotation"));
+      break;
+    case "SatisfiesExpression":
+    case "TSSatisfiesExpression":
+      o.push(" satisfies ", n("typeAnnotation"));
+      break;
+  }
+  return a === "callee" && L(r) || a === "object" && W(r) ? m([A([E, ...o]), E]) : o;
+}
+function Vc(e, t, n) {
+  let { node: r } = e, u = [ie(e), "component"];
+  r.id && u.push(" ", n("id")), u.push(n("typeParameters"));
+  let a = Kc(e, t, n);
+  return r.rendersType ? u.push(m([a, " ", n("rendersType")])) : u.push(m([a])), r.body && u.push(" ", n("body")), t.semi && r.type === "DeclareComponent" && u.push(";"), u;
+}
+function Kc(e, t, n) {
+  let { node: r } = e, u = r.params;
+  if (r.rest && (u = [...u, r.rest]), u.length === 0)
+    return ["(", $(e, t, { filter: (o) => ge(t.originalText, I(o)) === ")" }), ")"];
+  let a = [];
+  return zc(e, (o, i) => {
+    let s = i === u.length - 1;
+    s && r.rest && a.push("..."), a.push(n()), !s && (a.push(","), Ne(u[i], t) ? a.push(F, F) : a.push(C));
+  }), ["(", A([E, ...a]), w(Ie(t, "all") && !Hc(r, u) ? "," : ""), E, ")"];
+}
+function Hc(e, t) {
+  var n;
+  return e.rest || ((n = X(!1, t, -1)) == null ? void 0 : n.type) === "RestElement";
+}
+function zc(e, t) {
+  let { node: n } = e, r = 0, u = (a) => t(a, r++);
+  e.each(u, "params"), n.rest && e.call(u, "rest");
+}
+function Qc(e, t, n) {
+  let { node: r } = e;
+  return r.shorthand ? n("local") : [n("name"), " as ", n("local")];
+}
+function Yc(e, t, n) {
+  let { node: r } = e, u = [];
+  return r.name && u.push(n("name"), r.optional ? "?: " : ": "), u.push(n("typeAnnotation")), u;
+}
+function Ua(e, t, n) {
+  return pn(e, t, n);
+}
+function Ga(e, t) {
+  let { node: n } = e, r = t("id");
+  n.computed && (r = ["[", r, "]"]);
+  let u = "";
+  return n.initializer && (u = t("initializer")), n.init && (u = t("init")), u ? [r, " = ", u] : r;
+}
+function Va(e, t) {
+  let { node: n } = e;
+  return [ie(e), n.const ? "const " : "", "enum ", t("id"), " ", t("body")];
+}
+function Zc(e, t, n) {
+  let { node: r } = e, u = ["hook"];
+  r.id && u.push(" ", n("id"));
+  let a = at(e, t, n, !1, !0), o = sn(e, n), i = gt(r, o);
+  return u.push(m([i ? m(a) : a, o]), r.body ? " " : "", n("body")), u;
+}
+function eD(e, t, n) {
+  let { node: r } = e, u = [ie(e), "hook"];
+  return r.id && u.push(" ", n("id")), t.semi && u.push(";"), u;
+}
+function qr(e) {
+  var t;
+  let { node: n } = e;
+  return n.type === "HookTypeAnnotation" && ((t = e.getParentNode(2)) == null ? void 0 : t.type) === "DeclareHook";
+}
+function tD(e, t, n) {
+  let { node: r } = e, u = [];
+  u.push(qr(e) ? "" : "hook ");
+  let a = at(e, t, n, !1, !0), o = [];
+  return o.push(qr(e) ? ": " : " => ", n("returnType")), gt(r, o) && (a = m(a)), u.push(a, o), m(u);
+}
+function Ka(e, t, n) {
+  let { node: r } = e, u = [ie(e), "interface"], a = [], o = [];
+  r.type !== "InterfaceTypeAnnotation" && a.push(" ", n("id"), n("typeParameters"));
+  let i = r.typeParameters && !h(r.typeParameters, T.Trailing | T.Line);
+  return J(r.extends) && o.push(i ? w(" ", C, { groupId: ir(r.typeParameters) }) : C, "extends ", (r.extends.length === 1 ? pi : A)(N([",", C], e.map(n, "extends")))), h(r.id, T.Trailing) || J(r.extends) ? i ? u.push(m([...a, A(o)])) : u.push(m(A([...a, ...o]))) : u.push(...a, ...o), u.push(" ", n("body")), m(u);
+}
+function nD(e) {
+  switch (e) {
+    case null:
+      return "";
+    case "PlusOptional":
+      return "+?";
+    case "MinusOptional":
+      return "-?";
+    case "Optional":
+      return "?";
+  }
+}
+function rD(e, t, n) {
+  let { node: r } = e;
+  return m([r.variance ? n("variance") : "", "[", A([n("keyTparam"), " in ", n("sourceType")]), "]", nD(r.optional), ": ", n("propType")]);
+}
+function _r(e, t) {
+  return e === "+" || e === "-" ? e + t : t;
+}
+function uD(e, t, n) {
+  let { node: r } = e, u = !1;
+  if (t.objectWrap === "preserve") {
+    let a = q(r), o = sr(t, a + 1, q(r.key)), i = a + 1 + o.search(/\S/u);
+    ce(t.originalText, a, i) && (u = !0);
+  }
+  return m(["{", A([t.bracketSpacing ? C : E, h(r, T.Dangling) ? m([$(e, t), F]) : "", m([r.readonly ? [_r(r.readonly, "readonly"), " "] : "", "[", n("key"), " in ", n("constraint"), r.nameType ? [" as ", n("nameType")] : "", "]", r.optional ? _r(r.optional, "?") : "", r.typeAnnotation ? ": " : "", n("typeAnnotation")]), t.semi ? w(";") : ""]), t.bracketSpacing ? C : E, "}"], { shouldBreak: u });
+}
+function aD(e, t, n) {
+  let { node: r } = e;
+  if (Qr(r))
+    return r.type.slice(0, -14).toLowerCase();
+  let u = t.semi ? ";" : "";
+  switch (r.type) {
+    case "ComponentDeclaration":
+    case "DeclareComponent":
+    case "ComponentTypeAnnotation":
+      return Vc(e, t, n);
+    case "ComponentParameter":
+      return Qc(e, t, n);
+    case "ComponentTypeParameter":
+      return Yc(e, t, n);
+    case "HookDeclaration":
+      return Zc(e, t, n);
+    case "DeclareHook":
+      return eD(e, t, n);
+    case "HookTypeAnnotation":
+      return tD(e, t, n);
+    case "DeclareClass":
+      return va(e, t, n);
+    case "DeclareFunction":
+      return [ie(e), "function ", n("id"), n("predicate"), u];
+    case "DeclareModule":
+      return ["declare module ", n("id"), " ", n("body")];
+    case "DeclareModuleExports":
+      return ["declare module.exports", z(e, n), u];
+    case "DeclareNamespace":
+      return ["declare namespace ", n("id"), " ", n("body")];
+    case "DeclareVariable":
+      return [ie(e), r.kind ?? "var", " ", n("id"), u];
+    case "DeclareExportDeclaration":
+    case "DeclareExportAllDeclaration":
+      return Ja(e, t, n);
+    case "DeclareOpaqueType":
+    case "OpaqueType":
+      return _l(e, t, n);
+    case "DeclareTypeAlias":
+    case "TypeAlias":
+      return ta(e, t, n);
+    case "IntersectionTypeAnnotation":
+      return na(e, t, n);
+    case "UnionTypeAnnotation":
+      return ra(e, t, n);
+    case "ConditionalTypeAnnotation":
+      return lr(e, t, n);
+    case "InferTypeAnnotation":
+      return oa(e, t, n);
+    case "FunctionTypeAnnotation":
+      return ua(e, t, n);
+    case "TupleTypeAnnotation":
+      return ar(e, t, n);
+    case "TupleTypeLabeledElement":
+      return sa(e, t, n);
+    case "TupleTypeSpreadElement":
+      return ia(e, t, n);
+    case "GenericTypeAnnotation":
+      return [n("id"), vt(e, t, n, "typeParameters")];
+    case "IndexedAccessType":
+    case "OptionalIndexedAccessType":
+      return aa(e, t, n);
+    case "TypeAnnotation":
+      return la(e, t, n);
+    case "TypeParameter":
+      return ba(e, t, n);
+    case "TypeofTypeAnnotation":
+      return Da(e, n);
+    case "ExistsTypeAnnotation":
+      return "*";
+    case "ArrayTypeAnnotation":
+      return ca(n);
+    case "DeclareEnum":
+    case "EnumDeclaration":
+      return Va(e, n);
+    case "EnumBooleanBody":
+    case "EnumNumberBody":
+    case "EnumBigIntBody":
+    case "EnumStringBody":
+    case "EnumSymbolBody":
+      return [r.type === "EnumSymbolBody" || r.explicitType ? `of ${r.type.slice(4, -4).toLowerCase()} ` : "", Ua(e, t, n)];
+    case "EnumBooleanMember":
+    case "EnumNumberMember":
+    case "EnumBigIntMember":
+    case "EnumStringMember":
+    case "EnumDefaultedMember":
+      return Ga(e, n);
+    case "FunctionTypeParam": {
+      let a = r.name ? n("name") : e.parent.this === r ? "this" : "";
+      return [a, re(e), a ? ": " : "", n("typeAnnotation")];
+    }
+    case "DeclareInterface":
+    case "InterfaceDeclaration":
+    case "InterfaceTypeAnnotation":
+      return Ka(e, t, n);
+    case "ClassImplements":
+    case "InterfaceExtends":
+      return [n("id"), n("typeParameters")];
+    case "NullableTypeAnnotation":
+      return ["?", n("typeAnnotation")];
+    case "Variance": {
+      let { kind: a } = r;
+      return Wn.ok(a === "plus" || a === "minus"), a === "plus" ? "+" : "-";
+    }
+    case "KeyofTypeAnnotation":
+      return ["keyof ", n("argument")];
+    case "ObjectTypeCallProperty":
+      return [r.static ? "static " : "", n("value")];
+    case "ObjectTypeMappedTypeProperty":
+      return rD(e, t, n);
+    case "ObjectTypeIndexer":
+      return [r.static ? "static " : "", r.variance ? n("variance") : "", "[", n("id"), r.id ? ": " : "", n("key"), "]: ", n("value")];
+    case "ObjectTypeProperty": {
+      let a = "";
+      return r.proto ? a = "proto " : r.static && (a = "static "), [a, r.kind !== "init" ? r.kind + " " : "", r.variance ? n("variance") : "", Mt(e, t, n), re(e), nn(r) ? "" : ": ", n("value")];
+    }
+    case "ObjectTypeAnnotation":
+      return pn(e, t, n);
+    case "ObjectTypeInternalSlot":
+      return [r.static ? "static " : "", "[[", n("id"), "]]", re(e), r.method ? "" : ": ", n("value")];
+    case "ObjectTypeSpreadProperty":
+      return fa(e, n);
+    case "QualifiedTypeofIdentifier":
+    case "QualifiedTypeIdentifier":
+      return [n("qualification"), ".", n("id")];
+    case "NullLiteralTypeAnnotation":
+      return "null";
+    case "BooleanLiteralTypeAnnotation":
+      return String(r.value);
+    case "StringLiteralTypeAnnotation":
+      return He(yt(oe(r), t));
+    case "NumberLiteralTypeAnnotation":
+      return mt(oe(r));
+    case "BigIntLiteralTypeAnnotation":
+      return Jn(oe(r));
+    case "TypeCastExpression":
+      return ["(", n("expression"), z(e, n), ")"];
+    case "TypePredicate":
+      return ya(e, n);
+    case "TypeOperator":
+      return [r.operator, " ", n("typeAnnotation")];
+    case "TypeParameterDeclaration":
+    case "TypeParameterInstantiation":
+      return vt(e, t, n, "params");
+    case "InferredPredicate":
+    case "DeclaredPredicate":
+      return [e.key === "predicate" && e.parent.type !== "DeclareFunction" && !e.parent.returnType ? ": " : " ", "%checks", ...r.type === "DeclaredPredicate" ? ["(", n("value"), ")"] : []];
+    case "AsExpression":
+    case "AsConstExpression":
+    case "SatisfiesExpression":
+      return Ra(e, t, n);
+  }
+}
+function oD(e, t, n) {
+  var r;
+  let { node: u } = e;
+  if (!u.type.startsWith("TS"))
+    return;
+  if (Yr(u))
+    return u.type.slice(2, -7).toLowerCase();
+  let a = t.semi ? ";" : "", o = [];
+  switch (u.type) {
+    case "TSThisType":
+      return "this";
+    case "TSTypeAssertion": {
+      let i = !(Q(u.expression) || Ae(u.expression)), s = m(["<", A([E, n("typeAnnotation")]), E, ">"]), l = [w("("), A([E, n("expression")]), E, w(")")];
+      return i ? Ve([[s, n("expression")], [s, m(l, { shouldBreak: !0 })], [s, n("expression")]]) : m([s, n("expression")]);
+    }
+    case "TSDeclareFunction":
+      return ga(e, t, n);
+    case "TSExportAssignment":
+      return ["export = ", n("expression"), a];
+    case "TSModuleBlock":
+      return Ta(e, t, n);
+    case "TSInterfaceBody":
+    case "TSTypeLiteral":
+      return pn(e, t, n);
+    case "TSTypeAliasDeclaration":
+      return ta(e, t, n);
+    case "TSQualifiedName":
+      return [n("left"), ".", n("right")];
+    case "TSAbstractMethodDefinition":
+    case "TSDeclareMethod":
+      return wa(e, t, n);
+    case "TSAbstractAccessorProperty":
+    case "TSAbstractPropertyDefinition":
+      return Ia(e, t, n);
+    case "TSInterfaceHeritage":
+    case "TSClassImplements":
+    case "TSExpressionWithTypeArguments":
+    case "TSInstantiationExpression":
+      return [n("expression"), n(u.typeArguments ? "typeArguments" : "typeParameters")];
+    case "TSTemplateLiteralType":
+      return Iu(e, t, n);
+    case "TSNamedTupleMember":
+      return sa(e, t, n);
+    case "TSRestType":
+      return ia(e, t, n);
+    case "TSOptionalType":
+      return [n("typeAnnotation"), "?"];
+    case "TSInterfaceDeclaration":
+      return Ka(e, t, n);
+    case "TSTypeParameterDeclaration":
+    case "TSTypeParameterInstantiation":
+      return vt(e, t, n, "params");
+    case "TSTypeParameter":
+      return ba(e, t, n);
+    case "TSAsExpression":
+    case "TSSatisfiesExpression":
+      return Ra(e, t, n);
+    case "TSArrayType":
+      return ca(n);
+    case "TSPropertySignature":
+      return [u.readonly ? "readonly " : "", Mt(e, t, n), re(e), z(e, n)];
+    case "TSParameterProperty":
+      return [Zt(u), u.static ? "static " : "", u.override ? "override " : "", u.readonly ? "readonly " : "", n("parameter")];
+    case "TSTypeQuery":
+      return Da(e, n);
+    case "TSIndexSignature": {
+      let i = u.parameters.length > 1 ? w(Ie(t) ? "," : "") : "", s = m([A([E, N([", ", E], e.map(n, "parameters"))]), i, E]), l = e.parent.type === "ClassBody" && e.key === "body";
+      return [l && u.static ? "static " : "", u.readonly ? "readonly " : "", "[", u.parameters ? s : "", "]", z(e, n), l ? a : ""];
+    }
+    case "TSTypePredicate":
+      return ya(e, n);
+    case "TSNonNullExpression":
+      return [n("expression"), "!"];
+    case "TSImportType":
+      return ["import", Yt(e, t, n), u.qualifier ? [".", n("qualifier")] : "", vt(e, t, n, u.typeArguments ? "typeArguments" : "typeParameters")];
+    case "TSLiteralType":
+      return n("literal");
+    case "TSIndexedAccessType":
+      return aa(e, t, n);
+    case "TSTypeOperator":
+      return [u.operator, " ", n("typeAnnotation")];
+    case "TSMappedType":
+      return uD(e, t, n);
+    case "TSMethodSignature": {
+      let i = u.kind && u.kind !== "method" ? `${u.kind} ` : "";
+      o.push(Zt(u), i, u.computed ? "[" : "", n("key"), u.computed ? "]" : "", re(e));
+      let s = at(e, t, n, !1, !0), l = u.returnType ? "returnType" : "typeAnnotation", d = u[l], D = d ? z(e, n, l) : "", c = gt(u, D);
+      return o.push(c ? m(s) : s), d && o.push(m(D)), m(o);
+    }
+    case "TSNamespaceExportDeclaration":
+      return ["export as namespace ", n("id"), t.semi ? ";" : ""];
+    case "TSEnumDeclaration":
+      return Va(e, n);
+    case "TSEnumBody":
+      return Ua(e, t, n);
+    case "TSEnumMember":
+      return Ga(e, n);
+    case "TSImportEqualsDeclaration":
+      return [u.isExport ? "export " : "", "import ", qa(u, !1), n("id"), " = ", n("moduleReference"), t.semi ? ";" : ""];
+    case "TSExternalModuleReference":
+      return ["require(", n("expression"), ")"];
+    case "TSModuleDeclaration": {
+      let { parent: i } = e, s = i.type === "TSModuleDeclaration", l = ((r = u.body) == null ? void 0 : r.type) === "TSModuleDeclaration";
+      return s ? o.push(".") : (o.push(ie(e)), u.kind !== "global" && o.push(u.kind, " ")), o.push(n("id")), l ? o.push(n("body")) : u.body ? o.push(" ", m(n("body"))) : o.push(a), o;
+    }
+    case "TSConditionalType":
+      return lr(e, t, n);
+    case "TSInferType":
+      return oa(e, t, n);
+    case "TSIntersectionType":
+      return na(e, t, n);
+    case "TSUnionType":
+      return ra(e, t, n);
+    case "TSFunctionType":
+    case "TSCallSignatureDeclaration":
+    case "TSConstructorType":
+    case "TSConstructSignatureDeclaration":
+      return ua(e, t, n);
+    case "TSTupleType":
+      return ar(e, t, n);
+    case "TSTypeReference":
+      return [n("typeName"), vt(e, t, n, u.typeArguments ? "typeArguments" : "typeParameters")];
+    case "TSTypeAnnotation":
+      return la(e, t, n);
+    case "TSEmptyBodyFunctionExpression":
+      return or(e, t, n);
+    case "TSJSDocAllType":
+      return "*";
+    case "TSJSDocUnknownType":
+      return "?";
+    case "TSJSDocNullableType":
+      return Lr(e, n, "?");
+    case "TSJSDocNonNullableType":
+      return Lr(e, n, "!");
+    case "TSParenthesizedType":
+    default:
+      throw new At(u, "TypeScript");
+  }
+}
+function iD(e, t, n, r) {
+  if (Xu(e))
+    return gp(e, t);
+  for (let u of [ul, Qp, aD, oD, Gc]) {
+    let a = u(e, t, n, r);
+    if (a !== void 0)
+      return a;
+  }
+}
+var sD = _(["ClassMethod", "ClassPrivateMethod", "ClassProperty", "ClassAccessorProperty", "AccessorProperty", "TSAbstractAccessorProperty", "PropertyDefinition", "TSAbstractPropertyDefinition", "ClassPrivateProperty", "MethodDefinition", "TSAbstractMethodDefinition", "TSDeclareMethod"]);
+function pD(e, t, n, r) {
+  var u;
+  e.isRoot && ((u = t.__onHtmlBindingRoot) == null || u.call(t, e.node, t));
+  let a = iD(e, t, n, r);
+  if (!a)
+    return "";
+  let { node: o } = e;
+  if (sD(o))
+    return a;
+  let i = J(o.decorators), s = pl(e, t, n), l = o.type === "ClassExpression";
+  if (i && !l)
+    return Bn(a, (c) => m([s, c]));
+  let d = ut(e, t), D = Tc(e, t);
+  return !s && !d && !D ? a : Bn(a, (c) => [D ? ";" : "", d ? "(" : "", d && l && i ? [A([C, s, c]), C] : [s, c], d ? ")" : ""]);
+}
+var lD = pD, cD = { avoidAstMutation: !0 }, DD = [{ name: "JSON.stringify", type: "data", extensions: [".importmap"], tmScope: "source.json", aceMode: "json", aliases: ["geojson", "jsonl", "sarif", "topojson"], codemirrorMode: "javascript", codemirrorMimeType: "application/json", filenames: ["package.json", "package-lock.json", "composer.json"], parsers: ["json-stringify"], vscodeLanguageIds: ["json"], linguistLanguageId: 174 }, { name: "JSON", type: "data", extensions: [".json", ".4DForm", ".4DProject", ".avsc", ".geojson", ".gltf", ".har", ".ice", ".JSON-tmLanguage", ".json.example", ".mcmeta", ".sarif", ".tact", ".tfstate", ".tfstate.backup", ".topojson", ".webapp", ".webmanifest", ".yy", ".yyp"], tmScope: "source.json", aceMode: "json", aliases: ["geojson", "jsonl", "sarif", "topojson"], codemirrorMode: "javascript", codemirrorMimeType: "application/json", filenames: [".all-contributorsrc", ".arcconfig", ".auto-changelog", ".c8rc", ".htmlhintrc", ".imgbotconfig", ".nycrc", ".tern-config", ".tern-project", ".watchmanconfig", ".babelrc", ".jscsrc", ".jshintrc", ".jslintrc", ".swcrc"], parsers: ["json"], vscodeLanguageIds: ["json"], linguistLanguageId: 174 }, { name: "JSON with Comments", type: "data", 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"], tmScope: "source.json.comments", aceMode: "javascript", aliases: ["jsonc"], codemirrorMode: "javascript", codemirrorMimeType: "text/javascript", group: "JSON", filenames: [], parsers: ["jsonc"], vscodeLanguageIds: ["jsonc"], linguistLanguageId: 423 }, { name: "JSON5", type: "data", extensions: [".json5"], tmScope: "source.js", aceMode: "javascript", codemirrorMode: "javascript", codemirrorMimeType: "application/json", parsers: ["json5"], vscodeLanguageIds: ["json5"], linguistLanguageId: 175 }], Ha = {};
+en(Ha, { getVisitorKeys: () => fD, massageAstNode: () => za, print: () => ED });
+var yD = { JsonRoot: ["node"], ArrayExpression: ["elements"], ObjectExpression: ["properties"], ObjectProperty: ["key", "value"], UnaryExpression: ["argument"], NullLiteral: [], BooleanLiteral: [], StringLiteral: [], NumericLiteral: [], Identifier: [], TemplateLiteral: ["quasis"], TemplateElement: [] }, dD = yD, mD = Hr(dD), fD = mD;
+function ED(e, t, n) {
+  let { node: r } = e;
+  switch (r.type) {
+    case "JsonRoot":
+      return [n("node"), F];
+    case "ArrayExpression": {
+      if (r.elements.length === 0)
+        return "[]";
+      let u = e.map(() => e.node === null ? "null" : n(), "elements");
+      return ["[", A([F, N([",", F], u)]), F, "]"];
+    }
+    case "ObjectExpression":
+      return r.properties.length === 0 ? "{}" : ["{", A([F, N([",", F], e.map(n, "properties"))]), F, "}"];
+    case "ObjectProperty":
+      return [n("key"), ": ", n("value")];
+    case "UnaryExpression":
+      return [r.operator === "+" ? "" : r.operator, n("argument")];
+    case "NullLiteral":
+      return "null";
+    case "BooleanLiteral":
+      return r.value ? "true" : "false";
+    case "StringLiteral":
+      return JSON.stringify(r.value);
+    case "NumericLiteral":
+      return Xr(e) ? JSON.stringify(String(r.value)) : JSON.stringify(r.value);
+    case "Identifier":
+      return Xr(e) ? JSON.stringify(r.name) : r.name;
+    case "TemplateLiteral":
+      return n(["quasis", 0]);
+    case "TemplateElement":
+      return JSON.stringify(r.value.cooked);
+    default:
+      throw new At(r, "JSON");
+  }
+}
+function Xr(e) {
+  return e.key === "key" && e.parent.type === "ObjectProperty";
+}
+var FD = /* @__PURE__ */ new Set(["start", "end", "extra", "loc", "comments", "leadingComments", "trailingComments", "innerComments", "errors", "range", "tokens"]);
+function za(e, t) {
+  let { type: n } = e;
+  if (n === "ObjectProperty") {
+    let { key: r } = e;
+    r.type === "Identifier" ? t.key = { type: "StringLiteral", value: r.name } : r.type === "NumericLiteral" && (t.key = { type: "StringLiteral", value: String(r.value) });
+    return;
+  }
+  if (n === "UnaryExpression" && e.operator === "+")
+    return t.argument;
+  if (n === "ArrayExpression") {
+    for (let [r, u] of e.elements.entries())
+      u === null && t.elements.splice(r, 0, { type: "NullLiteral" });
+    return;
+  }
+  if (n === "TemplateLiteral")
+    return { type: "StringLiteral", value: e.quasis[0].value.cooked };
+}
+za.ignoredProperties = FD;
+var Tt = { bracketSpacing: { category: "Common", type: "boolean", default: !0, 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: !1, description: "Use single quotes instead of double quotes." }, proseWrap: { category: "Common", type: "choice", default: "preserve", description: "How to wrap prose.", choices: [{ value: "always", description: "Wrap prose if it exceeds the print width." }, { value: "never", description: "Do not wrap prose." }, { value: "preserve", description: "Wrap prose as-is." }] }, bracketSameLine: { category: "Common", type: "boolean", default: !1, description: "Put > of opening tags on the last line instead of on a new line." }, singleAttributePerLine: { category: "Common", type: "boolean", default: !1, description: "Enforce single attribute per line in HTML, Vue and JSX." } }, _e = "JavaScript", AD = { arrowParens: { category: _e, 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: Tt.bracketSameLine, objectWrap: Tt.objectWrap, bracketSpacing: Tt.bracketSpacing, jsxBracketSameLine: { category: _e, type: "boolean", description: "Put > on the last line instead of at a new line.", deprecated: "2.4.0" }, semi: { category: _e, type: "boolean", default: !0, description: "Print semicolons.", oppositeDescription: "Do not print semicolons, except at the beginning of lines which may need them." }, experimentalOperatorPosition: { category: _e, 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: _e, type: "boolean", default: !1, 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: Tt.singleQuote, jsxSingleQuote: { category: _e, type: "boolean", default: !1, description: "Use single quotes in JSX." }, quoteProps: { category: _e, 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: _e, 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: Tt.singleAttributePerLine }, gD = AD, xD = { estree: Ur, "estree-json": Ha }, hD = [...oo, ...DD], TD = Rr;
+export {
+  TD as default,
+  hD as languages,
+  gD as options,
+  xD as printers
+};