prettier-plugin-embed 0.7.0 → 0.7.2

package/dist/index.js

@@ -157,25 +157,34 @@ function he(e, t, n) {
 		previousQuasiText: i
 	};
 }
-function ge(e, t, n, r, i, a = !0) {
-	let { node: o } = e, s = t();
-	if (o?.comments?.length && (s = g([_([v, s]), v])), !a) return g([
+function ge(e, t, n, r, i, a = !0, o) {
+	let { node: s } = e, c = t();
+	if (s?.comments?.length && (c = g([_([v, c]), v])), !a) return g([
 		"${",
-		s,
+		c,
 		se,
 		"}"
 	]);
-	let { indentSize: c, previousQuasiText: l } = he(n, r, i), u = s;
-	return u = c === 0 && l.endsWith("\n") ? le(-Infinity, u) : ce(u, c, i), g([
+	let { indentSize: l, previousQuasiText: u } = o === void 0 ? he(n, r, i) : {
+		indentSize: o,
+		previousQuasiText: n.quasis[r].value.raw
+	}, d = c;
+	return d = l === 0 && u.endsWith("\n") ? le(-Infinity, d) : ce(d, l, i), g([
 		"${",
-		u,
+		d,
 		se,
 		"}"
 	]);
 }
 function x(e, t, n, r = !0) {
-	let i = n?.tabWidth ?? 2, a = e.node;
-	return e.map((e, n) => ge(e, t, a, n, i, r), "expressions");
+	let i = n?.tabWidth ?? 2, a = e.node, o = 0;
+	return e.map((e, n) => {
+		if (r) {
+			let e = a.quasis[n].value.raw;
+			e.includes("\n") && (o = me(e, i));
+		}
+		return ge(e, t, a, n, i, r, o);
+	}, "expressions");
 }
 function S(e, t, n, r = !1, i, a, o = !1) {
 	let s = n.length ? /* @__PURE__ */ new Set() : void 0, c = de(e, (e) => {
@@ -225,7 +234,7 @@ function _e(e, t, n) {
 	}
 	e.splice(r, 0, t);
 }
-var C = (() => {
+var ve = (() => {
 	let e = [...Array(26).keys()].map((e) => String.fromCharCode(e + 97)).concat([...Array(10).keys()].map((e) => `${e}`));
 	return () => {
 		let t = "";
@@ -233,40 +242,40 @@ var C = (() => {
 		return t;
 	};
 })();
-function w(e = "p", t = "") {
-	let n = C(), r = C(), i = ve(e), a = ve(t);
+function C(e = "p", t = "") {
+	let n = ve(), r = ve(), i = ye(e), a = ye(t);
 	return {
 		createPlaceholder: (i) => `${e}${n}${i}${r}${t}`,
 		placeholderRegex: RegExp(`${i}${n}(\\d+)${r}${a}`, "ig")
 	};
 }
-function ve(e) {
+function ye(e) {
 	return e.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
 }
-function T(e) {
+function w(e) {
 	return `${e}Identifiers`;
 }
-function E(e) {
+function T(e) {
 	return `${e}Comments`;
 }
-function D(e) {
+function E(e) {
 	return `${e}Tags`;
 }
-function ye(e) {
+function be(e) {
 	return `${e}Plugin`;
 }
-function O(e) {
+function D(e) {
 	return `${e}Parser`;
 }
-var k = "9ff2b366e8ca4c97b9aed1a29b5b94ed";
+var O = "9ff2b366e8ca4c97b9aed1a29b5b94ed";
 //#endregion
 //#region src/embedded/create-embedder.ts
-function A({ parser: e, parserOption: t, parserOptions: n, markup: r = !1, newlineHandling: i = !1, dedentContent: a = !1, placeholderPrefix: o = "p", transformDoc: s }) {
+function k({ parser: e, parserOption: t, parserOptions: n, markup: r = !1, newlineHandling: i = !1, dedentContent: a = !1, placeholderPrefix: o = "p", transformDoc: s }) {
 	return async (c, l, u, d, { commentOrTag: f, embeddedOverrideOptions: p }) => {
 		let m = {
 			...d,
 			...p
-		}, { createPlaceholder: h, placeholderRegex: ee } = w(o), { trimmedText: te, leadingWhitespaces: ne, trailingWhitespaces: ie } = y(u.node, h), ae = x(u, l, m, !1), g = t ? m[t] : void 0, _ = await c(a ? re(te) : te, {
+		}, { createPlaceholder: h, placeholderRegex: ee } = C(o), { trimmedText: te, leadingWhitespaces: ne, trailingWhitespaces: ie } = y(u.node, h), ae = x(u, l, m, !1), g = t ? m[t] : void 0, _ = await c(a ? re(te) : te, {
 			...m,
 			...n,
 			parser: g ?? e
@@ -276,100 +285,100 @@ function A({ parser: e, parserOption: t, parserOptions: n, markup: r = !1, newli
 }
 //#endregion
 //#region src/embedded/astro/embedder.ts
-var be = A({
+var xe = k({
 	parser: "astro",
 	markup: !0
-}), xe = "embeddedAstro", Se = ["astro"], Ce = E(xe), we = D(xe), Te = {
-	[Ce]: {
+}), Se = "embeddedAstro", Ce = ["astro"], we = T(Se), Te = E(Se), Ee = {
+	[we]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...Se] }],
+		default: [{ value: [...Ce] }],
 		description: "Block comments that identify embedded Astro in template literals. Requires the `prettier-plugin-astro` plugin."
 	},
-	[we]: {
+	[Te]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...Se] }],
+		default: [{ value: [...Ce] }],
 		description: "Tags that identify embedded Astro in template literals. Requires the `prettier-plugin-astro` plugin."
 	}
-}, Ee = /* @__PURE__ */ p({
-	embedder: () => be,
-	language: () => xe,
-	options: () => Te
-}), De = A({
+}, De = /* @__PURE__ */ p({
+	embedder: () => xe,
+	language: () => Se,
+	options: () => Ee
+}), Oe = k({
 	parser: "scss",
 	parserOption: "embeddedCssParser",
 	placeholderPrefix: "@prettier-placeholder",
 	newlineHandling: "literalline"
-}), j = "embeddedCss", Oe = ["css"], ke = [
+}), A = "embeddedCss", ke = ["css"], Ae = [
 	"css",
 	"less",
 	"scss"
-], Ae = T(j), je = E(j), Me = D(j), Ne = O(j), Pe = {
-	[Ae]: {
+], je = w(A), Me = T(A), Ne = E(A), Pe = D(A), Fe = {
+	[je]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...Oe] }],
+		default: [{ value: [...ke] }],
 		description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded CSS language.",
-		deprecated: `Please use \`${je}\` or \`${Me}\`.`
+		deprecated: `Please use \`${Me}\` or \`${Ne}\`.`
 	},
-	[je]: {
+	[Me]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Block comments that make their subsequent template literals be identified as embedded CSS language."
 	},
-	[Me]: {
+	[Ne]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Tags that make their subsequent template literals be identified as embedded CSS language."
 	},
-	[Ne]: {
+	[Pe]: {
 		category: "Embed",
 		type: "choice",
 		default: "scss",
 		description: "The parser used to parse the embedded CSS language.",
-		choices: ke.map((e) => ({
+		choices: Ae.map((e) => ({
 			value: e,
 			description: `Use the "${e}" parser.`
 		}))
 	}
-}, Fe = /* @__PURE__ */ p({
-	embedder: () => De,
-	language: () => j,
-	options: () => Pe
-}), Ie = A({
+}, Ie = /* @__PURE__ */ p({
+	embedder: () => Oe,
+	language: () => A,
+	options: () => Fe
+}), Le = k({
 	parser: "dockerfile",
 	newlineHandling: "hardline"
-}), Le = "embeddedDockerfile", Re = ["dockerfile", "containerfile"], ze = E(Le), Be = D(Le), Ve = {
-	[ze]: {
+}), Re = "embeddedDockerfile", ze = ["dockerfile", "containerfile"], Be = T(Re), Ve = E(Re), He = {
+	[Be]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...Re] }],
+		default: [{ value: [...ze] }],
 		description: "Block comments that identify embedded Dockerfile in template literals. Requires the `prettier-plugin-sh` plugin."
 	},
-	[Be]: {
+	[Ve]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...Re] }],
+		default: [{ value: [...ze] }],
 		description: "Tags that identify embedded Dockerfile in template literals. Requires the `prettier-plugin-sh` plugin."
 	}
-}, He = /* @__PURE__ */ p({
-	embedder: () => Ie,
-	language: () => Le,
-	options: () => Ve
-}), Ue = A({
+}, Ue = /* @__PURE__ */ p({
+	embedder: () => Le,
+	language: () => Re,
+	options: () => He
+}), We = k({
 	parser: "babel",
 	parserOption: "embeddedEsParser"
-}), M = "embeddedEs", We = [
+}), j = "embeddedEs", Ge = [
 	"js",
 	"jsx",
 	"es",
@@ -378,336 +387,336 @@ var be = A({
 	"cjs",
 	"pac",
 	"javascript"
-], Ge = [
+], Ke = [
 	"babel",
 	"babel-flow",
 	"acorn",
 	"espree",
 	"flow",
 	"meriyah"
-], Ke = T(M), qe = E(M), Je = D(M), Ye = O(M), Xe = {
-	[Ke]: {
+], qe = w(j), Je = T(j), Ye = E(j), Xe = D(j), Ze = {
+	[qe]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...We] }],
+		default: [{ value: [...Ge] }],
 		description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded ECMAScript/JavaScript language.",
-		deprecated: `Please use \`${qe}\` or \`${Je}\`.`
+		deprecated: `Please use \`${Je}\` or \`${Ye}\`.`
 	},
-	[qe]: {
+	[Je]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Block comments that make their subsequent template literals be identified as embedded ECMAScript/JavaScript language."
 	},
-	[Je]: {
+	[Ye]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Tags that make their subsequent template literals be identified as embedded ECMAScript/JavaScript language."
 	},
-	[Ye]: {
+	[Xe]: {
 		category: "Embed",
 		type: "choice",
 		default: "babel",
 		description: "The parser used to parse the embedded ECMASCript/JavaScript language.",
-		choices: Ge.map((e) => ({
+		choices: Ke.map((e) => ({
 			value: e,
 			description: `Use the "${e}" parser.`
 		}))
 	}
-}, Ze = /* @__PURE__ */ p({
-	embedder: () => Ue,
-	language: () => M,
-	options: () => Xe
-}), Qe = A({ parser: "gherkin" }), $e = "embeddedGherkin", et = ["gherkin", "feature"], tt = E($e), nt = D($e), rt = {
-	[tt]: {
+}, Qe = /* @__PURE__ */ p({
+	embedder: () => We,
+	language: () => j,
+	options: () => Ze
+}), $e = k({ parser: "gherkin" }), et = "embeddedGherkin", tt = ["gherkin", "feature"], nt = T(et), rt = E(et), it = {
+	[nt]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...et] }],
+		default: [{ value: [...tt] }],
 		description: "Block comments that identify embedded Gherkin in template literals. Requires the `prettier-plugin-gherkin` plugin."
 	},
-	[nt]: {
+	[rt]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...et] }],
+		default: [{ value: [...tt] }],
 		description: "Tags that identify embedded Gherkin in template literals. Requires the `prettier-plugin-gherkin` plugin."
 	}
-}, it = /* @__PURE__ */ p({
-	embedder: () => Qe,
-	language: () => $e,
-	options: () => rt
-}), at = A({ parser: "glsl-parser" }), ot = "embeddedGlsl", st = ["glsl", "shader"], ct = T(ot), lt = E(ot), ut = D(ot), dt = {
-	[ct]: {
+}, at = /* @__PURE__ */ p({
+	embedder: () => $e,
+	language: () => et,
+	options: () => it
+}), ot = k({ parser: "glsl-parser" }), st = "embeddedGlsl", ct = ["glsl", "shader"], lt = w(st), ut = T(st), dt = E(st), ft = {
+	[lt]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...st] }],
+		default: [{ value: [...ct] }],
 		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 \`${lt}\` or \`${ut}\`.`
+		deprecated: `Please use \`${ut}\` or \`${dt}\`.`
 	},
-	[lt]: {
+	[ut]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Block comments that make their subsequent template literals be identified as embedded GLSL language. This option requires the `prettier-plugin-glsl` plugin."
 	},
-	[ut]: {
+	[dt]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Tags that make their subsequent template literals be identified as embedded GLSL language. This option requires the `prettier-plugin-glsl` plugin."
 	}
-}, ft = /* @__PURE__ */ p({
-	embedder: () => at,
-	language: () => ot,
-	options: () => dt
-}), pt = A({
+}, pt = /* @__PURE__ */ p({
+	embedder: () => ot,
+	language: () => st,
+	options: () => ft
+}), mt = k({
 	parser: "go-template",
 	markup: !0
-}), mt = "embeddedGoTemplate", ht = ["goTemplate", "gotmpl"], gt = E(mt), _t = D(mt), vt = {
-	[gt]: {
+}), ht = "embeddedGoTemplate", gt = ["goTemplate", "gotmpl"], _t = T(ht), vt = E(ht), yt = {
+	[_t]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...ht] }],
+		default: [{ value: [...gt] }],
 		description: "Block comments that identify embedded Go Template in template literals. Requires the `@htnabe/prettier-plugin-go-template` plugin."
 	},
-	[_t]: {
+	[vt]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...ht] }],
+		default: [{ value: [...gt] }],
 		description: "Tags that identify embedded Go Template in template literals. Requires the `@htnabe/prettier-plugin-go-template` plugin."
 	}
-}, yt = /* @__PURE__ */ p({
-	embedder: () => pt,
-	language: () => mt,
-	options: () => vt
-}), bt = A({ parser: "graphql" }), xt = "embeddedGraphql", St = ["graphql", "gql"], Ct = T(xt), wt = E(xt), Tt = D(xt), Et = {
-	[Ct]: {
+}, bt = /* @__PURE__ */ p({
+	embedder: () => mt,
+	language: () => ht,
+	options: () => yt
+}), xt = k({ parser: "graphql" }), St = "embeddedGraphql", Ct = ["graphql", "gql"], wt = w(St), Tt = T(St), Et = E(St), Dt = {
+	[wt]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...St] }],
+		default: [{ value: [...Ct] }],
 		description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded GraphQL language.",
-		deprecated: `Please use \`${wt}\` or \`${Tt}\`.`
+		deprecated: `Please use \`${Tt}\` or \`${Et}\`.`
 	},
-	[wt]: {
+	[Tt]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Block comments that make their subsequent template literals be identified as embedded GraphQL language."
 	},
-	[Tt]: {
+	[Et]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Tags that make their subsequent template literals be identified as embedded GraphQL language."
 	}
-}, Dt = /* @__PURE__ */ p({
-	embedder: () => bt,
-	language: () => xt,
-	options: () => Et
-}), Ot = A({
+}, Ot = /* @__PURE__ */ p({
+	embedder: () => xt,
+	language: () => St,
+	options: () => Dt
+}), kt = k({
 	parser: "handlebars",
 	markup: !0
-}), kt = "embeddedHandlebars", At = ["handlebars", "hbs"], jt = E(kt), Mt = D(kt), Nt = {
-	[jt]: {
+}), At = "embeddedHandlebars", jt = ["handlebars", "hbs"], Mt = T(At), Nt = E(At), Pt = {
+	[Mt]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...At] }],
+		default: [{ value: [...jt] }],
 		description: "Block comments that identify embedded Handlebars in template literals. Requires the `@poliklot/prettier-plugin-handlebars` plugin."
 	},
