prettier-plugin-embed 0.4.15 → 0.5.1

package/dist/index.js

@@ -1,75 +1,133 @@
-import { builders as M, utils as si } from "prettier/doc";
-import bi from "prettier/parser-babel";
-import fi from "prettier/parser-espree";
-import yi from "prettier/parser-flow";
-import _i from "prettier/parser-meriyah";
-import $i from "prettier/parser-typescript";
-import { printers as vi } from "prettier/plugins/estree.mjs";
-import { resolveConfigFile as Di } from "prettier";
-const { group: Ti, indent: Mi, softline: Be, hardline: Ai, lineSuffixBoundary: Si } = M, { mapDoc: ki } = si;
-function Li(e, t) {
-  const { node: n } = e;
-  let r = t();
-  return n?.comments?.length && (r = Ti([Mi([Be, r]), Be])), ["${", r, Si, "}"];
-}
-function k(e, t) {
-  return e.map(
-    (n) => Li(n, t),
+import { builders as A, utils as bi } from "prettier/doc";
+import Oi from "prettier/parser-babel";
+import Gi from "prettier/parser-espree";
+import Ii from "prettier/parser-flow";
+import xi from "prettier/parser-meriyah";
+import Pi from "prettier/parser-typescript";
+import { printers as qi } from "prettier/plugins/estree.mjs";
+import { resolveConfigFile as ji } from "prettier";
+const {
+  group: Fe,
+  indent: Ri,
+  softline: ze,
+  lineSuffixBoundary: Bi,
+  addAlignmentToDoc: wi,
+  align: Ui,
+  hardline: Ci
+} = A, { mapDoc: Wi, replaceEndOfLine: Fi } = bi;
+function zi(t, e) {
+  let n = 0;
+  for (const i of t)
+    i === "	" ? n = n + e - n % e : n++;
+  return n;
+}
+function Je(t, e) {
+  const n = t.lastIndexOf(`
+`);
+  if (n === -1)
+    return 0;
+  const r = t.slice(n + 1).match(/^[\t ]*/)?.[0] ?? "";
+  return zi(r, e);
+}
+function Ji(t, e, n) {
+  let i = e;
+  const o = t.quasis[i]?.value.raw ?? "";
+  if (o.includes(`
+`))
+    return {
+      indentSize: Je(o, n),
+      previousQuasiText: o
+    };
+  for (; i-- > 0; ) {
+    const s = t.quasis[i];
+    if (!s) break;
+    const l = s.value.raw;
+    if (l.includes(`
+`))
+      return { indentSize: Je(l, n), previousQuasiText: o };
+  }
+  return { indentSize: 0, previousQuasiText: o };
+}
+function Xi(t, e, n, i, r) {
+  const { node: o } = t;
+  let s = e();
+  o?.comments?.length && (s = Fe([Ri([ze, s]), ze]));
+  const { indentSize: l, previousQuasiText: p } = Ji(
+    n,
+    i,
+    r
+  );
+  let f = s;
+  return f = l === 0 && p.endsWith(`
+`) ? Ui(Number.NEGATIVE_INFINITY, f) : wi(f, l, r), Fe(["${", f, Bi, "}"]);
+}
+function L(t, e, n) {
+  const r = t.node;
+  return t.map(
+    (o, s) => Xi(
+      o,
+      e,
+      r,
+      s,
+      2
+    ),
     "expressions"
   );
 }
-function S(e, t, n, r = !1) {
-  return ki(e, (a) => {
-    if (typeof a != "string")
-      return a;
-    const s = [], l = a.split(t);
-    for (let u = 0; u < l.length; u++) {
-      let E = l[u];
-      if (u % 2 === 0) {
-        if (!E)
+function M(t, e, n, i = !1) {
+  return Wi(t, (o) => {
+    if (typeof o != "string")
+      return o;
+    const s = [], l = o.split(e);
+    for (let p = 0; p < l.length; p++) {
+      let f = l[p];
+      if (p % 2 === 0) {
+        if (!f)
           continue;
-        if (E = E.replaceAll(/([\\`]|\${)/g, "\\$1"), r)
-          for (const d of E.split(/(\n)/))
+        if (f = f.replaceAll(/([\\`]|\${)/g, "\\$1"), i === "literalline")
+          s.push(Fi(f));
+        else if (i === "hardline")
+          for (const d of f.split(/(\n)/))
             d === `
-` ? s.push(Ai) : s.push(d);
+` ? s.push(Ci) : s.push(d);
         else
-          s.push(E);
+          s.push(f);
       } else {
-        const d = Number(E);
+        const d = Number(f);
         s.push(n[d]);
       }
     }
     return s;
   });
 }
-function Gi(e, t, n) {
-  if (t === n) {
-    e.unshift(t);
+function Hi(t, e, n) {
+  if (e === n) {
+    t.unshift(e);
     return;
   }
-  let r = 0, i = e.length;
-  for (; r < i; ) {
-    const a = r + i >>> 1;
-    if (e[a] === n) {
-      e.push(t);
+  let i = 0, r = t.length;
+  for (; i < r; ) {
+    const o = i + r >>> 1;
+    if (t[o] === n) {
+      t.push(e);
       return;
     }
-    e[a] < t ? r = a + 1 : i = a;
+    t[o] < e ? i = o + 1 : r = o;
   }
-  e.splice(r, 0, t);
+  t.splice(i, 0, e);
 }
-const he = (() => {
-  const e = [...Array(26).keys()].map((t) => String.fromCharCode(t + 97)).concat([...Array(10).keys()].map((t) => `${t}`));
+const ye = (() => {
+  const t = [...Array(26).keys()].map((e) => String.fromCharCode(e + 97)).concat([...Array(10).keys()].map((e) => `${e}`));
   return () => {
     let n = "";
-    for (let r = 0; r < 16; ++r)
-      n += e[parseInt((Math.random() * e.length).toFixed(0), 10) % e.length];
+    for (let i = 0; i < 16; ++i)
+      n += t[Number.parseInt((Math.random() * t.length).toFixed(0), 10) % t.length];
     return n;
   };
 })();
-function L(e = "p", t = "") {
-  const n = he(), r = he(), i = qe(e), a = qe(t), s = (u) => `${e}${n}${u}${r}${t}`, l = new RegExp(
-    `${i}${n}(\\d+)${r}${a}`,
+function N(t = "p", e = "") {
+  const n = ye(), i = ye(), r = Xe(t), o = Xe(e), s = (p) => `${t}${n}${p}${i}${e}`, l = new RegExp(
+    `${r}${n}(\\d+)${i}${o}`,
     "ig"
   );
   return {
@@ -77,127 +135,128 @@ function L(e = "p", t = "") {
     placeholderRegex: l
   };
 }
-function qe(e) {
-  return e.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+function Xe(t) {
+  return t.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
 }
-function D(e) {
-  return `${e}Identifiers`;
+function T(t) {
+  return `${t}Identifiers`;
 }
-function A(e) {
-  return `${e}Comments`;
+function S(t) {
+  return `${t}Comments`;
 }
-function T(e) {
-  return `${e}Tags`;
+function v(t) {
+  return `${t}Tags`;
 }
-function Ni(e) {
-  return `${e}Plugin`;
+function Qi(t) {
+  return `${t}Plugin`;
 }
-function O(e) {
-  return `${e}Parser`;
+function G(t) {
+  return `${t}Parser`;
 }
-const _ = "9ff2b366e8ca4c97b9aed1a29b5b94ed", { line: je, group: I, indent: Ue, softline: Re } = M, Oi = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
+const $ = "9ff2b366e8ca4c97b9aed1a29b5b94ed", { line: He, group: P, indent: Qe, softline: Ve } = A, Vi = async (t, e, n, i, { commentOrTag: r, embeddedOverrideOptions: o }) => {
   const s = {
-    ...r,
-    ...a
-  }, { node: l } = n, { createPlaceholder: u, placeholderRegex: E } = L(
+    ...i,
+    ...o
+  }, { node: l } = n, { createPlaceholder: p, placeholderRegex: f } = N(
     "@prettier-placeholder"
   ), d = l.quasis.map(
-    (m, g, { length: y }) => g === y - 1 ? m.value.cooked : m.value.cooked + u(g)
-  ).join(""), c = d.match(/^\s+/)?.[0] ?? "", p = d.match(/\s+$/)?.[0] ?? "", f = d.slice(
-    c.length,
-    -p.length || void 0
-  ), b = k(n, t), $ = await e(f, {
+    (m, h, { length: _ }) => h === _ - 1 ? m.value.cooked : m.value.cooked + p(h)
+  ).join(""), u = d.match(/^\s+/)?.[0] ?? "", c = d.match(/\s+$/)?.[0] ?? "", y = d.slice(
+    u.length,
+    -c.length || void 0
+  ), b = L(n, e), D = await t(y, {
     ...s,
     parser: s.embeddedCssParser ?? "scss"
-  }), o = S(
-    $,
-    E,
+  }), a = M(
+    D,
+    f,
     b,
+    // Use literalline to preserve original indentation in CSS comments
     // https://github.com/prettier/prettier/blob/3bfabd012873e5022f341aca75566966d91870f1/src/language-js/embed/css.js#L52
-    !0
+    "literalline"
   );
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return I([
+  if (s.preserveEmbeddedExteriorWhitespaces?.includes(r))
+    return P([
       "`",
+      u,
+      s.noEmbeddedMultiLineIndentation?.includes(r) ? [P(a)] : Qe([P(a)]),
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [I(o)] : Ue([I(o)]),
-      p,
       "`"
     ]);
-  const h = c.length ? je : Re, v = p.length ? je : Re;
-  return I([
+  const g = u.length ? He : Ve, E = c.length ? He : Ve;
+  return P([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, I(o)] : Ue([h, I(o)]),
-    v,
+    s.noEmbeddedMultiLineIndentation?.includes(r) ? [g, P(a)] : Qe([g, P(a)]),
+    E,
     "`"
   ]);
-}, re = "embeddedCss", xi = ["css"], Ii = ["css", "less", "scss"], Pi = D(re), Ce = A(re), we = T(re), Bi = O(re), qi = {
-  [Pi]: {
+}, ce = "embeddedCss", Yi = ["css"], Ki = ["css", "less", "scss"], Zi = T(ce), Ye = S(ce), Ke = v(ce), er = G(ce), tr = {
+  [Zi]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...xi] }],
+    default: [{ value: [...Yi] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded CSS language.",
-    deprecated: `Please use \`${Ce}\` or \`${we}\`.`
+    deprecated: `Please use \`${Ye}\` or \`${Ke}\`.`
   },
-  [Ce]: {
+  [Ye]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Block comments that make their subsequent template literals be identified as embedded CSS language."
   },
-  [we]: {
+  [Ke]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Tags that make their subsequent template literals be identified as embedded CSS language."
   },
-  [Bi]: {
+  [er]: {
     category: "Embed",
     type: "choice",
     default: "scss",
     description: "The parser used to parse the embedded CSS language.",
-    choices: Ii.map((e) => ({
-      value: e,
-      description: `Use the "${e}" parser.`
+    choices: Ki.map((t) => ({
+      value: t,
+      description: `Use the "${t}" parser.`
     }))
   }
-}, ji = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, nr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: Oi,
-  language: re,
-  options: qi
-}, Symbol.toStringTag, { value: "Module" })), { line: Fe, group: P, indent: We, softline: ze } = M, Ui = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
+  embedder: Vi,
+  language: ce,
+  options: tr
+}, Symbol.toStringTag, { value: "Module" })), { line: Ze, group: q, indent: et, softline: tt } = A, ir = async (t, e, n, i, { commentOrTag: r, embeddedOverrideOptions: o }) => {
   const s = {
-    ...r,
-    ...a
-  }, { node: l } = n, { createPlaceholder: u, placeholderRegex: E } = L(), d = l.quasis.map(
-    (m, g, { length: y }) => g === y - 1 ? m.value.cooked : m.value.cooked + u(g)
-  ).join(""), c = d.match(/^\s+/)?.[0] ?? "", p = d.match(/\s+$/)?.[0] ?? "", f = d.slice(
-    c.length,
-    -p.length || void 0
-  ), b = k(n, t), $ = await e(f, {
+    ...i,
+    ...o
+  }, { node: l } = n, { createPlaceholder: p, placeholderRegex: f } = N(), d = l.quasis.map(
+    (m, h, { length: _ }) => h === _ - 1 ? m.value.cooked : m.value.cooked + p(h)
+  ).join(""), u = d.match(/^\s+/)?.[0] ?? "", c = d.match(/\s+$/)?.[0] ?? "", y = d.slice(
+    u.length,
+    -c.length || void 0
+  ), b = L(n, e), D = await t(y, {
     ...s,
     parser: s.embeddedEsParser ?? "babel"
-  }), o = S($, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return P([
+  }), a = M(D, f, b);
+  if (s.preserveEmbeddedExteriorWhitespaces?.includes(r))
+    return q([
       "`",
+      u,
+      s.noEmbeddedMultiLineIndentation?.includes(r) ? [q(a)] : et([q(a)]),
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [P(o)] : We([P(o)]),
-      p,
       "`"
     ]);
-  const h = c.length ? Fe : ze, v = p.length ? Fe : ze;
-  return P([
+  const g = u.length ? Ze : tt, E = c.length ? Ze : tt;
+  return q([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, P(o)] : We([h, P(o)]),
-    v,
+    s.noEmbeddedMultiLineIndentation?.includes(r) ? [g, q(a)] : et([g, q(a)]),
+    E,
     "`"
   ]);
-}, oe = "embeddedEs", Ri = [
+}, de = "embeddedEs", rr = [
   "js",
   "jsx",
   "es",
@@ -206,525 +265,525 @@ const _ = "9ff2b366e8ca4c97b9aed1a29b5b94ed", { line: je, group: I, indent: Ue,
   "cjs",
   "pac",
   "javascript"
-], Ci = [
+], sr = [
   "babel",
   "babel-flow",
   "acorn",
   "espree",
   "flow",
   "meriyah"
-], wi = D(oe), Ke = A(oe), Je = T(oe), Fi = O(oe), Wi = {
-  [wi]: {
+], or = T(de), nt = S(de), it = v(de), ar = G(de), lr = {
+  [or]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...Ri] }],
+    default: [{ value: [...rr] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded ECMAScript/JavaScript language.",
-    deprecated: `Please use \`${Ke}\` or \`${Je}\`.`
+    deprecated: `Please use \`${nt}\` or \`${it}\`.`
   },
-  [Ke]: {
+  [nt]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Block comments that make their subsequent template literals be identified as embedded ECMAScript/JavaScript language."
   },
-  [Je]: {
+  [it]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Tags that make their subsequent template literals be identified as embedded ECMAScript/JavaScript language."
   },
-  [Fi]: {
+  [ar]: {
     category: "Embed",
     type: "choice",
     default: "babel",
     description: "The parser used to parse the embedded ECMASCript/JavaScript language.",
-    choices: Ci.map((e) => ({
-      value: e,
-      description: `Use the "${e}" parser.`
+    choices: sr.map((t) => ({
+      value: t,
+      description: `Use the "${t}" parser.`
     }))
   }
-}, zi = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, cr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: Ui,
-  language: oe,
-  options: Wi
-}, Symbol.toStringTag, { value: "Module" })), { line: He, group: B, indent: Xe, softline: Qe } = M, Ki = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
+  embedder: ir,
+  language: de,
+  options: lr
+}, Symbol.toStringTag, { value: "Module" })), { line: rt, group: j, indent: st, softline: ot } = A, dr = async (t, e, n, i, { commentOrTag: r, embeddedOverrideOptions: o }) => {
   const s = {
-    ...r,
-    ...a
-  }, { node: l } = n, { createPlaceholder: u, placeholderRegex: E } = L(), d = l.quasis.map(
-    (m, g, { length: y }) => g === y - 1 ? m.value.cooked : m.value.cooked + u(g)
-  ).join(""), c = d.match(/^\s+/)?.[0] ?? "", p = d.match(/\s+$/)?.[0] ?? "", f = d.slice(
-    c.length,
-    -p.length || void 0
-  ), b = k(n, t), $ = await e(f, {
+    ...i,
+    ...o
+  }, { node: l } = n, { createPlaceholder: p, placeholderRegex: f } = N(), d = l.quasis.map(
+    (m, h, { length: _ }) => h === _ - 1 ? m.value.cooked : m.value.cooked + p(h)
+  ).join(""), u = d.match(/^\s+/)?.[0] ?? "", c = d.match(/\s+$/)?.[0] ?? "", y = d.slice(
+    u.length,
+    -c.length || void 0
+  ), b = L(n, e), D = await t(y, {
     ...s,
     parser: "glsl-parser"
-  }), o = S($, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return B([
+  }), a = M(D, f, b);
+  if (s.preserveEmbeddedExteriorWhitespaces?.includes(r))
+    return j([
       "`",
+      u,
+      s.noEmbeddedMultiLineIndentation?.includes(r) ? [j(a)] : st([j(a)]),
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [B(o)] : Xe([B(o)]),
-      p,
       "`"
     ]);
-  const h = c.length ? He : Qe, v = p.length ? He : Qe;
-  return B([
+  const g = u.length ? rt : ot, E = c.length ? rt : ot;
+  return j([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, B(o)] : Xe([h, B(o)]),
-    v,
+    s.noEmbeddedMultiLineIndentation?.includes(r) ? [g, j(a)] : st([g, j(a)]),
+    E,
     "`"
   ]);
-}, be = "embeddedGlsl", Ji = ["glsl", "shader"], Hi = D(be), Ye = A(be), Ve = T(be), Xi = {
-  [Hi]: {
+}, $e = "embeddedGlsl", ur = ["glsl", "shader"], pr = T($e), at = S($e), lt = v($e), gr = {
+  [pr]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...Ji] }],
+    default: [{ value: [...ur] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded GLSL language. This option requires the `prettier-plugin-glsl` plugin.",
-    deprecated: `Please use \`${Ye}\` or \`${Ve}\`.`
+    deprecated: `Please use \`${at}\` or \`${lt}\`.`
   },
-  [Ye]: {
+  [at]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Block comments that make their subsequent template literals be identified as embedded GLSL language. This option requires the `prettier-plugin-glsl` plugin."
   },
-  [Ve]: {
+  [lt]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Tags that make their subsequent template literals be identified as embedded GLSL language. This option requires the `prettier-plugin-glsl` plugin."
   }
-}, Qi = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, mr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: Ki,
-  language: be,
-  options: Xi
-}, Symbol.toStringTag, { value: "Module" })), { line: Ze, group: q, indent: et, softline: tt } = M, Yi = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
+  embedder: dr,
+  language: $e,
+  options: gr
+}, Symbol.toStringTag, { value: "Module" })), { line: ct, group: R, indent: dt, softline: ut } = A, hr = async (t, e, n, i, { commentOrTag: r, embeddedOverrideOptions: o }) => {
   const s = {
-    ...r,
-    ...a
-  }, { node: l } = n, { createPlaceholder: u, placeholderRegex: E } = L(), d = l.quasis.map(
-    (m, g, { length: y }) => g === y - 1 ? m.value.cooked : m.value.cooked + u(g)
-  ).join(""), c = d.match(/^\s+/)?.[0] ?? "", p = d.match(/\s+$/)?.[0] ?? "", f = d.slice(
-    c.length,
-    -p.length || void 0
-  ), b = k(n, t), $ = await e(f, {
+    ...i,
+    ...o
+  }, { node: l } = n, { createPlaceholder: p, placeholderRegex: f } = N(), d = l.quasis.map(
+    (m, h, { length: _ }) => h === _ - 1 ? m.value.cooked : m.value.cooked + p(h)
+  ).join(""), u = d.match(/^\s+/)?.[0] ?? "", c = d.match(/\s+$/)?.[0] ?? "", y = d.slice(
+    u.length,
+    -c.length || void 0
+  ), b = L(n, e), D = await t(y, {
     ...s,
     parser: "graphql"
-  }), o = S($, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return q([
+  }), a = M(D, f, b);
+  if (s.preserveEmbeddedExteriorWhitespaces?.includes(r))
+    return R([
       "`",
+      u,
+      s.noEmbeddedMultiLineIndentation?.includes(r) ? [R(a)] : dt([R(a)]),
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [q(o)] : et([q(o)]),
-      p,
       "`"
     ]);
-  const h = c.length ? Ze : tt, v = p.length ? Ze : tt;
-  return q([
+  const g = u.length ? ct : ut, E = c.length ? ct : ut;
+  return R([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, q(o)] : et([h, q(o)]),
-    v,
+    s.noEmbeddedMultiLineIndentation?.includes(r) ? [g, R(a)] : dt([g, R(a)]),
+    E,
     "`"
   ]);
-}, fe = "embeddedGraphql", Vi = ["graphql", "gql"], Zi = D(fe), nt = A(fe), it = T(fe), es = {
-  [Zi]: {
+}, Te = "embeddedGraphql", fr = ["graphql", "gql"], Er = T(Te), pt = S(Te), gt = v(Te), br = {
+  [Er]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...Vi] }],
+    default: [{ value: [...fr] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded GraphQL language.",
-    deprecated: `Please use \`${nt}\` or \`${it}\`.`
+    deprecated: `Please use \`${pt}\` or \`${gt}\`.`
   },
-  [nt]: {
+  [pt]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Block comments that make their subsequent template literals be identified as embedded GraphQL language."
   },
-  [it]: {
+  [gt]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Tags that make their subsequent template literals be identified as embedded GraphQL language."
   }
-}, ts = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, _r = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: Yi,
-  language: fe,
-  options: es
-}, Symbol.toStringTag, { value: "Module" })), { line: st, group: j, indent: rt, softline: ot } = M, { mapDoc: ns } = si, is = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
+  embedder: hr,
+  language: Te,
+  options: br
+}, Symbol.toStringTag, { value: "Module" })), { line: mt, group: B, indent: ht, softline: ft } = A, { mapDoc: yr } = bi, Dr = async (t, e, n, i, { commentOrTag: r, embeddedOverrideOptions: o }) => {
   const s = {
-    ...r,
-    ...a
-  }, { node: l } = n, { createPlaceholder: u, placeholderRegex: E } = L(), d = l.quasis.map(
-    (m, g, { length: y }) => g === y - 1 ? m.value.cooked : m.value.cooked + u(g)
-  ).join(""), c = d.match(/^\s+/)?.[0] ?? "", p = d.match(/\s+$/)?.[0] ?? "", f = d.slice(
-    c.length,
-    -p.length || void 0
-  ), b = k(n, t), $ = await e(f, {
+    ...i,
+    ...o
+  }, { node: l } = n, { createPlaceholder: p, placeholderRegex: f } = N(), d = l.quasis.map(
+    (m, h, { length: _ }) => h === _ - 1 ? m.value.cooked : m.value.cooked + p(h)
+  ).join(""), u = d.match(/^\s+/)?.[0] ?? "", c = d.match(/\s+$/)?.[0] ?? "", y = d.slice(
+    u.length,
+    -c.length || void 0
+  ), b = L(n, e), D = await t(y, {
     ...s,
     parser: s.embeddedHtmlParser ?? "html"
-  }), o = ns($, (m) => {
+  }), a = yr(D, (m) => {
     if (typeof m != "string")
       return m;
-    const g = [], y = m.split(E);
-    for (let G = 0; G < y.length; G++) {
-      let N = y[G];
-      if (G % 2 === 0) {
-        if (!N)
+    const h = [], _ = m.split(f);
+    for (let k = 0; k < _.length; k++) {
+      let O = _[k];
+      if (k % 2 === 0) {
+        if (!O)
           continue;
-        N = N.replaceAll(/([\\`]|\${)/g, "\\$1"), s.__embeddedInHtml && (N = N.replaceAll(/<\/(?=script\b)/gi, "<\\/")), g.push(N);
+        O = O.replaceAll(/([\\`]|\${)/g, "\\$1"), s.__embeddedInHtml && (O = O.replaceAll(/<\/(?=script\b)/gi, "<\\/")), h.push(O);
       } else {
-        const x = Number(N);
-        g.push(b[x]);
+        const ki = Number(O);
+        h.push(b[ki]);
       }
     }
-    return g;
+    return h;
   });
   if (s.htmlWhitespaceSensitivity === "strict" || // TODO: is css mode should be included here?
-  s.htmlWhitespaceSensitivity === "css" || s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return j([
+  s.htmlWhitespaceSensitivity === "css" || s.preserveEmbeddedExteriorWhitespaces?.includes(r))
+    return B([
       "`",
+      u,
+      s.noEmbeddedMultiLineIndentation?.includes(r) ? [B(a)] : ht([B(a)]),
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [j(o)] : rt([j(o)]),
-      p,
       "`"
     ]);
-  const h = c.length ? st : ot, v = p.length ? st : ot;
-  return j([
+  const g = u.length ? mt : ft, E = c.length ? mt : ft;
+  return B([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, j(o)] : rt([h, j(o)]),
-    v,
+    s.noEmbeddedMultiLineIndentation?.includes(r) ? [g, B(a)] : ht([g, B(a)]),
+    E,
     "`"
   ]);
-}, ae = "embeddedHtml", ss = ["html", "xhtml"], rs = ["html", "vue", "angular", "lwc"], os = D(ae), at = A(ae), dt = T(ae), as = O(ae), ds = {
-  [os]: {
+}, ue = "embeddedHtml", $r = ["html", "xhtml"], Tr = ["html", "vue", "angular", "lwc"], vr = T(ue), Et = S(ue), bt = v(ue), Ar = G(ue), Sr = {
+  [vr]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...ss] }],
+    default: [{ value: [...$r] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded HTML language.",
-    deprecated: `Please use \`${at}\` or \`${dt}\`.`
+    deprecated: `Please use \`${Et}\` or \`${bt}\`.`
   },
-  [at]: {
+  [Et]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Block comments that make their subsequent template literals be identified as embedded HTML language."
   },
-  [dt]: {
+  [bt]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Tags that make their subsequent template literals be identified as embedded HTML language."
   },
-  [as]: {
+  [Ar]: {
     category: "Embed",
     type: "choice",
     default: "html",
     description: "The parser used to parse the embedded HTML language.",
-    choices: rs.map((e) => ({
-      value: e,
-      description: `Use the "${e}" parser.`
+    choices: Tr.map((t) => ({
+      value: t,
+      description: `Use the "${t}" parser.`
     }))
   }
-}, ls = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, Mr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: is,
-  language: ae,
-  options: ds
-}, Symbol.toStringTag, { value: "Module" })), { line: lt, group: U, indent: ct, softline: ut } = M, cs = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
+  embedder: Dr,
+  language: ue,
+  options: Sr
+}, Symbol.toStringTag, { value: "Module" })), { line: _t, group: w, indent: yt, softline: Dt } = A, Lr = async (t, e, n, i, { commentOrTag: r, embeddedOverrideOptions: o }) => {
   const s = {
-    ...r,
-    ...a
-  }, { node: l } = n, { createPlaceholder: u, placeholderRegex: E } = L(), d = l.quasis.map(
-    (m, g, { length: y }) => g === y - 1 ? m.value.cooked : m.value.cooked + u(g)
-  ).join(""), c = d.match(/^\s+/)?.[0] ?? "", p = d.match(/\s+$/)?.[0] ?? "", f = d.slice(
-    c.length,
-    -p.length || void 0
-  ), b = k(n, t), $ = await e(f, {
+    ...i,
+    ...o
+  }, { node: l } = n, { createPlaceholder: p, placeholderRegex: f } = N(), d = l.quasis.map(
+    (m, h, { length: _ }) => h === _ - 1 ? m.value.cooked : m.value.cooked + p(h)
+  ).join(""), u = d.match(/^\s+/)?.[0] ?? "", c = d.match(/\s+$/)?.[0] ?? "", y = d.slice(
+    u.length,
+    -c.length || void 0
+  ), b = L(n, e), D = await t(y, {
     ...s,
     parser: "ini"
-  }), o = S($, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return U([
+  }), a = M(D, f, b);
+  if (s.preserveEmbeddedExteriorWhitespaces?.includes(r))
+    return w([
       "`",
+      u,
+      s.noEmbeddedMultiLineIndentation?.includes(r) ? [w(a)] : yt([w(a)]),
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [U(o)] : ct([U(o)]),
-      p,
       "`"
     ]);
-  const h = c.length ? lt : ut, v = p.length ? lt : ut;
-  return U([
+  const g = u.length ? _t : Dt, E = c.length ? _t : Dt;
+  return w([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, U(o)] : ct([h, U(o)]),
-    v,
+    s.noEmbeddedMultiLineIndentation?.includes(r) ? [g, w(a)] : yt([g, w(a)]),
+    E,
     "`"
   ]);
-}, ye = "embeddedIni", us = ["ini", "cfg", "pro"], ps = D(ye), pt = A(ye), gt = T(ye), gs = {
-  [ps]: {
+}, ve = "embeddedIni", Nr = ["ini", "cfg", "pro"], kr = T(ve), $t = S(ve), Tt = v(ve), Or = {
+  [kr]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...us] }],
+    default: [{ value: [...Nr] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded INI language. This option requires the `prettier-plugin-ini` plugin.",
-    deprecated: `Please use \`${pt}\` or \`${gt}\`.`
+    deprecated: `Please use \`${$t}\` or \`${Tt}\`.`
   },
-  [pt]: {
+  [$t]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Block comments that make their subsequent template literals be identified as embedded INI language. This option requires the `prettier-plugin-ini` plugin."
   },
-  [gt]: {
+  [Tt]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Tags that make their subsequent template literals be identified as embedded INI language. This option requires the `prettier-plugin-ini` plugin."
   }
-}, ms = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, Gr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: cs,
-  language: ye,
-  options: gs
-}, Symbol.toStringTag, { value: "Module" })), { group: R, line: mt, softline: ht, indent: Et } = M, hs = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
+  embedder: Lr,
+  language: ve,
+  options: Or
+}, Symbol.toStringTag, { value: "Module" })), { group: U, line: vt, softline: At, indent: St } = A, Ir = async (t, e, n, i, { commentOrTag: r, embeddedOverrideOptions: o }) => {
   const s = {
-    ...r,
-    ...a
-  }, { node: l } = n, { createPlaceholder: u, placeholderRegex: E } = L(), d = l.quasis.map(
-    (m, g, { length: y }) => g === y - 1 ? m.value.cooked : m.value.cooked + u(g)
-  ).join(""), c = d.match(/^\s+/)?.[0] ?? "", p = d.match(/\s+$/)?.[0] ?? "", f = d.slice(
-    c.length,
-    -p.length || void 0
-  ), b = k(n, t), $ = await e(f, {
+    ...i,
+    ...o
+  }, { node: l } = n, { createPlaceholder: p, placeholderRegex: f } = N(), d = l.quasis.map(
+    (m, h, { length: _ }) => h === _ - 1 ? m.value.cooked : m.value.cooked + p(h)
+  ).join(""), u = d.match(/^\s+/)?.[0] ?? "", c = d.match(/\s+$/)?.[0] ?? "", y = d.slice(
+    u.length,
+    -c.length || void 0
+  ), b = L(n, e), D = await t(y, {
     ...s,
     parser: "java"
-  }), o = S(
-    $,
-    E,
+  }), a = M(
+    D,
+    f,
     b,
-    !0
+    "hardline"
   );
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return R([
+  if (s.preserveEmbeddedExteriorWhitespaces?.includes(r))
+    return U([
       "`",
+      u,
+      s.noEmbeddedMultiLineIndentation?.includes(r) ? [U(a)] : St([U(a)]),
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [R(o)] : Et([R(o)]),
-      p,
       "`"
     ]);
-  const h = c.length ? mt : ht, v = p.length ? mt : ht;
-  return R([
+  const g = u.length ? vt : At, E = c.length ? vt : At;
+  return U([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, R(o)] : Et([h, R(o)]),
-    v,
+    s.noEmbeddedMultiLineIndentation?.includes(r) ? [g, U(a)] : St([g, U(a)]),
+    E,
     "`"
   ]);
-}, _e = "embeddedJava", Es = ["java"], bs = D(_e), bt = A(_e), ft = T(_e), fs = {
-  [bs]: {
+}, Ae = "embeddedJava", xr = ["java"], Pr = T(Ae), Mt = S(Ae), Lt = v(Ae), qr = {
+  [Pr]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...Es] }],
+    default: [{ value: [...xr] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded Java language. This option requires the `prettier-plugin-java` plugin.",
-    deprecated: `Please use \`${bt}\` or \`${ft}\`.`
+    deprecated: `Please use \`${Mt}\` or \`${Lt}\`.`
   },
-  [bt]: {
+  [Mt]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Block comments that make their subsequent template literals be identified as embedded Java language. This option requires the `prettier-plugin-java` plugin."
   },
-  [ft]: {
+  [Lt]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Tags that make their subsequent template literals be identified as embedded Java language. This option requires the `prettier-plugin-java` plugin."
   }
-}, ys = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, jr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: hs,
-  language: _e,
-  options: fs
-}, Symbol.toStringTag, { value: "Module" })), { line: yt, group: C, indent: _t, softline: $t } = M, _s = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
+  embedder: Ir,
+  language: Ae,
+  options: qr
+}, Symbol.toStringTag, { value: "Module" })), { line: Nt, group: C, indent: kt, softline: Ot } = A, Rr = async (t, e, n, i, { commentOrTag: r, embeddedOverrideOptions: o }) => {
   const s = {
-    ...r,
-    ...a
-  }, { node: l } = n, { createPlaceholder: u, placeholderRegex: E } = $s(), d = l.quasis.map(
-    (m, g, { length: y }) => g === y - 1 ? m.value.cooked : m.value.cooked + u(g)
-  ).join(""), c = d.match(/^\s+/)?.[0] ?? "", p = d.match(/\s+$/)?.[0] ?? "", f = d.slice(
-    c.length,
-    -p.length || void 0
-  ), b = k(n, t), $ = await e(f, {
+    ...i,
+    ...o
+  }, { node: l } = n, { createPlaceholder: p, placeholderRegex: f } = Br(), d = l.quasis.map(
+    (m, h, { length: _ }) => h === _ - 1 ? m.value.cooked : m.value.cooked + p(h)
+  ).join(""), u = d.match(/^\s+/)?.[0] ?? "", c = d.match(/\s+$/)?.[0] ?? "", y = d.slice(
+    u.length,
+    -c.length || void 0
+  ), b = L(n, e), D = await t(y, {
     ...s,
     parser: s.embeddedJsonParser ?? "json"
-  }), o = S($, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
+  }), a = M(D, f, b);
+  if (s.preserveEmbeddedExteriorWhitespaces?.includes(r))
     return C([
       "`",
+      u,
+      s.noEmbeddedMultiLineIndentation?.includes(r) ? [C(a)] : kt([C(a)]),
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [C(o)] : _t([C(o)]),
-      p,
       "`"
     ]);
-  const h = c.length ? yt : $t, v = p.length ? yt : $t;
+  const g = u.length ? Nt : Ot, E = c.length ? Nt : Ot;
   return C([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, C(o)] : _t([h, C(o)]),
-    v,
+    s.noEmbeddedMultiLineIndentation?.includes(r) ? [g, C(a)] : kt([g, C(a)]),
+    E,
     "`"
   ]);
 };
