npm - prettier-plugin-embed - Versions diffs - 0.5.0 → 0.6.0 - Mend

prettier-plugin-embed 0.5.0 → 0.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (21) hide show

package/README.md +118 -406
package/dist/embedded/es/options.d.ts +1 -1
package/dist/embedded/html/options.d.ts +1 -1
package/dist/embedded/index.d.ts +2 -2
package/dist/embedded/json/options.d.ts +1 -1
package/dist/embedded/register.d.ts +20 -20
package/dist/embedded/ruby/options.d.ts +1 -1
package/dist/embedded/toml/plugin-toml-types.d.ts +2 -2
package/dist/embedded/ts/options.d.ts +1 -1
package/dist/embedded/types.d.ts +1 -1
package/dist/embedded/utils.d.ts +21 -5
package/dist/embedded/xml/parser.d.ts +7 -4
package/dist/import-module-worker.js +45 -0
package/dist/index.d.ts +5 -6
package/dist/index.js +1727 -2446
package/dist/options.d.ts +5 -5
package/dist/parsers.d.ts +13 -13
package/dist/type-utils.d.ts +5 -0
package/dist/types.d.ts +2 -2
package/dist/utils.d.ts +5 -124
package/package.json +40 -48

package/dist/index.js CHANGED Viewed

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