-	[Mt]: {
+	[Nt]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...At] }],
+		default: [{ value: [...jt] }],
 		description: "Tags that identify embedded Handlebars in template literals. Requires the `@poliklot/prettier-plugin-handlebars` plugin."
 	}
-}, Pt = /* @__PURE__ */ p({
-	embedder: () => Ot,
-	language: () => kt,
-	options: () => Nt
-}), Ft = A({
+}, Ft = /* @__PURE__ */ p({
+	embedder: () => kt,
+	language: () => At,
+	options: () => Pt
+}), It = k({
 	parser: "html",
 	parserOption: "embeddedHtmlParser",
 	markup: !0
-}), N = "embeddedHtml", It = ["html", "xhtml"], Lt = [
+}), M = "embeddedHtml", Lt = ["html", "xhtml"], Rt = [
 	"html",
 	"vue",
 	"angular",
 	"lwc"
-], Rt = T(N), zt = E(N), Bt = D(N), Vt = O(N), Ht = {
-	[Rt]: {
+], zt = w(M), Bt = T(M), Vt = E(M), Ht = D(M), Ut = {
+	[zt]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...It] }],
+		default: [{ value: [...Lt] }],
 		description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded HTML language.",
-		deprecated: `Please use \`${zt}\` or \`${Bt}\`.`
+		deprecated: `Please use \`${Bt}\` or \`${Vt}\`.`
 	},
-	[zt]: {
+	[Bt]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Block comments that make their subsequent template literals be identified as embedded HTML language."
 	},
-	[Bt]: {
+	[Vt]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Tags that make their subsequent template literals be identified as embedded HTML language."
 	},
-	[Vt]: {
+	[Ht]: {
 		category: "Embed",
 		type: "choice",
 		default: "html",
 		description: "The parser used to parse the embedded HTML language.",
-		choices: Lt.map((e) => ({
+		choices: Rt.map((e) => ({
 			value: e,
 			description: `Use the "${e}" parser.`
 		}))
 	}
-}, Ut = /* @__PURE__ */ p({
-	embedder: () => Ft,
-	language: () => N,
-	options: () => Ht
-}), Wt = A({
+}, Wt = /* @__PURE__ */ p({
+	embedder: () => It,
+	language: () => M,
+	options: () => Ut
+}), Gt = k({
 	parser: "hugo-post",
 	newlineHandling: "hardline",
 	dedentContent: !0
-}), Gt = "embeddedHugo", Kt = ["hugo", "hugoPost"], qt = E(Gt), Jt = D(Gt), Yt = {
-	[qt]: {
+}), Kt = "embeddedHugo", qt = ["hugo", "hugoPost"], Jt = T(Kt), Yt = E(Kt), Xt = {
+	[Jt]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...Kt] }],
+		default: [{ value: [...qt] }],
 		description: "Block comments that identify embedded Hugo in template literals. Requires the `@htnabe/prettier-plugin-hugo-post` plugin."
 	},
-	[Jt]: {
+	[Yt]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...Kt] }],
+		default: [{ value: [...qt] }],
 		description: "Tags that identify embedded Hugo in template literals. Requires the `@htnabe/prettier-plugin-hugo-post` plugin."
 	}