-function $s() {
-  const e = he(), t = he(), n = (i) => `'0${e}${i}${t}'`, r = new RegExp(
-    `["']?0${e}(\\d+)${t}['"]?`,
+function Br() {
+  const t = ye(), e = ye(), n = (r) => `'0${t}${r}${e}'`, i = new RegExp(
+    `["']?0${t}(\\d+)${e}['"]?`,
     "ig"
   );
   return {
     createPlaceholder: n,
-    placeholderRegex: r
+    placeholderRegex: i
   };
 }
-const de = "embeddedJson", vs = ["json", "jsonl"], Ds = ["json", "json5", "jsonc", "json-stringify"], Ts = D(de), vt = A(de), Dt = T(de), Ms = O(de), As = {
-  [Ts]: {
+const pe = "embeddedJson", wr = ["json", "jsonl"], Ur = ["json", "json5", "jsonc", "json-stringify"], Cr = T(pe), Gt = S(pe), It = v(pe), Wr = G(pe), Fr = {
+  [Cr]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...vs] }],
+    default: [{ value: [...wr] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded JSON language.",
-    deprecated: `Please use \`${vt}\` or \`${Dt}\`.`
+    deprecated: `Please use \`${Gt}\` or \`${It}\`.`
   },
-  [vt]: {
+  [Gt]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Block comments that make their subsequent template literals be identified as embedded JSON language."
   },
-  [Dt]: {
+  [It]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Tags that make their subsequent template literals be identified as embedded JSON language."
   },
-  [Ms]: {
+  [Wr]: {
     category: "Embed",
     type: "choice",
     default: "json",
     description: "The parser used to parse the embedded JSON language.",
-    choices: Ds.map((e) => ({
-      value: e,
-      description: `Use the "${e}" parser.`
+    choices: Ur.map((t) => ({
+      value: t,
+      description: `Use the "${t}" parser.`
     }))
   }
-}, Ss = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, zr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: _s,
-  language: de,
-  options: As
-}, Symbol.toStringTag, { value: "Module" })), { line: Tt, group: w, indent: Mt, softline: At } = M, ks = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
+  embedder: Rr,
+  language: pe,
+  options: Fr
+}, Symbol.toStringTag, { value: "Module" })), { line: xt, group: W, indent: Pt, softline: qt } = A, Jr = async (t, e, n, i, { commentOrTag: r, embeddedOverrideOptions: o }) => {
   const s = {
-    ...r,
-    ...a
-  }, { node: l } = n, { createPlaceholder: u, placeholderRegex: E } = L("$p"), d = l.quasis.map(
-    (m, g, { length: y }) => g === y - 1 ? m.value.cooked : m.value.cooked + u(g)
-  ).join(""), c = d.match(/^\s+/)?.[0] ?? "", p = d.match(/\s+$/)?.[0] ?? "", f = d.slice(
-    c.length,
-    -p.length || void 0
-  ), b = k(n, t), $ = await e(f, {
+    ...i,
+    ...o
+  }, { node: l } = n, { createPlaceholder: p, placeholderRegex: f } = N("$p"), d = l.quasis.map(
+    (m, h, { length: _ }) => h === _ - 1 ? m.value.cooked : m.value.cooked + p(h)
+  ).join(""), u = d.match(/^\s+/)?.[0] ?? "", c = d.match(/\s+$/)?.[0] ?? "", y = d.slice(
+    u.length,
+    -c.length || void 0
+  ), b = L(n, e), D = await t(y, {
     ...s,
     parser: "JSONata"
-  }), o = S($, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return w([
+  }), a = M(D, f, b);
+  if (s.preserveEmbeddedExteriorWhitespaces?.includes(r))
+    return W([
       "`",
+      u,
+      s.noEmbeddedMultiLineIndentation?.includes(r) ? [W(a)] : Pt([W(a)]),
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [w(o)] : Mt([w(o)]),
-      p,
       "`"
     ]);
-  const h = c.length ? Tt : At, v = p.length ? Tt : At;
-  return w([
+  const g = u.length ? xt : qt, E = c.length ? xt : qt;
+  return W([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, w(o)] : Mt([h, w(o)]),
-    v,
+    s.noEmbeddedMultiLineIndentation?.includes(r) ? [g, W(a)] : Pt([g, W(a)]),
+    E,
     "`"
   ]);
-}, $e = "embeddedJsonata", Ls = ["jsonata"], Gs = D($e), St = A($e), kt = T($e), Ns = {
-  [Gs]: {
+}, Se = "embeddedJsonata", Xr = ["jsonata"], Hr = T(Se), jt = S(Se), Rt = v(Se), Qr = {
+  [Hr]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...Ls] }],
+    default: [{ value: [...Xr] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded JSONata language. This option requires the `@stedi/prettier-plugin-jsonata` plugin.",
-    deprecated: `Please use \`${St}\` or \`${kt}\`.`
+    deprecated: `Please use \`${jt}\` or \`${Rt}\`.`
   },
-  [St]: {
+  [jt]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Block comments that make their subsequent template literals be identified as embedded JSONata language. This option requires the `@stedi/prettier-plugin-jsonata` plugin."
   },
-  [kt]: {
+  [Rt]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Tags that make their subsequent template literals be identified as embedded JSONata language. This option requires the `@stedi/prettier-plugin-jsonata` plugin."
   }
-}, Os = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, Vr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: ks,
-  language: $e,
-  options: Ns
-}, Symbol.toStringTag, { value: "Module" })), { line: Lt, group: F, indent: Gt, softline: Nt } = M, xs = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
+  embedder: Jr,
+  language: Se,
+  options: Qr
+}, Symbol.toStringTag, { value: "Module" })), { line: Bt, group: F, indent: wt, softline: Ut } = A, Yr = async (t, e, n, i, { commentOrTag: r, embeddedOverrideOptions: o }) => {
   const s = {
-    ...r,
-    ...a
-  }, { node: l } = n, { createPlaceholder: u, placeholderRegex: E } = L(), d = l.quasis.map(
-    (m, g, { length: y }) => g === y - 1 ? m.value.cooked : m.value.cooked + u(g)
-  ).join(""), c = d.match(/^\s+/)?.[0] ?? "", p = d.match(/\s+$/)?.[0] ?? "", f = d.slice(
-    c.length,
-    -p.length || void 0
-  ), b = k(n, t), $ = await e(f, {
+    ...i,
+    ...o
+  }, { node: l } = n, { createPlaceholder: p, placeholderRegex: f } = N(), d = l.quasis.map(
+    (m, h, { length: _ }) => h === _ - 1 ? m.value.cooked : m.value.cooked + p(h)
+  ).join(""), u = d.match(/^\s+/)?.[0] ?? "", c = d.match(/\s+$/)?.[0] ?? "", y = d.slice(
+    u.length,
+    -c.length || void 0
+  ), b = L(n, e), D = await t(y, {
     ...s,
     parser: "latex-parser"
-  }), o = S($, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
+  }), a = M(D, f, b);
+  if (s.preserveEmbeddedExteriorWhitespaces?.includes(r))
     return F([
       "`",
+      u,
+      s.noEmbeddedMultiLineIndentation?.includes(r) ? [F(a)] : wt([F(a)]),
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [F(o)] : Gt([F(o)]),
-      p,
       "`"
     ]);
-  const h = c.length ? Lt : Nt, v = p.length ? Lt : Nt;
+  const g = u.length ? Bt : Ut, E = c.length ? Bt : Ut;
   return F([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, F(o)] : Gt([h, F(o)]),
-    v,
+    s.noEmbeddedMultiLineIndentation?.includes(r) ? [g, F(a)] : wt([g, F(a)]),
+    E,
     "`"
   ]);
