prettier-plugin-embed 0.0.1 → 0.0.3

package/dist/embedded/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./register.js";
+export type { EmbeddedNames, EmbeddedParsers, EmbeddedEmbedders, EmbeddedOptions, } from "./types.js";

package/dist/embedded/noop/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./name.js";
+export * from "./option.js";

package/dist/embedded/noop/name.d.ts

@@ -0,0 +1,6 @@
+export declare const name = "embeddedNoop";
+declare module "../types.js" {
+    interface EmbeddedNamesHolder {
+        [name]: void;
+    }
+}

package/dist/embedded/noop/option.d.ts

@@ -0,0 +1,15 @@
+import { SupportOption } from "prettier";
+import { name } from "./name.js";
+export declare const option: SupportOption;
+declare module "../types.js" {
+    interface EmbeddedOptions {
+        [name]: typeof option;
+    }
+}
+export interface PrettierPluginEmbedOptions {
+    [name]?: string[];
+}
+declare module "prettier" {
+    interface Options extends PrettierPluginEmbedOptions {
+    }
+}

package/dist/embedded/php/embedder.d.ts

@@ -0,0 +1,9 @@
+import type { Options } from "prettier";
+import type { Embedder } from "../../types.js";
+import { name } from "./name.js";
+export declare const embedder: Embedder<Options>;
+declare module "../types.js" {
+    interface EmbeddedEmbedders {
+        [name]: typeof embedder;
+    }
+}

package/dist/embedded/php/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./name.js";
+export * from "./embedder.js";
+export * from "./option.js";

package/dist/embedded/php/name.d.ts

@@ -0,0 +1,6 @@
+export declare const name = "embeddedPhp";
+declare module "../types.js" {
+    interface EmbeddedNamesHolder {
+        [name]: void;
+    }
+}

package/dist/embedded/php/option.d.ts

@@ -0,0 +1,20 @@
+import { SupportOption } from "prettier";
+import { name } from "./name.js";
+export declare const option: SupportOption;
+declare module "../types.js" {
+    interface EmbeddedOptions {
+        [name]: typeof option;
+    }
+}
+export interface PrettierPluginDepsOptions {
+    phpVersion?: "5.0" | "5.1" | "5.2" | "5.3" | "5.4" | "5.5" | "5.6" | "7.0" | "7.1" | "7.2" | "7.3" | "7.4" | "8.0" | "8.1" | "8.2";
+    trailingCommaPHP?: boolean;
+    braceStyle?: "psr-2" | "per-cs" | "1tbs";
+}
+export interface PrettierPluginEmbedOptions {
+    [name]?: string[];
+}
+declare module "prettier" {
+    interface Options extends PrettierPluginDepsOptions, PrettierPluginEmbedOptions {
+    }
+}

package/dist/embedded/register.d.ts

@@ -0,0 +1,5 @@
+import type { EmbeddedEmbedders, EmbeddedNames, EmbeddedParsers, EmbeddedOptions } from "./types.js";
+export declare const embeddedNames: EmbeddedNames[];
+export declare const embeddedParsers: EmbeddedParsers;
+export declare const embeddedEmbedders: EmbeddedEmbedders;
+export declare const embeddedOptions: EmbeddedOptions;

package/dist/embedded/sql/embedder.d.ts

@@ -0,0 +1,9 @@
+import type { Options } from "prettier";
+import type { Embedder } from "../../types.js";
+import { name } from "./name.js";
+export declare const embedder: Embedder<Options>;
+declare module "../types.js" {
+    interface EmbeddedEmbedders {
+        [name]: typeof embedder;
+    }
+}

package/dist/embedded/sql/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./name.js";
+export * from "./embedder.js";
+export * from "./option.js";

package/dist/embedded/sql/name.d.ts

@@ -0,0 +1,6 @@
+export declare const name = "embeddedSql";
+declare module "../types.js" {
+    interface EmbeddedNamesHolder {
+        [name]: void;
+    }
+}

package/dist/embedded/sql/option.d.ts