-}, Xt = /* @__PURE__ */ p({
-	embedder: () => Wt,
-	language: () => Gt,
-	options: () => Yt
-}), Zt = A({ parser: "ini" }), P = "embeddedIni", Qt = [
+}, Zt = /* @__PURE__ */ p({
+	embedder: () => Gt,
+	language: () => Kt,
+	options: () => Xt
+}), Qt = k({ parser: "ini" }), N = "embeddedIni", $t = [
 	"ini",
 	"cfg",
 	"pro"
-], $t = T(P), en = E(P), tn = D(P), nn = {
-	[$t]: {
+], en = w(N), tn = T(N), nn = E(N), rn = {
+	[en]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...Qt] }],
+		default: [{ value: [...$t] }],
 		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 \`${en}\` or \`${tn}\`.`
+		deprecated: `Please use \`${tn}\` or \`${nn}\`.`
 	},
-	[en]: {
+	[tn]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Block comments that make their subsequent template literals be identified as embedded INI language. This option requires the `prettier-plugin-ini` plugin."
 	},
-	[tn]: {
+	[nn]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Tags that make their subsequent template literals be identified as embedded INI language. This option requires the `prettier-plugin-ini` plugin."
 	}
-}, rn = /* @__PURE__ */ p({
-	embedder: () => Zt,
-	language: () => P,
-	options: () => nn
-}), an = A({
+}, an = /* @__PURE__ */ p({
+	embedder: () => Qt,
+	language: () => N,
+	options: () => rn
+}), on = k({
 	parser: "java",
 	newlineHandling: "hardline"
-}), F = "embeddedJava", on = ["java"], sn = T(F), cn = E(F), ln = D(F), un = {
-	[sn]: {
+}), P = "embeddedJava", sn = ["java"], cn = w(P), ln = T(P), un = E(P), dn = {
+	[cn]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...on] }],
+		default: [{ value: [...sn] }],
 		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 \`${cn}\` or \`${ln}\`.`
+		deprecated: `Please use \`${ln}\` or \`${un}\`.`
 	},
-	[cn]: {
+	[ln]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Block comments that make their subsequent template literals be identified as embedded Java language. This option requires the `prettier-plugin-java` plugin."
 	},
-	[ln]: {
+	[un]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Tags that make their subsequent template literals be identified as embedded Java language. This option requires the `prettier-plugin-java` plugin."
 	}
-}, dn = /* @__PURE__ */ p({
-	embedder: () => an,
-	language: () => F,
-	options: () => un
-}), fn = A({
+}, fn = /* @__PURE__ */ p({
+	embedder: () => on,
+	language: () => P,
+	options: () => dn
+}), pn = k({
 	parser: "jinja-template",
 	markup: !0,
 	dedentContent: !0
-}), pn = "embeddedJinja", mn = [
+}), mn = "embeddedJinja", hn = [
 	"jinja",
 	"jinja2",
 	"j2"
-], hn = E(pn), gn = D(pn), _n = {
-	[hn]: {
+], gn = T(mn), _n = E(mn), vn = {
+	[gn]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...mn] }],
+		default: [{ value: [...hn] }],
 		description: "Block comments that identify embedded Jinja in template literals. Requires the `prettier-plugin-jinja-template` plugin."
 	},
-	[gn]: {
+	[_n]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...mn] }],
+		default: [{ value: [...hn] }],
 		description: "Tags that identify embedded Jinja in template literals. Requires the `prettier-plugin-jinja-template` plugin."
 	}
-}, vn = /* @__PURE__ */ p({
-	embedder: () => fn,
-	language: () => pn,
-	options: () => _n
-}), yn = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
+}, yn = /* @__PURE__ */ p({
+	embedder: () => pn,
+	language: () => mn,
+	options: () => vn
+}), bn = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
 	let o = {
 		...r,
 		...a
-	}, { node: s } = n, { createPlaceholder: c, placeholderRegex: l } = bn(), { trimmedText: u, leadingWhitespaces: d, trailingWhitespaces: f } = y(s, c), p = x(n, t);
+	}, { node: s } = n, { createPlaceholder: c, placeholderRegex: l } = xn(), { trimmedText: u, leadingWhitespaces: d, trailingWhitespaces: f } = y(s, c), p = x(n, t);
 	return b(S(await e(u, {
 		...o,
 		parser: o.embeddedJsonParser ?? "json"
 	}), l, p), o, i, d, f);
 };
-function bn() {
-	let e = C(), t = C();
+function xn() {
+	let e = ve(), t = ve();
 	return {
 		createPlaceholder: (n) => `'0${e}${n}${t}'`,
 		placeholderRegex: RegExp(`["']?0${e}(\\d+)${t}['"]?`, "ig")
@@ -715,101 +724,101 @@ function bn() {
 }
 //#endregion
 //#region src/embedded/json/language.ts
-var I = "embeddedJson", xn = ["json", "jsonl"], Sn = [
+var F = "embeddedJson", Sn = ["json", "jsonl"], Cn = [
 	"json",
 	"json5",
 	"jsonc",
 	"json-stringify"
-], Cn = T(I), wn = E(I), Tn = D(I), En = O(I), Dn = {
-	[Cn]: {
+], wn = w(F), Tn = T(F), En = E(F), Dn = D(F), On = {
+	[wn]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...xn] }],
+		default: [{ value: [...Sn] }],
 		description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded JSON language.",
-		deprecated: `Please use \`${wn}\` or \`${Tn}\`.`
+		deprecated: `Please use \`${Tn}\` or \`${En}\`.`
 	},
-	[wn]: {
+	[Tn]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Block comments that make their subsequent template literals be identified as embedded JSON language."
 	},
-	[Tn]: {
+	[En]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Tags that make their subsequent template literals be identified as embedded JSON language."
 	},
-	[En]: {
+	[Dn]: {
 		category: "Embed",
 		type: "choice",
 		default: "json",
 		description: "The parser used to parse the embedded JSON language.",
-		choices: Sn.map((e) => ({
+		choices: Cn.map((e) => ({
 			value: e,
 			description: `Use the "${e}" parser.`
 		}))
 	}
-}, On = /* @__PURE__ */ p({
-	embedder: () => yn,
-	language: () => I,
-	options: () => Dn
-}), kn = A({
+}, kn = /* @__PURE__ */ p({
+	embedder: () => bn,
+	language: () => F,
+	options: () => On
+}), An = k({
 	parser: "JSONata",
 	placeholderPrefix: "$p"
-}), L = "embeddedJsonata", An = ["jsonata"], jn = T(L), Mn = E(L), Nn = D(L), Pn = {
-	[jn]: {
+}), I = "embeddedJsonata", jn = ["jsonata"], Mn = w(I), Nn = T(I), Pn = E(I), Fn = {
+	[Mn]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...An] }],
+		default: [{ value: [...jn] }],
 		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 \`${Mn}\` or \`${Nn}\`.`
+		deprecated: `Please use \`${Nn}\` or \`${Pn}\`.`
 	},
-	[Mn]: {
+	[Nn]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Block comments that make their subsequent template literals be identified as embedded JSONata language. This option requires the `@stedi/prettier-plugin-jsonata` plugin."
 	},
-	[Nn]: {
+	[Pn]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Tags that make their subsequent template literals be identified as embedded JSONata language. This option requires the `@stedi/prettier-plugin-jsonata` plugin."
 	}
-}, Fn = /* @__PURE__ */ p({
-	embedder: () => kn,
-	language: () => L,
-	options: () => Pn
-}), In = A({
+}, In = /* @__PURE__ */ p({
+	embedder: () => An,
+	language: () => I,
+	options: () => Fn
+}), Ln = k({
 	parser: "jte",
 	markup: !0
-}), Ln = "embeddedJte", Rn = ["jte"], zn = E(Ln), Bn = D(Ln), Vn = {
-	[zn]: {
+}), Rn = "embeddedJte", zn = ["jte"], Bn = T(Rn), Vn = E(Rn), Hn = {
+	[Bn]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...Rn] }],
+		default: [{ value: [...zn] }],
 		description: "Block comments that identify embedded JTE in template literals. Requires the `prettier-plugin-jte` plugin."
 	},
-	[Bn]: {
+	[Vn]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...Rn] }],
+		default: [{ value: [...zn] }],
 		description: "Tags that identify embedded JTE in template literals. Requires the `prettier-plugin-jte` plugin."
 	}