-}, ve = "embeddedLatex", Is = [
+}, Me = "embeddedLatex", Kr = [
   "latex",
   "tex",
   "aux",
@@ -733,120 +792,144 @@ const de = "embeddedJson", vs = ["json", "jsonl"], Ds = ["json", "json5", "jsonc
   "bib",
   "toc",
   "sty"
-], Ps = D(ve), Ot = A(ve), xt = T(ve), Bs = {
-  [Ps]: {
+], Zr = T(Me), Ct = S(Me), Wt = v(Me), es = {
+  [Zr]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...Is] }],
+    default: [{ value: [...Kr] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded LaTeX language. This option requires the `prettier-plugin-latex` plugin.",
-    deprecated: `Please use \`${Ot}\` or \`${xt}\`.`
+    deprecated: `Please use \`${Ct}\` or \`${Wt}\`.`
   },
-  [Ot]: {
+  [Ct]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Block comments that make their subsequent template literals be identified as embedded LaTeX language. This option requires the `prettier-plugin-latex` plugin."
   },
-  [xt]: {
+  [Wt]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Tags that make their subsequent template literals be identified as embedded LaTeX language. This option requires the `prettier-plugin-latex` plugin."
   }
-}, qs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, ts = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: xs,
-  language: ve,
-  options: Bs
+  embedder: Yr,
+  language: Me,
+  options: es
 }, Symbol.toStringTag, { value: "Module" }));
-function It(e, t) {
-  var n = Object.keys(e);
+function Ft(t, e) {
+  var n = Object.keys(t);
   if (Object.getOwnPropertySymbols) {
-    var r = Object.getOwnPropertySymbols(e);
-    t && (r = r.filter(function(i) {
-      return Object.getOwnPropertyDescriptor(e, i).enumerable;
-    })), n.push.apply(n, r);
+    var i = Object.getOwnPropertySymbols(t);
+    e && (i = i.filter(function(r) {
+      return Object.getOwnPropertyDescriptor(t, r).enumerable;
+    })), n.push.apply(n, i);
   }
   return n;
 }
-function Pt(e) {
-  for (var t = 1; t < arguments.length; t++) {
-    var n = arguments[t] != null ? arguments[t] : {};
-    t % 2 ? It(Object(n), !0).forEach(function(r) {
-      js(e, r, n[r]);
-    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(n)) : It(Object(n)).forEach(function(r) {
-      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(n, r));
+function zt(t) {
+  for (var e = 1; e < arguments.length; e++) {
+    var n = arguments[e] != null ? arguments[e] : {};
+    e % 2 ? Ft(Object(n), !0).forEach(function(i) {
+      ns(t, i, n[i]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(t, Object.getOwnPropertyDescriptors(n)) : Ft(Object(n)).forEach(function(i) {
+      Object.defineProperty(t, i, Object.getOwnPropertyDescriptor(n, i));
     });
   }
-  return e;
+  return t;
 }
-function js(e, t, n) {
-  return t = Us(t), t in e ? Object.defineProperty(e, t, { value: n, enumerable: !0, configurable: !0, writable: !0 }) : e[t] = n, e;
+function ns(t, e, n) {
+  return e = is(e), e in t ? Object.defineProperty(t, e, { value: n, enumerable: !0, configurable: !0, writable: !0 }) : t[e] = n, t;
 }
-function Us(e) {
-  var t = Rs(e, "string");
-  return typeof t == "symbol" ? t : String(t);
+function is(t) {
+  var e = rs(t, "string");
+  return typeof e == "symbol" ? e : String(e);
 }
-function Rs(e, t) {
-  if (typeof e != "object" || e === null)
-    return e;
-  var n = e[Symbol.toPrimitive];
+function rs(t, e) {
+  if (typeof t != "object" || t === null) return t;
+  var n = t[Symbol.toPrimitive];
   if (n !== void 0) {
-    var r = n.call(e, t || "default");
-    if (typeof r != "object")
-      return r;
+    var i = n.call(t, e);
+    if (typeof i != "object") return i;
     throw new TypeError("@@toPrimitive must return a primitive value.");
   }
-  return (t === "string" ? String : Number)(e);
-}
-const ri = oi({});
-function oi(e) {
-  return t.withOptions = (n) => oi(Pt(Pt({}, e), n)), t;
-  function t(n, ...r) {
-    const i = typeof n == "string" ? [n] : n.raw, {
-      escapeSpecialCharacters: a = Array.isArray(n)
-    } = e;
-    let s = "";
-    for (let E = 0; E < i.length; E++) {
-      let d = i[E];
-      a && (d = d.replace(/\\\n[ \t]*/g, "").replace(/\\`/g, "`").replace(/\\\$/g, "$").replace(/\\{/g, "{")), s += d, E < r.length && (s += r[E]);
+  return (e === "string" ? String : Number)(t);
+}
+const _i = yi({});
+function yi(t) {
+  return e.withOptions = (n) => yi(zt(zt({}, t), n)), e;
+  function e(n, ...i) {
+    const r = typeof n == "string" ? [n] : n.raw, {
+      alignValues: o = !1,
+      escapeSpecialCharacters: s = Array.isArray(n),
+      trimWhitespace: l = !0
+    } = t;
+    let p = "";
+    for (let u = 0; u < r.length; u++) {
+      let c = r[u];
+      if (s && (c = c.replace(/\\\n[ \t]*/g, "").replace(/\\`/g, "`").replace(/\\\$/g, "$").replace(/\\\{/g, "{")), p += c, u < i.length) {
+        const y = o ? ss(i[u], p) : i[u];
+        p += y;
+      }
     }
-    const l = s.split(`
+    const f = p.split(`
 `);
-    let u = null;
-    for (const E of l) {
-      const d = E.match(/^(\s+)\S+/);
-      if (d) {
-        const c = d[1].length;
-        u ? u = Math.min(u, c) : u = c;
+    let d = null;
+    for (const u of f) {
+      const c = u.match(/^(\s+)\S+/);
+      if (c) {
+        const y = c[1].length;
+        d ? d = Math.min(d, y) : d = y;
       }
     }
-    if (u !== null) {
-      const E = u;
-      s = l.map((d) => d[0] === " " || d[0] === "	" ? d.slice(E) : d).join(`
+    if (d !== null) {
+      const u = d;
+      p = f.map((c) => c[0] === " " || c[0] === "	" ? c.slice(u) : c).join(`
 `);
     }
-    return s.trim().replace(/\\n/g, `
-`);
+    return l && (p = p.trim()), s && (p = p.replace(/\\n/g, `
+`)), typeof Bun < "u" && (p = p.replace(
+      // Matches e.g. \\u{1f60a} or \\u5F1F
+      /\\u(?:\{([\da-fA-F]{1,6})\}|([\da-fA-F]{4}))/g,
+      (u, c, y) => {
+        var b;
+        const D = (b = c ?? y) !== null && b !== void 0 ? b : "";
+        return String.fromCodePoint(parseInt(D, 16));
+      }
+    )), p;
   }
 }
-const { line: Bt, group: W, indent: qt, softline: jt } = M, Cs = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
+function ss(t, e) {
+  if (typeof t != "string" || !t.includes(`
+`))
+    return t;
+  const i = e.slice(e.lastIndexOf(`
+`) + 1).match(/^(\s+)/);
+  if (i) {
+    const r = i[1];
+    return t.replace(/\n/g, `
+${r}`);
+  }
+  return t;
+}
+const { line: Jt, group: se, indent: Xt, softline: je, dedentToRoot: Ht, literalline: os } = A, as = async (t, e, n, i, { commentOrTag: r, embeddedOverrideOptions: o }) => {
   const s = {
-    ...r,
-    ...a
-  }, { node: l } = n, { createPlaceholder: u, placeholderRegex: E } = L(), d = l.quasis.map(
-    (m, g, { length: y }) => g === y - 1 ? m.value.cooked : m.value.cooked + u(g)
-  ).join(""), c = d.match(/^\s+/)?.[0] ?? "", p = d.match(/\s+$/)?.[0] ?? "", f = d.slice(
-    c.length,
-    -p.length || void 0
-  ), b = k(n, t), $ = await e(
+    ...i,
+    ...o
+  }, { node: l } = n, { createPlaceholder: p, placeholderRegex: f } = N(), d = l.quasis.map(
+    (m, h, { length: _ }) => h === _ - 1 ? m.value.cooked : m.value.cooked + p(h)
+  ).join(""), u = d.match(/^\s+/)?.[0] ?? "", c = d.match(/\s+$/)?.[0] ?? "", y = d.slice(
+    u.length,
+    -c.length || void 0
+  ), b = L(n, e), D = await t(
     // use `dedent` to fix unstable embedded markdown indentation with the `useTabs` option
     // https://github.com/Sec-ant/prettier-plugin-embed/pull/91#issuecomment-1963760555
     // https://github.com/prettier/prettier/blob/1079517b32e5bb145afa7acba448af51f8a7b6e6/src/language-js/embed/markdown.js#L15-L19
-    ri(f),
+    _i(y),
     {
       ...s,
       parser: s.embeddedMarkdownParser ?? "markdown",
@@ -854,857 +937,862 @@ const { line: Bt, group: W, indent: qt, softline: jt } = M, Cs = async (e, t, n,
       // https://github.com/prettier/prettier/blob/1079517b32e5bb145afa7acba448af51f8a7b6e6/src/language-markdown/embed.js#L15
       __inJsTemplate: !0
     }
-  ), o = S(
-    $,
-    E,
+  ), a = M(
+    D,
+    f,
     b,
-    !0
+    "hardline"
   );
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return W([
+  if (s.preserveEmbeddedExteriorWhitespaces?.includes(r))
+    return se([
       "`",
+      u,
+      s.noEmbeddedMultiLineIndentation?.includes(r) ? Ht(se(a)) : Xt([se(a)]),
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [W(o)] : qt([W(o)]),
-      p,
       "`"
     ]);
-  const h = c.length ? Bt : jt, v = p.length ? Bt : jt;
-  return W([
+  const g = u.length ? Jt : je, E = c.length ? Jt : je;
+  return s.noEmbeddedMultiLineIndentation?.includes(r) ? ["`", os, Ht(a), je, "`"] : se([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, W(o)] : qt([h, W(o)]),
-    v,
+    Xt([g, se(a)]),
+    E,
     "`"
   ]);
-}, le = "embeddedMarkdown", ws = ["md", "markdown"], Fs = ["markdown", "mdx", "remark"], Ws = D(le), Ut = A(le), Rt = T(le), zs = O(le), Ks = {
-  [Ws]: {
+}, ge = "embeddedMarkdown", ls = ["md", "markdown"], cs = ["markdown", "mdx", "remark"], ds = T(ge), Qt = S(ge), Vt = v(ge), us = G(ge), ps = {
+  [ds]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...ws] }],
+    default: [{ value: [...ls] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded Markdown language.",
-    deprecated: `Please use \`${Ut}\` or \`${Rt}\`.`
+    deprecated: `Please use \`${Qt}\` or \`${Vt}\`.`
   },
-  [Ut]: {
+  [Qt]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Block comments that make their subsequent template literals be identified as embedded Markdown language."
   },
-  [Rt]: {
+  [Vt]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Tags that make their subsequent template literals be identified as embedded Markdown language."
   },
-  [zs]: {
+  [us]: {
     category: "Embed",
     type: "choice",
     default: "markdown",
     description: "The parser used to parse the embedded Markdown language.",
-    choices: Fs.map((e) => ({
-      value: e,
-      description: `Use the "${e}" parser.`
+    choices: cs.map((t) => ({
+      value: t,
+      description: `Use the "${t}" parser.`
     }))
   }
-}, Js = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, gs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: Cs,
-  language: le,
-  options: Ks
-}, Symbol.toStringTag, { value: "Module" })), { line: Ct, group: z, indent: wt, softline: Ft } = M, Hs = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
+  embedder: as,
+  language: ge,
+  options: ps
+}, Symbol.toStringTag, { value: "Module" })), { line: Yt, group: z, indent: Kt, softline: Zt } = A, ms = async (t, e, n, i, { commentOrTag: r, embeddedOverrideOptions: o }) => {
   const s = {
-    ...r,
-    ...a
-  }, { node: l } = n, { createPlaceholder: u, placeholderRegex: E } = L(), d = l.quasis.map(
-    (m, g, { length: y }) => g === y - 1 ? m.value.cooked : m.value.cooked + u(g)
-  ).join(""), c = d.match(/^\s+/)?.[0] ?? "", p = d.match(/\s+$/)?.[0] ?? "", f = d.slice(
-    c.length,
-    -p.length || void 0
-  ), b = k(n, t), $ = await e(f, {
+    ...i,
+    ...o
+  }, { node: l } = n, { createPlaceholder: p, placeholderRegex: f } = N(), d = l.quasis.map(
+    (m, h, { length: _ }) => h === _ - 1 ? m.value.cooked : m.value.cooked + p(h)
+  ).join(""), u = d.match(/^\s+/)?.[0] ?? "", c = d.match(/\s+$/)?.[0] ?? "", y = d.slice(
+    u.length,
+    -c.length || void 0
+  ), b = L(n, e), D = await t(y, {
     ...s,
     parser: "nginx"
-  }), o = S($, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
+  }), a = M(D, f, b);
+  if (s.preserveEmbeddedExteriorWhitespaces?.includes(r))
     return z([
       "`",
+      u,
+      s.noEmbeddedMultiLineIndentation?.includes(r) ? [z(a)] : Kt([z(a)]),
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [z(o)] : wt([z(o)]),
-      p,
       "`"
     ]);
-  const h = c.length ? Ct : Ft, v = p.length ? Ct : Ft;
+  const g = u.length ? Yt : Zt, E = c.length ? Yt : Zt;
   return z([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, z(o)] : wt([h, z(o)]),
-    v,
+    s.noEmbeddedMultiLineIndentation?.includes(r) ? [g, z(a)] : Kt([g, z(a)]),
+    E,
     "`"
   ]);
-}, De = "embeddedNginx", Xs = ["nginx"], Qs = D(De), Wt = A(De), zt = T(De), Ys = {
-  [Qs]: {
+}, Le = "embeddedNginx", hs = ["nginx"], fs = T(Le), en = S(Le), tn = v(Le), Es = {
+  [fs]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...Xs] }],
+    default: [{ value: [...hs] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded NGINX language. This option requires the `prettier-plugin-nginx` plugin.",
-    deprecated: `Please use \`${Wt}\` or \`${zt}\`.`
+    deprecated: `Please use \`${en}\` or \`${tn}\`.`
   },
-  [Wt]: {
+  [en]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Block comments that make their subsequent template literals be identified as embedded NGINX language. This option requires the `prettier-plugin-nginx` plugin."
   },
-  [zt]: {
+  [tn]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Tags that make their subsequent template literals be identified as embedded NGINX language. This option requires the `prettier-plugin-nginx` plugin."
   }
-}, Vs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, bs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: Hs,
-  language: De,
-  options: Ys
-}, Symbol.toStringTag, { value: "Module" })), ce = "embeddedNoop", Zs = D(ce), Kt = A(ce), Jt = T(ce), er = {
-  [Zs]: {
+  embedder: ms,
+  language: Le,
+  options: Es
+}, Symbol.toStringTag, { value: "Module" })), me = "embeddedNoop", _s = T(me), nn = S(me), rn = v(me), ys = {
+  [_s]: {
     category: "Embed",
     type: "string",
     array: !0,
     default: [{ value: [] }],
     description: "Tag or comment identifiers that prevent their subsequent template literals from being identified as embedded languages and thus from being formatted.",
-    deprecated: `Please use \`${Kt}\` or \`${Jt}\`.`
+    deprecated: `Please use \`${nn}\` or \`${rn}\`.`
   },
-  [Kt]: {
+  [nn]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Block comments that prevent their subsequent template literals from being identified as embedded languages and thus from being formatted."
   },
-  [Jt]: {
+  [rn]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Tags that prevent their subsequent template literals from being identified as embedded languages and thus from being formatted."
   }
-}, tr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, Ds = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  language: ce,
-  options: er
-}, Symbol.toStringTag, { value: "Module" })), { line: Ht, group: K, indent: Xt, softline: Qt } = M, nr = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
+  language: me,
+  options: ys
+}, Symbol.toStringTag, { value: "Module" })), { line: sn, group: J, indent: on, softline: an } = A, $s = async (t, e, n, i, { commentOrTag: r, embeddedOverrideOptions: o }) => {
   const s = {
-    ...r,
-    ...a
-  }, { node: l } = n, { createPlaceholder: u, placeholderRegex: E } = L(), d = l.quasis.map(
-    (m, g, { length: y }) => g === y - 1 ? m.value.cooked : m.value.cooked + u(g)
-  ).join(""), c = d.match(/^\s+/)?.[0] ?? "", p = d.match(/\s+$/)?.[0] ?? "", f = d.slice(
-    c.length,
-    -p.length || void 0
-  ), b = k(n, t), $ = await e(f, {
+    ...i,
+    ...o
+  }, { node: l } = n, { createPlaceholder: p, placeholderRegex: f } = N(), d = l.quasis.map(
+    (m, h, { length: _ }) => h === _ - 1 ? m.value.cooked : m.value.cooked + p(h)
+  ).join(""), u = d.match(/^\s+/)?.[0] ?? "", c = d.match(/\s+$/)?.[0] ?? "", y = d.slice(
+    u.length,
+    -c.length || void 0
+  ), b = L(n, e), D = await t(y, {
     ...s,
     parser: "pegjs-parser"
-  }), o = S($, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return K([
+  }), a = M(D, f, b);
+  if (s.preserveEmbeddedExteriorWhitespaces?.includes(r))
+    return J([
       "`",
+      u,
+      s.noEmbeddedMultiLineIndentation?.includes(r) ? [J(a)] : on([J(a)]),
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [K(o)] : Xt([K(o)]),
-      p,
       "`"
     ]);
-  const h = c.length ? Ht : Qt, v = p.length ? Ht : Qt;
-  return K([
+  const g = u.length ? sn : an, E = c.length ? sn : an;
+  return J([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, K(o)] : Xt([h, K(o)]),
-    v,
+    s.noEmbeddedMultiLineIndentation?.includes(r) ? [g, J(a)] : on([g, J(a)]),
+    E,
     "`"
   ]);
-}, Te = "embeddedPegjs", ir = ["pegjs", "peggy", "peg"], sr = D(Te), Yt = A(Te), Vt = T(Te), rr = {
-  [sr]: {
+}, Ne = "embeddedPegjs", Ts = ["pegjs", "peggy", "peg"], vs = T(Ne), ln = S(Ne), cn = v(Ne), As = {
+  [vs]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...ir] }],
+    default: [{ value: [...Ts] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded Pegjs language. This option requires the `prettier-plugin-pegjs` plugin.",
-    deprecated: `Please use \`${Yt}\` or \`${Vt}\`.`
+    deprecated: `Please use \`${ln}\` or \`${cn}\`.`
   },
-  [Yt]: {
+  [ln]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Block comments that make their subsequent template literals be identified as embedded Pegjs language. This option requires the `prettier-plugin-pegjs` plugin."
   },
-  [Vt]: {
+  [cn]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Tags that make their subsequent template literals be identified as embedded Pegjs language. This option requires the `prettier-plugin-pegjs` plugin."
   }
-}, or = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, Ss = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: nr,
-  language: Te,
-  options: rr
-}, Symbol.toStringTag, { value: "Module" })), { line: Zt, group: J, indent: en, softline: tn } = M, ar = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
+  embedder: $s,
+  language: Ne,
+  options: As
+}, Symbol.toStringTag, { value: "Module" })), { line: dn, group: X, indent: un, softline: pn } = A, Ms = async (t, e, n, i, { commentOrTag: r, embeddedOverrideOptions: o }) => {
   const s = {
-    ...r,
-    ...a
-  }, { node: l } = n, { createPlaceholder: u, placeholderRegex: E } = L("$p"), d = l.quasis.map(
-    (m, g, { length: y }) => g === y - 1 ? m.value.cooked : m.value.cooked + u(g)
-  ).join(""), c = d.match(/^\s+/)?.[0] ?? "", p = d.match(/\s+$/)?.[0] ?? "", f = d.slice(
-    c.length,
-    -p.length || void 0
-  ), b = k(n, t), $ = await e(f, {
+    ...i,
+    ...o
+  }, { node: l } = n, { createPlaceholder: p, placeholderRegex: f } = N("$p"), d = l.quasis.map(
+    (m, h, { length: _ }) => h === _ - 1 ? m.value.cooked : m.value.cooked + p(h)
+  ).join(""), u = d.match(/^\s+/)?.[0] ?? "", c = d.match(/\s+$/)?.[0] ?? "", y = d.slice(
+    u.length,
+    -c.length || void 0
+  ), b = L(n, e), D = await t(y, {
     ...s,
     parser: "php"
-  }), o = S($, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return J([
+  }), a = M(D, f, b);
+  if (s.preserveEmbeddedExteriorWhitespaces?.includes(r))
+    return X([
       "`",
+      u,
+      s.noEmbeddedMultiLineIndentation?.includes(r) ? [X(a)] : un([X(a)]),
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [J(o)] : en([J(o)]),
-      p,
       "`"
     ]);
-  const h = c.length ? Zt : tn, v = p.length ? Zt : tn;
-  return J([
+  const g = u.length ? dn : pn, E = c.length ? dn : pn;
+  return X([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, J(o)] : en([h, J(o)]),
-    v,
+    s.noEmbeddedMultiLineIndentation?.includes(r) ? [g, X(a)] : un([g, X(a)]),
+    E,
     "`"
   ]);
-}, Me = "embeddedPhp", dr = ["php", "php5"], lr = D(Me), nn = A(Me), sn = T(Me), cr = {
-  [lr]: {
+}, ke = "embeddedPhp", Ls = ["php", "php5"], Ns = T(ke), gn = S(ke), mn = v(ke), ks = {
+  [Ns]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...dr] }],
+    default: [{ value: [...Ls] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded PHP language. This option requires the `@prettier/plugin-php` plugin.",
-    deprecated: `Please use \`${nn}\` or \`${sn}\`.`
+    deprecated: `Please use \`${gn}\` or \`${mn}\`.`
   },
-  [nn]: {
+  [gn]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Block comments that make their subsequent template literals be identified as embedded PHP language. This option requires the `@prettier/plugin-php` plugin."
   },
-  [sn]: {
+  [mn]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Tags that make their subsequent template literals be identified as embedded PHP language. This option requires the `@prettier/plugin-php` plugin."
   }
-}, ur = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, Os = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: ar,
-  language: Me,
-  options: cr
-}, Symbol.toStringTag, { value: "Module" })), { line: rn, group: H, indent: on, softline: an } = M, pr = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
+  embedder: Ms,
+  language: ke,
+  options: ks
+}, Symbol.toStringTag, { value: "Module" })), { line: hn, group: H, indent: fn, softline: En } = A, Gs = async (t, e, n, i, { commentOrTag: r, embeddedOverrideOptions: o }) => {
   const s = {
-    ...r,
-    ...a
-  }, { node: l } = n, { createPlaceholder: u, placeholderRegex: E } = L(), d = l.quasis.map(
-    (m, g, { length: y }) => g === y - 1 ? m.value.cooked : m.value.cooked + u(g)
-  ).join(""), c = d.match(/^\s+/)?.[0] ?? "", p = d.match(/\s+$/)?.[0] ?? "", f = d.slice(
-    c.length,
-    -p.length || void 0
-  ), b = k(n, t), $ = await e(f, {
+    ...i,
+    ...o
+  }, { node: l } = n, { createPlaceholder: p, placeholderRegex: f } = N(), d = l.quasis.map(
+    (m, h, { length: _ }) => h === _ - 1 ? m.value.cooked : m.value.cooked + p(h)
+  ).join(""), u = d.match(/^\s+/)?.[0] ?? "", c = d.match(/\s+$/)?.[0] ?? "", y = d.slice(
+    u.length,
+    -c.length || void 0
+  ), b = L(n, e), D = await t(y, {
     ...s,
     parser: "prisma-parse"
-  }), o = S($, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
+  }), a = M(
+    D,
+    f,
+    b,
+    "hardline"
+  );
+  if (s.preserveEmbeddedExteriorWhitespaces?.includes(r))
     return H([
       "`",
+      u,
+      s.noEmbeddedMultiLineIndentation?.includes(r) ? [H(a)] : fn([H(a)]),
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [H(o)] : on([H(o)]),
-      p,
       "`"
     ]);
-  const h = c.length ? rn : an, v = p.length ? rn : an;
+  const g = u.length ? hn : En, E = c.length ? hn : En;
   return H([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, H(o)] : on([h, H(o)]),
-    v,
+    s.noEmbeddedMultiLineIndentation?.includes(r) ? [g, H(a)] : fn([g, H(a)]),
+    E,
     "`"
   ]);
-}, Ae = "embeddedPrisma", gr = ["prisma"], mr = D(Ae), dn = A(Ae), ln = T(Ae), hr = {
-  [mr]: {
+}, Oe = "embeddedPrisma", Is = ["prisma"], xs = T(Oe), bn = S(Oe), _n = v(Oe), Ps = {
+  [xs]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...gr] }],
+    default: [{ value: [...Is] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded Prisma language. This option requires the `prettier-plugin-prisma` plugin.",
-    deprecated: `Please use \`${dn}\` or \`${ln}\`.`
+    deprecated: `Please use \`${bn}\` or \`${_n}\`.`
   },
-  [dn]: {
+  [bn]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Block comments that make their subsequent template literals be identified as embedded Prisma language. This option requires the `prettier-plugin-prisma` plugin."
   },
-  [ln]: {
+  [_n]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Tags that make their subsequent template literals be identified as embedded Prisma language. This option requires the `prettier-plugin-prisma` plugin."
   }
-}, Er = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, qs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: pr,
-  language: Ae,
-  options: hr
-}, Symbol.toStringTag, { value: "Module" })), { line: cn, group: X, indent: un, softline: pn } = M, br = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
+  embedder: Gs,
+  language: Oe,
+  options: Ps
+}, Symbol.toStringTag, { value: "Module" })), { line: yn, group: Q, indent: Dn, softline: $n } = A, js = async (t, e, n, i, { commentOrTag: r, embeddedOverrideOptions: o }) => {
   const s = {
-    ...r,
-    ...a
-  }, { node: l } = n, { createPlaceholder: u, placeholderRegex: E } = L(), d = l.quasis.map(
-    (m, g, { length: y }) => g === y - 1 ? m.value.cooked : m.value.cooked + u(g)
-  ).join(""), c = d.match(/^\s+/)?.[0] ?? "", p = d.match(/\s+$/)?.[0] ?? "", f = d.slice(
-    c.length,
-    -p.length || void 0
-  ), b = k(n, t), $ = await e(f, {
+    ...i,
+    ...o
+  }, { node: l } = n, { createPlaceholder: p, placeholderRegex: f } = N(), d = l.quasis.map(
+    (m, h, { length: _ }) => h === _ - 1 ? m.value.cooked : m.value.cooked + p(h)
+  ).join(""), u = d.match(/^\s+/)?.[0] ?? "", c = d.match(/\s+$/)?.[0] ?? "", y = d.slice(
+    u.length,
+    -c.length || void 0
+  ), b = L(n, e), D = await t(y, {
     ...s,
     parser: "dot-properties"
-  }), o = S($, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return X([
+  }), a = M(D, f, b);
+  if (s.preserveEmbeddedExteriorWhitespaces?.includes(r))
+    return Q([
       "`",
+      u,
+      s.noEmbeddedMultiLineIndentation?.includes(r) ? [Q(a)] : Dn([Q(a)]),
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [X(o)] : un([X(o)]),
-      p,
       "`"
     ]);
-  const h = c.length ? cn : pn, v = p.length ? cn : pn;
-  return X([
+  const g = u.length ? yn : $n, E = c.length ? yn : $n;
+  return Q([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, X(o)] : un([h, X(o)]),
-    v,
+    s.noEmbeddedMultiLineIndentation?.includes(r) ? [g, Q(a)] : Dn([g, Q(a)]),
+    E,
     "`"
   ]);
-}, Se = "embeddedProperties", fr = ["properties"], yr = D(Se), gn = A(Se), mn = T(Se), _r = {
-  [yr]: {
+}, Ge = "embeddedProperties", Rs = ["properties"], Bs = T(Ge), Tn = S(Ge), vn = v(Ge), ws = {
+  [Bs]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...fr] }],
+    default: [{ value: [...Rs] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded Properties language. This option requires the `prettier-plugin-properties` plugin.",
-    deprecated: `Please use \`${gn}\` or \`${mn}\`.`
+    deprecated: `Please use \`${Tn}\` or \`${vn}\`.`
   },
-  [gn]: {
+  [Tn]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Block comments that make their subsequent template literals be identified as embedded Properties language. This option requires the `prettier-plugin-properties` plugin."
   },
-  [mn]: {
+  [vn]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Tags that make their subsequent template literals be identified as embedded Properties language. This option requires the `prettier-plugin-properties` plugin."
   }
-}, $r = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, Us = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: br,
-  language: Se,
-  options: _r
-}, Symbol.toStringTag, { value: "Module" })), { group: Q, line: hn, softline: En, indent: bn } = M, vr = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
+  embedder: js,
+  language: Ge,
+  options: ws
+}, Symbol.toStringTag, { value: "Module" })), { group: V, line: An, softline: Sn, indent: Mn } = A, Cs = async (t, e, n, i, { commentOrTag: r, embeddedOverrideOptions: o }) => {
   const s = {
-    ...r,
-    ...a
-  }, { node: l } = n, { createPlaceholder: u, placeholderRegex: E } = L(), d = l.quasis.map(
-    (m, g, { length: y }) => g === y - 1 ? m.value.cooked : m.value.cooked + u(g)
-  ).join(""), c = d.match(/^\s+/)?.[0] ?? "", p = d.match(/\s+$/)?.[0] ?? "", f = d.slice(
-    c.length,
-    -p.length || void 0
-  ), b = k(n, t), $ = await e(f, {
+    ...i,
+    ...o
+  }, { node: l } = n, { createPlaceholder: p, placeholderRegex: f } = N(), d = l.quasis.map(
+    (m, h, { length: _ }) => h === _ - 1 ? m.value.cooked : m.value.cooked + p(h)
+  ).join(""), u = d.match(/^\s+/)?.[0] ?? "", c = d.match(/\s+$/)?.[0] ?? "", y = d.slice(
+    u.length,
+    -c.length || void 0
+  ), b = L(n, e), D = await t(y, {
     ...s,
     parser: "pug"
-  }), o = S(
-    $,
-    E,
+  }), a = M(
+    D,
+    f,
     b,
-    !0
+    "hardline"
   );
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return Q([
+  if (s.preserveEmbeddedExteriorWhitespaces?.includes(r))
+    return V([
       "`",
+      u,
+      s.noEmbeddedMultiLineIndentation?.includes(r) ? [V(a)] : Mn([V(a)]),
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [Q(o)] : bn([Q(o)]),
-      p,
       "`"
     ]);
-  const h = c.length ? hn : En, v = p.length ? hn : En;
-  return Q([
+  const g = u.length ? An : Sn, E = c.length ? An : Sn;
+  return V([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, Q(o)] : bn([h, Q(o)]),
-    v,
+    s.noEmbeddedMultiLineIndentation?.includes(r) ? [g, V(a)] : Mn([g, V(a)]),
+    E,
     "`"
   ]);
-}, ke = "embeddedPug", Dr = ["pug", "jade"], Tr = D(ke), fn = A(ke), yn = T(ke), Mr = {
-  [Tr]: {
+}, Ie = "embeddedPug", Ws = ["pug", "jade"], Fs = T(Ie), Ln = S(Ie), Nn = v(Ie), zs = {
+  [Fs]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...Dr] }],
+    default: [{ value: [...Ws] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded Pug language. This option requires the `@prettier/plugin-pug` plugin.",
-    deprecated: `Please use \`${fn}\` or \`${yn}\`.`
+    deprecated: `Please use \`${Ln}\` or \`${Nn}\`.`
   },
-  [fn]: {
+  [Ln]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Block comments that make their subsequent template literals be identified as embedded Pug language. This option requires the `@prettier/plugin-pug` plugin."
   },
-  [yn]: {
+  [Nn]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Tags that make their subsequent template literals be identified as embedded Pug language. This option requires the `@prettier/plugin-pug` plugin."
   }
-}, Ar = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, Js = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: vr,
-  language: ke,
-  options: Mr
-}, Symbol.toStringTag, { value: "Module" })), { line: _n, group: Y, indent: $n, softline: vn } = M, Sr = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
+  embedder: Cs,
+  language: Ie,
+  options: zs
+}, Symbol.toStringTag, { value: "Module" })), { line: kn, group: Y, indent: On, softline: Gn } = A, Xs = async (t, e, n, i, { commentOrTag: r, embeddedOverrideOptions: o }) => {
   const s = {
-    ...r,
-    ...a
-  }, { node: l } = n, { createPlaceholder: u, placeholderRegex: E } = L(), d = l.quasis.map(
-    (m, g, { length: y }) => g === y - 1 ? m.value.cooked : m.value.cooked + u(g)
-  ).join(""), c = d.match(/^\s+/)?.[0] ?? "", p = d.match(/\s+$/)?.[0] ?? "", f = d.slice(
-    c.length,
-    -p.length || void 0
-  ), b = k(n, t), $ = await e(f, {
+    ...i,
+    ...o
+  }, { node: l } = n, { createPlaceholder: p, placeholderRegex: f } = N(), d = l.quasis.map(
+    (m, h, { length: _ }) => h === _ - 1 ? m.value.cooked : m.value.cooked + p(h)
+  ).join(""), u = d.match(/^\s+/)?.[0] ?? "", c = d.match(/\s+$/)?.[0] ?? "", y = d.slice(
+    u.length,
+    -c.length || void 0
+  ), b = L(n, e), D = await t(y, {
     ...s,
     parser: s.embeddedRubyParser ?? "ruby"
-  }), o = S($, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
+  }), a = M(D, f, b);
+  if (s.preserveEmbeddedExteriorWhitespaces?.includes(r))
     return Y([
       "`",
+      u,
+      s.noEmbeddedMultiLineIndentation?.includes(r) ? [Y(a)] : On([Y(a)]),
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [Y(o)] : $n([Y(o)]),
-      p,
       "`"
     ]);
-  const h = c.length ? _n : vn, v = p.length ? _n : vn;
+  const g = u.length ? kn : Gn, E = c.length ? kn : Gn;
   return Y([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, Y(o)] : $n([h, Y(o)]),
-    v,
+    s.noEmbeddedMultiLineIndentation?.includes(r) ? [g, Y(a)] : On([g, Y(a)]),
+    E,
     "`"
   ]);
