prettier-plugin-embed 0.4.14 → 0.5.0

package/dist/index.js

@@ -1,28 +1,28 @@
-import { builders as T, utils as ii } from "prettier/doc";
-import hi from "prettier/parser-babel";
-import Ei from "prettier/parser-espree";
-import bi from "prettier/parser-flow";
-import fi from "prettier/parser-meriyah";
-import yi from "prettier/parser-typescript";
-import { printers as _i } from "prettier/plugins/estree.mjs";
-import { resolveConfigFile as vi } from "prettier";
-const { group: $i, indent: Di, softline: Pe, hardline: Ti, lineSuffixBoundary: Mi } = T, { mapDoc: Ai } = ii;
-function Si(e, t) {
+import { builders as M, utils as si } from "prettier/doc";
+import fi from "prettier/parser-babel";
+import yi from "prettier/parser-espree";
+import _i from "prettier/parser-flow";
+import $i from "prettier/parser-meriyah";
+import vi from "prettier/parser-typescript";
+import { printers as Di } from "prettier/plugins/estree.mjs";
+import { resolveConfigFile as Ti } from "prettier";
+const { group: Mi, indent: Ai, softline: Be, hardline: Si, lineSuffixBoundary: ki } = M, { mapDoc: Li } = si;
+function Gi(e, t) {
   const { node: n } = e;
   let r = t();
-  return n?.comments?.length && (r = $i([Di([Pe, r]), Pe])), ["${", r, Mi, "}"];
+  return n?.comments?.length && (r = Mi([Ai([Be, r]), Be])), ["${", r, ki, "}"];
 }
-function S(e, t) {
+function k(e, t) {
   return e.map(
-    (n) => Si(n, t),
+    (n) => Gi(n, t),
     "expressions"
   );
 }
-function A(e, t, n, r = !1) {
-  return Ai(e, (a) => {
-    if (typeof a != "string")
-      return a;
-    const s = [], l = a.split(t);
+function S(e, t, n, r = !1) {
+  return Li(e, (o) => {
+    if (typeof o != "string")
+      return o;
+    const i = [], l = o.split(t);
     for (let u = 0; u < l.length; u++) {
       let E = l[u];
       if (u % 2 === 0) {
@@ -31,165 +31,173 @@ function A(e, t, n, r = !1) {
         if (E = E.replaceAll(/([\\`]|\${)/g, "\\$1"), r)
           for (const d of E.split(/(\n)/))
             d === `
-` ? s.push(Ti) : s.push(d);
+` ? i.push(Si) : i.push(d);
         else
-          s.push(E);
+          i.push(E);
       } else {
         const d = Number(E);
-        s.push(n[d]);
+        i.push(n[d]);
       }
     }
-    return s;
+    return i;
   });
 }
-function Li(e, t, n) {
+function Ni(e, t, n) {
   if (t === n) {
     e.unshift(t);
     return;
   }
-  let r = 0, i = e.length;
-  for (; r < i; ) {
-    const a = r + i >>> 1;
-    if (e[a] === n) {
+  let r = 0, s = e.length;
+  for (; r < s; ) {
+    const o = r + s >>> 1;
+    if (e[o] === n) {
       e.push(t);
       return;
     }
-    e[a] < t ? r = a + 1 : i = a;
+    e[o] < t ? r = o + 1 : s = o;
   }
   e.splice(r, 0, t);
 }
-const me = (() => {
+const he = (() => {
   const e = [...Array(26).keys()].map((t) => String.fromCharCode(t + 97)).concat([...Array(10).keys()].map((t) => `${t}`));
   return () => {
     let n = "";
     for (let r = 0; r < 16; ++r)
-      n += e[parseInt((Math.random() * e.length).toFixed(0), 10) % e.length];
+      n += e[Number.parseInt((Math.random() * e.length).toFixed(0), 10) % e.length];
     return n;
   };
 })();
 function L(e = "p", t = "") {
-  const n = me(), r = me(), i = Be(e), a = Be(t), s = (u) => `${e}${n}${u}${r}${t}`, l = new RegExp(
-    `${i}${n}(\\d+)${r}${a}`,
+  const n = he(), r = he(), s = qe(e), o = qe(t), i = (u) => `${e}${n}${u}${r}${t}`, l = new RegExp(
+    `${s}${n}(\\d+)${r}${o}`,
     "ig"
   );
   return {
-    createPlaceholder: s,
+    createPlaceholder: i,
     placeholderRegex: l
   };
 }
-function Be(e) {
+function qe(e) {
   return e.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
 }
-function $(e) {
+function D(e) {
   return `${e}Identifiers`;
 }
-function M(e) {
+function A(e) {
   return `${e}Comments`;
 }
-function D(e) {
+function T(e) {
   return `${e}Tags`;
 }
-function ki(e) {
+function Oi(e) {
   return `${e}Plugin`;
 }
-function N(e) {
+function O(e) {
   return `${e}Parser`;
 }
-const { line: qe, group: x, indent: je, softline: Ue } = T, Gi = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
-  const s = {
+const _ = "9ff2b366e8ca4c97b9aed1a29b5b94ed", { line: je, group: I, indent: Ue, softline: Re } = M, xi = async (e, t, n, r, { commentOrTag: s, embeddedOverrideOptions: o }) => {
+  const i = {
     ...r,
-    ...a
-  }, { node: l } = n, { createPlaceholder: u, placeholderRegex: E } = L("@p"), d = l.quasis.map(
+    ...o
+  }, { node: l } = n, { createPlaceholder: u, placeholderRegex: E } = L(
+    "@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 = S(n, t), _ = await e(f, {
-    ...s,
-    parser: s.embeddedCssParser ?? "scss"
-  }), o = A(_, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return x([
+  ), b = k(n, t), $ = await e(f, {
+    ...i,
+    parser: i.embeddedCssParser ?? "scss"
+  }), a = S(
+    $,
+    E,
+    b,
+    // https://github.com/prettier/prettier/blob/3bfabd012873e5022f341aca75566966d91870f1/src/language-js/embed/css.js#L52
+    !0
+  );
+  if (i.preserveEmbeddedExteriorWhitespaces?.includes(s))
+    return I([
       "`",
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [x(o)] : je([x(o)]),
+      i.noEmbeddedMultiLineIndentation?.includes(s) ? [I(a)] : Ue([I(a)]),
       p,
       "`"
     ]);
-  const h = c.length ? qe : Ue, v = p.length ? qe : Ue;
-  return x([
+  const h = c.length ? je : Re, v = p.length ? je : Re;
+  return I([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, x(o)] : je([h, x(o)]),
+    i.noEmbeddedMultiLineIndentation?.includes(s) ? [h, I(a)] : Ue([h, I(a)]),
     v,
     "`"
   ]);
-}, se = "embeddedCss", Ni = ["css"], Oi = ["css", "less", "scss"], xi = $(se), Re = M(se), Ce = D(se), Ii = N(se), Pi = {
-  [xi]: {
+}, re = "embeddedCss", Ii = ["css"], Pi = ["css", "less", "scss"], Bi = D(re), Ce = A(re), we = T(re), qi = O(re), ji = {
+  [Bi]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...Ni] }],
+    default: [{ value: [...Ii] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded CSS language.",
-    deprecated: `Please use \`${Re}\` or \`${Ce}\`.`
+    deprecated: `Please use \`${Ce}\` or \`${we}\`.`
   },
-  [Re]: {
+  [Ce]: {
     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."
   },
-  [Ce]: {
+  [we]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [] }],
+    default: [{ value: [_] }],
     description: "Tags that make their subsequent template literals be identified as embedded CSS language."
   },
-  [Ii]: {
+  [qi]: {
     category: "Embed",
     type: "choice",
     default: "scss",
     description: "The parser used to parse the embedded CSS language.",
-    choices: Oi.map((e) => ({
+    choices: Pi.map((e) => ({
       value: e,
       description: `Use the "${e}" parser.`
     }))
   }
-}, Bi = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, Ui = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: Gi,
-  language: se,
-  options: Pi
-}, Symbol.toStringTag, { value: "Module" })), { line: we, group: I, indent: Fe, softline: We } = T, qi = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
-  const s = {
+  embedder: xi,
+  language: re,
+  options: ji
+}, Symbol.toStringTag, { value: "Module" })), { line: Fe, group: P, indent: We, softline: ze } = M, Ri = async (e, t, n, r, { commentOrTag: s, embeddedOverrideOptions: o }) => {
+  const i = {
     ...r,
-    ...a
+    ...o
   }, { 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 = S(n, t), _ = await e(f, {
-    ...s,
-    parser: s.embeddedEsParser ?? "babel"
-  }), o = A(_, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return I([
+  ), b = k(n, t), $ = await e(f, {
+    ...i,
+    parser: i.embeddedEsParser ?? "babel"
+  }), a = S($, E, b);
+  if (i.preserveEmbeddedExteriorWhitespaces?.includes(s))
+    return P([
       "`",
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [I(o)] : Fe([I(o)]),
+      i.noEmbeddedMultiLineIndentation?.includes(s) ? [P(a)] : We([P(a)]),
       p,
       "`"
     ]);
-  const h = c.length ? we : We, v = p.length ? we : We;
-  return I([
+  const h = c.length ? Fe : ze, v = p.length ? Fe : ze;
+  return P([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, I(o)] : Fe([h, I(o)]),
+    i.noEmbeddedMultiLineIndentation?.includes(s) ? [h, P(a)] : We([h, P(a)]),
     v,
     "`"
   ]);
-}, re = "embeddedEs", ji = [
+}, oe = "embeddedEs", Ci = [
   "js",
   "jsx",
   "es",
@@ -198,394 +206,394 @@ const { line: qe, group: x, indent: je, softline: Ue } = T, Gi = async (e, t, n,
   "cjs",
   "pac",
   "javascript"
-], Ui = [
+], wi = [
   "babel",
   "babel-flow",
   "acorn",
   "espree",
   "flow",
   "meriyah"
-], Ri = $(re), ze = M(re), Ke = D(re), Ci = N(re), wi = {
-  [Ri]: {
+], Fi = D(oe), Ke = A(oe), Je = T(oe), Wi = O(oe), zi = {
+  [Fi]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...ji] }],
+    default: [{ value: [...Ci] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded ECMAScript/JavaScript language.",
-    deprecated: `Please use \`${ze}\` or \`${Ke}\`.`
+    deprecated: `Please use \`${Ke}\` or \`${Je}\`.`
   },
-  [ze]: {
+  [Ke]: {
     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."
   },
-  [Ke]: {
+  [Je]: {
     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."
   },
-  [Ci]: {
+  [Wi]: {
     category: "Embed",
     type: "choice",
     default: "babel",
     description: "The parser used to parse the embedded ECMASCript/JavaScript language.",
-    choices: Ui.map((e) => ({
+    choices: wi.map((e) => ({
       value: e,
       description: `Use the "${e}" parser.`
     }))
   }
-}, Fi = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, Ki = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: qi,
-  language: re,
-  options: wi
-}, Symbol.toStringTag, { value: "Module" })), { line: Je, group: P, indent: He, softline: Xe } = T, Wi = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
-  const s = {
+  embedder: Ri,
+  language: oe,
+  options: zi
+}, Symbol.toStringTag, { value: "Module" })), { line: He, group: B, indent: Xe, softline: Qe } = M, Ji = async (e, t, n, r, { commentOrTag: s, embeddedOverrideOptions: o }) => {
+  const i = {
     ...r,
-    ...a
+    ...o
   }, { 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 = S(n, t), _ = await e(f, {
-    ...s,
+  ), b = k(n, t), $ = await e(f, {
+    ...i,
     parser: "glsl-parser"
-  }), o = A(_, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return P([
+  }), a = S($, E, b);
+  if (i.preserveEmbeddedExteriorWhitespaces?.includes(s))
+    return B([
       "`",
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [P(o)] : He([P(o)]),
+      i.noEmbeddedMultiLineIndentation?.includes(s) ? [B(a)] : Xe([B(a)]),
       p,
       "`"
     ]);
-  const h = c.length ? Je : Xe, v = p.length ? Je : Xe;
-  return P([
+  const h = c.length ? He : Qe, v = p.length ? He : Qe;
+  return B([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, P(o)] : He([h, P(o)]),
+    i.noEmbeddedMultiLineIndentation?.includes(s) ? [h, B(a)] : Xe([h, B(a)]),
     v,
     "`"
   ]);
-}, Ee = "embeddedGlsl", zi = ["glsl", "shader"], Ki = $(Ee), Qe = M(Ee), Ye = D(Ee), Ji = {
-  [Ki]: {
+}, be = "embeddedGlsl", Hi = ["glsl", "shader"], Xi = D(be), Ye = A(be), Ve = T(be), Qi = {
+  [Xi]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...zi] }],
+    default: [{ value: [...Hi] }],
     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 \`${Qe}\` or \`${Ye}\`.`
+    deprecated: `Please use \`${Ye}\` or \`${Ve}\`.`
   },
-  [Qe]: {
+  [Ye]: {
     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."
   },
-  [Ye]: {
+  [Ve]: {
     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."
   }
-}, Hi = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, Yi = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: Wi,
-  language: Ee,
-  options: Ji
-}, Symbol.toStringTag, { value: "Module" })), { line: Ve, group: B, indent: Ze, softline: et } = T, Xi = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
-  const s = {
+  embedder: Ji,
+  language: be,
+  options: Qi
+}, Symbol.toStringTag, { value: "Module" })), { line: Ze, group: q, indent: et, softline: tt } = M, Vi = async (e, t, n, r, { commentOrTag: s, embeddedOverrideOptions: o }) => {
+  const i = {
     ...r,
-    ...a
+    ...o
   }, { 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 = S(n, t), _ = await e(f, {
-    ...s,
+  ), b = k(n, t), $ = await e(f, {
+    ...i,
     parser: "graphql"
-  }), o = A(_, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return B([
+  }), a = S($, E, b);
+  if (i.preserveEmbeddedExteriorWhitespaces?.includes(s))
+    return q([
       "`",
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [B(o)] : Ze([B(o)]),
+      i.noEmbeddedMultiLineIndentation?.includes(s) ? [q(a)] : et([q(a)]),
       p,
       "`"
     ]);
-  const h = c.length ? Ve : et, v = p.length ? Ve : et;
-  return B([
+  const h = c.length ? Ze : tt, v = p.length ? Ze : tt;
+  return q([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, B(o)] : Ze([h, B(o)]),
+    i.noEmbeddedMultiLineIndentation?.includes(s) ? [h, q(a)] : et([h, q(a)]),
     v,
     "`"
   ]);
-}, be = "embeddedGraphql", Qi = ["graphql", "gql"], Yi = $(be), tt = M(be), nt = D(be), Vi = {
-  [Yi]: {
+}, fe = "embeddedGraphql", Zi = ["graphql", "gql"], es = D(fe), nt = A(fe), it = T(fe), ts = {
+  [es]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...Qi] }],
+    default: [{ value: [...Zi] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded GraphQL language.",
-    deprecated: `Please use \`${tt}\` or \`${nt}\`.`
+    deprecated: `Please use \`${nt}\` or \`${it}\`.`
   },
-  [tt]: {
+  [nt]: {
     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."
   },
-  [nt]: {
+  [it]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [] }],
+    default: [{ value: [_] }],
     description: "Tags that make their subsequent template literals be identified as embedded GraphQL language."
   }
-}, Zi = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, ns = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: Xi,
-  language: be,
-  options: Vi
-}, Symbol.toStringTag, { value: "Module" })), { line: it, group: q, indent: st, softline: rt } = T, { mapDoc: es } = ii, ts = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
-  const s = {
+  embedder: Vi,
+  language: fe,
+  options: ts
+}, Symbol.toStringTag, { value: "Module" })), { line: st, group: j, indent: rt, softline: ot } = M, { mapDoc: is } = si, ss = async (e, t, n, r, { commentOrTag: s, embeddedOverrideOptions: o }) => {
+  const i = {
     ...r,
-    ...a
+    ...o
   }, { 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 = S(n, t), _ = await e(f, {
-    ...s,
-    parser: s.embeddedHtmlParser ?? "html"
-  }), o = es(_, (m) => {
+  ), b = k(n, t), $ = await e(f, {
+    ...i,
+    parser: i.embeddedHtmlParser ?? "html"
+  }), a = is($, (m) => {
     if (typeof m != "string")
       return m;
     const g = [], y = m.split(E);
-    for (let k = 0; k < y.length; k++) {
-      let G = y[k];
-      if (k % 2 === 0) {
-        if (!G)
+    for (let G = 0; G < y.length; G++) {
+      let N = y[G];
+      if (G % 2 === 0) {
+        if (!N)
           continue;
-        G = G.replaceAll(/([\\`]|\${)/g, "\\$1"), s.__embeddedInHtml && (G = G.replaceAll(/<\/(?=script\b)/gi, "<\\/")), g.push(G);
+        N = N.replaceAll(/([\\`]|\${)/g, "\\$1"), i.__embeddedInHtml && (N = N.replaceAll(/<\/(?=script\b)/gi, "<\\/")), g.push(N);
       } else {
-        const O = Number(G);
-        g.push(b[O]);
+        const x = Number(N);
+        g.push(b[x]);
       }
     }
     return g;
   });
-  if (s.htmlWhitespaceSensitivity === "strict" || // TODO: is css mode should be included here?
-  s.htmlWhitespaceSensitivity === "css" || s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return q([
+  if (i.htmlWhitespaceSensitivity === "strict" || // TODO: is css mode should be included here?
+  i.htmlWhitespaceSensitivity === "css" || i.preserveEmbeddedExteriorWhitespaces?.includes(s))
+    return j([
       "`",
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [q(o)] : st([q(o)]),
+      i.noEmbeddedMultiLineIndentation?.includes(s) ? [j(a)] : rt([j(a)]),
       p,
       "`"
     ]);
-  const h = c.length ? it : rt, v = p.length ? it : rt;
-  return q([
+  const h = c.length ? st : ot, v = p.length ? st : ot;
+  return j([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, q(o)] : st([h, q(o)]),
+    i.noEmbeddedMultiLineIndentation?.includes(s) ? [h, j(a)] : rt([h, j(a)]),
     v,
     "`"
   ]);
-}, oe = "embeddedHtml", ns = ["html", "xhtml"], is = ["html", "vue", "angular", "lwc"], ss = $(oe), ot = M(oe), at = D(oe), rs = N(oe), os = {
-  [ss]: {
+}, ae = "embeddedHtml", rs = ["html", "xhtml"], os = ["html", "vue", "angular", "lwc"], as = D(ae), at = A(ae), dt = T(ae), ds = O(ae), ls = {
+  [as]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...ns] }],
+    default: [{ value: [...rs] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded HTML language.",
-    deprecated: `Please use \`${ot}\` or \`${at}\`.`
+    deprecated: `Please use \`${at}\` or \`${dt}\`.`
   },
-  [ot]: {
+  [at]: {
     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."
   },
-  [at]: {
+  [dt]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [] }],
+    default: [{ value: [_] }],
     description: "Tags that make their subsequent template literals be identified as embedded HTML language."
   },
-  [rs]: {
+  [ds]: {
     category: "Embed",
     type: "choice",
     default: "html",
     description: "The parser used to parse the embedded HTML language.",
-    choices: is.map((e) => ({
+    choices: os.map((e) => ({
       value: e,
       description: `Use the "${e}" parser.`
     }))
   }
-}, as = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, cs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: ts,
-  language: oe,
-  options: os
-}, Symbol.toStringTag, { value: "Module" })), { line: dt, group: j, indent: lt, softline: ct } = T, ds = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
-  const s = {
+  embedder: ss,
+  language: ae,
+  options: ls
+}, Symbol.toStringTag, { value: "Module" })), { line: lt, group: U, indent: ct, softline: ut } = M, us = async (e, t, n, r, { commentOrTag: s, embeddedOverrideOptions: o }) => {
+  const i = {
     ...r,
-    ...a
+    ...o
   }, { 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 = S(n, t), _ = await e(f, {
-    ...s,
+  ), b = k(n, t), $ = await e(f, {
+    ...i,
     parser: "ini"
-  }), o = A(_, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return j([
+  }), a = S($, E, b);
+  if (i.preserveEmbeddedExteriorWhitespaces?.includes(s))
+    return U([
       "`",
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [j(o)] : lt([j(o)]),
+      i.noEmbeddedMultiLineIndentation?.includes(s) ? [U(a)] : ct([U(a)]),
       p,
       "`"
     ]);
-  const h = c.length ? dt : ct, v = p.length ? dt : ct;
-  return j([
+  const h = c.length ? lt : ut, v = p.length ? lt : ut;
+  return U([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, j(o)] : lt([h, j(o)]),
+    i.noEmbeddedMultiLineIndentation?.includes(s) ? [h, U(a)] : ct([h, U(a)]),
     v,
     "`"
   ]);
-}, fe = "embeddedIni", ls = ["ini", "cfg", "pro"], cs = $(fe), ut = M(fe), pt = D(fe), us = {
-  [cs]: {
+}, ye = "embeddedIni", ps = ["ini", "cfg", "pro"], gs = D(ye), pt = A(ye), gt = T(ye), ms = {
+  [gs]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...ls] }],
+    default: [{ value: [...ps] }],
     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 \`${ut}\` or \`${pt}\`.`
+    deprecated: `Please use \`${pt}\` or \`${gt}\`.`
   },
-  [ut]: {
+  [pt]: {
     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."
   },
-  [pt]: {
+  [gt]: {
     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."
   }
-}, ps = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, hs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: ds,
-  language: fe,
-  options: us
-}, Symbol.toStringTag, { value: "Module" })), { group: U, line: gt, softline: mt, indent: ht } = T, gs = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
-  const s = {
+  embedder: us,
+  language: ye,
+  options: ms
+}, Symbol.toStringTag, { value: "Module" })), { group: R, line: mt, softline: ht, indent: Et } = M, Es = async (e, t, n, r, { commentOrTag: s, embeddedOverrideOptions: o }) => {
+  const i = {
     ...r,
-    ...a
+    ...o
   }, { 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 = S(n, t), _ = await e(f, {
-    ...s,
+  ), b = k(n, t), $ = await e(f, {
+    ...i,
     parser: "java"
-  }), o = A(
-    _,
+  }), a = S(
+    $,
     E,
     b,
     !0
   );
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return U([
+  if (i.preserveEmbeddedExteriorWhitespaces?.includes(s))
+    return R([
       "`",
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [U(o)] : ht([U(o)]),
+      i.noEmbeddedMultiLineIndentation?.includes(s) ? [R(a)] : Et([R(a)]),
       p,
       "`"
     ]);
-  const h = c.length ? gt : mt, v = p.length ? gt : mt;
-  return U([
+  const h = c.length ? mt : ht, v = p.length ? mt : ht;
+  return R([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, U(o)] : ht([h, U(o)]),
+    i.noEmbeddedMultiLineIndentation?.includes(s) ? [h, R(a)] : Et([h, R(a)]),
     v,
     "`"
   ]);
-}, ye = "embeddedJava", ms = ["java"], hs = $(ye), Et = M(ye), bt = D(ye), Es = {
-  [hs]: {
+}, _e = "embeddedJava", bs = ["java"], fs = D(_e), bt = A(_e), ft = T(_e), ys = {
+  [fs]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...ms] }],
+    default: [{ value: [...bs] }],
     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 \`${Et}\` or \`${bt}\`.`
+    deprecated: `Please use \`${bt}\` or \`${ft}\`.`
   },
-  [Et]: {
+  [bt]: {
     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."
   },
-  [bt]: {
+  [ft]: {
     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."
   }
-}, bs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, _s = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: gs,
-  language: ye,
-  options: Es
-}, Symbol.toStringTag, { value: "Module" })), { line: ft, group: R, indent: yt, softline: _t } = T, fs = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
-  const s = {
+  embedder: Es,
+  language: _e,
+  options: ys
+}, Symbol.toStringTag, { value: "Module" })), { line: yt, group: C, indent: _t, softline: $t } = M, $s = async (e, t, n, r, { commentOrTag: s, embeddedOverrideOptions: o }) => {
+  const i = {
     ...r,
-    ...a
-  }, { node: l } = n, { createPlaceholder: u, placeholderRegex: E } = ys(), d = l.quasis.map(
+    ...o
+  }, { node: l } = n, { createPlaceholder: u, placeholderRegex: E } = vs(), 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 = S(n, t), _ = await e(f, {
-    ...s,
-    parser: s.embeddedJsonParser ?? "json"
-  }), o = A(_, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return R([
+  ), b = k(n, t), $ = await e(f, {
+    ...i,
+    parser: i.embeddedJsonParser ?? "json"
+  }), a = S($, E, b);
+  if (i.preserveEmbeddedExteriorWhitespaces?.includes(s))
+    return C([
       "`",
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [R(o)] : yt([R(o)]),
+      i.noEmbeddedMultiLineIndentation?.includes(s) ? [C(a)] : _t([C(a)]),
       p,
       "`"
     ]);
-  const h = c.length ? ft : _t, v = p.length ? ft : _t;
-  return R([
+  const h = c.length ? yt : $t, v = p.length ? yt : $t;
+  return C([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, R(o)] : yt([h, R(o)]),
+    i.noEmbeddedMultiLineIndentation?.includes(s) ? [h, C(a)] : _t([h, C(a)]),
     v,
     "`"
   ]);
 };
-function ys() {
-  const e = me(), t = me(), n = (i) => `'0${e}${i}${t}'`, r = new RegExp(
+function vs() {
+  const e = he(), t = he(), n = (s) => `'0${e}${s}${t}'`, r = new RegExp(
     `["']?0${e}(\\d+)${t}['"]?`,
     "ig"
   );
@@ -594,129 +602,129 @@ function ys() {
     placeholderRegex: r
   };
 }
-const ae = "embeddedJson", _s = ["json", "jsonl"], vs = ["json", "json5", "jsonc", "json-stringify"], $s = $(ae), vt = M(ae), $t = D(ae), Ds = N(ae), Ts = {
-  [$s]: {
+const de = "embeddedJson", Ds = ["json", "jsonl"], Ts = ["json", "json5", "jsonc", "json-stringify"], Ms = D(de), vt = A(de), Dt = T(de), As = O(de), Ss = {
+  [Ms]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [..._s] }],
+    default: [{ value: [...Ds] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded JSON language.",
-    deprecated: `Please use \`${vt}\` or \`${$t}\`.`
+    deprecated: `Please use \`${vt}\` or \`${Dt}\`.`
   },
   [vt]: {
     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."
   },
-  [$t]: {
+  [Dt]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [] }],
+    default: [{ value: [_] }],
     description: "Tags that make their subsequent template literals be identified as embedded JSON language."
   },
-  [Ds]: {
+  [As]: {
     category: "Embed",
     type: "choice",
     default: "json",
     description: "The parser used to parse the embedded JSON language.",
-    choices: vs.map((e) => ({
+    choices: Ts.map((e) => ({
       value: e,
       description: `Use the "${e}" parser.`
     }))
   }
-}, Ms = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, ks = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: fs,
-  language: ae,
-  options: Ts
-}, Symbol.toStringTag, { value: "Module" })), { line: Dt, group: C, indent: Tt, softline: Mt } = T, As = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
-  const s = {
+  embedder: $s,
+  language: de,
+  options: Ss
+}, Symbol.toStringTag, { value: "Module" })), { line: Tt, group: w, indent: Mt, softline: At } = M, Ls = async (e, t, n, r, { commentOrTag: s, embeddedOverrideOptions: o }) => {
+  const i = {
     ...r,
-    ...a
+    ...o
   }, { 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 = S(n, t), _ = await e(f, {
-    ...s,
+  ), b = k(n, t), $ = await e(f, {
+    ...i,
     parser: "JSONata"
-  }), o = A(_, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return C([
+  }), a = S($, E, b);
+  if (i.preserveEmbeddedExteriorWhitespaces?.includes(s))
+    return w([
       "`",
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [C(o)] : Tt([C(o)]),
+      i.noEmbeddedMultiLineIndentation?.includes(s) ? [w(a)] : Mt([w(a)]),
       p,
       "`"
     ]);
-  const h = c.length ? Dt : Mt, v = p.length ? Dt : Mt;
-  return C([
+  const h = c.length ? Tt : At, v = p.length ? Tt : At;
+  return w([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, C(o)] : Tt([h, C(o)]),
+    i.noEmbeddedMultiLineIndentation?.includes(s) ? [h, w(a)] : Mt([h, w(a)]),
     v,
     "`"
   ]);
-}, _e = "embeddedJsonata", Ss = ["jsonata"], Ls = $(_e), At = M(_e), St = D(_e), ks = {
-  [Ls]: {
+}, $e = "embeddedJsonata", Gs = ["jsonata"], Ns = D($e), St = A($e), kt = T($e), Os = {
+  [Ns]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...Ss] }],
+    default: [{ value: [...Gs] }],
     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 \`${At}\` or \`${St}\`.`
+    deprecated: `Please use \`${St}\` or \`${kt}\`.`
   },
-  [At]: {
+  [St]: {
     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."
   },
-  [St]: {
+  [kt]: {
     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."
   }
-}, Gs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, xs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: As,
-  language: _e,
-  options: ks
-}, Symbol.toStringTag, { value: "Module" })), { line: Lt, group: w, indent: kt, softline: Gt } = T, Ns = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
-  const s = {
+  embedder: Ls,
+  language: $e,
+  options: Os
+}, Symbol.toStringTag, { value: "Module" })), { line: Lt, group: F, indent: Gt, softline: Nt } = M, Is = async (e, t, n, r, { commentOrTag: s, embeddedOverrideOptions: o }) => {
+  const i = {
     ...r,
-    ...a
+    ...o
   }, { 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 = S(n, t), _ = await e(f, {
-    ...s,
+  ), b = k(n, t), $ = await e(f, {
+    ...i,
     parser: "latex-parser"
-  }), o = A(_, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return w([
+  }), a = S($, E, b);
+  if (i.preserveEmbeddedExteriorWhitespaces?.includes(s))
+    return F([
       "`",
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [w(o)] : kt([w(o)]),
+      i.noEmbeddedMultiLineIndentation?.includes(s) ? [F(a)] : Gt([F(a)]),
       p,
       "`"
     ]);
-  const h = c.length ? Lt : Gt, v = p.length ? Lt : Gt;
-  return w([
+  const h = c.length ? Lt : Nt, v = p.length ? Lt : Nt;
+  return F([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, w(o)] : kt([h, w(o)]),
+    i.noEmbeddedMultiLineIndentation?.includes(s) ? [h, F(a)] : Gt([h, F(a)]),
     v,
     "`"
   ]);
-}, ve = "embeddedLatex", Os = [
+}, ve = "embeddedLatex", Ps = [
   "latex",
   "tex",
   "aux",
@@ -725,965 +733,976 @@ const ae = "embeddedJson", _s = ["json", "jsonl"], vs = ["json", "json5", "jsonc
   "bib",
   "toc",
   "sty"
-], xs = $(ve), Nt = M(ve), Ot = D(ve), Is = {
-  [xs]: {
+], Bs = D(ve), Ot = A(ve), xt = T(ve), qs = {
+  [Bs]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...Os] }],
+    default: [{ value: [...Ps] }],
     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 \`${Nt}\` or \`${Ot}\`.`
+    deprecated: `Please use \`${Ot}\` or \`${xt}\`.`
   },
-  [Nt]: {
+  [Ot]: {
     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."
   },
-  [Ot]: {
+  [xt]: {
     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."
   }
-}, Ps = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, js = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: Ns,
+  embedder: Is,
   language: ve,
-  options: Is
-}, Symbol.toStringTag, { value: "Module" })), { line: xt, group: F, indent: It, softline: Pt } = T, Bs = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
-  const s = {
+  options: qs
+}, Symbol.toStringTag, { value: "Module" }));
+function It(e, t) {
+  var n = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var r = Object.getOwnPropertySymbols(e);
+    t && (r = r.filter(function(s) {
+      return Object.getOwnPropertyDescriptor(e, s).enumerable;
+    })), n.push.apply(n, r);
+  }
+  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) {
+      Us(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));
+    });
+  }
+  return e;
+}
+function Us(e, t, n) {
+  return t = Rs(t), t in e ? Object.defineProperty(e, t, { value: n, enumerable: !0, configurable: !0, writable: !0 }) : e[t] = n, e;
+}
+function Rs(e) {
+  var t = Cs(e, "string");
+  return typeof t == "symbol" ? t : String(t);
+}
+function Cs(e, t) {
+  if (typeof e != "object" || e === null) return e;
+  var n = e[Symbol.toPrimitive];
+  if (n !== void 0) {
+    var r = n.call(e, t);
+    if (typeof r != "object") return r;
+    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 s = typeof n == "string" ? [n] : n.raw, {
+      escapeSpecialCharacters: o = Array.isArray(n)
+    } = e;
+    let i = "";
+    for (let E = 0; E < s.length; E++) {
+      let d = s[E];
+      o && (d = d.replace(/\\\n[ \t]*/g, "").replace(/\\`/g, "`").replace(/\\\$/g, "$").replace(/\\\{/g, "{")), i += d, E < r.length && (i += r[E]);
+    }
+    const l = i.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;
+      }
+    }
+    if (u !== null) {
+      const E = u;
+      i = l.map((d) => d[0] === " " || d[0] === "	" ? d.slice(E) : d).join(`
+`);
+    }
+    return i = i.trim(), o && (i = i.replace(/\\n/g, `
+`)), i;
+  }
+}
+const { line: Bt, group: W, indent: qt, softline: jt } = M, ws = async (e, t, n, r, { commentOrTag: s, embeddedOverrideOptions: o }) => {
+  const i = {
     ...r,
-    ...a
+    ...o
   }, { 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 = S(n, t), _ = await e(f, {
-    ...s,
-    parser: s.embeddedMarkdownParser ?? "markdown",
-    __inJsTemplate: !0
-  }), o = A(_, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return F([
+  ), b = k(n, t), $ = await e(
+    // 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,
+      parser: i.embeddedMarkdownParser ?? "markdown",
+      // this will change the code fence delimiter from ``` to ~~~
+      // https://github.com/prettier/prettier/blob/1079517b32e5bb145afa7acba448af51f8a7b6e6/src/language-markdown/embed.js#L15
+      __inJsTemplate: !0
+    }
+  ), a = S(
+    $,
+    E,
+    b,
+    !0
+  );
+  if (i.preserveEmbeddedExteriorWhitespaces?.includes(s))
+    return W([
       "`",
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [F(o)] : It([F(o)]),
+      i.noEmbeddedMultiLineIndentation?.includes(s) ? [W(a)] : qt([W(a)]),
       p,
       "`"
     ]);
-  const h = c.length ? xt : Pt, v = p.length ? xt : Pt;
-  return F([
+  const h = c.length ? Bt : jt, v = p.length ? Bt : jt;
+  return W([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, F(o)] : It([h, F(o)]),
+    i.noEmbeddedMultiLineIndentation?.includes(s) ? [h, W(a)] : qt([h, W(a)]),
     v,
     "`"
   ]);
-}, de = "embeddedMarkdown", qs = ["md", "markdown"], js = ["markdown", "mdx", "remark"], Us = $(de), Bt = M(de), qt = D(de), Rs = N(de), Cs = {
-  [Us]: {
+}, le = "embeddedMarkdown", Fs = ["md", "markdown"], Ws = ["markdown", "mdx", "remark"], zs = D(le), Ut = A(le), Rt = T(le), Ks = O(le), Js = {
+  [zs]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...qs] }],
+    default: [{ value: [...Fs] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded Markdown language.",
-    deprecated: `Please use \`${Bt}\` or \`${qt}\`.`
+    deprecated: `Please use \`${Ut}\` or \`${Rt}\`.`
   },
-  [Bt]: {
+  [Ut]: {
     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."
   },
-  [qt]: {
+  [Rt]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [] }],
+    default: [{ value: [_] }],
     description: "Tags that make their subsequent template literals be identified as embedded Markdown language."
   },
-  [Rs]: {
+  [Ks]: {
     category: "Embed",
     type: "choice",
     default: "markdown",
     description: "The parser used to parse the embedded Markdown language.",
-    choices: js.map((e) => ({
+    choices: Ws.map((e) => ({
       value: e,
       description: `Use the "${e}" parser.`
     }))
   }
-}, ws = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, Hs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: Bs,
-  language: de,
-  options: Cs
-}, Symbol.toStringTag, { value: "Module" })), { line: jt, group: W, indent: Ut, softline: Rt } = T, Fs = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
-  const s = {
+  embedder: ws,
+  language: le,
+  options: Js
+}, Symbol.toStringTag, { value: "Module" })), { line: Ct, group: z, indent: wt, softline: Ft } = M, Xs = async (e, t, n, r, { commentOrTag: s, embeddedOverrideOptions: o }) => {
+  const i = {
     ...r,
-    ...a
+    ...o
   }, { 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 = S(n, t), _ = await e(f, {
-    ...s,
+  ), b = k(n, t), $ = await e(f, {
+    ...i,
     parser: "nginx"
-  }), o = A(_, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return W([
+  }), a = S($, E, b);
+  if (i.preserveEmbeddedExteriorWhitespaces?.includes(s))
+    return z([
       "`",
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [W(o)] : Ut([W(o)]),
+      i.noEmbeddedMultiLineIndentation?.includes(s) ? [z(a)] : wt([z(a)]),
       p,
       "`"
     ]);
-  const h = c.length ? jt : Rt, v = p.length ? jt : Rt;
-  return W([
+  const h = c.length ? Ct : Ft, v = p.length ? Ct : Ft;
+  return z([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, W(o)] : Ut([h, W(o)]),
+    i.noEmbeddedMultiLineIndentation?.includes(s) ? [h, z(a)] : wt([h, z(a)]),
     v,
     "`"
   ]);
-}, $e = "embeddedNginx", Ws = ["nginx"], zs = $($e), Ct = M($e), wt = D($e), Ks = {
-  [zs]: {
+}, De = "embeddedNginx", Qs = ["nginx"], Ys = D(De), Wt = A(De), zt = T(De), Vs = {
+  [Ys]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...Ws] }],
+    default: [{ value: [...Qs] }],
     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 \`${Ct}\` or \`${wt}\`.`
+    deprecated: `Please use \`${Wt}\` or \`${zt}\`.`
   },
-  [Ct]: {
+  [Wt]: {
     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."
   },
-  [wt]: {
+  [zt]: {
     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."
   }
-}, Js = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, Zs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: Fs,
-  language: $e,
-  options: Ks
-}, Symbol.toStringTag, { value: "Module" })), le = "embeddedNoop", Hs = $(le), Ft = M(le), Wt = D(le), Xs = {
-  [Hs]: {
+  embedder: Xs,
+  language: De,
+  options: Vs
+}, Symbol.toStringTag, { value: "Module" })), ce = "embeddedNoop", er = D(ce), Kt = A(ce), Jt = T(ce), tr = {
+  [er]: {
     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 \`${Ft}\` or \`${Wt}\`.`
+    deprecated: `Please use \`${Kt}\` or \`${Jt}\`.`
   },
-  [Ft]: {
+  [Kt]: {
     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."
   },
-  [Wt]: {
+  [Jt]: {
     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."
   }
-}, Qs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, nr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  language: le,
-  options: Xs
-}, Symbol.toStringTag, { value: "Module" })), { line: zt, group: z, indent: Kt, softline: Jt } = T, Ys = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
-  const s = {
+  language: ce,
+  options: tr
+}, Symbol.toStringTag, { value: "Module" })), { line: Ht, group: K, indent: Xt, softline: Qt } = M, ir = async (e, t, n, r, { commentOrTag: s, embeddedOverrideOptions: o }) => {
+  const i = {
     ...r,
-    ...a
+    ...o
   }, { 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 = S(n, t), _ = await e(f, {
-    ...s,
+  ), b = k(n, t), $ = await e(f, {
+    ...i,
     parser: "pegjs-parser"
-  }), o = A(_, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return z([
+  }), a = S($, E, b);
+  if (i.preserveEmbeddedExteriorWhitespaces?.includes(s))
+    return K([
       "`",
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [z(o)] : Kt([z(o)]),
+      i.noEmbeddedMultiLineIndentation?.includes(s) ? [K(a)] : Xt([K(a)]),
       p,
       "`"
     ]);
-  const h = c.length ? zt : Jt, v = p.length ? zt : Jt;
-  return z([
+  const h = c.length ? Ht : Qt, v = p.length ? Ht : Qt;
+  return K([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, z(o)] : Kt([h, z(o)]),
+    i.noEmbeddedMultiLineIndentation?.includes(s) ? [h, K(a)] : Xt([h, K(a)]),
     v,
     "`"
   ]);
-}, De = "embeddedPegjs", Vs = ["pegjs", "peggy", "peg"], Zs = $(De), Ht = M(De), Xt = D(De), er = {
-  [Zs]: {
+}, Te = "embeddedPegjs", sr = ["pegjs", "peggy", "peg"], rr = D(Te), Yt = A(Te), Vt = T(Te), or = {
+  [rr]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...Vs] }],
+    default: [{ value: [...sr] }],
     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 \`${Ht}\` or \`${Xt}\`.`
+    deprecated: `Please use \`${Yt}\` or \`${Vt}\`.`
   },
-  [Ht]: {
+  [Yt]: {
     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."
   },
-  [Xt]: {
+  [Vt]: {
     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."
   }
-}, tr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, ar = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: Ys,
-  language: De,
-  options: er
-}, Symbol.toStringTag, { value: "Module" })), { line: Qt, group: K, indent: Yt, softline: Vt } = T, nr = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
-  const s = {
+  embedder: ir,
+  language: Te,
+  options: or
+}, Symbol.toStringTag, { value: "Module" })), { line: Zt, group: J, indent: en, softline: tn } = M, dr = async (e, t, n, r, { commentOrTag: s, embeddedOverrideOptions: o }) => {
+  const i = {
     ...r,
-    ...a
+    ...o
   }, { 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 = S(n, t), _ = await e(f, {
-    ...s,
+  ), b = k(n, t), $ = await e(f, {
+    ...i,
     parser: "php"
-  }), o = A(_, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return K([
+  }), a = S($, E, b);
+  if (i.preserveEmbeddedExteriorWhitespaces?.includes(s))
+    return J([
       "`",
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [K(o)] : Yt([K(o)]),
+      i.noEmbeddedMultiLineIndentation?.includes(s) ? [J(a)] : en([J(a)]),
       p,
       "`"
     ]);
-  const h = c.length ? Qt : Vt, v = p.length ? Qt : Vt;
-  return K([
+  const h = c.length ? Zt : tn, v = p.length ? Zt : tn;
+  return J([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, K(o)] : Yt([h, K(o)]),
+    i.noEmbeddedMultiLineIndentation?.includes(s) ? [h, J(a)] : en([h, J(a)]),
     v,
     "`"
   ]);
-}, Te = "embeddedPhp", ir = ["php", "php5"], sr = $(Te), Zt = M(Te), en = D(Te), rr = {
-  [sr]: {
+}, Me = "embeddedPhp", lr = ["php", "php5"], cr = D(Me), nn = A(Me), sn = T(Me), ur = {
+  [cr]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...ir] }],
+    default: [{ value: [...lr] }],
     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 \`${Zt}\` or \`${en}\`.`
+    deprecated: `Please use \`${nn}\` or \`${sn}\`.`
   },
-  [Zt]: {
+  [nn]: {
     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."
   },
-  [en]: {
+  [sn]: {
     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."
   }
-}, or = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, pr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: nr,
-  language: Te,
-  options: rr
-}, Symbol.toStringTag, { value: "Module" })), { line: tn, group: J, indent: nn, softline: sn } = T, ar = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
-  const s = {
+  embedder: dr,
+  language: Me,
+  options: ur
+}, Symbol.toStringTag, { value: "Module" })), { line: rn, group: H, indent: on, softline: an } = M, gr = async (e, t, n, r, { commentOrTag: s, embeddedOverrideOptions: o }) => {
+  const i = {
     ...r,
-    ...a
+    ...o
   }, { 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 = S(n, t), _ = await e(f, {
-    ...s,
+  ), b = k(n, t), $ = await e(f, {
+    ...i,
     parser: "prisma-parse"
-  }), o = A(_, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return J([
+  }), a = S($, E, b);
+  if (i.preserveEmbeddedExteriorWhitespaces?.includes(s))
+    return H([
       "`",
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [J(o)] : nn([J(o)]),
+      i.noEmbeddedMultiLineIndentation?.includes(s) ? [H(a)] : on([H(a)]),
       p,
       "`"
     ]);
-  const h = c.length ? tn : sn, v = p.length ? tn : sn;
-  return J([
+  const h = c.length ? rn : an, v = p.length ? rn : an;
+  return H([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, J(o)] : nn([h, J(o)]),
+    i.noEmbeddedMultiLineIndentation?.includes(s) ? [h, H(a)] : on([h, H(a)]),
     v,
     "`"
   ]);
-}, Me = "embeddedPrisma", dr = ["prisma"], lr = $(Me), rn = M(Me), on = D(Me), cr = {
-  [lr]: {
+}, Ae = "embeddedPrisma", mr = ["prisma"], hr = D(Ae), dn = A(Ae), ln = T(Ae), Er = {
+  [hr]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...dr] }],
+    default: [{ value: [...mr] }],
     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 \`${rn}\` or \`${on}\`.`
+    deprecated: `Please use \`${dn}\` or \`${ln}\`.`
   },
-  [rn]: {
+  [dn]: {
     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."
   },
-  [on]: {
+  [ln]: {
     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."
   }
-}, ur = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, br = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: ar,
-  language: Me,
-  options: cr
-}, Symbol.toStringTag, { value: "Module" })), { line: an, group: H, indent: dn, softline: ln } = T, pr = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
-  const s = {
+  embedder: gr,
+  language: Ae,
+  options: Er
+}, Symbol.toStringTag, { value: "Module" })), { line: cn, group: X, indent: un, softline: pn } = M, fr = async (e, t, n, r, { commentOrTag: s, embeddedOverrideOptions: o }) => {
+  const i = {
     ...r,
-    ...a
+    ...o
   }, { 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 = S(n, t), _ = await e(f, {
-    ...s,
+  ), b = k(n, t), $ = await e(f, {
+    ...i,
     parser: "dot-properties"
-  }), o = A(_, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return H([
+  }), a = S($, E, b);
+  if (i.preserveEmbeddedExteriorWhitespaces?.includes(s))
+    return X([
       "`",
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [H(o)] : dn([H(o)]),
+      i.noEmbeddedMultiLineIndentation?.includes(s) ? [X(a)] : un([X(a)]),
       p,
       "`"
     ]);
-  const h = c.length ? an : ln, v = p.length ? an : ln;
-  return H([
+  const h = c.length ? cn : pn, v = p.length ? cn : pn;
+  return X([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, H(o)] : dn([h, H(o)]),
+    i.noEmbeddedMultiLineIndentation?.includes(s) ? [h, X(a)] : un([h, X(a)]),
     v,
     "`"
   ]);
-}, Ae = "embeddedProperties", gr = ["properties"], mr = $(Ae), cn = M(Ae), un = D(Ae), hr = {
-  [mr]: {
+}, Se = "embeddedProperties", yr = ["properties"], _r = D(Se), gn = A(Se), mn = T(Se), $r = {
+  [_r]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...gr] }],
+    default: [{ value: [...yr] }],
     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 \`${cn}\` or \`${un}\`.`
+    deprecated: `Please use \`${gn}\` or \`${mn}\`.`
   },
-  [cn]: {
+  [gn]: {
     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."
   },
-  [un]: {
+  [mn]: {
     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."
   }
-}, Er = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, vr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: pr,
-  language: Ae,
-  options: hr
-}, Symbol.toStringTag, { value: "Module" })), { group: X, line: pn, softline: gn, indent: mn } = T, br = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
-  const s = {
+  embedder: fr,
+  language: Se,
+  options: $r
+}, Symbol.toStringTag, { value: "Module" })), { group: Q, line: hn, softline: En, indent: bn } = M, Dr = async (e, t, n, r, { commentOrTag: s, embeddedOverrideOptions: o }) => {
+  const i = {
     ...r,
-    ...a
+    ...o
   }, { 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 = S(n, t), _ = await e(f, {
-    ...s,
+  ), b = k(n, t), $ = await e(f, {
+    ...i,
     parser: "pug"
-  }), o = A(
-    _,
+  }), a = S(
+    $,
     E,
     b,
     !0
   );
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return X([
+  if (i.preserveEmbeddedExteriorWhitespaces?.includes(s))
+    return Q([
       "`",
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [X(o)] : mn([X(o)]),
+      i.noEmbeddedMultiLineIndentation?.includes(s) ? [Q(a)] : bn([Q(a)]),
       p,
       "`"
     ]);
-  const h = c.length ? pn : gn, v = p.length ? pn : gn;
-  return X([
+  const h = c.length ? hn : En, v = p.length ? hn : En;
+  return Q([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, X(o)] : mn([h, X(o)]),
+    i.noEmbeddedMultiLineIndentation?.includes(s) ? [h, Q(a)] : bn([h, Q(a)]),
     v,
     "`"
   ]);
-}, Se = "embeddedPug", fr = ["pug", "jade"], yr = $(Se), hn = M(Se), En = D(Se), _r = {
-  [yr]: {
+}, ke = "embeddedPug", Tr = ["pug", "jade"], Mr = D(ke), fn = A(ke), yn = T(ke), Ar = {
+  [Mr]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...fr] }],
+    default: [{ value: [...Tr] }],
     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 \`${hn}\` or \`${En}\`.`
+    deprecated: `Please use \`${fn}\` or \`${yn}\`.`
   },
-  [hn]: {
+  [fn]: {
     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."
   },
-  [En]: {
+  [yn]: {
     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."
   }
-}, vr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, Sr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: br,
-  language: Se,
-  options: _r
-}, Symbol.toStringTag, { value: "Module" })), { line: bn, group: Q, indent: fn, softline: yn } = T, $r = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
-  const s = {
+  embedder: Dr,
+  language: ke,
+  options: Ar
+}, Symbol.toStringTag, { value: "Module" })), { line: _n, group: Y, indent: $n, softline: vn } = M, kr = async (e, t, n, r, { commentOrTag: s, embeddedOverrideOptions: o }) => {
+  const i = {
     ...r,
-    ...a
+    ...o
   }, { 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 = S(n, t), _ = await e(f, {
-    ...s,
-    parser: s.embeddedRubyParser ?? "ruby"
-  }), o = A(_, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return Q([
+  ), b = k(n, t), $ = await e(f, {
+    ...i,
+    parser: i.embeddedRubyParser ?? "ruby"
+  }), a = S($, E, b);
+  if (i.preserveEmbeddedExteriorWhitespaces?.includes(s))
+    return Y([
       "`",
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [Q(o)] : fn([Q(o)]),
+      i.noEmbeddedMultiLineIndentation?.includes(s) ? [Y(a)] : $n([Y(a)]),
       p,
       "`"
     ]);
-  const h = c.length ? bn : yn, v = p.length ? bn : yn;
-  return Q([
+  const h = c.length ? _n : vn, v = p.length ? _n : vn;
+  return Y([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, Q(o)] : fn([h, Q(o)]),
+    i.noEmbeddedMultiLineIndentation?.includes(s) ? [h, Y(a)] : $n([h, Y(a)]),
     v,
     "`"
   ]);
-}, ce = "embeddedRuby", Dr = ["ruby"], Tr = ["ruby", "rbs", "haml"], Mr = $(ce), _n = M(ce), vn = D(ce), Ar = N(ce), Sr = {
-  [Mr]: {
+}, ue = "embeddedRuby", Lr = ["ruby"], Gr = ["ruby", "rbs", "haml"], Nr = D(ue), Dn = A(ue), Tn = T(ue), Or = O(ue), xr = {
+  [Nr]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...Dr] }],
+    default: [{ value: [...Lr] }],
     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 \`${_n}\` or \`${vn}\`.`
+    deprecated: `Please use \`${Dn}\` or \`${Tn}\`.`
   },
-  [_n]: {
+  [Dn]: {
     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."
   },
-  [vn]: {
+  [Tn]: {
     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."
   },
-  [Ar]: {
+  [Or]: {
     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: Tr.map((e) => ({
+    choices: Gr.map((e) => ({
       value: e,
       description: `Use the "${e}" parser.`
     }))
   }
-}, Lr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, Ir = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: $r,
-  language: ce,
-  options: Sr
-}, Symbol.toStringTag, { value: "Module" })), { group: Y, line: $n, softline: Dn, indent: Tn } = T, kr = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
-  const s = {
+  embedder: kr,
+  language: ue,
+  options: xr
+}, Symbol.toStringTag, { value: "Module" })), { group: V, line: Mn, softline: An, indent: Sn } = M, Pr = async (e, t, n, r, { commentOrTag: s, embeddedOverrideOptions: o }) => {
+  const i = {
     ...r,
-    ...a
+    ...o
   }, { 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 = S(n, t), _ = await e(f, {
-    ...s,
+  ), b = k(n, t), $ = await e(f, {
+    ...i,
     parser: "sh"
-  }), o = A(
-    _,
+  }), a = S(
+    $,
     E,
     b,
     !0
   );
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return Y([
+  if (i.preserveEmbeddedExteriorWhitespaces?.includes(s))
+    return V([
       "`",
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [Y(o)] : Tn([Y(o)]),
+      i.noEmbeddedMultiLineIndentation?.includes(s) ? [V(a)] : Sn([V(a)]),
       p,
       "`"
     ]);
-  const h = c.length ? $n : Dn, v = p.length ? $n : Dn;
-  return Y([
+  const h = c.length ? Mn : An, v = p.length ? Mn : An;
+  return V([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, Y(o)] : Tn([h, Y(o)]),
+    i.noEmbeddedMultiLineIndentation?.includes(s) ? [h, V(a)] : Sn([h, V(a)]),
     v,
     "`"
   ]);
-}, Le = "embeddedSh", Gr = ["sh"], Nr = $(Le), Mn = M(Le), An = D(Le), Or = {
-  [Nr]: {
+}, Le = "embeddedSh", Br = ["sh"], qr = D(Le), kn = A(Le), Ln = T(Le), jr = {
+  [qr]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...Gr] }],
+    default: [{ value: [...Br] }],
     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 \`${Mn}\` or \`${An}\`.`
+    deprecated: `Please use \`${kn}\` or \`${Ln}\`.`
   },
-  [Mn]: {
+  [kn]: {
     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."
   },
-  [An]: {
+  [Ln]: {
     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."
   }
-}, xr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, Ur = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: kr,
+  embedder: Pr,
   language: Le,
-  options: Or
-}, Symbol.toStringTag, { value: "Module" }));
-function Sn(e, t) {
-  var n = Object.keys(e);
-  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);
-  }
-  return n;
-}
-function Ln(e) {
-  for (var t = 1; t < arguments.length; t++) {
-    var n = arguments[t] != null ? arguments[t] : {};
-    t % 2 ? Sn(Object(n), !0).forEach(function(r) {
-      Ir(e, r, n[r]);
-    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(n)) : Sn(Object(n)).forEach(function(r) {
-      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(n, r));
-    });
-  }
-  return e;
-}
-function Ir(e, t, n) {
-  return t = Pr(t), t in e ? Object.defineProperty(e, t, { value: n, enumerable: !0, configurable: !0, writable: !0 }) : e[t] = n, e;
-}
-function Pr(e) {
-  var t = Br(e, "string");
-  return typeof t == "symbol" ? t : String(t);
-}
-function Br(e, t) {
-  if (typeof e != "object" || e === null)
-    return e;
-  var n = e[Symbol.toPrimitive];
-  if (n !== void 0) {
-    var r = n.call(e, t || "default");
-    if (typeof r != "object")
-      return r;
-    throw new TypeError("@@toPrimitive must return a primitive value.");
-  }
-  return (t === "string" ? String : Number)(e);
-}
-const qr = si({});
-function si(e) {
-  return t.withOptions = (n) => si(Ln(Ln({}, 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]);
-    }
-    const l = s.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;
-      }
-    }
-    if (u !== null) {
-      const E = u;
-      s = l.map((d) => d[0] === " " || d[0] === "	" ? d.slice(E) : d).join(`
-`);
-    }
-    return s.trim().replace(/\\n/g, `
-`);
-  }
-}
-const { group: V, line: kn, softline: Gn, indent: Nn } = T, jr = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
-  const s = {
+  options: jr
+}, Symbol.toStringTag, { value: "Module" })), { group: Z, line: Gn, softline: Nn, indent: On } = M, Rr = async (e, t, n, r, { commentOrTag: s, embeddedOverrideOptions: o }) => {
+  const i = {
     ...r,
-    ...a
-  }, l = s.embeddedSqlPlugin ?? "prettier-plugin-sql", { node: u } = n, { createPlaceholder: E, placeholderRegex: d } = L(), c = u.quasis.map(
+    ...o
+  }, l = i.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
-  ), _ = S(n, t);
-  let o;
+  ), $ = k(n, t);
+  let a;
   if (l === "prettier-plugin-sql-cst") {
     const m = await e(b, {
-      ...s,
-      parser: s.embeddedSqlParser ?? "sqlite"
+      ...i,
+      parser: i.embeddedSqlParser ?? "sqlite"
     });
-    o = A(m, d, _);
+    a = S(m, d, $);
   } else {
-    const m = await e(qr(b), {
-      ...s,
+    const m = await e(ri(b), {
+      ...i,
       parser: "sql"
     });
-    o = A(
+    a = S(
       m,
       d,
-      _,
+      $,
       !0
     );
   }
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return V([
+  if (i.preserveEmbeddedExteriorWhitespaces?.includes(s))
+    return Z([
       "`",
       p,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [V(o)] : Nn([V(o)]),
+      i.noEmbeddedMultiLineIndentation?.includes(s) ? [Z(a)] : On([Z(a)]),
       f,
       "`"
     ]);
-  const h = p.length ? kn : Gn, v = f.length ? kn : Gn;
-  return V([
+  const h = p.length ? Gn : Nn, v = f.length ? Gn : Nn;
+  return Z([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, V(o)] : Nn([h, V(o)]),
+    i.noEmbeddedMultiLineIndentation?.includes(s) ? [h, Z(a)] : On([h, Z(a)]),
     v,
     "`"
   ]);
-}, ie = "embeddedSql", Ur = ["sql"], Rr = ["prettier-plugin-sql", "prettier-plugin-sql-cst"], Cr = [
+}, se = "embeddedSql", Cr = ["sql"], wr = ["prettier-plugin-sql", "prettier-plugin-sql-cst"], Fr = [
   "sqlite",
   "bigquery",
   "mysql",
   "mariadb",
   "postgresql"
-], wr = $(ie), On = M(ie), xn = D(ie), Fr = ki(ie), Wr = N(ie), zr = {
-  [wr]: {
+], Wr = D(se), xn = A(se), In = T(se), zr = Oi(se), Kr = O(se), Jr = {
+  [Wr]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...Ur] }],
+    default: [{ value: [...Cr] }],
     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 \`${On}\` or \`${xn}\`.`
+    deprecated: `Please use \`${xn}\` or \`${In}\`.`
   },
-  [On]: {
+  [xn]: {
     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."
   },
-  [xn]: {
+  [In]: {
     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."
   },
-  [Fr]: {
+  [zr]: {
     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: Rr.map((e) => ({
+    choices: wr.map((e) => ({
       value: e,
       description: `Use the "${e}" plugin.`
     }))
   },
-  [Wr]: {
+  [Kr]: {
     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: Cr.map((e) => ({
+    choices: Fr.map((e) => ({
       value: e,
       description: `Use the "${e}" parser.`
     }))
   }
-}, Kr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, Hr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: jr,
-  language: ie,
-  options: zr
-}, Symbol.toStringTag, { value: "Module" })), { line: In, group: Z, indent: Pn, softline: Bn } = T, Jr = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
-  const s = {
+  embedder: Rr,
+  language: se,
+  options: Jr
+}, Symbol.toStringTag, { value: "Module" })), { line: Pn, group: ee, indent: Bn, softline: qn } = M, Xr = async (e, t, n, r, { commentOrTag: s, embeddedOverrideOptions: o }) => {
+  const i = {
     ...r,
-    ...a
+    ...o
   }, { 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 = S(n, t), _ = await e(f, {
-    ...s,
+  ), b = k(n, t), $ = await e(f, {
+    ...i,
     parser: "toml"
-  }), o = A(
-    _,
+  }), a = S(
+    $,
     E,
     b,
     !0
   );
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return Z([
+  if (i.preserveEmbeddedExteriorWhitespaces?.includes(s))
+    return ee([
       "`",
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [Z(o)] : Pn([Z(o)]),
+      i.noEmbeddedMultiLineIndentation?.includes(s) ? [ee(a)] : Bn([ee(a)]),
       p,
       "`"
     ]);
-  const h = c.length ? In : Bn, v = p.length ? In : Bn;
-  return Z([
+  const h = c.length ? Pn : qn, v = p.length ? Pn : qn;
+  return ee([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, Z(o)] : Pn([h, Z(o)]),
+    i.noEmbeddedMultiLineIndentation?.includes(s) ? [h, ee(a)] : Bn([h, ee(a)]),
     v,
     "`"
   ]);
-}, ke = "embeddedToml", Hr = ["toml"], Xr = $(ke), qn = M(ke), jn = D(ke), Qr = {
-  [Xr]: {
+}, Ge = "embeddedToml", Qr = ["toml"], Yr = D(Ge), jn = A(Ge), Un = T(Ge), Vr = {
+  [Yr]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...Hr] }],
+    default: [{ value: [...Qr] }],
     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 \`${qn}\` or \`${jn}\`.`
+    deprecated: `Please use \`${jn}\` or \`${Un}\`.`
   },
-  [qn]: {
+  [jn]: {
     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."
   },
-  [jn]: {
+  [Un]: {
     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."
   }
-}, Yr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, Zr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: Jr,
-  language: ke,
-  options: Qr
-}, Symbol.toStringTag, { value: "Module" })), { line: Un, group: ee, indent: Rn, softline: Cn } = T, Vr = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
-  const s = {
+  embedder: Xr,
+  language: Ge,
+  options: Vr
+}, Symbol.toStringTag, { value: "Module" })), { line: Rn, group: te, indent: Cn, softline: wn } = M, eo = async (e, t, n, r, { commentOrTag: s, embeddedOverrideOptions: o }) => {
+  const i = {
     ...r,
-    ...a
+    ...o
   }, { 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 = S(n, t), _ = await e(f, {
-    ...s,
-    parser: s.embeddedTsParser ?? "typescript",
+  ), b = k(n, t), $ = await e(f, {
+    ...i,
+    parser: i.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 = A(_, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return ee([
+  }), a = S($, E, b);
+  if (i.preserveEmbeddedExteriorWhitespaces?.includes(s))
+    return te([
       "`",
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [ee(o)] : Rn([ee(o)]),
+      i.noEmbeddedMultiLineIndentation?.includes(s) ? [te(a)] : Cn([te(a)]),
       p,
       "`"
     ]);
-  const h = c.length ? Un : Cn, v = p.length ? Un : Cn;
-  return ee([
+  const h = c.length ? Rn : wn, v = p.length ? Rn : wn;
+  return te([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, ee(o)] : Rn([h, ee(o)]),
+    i.noEmbeddedMultiLineIndentation?.includes(s) ? [h, te(a)] : Cn([h, te(a)]),
     v,
     "`"
   ]);
-}, ue = "embeddedTs", Zr = [
+}, pe = "embeddedTs", to = [
   "ts",
   "tsx",
   "cts",
   "mts",
   "typescript"
-], eo = ["typescript", "babel-ts"], to = $(ue), wn = M(ue), Fn = D(ue), no = N(ue), io = {
-  [to]: {
+], no = ["typescript", "babel-ts"], io = D(pe), Fn = A(pe), Wn = T(pe), so = O(pe), ro = {
+  [io]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...Zr] }],
+    default: [{ value: [...to] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded TypeScript language.",
-    deprecated: `Please use \`${wn}\` or \`${Fn}\`.`
+    deprecated: `Please use \`${Fn}\` or \`${Wn}\`.`
   },
-  [wn]: {
+  [Fn]: {
     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."
   },
-  [Fn]: {
+  [Wn]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [] }],
+    default: [{ value: [_] }],
     description: "Tags that make their subsequent template literals be identified as embedded TypeScript language."
   },
-  [no]: {
+  [so]: {
     category: "Embed",
     type: "choice",
     default: "typescript",
     description: "The parser used to parse the embedded TypeScript language.",
-    choices: eo.map((e) => ({
+    choices: no.map((e) => ({
       value: e,
       description: `Use the "${e}" parser.`
     }))
   }
-}, so = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, oo = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: Vr,
-  language: ue,
-  options: io
-}, Symbol.toStringTag, { value: "Module" })), pe = "embeddedXml", { line: Wn, group: te, indent: zn, softline: Ne } = T, ro = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
-  const s = {
+  embedder: eo,
+  language: pe,
+  options: ro
+}, Symbol.toStringTag, { value: "Module" })), ge = "embeddedXml", { line: zn, group: ne, indent: Kn, softline: Oe } = M, ao = async (e, t, n, r, { commentOrTag: s, embeddedOverrideOptions: o }) => {
+  const i = {
     ...r,
-    ...a
+    ...o
   }, { node: l } = n, { createPlaceholder: u, placeholderRegex: E } = L(), d = l.quasis.map(
-    (g, y, { length: k }) => y === k - 1 ? g.value.cooked : g.value.cooked + u(y)
+    (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 = S(n, t), _ = [];
-  let o = 0;
-  for (; o !== void 0; ) {
-    const g = f.slice(o);
+  ), b = k(n, t), $ = [];
+  let a = 0;
+  for (; a !== void 0; ) {
+    const g = f.slice(a);
     if (g.length === 0)
       break;
-    o > 0 && s.xmlWhitespaceSensitivity !== "strict" && _.push(Ne), s.__embeddedXmlFragmentRecoverIndex?.splice(
+    a > 0 && i.xmlWhitespaceSensitivity !== "strict" && $.push(Oe), i.__embeddedXmlFragmentRecoverIndex?.splice(
       0,
-      s.__embeddedXmlFragmentRecoverIndex.length
+      i.__embeddedXmlFragmentRecoverIndex.length
     );
     let y = await e(g, {
-      ...s,
-      parser: pe
+      ...i,
+      parser: ge
     });
-    const [k, G] = s.__embeddedXmlFragmentRecoverIndex ?? [];
-    k === void 0 ? o = void 0 : G === void 0 ? o += k : (y = g.slice(k, G + 1), o += G + 1), _.push(y);
+    const [G, N] = i.__embeddedXmlFragmentRecoverIndex ?? [];
+    G === void 0 ? a = void 0 : N === void 0 ? a += G : (y = g.slice(G, N + 1), a += N + 1), $.push(y);
   }
-  const h = A(_, E, b);
-  if (s.xmlWhitespaceSensitivity === "strict" || s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return te([
+  const h = S($, E, b);
+  if (i.xmlWhitespaceSensitivity === "strict" || i.preserveEmbeddedExteriorWhitespaces?.includes(s))
+    return ne([
       "`",
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [te(h)] : zn([te(h)]),
+      i.noEmbeddedMultiLineIndentation?.includes(s) ? [ne(h)] : Kn([ne(h)]),
       p,
       "`"
     ]);
-  const v = c.length ? Wn : Ne, m = p.length ? Wn : Ne;
-  return te([
+  const v = c.length ? zn : Oe, m = p.length ? zn : Oe;
+  return ne([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [v, te(h)] : zn([v, te(h)]),
+    i.noEmbeddedMultiLineIndentation?.includes(s) ? [v, ne(h)] : Kn([v, ne(h)]),
     m,
     "`"
   ]);
-}, oo = ["xml", "opml", "rss", "svg"], ao = $(pe), Kn = M(pe), Jn = D(pe), lo = {
-  [ao]: {
+}, lo = ["xml", "opml", "rss", "svg"], co = D(ge), Jn = A(ge), Hn = T(ge), uo = {
+  [co]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...oo] }],
+    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 \`${Kn}\` or \`${Jn}\`.`
+    deprecated: `Please use \`${Jn}\` or \`${Hn}\`.`
   },
-  [Kn]: {
+  [Jn]: {
     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."
   },
-  [Jn]: {
+  [Hn]: {
     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."
   },
   /**
@@ -1697,7 +1716,7 @@ const { group: V, line: kn, softline: Gn, indent: Nn } = T, jr = async (e, t, n,
     description: "This option is read only and is used internally as a workaround to support xml fragments"
   }
 };
-function co(e) {
+function po(e) {
   const t = {
     loc: {
       start: {
@@ -1717,16 +1736,16 @@ function co(e) {
   );
   return Object.assign(n, t), n;
 }
-function Hn(e) {
+function Xn(e) {
   const t = {
     loc: {
       start: {
-        line: e.token.startLine ?? NaN,
-        column: e.token.startColumn ?? NaN
+        line: e.token.startLine ?? Number.NaN,
+        column: e.token.startColumn ?? Number.NaN
       },
       end: {
-        line: e.token.endLine ?? NaN,
-        column: e.token.endColumn ?? NaN
+        line: e.token.endLine ?? Number.NaN,
+        column: e.token.endColumn ?? Number.NaN
       }
     }
   }, n = new SyntaxError(
@@ -1737,22 +1756,22 @@ function Hn(e) {
   );
   return Object.assign(n, t), n;
 }
-const uo = {
+const go = {
   async parse(e, t) {
-    const { parse: n } = await import("@xml-tools/parser"), { lexErrors: r, parseErrors: i, cst: a } = n(e);
+    const { parse: n } = await import("@xml-tools/parser"), { lexErrors: r, parseErrors: s, cst: o } = n(e);
     if (r.length > 0) {
-      const s = r[0];
-      throw co(s);
+      const i = r[0];
+      throw po(i);
     }
-    if (i.length > 0) {
-      let s = !1;
-      for (const l of i) {
+    if (s.length > 0) {
+      let i = !1;
+      for (const l of s) {
         if (!["MismatchedTokenException", "NotAllInputParsedException"].includes(
           l.name
         ))
-          throw Hn(l);
+          throw Xn(l);
         if (l.message === "Expecting token of type --> OPEN <-- but found --> '' <--") {
-          s = !0;
+          i = !0;
           continue;
         }
         if (/Expecting token of type --> EOF <-- but found --> '[\s\S]+' <--/.test(
@@ -1775,139 +1794,139 @@ const uo = {
             t.__embeddedXmlFragmentRecoverIndex.length,
             l.token.startOffset,
             l.token.endOffset
-          ), s = !0;
+          ), i = !0;
           break;
         }
-        throw Hn(l);
+        throw Xn(l);
       }
-      s && ri(a);
+      i && ai(o);
     }
-    return a;
+    return o;
   },
   astFormat: "xml",
   locStart(e) {
     return e.location.startOffset;
   },
   locEnd(e) {
-    return e.location.endOffset ?? NaN;
+    return e.location.endOffset ?? Number.NaN;
   }
 };
-function ri(e) {
+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 (po(a)) {
-        if (Object.keys(a.children).length === 0) {
-          r.splice(i, 1), r.length === 0 && delete t[n];
+    for (let s = r.length - 1; s >= 0; --s) {
+      const o = r[s];
+      if (mo(o)) {
+        if (Object.keys(o.children).length === 0) {
+          r.splice(s, 1), r.length === 0 && delete t[n];
           continue;
         }
-        ri(a);
+        ai(o);
       }
     }
   }
 }
-function po(e) {
+function mo(e) {
   return "name" in e && "children" in e && "location" in e;
 }
-const go = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const ho = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: ro,
-  language: pe,
-  options: lo,
-  parser: uo
-}, Symbol.toStringTag, { value: "Module" })), { line: Xn, group: ne, indent: Qn, softline: Yn } = T, mo = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
-  const s = {
+  embedder: ao,
+  language: ge,
+  options: uo,
+  parser: go
+}, Symbol.toStringTag, { value: "Module" })), { line: Qn, group: ie, indent: Yn, softline: Vn } = M, Eo = async (e, t, n, r, { commentOrTag: s, embeddedOverrideOptions: o }) => {
+  const i = {
     ...r,
-    ...a
+    ...o
   }, { 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 = S(n, t), _ = await e(f, {
-    ...s,
+  ), b = k(n, t), $ = await e(f, {
+    ...i,
     parser: "yaml"
-  }), o = A(_, E, b);
-  if (s.preserveEmbeddedExteriorWhitespaces?.includes(i))
-    return ne([
+  }), a = S($, E, b);
+  if (i.preserveEmbeddedExteriorWhitespaces?.includes(s))
+    return ie([
       "`",
       c,
-      s.noEmbeddedMultiLineIndentation?.includes(i) ? [ne(o)] : Qn([ne(o)]),
+      i.noEmbeddedMultiLineIndentation?.includes(s) ? [ie(a)] : Yn([ie(a)]),
       p,
       "`"
     ]);
-  const h = c.length ? Xn : Yn, v = p.length ? Xn : Yn;
-  return ne([
+  const h = c.length ? Qn : Vn, v = p.length ? Qn : Vn;
+  return ie([
     "`",
-    s.noEmbeddedMultiLineIndentation?.includes(i) ? [h, ne(o)] : Qn([h, ne(o)]),
+    i.noEmbeddedMultiLineIndentation?.includes(s) ? [h, ie(a)] : Yn([h, ie(a)]),
     v,
     "`"
   ]);
-}, Ge = "embeddedYaml", ho = ["yaml", "yml"], Eo = $(Ge), Vn = M(Ge), Zn = D(Ge), bo = {
-  [Eo]: {
+}, Ne = "embeddedYaml", bo = ["yaml", "yml"], fo = D(Ne), Zn = A(Ne), ei = T(Ne), yo = {
+  [fo]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [...ho] }],
+    default: [{ value: [...bo] }],
     description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded YAML language.",
-    deprecated: `Please use \`${Vn}\` or \`${Zn}\`.`
+    deprecated: `Please use \`${Zn}\` or \`${ei}\`.`
   },
-  [Vn]: {
+  [Zn]: {
     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."
   },
-  [Zn]: {
+  [ei]: {
     category: "Embed",
     type: "string",
     array: !0,
-    default: [{ value: [] }],
+    default: [{ value: [_] }],
     description: "Tags that make their subsequent template literals be identified as embedded YAML language."
   }
-}, fo = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, _o = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: mo,
-  language: Ge,
-  options: bo
-}, Symbol.toStringTag, { value: "Module" })), ge = [], oi = {}, ai = {}, di = {}, yo = /* @__PURE__ */ Object.assign({
-  "./css/index.ts": Bi,
-  "./es/index.ts": Fi,
-  "./glsl/index.ts": Hi,
-  "./graphql/index.ts": Zi,
-  "./html/index.ts": as,
-  "./ini/index.ts": ps,
-  "./java/index.ts": bs,
-  "./json/index.ts": Ms,
-  "./jsonata/index.ts": Gs,
-  "./latex/index.ts": Ps,
-  "./markdown/index.ts": ws,
-  "./nginx/index.ts": Js,
-  "./noop/index.ts": Qs,
-  "./pegjs/index.ts": tr,
-  "./php/index.ts": or,
-  "./prisma/index.ts": ur,
-  "./properties/index.ts": Er,
-  "./pug/index.ts": vr,
-  "./ruby/index.ts": Lr,
-  "./sh/index.ts": xr,
-  "./sql/index.ts": Kr,
-  "./toml/index.ts": Yr,
-  "./ts/index.ts": so,
-  "./xml/index.ts": go,
-  "./yaml/index.ts": fo
+  embedder: Eo,
+  language: Ne,
+  options: yo
+}, Symbol.toStringTag, { value: "Module" })), me = [], di = {}, li = {}, ci = {}, $o = /* @__PURE__ */ Object.assign({
+  "./css/index.ts": Ui,
+  "./es/index.ts": Ki,
+  "./glsl/index.ts": Yi,
+  "./graphql/index.ts": ns,
+  "./html/index.ts": cs,
+  "./ini/index.ts": hs,
+  "./java/index.ts": _s,
+  "./json/index.ts": ks,
+  "./jsonata/index.ts": xs,
+  "./latex/index.ts": js,
+  "./markdown/index.ts": Hs,
+  "./nginx/index.ts": Zs,
+  "./noop/index.ts": nr,
+  "./pegjs/index.ts": ar,
+  "./php/index.ts": pr,
+  "./prisma/index.ts": br,
+  "./properties/index.ts": vr,
+  "./pug/index.ts": Sr,
+  "./ruby/index.ts": Ir,
+  "./sh/index.ts": Ur,
+  "./sql/index.ts": Hr,
+  "./toml/index.ts": Zr,
+  "./ts/index.ts": oo,
+  "./xml/index.ts": ho,
+  "./yaml/index.ts": _o
 });
-for (const { language: e, parser: t, embedder: n, options: r } of Object.values(yo))
-  Li(ge, e, le), t && (oi[e] = t), n && (ai[e] = n), Object.assign(di, r);
-const _o = "noEmbeddedIdentificationByComment", vo = "noEmbeddedIdentificationByTag", $o = "preserveEmbeddedExteriorWhitespaces", Do = "noEmbeddedMultiLineIndentation", To = "embeddedOverrides", na = {
-  ...di,
+for (const { language: e, parser: t, embedder: n, options: r } of Object.values($o))
+  Ni(me, e, ce), t && (di[e] = t), n && (li[e] = n), Object.assign(ci, r);
+const vo = "noEmbeddedIdentificationByComment", Do = "noEmbeddedIdentificationByTag", To = "preserveEmbeddedExteriorWhitespaces", Mo = "noEmbeddedMultiLineIndentation", Ao = "embeddedOverrides", sa = {
+  ...ci,
   /**
    * @deprecated Please use `embedded<Language>Comments` or `embedded<Language>Tags` to configure each embedded language, and you won't need this option anymore.
    */
-  [_o]: {
+  [vo]: {
     category: "Embed",
     type: "string",
     array: !0,
@@ -1918,7 +1937,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]: {
+  [Do]: {
     category: "Embed",
     type: "string",
     array: !0,
@@ -1926,38 +1945,38 @@ 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."
   },
-  [$o]: {
+  [To]: {
     category: "Embed",
     type: "string",
     array: !0,
     default: [{ value: [] }],
     description: "Preserves leading and trailing whitespaces in the formatting results for the specified comments or tags."
   },
-  [Do]: {
+  [Mo]: {
     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."
   },
-  [To]: {
+  [Ao]: {
     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."
   }
-}, Mo = {
+}, So = {
   // parsers from internal
-  ...hi.parsers,
-  ...Ei.parsers,
-  ...bi.parsers,
-  ...yi.parsers,
   ...fi.parsers,
+  ...yi.parsers,
+  ..._i.parsers,
+  ...vi.parsers,
+  ...$i.parsers,
   // parsers from this plugin
-  ...oi
+  ...di
 };
-var Ao = {
+var ko = {
   isEqual: !0,
   isMatchingKey: !0,
   isPromise: !0,
@@ -1966,24 +1985,24 @@ var Ao = {
   onCacheChange: !0,
   onCacheHit: !0,
   transformKey: !0
-}, So = Array.prototype.slice;
-function he(e) {
+}, Lo = 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]] : So.call(e, 0) : [];
+  return t ? t === 1 ? [e[0]] : t === 2 ? [e[0], e[1]] : t === 3 ? [e[0], e[1], e[2]] : Lo.call(e, 0) : [];
 }
-function Lo(e) {
+function Go(e) {
   var t = {};
   for (var n in e)
-    Ao[n] || (t[n] = e[n]);
+    ko[n] || (t[n] = e[n]);
   return t;
 }
-function ko(e) {
+function No(e) {
   return typeof e == "function" && e.isMemoized;
 }
-function Go(e, t) {
+function Oo(e, t) {
   return e === t || e !== e && t !== t;
 }
-function ei(e, t) {
+function ti(e, t) {
   var n = {};
   for (var r in e)
     n[r] = e[r];
@@ -1991,7 +2010,7 @@ function ei(e, t) {
     n[r] = t[r];
   return n;
 }
-var No = (
+var xo = (
   /** @class */
   function() {
     function e(t) {
@@ -2016,168 +2035,168 @@ var No = (
        */
       get: function() {
         return {
-          keys: he(this.keys),
+          keys: Ee(this.keys),
           size: this.size,
-          values: he(this.values)
+          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)
+      var n = this.options, r = n.isMatchingKey, s = n.maxSize, o = this.keys, i = o.length;
+      if (!i)
         return -1;
-      if (r(a[0], t))
+      if (r(o[0], t))
         return 0;
-      if (i > 1) {
-        for (var l = 1; l < s; l++)
-          if (r(a[l], t))
+      if (s > 1) {
+        for (var l = 1; l < i; l++)
+          if (r(o[l], t))
             return l;
       }
       return -1;
     }, e.prototype._getKeyIndexForMany = function(t) {
-      var n = this.options.isEqual, r = this.keys, i = r.length;
-      if (!i)
+      var n = this.options.isEqual, r = this.keys, s = r.length;
+      if (!s)
         return -1;
-      if (i === 1)
+      if (s === 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++)
+      var o = t.length, i, l;
+      if (o > 1) {
+        for (var u = 0; u < s; u++)
+          if (i = r[u], i.length === o) {
+            for (l = 0; l < o && n(i[l], t[l]); l++)
               ;
-            if (l === a)
+            if (l === o)
               return u;
           }
       } else
-        for (var u = 0; u < i; u++)
-          if (s = r[u], s.length === a && n(s[0], t[0]))
+        for (var u = 0; u < s; u++)
+          if (i = r[u], i.length === o && n(i[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)
+      var r = n[0], s = r.length;
+      if (t.length !== s)
         return -1;
-      var a = this.options.isEqual;
-      if (i > 1) {
-        for (var s = 0; s < i; s++)
-          if (!a(r[s], t[s]))
+      var o = this.options.isEqual;
+      if (s > 1) {
+        for (var i = 0; i < s; i++)
+          if (!o(r[i], t[i]))
             return -1;
         return 0;
       }
-      return a(r[0], t[0]) ? 0 : -1;
+      return o(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;
+      for (var s = this.keys, o = this.values, i = s.length, l = r; l--; )
+        s[l + 1] = s[l], o[l + 1] = o[l];
+      s[0] = t, o[0] = n;
       var u = this.options.maxSize;
-      s === u && r === s ? (i.pop(), a.pop()) : r >= u && (i.length = a.length = u);
+      i === u && r === i ? (s.pop(), o.pop()) : r >= u && (s.length = o.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];
+      var n = this, r = this.options, s = r.onCacheChange, o = r.onCacheHit, i = 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;
+        return n.shouldUpdateOnHit && o(n, n.options, t), n.shouldUpdateOnChange && s(n, n.options, t), u;
       }, function(u) {
-        var E = n.getKeyIndex(s);
+        var E = n.getKeyIndex(i);
         throw E !== -1 && (n.keys.splice(E, 1), n.values.splice(E, 1)), u;
       });
     }, e;
   }()
 );
-function li(e, t) {
-  if (t === void 0 && (t = {}), ko(e))
-    return li(e.fn, ei(e.options, t));
+function ui(e, t) {
+  if (t === void 0 && (t = {}), No(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 ? Go : 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 = ei({
+  var n = t.isEqual, r = n === void 0 ? Oo : n, s = t.isMatchingKey, o = t.isPromise, i = o === void 0 ? !1 : o, 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,
+    isMatchingKey: s,
+    isPromise: i,
     maxSize: u,
     onCacheAdd: E,
     onCacheChange: d,
     onCacheHit: c,
     transformKey: p
-  }, Lo(t)), b = new No(f), _ = b.keys, o = b.values, h = b.canTransformKey, v = b.shouldCloneArguments, m = b.shouldUpdateOnAdd, g = b.shouldUpdateOnChange, y = b.shouldUpdateOnHit, k = function() {
-    var G = v ? he(arguments) : arguments;
-    h && (G = p(G));
-    var O = _.length ? b.getKeyIndex(G) : -1;
-    if (O !== -1)
-      y && c(b, f, k), O && (b.orderByLru(_[O], o[O], O), g && d(b, f, k));
+  }, Go(t)), b = new xo(f), $ = b.keys, a = 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], a[x], x), g && d(b, f, G));
     else {
-      var gi = e.apply(this, arguments), mi = v ? G : he(arguments);
-      b.orderByLru(mi, gi, _.length), s && b.updateAsyncCache(k), m && E(b, f, k), g && d(b, f, k);
+      var Ei = e.apply(this, arguments), bi = v ? N : Ee(arguments);
+      b.orderByLru(bi, Ei, $.length), i && b.updateAsyncCache(G), m && E(b, f, G), g && d(b, f, G);
     }
-    return o[0];
+    return a[0];
   };
-  return k.cache = b, k.fn = e, k.isMemoized = !0, k.options = f, k;
+  return G.cache = b, G.fn = e, G.isMemoized = !0, G.options = f, G;
 }
-const Oo = /("(?:\\?[^])*?")|(\/\/.*)|(\/\*[^]*?\*\/)/g, xo = /("(?:\\?[^])*?")|(,\s*)(?=]|})/g, Ie = {
+const Io = /("(?:\\?[^])*?")|(\/\/.*)|(\/\*[^]*?\*\/)/g, Po = /("(?:\\?[^])*?")|(,\s*)(?=]|})/g, Pe = {
   parse: (e) => {
     e = String(e);
     try {
       return JSON.parse(e);
     } catch {
-      return JSON.parse(e.replace(Oo, "$1").replace(xo, "$1"));
+      return JSON.parse(e.replace(Io, "$1").replace(Po, "$1"));
     }
   }
-}, { label: Io } = T;
-async function ti(e) {
+}, { label: Bo } = M;
+async function ni(e) {
   try {
     const { readFile: t } = await import("node:fs/promises"), n = await t(e, { encoding: "utf-8" });
-    return Ie.parse(n);
+    return Pe.parse(n);
   } catch {
   }
 }
-const Po = /* @__PURE__ */ new URL(
+const qo = /* @__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);')}`
-), Bo = /* @__PURE__ */ new URL(
+), jo = /* @__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 qo(e) {
+async function Uo(e) {
   const { Worker: t } = await import("node:worker_threads");
   return new Promise((n) => {
-    const r = new t(Po, {
+    const r = new t(qo, {
       workerData: {
         absolutePath: e
       }
     });
-    r.once("message", (i) => {
-      n(i);
-    }), r.once("error", (i) => {
-      console.error(i), n(void 0);
+    r.once("message", (s) => {
+      n(s);
+    }), r.once("error", (s) => {
+      console.error(s), n(void 0);
     });
   });
 }
-async function jo(e) {
+async function Ro(e) {
   const { Worker: t } = await import("node:worker_threads");
   return new Promise((n) => {
-    const r = new t(Bo, {
+    const r = new t(jo, {
       workerData: {
         absolutePath: e,
         importMetaUrl: import.meta.url
       }
     });
-    r.once("message", (i) => {
-      n(i);
-    }), r.once("error", (i) => {
-      console.error(i), n(void 0);
+    r.once("message", (s) => {
+      n(s);
+    }), r.once("error", (s) => {
+      console.error(s), n(void 0);
     });
   });
 }
-const Uo = li(
+const Co = ui(
   async (e, t) => {
-    const { isAbsolute: n, dirname: r, resolve: i } = await import("node:path");
+    const { isAbsolute: n, dirname: r, resolve: s } = await import("node:path");
     if (n(e))
       return e;
-    const a = await vi(t);
-    let s;
-    return typeof a != "string" ? s = process.env.PWD ?? process.cwd() : s = r(a), i(s, e);
+    const o = await Ti(t);
+    let i;
+    return typeof o != "string" ? i = process.env.PWD ?? process.cwd() : i = r(o), s(i, e);
   }
-), Ro = async (e, t) => {
+), wo = async (e, t) => {
   let n;
   try {
     n = (await import("node:path")).extname(
@@ -2185,71 +2204,74 @@ const Uo = li(
     );
   } catch {
     try {
-      return Ie.parse(e);
+      return Pe.parse(e);
     } catch {
       console.error("Failed to parse embeddedOverrides as a json object");
       return;
     }
   }
-  const r = Uo(
+  const r = Co(
     e,
     t
   );
   if (n === ".json" || n === ".jsonc") {
-    const i = await r, a = await ti(i);
-    if (a !== void 0)
-      return a;
-    console.error(`Failed to parse the json file: ${i}`);
+    const s = await r, o = await ni(s);
+    if (o !== void 0)
+      return o;
+    console.error(`Failed to parse the json file: ${s}`);
     return;
   }
   if (n === ".mjs" || n === ".cjs" || n === ".js") {
-    const i = await r, a = await qo(i);
-    if (a !== void 0)
-      return a;
-    console.error(`Failed to parse the js module file: ${i}`);
+    const s = await r, o = await Uo(s);
+    if (o !== void 0)
+      return o;
+    console.error(`Failed to parse the js module file: ${s}`);
     return;
   }
   if (n === ".mts" || n === ".cts" || n === ".ts") {
-    const i = await r, a = await jo(i);
-    if (a !== void 0)
-      return a;
-    console.error(`Failed to parse the ts module file: ${i}`);
+    const s = await r, o = await Ro(s);
+    if (o !== void 0)
+      return o;
+    console.error(`Failed to parse the ts module file: ${s}`);
     return;
   }
   if (n === "") {
-    const i = await r, a = await ti(i);
-    if (a !== void 0)
-      return a;
+    const s = await r, o = await ni(s);
+    if (o !== void 0)
+      return o;
   }
   try {
-    return Ie.parse(e);
+    return Pe.parse(e);
   } catch {
     console.error("Failed to parse embeddedOverrides as a json object");
   }
 };
-async function Co(e, {
+async function Fo(e, {
   commentOrTag: t,
   kind: n,
   filepath: r
 }) {
   if (e === void 0)
     return;
-  const i = await Ro(
+  const s = await wo(
     e,
     r
   );
-  if (i !== void 0)
+  if (s !== void 0)
     for (const {
-      [`${n}s`]: a,
-      identifiers: s,
+      [`${n}s`]: o,
+      identifiers: i,
       options: l
-    } of i) {
-      const u = a ?? [];
-      if (u.length === 0 && s?.includes(t) || u.includes(t))
+    } of s) {
+      const u = o ?? [];
+      if (u.length === 0 && i?.includes(t) || u.includes(t))
         return l;
     }
 }
-const wo = /* @__PURE__ */ (() => {
+function* pi(e) {
+  yield e, e.type === "CallExpression" && (yield* pi(e.callee));
+}
+const Wo = /* @__PURE__ */ (() => {
   const e = /* @__PURE__ */ new Set([
     "start",
     "end",
@@ -2260,26 +2282,31 @@ const wo = /* @__PURE__ */ (() => {
     "decorators"
   ]);
   return (t, n, r) => {
-    let i;
+    let s;
     try {
-      const s = r(`${n}\`\``);
-      if (s instanceof Promise)
+      const i = r(`${n}\`\``);
+      if (i instanceof Promise)
         throw new TypeError("Async parse function hasn't been supported yet.");
-      i = s;
+      s = i;
     } catch {
       return !1;
     }
-    if (i.type === "File" && (i = i.program), !(i.type === "Program" && i.body[0]?.type === "ExpressionStatement"))
+    if (s.type === "File" && (s = s.program), !(s.type === "Program" && s.body[0]?.type === "ExpressionStatement"))
       return !1;
-    const a = i.body[0]?.expression;
-    return a?.type !== "TaggedTemplateExpression" ? !1 : !!ui(
-      t,
-      a.tag,
-      e
-    );
+    const o = s.body[0]?.expression;
+    if (o?.type !== "TaggedTemplateExpression")
+      return !1;
+    for (const i of pi(t))
+      if (mi(
+        i,
+        o.tag,
+        e
+      ))
+        return !0;
+    return !1;
   };
 })();
-function Fo({
+function zo({
   node: e,
   parent: t
 }) {
@@ -2296,69 +2323,64 @@ function Fo({
     // babel, babel-flow, babel-ts
   ].includes(r.type) || !r.leading)
     return;
-  const i = r.value;
-  if (i.length > 1 && i.startsWith(" ") && i.endsWith(" "))
-    return i.slice(1, -1);
+  const s = r.value;
+  if (s.length > 1 && s.startsWith(" ") && s.endsWith(" "))
+    return s.slice(1, -1);
 }
-function Wo({
+function Ko({
   parent: e
 }) {
   if (e?.type === "TaggedTemplateExpression")
     return e.tag.type === "Identifier" ? e.tag.name : e.tag;
 }
-function zo(e, t) {
-  const n = /* @__PURE__ */ (() => {
-    let r;
-    return () => (r === void 0 && (r = !(e.noEmbeddedIdentificationByComment?.includes(t) ?? !1)), r);
-  })();
-  return function* (r) {
-    const i = e[M(r)] ?? [];
-    i.length === 0 && n() ? yield* e[$(r)] ?? [] : yield* i;
+function Jo(e, t) {
+  return e.noEmbeddedIdentificationByComment?.includes(t) ?? !1 ? function* (r) {
+  } : function* (r) {
+    const s = e[A(r)] ?? [_];
+    s[0] === _ ? yield* e[D(r)] ?? [] : yield* s ?? [];
   };
 }
-function ni(e, t) {
-  if (typeof t == "string") {
-    const n = /* @__PURE__ */ (() => {
-      let r;
-      return () => (r === void 0 && (r = !(e.noEmbeddedIdentificationByTag?.includes(t) ?? !1)), r);
-    })();
-    return function* (r) {
-      const i = e[D(r)] ?? [];
-      i.length === 0 && n() ? yield* e[$(r)] ?? [] : yield* i;
-    };
-  }
-  return function* (n) {
-    const r = e[D(n)] ?? [];
-    if (r.length === 0) {
-      const { noEmbeddedIdentificationByTag: i } = e;
-      for (const a of e[$(n)] ?? [])
-        i?.includes(a) || (yield a);
+function ii(e, t) {
+  return typeof t == "string" ? e.noEmbeddedIdentificationByTag?.includes(t) ?? !1 ? function* (r) {
+  } : function* (r) {
+    const s = e[T(r)] ?? [
+      _
+    ];
+    s[0] === _ ? yield* e[D(r)] ?? [] : yield* s ?? [];
+  } : function* (n) {
+    const r = e[T(n)] ?? [
+      _
+    ];
+    if (r[0] === _) {
+      const { noEmbeddedIdentificationByTag: s } = e;
+      for (const o of e[D(n)] ?? [])
+        s?.includes(o) || (yield o);
     } else
       yield* r;
   };
 }
-function Oe(e, t, n, r, i) {
-  const a = ai[t];
-  if (!a)
+function xe(e, t, n, r, s) {
+  const o = li[t];
+  if (!o)
     return null;
   if (e.quasis.length === 1 && e.quasis[0]?.value.raw.trim() === "")
     return "``";
-  const s = Co(
-    i.embeddedOverrides,
+  const i = Fo(
+    s.embeddedOverrides,
     {
       commentOrTag: n,
       kind: r,
-      filepath: i.filepath
+      filepath: s.filepath
     }
   );
   return async (...l) => {
     try {
-      const u = await a(...l, {
+      const u = await o(...l, {
         commentOrTag: n,
         kind: r,
-        embeddedOverrideOptions: await s
+        embeddedOverrideOptions: await i
       });
-      return Io(
+      return Bo(
         {
           embed: !0,
           ...u.label
@@ -2370,83 +2392,83 @@ function Oe(e, t, n, r, i) {
     }
   };
 }
-function ci(e, t, n) {
-  return Object.is(e, t) ? !0 : e === null || t === null ? !1 : Array.isArray(e) ? Ko(e, t, n) : typeof e == "object" ? ui(e, t, n) : !1;
+function gi(e, t, n) {
+  return Object.is(e, t) ? !0 : e === null || t === null ? !1 : Array.isArray(e) ? Ho(e, t, n) : typeof e == "object" ? mi(e, t, n) : !1;
 }
-function Ko(e, t, n) {
+function Ho(e, t, n) {
   const r = e.length;
   if (r !== t.length)
     return !1;
-  for (let i = 0; i < r; i++)
-    if (!ci(e[i], t[i], n))
+  for (let s = 0; s < r; s++)
+    if (!gi(e[s], t[s], n))
       return !1;
   return !0;
 }
-function ui(e, t, n) {
+function mi(e, t, n) {
   for (const r of Object.keys(e))
-    if (!n?.has(r) && !(Object.prototype.hasOwnProperty.call(t, r) && ci(e[r], t[r], n)))
+    if (!n?.has(r) && !(Object.prototype.hasOwnProperty.call(t, r) && gi(e[r], t[r], n)))
       return !1;
   return !0;
 }
-const { estree: pi } = _i, { embed: xe } = pi, Jo = (e, t) => {
+const { estree: hi } = Di, { embed: Ie } = hi, Xo = (e, t) => {
   const { node: n } = e;
-  if (n.type !== "TemplateLiteral" || n.quasis.some(({ value: { cooked: a } }) => a === null))
+  if (n.type !== "TemplateLiteral" || n.quasis.some(({ value: { cooked: o } }) => o === null))
     return null;
-  const r = Fo(e);
+  const r = zo(e);
   if (typeof r == "string") {
-    const a = zo(
+    const o = Jo(
       t,
       r
     );
-    for (const s of ge) {
+    for (const i of me) {
       let l = !1;
-      for (const u of a(
-        s
+      for (const u of o(
+        i
       ))
         if (r === u) {
           l = !0;
           break;
         }
       if (l)
-        return Oe(
+        return xe(
           n,
-          s,
+          i,
           r,
           "comment",
           t
         );
     }
-    return xe?.(e, t) ?? null;
+    return Ie?.(e, t) ?? null;
   }
-  const i = Wo(e);
-  if (typeof i == "string") {
-    const a = ni(t, i);
-    for (const s of ge) {
+  const s = Ko(e);
+  if (typeof s == "string") {
+    const o = ii(t, s);
+    for (const i of me) {
       let l = !1;
-      for (const u of a(s))
-        if (i === u) {
+      for (const u of o(i))
+        if (s === u) {
           l = !0;
           break;
         }
       if (l)
-        return Oe(n, s, i, "tag", t);
+        return xe(n, i, s, "tag", t);
     }
-    return xe?.(e, t) ?? null;
+    return Ie?.(e, t) ?? null;
   }
-  if (i !== void 0) {
-    const a = (l) => Mo[t.parser].parse(
+  if (s !== void 0) {
+    const o = (l) => So[t.parser].parse(
       l,
       t
-    ), s = ni(t);
-    for (const l of ge) {
+    ), i = ii(t);
+    for (const l of me) {
       let u;
-      for (const E of s(l))
-        if (wo(i, E, a)) {
+      for (const E of i(l))
+        if (Wo(s, E, o)) {
           u = E;
           break;
         }
       if (u !== void 0)
-        return Oe(
+        return xe(
           n,
           l,
           u,
@@ -2455,15 +2477,15 @@ const { estree: pi } = _i, { embed: xe } = pi, Jo = (e, t) => {
         );
     }
   }
-  return xe?.(e, t) ?? null;
-}, ia = {
+  return Ie?.(e, t) ?? null;
+}, ra = {
   estree: {
-    ...pi,
-    embed: Jo
+    ...hi,
+    embed: Xo
   }
 };
 export {
-  na as options,
-  Mo as parsers,
-  ia as printers
+  sa as options,
+  So as parsers,
+  ra as printers
 };