-}, Hn = /* @__PURE__ */ p({
-	embedder: () => In,
-	language: () => Ln,
-	options: () => Vn
-}), Un = A({ parser: "latex-parser" }), R = "embeddedLatex", Wn = [
+}, Un = /* @__PURE__ */ p({
+	embedder: () => Ln,
+	language: () => Rn,
+	options: () => Hn
+}), Wn = k({ parser: "latex-parser" }), L = "embeddedLatex", Gn = [
 	"latex",
 	"tex",
 	"aux",
@@ -818,361 +827,361 @@ var I = "embeddedJson", xn = ["json", "jsonl"], Sn = [
 	"bib",
 	"toc",
 	"sty"
-], Gn = T(R), Kn = E(R), qn = D(R), Jn = {
-	[Gn]: {
+], Kn = w(L), qn = T(L), Jn = E(L), Yn = {
+	[Kn]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...Wn] }],
+		default: [{ value: [...Gn] }],
 		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 \`${Kn}\` or \`${qn}\`.`
+		deprecated: `Please use \`${qn}\` or \`${Jn}\`.`
 	},
-	[Kn]: {
+	[qn]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Block comments that make their subsequent template literals be identified as embedded LaTeX language. This option requires the `prettier-plugin-latex` plugin."
 	},
-	[qn]: {
+	[Jn]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Tags that make their subsequent template literals be identified as embedded LaTeX language. This option requires the `prettier-plugin-latex` plugin."
 	}
-}, Yn = /* @__PURE__ */ p({
-	embedder: () => Un,
-	language: () => R,
-	options: () => Jn
-}), Xn = A({
+}, Xn = /* @__PURE__ */ p({
+	embedder: () => Wn,
+	language: () => L,
+	options: () => Yn
+}), Zn = k({
 	parser: "liquid-html",
 	markup: !0
-}), Zn = "embeddedLiquid", Qn = ["liquid"], $n = E(Zn), er = D(Zn), tr = {
-	[$n]: {
+}), Qn = "embeddedLiquid", $n = ["liquid"], er = T(Qn), tr = E(Qn), nr = {
+	[er]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...Qn] }],
+		default: [{ value: [...$n] }],
 		description: "Block comments that identify embedded Liquid in template literals. Requires the `@shopify/prettier-plugin-liquid` plugin."
 	},
-	[er]: {
+	[tr]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...Qn] }],
+		default: [{ value: [...$n] }],
 		description: "Tags that identify embedded Liquid in template literals. Requires the `@shopify/prettier-plugin-liquid` plugin."
 	}
-}, nr = /* @__PURE__ */ p({
-	embedder: () => Xn,
-	language: () => Zn,
-	options: () => tr
-}), { line: rr, group: z, indent: ir, softline: ar, dedentToRoot: or, literalline: sr } = e, cr = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
+}, rr = /* @__PURE__ */ p({
+	embedder: () => Zn,
+	language: () => Qn,
+	options: () => nr
+}), { line: ir, group: R, indent: ar, softline: or, dedentToRoot: sr, literalline: cr } = e, lr = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
 	let o = {
 		...r,
 		...a
-	}, { node: s } = n, { createPlaceholder: c, placeholderRegex: l } = w(), { trimmedText: u, leadingWhitespaces: d, trailingWhitespaces: f } = y(s, c), p = x(n, t), m = S(await e(re(u), {
+	}, { node: s } = n, { createPlaceholder: c, placeholderRegex: l } = C(), { trimmedText: u, leadingWhitespaces: d, trailingWhitespaces: f } = y(s, c), p = x(n, t), m = S(await e(re(u), {
 		...o,
 		parser: o.embeddedMarkdownParser ?? "markdown",
 		__inJsTemplate: !0
 	}), l, p, "hardline");
-	if (o.preserveEmbeddedExteriorWhitespaces?.includes(i)) return z([
+	if (o.preserveEmbeddedExteriorWhitespaces?.includes(i)) return R([
 		"`",
 		d,
-		o.noEmbeddedMultiLineIndentation?.includes(i) ? or(z(m)) : ir([z(m)]),
+		o.noEmbeddedMultiLineIndentation?.includes(i) ? sr(R(m)) : ar([R(m)]),
 		f,
 		"`"
 	]);
-	let h = d.length ? rr : ar, ee = f.length ? rr : ar;
+	let h = d.length ? ir : or, ee = f.length ? ir : or;
 	return o.noEmbeddedMultiLineIndentation?.includes(i) ? [
 		"`",
-		sr,
-		or(m),
-		ar,
+		cr,
+		sr(m),
+		or,
 		"`"
-	] : z([
+	] : R([
 		"`",
-		ir([h, z(m)]),
+		ar([h, R(m)]),
 		ee,
 		"`"
 	]);
-}, B = "embeddedMarkdown", lr = ["md", "markdown"], ur = [
+}, z = "embeddedMarkdown", ur = ["md", "markdown"], dr = [
 	"markdown",
 	"mdx",
 	"remark"
-], dr = T(B), fr = E(B), pr = D(B), mr = O(B), hr = {
-	[dr]: {
+], fr = w(z), pr = T(z), mr = E(z), hr = D(z), gr = {
+	[fr]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...lr] }],
+		default: [{ value: [...ur] }],
 		description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded Markdown language.",
-		deprecated: `Please use \`${fr}\` or \`${pr}\`.`
+		deprecated: `Please use \`${pr}\` or \`${mr}\`.`
 	},
-	[fr]: {
+	[pr]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Block comments that make their subsequent template literals be identified as embedded Markdown language."
 	},
-	[pr]: {
+	[mr]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Tags that make their subsequent template literals be identified as embedded Markdown language."
 	},
-	[mr]: {
+	[hr]: {
 		category: "Embed",
 		type: "choice",
 		default: "markdown",
 		description: "The parser used to parse the embedded Markdown language.",
-		choices: ur.map((e) => ({
+		choices: dr.map((e) => ({
 			value: e,
 			description: `Use the "${e}" parser.`
 		}))
 	}
-}, gr = /* @__PURE__ */ p({
-	embedder: () => cr,
-	language: () => B,
-	options: () => hr
-}), _r = A({
+}, _r = /* @__PURE__ */ p({
+	embedder: () => lr,
+	language: () => z,
+	options: () => gr
+}), vr = k({
 	parser: "marko",
 	markup: !0
-}), vr = "embeddedMarko", yr = ["marko"], br = E(vr), xr = D(vr), Sr = {
-	[br]: {
+}), yr = "embeddedMarko", br = ["marko"], xr = T(yr), Sr = E(yr), Cr = {
+	[xr]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...yr] }],
+		default: [{ value: [...br] }],
 		description: "Block comments that identify embedded Marko in template literals. Requires the `prettier-plugin-marko` plugin."
 	},
-	[xr]: {
+	[Sr]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...yr] }],
+		default: [{ value: [...br] }],
 		description: "Tags that identify embedded Marko in template literals. Requires the `prettier-plugin-marko` plugin."
 	}
-}, Cr = /* @__PURE__ */ p({
-	embedder: () => _r,
-	language: () => vr,
-	options: () => Sr
-}), wr = A({
+}, wr = /* @__PURE__ */ p({
+	embedder: () => vr,
+	language: () => yr,
+	options: () => Cr
+}), Tr = k({
 	parser: "motoko-tt-parse",
-	transformDoc: Tr
+	transformDoc: Er
 });
-function Tr(e) {
+function Er(e) {
 	if (!Array.isArray(e)) return e;
 	let t = e.at(-1);
 	return t && !Array.isArray(t) && typeof t == "object" && t.type === "line" && t.hard && t.literal ? e.slice(0, -1) : e;
 }
 //#endregion
 //#region src/embedded/motoko/language.ts
-var Er = "embeddedMotoko", Dr = ["motoko", "mo"], Or = E(Er), kr = D(Er), Ar = {
-	[Or]: {
+var Dr = "embeddedMotoko", Or = ["motoko", "mo"], kr = T(Dr), Ar = E(Dr), jr = {
+	[kr]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...Dr] }],
+		default: [{ value: [...Or] }],
 		description: "Block comments that identify embedded Motoko in template literals. Requires the `prettier-plugin-motoko` plugin."
 	},
-	[kr]: {
+	[Ar]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...Dr] }],
+		default: [{ value: [...Or] }],
 		description: "Tags that identify embedded Motoko in template literals. Requires the `prettier-plugin-motoko` plugin."
 	}
-}, jr = /* @__PURE__ */ p({
-	embedder: () => wr,
-	language: () => Er,
-	options: () => Ar
-}), Mr = A({
+}, Mr = /* @__PURE__ */ p({
+	embedder: () => Tr,
+	language: () => Dr,
+	options: () => jr
+}), Nr = k({
 	parser: "mustache",
 	markup: !0
-}), Nr = "embeddedMustache", Pr = ["mustache"], Fr = E(Nr), Ir = D(Nr), Lr = {
-	[Fr]: {
+}), Pr = "embeddedMustache", Fr = ["mustache"], Ir = T(Pr), Lr = E(Pr), Rr = {
+	[Ir]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...Pr] }],
+		default: [{ value: [...Fr] }],
 		description: "Block comments that identify embedded Mustache in template literals. Requires the `prettier-plugin-mustache` plugin."
 	},