-}, ue = "embeddedRuby", kr = ["ruby"], Lr = ["ruby", "rbs", "haml"], Gr = D(ue), Dn = A(ue), Tn = T(ue), Nr = O(ue), Or = {
-  [Gr]: {
+}, he = "embeddedRuby", Hs = ["ruby"], Qs = ["ruby", "rbs", "haml"], Vs = T(he), In = S(he), xn = v(he), Ys = G(he), Ks = {
+  [Vs]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...kr] }],
+    default: [{ value: [...Hs] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded Ruby language. This option requires the `@prettier/plugin-ruby` plugin.",
-    deprecated: `Please use \`${Dn}\` or \`${Tn}\`.`
+    deprecated: `Please use \`${In}\` or \`${xn}\`.`
   },
-  [Dn]: {
+  [In]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Block comments that make their subsequent template literals be identified as embedded Ruby language. This option requires the `@prettier/plugin-ruby` plugin."
   },
-  [Tn]: {
+  [xn]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Tags that make their subsequent template literals be identified as embedded Ruby language. This option requires the `@prettier/plugin-ruby` plugin."
   },
-  [Nr]: {
+  [Ys]: {
     category: "Embed",
     type: "choice",
     default: "ruby",
     description: "The parser used to parse the embedded Ruby language. This option requires the `@prettier/plugin-ruby` plugin.",
-    choices: Lr.map((e) => ({
-      value: e,
-      description: `Use the "${e}" parser.`
+    choices: Qs.map((t) => ({
+      value: t,
+      description: `Use the "${t}" parser.`
     }))
   }
-}, xr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, Zs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: Sr,
-  language: ue,
-  options: Or
-}, Symbol.toStringTag, { value: "Module" })), { group: V, line: Mn, softline: An, indent: Sn } = M, Ir = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
+  embedder: Xs,
+  language: he,
+  options: Ks
+}, Symbol.toStringTag, { value: "Module" })), { group: K, line: Pn, softline: qn, indent: jn } = A, eo = async (t, e, n, i, { commentOrTag: r, embeddedOverrideOptions: o }) => {
   const s = {
-    ...r,
-    ...a
-  }, { node: l } = n, { createPlaceholder: u, placeholderRegex: E } = L(), d = l.quasis.map(
-    (m, g, { length: y }) => g === y - 1 ? m.value.cooked : m.value.cooked + u(g)
-  ).join(""), c = d.match(/^\s+/)?.[0] ?? "", p = d.match(/\s+$/)?.[0] ?? "", f = d.slice(
-    c.length,
-    -p.length || void 0
-  ), b = k(n, t), $ = await e(f, {
+    ...i,
+    ...o
+  }, { node: l } = n, { createPlaceholder: p, placeholderRegex: f } = N(), d = l.quasis.map(
+    (m, h, { length: _ }) => h === _ - 1 ? m.value.cooked : m.value.cooked + p(h)
+  ).join(""), u = d.match(/^\s+/)?.[0] ?? "", c = d.match(/\s+$/)?.[0] ?? "", y = d.slice(
+    u.length,
+    -c.length || void 0
+  ), b = L(n, e), D = await t(y, {
     ...s,
     parser: "sh"
-  }), o = S(
-    $,
-    E,
+  }), a = M(
+    D,
+    f,
     b,
-    !0
+    "hardline"
   );
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return V([
+  if (s.preserveEmbeddedExteriorWhitespaces?.includes(r))
+    return K([
       "`",
+      u,
+      s.noEmbeddedMultiLineIndentation?.includes(r) ? [K(a)] : jn([K(a)]),
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [V(o)] : Sn([V(o)]),
-      p,
       "`"
     ]);
-  const h = c.length ? Mn : An, v = p.length ? Mn : An;
-  return V([
+  const g = u.length ? Pn : qn, E = c.length ? Pn : qn;
+  return K([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, V(o)] : Sn([h, V(o)]),
-    v,
+    s.noEmbeddedMultiLineIndentation?.includes(r) ? [g, K(a)] : jn([g, K(a)]),
+    E,
     "`"
   ]);
-}, Le = "embeddedSh", Pr = ["sh"], Br = D(Le), kn = A(Le), Ln = T(Le), qr = {
-  [Br]: {
+}, xe = "embeddedSh", to = ["sh"], no = T(xe), Rn = S(xe), Bn = v(xe), io = {
+  [no]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...Pr] }],
+    default: [{ value: [...to] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded Shell language. This option requires the `prettier-plugin-sh` plugin.",
-    deprecated: `Please use \`${kn}\` or \`${Ln}\`.`
+    deprecated: `Please use \`${Rn}\` or \`${Bn}\`.`
   },
-  [kn]: {
+  [Rn]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Block comments that make their subsequent template literals be identified as embedded Shell language. This option requires the `prettier-plugin-sh` plugin."
   },
-  [Ln]: {
+  [Bn]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Tags that make their subsequent template literals be identified as embedded Shell language. This option requires the `prettier-plugin-sh` plugin."
   }
-}, jr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, ro = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: Ir,
-  language: Le,
-  options: qr
-}, Symbol.toStringTag, { value: "Module" })), { group: Z, line: Gn, softline: Nn, indent: On } = M, Ur = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
+  embedder: eo,
+  language: xe,
+  options: io
+}, Symbol.toStringTag, { value: "Module" })), { group: Z, line: wn, softline: Un, indent: Cn } = A, so = async (t, e, n, i, { commentOrTag: r, embeddedOverrideOptions: o }) => {
   const s = {
-    ...r,
-    ...a
-  }, l = s.embeddedSqlPlugin ?? "prettier-plugin-sql", { node: u } = n, { createPlaceholder: E, placeholderRegex: d } = L(), c = u.quasis.map(
-    (m, g, { length: y }) => g === y - 1 ? m.value.cooked : m.value.cooked + E(g)
-  ).join(""), p = c.match(/^\s+/)?.[0] ?? "", f = c.match(/\s+$/)?.[0] ?? "", b = c.slice(
-    p.length,
-    -f.length || void 0
-  ), $ = k(n, t);
-  let o;
+    ...i,
+    ...o
+  }, l = s.embeddedSqlPlugin ?? "prettier-plugin-sql", { node: p } = n, { createPlaceholder: f, placeholderRegex: d } = N(), u = p.quasis.map(
+    (m, h, { length: _ }) => h === _ - 1 ? m.value.cooked : m.value.cooked + f(h)
+  ).join(""), c = u.match(/^\s+/)?.[0] ?? "", y = u.match(/\s+$/)?.[0] ?? "", b = u.slice(
+    c.length,
+    -y.length || void 0
+  ), D = L(n, e);
+  let a;
   if (l === "prettier-plugin-sql-cst") {
-    const m = await e(b, {
+    const m = await t(b, {
       ...s,
       parser: s.embeddedSqlParser ?? "sqlite"
     });
-    o = S(m, d, $);
+    a = M(m, d, D);
   } else {
-    const m = await e(ri(b), {
+    const m = await t(_i(b), {
       ...s,
       parser: "sql"
     });
-    o = S(
+    a = M(
       m,
       d,
-      $,
-      !0
+      D,
+      "hardline"
     );
   }
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
+  if (s.preserveEmbeddedExteriorWhitespaces?.includes(r))
     return Z([
       "`",
-      p,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [Z(o)] : On([Z(o)]),
-      f,
+      c,
+      s.noEmbeddedMultiLineIndentation?.includes(r) ? [Z(a)] : Cn([Z(a)]),
+      y,
       "`"
     ]);
-  const h = p.length ? Gn : Nn, v = f.length ? Gn : Nn;
+  const g = c.length ? wn : Un, E = y.length ? wn : Un;
   return Z([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, Z(o)] : On([h, Z(o)]),
-    v,
+    s.noEmbeddedMultiLineIndentation?.includes(r) ? [g, Z(a)] : Cn([g, Z(a)]),
+    E,
     "`"
   ]);
-}, se = "embeddedSql", Rr = ["sql"], Cr = ["prettier-plugin-sql", "prettier-plugin-sql-cst"], wr = [
+}, re = "embeddedSql", oo = ["sql"], ao = ["prettier-plugin-sql", "prettier-plugin-sql-cst"], lo = [
   "sqlite",
   "bigquery",
   "mysql",
   "mariadb",
   "postgresql"
-], Fr = D(se), xn = A(se), In = T(se), Wr = Ni(se), zr = O(se), Kr = {
-  [Fr]: {
+], co = T(re), Wn = S(re), Fn = v(re), uo = Qi(re), po = G(re), go = {
+  [co]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...Rr] }],
+    default: [{ value: [...oo] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded SQL language. This option requires the `prettier-plugin-sql` plugin or the `prettier-plugin-sql-cst` plugin.",
-    deprecated: `Please use \`${xn}\` or \`${In}\`.`
+    deprecated: `Please use \`${Wn}\` or \`${Fn}\`.`
   },
-  [xn]: {
+  [Wn]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Block comments that make their subsequent template literals be identified as embedded SQL language. This option requires the `prettier-plugin-sql` plugin or the `prettier-plugin-sql-cst` plugin."
   },
-  [In]: {
+  [Fn]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Tags that make their subsequent template literals be identified as embedded SQL language. This option requires the `prettier-plugin-sql` plugin or the `prettier-plugin-sql-cst` plugin."
   },
-  [Wr]: {
+  [uo]: {
     category: "Embed",
     type: "choice",
     default: "prettier-plugin-sql",
     description: "The plugin used to format the embedded SQL language. This option requires the `prettier-plugin-sql` plugin or the `prettier-plugin-sql-cst` plugin.",
-    choices: Cr.map((e) => ({
-      value: e,
-      description: `Use the "${e}" plugin.`
+    choices: ao.map((t) => ({
+      value: t,
+      description: `Use the "${t}" plugin.`
     }))
   },
-  [zr]: {
+  [po]: {
     category: "Embed",
     type: "choice",
     default: "sqlite",
     description: "Specify the embedded SQL language parser. This option is only needed with the `prettier-plugin-sql-cst` plugin.",
-    choices: wr.map((e) => ({
-      value: e,
-      description: `Use the "${e}" parser.`
+    choices: lo.map((t) => ({
+      value: t,
+      description: `Use the "${t}" parser.`
     }))
   }
-}, Jr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, mo = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: Ur,
-  language: se,
-  options: Kr
-}, Symbol.toStringTag, { value: "Module" })), { line: Pn, group: ee, indent: Bn, softline: qn } = M, Hr = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
+  embedder: so,
+  language: re,
+  options: go
+}, Symbol.toStringTag, { value: "Module" })), { line: zn, group: ee, indent: Jn, softline: Xn } = A, ho = async (t, e, n, i, { commentOrTag: r, embeddedOverrideOptions: o }) => {
   const s = {
-    ...r,
-    ...a
-  }, { node: l } = n, { createPlaceholder: u, placeholderRegex: E } = L(), d = l.quasis.map(
-    (m, g, { length: y }) => g === y - 1 ? m.value.cooked : m.value.cooked + u(g)
-  ).join(""), c = d.match(/^\s+/)?.[0] ?? "", p = d.match(/\s+$/)?.[0] ?? "", f = d.slice(
-    c.length,
-    -p.length || void 0
-  ), b = k(n, t), $ = await e(f, {
+    ...i,
+    ...o
+  }, { node: l } = n, { createPlaceholder: p, placeholderRegex: f } = N(), d = l.quasis.map(
+    (m, h, { length: _ }) => h === _ - 1 ? m.value.cooked : m.value.cooked + p(h)
+  ).join(""), u = d.match(/^\s+/)?.[0] ?? "", c = d.match(/\s+$/)?.[0] ?? "", y = d.slice(
+    u.length,
+    -c.length || void 0
+  ), b = L(n, e), D = await t(y, {
     ...s,
     parser: "toml"
-  }), o = S(
-    $,
-    E,
+  }), a = M(
+    D,
+    f,
     b,
-    !0
+    "hardline"
   );
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
+  if (s.preserveEmbeddedExteriorWhitespaces?.includes(r))
     return ee([
       "`",
+      u,
+      s.noEmbeddedMultiLineIndentation?.includes(r) ? [ee(a)] : Jn([ee(a)]),
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [ee(o)] : Bn([ee(o)]),
-      p,
       "`"
     ]);
-  const h = c.length ? Pn : qn, v = p.length ? Pn : qn;
+  const g = u.length ? zn : Xn, E = c.length ? zn : Xn;
   return ee([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, ee(o)] : Bn([h, ee(o)]),
-    v,
+    s.noEmbeddedMultiLineIndentation?.includes(r) ? [g, ee(a)] : Jn([g, ee(a)]),
+    E,
     "`"
   ]);
-}, Ge = "embeddedToml", Xr = ["toml"], Qr = D(Ge), jn = A(Ge), Un = T(Ge), Yr = {
-  [Qr]: {
+}, Pe = "embeddedToml", fo = ["toml"], Eo = T(Pe), Hn = S(Pe), Qn = v(Pe), bo = {
+  [Eo]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...Xr] }],
+    default: [{ value: [...fo] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded TOML language. This option requires the `prettier-plugin-toml` plugin.",
-    deprecated: `Please use \`${jn}\` or \`${Un}\`.`
+    deprecated: `Please use \`${Hn}\` or \`${Qn}\`.`
   },
-  [jn]: {
+  [Hn]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Block comments that make their subsequent template literals be identified as embedded TOML language. This option requires the `prettier-plugin-toml` plugin."
   },
-  [Un]: {
+  [Qn]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Tags that make their subsequent template literals be identified as embedded TOML language. This option requires the `prettier-plugin-toml` plugin."
   }
-}, Vr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, _o = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: Hr,
-  language: Ge,
-  options: Yr
-}, Symbol.toStringTag, { value: "Module" })), { line: Rn, group: te, indent: Cn, softline: wn } = M, Zr = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
+  embedder: ho,
+  language: Pe,
+  options: bo
+}, Symbol.toStringTag, { value: "Module" })), { line: Vn, group: te, indent: Yn, softline: Kn } = A, yo = async (t, e, n, i, { commentOrTag: r, embeddedOverrideOptions: o }) => {
   const s = {
-    ...r,
-    ...a
-  }, { node: l } = n, { createPlaceholder: u, placeholderRegex: E } = L(), d = l.quasis.map(
-    (m, g, { length: y }) => g === y - 1 ? m.value.cooked : m.value.cooked + u(g)
-  ).join(""), c = d.match(/^\s+/)?.[0] ?? "", p = d.match(/\s+$/)?.[0] ?? "", f = d.slice(
-    c.length,
-    -p.length || void 0
-  ), b = k(n, t), $ = await e(f, {
+    ...i,
+    ...o
+  }, { node: l } = n, { createPlaceholder: p, placeholderRegex: f } = N(), d = l.quasis.map(
+    (m, h, { length: _ }) => h === _ - 1 ? m.value.cooked : m.value.cooked + p(h)
+  ).join(""), u = d.match(/^\s+/)?.[0] ?? "", c = d.match(/\s+$/)?.[0] ?? "", y = d.slice(
+    u.length,
+    -c.length || void 0
+  ), b = L(n, e), D = await t(y, {
     ...s,
     parser: s.embeddedTsParser ?? "typescript",
     // set filepath to undefined to enable jsx auto detection:
     // https://github.com/prettier/prettier/blob/427a84d24203e2d54160cde153a1e6a6390fe65a/src/language-js/parse/typescript.js#L49-L53
     filepath: void 0
-  }), o = S($, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
+  }), a = M(D, f, b);
+  if (s.preserveEmbeddedExteriorWhitespaces?.includes(r))
     return te([
       "`",
+      u,
+      s.noEmbeddedMultiLineIndentation?.includes(r) ? [te(a)] : Yn([te(a)]),
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [te(o)] : Cn([te(o)]),
-      p,
       "`"
     ]);
-  const h = c.length ? Rn : wn, v = p.length ? Rn : wn;
+  const g = u.length ? Vn : Kn, E = c.length ? Vn : Kn;
   return te([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, te(o)] : Cn([h, te(o)]),
-    v,
+    s.noEmbeddedMultiLineIndentation?.includes(r) ? [g, te(a)] : Yn([g, te(a)]),
+    E,
     "`"
   ]);