@@ -0,0 +1,21 @@
+import { SupportOption } from "prettier";
+import type { SqlBaseOptions as PrettierPluginDepsOptions } from "prettier-plugin-sql";
+import { name } from "./name.js";
+export declare const option: SupportOption;
+declare module "../types.js" {
+    interface EmbeddedOptions {
+        [name]: typeof option;
+    }
+}
+export declare const SQL_FORMATTER_LANGUAGES: readonly ["sql", "bigquery", "hive", "mariadb", "mysql", "postgresql", "db2", "plsql", "n1ql", "redshift", "singlestoredb", "spark", "sqlite", "transactsql", "tsql", "trino"];
+export declare const NODE_SQL_PARSER_DATABASES: readonly ["bigquery", "db2", "hive", "mariadb", "mysql", "postgresql", "transactsql", "flinksql"];
+export type SqlFormatterLanguage = (typeof SQL_FORMATTER_LANGUAGES)[number];
+export type NodeSqlParserDataBase = (typeof NODE_SQL_PARSER_DATABASES)[number];
+export { PrettierPluginDepsOptions };
+export interface PrettierPluginEmbedOptions {
+    [name]?: SqlFormatterLanguage[] | NodeSqlParserDataBase[] | string[];
+}
+declare module "prettier" {
+    interface Options extends PrettierPluginDepsOptions, PrettierPluginEmbedOptions {
+    }
+}

package/dist/embedded/types.d.ts

@@ -0,0 +1,14 @@
+import { Parser, SupportOption, Options } from "prettier";
+import { Embedder } from "../types.js";
+export interface EmbeddedParsers {
+    [name: string]: Parser | undefined;
+}
+export interface EmbeddedEmbedders {
+    [name: string]: Embedder<Options> | undefined;
+}
+export interface EmbeddedOptions {
+    [name: string]: SupportOption | undefined;
+}
+export interface EmbeddedNamesHolder {
+}
+export type EmbeddedNames = keyof EmbeddedNamesHolder;

package/dist/embedded/utils.d.ts

@@ -0,0 +1,10 @@
+import { Expression, Comment, TemplateLiteral } from "estree";
+import { AstPath, Options } from "prettier";
+import { builders } from "prettier/doc";
+import { InternalPrintFun } from "../types.js";
+export declare function printTemplateExpression(path: AstPath<Expression & {
+    comments?: Comment[];
+}>, print: InternalPrintFun): builders.Doc[];
+export declare function printTemplateExpressions(path: AstPath<TemplateLiteral>, print: InternalPrintFun): builders.Doc[][];
+export declare function throwIfPluginIsNotFound(pluginName: string, options: Options, lang: string): void;
+export declare function insertEmbeddedLanguageName(names: string[], name: string, headName: string): void;

package/dist/embedded/xml/embedder.d.ts

@@ -0,0 +1,9 @@
+import type { Options } from "prettier";
+import type { Embedder } from "../../types.js";
+import { name } from "./name.js";
+export declare const embedder: Embedder<Options>;
+declare module "../types.js" {
+    interface EmbeddedEmbedders {
+        [name]: typeof embedder;
+    }
+}

package/dist/embedded/xml/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./name.js";
+export * from "./parser.js";
+export * from "./embedder.js";
+export * from "./option.js";

package/dist/embedded/xml/name.d.ts

@@ -0,0 +1,6 @@
+export declare const name = "embeddedXml";
+declare module "../types.js" {
+    interface EmbeddedNamesHolder {
+        [name]: void;
+    }
+}

package/dist/embedded/xml/option.d.ts

@@ -0,0 +1,21 @@
+import { SupportOption } from "prettier";
+import { name } from "./name.js";
+export declare const option: SupportOption;
+declare module "../types.js" {
+    interface EmbeddedOptions {
+        [name]: typeof option;
+    }
+}
+export interface PrettierPluginDepsOptions {
+    xmlSelfClosingSpace?: boolean;
+    xmlWhitespaceSensitivity?: "strict" | "preserve" | "ignore";
+    xmlSortAttributesByKey?: boolean;
+    xmlQuoteAttributes?: "preserve" | "single" | "double";
+}
+export interface PrettierPluginEmbedOptions {
+    [name]?: string[];
+}
+declare module "prettier" {
+    interface Options extends PrettierPluginDepsOptions, PrettierPluginEmbedOptions {
+    }
+}

package/dist/embedded/xml/parser.d.ts

@@ -0,0 +1,11 @@
+import type { Parser } from "prettier";
+import { parse as xmlToolsParse } from "@xml-tools/parser";
+import { name } from "./name.js";
+type CstNode = ReturnType<typeof xmlToolsParse>["cst"];
+export declare const parser: Parser<CstNode>;
+declare module "../types.js" {
+    interface EmbeddedParsers {
+        [name]: Parser;
+    }
+}
+export {};

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { parsers } from "./parsers.js";
 export { printers } from "./printers.js";
 export { options } from "./options.js";
