prettier-plugin-embed 0.4.10 → 0.4.11

package/dist/index.js

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