prettier-plugin-embed 0.0.3 → 0.0.5

package/dist/embedded/index.d.ts

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

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

@@ -1,15 +1,11 @@
-import { SupportOption } from "prettier";
+import type { 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 {
+    interface PrettierPluginEmbedOptions {
+        [name]?: string[];
     }
 }

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

@@ -1,20 +1,20 @@
-import { SupportOption } from "prettier";
+import type { 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 "../types.js" {
+    interface EmbeddedOptions {
+        [name]: typeof option;
+    }
+    interface PrettierPluginEmbedOptions {
+        [name]?: string[];
+    }
 }
 declare module "prettier" {
-    interface Options extends PrettierPluginDepsOptions, PrettierPluginEmbedOptions {
+    interface Options extends PrettierPluginDepsOptions {
     }
 }

package/dist/embedded/register.d.ts

@@ -1,5 +1,9 @@
-import type { EmbeddedEmbedders, EmbeddedNames, EmbeddedParsers, EmbeddedOptions } from "./types.js";
-export declare const embeddedNames: EmbeddedNames[];
+import type { EmbeddedEmbedders, EmbeddedName, EmbeddedParsers, EmbeddedOptions } from "./types.js";
+export declare const embeddedNames: EmbeddedName[];
 export declare const embeddedParsers: EmbeddedParsers;
 export declare const embeddedEmbedders: EmbeddedEmbedders;
 export declare const embeddedOptions: EmbeddedOptions;
+import * as __glob__0_0 from "./noop/index.js";
+import * as __glob__0_1 from "./php/index.js";
+import * as __glob__0_2 from "./sql/index.js";
+import * as __glob__0_3 from "./xml/index.js";

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

@@ -1,21 +1,21 @@
-import { SupportOption } from "prettier";
+import type { 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 "../types.js" {
+    interface EmbeddedOptions {
+        [name]: typeof option;
+    }
+    interface PrettierPluginEmbedOptions {
+        [name]?: SqlFormatterLanguage[] | NodeSqlParserDataBase[] | string[];
+    }
 }
 declare module "prettier" {
-    interface Options extends PrettierPluginDepsOptions, PrettierPluginEmbedOptions {
+    interface Options extends PrettierPluginDepsOptions {
     }
 }

package/dist/embedded/types.d.ts

@@ -1,14 +1,22 @@
-import { Parser, SupportOption, Options } from "prettier";
-import { Embedder } from "../types.js";
+import type { Parser, SupportOption, Options } from "prettier";
+import type { Embedder } from "../types.js";
+type EmbeddedNameConvention = `embedded${string}`;
 export interface EmbeddedParsers {
-    [name: string]: Parser | undefined;
+    [name: EmbeddedNameConvention]: Parser | undefined;
 }
 export interface EmbeddedEmbedders {
-    [name: string]: Embedder<Options> | undefined;
+    [name: EmbeddedNameConvention]: Embedder<Options> | undefined;
 }
 export interface EmbeddedOptions {
-    [name: string]: SupportOption | undefined;
+    [name: EmbeddedNameConvention]: SupportOption | undefined;
 }
 export interface EmbeddedNamesHolder {
 }
-export type EmbeddedNames = keyof EmbeddedNamesHolder;
+export type EmbeddedName = keyof EmbeddedNamesHolder;
+export interface PrettierPluginEmbedOptions {
+}
+declare module "prettier" {
+    interface Options extends PrettierPluginEmbedOptions {
+    }
+}
+export {};

package/dist/embedded/utils.d.ts

@@ -1,10 +1,11 @@
-import { Expression, Comment, TemplateLiteral } from "estree";
-import { AstPath, Options } from "prettier";
+import type { Expression, Comment, TemplateLiteral } from "estree";
+import type { AstPath, Options } from "prettier";
 import { builders } from "prettier/doc";
-import { InternalPrintFun } from "../types.js";
+import type { 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;
+export declare function uuidV4(): string;

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

@@ -1,21 +1,21 @@
-import { SupportOption } from "prettier";
+import type { 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 "../types.js" {
+    interface EmbeddedOptions {
+        [name]: typeof option;
+    }
+    interface PrettierPluginEmbedOptions {
+        [name]?: string[];
+    }
 }
 declare module "prettier" {
-    interface Options extends PrettierPluginDepsOptions, PrettierPluginEmbedOptions {
+    interface Options extends PrettierPluginDepsOptions {
     }
 }

package/dist/index.js

@@ -1,71 +1,46 @@
-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 = {
+import Q from "prettier/parser-babel";
+import U from "prettier/parser-espree";
+import X from "prettier/parser-flow";
+import H from "prettier/parser-typescript";
+import { builders as q, utils as T } from "prettier/doc";
+import { parse as V } from "@xml-tools/parser";
+import { printers as J } from "prettier/plugins/estree.mjs";
+const P = "embeddedNoop", K = {
   category: "Global",
   type: "string",
   array: !0,
   default: [{ value: [] }],
   description: "Specify embedded languages that will not be formatted."
-}, te = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, Y = /* @__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 S(re);
-}
-const c = [];
-for (let e = 0; e < 256; ++e)
-  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 ie = typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto), I = {
-  randomUUID: ie
-};
-function k(e, t, n) {
-  if (I.randomUUID && !t && !e)
-    return I.randomUUID();
-  e = e || {};
-  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) {
+  name: P,
+  option: K
+}, Symbol.toStringTag, { value: "Module" })), Z = "embeddedPhp", { group: ee, indent: te, softline: j, lineSuffixBoundary: ne } = q;
+function re(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, "}"];
+  return (r = n == null ? void 0 : n.comments) != null && r.length && (o = ee([te([j, o]), j])), ["${", o, ne, "}"];
 }
-function j(e, t) {
+function D(e, t) {
   return e.map(
-    (n) => ue(n, t),
+    (n) => re(n, t),
     "expressions"
   );
 }
-function A(e, t, n) {
+function N(e, t, n) {
   var o;
-  if (!(((o = t.plugins) == null ? void 0 : o.map((r) => r.name)) ?? []).includes(e))
+  if (!(((o = t.plugins) == null ? void 0 : o.some(
+    (r) => {
+      var s;
+      return ((s = r.name) == null ? void 0 : s.includes(e)) ?? !1;
+    }
+  )) ?? !1))
     throw new Error(
       `Cannot format embedded language "${n}" because plugin "${e}" is not loaded.`
     );
 }
-function de(e, t, n) {
+function oe(e, t, n) {
   if (t === n) {
     e.unshift(t);
     return;
@@ -81,72 +56,91 @@ function de(e, t, n) {
   }
   e.splice(o, 0, t);
 }
-const { label: pe, hardline: me, line: ge, group: w, indent: fe } = E, { mapDoc: be } = N, ye = async (e, t, n, o, r) => {
+function k() {
+  function e(n) {
+    return t(Math.random() * (1 << (n << 2)) ^ Date.now()).slice(-n);
+  }
+  function t(n) {
+    return (n | 0).toString(16);
+  }
+  return [
+    e(4) + e(4),
+    e(4),
+    "4" + e(3),
+    // UUID version 4
+    t(8 | Math.random() * 4) + e(3),
+    // {8|9|A|B}xxx
+    // s(4) + s(4) + s(4),
+    Date.now().toString(16).slice(-10) + e(2)
+    // Use timestamp to avoid collisions
+  ].join("-");
+}
+const { label: se, hardline: ie, line: le, group: E, indent: ae } = q, { mapDoc: ce } = T, ue = async (e, t, n, o, r) => {
   try {
-    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}`
+    N("@prettier/plugin-php", o, r);
+    const s = "$p" + k().replaceAll("-", ""), { node: a } = n, g = a.quasis.map(
+      (i, l, { length: p }) => l === p - 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), {
+    let u = "", b = 0;
+    const f = /^\s+/.exec(g);
+    f && (b = f.index + f[0].length, u = " ");
+    const $ = /\s$/.test(g) ? " " : "", _ = D(n, t), v = await e(g.slice(b), {
       parser: "php"
     });
     let h = !1;
-    const $ = be(q, (i) => {
+    const y = ce(v, (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)
+      const l = [], p = i.split(new RegExp("\\" + s + "(\\d+)", "g"));
+      for (let c = 0; c < p.length; c++) {
+        let m = p[c];
+        if (c % 2 == 0) {
+          if (!m)
             continue;
-          f = f.replaceAll(/([\\`]|\${)/g, "\\$1"), l.push(f);
+          m = m.replaceAll(/([\\`]|\${)/g, "\\$1"), l.push(m);
         } else {
-          const v = Number(f);
-          l.push(_[v]);
+          const x = Number(m);
+          l.push(_[x]);
         }
       }
       return l;
-    }), p = h ? me : d && x ? ge : null;
-    return p ? w([
+    }), d = h ? ie : u && $ ? le : null;
+    return d ? E([
       "`",
-      fe([p, w($)]),
-      p,
+      ae([d, E(y)]),
+      d,
       "`"
-    ]) : pe(
+    ]) : se(
       { hug: !1 },
-      w([
+      E([
         "`",
-        d,
-        w([$]),
-        x,
+        u,
+        E([y]),
+        $,
         "`"
       ])
     );
   } catch (s) {
     throw console.error(s), s;
   }
-}, he = {
+}, de = {
   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({
+}, pe = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  embedder: ye,
-  name: ne,
-  option: he
-}, Symbol.toStringTag, { value: "Module" })), xe = "embeddedSql", _e = {
+  embedder: ue,
+  name: Z,
+  option: de
+}, Symbol.toStringTag, { value: "Module" })), fe = "embeddedSql", me = {
   category: "Global",
   type: "string",
   array: !0,
   default: [{ value: ["sql"] }],
   description: "Specify embedded SQL languages. This requires prettier-plugin-sql"
-}, G = [
+}, C = [
   "sql",
   "bigquery",
   "hive",
@@ -163,7 +157,7 @@ const { label: pe, hardline: me, line: ge, group: w, indent: fe } = E, { mapDoc:
   "transactsql",
   "tsql",
   "trino"
-], W = [
+], G = [
   "bigquery",
   "db2",
   "hive",
@@ -172,107 +166,107 @@ const { label: pe, hardline: me, line: ge, group: w, indent: fe } = E, { mapDoc:
   "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) => {
+], { label: ge, hardline: A, group: S, line: be, indent: he } = q, { mapDoc: ye } = T, $e = 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);
+    N("prettier-plugin-sql", o, r);
+    const a = "p" + k().replaceAll("-", ""), { node: g } = n, u = g.quasis.map(
+      (i, l, { length: p }) => l === p - 1 ? i.value.cooked : i.value.cooked + `${a}${l}`
+    ).join(""), b = /^\s/.test(u) ? " " : "", f = /\s$/.test(u) ? " " : "", $ = D(n, t), _ = xe(o, r, s);
     if (typeof _ > "u")
       throw new SyntaxError(`Unrecognized language: ${r}`);
-    const q = await e(d, {
+    const v = await e(u, {
       parser: "sql",
       ..._
     });
     let h = !1;
-    const $ = Se(q, (i) => {
+    const y = ye(v, (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)
+      const l = [], p = i.split(new RegExp(a + "(\\d+)", "g"));
+      for (let c = 0; c < p.length; c++) {
+        let m = p[c];
+        if (c % 2 == 0) {
+          if (!m)
             continue;
-          f = f.replaceAll(/([\\`]|\${)/g, "\\$1"), f.split(/(\n)/).forEach(
-            (v) => v === `
-` ? (h = !0, l.push(R)) : l.push(v)
+          m = m.replaceAll(/([\\`]|\${)/g, "\\$1"), m.split(/(\n)/).forEach(
+            (x) => x === `
+` ? (h = !0, l.push(A)) : l.push(x)
           );
         } else {
-          const v = Number(f);
-          l.push(x[v]);
+          const x = Number(m);
+          l.push($[x]);
         }
       }
       return l;
-    }), p = h ? R : y && g ? qe : null;
-    return p ? O([
+    }), d = h ? A : b && f ? be : null;
+    return d ? S([
       "`",
-      Ee([p, O($)]),
-      p,
+      he([d, S(y)]),
+      d,
       "`"
-    ]) : ve(
+    ]) : ge(
       { hug: !1 },
-      O([
+      S([
         "`",
-        y,
-        O($),
-        g,
+        b,
+        S(y),
+        f,
         "`"
       ])
     );
   } catch (a) {
     throw console.error(a), a;
   }
-}, Oe = {
-  "sql-formatter": (e) => G.includes(e),
-  "node-sql-parser": (e) => W.includes(e)
+}, _e = {
+  "sql-formatter": (e) => C.includes(e),
+  "node-sql-parser": (e) => G.includes(e)
 };
-function B(e, t) {
+function L(e, t) {
   for (const n of t)
-    if (Oe[n](e))
+    if (_e[n](e))
       return {
         formatter: n,
         language: e
       };
 }
-function F(e, t, n) {
-  let o = B(e, n);
+function B(e, t, n) {
+  let o = L(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)
+    if (o = L(t[s], n), o)
       return o;
 }
-function Te(e, t, n) {
-  return e.formatter === "sql-formatter" ? F(t, n, [
+function xe(e, t, n) {
+  return e.formatter === "sql-formatter" ? B(t, n, [
     "sql-formatter",
     "node-sql-parser"
-  ]) : F(t, n, [
+  ]) : B(t, n, [
     "node-sql-parser",
     "sql-formatter"
   ]);
 }
-const De = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const ve = /* @__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) {
+  NODE_SQL_PARSER_DATABASES: G,
+  SQL_FORMATTER_LANGUAGES: C,
+  embedder: $e,
+  name: fe,
+  option: me
+}, Symbol.toStringTag, { value: "Module" })), I = "embeddedXml";
+function F(e, t) {
   const n = new SyntaxError(
     e + " (" + t.loc.start.line + ":" + t.loc.start.column + ")"
   );
   return Object.assign(n, t);
 }
-const Ne = {
+const qe = {
   parse(e) {
-    const { lexErrors: t, parseErrors: n, cst: o } = Y(e);
+    const { lexErrors: t, parseErrors: n, cst: o } = V(e);
     if (t.length > 0) {
       const r = t[0];
-      throw P(r.message, {
+      throw F(r.message, {
         loc: {
           start: { line: r.line, column: r.column },
           end: {
@@ -284,7 +278,7 @@ const Ne = {
     }
     if (n.length > 0) {
       const r = n[0];
-      throw P(r.message, {
+      throw F(r.message, {
         loc: {
           start: {
             line: r.token.startLine ?? NaN,
@@ -306,115 +300,113 @@ const Ne = {
   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) => {
+}, { label: Ee, hardline: Se, line: we, group: w, indent: Oe } = q, { mapDoc: Te } = T, De = 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}`
+    N("@prettier/plugin-xml", o, r);
+    const s = k(), { node: a } = n, g = a.quasis.map(
+      (d, i, { length: l }) => i === l - 1 ? d.value.cooked : d.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)
+    let u = "", b = 0;
+    const f = /^\s+/.exec(g);
+    f && (b = f.index + f[0].length, u = " ");
+    const $ = /\s$/.test(g) ? " " : "", _ = D(n, t), v = await e(g.slice(b), {
+      parser: I
+    }), h = Te(v, (d) => {
+      if (typeof d != "string")
+        return d;
+      const i = [], l = d.split(new RegExp(s + "-(\\d+)", "g"));
+      for (let p = 0; p < l.length; p++) {
+        let c = l[p];
+        if (p % 2 == 0) {
+          if (!c)
             continue;
-          u = u.replaceAll(/([\\`]|\${)/g, "\\$1"), i.push(u);
+          c = c.replaceAll(/([\\`]|\${)/g, "\\$1"), i.push(c);
         } else {
-          const f = Number(u);
-          i.push(_[f]);
+          const m = Number(c);
+          i.push(_[m]);
         }
       }
       return i;
-    }), $ = o.xmlWhitespaceSensitivity === "ignore" ? je : d && x ? Ae : null;
-    return $ ? T([
+    }), y = o.xmlWhitespaceSensitivity === "ignore" ? Se : u && $ ? we : null;
+    return y ? w([
       "`",
-      Le([$, T(h)]),
-      $,
+      Oe([y, w(h)]),
+      y,
       "`"
-    ]) : ke(
+    ]) : Ee(
       { hug: !1 },
-      T([
+      w([
         "`",
-        d,
-        T(h),
-        x,
+        u,
+        w(h),
+        $,
         "`"
       ])
     );
   } catch (s) {
     throw console.error(s), s;
   }
-}, Re = {
+}, Ne = {
   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({
+}, ke = /* @__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
+  embedder: De,
+  name: I,
+  option: Ne,
+  parser: qe
+}, Symbol.toStringTag, { value: "Module" })), M = [], W = {}, R = {}, z = {}, je = /* @__PURE__ */ Object.assign({
+  "./noop/index.ts": Y,
+  "./php/index.ts": pe,
+  "./sql/index.ts": ve,
+  "./xml/index.ts": ke
 });
-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;
+Object.values(je).forEach(({ name: e, parser: t, embedder: n, option: o }) => {
+  oe(M, e, P), t && (W[e] = t), n && (R[e] = n), z[e] = o;
 });
-const Je = {
+const Re = {
   // parsers from internal
   // TODO: find out which parsers are required and which are optional
-  ...H.parsers,
+  ...Q.parsers,
+  ...U.parsers,
   ...X.parsers,
-  ...J.parsers,
-  ...K.parsers,
+  ...H.parsers,
   // parsers from this plugin
-  ...z
-};
-console.log(L);
-const { estree: D } = Z, Pe = function(e, t) {
+  ...W
+}, { estree: O } = J, Ae = 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 r of L) {
+  for (const r of M) {
     const s = t[r];
     if (!s)
       continue;
-    const a = Ce(
+    const a = Le(
       e,
       s,
-      t.disableEmbeddedDetectionByComment ?? []
-    ) ?? Ge(e, s, t.disableEmbeddedDetectionByTag ?? []);
+      t.noEmbeddedDetectionByComment ?? []
+    ) ?? Be(e, s, t.noEmbeddedDetectionByTag ?? []);
     if (a === void 0)
       continue;
-    const b = V[r];
-    if (!b)
+    const g = R[r];
+    if (!g)
       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
+    const u = e.node;
+    return u.quasis.length === 1 && u.quasis[0].value.raw.trim() === "" ? "``" : async (...b) => {
+      const f = await g(...b, a, s);
+      return q.label(
+        { embed: !0, ...f.label },
+        f
       );
     };
   }
-  return ((o = D.embed) == null ? void 0 : o.call(D, e, t)) ?? null;
+  return ((o = O.embed) == null ? void 0 : o.call(O, e, t)) ?? null;
 };
-function Ce({ node: e, parent: t }, n, o) {
+function Le({ node: e, parent: t }, n, o) {
   if (n.length === 0 || e.type !== "TemplateLiteral")
     return;
   const r = e.comments ?? (t == null ? void 0 : t.comments);
@@ -427,28 +419,28 @@ function Ce({ node: e, parent: t }, n, o) {
         return a;
   }
 }
-function Ge({ node: e, parent: t }, n, o) {
+function Be({ 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 Ke = {
+const ze = {
   estree: {
-    ...D,
-    embed: Pe
+    ...O,
+    embed: Ae
   }
-}, Ye = {
-  ...Q,
-  disableEmbeddedDetectionByComment: {
+}, Qe = {
+  ...z,
+  noEmbeddedDetectionByComment: {
     category: "Global",
     type: "string",
     array: !0,
     default: [{ value: [] }],
     description: 'This option turns off "/* lang */`...`" comment-based language detection for the specified languages.'
   },
-  disableEmbeddedDetectionByTag: {
+  noEmbeddedDetectionByTag: {
     category: "Global",
     type: "string",
     array: !0,
@@ -457,11 +449,11 @@ const Ke = {
   }
 };
 export {
-  V as embeddedEmbedders,
-  L as embeddedNames,
-  Q as embeddedOptions,
-  z as embeddedParsers,
-  Ye as options,
-  Je as parsers,
-  Ke as printers
+  R as embeddedEmbedders,
+  M as embeddedNames,
+  z as embeddedOptions,
+  W as embeddedParsers,
+  Qe as options,
+  Re as parsers,
+  ze as printers
 };

package/dist/options.d.ts

@@ -1,8 +1,13 @@
 import type { SupportOptions } from "prettier";
+import { PrettierPluginEmbedOptions } from "./embedded/index.js";
 export declare const options: SupportOptions;
+declare module "./embedded/types.js" {
+    interface PrettierPluginEmbedOptions {
+        noEmbeddedDetectionByComment?: string[];
+        noEmbeddedDetectionByTag?: string[];
+    }
+}
 declare module "prettier" {
-    interface Options {
-        disableEmbeddedDetectionByComment?: string[];
-        disableEmbeddedDetectionByTag?: string[];
+    interface Options extends PrettierPluginEmbedOptions {
     }
 }

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import { Options, Doc, AstPath } from "prettier";
+import type { Options, Doc, AstPath } from "prettier";
 import type { Node as EsTreeNode, TemplateLiteral, Comment } from "estree";
 export type PrettierNode = EsTreeNode & {
     comments?: (Comment & {

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.3",
+  "version": "0.0.5",
   "type": "module",
   "files": [
     "./dist"
@@ -46,7 +46,8 @@
     "format": "prettier . --write",
     "prebuild": "npm run lint && npm run type-check && npm run format",
     "build": "vite build",
-    "postbuild": "tsc",
+    "add-glob-import-types": "tsx ./scripts/add-glob-import-types.ts",
+    "postbuild": "tsc --project ./tsconfig.production.json && npm run add-glob-import-types",
     "test": "vitest",
     "test:ui": "vitest --ui",
     "preview": "vite preview",
@@ -54,9 +55,6 @@
     "ncu": "npx npm-check-updates -u",
     "postncu": "npm i"
   },
-  "dependencies": {
-    "uuid": "^9.0.1"
-  },
   "devDependencies": {
     "@commitlint/cli": "^17.7.2",
     "@commitlint/config-conventional": "^17.7.0",
@@ -64,7 +62,6 @@
     "@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.4",
     "@typescript-eslint/parser": "^6.7.4",
     "@vitest/browser": "^0.34.6",
@@ -72,10 +69,12 @@
     "@vitest/ui": "^0.34.6",
     "code-tag": "^1.1.0",
     "eslint": "^8.50.0",
+    "fast-glob": "^3.3.1",
     "npm-check-updates": "^16.14.5",
     "playwright": "^1.38.1",
     "prettier-plugin-sql": "^0.15.1",
     "semantic-release": "^22.0.5",
+    "tsx": "^3.13.0",
     "typescript": "^5.2.2",
     "vite": "^4.4.11",
     "vitest": "^0.34.6"