-export type * from "./options.js";
+export type * from "./types.js";
+export * from "./embedded/index.js";

package/dist/index.js

@@ -1,146 +1,467 @@
-import L from "prettier/parser-babel";
-import R from "prettier/parser-espree";
-import S from "prettier/parser-flow";
-import k from "prettier/parser-typescript";
-import { printers as A } from "prettier/plugins/estree.mjs";
-import { builders as $, utils as V } from "prettier/doc";
-const oe = {
-  ...L.parsers,
-  ...R.parsers,
-  ...S.parsers,
-  ...k.parsers
-};
-let f;
-const q = new Uint8Array(16);
-function C() {
-  if (!f && (f = typeof crypto < "u" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto), !f))
+import H from "prettier/parser-babel";
+import X from "prettier/parser-espree";
+import J from "prettier/parser-flow";
+import K from "prettier/parser-typescript";
+import { builders as E, utils as N } from "prettier/doc";
+import { parse as Y } from "@xml-tools/parser";
+import { printers as Z } from "prettier/plugins/estree.mjs";
+const C = "embeddedNoop", ee = {
+  category: "Global",
+  type: "string",
+  array: !0,
+  default: [{ value: [] }],
+  description: "Specify embedded languages that will not be formatted."
+}, te = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  name: C,
+  option: ee
+}, Symbol.toStringTag, { value: "Module" })), ne = "embeddedPhp";
+let S;
+const re = new Uint8Array(16);
+function oe() {
+  if (!S && (S = typeof crypto < "u" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto), !S))
     throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
-  return f(q);
+  return S(re);
 }
-const o = [];
+const c = [];
 for (let e = 0; e < 256; ++e)
-  o.push((e + 256).toString(16).slice(1));
-function H(e, n = 0) {
-  return o[e[n + 0]] + o[e[n + 1]] + o[e[n + 2]] + o[e[n + 3]] + "-" + o[e[n + 4]] + o[e[n + 5]] + "-" + o[e[n + 6]] + o[e[n + 7]] + "-" + o[e[n + 8]] + o[e[n + 9]] + "-" + o[e[n + 10]] + o[e[n + 11]] + o[e[n + 12]] + o[e[n + 13]] + o[e[n + 14]] + o[e[n + 15]];
+  c.push((e + 256).toString(16).slice(1));
+function se(e, t = 0) {
+  return c[e[t + 0]] + c[e[t + 1]] + c[e[t + 2]] + c[e[t + 3]] + "-" + c[e[t + 4]] + c[e[t + 5]] + "-" + c[e[t + 6]] + c[e[t + 7]] + "-" + c[e[t + 8]] + c[e[t + 9]] + "-" + c[e[t + 10]] + c[e[t + 11]] + c[e[t + 12]] + c[e[t + 13]] + c[e[t + 14]] + c[e[t + 15]];
 }
-const W = typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto), v = {
-  randomUUID: W
+const ie = typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto), I = {
+  randomUUID: ie
 };