-	[Ir]: {
+	[Lr]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...Pr] }],
+		default: [{ value: [...Fr] }],
 		description: "Tags that identify embedded Mustache in template literals. Requires the `prettier-plugin-mustache` plugin."
 	}
-}, Rr = /* @__PURE__ */ p({
-	embedder: () => Mr,
-	language: () => Nr,
-	options: () => Lr
-}), zr = A({ parser: "nginx" }), V = "embeddedNginx", Br = ["nginx"], Vr = T(V), Hr = E(V), Ur = D(V), Wr = {
-	[Vr]: {
+}, zr = /* @__PURE__ */ p({
+	embedder: () => Nr,
+	language: () => Pr,
+	options: () => Rr
+}), Br = k({ parser: "nginx" }), B = "embeddedNginx", Vr = ["nginx"], Hr = w(B), Ur = T(B), Wr = E(B), Gr = {
+	[Hr]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...Br] }],
+		default: [{ value: [...Vr] }],
 		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 \`${Hr}\` or \`${Ur}\`.`
+		deprecated: `Please use \`${Ur}\` or \`${Wr}\`.`
 	},
-	[Hr]: {
+	[Ur]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Block comments that make their subsequent template literals be identified as embedded NGINX language. This option requires the `prettier-plugin-nginx` plugin."
 	},
-	[Ur]: {
+	[Wr]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Tags that make their subsequent template literals be identified as embedded NGINX language. This option requires the `prettier-plugin-nginx` plugin."
 	}
-}, Gr = /* @__PURE__ */ p({
-	embedder: () => zr,
-	language: () => V,
-	options: () => Wr
-}), H = "embeddedNoop", Kr = T(H), qr = E(H), Jr = D(H), Yr = {
-	[Kr]: {
+}, Kr = /* @__PURE__ */ p({
+	embedder: () => Br,
+	language: () => B,
+	options: () => Gr
+}), V = "embeddedNoop", qr = w(V), Jr = T(V), Yr = E(V), Xr = {
+	[qr]: {
 		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 \`${qr}\` or \`${Jr}\`.`
+		deprecated: `Please use \`${Jr}\` or \`${Yr}\`.`
 	},
-	[qr]: {
+	[Jr]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Block comments that prevent their subsequent template literals from being identified as embedded languages and thus from being formatted."
 	},
-	[Jr]: {
+	[Yr]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Tags that prevent their subsequent template literals from being identified as embedded languages and thus from being formatted."
 	}
-}, Xr = /* @__PURE__ */ p({
-	language: () => H,
-	options: () => Yr
-}), Zr = A({
+}, Zr = /* @__PURE__ */ p({
+	language: () => V,
+	options: () => Xr
+}), Qr = k({
 	parser: "nunjucks",
 	markup: !0
-}), Qr = "embeddedNunjucks", $r = ["nunjucks", "njk"], ei = E(Qr), ti = D(Qr), ni = {
-	[ei]: {
+}), $r = "embeddedNunjucks", ei = ["nunjucks", "njk"], ti = T($r), ni = E($r), ri = {
+	[ti]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...$r] }],
+		default: [{ value: [...ei] }],
 		description: "Block comments that identify embedded Nunjucks in template literals. Requires the `prettier-plugin-nunjucks` plugin."
 	},
-	[ti]: {
+	[ni]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...$r] }],
+		default: [{ value: [...ei] }],
 		description: "Tags that identify embedded Nunjucks in template literals. Requires the `prettier-plugin-nunjucks` plugin."
 	}
-}, ri = /* @__PURE__ */ p({
-	embedder: () => Zr,
-	language: () => Qr,
-	options: () => ni
-}), ii = A({ parser: "pegjs-parser" }), U = "embeddedPegjs", ai = [
+}, ii = /* @__PURE__ */ p({
+	embedder: () => Qr,
+	language: () => $r,
+	options: () => ri
+}), ai = k({ parser: "pegjs-parser" }), H = "embeddedPegjs", oi = [
 	"pegjs",
 	"peggy",
 	"peg"
-], oi = T(U), si = E(U), ci = D(U), li = {
-	[oi]: {
+], si = w(H), ci = T(H), li = E(H), ui = {
+	[si]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...ai] }],
+		default: [{ value: [...oi] }],
 		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 \`${si}\` or \`${ci}\`.`
+		deprecated: `Please use \`${ci}\` or \`${li}\`.`
 	},
-	[si]: {
+	[ci]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Block comments that make their subsequent template literals be identified as embedded Pegjs language. This option requires the `prettier-plugin-pegjs` plugin."
 	},
-	[ci]: {
+	[li]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Tags that make their subsequent template literals be identified as embedded Pegjs language. This option requires the `prettier-plugin-pegjs` plugin."
 	}
-}, ui = /* @__PURE__ */ p({
-	embedder: () => ii,
-	language: () => U,
-	options: () => li
-}), di = A({
+}, di = /* @__PURE__ */ p({
+	embedder: () => ai,
+	language: () => H,
+	options: () => ui
+}), fi = k({
 	parser: "php",
 	placeholderPrefix: "$p"
-}), W = "embeddedPhp", fi = ["php", "php5"], pi = T(W), mi = E(W), hi = D(W), gi = {
-	[pi]: {
+}), U = "embeddedPhp", pi = ["php", "php5"], mi = w(U), hi = T(U), gi = E(U), _i = {
+	[mi]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...fi] }],
+		default: [{ value: [...pi] }],
 		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 \`${mi}\` or \`${hi}\`.`
+		deprecated: `Please use \`${hi}\` or \`${gi}\`.`
 	},
-	[mi]: {
+	[hi]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Block comments that make their subsequent template literals be identified as embedded PHP language. This option requires the `@prettier/plugin-php` plugin."
 	},
-	[hi]: {
+	[gi]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Tags that make their subsequent template literals be identified as embedded PHP language. This option requires the `@prettier/plugin-php` plugin."
 	}
-}, _i = /* @__PURE__ */ p({
-	embedder: () => di,
-	language: () => W,
-	options: () => gi
-}), vi = A({
+}, vi = /* @__PURE__ */ p({
+	embedder: () => fi,
+	language: () => U,
+	options: () => _i
+}), yi = k({
 	parser: "powershell",
 	newlineHandling: "hardline"
-}), yi = "embeddedPowerShell", bi = ["powershell", "ps1"], xi = E(yi), Si = D(yi), Ci = {
-	[xi]: {
+}), bi = "embeddedPowerShell", xi = ["powershell", "ps1"], Si = T(bi), Ci = E(bi), wi = {
+	[Si]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...bi] }],
+		default: [{ value: [...xi] }],
 		description: "Block comments that identify embedded PowerShell in template literals. Requires the `prettier-plugin-powershell` plugin."
 	},
-	[Si]: {
+	[Ci]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...bi] }],
+		default: [{ value: [...xi] }],
 		description: "Tags that identify embedded PowerShell in template literals. Requires the `prettier-plugin-powershell` plugin."
 	}
-}, wi = /* @__PURE__ */ p({
-	embedder: () => vi,
-	language: () => yi,
-	options: () => Ci
-}), Ti = A({
+}, Ti = /* @__PURE__ */ p({
+	embedder: () => yi,
+	language: () => bi,
+	options: () => wi
+}), Ei = k({
 	parser: "prisma-parse",
 	newlineHandling: "hardline"
-}), Ei = "embeddedPrisma", Di = ["prisma"], Oi = T(Ei), ki = E(Ei), Ai = D(Ei), ji = {
+}), W = "embeddedPrisma", Di = ["prisma"], Oi = w(W), ki = T(W), Ai = E(W), ji = {
 	[Oi]: {
 		category: "Embed",
 		type: "string",
@@ -1185,170 +1194,170 @@ var Er = "embeddedMotoko", Dr = ["motoko", "mo"], Or = E(Er), kr = D(Er), Ar = {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Block comments that make their subsequent template literals be identified as embedded Prisma language. This option requires the `prettier-plugin-prisma` plugin."
 	},
 	[Ai]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Tags that make their subsequent template literals be identified as embedded Prisma language. This option requires the `prettier-plugin-prisma` plugin."
 	}
 }, Mi = /* @__PURE__ */ p({
-	embedder: () => Ti,
-	language: () => Ei,
+	embedder: () => Ei,
+	language: () => W,
 	options: () => ji
-}), Ni = A({ parser: "dot-properties" }), Pi = "embeddedProperties", Fi = ["properties"], Ii = T(Pi), Li = E(Pi), Ri = D(Pi), zi = {
-	[Ii]: {
+}), Ni = k({ parser: "dot-properties" }), G = "embeddedProperties", Pi = ["properties"], Fi = w(G), Ii = T(G), Li = E(G), Ri = {
+	[Fi]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...Fi] }],
+		default: [{ value: [...Pi] }],
 		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 \`${Li}\` or \`${Ri}\`.`
+		deprecated: `Please use \`${Ii}\` or \`${Li}\`.`
 	},
-	[Li]: {
+	[Ii]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Block comments that make their subsequent template literals be identified as embedded Properties language. This option requires the `prettier-plugin-properties` plugin."
 	},