-}, pe = "embeddedTs", eo = [
+}, fe = "embeddedTs", Do = [
   "ts",
   "tsx",
   "cts",
   "mts",
   "typescript"
-], to = ["typescript", "babel-ts"], no = D(pe), Fn = A(pe), Wn = T(pe), io = O(pe), so = {
-  [no]: {
+], $o = ["typescript", "babel-ts"], To = T(fe), Zn = S(fe), ei = v(fe), vo = G(fe), Ao = {
+  [To]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...eo] }],
+    default: [{ value: [...Do] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded TypeScript language.",
-    deprecated: `Please use \`${Fn}\` or \`${Wn}\`.`
+    deprecated: `Please use \`${Zn}\` or \`${ei}\`.`
   },
-  [Fn]: {
+  [Zn]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Block comments that make their subsequent template literals be identified as embedded TypeScript language."
   },
-  [Wn]: {
+  [ei]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Tags that make their subsequent template literals be identified as embedded TypeScript language."
   },
-  [io]: {
+  [vo]: {
     category: "Embed",
     type: "choice",
     default: "typescript",
     description: "The parser used to parse the embedded TypeScript language.",
-    choices: to.map((e) => ({
-      value: e,
-      description: `Use the "${e}" parser.`
+    choices: $o.map((t) => ({
+      value: t,
+      description: `Use the "${t}" parser.`
     }))
   }
-}, ro = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, So = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: Zr,
-  language: pe,
-  options: so
-}, Symbol.toStringTag, { value: "Module" })), ge = "embeddedXml", { line: zn, group: ne, indent: Kn, softline: Oe } = M, oo = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
+  embedder: yo,
+  language: fe,
+  options: Ao
+}, Symbol.toStringTag, { value: "Module" })), Ee = "embeddedXml", { line: ti, group: ne, indent: ni, softline: Re } = A, Mo = async (t, e, n, i, { commentOrTag: r, embeddedOverrideOptions: o }) => {
   const s = {
-    ...r,
-    ...a
-  }, { node: l } = n, { createPlaceholder: u, placeholderRegex: E } = L(), d = l.quasis.map(
-    (g, y, { length: G }) => y === G - 1 ? g.value.cooked : g.value.cooked + u(y)
-  ).join(""), c = d.match(/^\s+/)?.[0] ?? "", p = d.match(/\s+$/)?.[0] ?? "", f = d.slice(
-    c.length,
-    -p.length || void 0
-  ), b = k(n, t), $ = [];
-  let o = 0;
-  for (; o !== void 0; ) {
-    const g = f.slice(o);
-    if (g.length === 0)
+    ...i,
+    ...o
+  }, { node: l } = n, { createPlaceholder: p, placeholderRegex: f } = N(), d = l.quasis.map(
+    (h, _, { length: k }) => _ === k - 1 ? h.value.cooked : h.value.cooked + p(_)
+  ).join(""), u = d.match(/^\s+/)?.[0] ?? "", c = d.match(/\s+$/)?.[0] ?? "", y = d.slice(
+    u.length,
+    -c.length || void 0
+  ), b = L(n, e), D = [];
+  let a = 0;
+  for (; a !== void 0; ) {
+    const h = y.slice(a);
+    if (h.length === 0)
       break;
-    o > 0 && s.xmlWhitespaceSensitivity !== "strict" && $.push(Oe), s.__embeddedXmlFragmentRecoverIndex?.splice(
+    a > 0 && s.xmlWhitespaceSensitivity !== "strict" && D.push(Re), s.__embeddedXmlFragmentRecoverIndex?.splice(
       0,
       s.__embeddedXmlFragmentRecoverIndex.length
     );
-    let y = await e(g, {
+    let _ = await t(h, {
       ...s,
-      parser: ge
+      parser: Ee
     });
-    const [G, N] = s.__embeddedXmlFragmentRecoverIndex ?? [];
-    G === void 0 ? o = void 0 : N === void 0 ? o += G : (y = g.slice(G, N + 1), o += N + 1), $.push(y);
+    const [k, O] = s.__embeddedXmlFragmentRecoverIndex ?? [];
+    k === void 0 ? a = void 0 : O === void 0 ? a += k : (_ = h.slice(k, O + 1), a += O + 1), D.push(_);
   }
-  const h = S($, E, b);
-  if (s.xmlWhitespaceSensitivity === "strict" || s.preserveEmbeddedExteriorWhitespaces?.includes(i))
+  const g = M(D, f, b);
+  if (s.xmlWhitespaceSensitivity === "strict" || s.preserveEmbeddedExteriorWhitespaces?.includes(r))
     return ne([
       "`",
+      u,
+      s.noEmbeddedMultiLineIndentation?.includes(r) ? [ne(g)] : ni([ne(g)]),
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [ne(h)] : Kn([ne(h)]),
-      p,
       "`"
     ]);
-  const v = c.length ? zn : Oe, m = p.length ? zn : Oe;
+  const E = u.length ? ti : Re, m = c.length ? ti : Re;
   return ne([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [v, ne(h)] : Kn([v, ne(h)]),
+    s.noEmbeddedMultiLineIndentation?.includes(r) ? [E, ne(g)] : ni([E, ne(g)]),
     m,
     "`"
   ]);
-}, ao = ["xml", "opml", "rss", "svg"], lo = D(ge), Jn = A(ge), Hn = T(ge), co = {
-  [lo]: {
+}, Lo = ["xml", "opml", "rss", "svg"], No = T(Ee), ii = S(Ee), ri = v(Ee), ko = {
+  [No]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...ao] }],
+    default: [{ value: [...Lo] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded XML language. This option requires the `@prettier/plugin-xml` plugin.",
-    deprecated: `Please use \`${Jn}\` or \`${Hn}\`.`
+    deprecated: `Please use \`${ii}\` or \`${ri}\`.`
   },
-  [Jn]: {
+  [ii]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Block comments that make their subsequent template literals be identified as embedded XML language. This option requires the `@prettier/plugin-xml` plugin."
   },
-  [Hn]: {
+  [ri]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Tags that make their subsequent template literals be identified as embedded XML language. This option requires the `@prettier/plugin-xml` plugin."
   },
   /**
@@ -1718,60 +1806,174 @@ const { line: Bt, group: W, indent: qt, softline: jt } = M, Cs = async (e, t, n,
     description: "This option is read only and is used internally as a workaround to support xml fragments"
   }
 };
-function uo(e) {
-  const t = {
+function ae(t) {
+  const e = t.children, n = (o) => o?.[0]?.image ?? null, i = (o) => o?.filter(le).map(ae) ?? [], r = (o) => o?.[0] && le(o[0]) ? ae(o[0]) : null;
+  switch (t.name) {
+    case "document":
+      return {
+        name: t.name,
+        location: t.location,
+        prolog: r(e.prolog),
+        docTypeDecl: r(e.docTypeDecl),
+        element: r(e.element),
+        // Filter out misc nodes that only contain SEA_WS (whitespace)
+        misc: (e.misc ?? []).filter(
+          (o) => le(o) && !o.children.SEA_WS
+        ).map(ae)
+      };
+    case "prolog":
+      return {
+        name: t.name,
+        location: t.location,
+        XMLDeclOpen: n(e.XMLDeclOpen),
+        attribute: i(e.attribute),
+        SPECIAL_CLOSE: n(e.SPECIAL_CLOSE)
+      };
+    case "docTypeDecl":
+      return {
+        name: t.name,
+        location: t.location,
+        DocType: n(e.DocType),
+        Name: n(e.Name),
+        externalID: r(e.externalID),
+        CLOSE: n(e.CLOSE)
+      };
+    case "externalID":
+      return {
+        name: t.name,
+        location: t.location,
+        Public: n(e.Public),
+        System: n(e.System),
+        PubIDLiteral: n(e.PubIDLiteral),
+        SystemLiteral: n(e.SystemLiteral)
+      };
+    case "element":
+      return {
+        name: t.name,
+        location: t.location,
+        OPEN: n(e.OPEN),
+        Name: n(e.Name),
+        attribute: i(e.attribute),
+        START_CLOSE: n(e.START_CLOSE),
+        content: r(e.content),
+        SLASH_OPEN: n(e.SLASH_OPEN),
+        END_NAME: n(e.END_NAME),
+        END: n(e.END),
+        SLASH_CLOSE: n(e.SLASH_CLOSE)
+      };
+    case "attribute":
+      return {
+        name: t.name,
+        location: t.location,
+        Name: n(e.Name),
+        EQUALS: n(e.EQUALS),
+        STRING: n(e.STRING)
+      };
+    case "content":
+      return {
+        name: t.name,
+        location: t.location,
+        chardata: i(e.chardata),
+        element: i(e.element),
+        reference: i(e.reference),
+        // These should remain as IToken arrays (not mapped to .image)
+        CData: e.CData ?? [],
+        Comment: e.Comment ?? [],
+        PROCESSING_INSTRUCTION: e.PROCESSING_INSTRUCTION ?? []
+      };
+    case "chardata":
+      return {
+        name: t.name,
+        location: t.location,
+        SEA_WS: n(e.SEA_WS),
+        TEXT: n(e.TEXT)
+      };
+    case "reference":
+      return {
+        name: t.name,
+        location: t.location,
+        EntityRef: n(e.EntityRef),
+        CharRef: n(e.CharRef)
+      };
+    case "misc":
+      return {
+        name: t.name,
+        location: t.location,
+        Comment: n(e.Comment),
+        PROCESSING_INSTRUCTION: n(
+          e.PROCESSING_INSTRUCTION
+        ),
+        SEA_WS: n(e.SEA_WS)
+      };
+    default:
+      return {
+        name: t.name,
+        location: t.location,
+        ...Object.fromEntries(
+          Object.entries(e).map(([o, s]) => [
+            o,
+            Array.isArray(s) ? s.map(
+              (l) => le(l) ? ae(l) : l.image
+            ) : s
+          ])
+        )
+      };
+  }
+}
+function Oo(t) {
+  const e = {
     loc: {
       start: {
-        line: e.line,
-        column: e.column
+        line: t.line,
+        column: t.column
       },
       end: {
-        line: e.line,
-        column: e.column + e.length
+        line: t.line,
+        column: t.column + t.length
       }
     }
   }, n = new SyntaxError(
-    `${e.message} (${t.loc.start.line}:${t.loc.start.column})`,
+    `${t.message} (${e.loc.start.line}:${e.loc.start.column})`,
     {
-      cause: e
+      cause: t
     }
   );
-  return Object.assign(n, t), n;
+  return Object.assign(n, e), n;
 }
-function Xn(e) {
-  const t = {
+function si(t) {
+  const e = {
     loc: {
       start: {
-        line: e.token.startLine ?? NaN,
-        column: e.token.startColumn ?? NaN
+        line: t.token.startLine ?? Number.NaN,
+        column: t.token.startColumn ?? Number.NaN
       },
       end: {
-        line: e.token.endLine ?? NaN,
-        column: e.token.endColumn ?? NaN
+        line: t.token.endLine ?? Number.NaN,
+        column: t.token.endColumn ?? Number.NaN
       }
     }
   }, n = new SyntaxError(
-    `${e.message} (${t.loc.start.line}:${t.loc.start.column})`,
+    `${t.message} (${e.loc.start.line}:${e.loc.start.column})`,
     {
-      cause: e
+      cause: t
     }
   );
-  return Object.assign(n, t), n;
+  return Object.assign(n, e), n;
 }
-const po = {
-  async parse(e, t) {
-    const { parse: n } = await import("@xml-tools/parser"), { lexErrors: r, parseErrors: i, cst: a } = n(e);
-    if (r.length > 0) {
-      const s = r[0];
-      throw uo(s);
-    }
+const Go = {
+  async parse(t, e) {
+    const { parse: n } = await import("@xml-tools/parser"), { lexErrors: i, parseErrors: r, cst: o } = n(t);
     if (i.length > 0) {
+      const s = i[0];
+      throw Oo(s);
+    }
+    if (r.length > 0) {
       let s = !1;
-      for (const l of i) {
+      for (const l of r) {
         if (!["MismatchedTokenException", "NotAllInputParsedException"].includes(
           l.name
         ))
-          throw Xn(l);
+          throw si(l);
         if (l.message === "Expecting token of type --> OPEN <-- but found --> '' <--") {
           s = !0;
           continue;
@@ -1779,9 +1981,9 @@ const po = {
         if (/Expecting token of type --> EOF <-- but found --> '[\s\S]+' <--/.test(
           l.message
         ) || /Redundant input, expecting EOF but found: /.test(l.message)) {
-          t.__embeddedXmlFragmentRecoverIndex?.splice(
+          e.__embeddedXmlFragmentRecoverIndex?.splice(
             0,
-            t.__embeddedXmlFragmentRecoverIndex.length,
+            e.__embeddedXmlFragmentRecoverIndex.length,
             l.token.startOffset
           );
           break;
@@ -1791,144 +1993,144 @@ const po = {
         )) {
           if (l.token.endOffset === void 0 || Number.isNaN(l.token.endOffset))
             break;
-          t.__embeddedXmlFragmentRecoverIndex?.splice(
+          e.__embeddedXmlFragmentRecoverIndex?.splice(
             0,
-            t.__embeddedXmlFragmentRecoverIndex.length,
+            e.__embeddedXmlFragmentRecoverIndex.length,
             l.token.startOffset,
             l.token.endOffset
           ), s = !0;
           break;
         }
-        throw Xn(l);
+        throw si(l);
       }
-      s && ai(a);
+      s && Di(o);
     }
-    return a;
+    return ae(o);
   },
   astFormat: "xml",
-  locStart(e) {
-    return e.location.startOffset;
+  locStart(t) {
+    return t.location?.startOffset ?? 0;
   },
-  locEnd(e) {
-    return e.location.endOffset ?? NaN;
+  locEnd(t) {
+    return t.location?.endOffset ?? Number.NaN;
   }
 };
-function ai(e) {
-  const t = e.children;
-  for (const n in t) {
-    const r = t[n] ?? [];
-    for (let i = r.length - 1; i >= 0; --i) {
-      const a = r[i];
-      if (go(a)) {
-        if (Object.keys(a.children).length === 0) {
-          r.splice(i, 1), r.length === 0 && delete t[n];
+function Di(t) {
+  const e = t.children;
+  for (const n in e) {
+    const i = e[n] ?? [];
+    for (let r = i.length - 1; r >= 0; --r) {
+      const o = i[r];
+      if (le(o)) {
+        if (Object.keys(o.children).length === 0) {
+          i.splice(r, 1), i.length === 0 && delete e[n];
           continue;
         }
-        ai(a);
+        Di(o);
       }
     }
   }
 }
-function go(e) {
-  return "name" in e && "children" in e && "location" in e;
+function le(t) {
+  return "name" in t && "children" in t && "location" in t;
 }
-const mo = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const Io = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: oo,
-  language: ge,
-  options: co,
-  parser: po
-}, Symbol.toStringTag, { value: "Module" })), { line: Qn, group: ie, indent: Yn, softline: Vn } = M, ho = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
+  embedder: Mo,
+  language: Ee,
+  options: ko,
+  parser: Go
+}, Symbol.toStringTag, { value: "Module" })), { line: oi, group: ie, indent: ai, softline: li } = A, xo = async (t, e, n, i, { commentOrTag: r, embeddedOverrideOptions: o }) => {
   const s = {
-    ...r,
-    ...a
-  }, { node: l } = n, { createPlaceholder: u, placeholderRegex: E } = L(), d = l.quasis.map(
-    (m, g, { length: y }) => g === y - 1 ? m.value.cooked : m.value.cooked + u(g)
-  ).join(""), c = d.match(/^\s+/)?.[0] ?? "", p = d.match(/\s+$/)?.[0] ?? "", f = d.slice(
-    c.length,
-    -p.length || void 0
-  ), b = k(n, t), $ = await e(f, {
+    ...i,
+    ...o
+  }, { node: l } = n, { createPlaceholder: p, placeholderRegex: f } = N(), d = l.quasis.map(
+    (m, h, { length: _ }) => h === _ - 1 ? m.value.cooked : m.value.cooked + p(h)
+  ).join(""), u = d.match(/^\s+/)?.[0] ?? "", c = d.match(/\s+$/)?.[0] ?? "", y = d.slice(
+    u.length,
+    -c.length || void 0
+  ), b = L(n, e), D = await t(y, {
     ...s,
     parser: "yaml"
-  }), o = S($, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
+  }), a = M(D, f, b);
+  if (s.preserveEmbeddedExteriorWhitespaces?.includes(r))
     return ie([
       "`",
+      u,
+      s.noEmbeddedMultiLineIndentation?.includes(r) ? [ie(a)] : ai([ie(a)]),
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [ie(o)] : Yn([ie(o)]),
-      p,
       "`"
     ]);
-  const h = c.length ? Qn : Vn, v = p.length ? Qn : Vn;
+  const g = u.length ? oi : li, E = c.length ? oi : li;
   return ie([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, ie(o)] : Yn([h, ie(o)]),
-    v,
+    s.noEmbeddedMultiLineIndentation?.includes(r) ? [g, ie(a)] : ai([g, ie(a)]),
+    E,
     "`"
   ]);
-}, Ne = "embeddedYaml", Eo = ["yaml", "yml"], bo = D(Ne), Zn = A(Ne), ei = T(Ne), fo = {
-  [bo]: {
+}, qe = "embeddedYaml", Po = ["yaml", "yml"], qo = T(qe), ci = S(qe), di = v(qe), jo = {
+  [qo]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...Eo] }],
+    default: [{ value: [...Po] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded YAML language.",
-    deprecated: `Please use \`${Zn}\` or \`${ei}\`.`
+    deprecated: `Please use \`${ci}\` or \`${di}\`.`
   },
-  [Zn]: {
+  [ci]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Block comments that make their subsequent template literals be identified as embedded YAML language."
   },
-  [ei]: {
+  [di]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [_] }],
+    default: [{ value: [$] }],
     description: "Tags that make their subsequent template literals be identified as embedded YAML language."
   }
-}, yo = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, Ro = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: ho,
-  language: Ne,
-  options: fo
-}, Symbol.toStringTag, { value: "Module" })), me = [], di = {}, li = {}, ci = {}, _o = /* @__PURE__ */ Object.assign({
-  "./css/index.ts": ji,
-  "./es/index.ts": zi,
-  "./glsl/index.ts": Qi,
-  "./graphql/index.ts": ts,
-  "./html/index.ts": ls,
-  "./ini/index.ts": ms,
-  "./java/index.ts": ys,
-  "./json/index.ts": Ss,
-  "./jsonata/index.ts": Os,
-  "./latex/index.ts": qs,
-  "./markdown/index.ts": Js,
-  "./nginx/index.ts": Vs,
-  "./noop/index.ts": tr,
-  "./pegjs/index.ts": or,
-  "./php/index.ts": ur,
-  "./prisma/index.ts": Er,
-  "./properties/index.ts": $r,
-  "./pug/index.ts": Ar,
-  "./ruby/index.ts": xr,
-  "./sh/index.ts": jr,
-  "./sql/index.ts": Jr,
-  "./toml/index.ts": Vr,
-  "./ts/index.ts": ro,
-  "./xml/index.ts": mo,
-  "./yaml/index.ts": yo
+  embedder: xo,
+  language: qe,
+  options: jo
+}, Symbol.toStringTag, { value: "Module" })), _e = [], $i = {}, Ti = {}, vi = {}, Bo = /* @__PURE__ */ Object.assign({
+  "./css/index.ts": nr,
+  "./es/index.ts": cr,
+  "./glsl/index.ts": mr,
+  "./graphql/index.ts": _r,
+  "./html/index.ts": Mr,
+  "./ini/index.ts": Gr,
+  "./java/index.ts": jr,
+  "./json/index.ts": zr,
+  "./jsonata/index.ts": Vr,
+  "./latex/index.ts": ts,
+  "./markdown/index.ts": gs,
+  "./nginx/index.ts": bs,
+  "./noop/index.ts": Ds,
+  "./pegjs/index.ts": Ss,
+  "./php/index.ts": Os,
+  "./prisma/index.ts": qs,
+  "./properties/index.ts": Us,
+  "./pug/index.ts": Js,
+  "./ruby/index.ts": Zs,
+  "./sh/index.ts": ro,
+  "./sql/index.ts": mo,
+  "./toml/index.ts": _o,
+  "./ts/index.ts": So,
+  "./xml/index.ts": Io,
+  "./yaml/index.ts": Ro
 });
-for (const { language: e, parser: t, embedder: n, options: r } of Object.values(_o))
-  Gi(me, e, ce), t && (di[e] = t), n && (li[e] = n), Object.assign(ci, r);
-const $o = "noEmbeddedIdentificationByComment", vo = "noEmbeddedIdentificationByTag", Do = "preserveEmbeddedExteriorWhitespaces", To = "noEmbeddedMultiLineIndentation", Mo = "embeddedOverrides", ia = {
-  ...ci,
+for (const { language: t, parser: e, embedder: n, options: i } of Object.values(Bo))
+  Hi(_e, t, me), e && ($i[t] = e), n && (Ti[t] = n), Object.assign(vi, i);
+const wo = "noEmbeddedIdentificationByComment", Uo = "noEmbeddedIdentificationByTag", Co = "preserveEmbeddedExteriorWhitespaces", Wo = "noEmbeddedMultiLineIndentation", Fo = "embeddedOverrides", bl = {
+  ...vi,
   /**
    * @deprecated Please use `embedded<Language>Comments` or `embedded<Language>Tags` to configure each embedded language, and you won't need this option anymore.
    */
-  [$o]: {
+  [wo]: {
     category: "Embed",
     type: "string",
     array: !0,
@@ -1939,7 +2141,7 @@ const $o = "noEmbeddedIdentificationByComment", vo = "noEmbeddedIdentificationBy
   /**
    * @deprecated Please use `embedded<Language>Comments` or `embedded<Language>Tags` to configure each embedded language, and you won't need this option anymore.
    */
-  [vo]: {
+  [Uo]: {
     category: "Embed",
     type: "string",
     array: !0,
@@ -1947,331 +2149,853 @@ const $o = "noEmbeddedIdentificationByComment", vo = "noEmbeddedIdentificationBy
     description: "Turns off `` tag`...` `` tag-based embedded language identification for the specified identifiers.",
     deprecated: "Please use `embedded<Language>Comments` or `embedded<Language>Tags` to configure each embedded language, and you won't need this option anymore."
   },
-  [Do]: {
+  [Co]: {
     category: "Embed",
     type: "string",
     array: !0,
     default: [{ value: [] }],
     description: "Preserves leading and trailing whitespaces in the formatting results for the specified comments or tags."
   },
-  [To]: {
+  [Wo]: {
     category: "Embed",
     type: "string",
     array: !0,
     default: [{ value: [] }],
     description: "Turns off auto indentation in the formatting results for the specified comments or tags when they are formatted to span multi lines."
   },
-  [Mo]: {
+  [Fo]: {
     category: "Embed",
     type: "string",
     array: !1,
     default: void 0,
     description: "Option overrides for the specified comments or tags. It should either be a stringified JSON or an absolute filepath to the option overrides file."
   }
-}, Ao = {
+}, zo = {
   // parsers from internal
-  ...bi.parsers,
-  ...fi.parsers,
-  ...yi.parsers,
-  ...$i.parsers,
-  ..._i.parsers,
+  ...Oi.parsers,
+  ...Gi.parsers,
+  ...Ii.parsers,
+  ...Pi.parsers,
+  ...xi.parsers,
   // parsers from this plugin
-  ...di
-};
-var So = {
-  isEqual: !0,
-  isMatchingKey: !0,
-  isPromise: !0,
-  maxSize: !0,
-  onCacheAdd: !0,
-  onCacheChange: !0,
-  onCacheHit: !0,
-  transformKey: !0
-}, ko = Array.prototype.slice;
-function Ee(e) {
-  var t = e.length;
-  return t ? t === 1 ? [e[0]] : t === 2 ? [e[0], e[1]] : t === 3 ? [e[0], e[1], e[2]] : ko.call(e, 0) : [];
-}
-function Lo(e) {
-  var t = {};
-  for (var n in e)
-    So[n] || (t[n] = e[n]);
-  return t;
+  ...$i
+}, { getOwnPropertyNames: Jo, getOwnPropertySymbols: Xo } = Object, { hasOwnProperty: Ho } = Object.prototype;
+function Be(t, e) {
+  return function(i, r, o) {
+    return t(i, r, o) && e(i, r, o);
+  };
 }
-function Go(e) {
-  return typeof e == "function" && e.isMemoized;
+function be(t) {
+  return function(n, i, r) {
+    if (!n || !i || typeof n != "object" || typeof i != "object")
+      return t(n, i, r);
+    const { cache: o } = r, s = o.get(n), l = o.get(i);
+    if (s && l)
+      return s === i && l === n;
+    o.set(n, i), o.set(i, n);
+    const p = t(n, i, r);
+    return o.delete(n), o.delete(i), p;
+  };
 }
-function No(e, t) {
-  return e === t || e !== e && t !== t;
+function Qo(t) {
+  return t?.[Symbol.toStringTag];
 }
-function ti(e, t) {
-  var n = {};
-  for (var r in e)
-    n[r] = e[r];
-  for (var r in t)
-    n[r] = t[r];
-  return n;
+function ui(t) {
+  return Jo(t).concat(Xo(t));
+}
+const Vo = (
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  Object.hasOwn || ((t, e) => Ho.call(t, e))
+);
+function x(t, e) {
+  return t === e || !t && !e && t !== t && e !== e;
+}
+const Yo = "__v", Ko = "__o", Zo = "_owner", { getOwnPropertyDescriptor: pi, keys: gi } = Object;
+function ea(t, e) {
+  return t.byteLength === e.byteLength && De(new Uint8Array(t), new Uint8Array(e));
+}
+function ta(t, e, n) {
+  let i = t.length;
+  if (e.length !== i)
+    return !1;
+  for (; i-- > 0; )
+    if (!n.equals(t[i], e[i], i, i, t, e, n))
+      return !1;
+  return !0;
+}
+function na(t, e) {
+  return t.byteLength === e.byteLength && De(new Uint8Array(t.buffer, t.byteOffset, t.byteLength), new Uint8Array(e.buffer, e.byteOffset, e.byteLength));
+}
+function ia(t, e) {
+  return x(t.getTime(), e.getTime());
+}
+function ra(t, e) {
+  return t.name === e.name && t.message === e.message && t.cause === e.cause && t.stack === e.stack;
 }
-var Oo = (
-  /** @class */
-  function() {
-    function e(t) {
-      this.keys = [], this.values = [], this.options = t;
-      var n = typeof t.isMatchingKey == "function";
-      n ? this.getKeyIndex = this._getKeyIndexFromMatchingKey : t.maxSize > 1 ? this.getKeyIndex = this._getKeyIndexForMany : this.getKeyIndex = this._getKeyIndexForSingle, this.canTransformKey = typeof t.transformKey == "function", this.shouldCloneArguments = this.canTransformKey || n, this.shouldUpdateOnAdd = typeof t.onCacheAdd == "function", this.shouldUpdateOnChange = typeof t.onCacheChange == "function", this.shouldUpdateOnHit = typeof t.onCacheHit == "function";
+function sa(t, e) {
+  return t === e;
+}
+function mi(t, e, n) {
+  const i = t.size;
+  if (i !== e.size)
+    return !1;
+  if (!i)
+    return !0;
+  const r = new Array(i), o = t.entries();
+  let s, l, p = 0;
+  for (; (s = o.next()) && !s.done; ) {
+    const f = e.entries();
+    let d = !1, u = 0;
+    for (; (l = f.next()) && !l.done; ) {
+      if (r[u]) {
+        u++;
+        continue;
+      }
+      const c = s.value, y = l.value;
+      if (n.equals(c[0], y[0], p, u, t, e, n) && n.equals(c[1], y[1], c[0], y[0], t, e, n)) {
+        d = r[u] = !0;
+        break;
+      }
+      u++;
     }
-    return Object.defineProperty(e.prototype, "size", {
-      /**
-       * The number of cached [key,value] results.
-       */
-      get: function() {
-        return this.keys.length;
-      },
-      enumerable: !1,
-      configurable: !0
-    }), Object.defineProperty(e.prototype, "snapshot", {
-      /**
-       * A copy of the cache at a moment in time. This is useful
-       * to compare changes over time, since the cache mutates
-       * internally for performance reasons.
-       */
-      get: function() {
-        return {
-          keys: Ee(this.keys),
-          size: this.size,
-          values: Ee(this.values)
-        };
-      },
-      enumerable: !1,
-      configurable: !0
-    }), e.prototype._getKeyIndexFromMatchingKey = function(t) {
-      var n = this.options, r = n.isMatchingKey, i = n.maxSize, a = this.keys, s = a.length;
-      if (!s)
-        return -1;
-      if (r(a[0], t))
-        return 0;
-      if (i > 1) {
-        for (var l = 1; l < s; l++)
-          if (r(a[l], t))
-            return l;
+    if (!d)
+      return !1;
+    p++;
+  }
+  return !0;
+}
+const oa = x;
+function aa(t, e, n) {
+  const i = gi(t);
+  let r = i.length;
+  if (gi(e).length !== r)
+    return !1;
+  for (; r-- > 0; )
+    if (!Ai(t, e, n, i[r]))
+      return !1;
+  return !0;
+}
+function oe(t, e, n) {
+  const i = ui(t);
+  let r = i.length;
+  if (ui(e).length !== r)
+    return !1;
+  let o, s, l;
+  for (; r-- > 0; )
+    if (o = i[r], !Ai(t, e, n, o) || (s = pi(t, o), l = pi(e, o), (s || l) && (!s || !l || s.configurable !== l.configurable || s.enumerable !== l.enumerable || s.writable !== l.writable)))
+      return !1;
+  return !0;
+}
+function la(t, e) {
+  return x(t.valueOf(), e.valueOf());
+}
+function ca(t, e) {
+  return t.source === e.source && t.flags === e.flags;
+}
+function hi(t, e, n) {
+  const i = t.size;
+  if (i !== e.size)
+    return !1;
+  if (!i)
+    return !0;
+  const r = new Array(i), o = t.values();
+  let s, l;
+  for (; (s = o.next()) && !s.done; ) {
+    const p = e.values();
+    let f = !1, d = 0;
+    for (; (l = p.next()) && !l.done; ) {
+      if (!r[d] && n.equals(s.value, l.value, s.value, l.value, t, e, n)) {
+        f = r[d] = !0;
+        break;
       }
-      return -1;
-    }, e.prototype._getKeyIndexForMany = function(t) {
-      var n = this.options.isEqual, r = this.keys, i = r.length;
-      if (!i)
-        return -1;
-      if (i === 1)
-        return this._getKeyIndexForSingle(t);
-      var a = t.length, s, l;
-      if (a > 1) {
-        for (var u = 0; u < i; u++)
-          if (s = r[u], s.length === a) {
-            for (l = 0; l < a && n(s[l], t[l]); l++)
-              ;
-            if (l === a)
-              return u;
-          }
-      } else
-        for (var u = 0; u < i; u++)
-          if (s = r[u], s.length === a && n(s[0], t[0]))
-            return u;
-      return -1;
-    }, e.prototype._getKeyIndexForSingle = function(t) {
-      var n = this.keys;
-      if (!n.length)
-        return -1;
-      var r = n[0], i = r.length;
-      if (t.length !== i)
-        return -1;
-      var a = this.options.isEqual;
-      if (i > 1) {
-        for (var s = 0; s < i; s++)
-          if (!a(r[s], t[s]))
-            return -1;
-        return 0;
+      d++;
+    }
+    if (!f)
+      return !1;
+  }
+  return !0;
+}
+function De(t, e) {
+  let n = t.byteLength;
+  if (e.byteLength !== n || t.byteOffset !== e.byteOffset)
+    return !1;
+  for (; n-- > 0; )
+    if (t[n] !== e[n])
+      return !1;
+  return !0;
+}
+function da(t, e) {
+  return t.hostname === e.hostname && t.pathname === e.pathname && t.protocol === e.protocol && t.port === e.port && t.hash === e.hash && t.username === e.username && t.password === e.password;
+}
+function Ai(t, e, n, i) {
+  return (i === Zo || i === Ko || i === Yo) && (t.$$typeof || e.$$typeof) ? !0 : Vo(e, i) && n.equals(t[i], e[i], i, i, t, e, n);
+}
+const ua = "[object ArrayBuffer]", pa = "[object Arguments]", ga = "[object Boolean]", ma = "[object DataView]", ha = "[object Date]", fa = "[object Error]", Ea = "[object Map]", ba = "[object Number]", _a = "[object Object]", ya = "[object RegExp]", Da = "[object Set]", $a = "[object String]", Ta = {
+  "[object Int8Array]": !0,
+  "[object Uint8Array]": !0,
+  "[object Uint8ClampedArray]": !0,
+  "[object Int16Array]": !0,
+  "[object Uint16Array]": !0,
+  "[object Int32Array]": !0,
+  "[object Uint32Array]": !0,
+  "[object Float16Array]": !0,
+  "[object Float32Array]": !0,
+  "[object Float64Array]": !0,
+  "[object BigInt64Array]": !0,
+  "[object BigUint64Array]": !0
+}, va = "[object URL]", Aa = Object.prototype.toString;
+function Sa({ areArrayBuffersEqual: t, areArraysEqual: e, areDataViewsEqual: n, areDatesEqual: i, areErrorsEqual: r, areFunctionsEqual: o, areMapsEqual: s, areNumbersEqual: l, areObjectsEqual: p, arePrimitiveWrappersEqual: f, areRegExpsEqual: d, areSetsEqual: u, areTypedArraysEqual: c, areUrlsEqual: y, unknownTagComparators: b }) {
+  return function(a, g, E) {
+    if (a === g)
+      return !0;
+    if (a == null || g == null)
+      return !1;
+    const m = typeof a;
+    if (m !== typeof g)
+      return !1;
+    if (m !== "object")
+      return m === "number" ? l(a, g, E) : m === "function" ? o(a, g, E) : !1;
+    const h = a.constructor;
+    if (h !== g.constructor)
+      return !1;
+    if (h === Object)
+      return p(a, g, E);
+    if (Array.isArray(a))
+      return e(a, g, E);
+    if (h === Date)
+      return i(a, g, E);
+    if (h === RegExp)
+      return d(a, g, E);
+    if (h === Map)
+      return s(a, g, E);
+    if (h === Set)
+      return u(a, g, E);
+    const _ = Aa.call(a);
+    if (_ === ha)
+      return i(a, g, E);
+    if (_ === ya)
+      return d(a, g, E);
+    if (_ === Ea)
+      return s(a, g, E);
+    if (_ === Da)
+      return u(a, g, E);
+    if (_ === _a)
+      return typeof a.then != "function" && typeof g.then != "function" && p(a, g, E);
+    if (_ === va)
+      return y(a, g, E);
+    if (_ === fa)
+      return r(a, g, E);
+    if (_ === pa)
+      return p(a, g, E);
+    if (Ta[_])
+      return c(a, g, E);
+    if (_ === ua)
+      return t(a, g, E);
+    if (_ === ma)
+      return n(a, g, E);
+    if (_ === ga || _ === ba || _ === $a)
+      return f(a, g, E);
+    if (b) {
+      let k = b[_];
+      if (!k) {
+        const O = Qo(a);
+        O && (k = b[O]);
       }
-      return a(r[0], t[0]) ? 0 : -1;
-    }, e.prototype.orderByLru = function(t, n, r) {
-      for (var i = this.keys, a = this.values, s = i.length, l = r; l--; )
-        i[l + 1] = i[l], a[l + 1] = a[l];
-      i[0] = t, a[0] = n;
-      var u = this.options.maxSize;
-      s === u && r === s ? (i.pop(), a.pop()) : r >= u && (i.length = a.length = u);
-    }, e.prototype.updateAsyncCache = function(t) {
-      var n = this, r = this.options, i = r.onCacheChange, a = r.onCacheHit, s = this.keys[0], l = this.values[0];
-      this.values[0] = l.then(function(u) {
-        return n.shouldUpdateOnHit && a(n, n.options, t), n.shouldUpdateOnChange && i(n, n.options, t), u;
-      }, function(u) {
-        var E = n.getKeyIndex(s);
-        throw E !== -1 && (n.keys.splice(E, 1), n.values.splice(E, 1)), u;
+      if (k)
+        return k(a, g, E);
+    }
+    return !1;
+  };
+}
+function Ma({ circular: t, createCustomConfig: e, strict: n }) {
+  let i = {
+    areArrayBuffersEqual: ea,
+    areArraysEqual: n ? oe : ta,
+    areDataViewsEqual: na,
+    areDatesEqual: ia,
+    areErrorsEqual: ra,
+    areFunctionsEqual: sa,
+    areMapsEqual: n ? Be(mi, oe) : mi,
+    areNumbersEqual: oa,
+    areObjectsEqual: n ? oe : aa,
+    arePrimitiveWrappersEqual: la,
+    areRegExpsEqual: ca,
+    areSetsEqual: n ? Be(hi, oe) : hi,
+    areTypedArraysEqual: n ? Be(De, oe) : De,
+    areUrlsEqual: da,
+    unknownTagComparators: void 0
+  };
+  if (e && (i = Object.assign({}, i, e(i))), t) {
+    const r = be(i.areArraysEqual), o = be(i.areMapsEqual), s = be(i.areObjectsEqual), l = be(i.areSetsEqual);
+    i = Object.assign({}, i, {
+      areArraysEqual: r,
+      areMapsEqual: o,
+      areObjectsEqual: s,
+      areSetsEqual: l
+    });
+  }
+  return i;
+}
+function La(t) {
+  return function(e, n, i, r, o, s, l) {
+    return t(e, n, l);
+  };
+}
+function Na({ circular: t, comparator: e, createState: n, equals: i, strict: r }) {
+  if (n)
+    return function(l, p) {
+      const { cache: f = t ? /* @__PURE__ */ new WeakMap() : void 0, meta: d } = n();
+      return e(l, p, {
+        cache: f,
+        equals: i,
+        meta: d,
+        strict: r
       });
-    }, e;
-  }()
-);
-function ui(e, t) {
-  if (t === void 0 && (t = {}), Go(e))
-    return ui(e.fn, ti(e.options, t));
-  if (typeof e != "function")
-    throw new TypeError("You must pass a function to `memoize`.");
-  var n = t.isEqual, r = n === void 0 ? No : n, i = t.isMatchingKey, a = t.isPromise, s = a === void 0 ? !1 : a, l = t.maxSize, u = l === void 0 ? 1 : l, E = t.onCacheAdd, d = t.onCacheChange, c = t.onCacheHit, p = t.transformKey, f = ti({
-    isEqual: r,
-    isMatchingKey: i,
-    isPromise: s,
-    maxSize: u,
-    onCacheAdd: E,
-    onCacheChange: d,
-    onCacheHit: c,
-    transformKey: p
-  }, Lo(t)), b = new Oo(f), $ = b.keys, o = b.values, h = b.canTransformKey, v = b.shouldCloneArguments, m = b.shouldUpdateOnAdd, g = b.shouldUpdateOnChange, y = b.shouldUpdateOnHit, G = function() {
-    var N = v ? Ee(arguments) : arguments;
-    h && (N = p(N));
-    var x = $.length ? b.getKeyIndex(N) : -1;
-    if (x !== -1)
-      y && c(b, f, G), x && (b.orderByLru($[x], o[x], x), g && d(b, f, G));
-    else {
-      var hi = e.apply(this, arguments), Ei = v ? N : Ee(arguments);
-      b.orderByLru(Ei, hi, $.length), s && b.updateAsyncCache(G), m && E(b, f, G), g && d(b, f, G);
+    };
+  if (t)
+    return function(l, p) {
+      return e(l, p, {
+        cache: /* @__PURE__ */ new WeakMap(),
+        equals: i,
+        meta: void 0,
+        strict: r
+      });
+    };
+  const o = {
+    cache: void 0,
+    equals: i,
+    meta: void 0,
+    strict: r
+  };
+  return function(l, p) {
+    return e(l, p, o);
+  };
+}
+const ka = I();
+I({ strict: !0 });
+I({ circular: !0 });
+I({
+  circular: !0,
+  strict: !0
+});
+const Oa = I({
+  createInternalComparator: () => x
+});
+I({
+  strict: !0,
+  createInternalComparator: () => x
+});
+I({
+  circular: !0,
+  createInternalComparator: () => x
+});
+I({
+  circular: !0,
+  createInternalComparator: () => x,
+  strict: !0
+});
+function I(t = {}) {
+  const { circular: e = !1, createInternalComparator: n, createState: i, strict: r = !1 } = t, o = Ma(t), s = Sa(o), l = n ? n(s) : La(s);
+  return Na({ circular: e, comparator: s, createState: i, equals: l, strict: r });
+}
+var Ga = {};
+function Ia(t, e) {
+  var n = e === void 0 ? Ga : e, i = n.indent, r = n.replacer, o = n.circularReplacer, s = n.stable, l = n.stabilizer, p = [], f = [], d = s && l ? function(u) {
+    var c = {
+      get: function(y) {
+        return u[y];
+      }
+    };
+    return function(y, b) {
+      return l({ key: y, value: u[y] }, { key: b, value: u[b] }, c);
+    };
+  } : void 0;
+  return JSON.stringify(t, function(c, y) {
+    var b = y;
+    if (typeof b == "object" && b !== null) {
+      if (p.length) {
+        var D = p.indexOf(this) + 1;
+        D === 0 ? p[p.length] = this : (p.splice(D), f.splice(D)), f[f.length] = c;
+        var a = p.indexOf(b) + 1;
+        if (a > 0) {
+          var g = f.slice(0, a).join(".") || ".";
+          return o ? o.call(this, c, b, g) : "[ref=" + g + "]";
+        }
+      } else
+        p[0] = b, f[0] = c;
+      s && !Array.isArray(b) && (b = Object.keys(b).sort(d?.(b)).reduce(function(E, m) {
+        return E[m] = b[m], E;
+      }, {}));
     }
-    return o[0];
+    return r ? r.call(this, c, b) : b;
+  }, i);
+}
+class xa {
+  constructor(e) {
+    this.l = {}, this.c = e;
+  }
+  /**
+   * Method to [a]dd a listener for the given cache change event.
+   */
+  a(e, n) {
+    const i = this.l[e];
+    i ? i.has(n) || i.add(n) : this.l[e] = /* @__PURE__ */ new Set([n]);
+  }
+  /**
+   * Method to [n]otify all listeners for the given cache change event.
+   */
+  n(e, n, i) {
+    const r = this.l[e];
+    r && r.forEach((o) => {
+      o({
+        cache: this.c,
+        key: n.k,
+        reason: i,
+        value: n.v,
+        type: e
+      });
+    });
+  }
+  /**
+   * Method to [r]emove a listener for the given cache change event.
+   */
+  r(e, n) {
+    const i = this.l[e];
+    i && (i.delete(n), i.size || (this.l[e] = void 0));
+  }
+}
+function Pa(t) {
+  return t === 1 ? (e) => t >= e.length ? e : [e[0]] : t === 2 ? (e) => t >= e.length ? e : [e[0], e[1]] : (e) => {
+    if (t >= e.length)
+      return e;
+    const n = new Array(t);
+    for (let i = 0; i < t; ++i)
+      n[i] = e[i];
+    return n;
+  };
+}
+function qa(t, e) {
+  const n = typeof e;
+  return n === "function" || n === "symbol" ? e.toString() : e;
+}
+function ja(t) {
+  return [Ia(t, { replacer: qa })];
+}
+function Ra(t, e) {
+  return t[0] === e[0];
+}
+function Ba(t) {
+  return typeof t == "function" && t.isMemoized;
+}
+function We(t) {
+  return typeof t == "number" && t >= 0 && Number.isFinite(t);
+}
+class wa {
+  constructor(e) {
+    this.c = 0;
+    const { async: n, maxSize: i } = e;
+    this.e = Ua(e), this.k = Ca(e), this.p = typeof n == "boolean" && n, this.s = We(i) ? i : 1;
+  }
+  /**
+   * The size of the populated cache.
+   */
+  get size() {
+    return this.c;
+  }
+  /**
+   * The [key, value] pairs for the existing entries in cache.
+   */
+  get snapshot() {
+    const e = [], n = [], i = [];
+    let r = this.h, o = 0;
+    for (; r != null; )
+      n.push(r.k), i.push(r.v), e.push([r.k, r.v]), ++o, r = r.n;
+    return { entries: e, keys: n, size: o, values: i };
+  }
+  /**
+   * Clear the cache.
+   */
+  clear(e = "explicit clear") {
+    if (!this.h)
+      return;
+    const n = this.o;
+    let i;
+    if (n) {
+      i = [];
+      let r = this.h;
+      for (; r != null; )
+        i.push(r), r = r.n;
+    }
+    if (this.h = this.t = void 0, this.c = 0, n && i)
+      for (let r = 0; r < i.length; ++r)
+        n.n("delete", i[r], e);
+  }
+  /**
+   * Delete the entry for the key based on the given `args` in cache.
+   */
+  delete(e, n = "explicit delete") {
+    const i = this.g(this.k ? this.k(e) : e);
+    return i ? (this.d(i, n), !0) : !1;
+  }
+  /**
+   * Get the value in cache based on the given `args`.
+   */
+  get(e, n = "explicit get") {
+    const i = this.g(this.k ? this.k(e) : e);
+    if (i)
+      return i !== this.h ? this.u(i, n, !0) : this.o && this.o.n("hit", i, n), i.v;
+  }
+  /**
+   * Determine whether the given `args` have a related entry in the cache.
+   */
+  has(e) {
+    return !!this.g(this.k ? this.k(e) : e);
+  }
+  /**
+   * Remove the given `listener` for the given `type` of cache event.
+   */
+  off(e, n) {
+    this.o && this.o.r(e, n);
+  }
+  /**
+   * Add the given `listener` for the given `type` of cache event.
+   */
+  on(e, n) {
+    this.o || (this.o = new xa(this)), this.o.a(e, n);
+  }
+  /**
+   * Add or update the cache entry for the given `key`.
+   */
+  set(e, n, i = "explicit set") {
+    const r = this.k ? this.k(e) : e;
+    let o = this.g(r);
+    if (o) {
+      const s = o.v;
+      o.v = n, this.p && n !== s && (o.v = this.w(o)), o !== this.h && this.u(o, i, !1);
+    } else
+      o = this.n(r, n);
+  }
+  /**
+   * Method to [d]elete the given `node` from the cache.
+   */
+  d(e, n) {
+    const i = e.n, r = e.p;
+    i ? i.p = r : this.t = r, r ? r.n = i : this.h = i, --this.c, e.r = !0, this.o && this.o.n("delete", e, n);
+  }
+  /**
+   * Method to [g]et an existing node from cache based on the given `key`.
+   */
+  g(e) {
+    let n = this.h;
+    if (!(!n || n.r)) {
+      if (this.e(n.k, e))
+        return n;
+      if (this.h !== this.t)
+        for (n = n.n; n; ) {
+          if (n.r)
+            return;
+          if (this.e(n.k, e))
+            return n;
+          n = n.n;
+        }
+    }
+  }
+  /**
+   * Method to create a new [n]ode and set it at the head of the linked list.
+   */
+  n(e, n, i) {
+    const r = this.h, o = this.t, s = { k: e, n: r, p: void 0, v: n };
+    return this.p && (s.v = this.w(s)), this.h = s, r ? r.p = s : this.t = s, ++this.c > this.s && o && this.d(o, "evicted"), this.o && this.o.n("add", s, i), s;
+  }
+  /**
+   * Method to [u]date the location of the given `node` in cache.
+   */
+  u(e, n, i) {
+    const r = e.n, o = e.p;
+    r && (r.p = o), o && (o.n = r), this.h && (this.h.p = e), e.n = this.h, e.p = void 0, this.h = e, e === this.t && (this.t = o), this.o && (i && this.o.n("hit", e, n), this.o.n("update", e, n));
+  }
+  /**
+   * Method to [w]rap the promise in a handler to automatically delete the
+   * entry if it rejects.
+   */
+  w(e) {
+    const { v: n } = e;
+    return n == null || typeof n.then != "function" ? n : n.then((i) => (!e.r && this.o && this.o.n("update", e, "resolved"), i), (i) => {
+      throw !e.r && this.d(e, "rejected"), i;
+    });
+  }
+}
+function Ua({ isKeyEqual: t, isKeyItemEqual: e, serialize: n }) {
+  if (typeof t == "function")
+    return t;
+  if (n)
+    return Ra;
+  const i = typeof e == "function" ? e : e === "deep" ? ka : e === "shallow" ? Oa : Object.is;
+  return function(o, s) {
+    const l = s.length;
+    if (o.length !== l)
+      return !1;
+    if (l === 1)
+      return i(o[0], s[0], 0);
+    for (let p = 0; p < l; ++p)
+      if (!i(o[p], s[p], p))
+        return !1;
+    return !0;
   };
-  return G.cache = b, G.fn = e, G.isMemoized = !0, G.options = f, G;
 }
-const xo = /("(?:\\?[^])*?")|(\/\/.*)|(\/\*[^]*?\*\/)/g, Io = /("(?:\\?[^])*?")|(,\s*)(?=]|})/g, Pe = {
-  parse: (e) => {
-    e = String(e);
+function Ca(t) {
+  const { maxArgs: e, serialize: n, transformKey: i } = t, r = [
+    n ? typeof n == "function" ? n : ja : void 0,
+    We(e) ? Pa(e) : void 0,
+    typeof i == "function" ? i : void 0
+  ].filter(Boolean);
+  return r.length ? r.reduce((o, s) => (...l) => (
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    o(s(...l))
+  )) : void 0;
+}
+class Wa {
+  constructor(e, n) {
+    if (this.e = /* @__PURE__ */ new Map(), this.c = e, typeof n == "object" ? (this.t = n.after, this.p = n.shouldPersist, this.r = n.shouldRemove, this.u = !!n.update) : (this.t = n, this.u = !1), this.c.on("add", ({ key: i, value: r }) => {
+      this.a(i, r) && this.s(i, r);
+    }), this.u && (this.c.on("hit", ({ key: i, value: r }) => {
+      this.a(i, r) && this.s(i, r);
+    }), this.c.p)) {
+      const i = ({ key: r, reason: o, value: s }) => {
+        o === "resolved" && this.a(r, s) && (this.s(r, s), this.c.off("update", i));
+      };
+      this.c.on("update", i);
+    }
+    this.c.on("delete", ({ key: i }) => {
+      this.e.has(i) && this.d(i);
+    });
+  }
+  get size() {
+    return this.e.size;
+  }
+  /**
+   * Whether the cache expiration should be set [a]gain, generally after some cache change.
+   */
+  a(e, n) {
+    var i;
+    return !!(this.c.g(e) && !(!((i = this.p) === null || i === void 0) && i.call(this, e, n, this.c)));
+  }
+  /**
+   * Method to [d]elete the expiration.
+   */
+  d(e) {
+    const n = this.e.get(e);
+    n && (clearTimeout(n), this.e.delete(e));
+  }
+  /**
+   * Method to [s]et the new expiration. If one is present for the given `key`, it will delete
+   * the existing expiration before creating the new one.
+   */
+  s(e, n) {
+    this.e.has(e) && this.d(e);
+    const i = this.c, r = typeof this.t == "function" ? this.t(e, n, i) : this.t;
+    if (!We(r))
+      throw new TypeError(`The expiration time must be a finite, non-negative number; received ${r}`);
+    const o = setTimeout(() => {
+      this.d(e);
+      const s = i.g(e);
+      s && (typeof this.r == "function" && !this.r(e, s.v, r, i) ? (s !== i.h ? i.u(s, "expiration reset", !1) : i.o && i.o.n("update", s, "expiration reset"), this.s(e, s.v)) : i.d(s, "expired"));
+    }, r);
+    typeof o.unref == "function" && o.unref(), this.e.set(e, o);
+  }
+}
+const Fa = /* @__PURE__ */ new Map();
+class za {
+  constructor(e, n) {
+    this.p = { c: 0, h: 0 }, this.c = e, this.n = n, Fa.set(n, this);
+  }
+  /**
+   * Method to compute the [m]etrics for the profile stats.
+   */
+  m() {
+    const { c: e, h: n } = this.p, i = e ? `${(n / e * 100).toFixed(4)}%` : "0.0000%";
+    return { calls: e, hits: n, name: this.n, usage: i };
+  }
+  /**
+   * Method to [r]eset the counts.
+   */
+  r() {
+    this.p = { c: 0, h: 0 };
+  }
+  /**
+   * Method to [s]tart the collection of stats for the given profile.
+   */
+  s() {
+    const e = () => {
+      ++this.p.c;
+    }, n = () => {
+      ++this.p.c, ++this.p.h;
+    };
+    this.d = () => {
+      this.c.off("add", e), this.c.off("hit", n), this.d = void 0, this.p.c = this.p.h = 0;
+    }, this.c.on("add", e), this.c.on("hit", n);
+  }
+}
+const Ja = function t(e, n = {}) {
+  if (Ba(e))
+    return t(e.fn, Object.assign({}, e.options, n));
+  if (typeof e != "function")
+    throw new TypeError(`Expected first parameter to be function; received ${typeof e}`);
+  const i = new wa(n), r = Xa(e, i, n.forceUpdate), { expires: o, statsName: s } = n;
+  return r.cache = i, r.expirationManager = o != null ? new Wa(i, o) : null, r.fn = e, r.isMemoized = !0, r.options = n, r.statsManager = s != null ? new za(i, s) : null, r;
+};
+function Xa(t, e, n) {
+  const i = function(...o) {
+    const s = e.k ? e.k(o) : o;
+    let l = e.g(s);
+    return l ? l !== e.h ? e.u(l, void 0, !0) : e.o && e.o.n("hit", l) : l = e.n(s, t.apply(this, o)), l.v;
+  };
+  return n ? function(...o) {
+    if (!n(o) || !e.has(o))
+      return i.apply(this, o);
+    const s = t.apply(this, o);
+    return e.set(o, s, "forced"), s;
+  } : i;
+}
+const Ha = /("(?:\\?[^])*?")|(\/\/.*)|(\/\*[^]*?\*\/)/g, Qa = /("(?:\\?[^])*?")|(,\s*)(?=]|})/g, Ce = {
+  parse: (t) => {
+    t = String(t);
     try {
-      return JSON.parse(e);
+      return JSON.parse(t);
     } catch {
-      return JSON.parse(e.replace(xo, "$1").replace(Io, "$1"));
+      return JSON.parse(t.replace(Ha, "$1").replace(Qa, "$1"));
     }
   }
-}, { label: Po } = M;
-async function ni(e) {
+}, { label: Va } = A;
+async function fi(t) {
   try {
-    const { readFile: t } = await import("node:fs/promises"), n = await t(e, { encoding: "utf-8" });
-    return Pe.parse(n);
+    const { readFile: e } = await import("node:fs/promises"), n = await e(t, { encoding: "utf-8" });
+    return Ce.parse(n);
   } catch {
   }
 }
-const Bo = /* @__PURE__ */ new URL(
+const Ya = /* @__PURE__ */ new URL(
   `data:text/javascript,${encodeURIComponent('import{pathToFileURL as o}from"node:url";import{parentPort as t,workerData as a}from"node:worker_threads";const s=async({absolutePath:r})=>{try{const e=await import(o(r).href);t?.postMessage(e.embeddedOverrides??e.default??void 0)}catch{t?.postMessage(void 0)}};s(a);')}`
-), qo = /* @__PURE__ */ new URL(
+), Ka = /* @__PURE__ */ new URL(
   `data:text/javascript,${encodeURIComponent('import{register as a}from"node:module";import{pathToFileURL as s}from"node:url";import{parentPort as t,workerData as i}from"node:worker_threads";const d=async({absolutePath:r,importMetaUrl:o})=>{a("tsx/esm",{parentURL:o,data:!0});try{const e=await import(s(r).href);t?.postMessage(e.embeddedOverrides??e.default??void 0)}catch{t?.postMessage(void 0)}};d(i);')}`
 );
-async function jo(e) {
-  const { Worker: t } = await import("node:worker_threads");
+async function Za(t) {
+  const { Worker: e } = await import("node:worker_threads");
   return new Promise((n) => {
-    const r = new t(Bo, {
+    const i = new e(Ya, {
       workerData: {
-        absolutePath: e
+        absolutePath: t
       }
     });
-    r.once("message", (i) => {
-      n(i);
-    }), r.once("error", (i) => {
-      console.error(i), n(void 0);
+    i.once("message", (r) => {
+      n(r);
+    }), i.once("error", (r) => {
+      console.error(r), n(void 0);
     });
   });
 }
-async function Uo(e) {
-  const { Worker: t } = await import("node:worker_threads");
+async function el(t) {
+  const { Worker: e } = await import("node:worker_threads");
   return new Promise((n) => {
-    const r = new t(qo, {
+    const i = new e(Ka, {
       workerData: {
-        absolutePath: e,
+        absolutePath: t,
         importMetaUrl: import.meta.url
       }
     });
-    r.once("message", (i) => {
-      n(i);
-    }), r.once("error", (i) => {
-      console.error(i), n(void 0);
+    i.once("message", (r) => {
+      n(r);
+    }), i.once("error", (r) => {
+      console.error(r), n(void 0);
     });
   });
 }
-const Ro = ui(
-  async (e, t) => {
-    const { isAbsolute: n, dirname: r, resolve: i } = await import("node:path");
-    if (n(e))
-      return e;
-    const a = await Di(t);
+const tl = Ja(
+  async (t, e) => {
+    const { isAbsolute: n, dirname: i, resolve: r } = await import("node:path");
+    if (n(t))
+      return t;
+    const o = await ji(e);
     let s;
-    return typeof a != "string" ? s = process.env.PWD ?? process.cwd() : s = r(a), i(s, e);
+    return typeof o != "string" ? s = process.env.PWD ?? process.cwd() : s = i(o), r(s, t);
   }
-), Co = async (e, t) => {
+), nl = async (t, e) => {
   let n;
   try {
     n = (await import("node:path")).extname(
-      e
+      t
     );
   } catch {
     try {
-      return Pe.parse(e);
+      return Ce.parse(t);
     } catch {
       console.error("Failed to parse embeddedOverrides as a json object");
       return;
     }
   }
-  const r = Ro(
-    e,
-    t
+  const i = tl(
+    t,
+    e
   );
   if (n === ".json" || n === ".jsonc") {
-    const i = await r, a = await ni(i);
-    if (a !== void 0)
-      return a;
-    console.error(`Failed to parse the json file: ${i}`);
+    const r = await i, o = await fi(r);
+    if (o !== void 0)
+      return o;
+    console.error(`Failed to parse the json file: ${r}`);
     return;
   }
   if (n === ".mjs" || n === ".cjs" || n === ".js") {
-    const i = await r, a = await jo(i);
-    if (a !== void 0)
-      return a;
-    console.error(`Failed to parse the js module file: ${i}`);
+    const r = await i, o = await Za(r);
+    if (o !== void 0)
+      return o;
+    console.error(`Failed to parse the js module file: ${r}`);
     return;
   }
   if (n === ".mts" || n === ".cts" || n === ".ts") {
-    const i = await r, a = await Uo(i);
-    if (a !== void 0)
-      return a;
-    console.error(`Failed to parse the ts module file: ${i}`);
+    const r = await i, o = await el(r);
+    if (o !== void 0)
+      return o;
+    console.error(`Failed to parse the ts module file: ${r}`);
     return;
   }
   if (n === "") {
-    const i = await r, a = await ni(i);
-    if (a !== void 0)
-      return a;
+    const r = await i, o = await fi(r);
+    if (o !== void 0)
+      return o;
   }
   try {
-    return Pe.parse(e);
+    return Ce.parse(t);
   } catch {
     console.error("Failed to parse embeddedOverrides as a json object");
   }
 };
-async function wo(e, {
-  commentOrTag: t,
+async function il(t, {
+  commentOrTag: e,
   kind: n,
-  filepath: r
+  filepath: i
 }) {
-  if (e === void 0)
+  if (t === void 0)
     return;
-  const i = await Co(
-    e,
-    r
+  const r = await nl(
+    t,
+    i
   );
-  if (i !== void 0)
+  if (r !== void 0)
     for (const {
-      [`${n}s`]: a,
+      [`${n}s`]: o,
       identifiers: s,
       options: l
-    } of i) {
-      const u = a ?? [];
-      if (u.length === 0 && s?.includes(t) || u.includes(t))
+    } of r) {
+      const p = o ?? [];
+      if (p.length === 0 && s?.includes(e) || p.includes(e))
         return l;
     }
 }
-const Fo = /* @__PURE__ */ (() => {
-  const e = /* @__PURE__ */ new Set([
+function* Si(t) {
+  yield t, t.type === "CallExpression" && (yield* Si(t.callee));
+}
+const rl = /* @__PURE__ */ (() => {
+  const t = /* @__PURE__ */ new Set([
     "start",
     "end",
     "loc",
@@ -2280,34 +3004,39 @@ const Fo = /* @__PURE__ */ (() => {
     "typeAnnotation",
     "decorators"
   ]);
-  return (t, n, r) => {
-    let i;
+  return (e, n, i) => {
+    let r;
     try {
-      const s = r(`${n}\`\``);
+      const s = i(`${n}\`\``);
       if (s instanceof Promise)
         throw new TypeError("Async parse function hasn't been supported yet.");
-      i = s;
+      r = s;
     } catch {
       return !1;
     }
-    if (i.type === "File" && (i = i.program), !(i.type === "Program" && i.body[0]?.type === "ExpressionStatement"))
+    if (r.type === "File" && (r = r.program), !(r.type === "Program" && r.body[0]?.type === "ExpressionStatement"))
       return !1;
-    const a = i.body[0]?.expression;
-    return a?.type !== "TaggedTemplateExpression" ? !1 : !!gi(
-      t,
-      a.tag,
-      e
-    );
+    const o = r.body[0]?.expression;
+    if (o?.type !== "TaggedTemplateExpression")
+      return !1;
+    for (const s of Si(e))
+      if (Li(
+        s,
+        o.tag,
+        t
+      ))
+        return !0;
+    return !1;
   };
 })();
-function Wo({
-  node: e,
-  parent: t
+function sl({
+  node: t,
+  parent: e
 }) {
-  const n = e.comments ?? t?.comments;
+  const n = t.comments ?? e?.comments;
   if (!n)
     return;
-  const r = n[n.length - 1];
+  const i = n[n.length - 1];
   if (![
     "MultiLine",
     // meriyah
@@ -2315,171 +3044,171 @@ function Wo({
     // typescript, acorn, espree, flow
     "CommentBlock"
     // babel, babel-flow, babel-ts
-  ].includes(r.type) || !r.leading)
+  ].includes(i.type) || !i.leading)
     return;
-  const i = r.value;
-  if (i.length > 1 && i.startsWith(" ") && i.endsWith(" "))
-    return i.slice(1, -1);
+  const r = i.value;
+  if (r.length > 1 && r.startsWith(" ") && r.endsWith(" "))
+    return r.slice(1, -1);
 }
-function zo({
-  parent: e
+function ol({
+  parent: t
 }) {
-  if (e?.type === "TaggedTemplateExpression")
-    return e.tag.type === "Identifier" ? e.tag.name : e.tag;
-}
-function Ko(e, t) {
-  return e.noEmbeddedIdentificationByComment?.includes(t) ?? !1 ? function* (r) {
-  } : function* (r) {
-    const i = e[A(r)] ?? [_];
-    i[0] === _ ? yield* e[D(r)] ?? [] : yield* i ?? [];
+  if (t?.type === "TaggedTemplateExpression")
+    return t.tag.type === "Identifier" ? t.tag.name : t.tag;
+}
+function al(t, e) {
+  return t.noEmbeddedIdentificationByComment?.includes(e) ?? !1 ? function* (i) {
+  } : function* (i) {
+    const r = t[S(i)] ?? [$];
+    r[0] === $ ? yield* t[T(i)] ?? [] : yield* r ?? [];
   };
 }
-function ii(e, t) {
-  return typeof t == "string" ? e.noEmbeddedIdentificationByTag?.includes(t) ?? !1 ? function* (r) {
-  } : function* (r) {
-    const i = e[T(r)] ?? [
-      _
+function Ei(t, e) {
+  return typeof e == "string" ? t.noEmbeddedIdentificationByTag?.includes(e) ?? !1 ? function* (i) {
+  } : function* (i) {
+    const r = t[v(i)] ?? [
+      $
     ];
-    i[0] === _ ? yield* e[D(r)] ?? [] : yield* i ?? [];
+    r[0] === $ ? yield* t[T(i)] ?? [] : yield* r ?? [];
   } : function* (n) {
-    const r = e[T(n)] ?? [
-      _
+    const i = t[v(n)] ?? [
+      $
     ];
-    if (r[0] === _) {
-      const { noEmbeddedIdentificationByTag: i } = e;
-      for (const a of e[D(n)] ?? [])
-        i?.includes(a) || (yield a);
+    if (i[0] === $) {
+      const { noEmbeddedIdentificationByTag: r } = t;
+      for (const o of t[T(n)] ?? [])
+        r?.includes(o) || (yield o);
     } else
-      yield* r;
+      yield* i;
   };
 }
-function xe(e, t, n, r, i) {
-  const a = li[t];
-  if (!a)
+function we(t, e, n, i, r) {
+  const o = Ti[e];
+  if (!o)
     return null;
-  if (e.quasis.length === 1 && e.quasis[0]?.value.raw.trim() === "")
+  if (t.quasis.length === 1 && t.quasis[0]?.value.raw.trim() === "")
     return "``";
-  const s = wo(
-    i.embeddedOverrides,
+  const s = il(
+    r.embeddedOverrides,
     {
       commentOrTag: n,
-      kind: r,
-      filepath: i.filepath
+      kind: i,
+      filepath: r.filepath
     }
   );
   return async (...l) => {
     try {
-      const u = await a(...l, {
+      const p = await o(...l, {
         commentOrTag: n,
-        kind: r,
+        kind: i,
         embeddedOverrideOptions: await s
       });
-      return Po(
+      return Va(
         {
           embed: !0,
-          ...u.label
+          ...p.label
         },
-        u
+        p
       );
-    } catch (u) {
-      throw console.error(u), u;
+    } catch (p) {
+      throw console.error(p), p;
     }
   };
 }
-function pi(e, t, n) {
-  return Object.is(e, t) ? !0 : e === null || t === null ? !1 : Array.isArray(e) ? Jo(e, t, n) : typeof e == "object" ? gi(e, t, n) : !1;
+function Mi(t, e, n) {
+  return Object.is(t, e) ? !0 : t === null || e === null ? !1 : Array.isArray(t) ? ll(t, e, n) : typeof t == "object" ? Li(t, e, n) : !1;
 }
-function Jo(e, t, n) {
-  const r = e.length;
-  if (r !== t.length)
+function ll(t, e, n) {
+  const i = t.length;
+  if (i !== e.length)
     return !1;
-  for (let i = 0; i < r; i++)
-    if (!pi(e[i], t[i], n))
+  for (let r = 0; r < i; r++)
+    if (!Mi(t[r], e[r], n))
       return !1;
   return !0;
 }
-function gi(e, t, n) {
-  for (const r of Object.keys(e))
-    if (!n?.has(r) && !(Object.prototype.hasOwnProperty.call(t, r) && pi(e[r], t[r], n)))
+function Li(t, e, n) {
+  for (const i of Object.keys(t))
+    if (!n?.has(i) && !(Object.hasOwn(e, i) && Mi(t[i], e[i], n)))
       return !1;
   return !0;
 }
-const { estree: mi } = vi, { embed: Ie } = mi, Ho = (e, t) => {
-  const { node: n } = e;
-  if (n.type !== "TemplateLiteral" || n.quasis.some(({ value: { cooked: a } }) => a === null))
+const { estree: Ni } = qi, { embed: Ue } = Ni, cl = (t, e) => {
+  const { node: n } = t;
+  if (n.type !== "TemplateLiteral" || n.quasis.some(({ value: { cooked: o } }) => o === null))
     return null;
-  const r = Wo(e);
-  if (typeof r == "string") {
-    const a = Ko(
-      t,
-      r
+  const i = sl(t);
+  if (typeof i == "string") {
+    const o = al(
+      e,
+      i
     );
-    for (const s of me) {
+    for (const s of _e) {
       let l = !1;
-      for (const u of a(
+      for (const p of o(
         s
       ))
-        if (r === u) {
+        if (i === p) {
           l = !0;
           break;
         }
       if (l)
-        return xe(
+        return we(
           n,
           s,
-          r,
+          i,
           "comment",
-          t
+          e
         );
     }
-    return Ie?.(e, t) ?? null;
+    return Ue?.(t, e) ?? null;
   }
-  const i = zo(e);
-  if (typeof i == "string") {
-    const a = ii(t, i);
-    for (const s of me) {
+  const r = ol(t);
+  if (typeof r == "string") {
+    const o = Ei(e, r);
+    for (const s of _e) {
       let l = !1;
-      for (const u of a(s))
-        if (i === u) {
+      for (const p of o(s))
+        if (r === p) {
           l = !0;
           break;
         }
       if (l)
-        return xe(n, s, i, "tag", t);
+        return we(n, s, r, "tag", e);
     }
-    return Ie?.(e, t) ?? null;
+    return Ue?.(t, e) ?? null;
   }
-  if (i !== void 0) {
-    const a = (l) => Ao[t.parser].parse(
+  if (r !== void 0) {
+    const o = (l) => zo[e.parser].parse(
       l,
-      t
-    ), s = ii(t);
-    for (const l of me) {
-      let u;
-      for (const E of s(l))
-        if (Fo(i, E, a)) {
-          u = E;
+      e
+    ), s = Ei(e);
+    for (const l of _e) {
+      let p;
+      for (const f of s(l))
+        if (rl(r, f, o)) {
+          p = f;
           break;
         }
-      if (u !== void 0)
-        return xe(
+      if (p !== void 0)
+        return we(
           n,
           l,
-          u,
+          p,
           "tag",
-          t
+          e
         );
     }
   }
-  return Ie?.(e, t) ?? null;
-}, sa = {
+  return Ue?.(t, e) ?? null;
+}, _l = {
   estree: {
-    ...mi,
-    embed: Ho
+    ...Ni,
+    embed: cl
   }
 };
 export {
-  ia as options,
-  Ao as parsers,
-  sa as printers
+  bl as options,
+  zo as parsers,
+  _l as printers
 };