-function _(e, n, r) {
-  if (v.randomUUID && !n && !e)
-    return v.randomUUID();
+function k(e, t, n) {
+  if (I.randomUUID && !t && !e)
+    return I.randomUUID();
   e = e || {};
-  const t = e.random || (e.rng || C)();
-  if (t[6] = t[6] & 15 | 64, t[8] = t[8] & 63 | 128, n) {
-    r = r || 0;
-    for (let s = 0; s < 16; ++s)
-      n[r + s] = t[s];
-    return n;
+  const o = e.random || (e.rng || oe)();
+  if (o[6] = o[6] & 15 | 64, o[8] = o[8] & 63 | 128, t) {
+    n = n || 0;
+    for (let r = 0; r < 16; ++r)
+      t[n + r] = o[r];
+    return t;
+  }
+  return se(o);
+}
+const { group: le, indent: ce, softline: U, lineSuffixBoundary: ae } = E;
+function ue(e, t) {
+  var r;
+  const { node: n } = e;
+  let o = t();
+  return (r = n == null ? void 0 : n.comments) != null && r.length && (o = le([ce([U, o]), U])), ["${", o, ae, "}"];
+}
+function j(e, t) {
+  return e.map(
+    (n) => ue(n, t),
+    "expressions"
+  );
+}
+function A(e, t, n) {
+  var o;
+  if (!(((o = t.plugins) == null ? void 0 : o.map((r) => r.name)) ?? []).includes(e))
+    throw new Error(
+      `Cannot format embedded language "${n}" because plugin "${e}" is not loaded.`
+    );
+}
+function de(e, t, n) {
+  if (t === n) {
+    e.unshift(t);
+    return;
+  }
+  let o = 0, r = e.length;
+  for (; o < r; ) {
+    const s = o + r >>> 1;
+    if (e[s] === n) {
+      e.push(t);
+      return;
+    }
+    e[s] < t ? o = s + 1 : r = s;
   }
-  return H(t);
+  e.splice(o, 0, t);
 }
-const { label: j, softline: I, hardline: B, line: F, group: a, indent: h, lineSuffixBoundary: G } = $, { mapDoc: N } = V, T = _(), O = new RegExp(T + "-(\\d+)", "g");
-async function X(e, n, r, t) {
+const { label: pe, hardline: me, line: ge, group: w, indent: fe } = E, { mapDoc: be } = N, ye = async (e, t, n, o, r) => {
   try {
-    const { node: s } = r, i = s.quasis.map(
-      (u, p, { length: g }) => p === g - 1 ? u.value.cooked : u.value.cooked + J(p)
-    ).join(""), d = z(r, n), U = 0, m = await e(i, {
-      parser: "xml"
-    }), l = N(m, (u) => {
-      if (typeof u != "string")
-        return u;
-      const p = [], g = u.split(O);
-      for (let y = 0; y < g.length; y++) {
-        let c = g[y];
-        if (y % 2 == 0) {
-          c && (c = c.replaceAll(/([\\`]|\${)/g, "\\$1"), t.__embeddedInHtml && (c = c.replaceAll(/<\/(?=script\b)/gi, "<\\/")), p.push(c));
-          continue;
+    A("@prettier/plugin-php", o, r);
+    const s = "$p" + k().replaceAll("-", ""), { node: a } = n, b = a.quasis.map(
+      (i, l, { length: m }) => l === m - 1 ? i.value.cooked : i.value.cooked + `${s}${l}`
+    ).join("");
+    let d = "", y = 0;
+    const g = /^\s+/.exec(b);
+    g && (y = g.index + g[0].length, d = " ");
+    const x = /\s$/.test(b) ? " " : "", _ = j(n, t), q = await e(b.slice(y), {
+      parser: "php"
+    });
+    let h = !1;
+    const $ = be(q, (i) => {
+      if (typeof i != "string")
+        return Array.isArray(i) || (i.type === "group" && i.break || i.type === "line" && (i.hard || i.literal)) && (h = !0), i;
+      const l = [], m = i.split(new RegExp("\\" + s + "(\\d+)", "g"));
+      for (let u = 0; u < m.length; u++) {
+        let f = m[u];
+        if (u % 2 == 0) {
+          if (!f)
+            continue;
+          f = f.replaceAll(/([\\`]|\${)/g, "\\$1"), l.push(f);
+        } else {
+          const v = Number(f);
+          l.push(_[v]);
         }
-        const w = Number(c);
-        p.push(d[w]);
       }
-      return p;
-    }), E = /^\s/.test(i) ? " " : "", D = /\s$/.test(i) ? " " : "", x = t.xmlWhitespaceSensitivity === "ignore" ? B : E && D ? F : null;
-    return x ? a([
+      return l;
+    }), p = h ? me : d && x ? ge : null;
+    return p ? w([
       "`",
-      h([x, a(l)]),
-      x,
+      fe([p, w($)]),
+      p,
       "`"
-    ]) : j(
+    ]) : pe(
       { hug: !1 },
-      a([
+      w([
         "`",
-        E,
-        U > 1 ? h(a(l)) : a(l),
-        D,
+        d,
+        w([$]),
+        x,
         "`"
       ])
     );
   } catch (s) {
     throw console.error(s), s;
   }
+}, he = {
+  category: "Global",
+  type: "string",
+  array: !0,
+  default: [{ value: ["php"] }],
+  description: "Specify embedded PHP languages. This requires @prettier/plugin-php"
+}, $e = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  embedder: ye,
+  name: ne,
+  option: he
+}, Symbol.toStringTag, { value: "Module" })), xe = "embeddedSql", _e = {
+  category: "Global",
+  type: "string",
+  array: !0,
+  default: [{ value: ["sql"] }],
+  description: "Specify embedded SQL languages. This requires prettier-plugin-sql"
+}, G = [
+  "sql",
+  "bigquery",
+  "hive",
+  "mariadb",
+  "mysql",
+  "postgresql",
+  "db2",
+  "plsql",
+  "n1ql",
+  "redshift",
+  "singlestoredb",
+  "spark",
+  "sqlite",
+  "transactsql",
+  "tsql",
+  "trino"
+], W = [
+  "bigquery",
+  "db2",
+  "hive",
+  "mariadb",
+  "mysql",
+  "postgresql",
+  "transactsql",
+  "flinksql"
+], { label: ve, hardline: R, group: O, line: qe, indent: Ee } = E, { mapDoc: Se } = N, we = async (e, t, n, o, r, s) => {
+  try {
+    A("prettier-plugin-sql", o, r);
+    const a = "p" + k().replaceAll("-", ""), { node: b } = n, d = b.quasis.map(
+      (i, l, { length: m }) => l === m - 1 ? i.value.cooked : i.value.cooked + `${a}${l}`
+    ).join(""), y = /^\s/.test(d) ? " " : "", g = /\s$/.test(d) ? " " : "", x = j(n, t), _ = Te(o, r, s);
+    if (typeof _ > "u")
+      throw new SyntaxError(`Unrecognized language: ${r}`);
+    const q = await e(d, {
+      parser: "sql",
+      ..._
+    });
+    let h = !1;
+    const $ = Se(q, (i) => {
+      if (typeof i != "string")
+        return i;
+      const l = [], m = i.split(new RegExp(a + "(\\d+)", "g"));
+      for (let u = 0; u < m.length; u++) {
+        let f = m[u];
+        if (u % 2 == 0) {
+          if (!f)
+            continue;
+          f = f.replaceAll(/([\\`]|\${)/g, "\\$1"), f.split(/(\n)/).forEach(
+            (v) => v === `
+` ? (h = !0, l.push(R)) : l.push(v)
+          );
+        } else {
+          const v = Number(f);
+          l.push(x[v]);
+        }
+      }
+      return l;
+    }), p = h ? R : y && g ? qe : null;
+    return p ? O([
+      "`",
+      Ee([p, O($)]),
+      p,
+      "`"
+    ]) : ve(
+      { hug: !1 },
+      O([
+        "`",
+        y,
+        O($),
+        g,
+        "`"
+      ])
+    );
+  } catch (a) {
+    throw console.error(a), a;
+  }
+}, Oe = {
+  "sql-formatter": (e) => G.includes(e),
+  "node-sql-parser": (e) => W.includes(e)
+};
+function B(e, t) {
+  for (const n of t)
+    if (Oe[n](e))
+      return {
+        formatter: n,
+        language: e
+      };
 }
-function J(e) {
-  return T + "-" + e;
+function F(e, t, n) {
+  let o = B(e, n);
+  if (o)
+    return o;
+  const r = t.indexOf(e);
+  for (let s = r - 1; s >= 0; --s)
+    if (o = B(t[s], n), o)
+      return o;
 }
-function P(e, n) {
-  var s;
-  const { node: r } = e;
-  let t = n();
-  return (s = r == null ? void 0 : r.comments) != null && s.length && (t = a([h([I, t]), I])), ["${", t, G, "}"];
+function Te(e, t, n) {
+  return e.formatter === "sql-formatter" ? F(t, n, [
+    "sql-formatter",
+    "node-sql-parser"
+  ]) : F(t, n, [
+    "node-sql-parser",
+    "sql-formatter"
+  ]);
 }
-function z(e, n) {
-  return e.map(
-    (r) => P(r, n),
-    "expressions"
+const De = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  NODE_SQL_PARSER_DATABASES: W,
+  SQL_FORMATTER_LANGUAGES: G,
+  embedder: we,
+  name: xe,
+  option: _e
+}, Symbol.toStringTag, { value: "Module" })), M = "embeddedXml";
+function P(e, t) {
+  const n = new SyntaxError(
+    e + " (" + t.loc.start.line + ":" + t.loc.start.column + ")"
   );
+  return Object.assign(n, t);
 }
-const K = {
-  xml: X
-}, { estree: b } = A, M = function(e, n) {
-  var t;
-  const { node: r } = e;
-  if (r.type !== "TemplateLiteral" || r.quasis.some(({ value: { cooked: s } }) => s === null))
+const Ne = {
+  parse(e) {
+    const { lexErrors: t, parseErrors: n, cst: o } = Y(e);
+    if (t.length > 0) {
+      const r = t[0];
+      throw P(r.message, {
+        loc: {
+          start: { line: r.line, column: r.column },
+          end: {
+            line: r.line,
+            column: r.column + r.length
+          }
+        }
+      });
+    }
+    if (n.length > 0) {
+      const r = n[0];
+      throw P(r.message, {
+        loc: {
+          start: {
+            line: r.token.startLine ?? NaN,
+            column: r.token.startColumn ?? NaN
+          },
+          end: {
+            line: r.token.endLine ?? NaN,
+            column: r.token.endColumn ?? NaN
+          }
+        }
+      });
+    }
+    return o;
+  },
+  astFormat: "xml",
+  locStart(e) {
+    return e.location.startOffset;
+  },
+  locEnd(e) {
+    return e.location.endOffset ?? NaN;
+  }
+}, { label: ke, hardline: je, line: Ae, group: T, indent: Le } = E, { mapDoc: Ie } = N, Ue = async (e, t, n, o, r) => {
+  try {
+    A("@prettier/plugin-xml", o, r);
+    const s = k(), { node: a } = n, b = a.quasis.map(
+      (p, i, { length: l }) => i === l - 1 ? p.value.cooked : p.value.cooked + `${s}-${i}`
+    ).join("");
+    let d = "", y = 0;
+    const g = /^\s+/.exec(b);
+    g && (y = g.index + g[0].length, d = " ");
+    const x = /\s$/.test(b) ? " " : "", _ = j(n, t), q = await e(b.slice(y), {
+      parser: M
+    }), h = Ie(q, (p) => {
+      if (typeof p != "string")
+        return p;
+      const i = [], l = p.split(new RegExp(s + "-(\\d+)", "g"));
+      for (let m = 0; m < l.length; m++) {
+        let u = l[m];
+        if (m % 2 == 0) {
+          if (!u)
+            continue;
+          u = u.replaceAll(/([\\`]|\${)/g, "\\$1"), i.push(u);
+        } else {
+          const f = Number(u);
+          i.push(_[f]);
+        }
+      }
+      return i;
+    }), $ = o.xmlWhitespaceSensitivity === "ignore" ? je : d && x ? Ae : null;
+    return $ ? T([
+      "`",
+      Le([$, T(h)]),
+      $,
+      "`"
+    ]) : ke(
+      { hug: !1 },
+      T([
+        "`",
+        d,
+        T(h),
+        x,
+        "`"
+      ])
+    );
+  } catch (s) {
+    throw console.error(s), s;
+  }
+}, Re = {
+  category: "Global",
+  type: "string",
+  array: !0,
+  default: [{ value: ["xml", "svg"] }],
+  description: "Specify embedded XML languages. This requires @prettier/plugin-xml"
+}, Be = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  embedder: Ue,
+  name: M,
+  option: Re,
+  parser: Ne
+}, Symbol.toStringTag, { value: "Module" })), L = [], z = {}, V = {}, Q = {}, Fe = /* @__PURE__ */ Object.assign({
+  "./noop/index.ts": te,
+  "./php/index.ts": $e,
+  "./sql/index.ts": De,
+  "./xml/index.ts": Be
+});
+Object.values(Fe).forEach(({ name: e, parser: t, embedder: n, option: o }) => {
+  de(L, e, C), t && (z[e] = t), n && (V[e] = n), Q[e] = o;
+});
+const Je = {
+  // parsers from internal
+  // TODO: find out which parsers are required and which are optional
+  ...H.parsers,
+  ...X.parsers,
+  ...J.parsers,
+  ...K.parsers,
+  // parsers from this plugin
+  ...z
+};
+console.log(L);
+const { estree: D } = Z, Pe = function(e, t) {
+  var o;
+  const { node: n } = e;
+  if (n.type !== "TemplateLiteral" || n.quasis.some(({ value: { cooked: r } }) => r === null))
     return null;
-  for (const { comment: s, tag: i, embedder: d } of JSON.parse(
-    n.embeddedLanguages ?? "[]"
-  )) {
-    if (!Q(e, typeof i == "string" ? [i] : i))
+  for (const r of L) {
+    const s = t[r];
+    if (!s)
       continue;
-    let m;
-    if (typeof d == "string") {
-      m = K[d];
-      const l = e.node;
-      if (l.quasis.length === 1 && l.quasis[0].value.raw.trim() === "")
-        return "``";
-    } else
-      m = d ?? null;
-    return m;
+    const a = Ce(
+      e,
+      s,
+      t.disableEmbeddedDetectionByComment ?? []
+    ) ?? Ge(e, s, t.disableEmbeddedDetectionByTag ?? []);
+    if (a === void 0)
+      continue;
+    const b = V[r];
+    if (!b)
+      return null;
+    const d = e.node;
+    return d.quasis.length === 1 && d.quasis[0].value.raw.trim() === "" ? "``" : async (...y) => {
+      const g = await b(...y, a, s);
+      return E.label(
+        { embed: !0, ...g.label },
+        g
+      );
+    };
   }
-  return ((t = b.embed) == null ? void 0 : t.call(b, e, n)) ?? null;
+  return ((o = D.embed) == null ? void 0 : o.call(D, e, t)) ?? null;
 };
-function Q({ node: e, parent: n }, r) {
-  for (const t of r)
-    if (e.type === "TemplateLiteral" && (n == null ? void 0 : n.type) === "TaggedTemplateExpression" && n.tag.type === "Identifier" && n.tag.name === t)
-      return !0;
-  return !1;
+function Ce({ node: e, parent: t }, n, o) {
+  if (n.length === 0 || e.type !== "TemplateLiteral")
+    return;
+  const r = e.comments ?? (t == null ? void 0 : t.comments);
+  if (!r)
+    return;
+  const s = r[r.length - 1];
+  if (!(s.type !== "Block" || !s.leading)) {
+    for (const a of n)
+      if (` ${a} ` === s.value && !o.includes(a))
+        return a;
+  }
+}
+function Ge({ node: e, parent: t }, n, o) {
+  if (n.length !== 0 && !(e.type !== "TemplateLiteral" || (t == null ? void 0 : t.type) !== "TaggedTemplateExpression" || t.tag.type !== "Identifier")) {
+    for (const r of n)
+      if (t.tag.name === r && !o.includes(r))
+        return r;
+  }
 }
-const se = {
+const Ke = {
   estree: {
-    ...b,
-    embed: M
+    ...D,
+    embed: Pe
   }
-}, ie = {
-  embeddedLanguages: {
+}, Ye = {
+  ...Q,
+  disableEmbeddedDetectionByComment: {
+    category: "Global",
+    type: "string",
+    array: !0,
+    default: [{ value: [] }],
+    description: 'This option turns off "/* lang */`...`" comment-based language detection for the specified languages.'
+  },
+  disableEmbeddedDetectionByTag: {
     category: "Global",
     type: "string",
-    array: !1,
-    default: "[]",
-    description: "Config embedded languages formatting supported by this plugin."
+    array: !0,
+    default: [{ value: [] }],
+    description: 'This option turns off "lang`...`" tag-based language detection for the specified languages.'
   }
 };
 export {
-  ie as options,
-  oe as parsers,
-  se as printers
+  V as embeddedEmbedders,
+  L as embeddedNames,
+  Q as embeddedOptions,
+  z as embeddedParsers,
+  Ye as options,
+  Je as parsers,
+  Ke as printers
 };

package/dist/options.d.ts

@@ -1,10 +1,8 @@
 import type { SupportOptions } from "prettier";
 export declare const options: SupportOptions;
-export interface EmbeddedLanguage {
-    tag: string | string[];
-    comment: string | string[];
-    embedder?: string | null;
-}
-export interface PrettierPluginEmbedOptions {
-    embeddedLanguages?: string;
+declare module "prettier" {
+    interface Options {
+        disableEmbeddedDetectionByComment?: string[];
+        disableEmbeddedDetectionByTag?: string[];
+    }
 }

package/dist/parsers.d.ts

@@ -1,4 +1,5 @@
 export declare const parsers: {
+    embeddedXml: import("prettier").Parser<any>;
     typescript: import("prettier").Parser<any>;
     flow: import("prettier").Parser<any>;
     acorn: import("prettier").Parser<any>;

package/dist/types.d.ts

@@ -0,0 +1,11 @@
+import { Options, Doc, AstPath } from "prettier";
+import type { Node as EsTreeNode, TemplateLiteral, Comment } from "estree";
+export type PrettierNode = EsTreeNode & {
+    comments?: (Comment & {
+        leading: boolean;
+        trailing: boolean;
+        nodeDescription: string;
+    })[];
+};
+export type InternalPrintFun = (selector?: string | number | (string | number)[] | AstPath<TemplateLiteral>) => Doc;
+export type Embedder<T extends Options = Options> = (textToDoc: (text: string, options: T) => Promise<Doc>, print: InternalPrintFun, path: AstPath<TemplateLiteral>, options: T, lang: string, langs: string[]) => Promise<Doc>;

package/package.json

@@ -2,7 +2,7 @@
   "name": "prettier-plugin-embed",
   "description": "A prettier plugin to format embedded languages in js/ts files.",
   "private": false,
-  "version": "0.0.1",
+  "version": "0.0.3",
   "type": "module",
   "files": [
     "./dist"
@@ -54,31 +54,34 @@
     "ncu": "npx npm-check-updates -u",
     "postncu": "npm i"
   },
-  "peerDependencies": {
-    "prettier": "^3.0.3"
+  "dependencies": {
+    "uuid": "^9.0.1"
   },
   "devDependencies": {
     "@commitlint/cli": "^17.7.2",
     "@commitlint/config-conventional": "^17.7.0",
+    "@prettier/plugin-php": "^0.20.1",
     "@prettier/plugin-xml": "^3.2.1",
     "@semantic-release/git": "^10.0.1",
     "@types/estree": "^1.0.2",
     "@types/uuid": "^9.0.4",
-    "@typescript-eslint/eslint-plugin": "^6.7.3",
-    "@typescript-eslint/parser": "^6.7.3",
+    "@typescript-eslint/eslint-plugin": "^6.7.4",
+    "@typescript-eslint/parser": "^6.7.4",
     "@vitest/browser": "^0.34.6",
     "@vitest/coverage-istanbul": "^0.34.6",
     "@vitest/ui": "^0.34.6",
     "code-tag": "^1.1.0",
     "eslint": "^8.50.0",
-    "npm-check-updates": "^16.14.4",
+    "npm-check-updates": "^16.14.5",
     "playwright": "^1.38.1",
+    "prettier-plugin-sql": "^0.15.1",
     "semantic-release": "^22.0.5",
     "typescript": "^5.2.2",
-    "vite": "^4.4.9",
+    "vite": "^4.4.11",
     "vitest": "^0.34.6"
   },
-  "dependencies": {
-    "uuid": "^9.0.1"
+  "peerDependencies": {
+    "@xml-tools/parser": "^1.0.11",
+    "prettier": "^3.0.3"
   }
 }

package/dist/embedders/index.d.ts

@@ -1,3 +0,0 @@
-import type { Embedder } from "./types.js";
-export declare const embedders: Record<string, Embedder>;
-export * from "./types.js";

package/dist/embedders/types.d.ts

@@ -1,4 +0,0 @@
-import type { Options, Doc, AstPath } from "prettier";
-import type { TemplateLiteral } from "estree";
-export type InternalPrintFun = (selector?: string | number | (string | number)[] | AstPath<TemplateLiteral>) => Doc;
-export type Embedder = (textToDoc: (text: string, options: Options) => Promise<Doc>, print: InternalPrintFun, path: AstPath<TemplateLiteral>, options: Options) => Promise<Doc>;

package/dist/embedders/xml.d.ts

@@ -1,11 +0,0 @@
-import type { AstPath, Options, Doc } from "prettier";
-import type { TemplateLiteral } from "estree";
-import type { InternalPrintFun } from "./types.js";
-interface PrettierPluginXmlOptions extends Options {
-    xmlSelfClosingSpace?: boolean;
-    xmlWhitespaceSensitivity?: "strict" | "preserve" | "ignore";
-    xmlSortAttributesByKey?: boolean;
-    xmlQuoteAttributes?: "preserve" | "single" | "double";
-}
-declare function printEmbedXml(textToDoc: (text: string, options: Options) => Promise<Doc>, print: InternalPrintFun, path: AstPath<TemplateLiteral>, options: PrettierPluginXmlOptions): Promise<Doc>;
-export default printEmbedXml;