-	[Ri]: {
+	[Li]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Tags that make their subsequent template literals be identified as embedded Properties language. This option requires the `prettier-plugin-properties` plugin."
 	}
-}, Bi = /* @__PURE__ */ p({
+}, zi = /* @__PURE__ */ p({
 	embedder: () => Ni,
-	language: () => Pi,
-	options: () => zi
-}), Vi = A({
+	language: () => G,
+	options: () => Ri
+}), Bi = k({
 	parser: "pug",
 	newlineHandling: "hardline"
-}), Hi = "embeddedPug", Ui = ["pug", "jade"], Wi = T(Hi), Gi = E(Hi), Ki = D(Hi), qi = {
-	[Wi]: {
+}), Vi = "embeddedPug", Hi = ["pug", "jade"], Ui = w(Vi), Wi = T(Vi), Gi = E(Vi), Ki = {
+	[Ui]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...Ui] }],
+		default: [{ value: [...Hi] }],
 		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 \`${Gi}\` or \`${Ki}\`.`
+		deprecated: `Please use \`${Wi}\` or \`${Gi}\`.`
 	},
-	[Gi]: {
+	[Wi]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Block comments that make their subsequent template literals be identified as embedded Pug language. This option requires the `@prettier/plugin-pug` plugin."
 	},
-	[Ki]: {
+	[Gi]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Tags that make their subsequent template literals be identified as embedded Pug language. This option requires the `@prettier/plugin-pug` plugin."
 	}
-}, Ji = /* @__PURE__ */ p({
-	embedder: () => Vi,
-	language: () => Hi,
-	options: () => qi
-}), Yi = A({
+}, qi = /* @__PURE__ */ p({
+	embedder: () => Bi,
+	language: () => Vi,
+	options: () => Ki
+}), Ji = k({
 	parser: "ruby",
 	parserOption: "embeddedRubyParser"
-}), G = "embeddedRuby", Xi = ["ruby"], Zi = [
+}), K = "embeddedRuby", Yi = ["ruby"], Xi = [
 	"ruby",
 	"rbs",
 	"haml"
-], Qi = T(G), $i = E(G), ea = D(G), ta = O(G), na = {
-	[Qi]: {
+], Zi = w(K), Qi = T(K), $i = E(K), ea = D(K), ta = {
+	[Zi]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...Xi] }],
+		default: [{ value: [...Yi] }],
 		description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded Ruby language. This option requires the `@prettier/plugin-ruby` plugin.",
-		deprecated: `Please use \`${$i}\` or \`${ea}\`.`
+		deprecated: `Please use \`${Qi}\` or \`${$i}\`.`
 	},
-	[$i]: {
+	[Qi]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Block comments that make their subsequent template literals be identified as embedded Ruby language. This option requires the `@prettier/plugin-ruby` plugin."
 	},
-	[ea]: {
+	[$i]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Tags that make their subsequent template literals be identified as embedded Ruby language. This option requires the `@prettier/plugin-ruby` plugin."
 	},
-	[ta]: {
+	[ea]: {
 		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: Zi.map((e) => ({
+		choices: Xi.map((e) => ({
 			value: e,
 			description: `Use the "${e}" parser.`
 		}))
 	}
-}, ra = /* @__PURE__ */ p({
-	embedder: () => Yi,
-	language: () => G,
-	options: () => na
-}), ia = A({
+}, na = /* @__PURE__ */ p({
+	embedder: () => Ji,
+	language: () => K,
+	options: () => ta
+}), ra = k({
 	parser: "sh",
 	newlineHandling: "hardline"
-}), aa = "embeddedSh", oa = ["sh"], sa = T(aa), ca = E(aa), la = D(aa), ua = {
-	[sa]: {
+}), ia = "embeddedSh", aa = ["sh"], oa = w(ia), sa = T(ia), ca = E(ia), la = {
+	[oa]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...oa] }],
+		default: [{ value: [...aa] }],
 		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 \`${ca}\` or \`${la}\`.`
+		deprecated: `Please use \`${sa}\` or \`${ca}\`.`
 	},
-	[ca]: {
+	[sa]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Block comments that make their subsequent template literals be identified as embedded Shell language. This option requires the `prettier-plugin-sh` plugin."
 	},
-	[la]: {
+	[ca]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Tags that make their subsequent template literals be identified as embedded Shell language. This option requires the `prettier-plugin-sh` plugin."
 	}
-}, da = /* @__PURE__ */ p({
-	embedder: () => ia,
-	language: () => aa,
-	options: () => ua
-}), K = "embeddedSolidity", fa = A({
+}, ua = /* @__PURE__ */ p({
+	embedder: () => ra,
+	language: () => ia,
+	options: () => la
+}), q = "embeddedSolidity", da = k({
 	parser: "slang",
-	parserOption: `${K}Parser`
-}), pa = ["solidity", "sol"], ma = E(K), ha = D(K), ga = `${K}Parser`, _a = {
-	[ma]: {
+	parserOption: `${q}Parser`
+}), fa = ["solidity", "sol"], pa = T(q), ma = E(q), ha = `${q}Parser`, ga = {
+	[pa]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...pa] }],
+		default: [{ value: [...fa] }],
 		description: "Block comments that identify embedded Solidity in template literals. Requires the `prettier-plugin-solidity` plugin."
 	},
-	[ha]: {
+	[ma]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...pa] }],
+		default: [{ value: [...fa] }],
 		description: "Tags that identify embedded Solidity in template literals. Requires the `prettier-plugin-solidity` plugin."
 	},
-	[ga]: {
+	[ha]: {
 		category: "Embed",
 		type: "choice",
 		default: "slang",
@@ -1368,15 +1377,15 @@ var Er = "embeddedMotoko", Dr = ["motoko", "mo"], Or = E(Er), kr = D(Er), Ar = {
 			}
 		]
 	}
-}, va = /* @__PURE__ */ p({
-	embedder: () => fa,
-	language: () => K,
-	options: () => _a
-}), ya = async (e, t, n, r, { commentOrTag: i, embeddedOverrideOptions: a }) => {
+}, _a = /* @__PURE__ */ p({
+	embedder: () => da,
+	language: () => q,
+	options: () => ga
+}), va = 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 } = w(), { trimmedText: d, leadingWhitespaces: f, trailingWhitespaces: p } = y(c, l), m = x(n, t, o, !1), h;
+	}, s = o.embeddedSqlPlugin ?? "prettier-plugin-sql", { node: c } = n, { createPlaceholder: l, placeholderRegex: u } = C(), { trimmedText: d, leadingWhitespaces: f, trailingWhitespaces: p } = y(c, l), m = x(n, t, o, !1), h;
 	if (s === "prettier-plugin-sql-cst") h = S(await e(d, {
 		...o,
 		parser: o.embeddedSqlParser ?? "sqlite"
@@ -1389,85 +1398,85 @@ var Er = "embeddedMotoko", Dr = ["motoko", "mo"], Or = E(Er), kr = D(Er), Ar = {
 		}), u, m, "hardline", t, o.tabWidth ?? 2);
 	}
 	return b(h, o, i, f, p);
-}, q = "embeddedSql", ba = ["sql"], xa = ["prettier-plugin-sql", "prettier-plugin-sql-cst"], Sa = [
+}, J = "embeddedSql", ya = ["sql"], ba = ["prettier-plugin-sql", "prettier-plugin-sql-cst"], xa = [
 	"sqlite",
 	"bigquery",
 	"mysql",
 	"mariadb",
 	"postgresql"
-], Ca = T(q), wa = E(q), Ta = D(q), Ea = ye(q), Da = O(q), Oa = {
-	[Ca]: {
+], Sa = w(J), Ca = T(J), wa = E(J), Ta = be(J), Ea = D(J), Da = {
+	[Sa]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...ba] }],
+		default: [{ value: [...ya] }],
 		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 \`${wa}\` or \`${Ta}\`.`
+		deprecated: `Please use \`${Ca}\` or \`${wa}\`.`
 	},
-	[wa]: {
+	[Ca]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		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."
 	},
-	[Ta]: {
+	[wa]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		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."
 	},
