prettier-plugin-embed 0.5.1 → 0.6.0

package/dist/index.js

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