-	[Ea]: {
+	[Ta]: {
 		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: xa.map((e) => ({
+		choices: ba.map((e) => ({
 			value: e,
 			description: `Use the "${e}" plugin.`
 		}))
 	},
-	[Da]: {
+	[Ea]: {
 		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: Sa.map((e) => ({
+		choices: xa.map((e) => ({
 			value: e,
 			description: `Use the "${e}" parser.`
 		}))
 	}
-}, ka = /* @__PURE__ */ p({
-	embedder: () => ya,
-	language: () => q,
-	options: () => Oa
-}), Aa = A({
+}, Oa = /* @__PURE__ */ p({
+	embedder: () => va,
+	language: () => J,
+	options: () => Da
+}), ka = k({
 	parser: "svelte",
 	markup: !0
-}), ja = "embeddedSvelte", Ma = ["svelte"], Na = E(ja), Pa = D(ja), Fa = {
-	[Na]: {
+}), Aa = "embeddedSvelte", ja = ["svelte"], Ma = T(Aa), Na = E(Aa), Pa = {
+	[Ma]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...Ma] }],
+		default: [{ value: [...ja] }],
 		description: "Block comments that identify embedded Svelte in template literals. Requires the `prettier-plugin-svelte` plugin."
 	},
-	[Pa]: {
+	[Na]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [...Ma] }],
+		default: [{ value: [...ja] }],
 		description: "Tags that identify embedded Svelte in template literals. Requires the `prettier-plugin-svelte` plugin."
 	}
-}, Ia = /* @__PURE__ */ p({
-	embedder: () => Aa,
-	language: () => ja,
-	options: () => Fa
-}), La = A({
+}, Fa = /* @__PURE__ */ p({
+	embedder: () => ka,
+	language: () => Aa,
+	options: () => Pa
+}), Ia = k({
 	parser: "toml",
 	newlineHandling: "hardline"
-}), J = "embeddedToml", Ra = ["toml"], za = T(J), Ba = E(J), Va = D(J), Ha = {
+}), La = "embeddedToml", Ra = ["toml"], za = w(La), Ba = T(La), Va = E(La), Ha = {
 	[za]: {
 		category: "Embed",
 		type: "string",
@@ -1480,21 +1489,21 @@ var Er = "embeddedMotoko", Dr = ["motoko", "mo"], Or = E(Er), kr = D(Er), Ar = {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Block comments that make their subsequent template literals be identified as embedded TOML language. This option requires the `prettier-plugin-toml` plugin."
 	},
 	[Va]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Tags that make their subsequent template literals be identified as embedded TOML language. This option requires the `prettier-plugin-toml` plugin."
 	}
 }, Ua = /* @__PURE__ */ p({
-	embedder: () => La,
-	language: () => J,
+	embedder: () => Ia,
+	language: () => La,
 	options: () => Ha
-}), Wa = A({
+}), Wa = k({
 	parser: "typescript",
 	parserOption: "embeddedTsParser",
 	parserOptions: { filepath: void 0 }
@@ -1504,7 +1513,7 @@ var Er = "embeddedMotoko", Dr = ["motoko", "mo"], Or = E(Er), kr = D(Er), Ar = {
 	"cts",
 	"mts",
 	"typescript"
-], Ka = ["typescript", "babel-ts"], qa = T(Y), Ja = E(Y), Ya = D(Y), Xa = O(Y), Za = {
+], Ka = ["typescript", "babel-ts"], qa = w(Y), Ja = T(Y), Ya = E(Y), Xa = D(Y), Za = {
 	[qa]: {
 		category: "Embed",
 		type: "string",
@@ -1517,14 +1526,14 @@ var Er = "embeddedMotoko", Dr = ["motoko", "mo"], Or = E(Er), kr = D(Er), Ar = {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Block comments that make their subsequent template literals be identified as embedded TypeScript language."
 	},
 	[Ya]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Tags that make their subsequent template literals be identified as embedded TypeScript language."
 	},
 	[Xa]: {
@@ -1545,7 +1554,7 @@ var Er = "embeddedMotoko", Dr = ["motoko", "mo"], Or = E(Er), kr = D(Er), Ar = {
 	let o = {
 		...r,
 		...a
-	}, { node: s } = n, { createPlaceholder: c, placeholderRegex: l } = w(), { trimmedText: u, leadingWhitespaces: d, trailingWhitespaces: f } = y(s, c), p = x(n, t), m = [], h = 0;
+	}, { node: s } = n, { createPlaceholder: c, placeholderRegex: l } = C(), { trimmedText: u, leadingWhitespaces: d, trailingWhitespaces: f } = y(s, c), p = x(n, t), m = [], h = 0;
 	for (; h !== void 0;) {
 		let t = u.slice(h);
 		if (t.length === 0) break;
@@ -1562,7 +1571,7 @@ var Er = "embeddedMotoko", Dr = ["motoko", "mo"], Or = E(Er), kr = D(Er), Ar = {
 	"opml",
 	"rss",
 	"svg"
-], no = T(X), ro = E(X), io = D(X), ao = {
+], no = w(X), ro = T(X), io = E(X), ao = {
 	[no]: {
 		category: "Embed",
 		type: "string",
@@ -1575,14 +1584,14 @@ var Er = "embeddedMotoko", Dr = ["motoko", "mo"], Or = E(Er), kr = D(Er), Ar = {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Block comments that make their subsequent template literals be identified as embedded XML language. This option requires the `@prettier/plugin-xml` plugin."
 	},
 	[io]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Tags that make their subsequent template literals be identified as embedded XML language. This option requires the `@prettier/plugin-xml` plugin."
 	},
 	__embeddedXmlFragmentRecoverIndex: {
@@ -1659,10 +1668,10 @@ var fo = {
 	parseWithXmlPlugin: () => Z,
 	parseXml: () => uo,
 	parser: () => fo
-}), Q = "embeddedXQuery", mo = A({
+}), Q = "embeddedXQuery", mo = k({
 	parser: "xquery",
 	parserOption: `${Q}Parser`
-}), ho = ["xquery", "xq"], go = E(Q), _o = D(Q), vo = `${Q}Parser`, yo = {
+}), ho = ["xquery", "xq"], go = T(Q), _o = E(Q), vo = `${Q}Parser`, yo = {
 	[go]: {
 		category: "Embed",
 		type: "string",
@@ -1698,12 +1707,12 @@ var fo = {
 	let o = {
 		...r,
 		...a
-	}, { node: s } = n, { createPlaceholder: c, placeholderRegex: l } = w(), { trimmedText: u, leadingWhitespaces: d, trailingWhitespaces: f } = y(s, c), p = d.slice(d.lastIndexOf("\n") + 1), m = x(n, t);
-	return b(S(await e(p ? u.replace(RegExp(`(\\r?\\n)${ve(p)}`, "g"), "$1") : u, {
+	}, { node: s } = n, { createPlaceholder: c, placeholderRegex: l } = C(), { trimmedText: u, leadingWhitespaces: d, trailingWhitespaces: f } = y(s, c), p = d.slice(d.lastIndexOf("\n") + 1), m = x(n, t);
+	return b(S(await e(p ? u.replace(RegExp(`(\\r?\\n)${ye(p)}`, "g"), "$1") : u, {
 		...o,
 		parser: "yaml"
 	}), l, m), o, i, d, f);
-}, So = "embeddedYaml", Co = ["yaml", "yml"], wo = T(So), To = E(So), Eo = D(So), Do = {
+}, So = "embeddedYaml", Co = ["yaml", "yml"], wo = w(So), To = T(So), Eo = E(So), Do = {
 	[wo]: {
 		category: "Embed",
 		type: "string",
@@ -1716,14 +1725,14 @@ var fo = {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Block comments that make their subsequent template literals be identified as embedded YAML language."
 	},
 	[Eo]: {
 		category: "Embed",
 		type: "string",
 		array: !0,
-		default: [{ value: [k] }],
+		default: [{ value: [O] }],
 		description: "Tags that make their subsequent template literals be identified as embedded YAML language."
 	}
 }, Oo = /* @__PURE__ */ p({
@@ -1731,50 +1740,50 @@ var fo = {
 	language: () => So,
 	options: () => Do
 }), ko = [], Ao = {}, jo = {}, Mo = {}, No = /* #__PURE__ */ Object.assign({
-	"./astro/index.ts": Ee,
-	"./css/index.ts": Fe,
-	"./dockerfile/index.ts": He,
-	"./es/index.ts": Ze,
-	"./gherkin/index.ts": it,
-	"./glsl/index.ts": ft,
-	"./go-template/index.ts": yt,
-	"./graphql/index.ts": Dt,
-	"./handlebars/index.ts": Pt,
-	"./html/index.ts": Ut,
-	"./hugo/index.ts": Xt,
-	"./ini/index.ts": rn,
-	"./java/index.ts": dn,
-	"./jinja/index.ts": vn,
-	"./json/index.ts": On,
-	"./jsonata/index.ts": Fn,
-	"./jte/index.ts": Hn,
-	"./latex/index.ts": Yn,
-	"./liquid/index.ts": nr,
-	"./markdown/index.ts": gr,
-	"./marko/index.ts": Cr,
-	"./motoko/index.ts": jr,
-	"./mustache/index.ts": Rr,
-	"./nginx/index.ts": Gr,
-	"./noop/index.ts": Xr,
-	"./nunjucks/index.ts": ri,
-	"./pegjs/index.ts": ui,
-	"./php/index.ts": _i,
-	"./powershell/index.ts": wi,
+	"./astro/index.ts": De,
+	"./css/index.ts": Ie,
+	"./dockerfile/index.ts": Ue,
+	"./es/index.ts": Qe,
+	"./gherkin/index.ts": at,
+	"./glsl/index.ts": pt,
+	"./go-template/index.ts": bt,
+	"./graphql/index.ts": Ot,
+	"./handlebars/index.ts": Ft,
+	"./html/index.ts": Wt,
+	"./hugo/index.ts": Zt,
+	"./ini/index.ts": an,
+	"./java/index.ts": fn,
+	"./jinja/index.ts": yn,
+	"./json/index.ts": kn,
+	"./jsonata/index.ts": In,
+	"./jte/index.ts": Un,
+	"./latex/index.ts": Xn,
+	"./liquid/index.ts": rr,
+	"./markdown/index.ts": _r,
+	"./marko/index.ts": wr,
+	"./motoko/index.ts": Mr,
+	"./mustache/index.ts": zr,
+	"./nginx/index.ts": Kr,
+	"./noop/index.ts": Zr,
+	"./nunjucks/index.ts": ii,
+	"./pegjs/index.ts": di,
+	"./php/index.ts": vi,
+	"./powershell/index.ts": Ti,
 	"./prisma/index.ts": Mi,
-	"./properties/index.ts": Bi,
-	"./pug/index.ts": Ji,
-	"./ruby/index.ts": ra,
-	"./sh/index.ts": da,
-	"./solidity/index.ts": va,
-	"./sql/index.ts": ka,
-	"./svelte/index.ts": Ia,
+	"./properties/index.ts": zi,
+	"./pug/index.ts": qi,
+	"./ruby/index.ts": na,
+	"./sh/index.ts": ua,
+	"./solidity/index.ts": _a,
+	"./sql/index.ts": Oa,
+	"./svelte/index.ts": Fa,
 	"./toml/index.ts": Ua,
 	"./ts/index.ts": Qa,
 	"./xml/index.ts": po,
 	"./xquery/index.ts": bo,
 	"./yaml/index.ts": Oo
 });
-for (let { language: e, parser: t, embedder: n, options: r } of Object.values(No)) _e(ko, e, H), t && (Ao[e] = t), n && (jo[e] = n), Object.assign(Mo, r);
+for (let { language: e, parser: t, embedder: n, options: r } of Object.values(No)) _e(ko, e, V), t && (Ao[e] = t), n && (jo[e] = n), Object.assign(Mo, r);
 //#endregion
 //#region src/options.ts
 var Po = "noEmbeddedIdentificationByComment", Fo = "noEmbeddedIdentificationByTag", Io = "preserveEmbeddedExteriorWhitespaces", Lo = "noEmbeddedMultiLineIndentation", Ro = "embeddedOverrides", zo = {
@@ -1858,40 +1867,35 @@ async function Jo(e, t) {
 	return i(typeof a == "string" ? r(a) : process.env.PWD ?? process.cwd(), e);
 }
 var Yo = async (e, t) => {
+	try {
+		return Uo.parse(e);
+	} catch {}
 	let n;
 	try {
 		n = (await import("node:path")).extname(e);
 	} catch {
-		try {
-			return Uo.parse(e);
-		} catch {
-			console.error("Failed to parse embeddedOverrides as a json object");
-			return;
-		}
+		console.error("Failed to parse embeddedOverrides as a json object");
+		return;
 	}
-	let r = Jo(e, t);
+	let r = () => Jo(e, t);
 	if (n === ".json" || n === ".jsonc") {
-		let e = await r, t = await Go(e);
+		let e = await r(), t = await Go(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 qo(e);
+		let e = await r(), t = await qo(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 qo(e);
+		let e = await r(), t = await qo(e);
 		if (t !== void 0) return t;
 		console.error(`Failed to parse the ts module file: ${e}`);
 	} else {
 		if (n === "") {
-			let e = await Go(await r);
+			let e = await Go(await r());
 			if (e !== void 0) return e;
 		}
-		try {
-			return Uo.parse(e);
-		} catch {
-			console.error("Failed to parse embeddedOverrides as a json object");
-		}
+		console.error("Failed to parse embeddedOverrides as a json object");
 	}
 }, Xo = /* @__PURE__ */ new WeakMap();
 async function Zo(e, { commentOrTag: t, kind: n }) {
@@ -1942,20 +1946,20 @@ var es = (() => {
 		"typeAnnotation",
 		"decorators"
 	]);
-	return (t, n, r) => {
+	return (t, n, r, i) => {
 		if (/^\/.*\/[dgimsuvy]*$/.test(n)) return $o(t, n);
-		let i;
+		let a = i?.get(n);
 		try {
-			let e = r(`${n}\`\``);
+			let e = i?.has(n) ? a : r(`${n}\`\``);
 			if (e instanceof Promise) throw TypeError("Async parse function hasn't been supported yet.");
-			i = e;
+			a = e;
 		} catch {
-			return !1;
+			return i?.set(n, void 0), !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 Qo(t)) if (cs(n, a.tag, e)) return !0;
+		if (i?.set(n, a), !a || (a.type === "File" && (a = a.program), a.type !== "Program" || a.body[0]?.type !== "ExpressionStatement")) return !1;
+		let o = a.body[0]?.expression;
+		if (o?.type !== "TaggedTemplateExpression") return !1;
+		for (let n of Qo(t)) if (cs(n, o.tag, e)) return !0;
 		return !1;
 	};
 })();
@@ -1976,19 +1980,19 @@ function ns({ parent: e }) {
 }
 function rs(e, t) {
 	return e.noEmbeddedIdentificationByComment?.includes(t) ?? !1 ? function* (e) {} : function* (t) {
-		let n = e[E(t)] ?? ["9ff2b366e8ca4c97b9aed1a29b5b94ed"];
-		n[0] === "9ff2b366e8ca4c97b9aed1a29b5b94ed" ? yield* e[T(t)] ?? [] : yield* n;
+		let n = e[T(t)] ?? ["9ff2b366e8ca4c97b9aed1a29b5b94ed"];
+		n[0] === "9ff2b366e8ca4c97b9aed1a29b5b94ed" ? yield* e[w(t)] ?? [] : yield* n;
 	};
 }
 function is(e, t) {
 	return typeof t == "string" ? e.noEmbeddedIdentificationByTag?.includes(t) ?? !1 ? function* (e) {} : function* (t) {
-		let n = e[D(t)] ?? ["9ff2b366e8ca4c97b9aed1a29b5b94ed"];
-		n[0] === "9ff2b366e8ca4c97b9aed1a29b5b94ed" ? yield* e[T(t)] ?? [] : yield* n;
+		let n = e[E(t)] ?? ["9ff2b366e8ca4c97b9aed1a29b5b94ed"];
+		n[0] === "9ff2b366e8ca4c97b9aed1a29b5b94ed" ? yield* e[w(t)] ?? [] : yield* n;
 	} : function* (t) {
-		let n = e[D(t)] ?? ["9ff2b366e8ca4c97b9aed1a29b5b94ed"];
+		let n = e[E(t)] ?? ["9ff2b366e8ca4c97b9aed1a29b5b94ed"];
 		if (n[0] === "9ff2b366e8ca4c97b9aed1a29b5b94ed") {
 			let { noEmbeddedIdentificationByTag: n } = e;
-			for (let r of e[T(t)] ?? []) n?.includes(r) || (yield r);
+			for (let r of e[w(t)] ?? []) n?.includes(r) || (yield r);
 		} else yield* n;
 	};
 }
@@ -2001,19 +2005,15 @@ function as(e, t, n, r, i) {
 		kind: r
 	});
 	return async (...e) => {
-		try {
-			let t = await a(...e, {
-				commentOrTag: n,
-				kind: r,
-				embeddedOverrideOptions: await o
-			});
-			return Wo({
-				embed: !0,
-				...t.label
-			}, t);
-		} catch (e) {
-			throw console.error(e), e;
-		}
+		let t = await a(...e, {
+			commentOrTag: n,
+			kind: r,
+			embeddedOverrideOptions: await o
+		});
+		return Wo({
+			embed: !0,
+			...t.label
+		}, t);
 	};
 }
 function os(e, t, n) {
@@ -2031,7 +2031,7 @@ function cs(e, t, n) {
 }
 //#endregion
 //#region src/printers.ts
-var { estree: ls } = u, { embed: us } = ls, ds = (e, t) => {
+var { estree: ls } = u, { embed: us } = ls, ds = /* @__PURE__ */ new WeakMap(), fs = (e, t) => {
 	let { node: n } = e;
 	if (n.type !== "TemplateLiteral" || n.quasis.some(({ value: { cooked: e } }) => e === null)) return null;
 	let r = ts(e);
@@ -2064,20 +2064,22 @@ var { estree: ls } = u, { embed: us } = ls, ds = (e, t) => {
 		return us?.(e, t) ?? null;
 	}
 	if (i !== void 0) {
-		let e = (e) => Bo[t.parser].parse(e, t), r = is(t);
-		for (let a of ko) {
-			let o;
-			for (let t of r(a)) if (es(i, t, e)) {
-				o = t;
+		let e = ds.get(t);
+		e || (e = /* @__PURE__ */ new Map(), ds.set(t, e));
+		let r = (e) => Bo[t.parser].parse(e, t), a = is(t);
+		for (let o of ko) {
+			let s;
+			for (let t of a(o)) if (es(i, t, r, e)) {
+				s = t;
 				break;
 			}
-			if (o !== void 0) return as(n, a, o, "tag", t);
+			if (s !== void 0) return as(n, o, s, "tag", t);
 		}
 	}
 	return us?.(e, t) ?? null;
-}, fs = { estree: {
+}, ps = { estree: {
 	...ls,
-	embed: ds
+	embed: fs
 } };
 //#endregion
-export { zo as options, Bo as parsers, fs as printers };
+export { zo as options, Bo as parsers, ps as printers };