prettier-plugin-embed 0.4.10 → 0.4.12

package/dist/embedded/css/options.d.ts

@@ -1,16 +1,15 @@
 import { type AutocompleteStringList, type StringListToInterfaceKey } from "../utils.js";
-/**
- * References:
- *
- * - https://github.com/microsoft/vscode/blob/de0121cf0e05d1673903551b6dbb2871556bfae9/extensions/css/package.json#L22
- * - https://github.com/github-linguist/linguist/blob/7ca3799b8b5f1acde1dd7a8dfb7ae849d3dfb4cd/lib/linguist/languages.yml#L887
- */
-declare const DEFAULT_IDENTIFIERS: readonly ["css"];
-type Identifiers = AutocompleteStringList<(typeof DEFAULT_IDENTIFIERS)[number]>;
-type DefaultIdentifiersHolder = StringListToInterfaceKey<typeof DEFAULT_IDENTIFIERS>;
+declare const DEFAULT_COMMENTS: readonly ["css"];
+type Comments = AutocompleteStringList<(typeof DEFAULT_COMMENTS)[number]>;
+type DefaultCommentsHolder = StringListToInterfaceKey<typeof DEFAULT_COMMENTS>;
+declare const DEFAULT_TAGS: readonly ["css"];
+type Tags = AutocompleteStringList<(typeof DEFAULT_TAGS)[number]>;
+type DefaultTagsHolder = StringListToInterfaceKey<typeof DEFAULT_TAGS>;
 declare const CSS_PARSERS: readonly ["css", "less", "scss"];
 type CssParser = (typeof CSS_PARSERS)[number];
 declare const EMBEDDED_LANGUAGE_IDENTIFIERS: "embeddedCssIdentifiers";
+declare const EMBEDDED_LANGUAGE_COMMENTS: "embeddedCssComments";
+declare const EMBEDDED_LANGUAGE_TAGS: "embeddedCssTags";
 declare const EMBEDDED_LANGUAGE_PARSER: "embeddedCssParser";
 export declare const options: {
     readonly embeddedCssIdentifiers: {
@@ -21,6 +20,25 @@ export declare const options: {
             readonly value: ["css"];
         }];
         readonly description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded CSS language.";
+        readonly deprecated: "Please use `embeddedCssComments` or `embeddedCssTags`.";
+    };
+    readonly embeddedCssComments: {
+        readonly category: "Embed";
+        readonly type: "string";
+        readonly array: true;
+        readonly default: [{
+            readonly value: [];
+        }];
+        readonly description: "Block comments that make their subsequent template literals be identified as embedded CSS language.";
+    };
+    readonly embeddedCssTags: {
+        readonly category: "Embed";
+        readonly type: "string";
+        readonly array: true;
+        readonly default: [{
+            readonly value: [];
+        }];
+        readonly description: "Tags that make their subsequent template literals be identified as embedded CSS language.";
     };
     readonly embeddedCssParser: {
         category: string;
@@ -37,10 +55,17 @@ type Options = typeof options;
 declare module "../types.js" {
     interface EmbeddedOptions extends Options {
     }
-    interface EmbeddedDefaultIdentifiersHolder extends DefaultIdentifiersHolder {
+    interface EmbeddedDefaultCommentsHolder extends DefaultCommentsHolder {
+    }
+    interface EmbeddedDefaultTagsHolder extends DefaultTagsHolder {
     }
     interface PluginEmbedOptions {
-        [EMBEDDED_LANGUAGE_IDENTIFIERS]?: Identifiers;
+        /**
+         * @deprecated Please use `embeddedCssComments` or `embeddedCssTags`.,
+         */
+        [EMBEDDED_LANGUAGE_IDENTIFIERS]?: (Comments[number] | Tags[number])[];
+        [EMBEDDED_LANGUAGE_COMMENTS]?: Comments;
+        [EMBEDDED_LANGUAGE_TAGS]?: Tags;
         [EMBEDDED_LANGUAGE_PARSER]?: CssParser;
     }
 }

package/dist/embedded/es/options.d.ts

@@ -1,16 +1,15 @@
 import { type AutocompleteStringList, type StringListToInterfaceKey } from "../utils.js";
-/**
- * References:
- *
- * - https://github.com/microsoft/vscode/blob/de0121cf0e05d1673903551b6dbb2871556bfae9/extensions/javascript/package.json#L37
- * - https://github.com/github-linguist/linguist/blob/7ca3799b8b5f1acde1dd7a8dfb7ae849d3dfb4cd/lib/linguist/languages.yml#L3314
- */
-declare const DEFAULT_IDENTIFIERS: readonly ["js", "jsx", "es", "es6", "mjs", "cjs", "pac", "javascript"];
-type Identifiers = AutocompleteStringList<(typeof DEFAULT_IDENTIFIERS)[number]>;
-type DefaultIdentifiersHolder = StringListToInterfaceKey<typeof DEFAULT_IDENTIFIERS>;
+declare const DEFAULT_COMMENTS: readonly ["js", "jsx", "es", "es6", "mjs", "cjs", "pac", "javascript"];
+type Comments = AutocompleteStringList<(typeof DEFAULT_COMMENTS)[number]>;
+type DefaultCommentsHolder = StringListToInterfaceKey<typeof DEFAULT_COMMENTS>;
+declare const DEFAULT_TAGS: readonly ["js", "jsx", "es", "es6", "mjs", "cjs", "pac", "javascript"];
+type Tags = AutocompleteStringList<(typeof DEFAULT_TAGS)[number]>;
+type DefaultTagsHolder = StringListToInterfaceKey<typeof DEFAULT_TAGS>;
 declare const ES_PARSERS: readonly ["babel", "babel-flow", "acorn", "espree", "flow", "meriyah"];
 export type EsParser = (typeof ES_PARSERS)[number];
 declare const EMBEDDED_LANGUAGE_IDENTIFIERS: "embeddedEsIdentifiers";
+declare const EMBEDDED_LANGUAGE_COMMENTS: "embeddedEsComments";
+declare const EMBEDDED_LANGUAGE_TAGS: "embeddedEsTags";
 declare const EMBEDDED_LANGUAGE_PARSER: "embeddedEsParser";
 export declare const options: {
     readonly embeddedEsIdentifiers: {
@@ -21,6 +20,25 @@ export declare const options: {
             readonly value: ["js", "jsx", "es", "es6", "mjs", "cjs", "pac", "javascript"];
         }];
         readonly description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded ECMAScript/JavaScript language.";
+        readonly deprecated: "Please use `embeddedEsComments` or `embeddedEsTags`.";
+    };
+    readonly embeddedEsComments: {
+        readonly category: "Embed";
+        readonly type: "string";
+        readonly array: true;
+        readonly default: [{
+            readonly value: [];
+        }];
+        readonly description: "Block comments that make their subsequent template literals be identified as embedded ECMAScript/JavaScript language.";
+    };
+    readonly embeddedEsTags: {
+        readonly category: "Embed";
+        readonly type: "string";
+        readonly array: true;
+        readonly default: [{
+            readonly value: [];
+        }];
+        readonly description: "Tags that make their subsequent template literals be identified as embedded ECMAScript/JavaScript language.";
     };
     readonly embeddedEsParser: {
         category: string;
@@ -37,10 +55,17 @@ type Options = typeof options;
 declare module "../types.js" {
     interface EmbeddedOptions extends Options {
     }
-    interface EmbeddedDefaultIdentifiersHolder extends DefaultIdentifiersHolder {
+    interface EmbeddedDefaultCommentsHolder extends DefaultCommentsHolder {
+    }
+    interface EmbeddedDefaultTagsHolder extends DefaultTagsHolder {
     }
     interface PluginEmbedOptions {
-        [EMBEDDED_LANGUAGE_IDENTIFIERS]?: Identifiers;
+        /**
+         * @deprecated Please use `embeddedEsComments` or `embeddedEsTags`.
+         */
+        [EMBEDDED_LANGUAGE_IDENTIFIERS]?: (Comments[number] | Tags[number])[];
+        [EMBEDDED_LANGUAGE_COMMENTS]?: Comments;
+        [EMBEDDED_LANGUAGE_TAGS]?: Tags;
         [EMBEDDED_LANGUAGE_PARSER]?: EsParser;
     }
 }

package/dist/embedded/glsl/options.d.ts

@@ -1,14 +1,13 @@
 import { type AutocompleteStringList, type StringListToInterfaceKey } from "../utils.js";
-/**
- * References:
- *
- * - https://github.com/NaridaL/glsl-language-toolkit/blob/a7bd08d3f31355b335ae002b6a44c2999998b952/packages/prettier-plugin-glsl/src/prettier-plugin.ts#L88
- * - https://github.com/github-linguist/linguist/blob/7ca3799b8b5f1acde1dd7a8dfb7ae849d3dfb4cd/lib/linguist/languages.yml#L2180
- */
-declare const DEFAULT_IDENTIFIERS: readonly ["glsl", "shader"];
-type Identifiers = AutocompleteStringList<(typeof DEFAULT_IDENTIFIERS)[number]>;
-type DefaultIdentifiersHolder = StringListToInterfaceKey<typeof DEFAULT_IDENTIFIERS>;
+declare const DEFAULT_COMMENTS: readonly ["glsl", "shader"];
+type Comments = AutocompleteStringList<(typeof DEFAULT_COMMENTS)[number]>;
+type DefaultCommentsHolder = StringListToInterfaceKey<typeof DEFAULT_COMMENTS>;
+declare const DEFAULT_TAGS: readonly ["glsl", "shader"];
+type Tags = AutocompleteStringList<(typeof DEFAULT_TAGS)[number]>;
+type DefaultTagsHolder = StringListToInterfaceKey<typeof DEFAULT_TAGS>;
 declare const EMBEDDED_LANGUAGE_IDENTIFIERS: "embeddedGlslIdentifiers";
+declare const EMBEDDED_LANGUAGE_COMMENTS: "embeddedGlslComments";
+declare const EMBEDDED_LANGUAGE_TAGS: "embeddedGlslTags";
 export declare const options: {
     readonly embeddedGlslIdentifiers: {
         readonly category: "Embed";
@@ -18,16 +17,42 @@ export declare const options: {
             readonly value: ["glsl", "shader"];
         }];
         readonly 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.";
+        readonly deprecated: "Please use `embeddedGlslComments` or `embeddedGlslTags`.";
+    };
+    readonly embeddedGlslComments: {
+        readonly category: "Embed";
+        readonly type: "string";
+        readonly array: true;
+        readonly default: [{
+            readonly value: [];
+        }];
+        readonly description: "Block comments that make their subsequent template literals be identified as embedded GLSL language. This option requires the `prettier-plugin-glsl` plugin.";
+    };
+    readonly embeddedGlslTags: {
+        readonly category: "Embed";
+        readonly type: "string";
+        readonly array: true;
+        readonly default: [{
+            readonly value: [];
+        }];
+        readonly description: "Tags that make their subsequent template literals be identified as embedded GLSL language. This option requires the `prettier-plugin-glsl` plugin.";
     };
 };
 type Options = typeof options;
 declare module "../types.js" {
     interface EmbeddedOptions extends Options {
     }
-    interface EmbeddedDefaultIdentifiersHolder extends DefaultIdentifiersHolder {
+    interface EmbeddedDefaultCommentsHolder extends DefaultCommentsHolder {
+    }
+    interface EmbeddedDefaultTagsHolder extends DefaultTagsHolder {
     }
     interface PluginEmbedOptions {
-        [EMBEDDED_LANGUAGE_IDENTIFIERS]?: Identifiers;
+        /**
+         * @deprecated Please use `embeddedGlslComments` or `embeddedGlslTags`.
+         */
+        [EMBEDDED_LANGUAGE_IDENTIFIERS]?: (Comments[number] | Tags[number])[];
+        [EMBEDDED_LANGUAGE_COMMENTS]?: Comments;
+        [EMBEDDED_LANGUAGE_TAGS]?: Tags;
     }
 }
 export {};

package/dist/embedded/graphql/options.d.ts

@@ -1,13 +1,13 @@
 import { type AutocompleteStringList, type StringListToInterfaceKey } from "../utils.js";
-/**
- * References:
- *
- * - https://github.com/github-linguist/linguist/blob/7ca3799b8b5f1acde1dd7a8dfb7ae849d3dfb4cd/lib/linguist/languages.yml#L2578
- */
-declare const DEFAULT_IDENTIFIERS: readonly ["graphql", "gql"];
-type Identifiers = AutocompleteStringList<(typeof DEFAULT_IDENTIFIERS)[number]>;
-type DefaultIdentifiersHolder = StringListToInterfaceKey<typeof DEFAULT_IDENTIFIERS>;
+declare const DEFAULT_COMMENTS: readonly ["graphql", "gql"];
+type Comments = AutocompleteStringList<(typeof DEFAULT_COMMENTS)[number]>;
+type DefaultCommentsHolder = StringListToInterfaceKey<typeof DEFAULT_COMMENTS>;
+declare const DEFAULT_TAGS: readonly ["graphql", "gql"];
+type Tags = AutocompleteStringList<(typeof DEFAULT_TAGS)[number]>;
+type DefaultTagsHolder = StringListToInterfaceKey<typeof DEFAULT_TAGS>;
 declare const EMBEDDED_LANGUAGE_IDENTIFIERS: "embeddedGraphqlIdentifiers";
+declare const EMBEDDED_LANGUAGE_COMMENTS: "embeddedGraphqlComments";
+declare const EMBEDDED_LANGUAGE_TAGS: "embeddedGraphqlTags";
 export declare const options: {
     readonly embeddedGraphqlIdentifiers: {
         readonly category: "Embed";
@@ -17,16 +17,42 @@ export declare const options: {
             readonly value: ["graphql", "gql"];
         }];
         readonly description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded GraphQL language.";
+        readonly deprecated: "Please use `embeddedGraphqlComments` or `embeddedGraphqlTags`.";
+    };
+    readonly embeddedGraphqlComments: {
+        readonly category: "Embed";
+        readonly type: "string";
+        readonly array: true;
+        readonly default: [{
+            readonly value: [];
+        }];
+        readonly description: "Block comments that make their subsequent template literals be identified as embedded GraphQL language.";
+    };
+    readonly embeddedGraphqlTags: {
+        readonly category: "Embed";
+        readonly type: "string";
+        readonly array: true;
+        readonly default: [{
+            readonly value: [];
+        }];
+        readonly description: "Tags that make their subsequent template literals be identified as embedded GraphQL language.";
     };
 };
 type Options = typeof options;
 declare module "../types.js" {
     interface EmbeddedOptions extends Options {
     }
-    interface EmbeddedDefaultIdentifiersHolder extends DefaultIdentifiersHolder {
+    interface EmbeddedDefaultCommentsHolder extends DefaultCommentsHolder {
+    }
+    interface EmbeddedDefaultTagsHolder extends DefaultTagsHolder {
     }
     interface PluginEmbedOptions {
-        [EMBEDDED_LANGUAGE_IDENTIFIERS]?: Identifiers;
+        /**
+         * @deprecated Please use `embeddedGraphqlComments` or `embeddedGraphqlTags`.
+         */
+        [EMBEDDED_LANGUAGE_IDENTIFIERS]?: (Comments[number] | Tags[number])[];
+        [EMBEDDED_LANGUAGE_COMMENTS]?: Comments;
+        [EMBEDDED_LANGUAGE_TAGS]?: Tags;
     }
 }
 export {};

package/dist/embedded/html/options.d.ts

@@ -1,16 +1,15 @@
 import { type AutocompleteStringList, type StringListToInterfaceKey } from "../utils.js";
-/**
- * References
- *
- * - https://github.com/microsoft/vscode/blob/de0121cf0e05d1673903551b6dbb2871556bfae9/extensions/html/package.json#L18
- * - https://github.com/github-linguist/linguist/blob/7ca3799b8b5f1acde1dd7a8dfb7ae849d3dfb4cd/lib/linguist/languages.yml#L2684
- */
-declare const DEFAULT_IDENTIFIERS: readonly ["html", "xhtml"];
-type Identifiers = AutocompleteStringList<(typeof DEFAULT_IDENTIFIERS)[number]>;
-type DefaultIdentifiersHolder = StringListToInterfaceKey<typeof DEFAULT_IDENTIFIERS>;
+declare const DEFAULT_COMMENTS: readonly ["html", "xhtml"];
+type Comments = AutocompleteStringList<(typeof DEFAULT_COMMENTS)[number]>;
+type DefaultCommentsHolder = StringListToInterfaceKey<typeof DEFAULT_COMMENTS>;
+declare const DEFAULT_TAGS: readonly ["html", "xhtml"];
+type Tags = AutocompleteStringList<(typeof DEFAULT_TAGS)[number]>;
+type DefaultTagsHolder = StringListToInterfaceKey<typeof DEFAULT_TAGS>;
 declare const HTML_PARSERS: readonly ["html", "vue", "angular", "lwc"];
 type HtmlParser = (typeof HTML_PARSERS)[number];
 declare const EMBEDDED_LANGUAGE_IDENTIFIERS: "embeddedHtmlIdentifiers";
+declare const EMBEDDED_LANGUAGE_COMMENTS: "embeddedHtmlComments";
+declare const EMBEDDED_LANGUAGE_TAGS: "embeddedHtmlTags";
 declare const EMBEDDED_LANGUAGE_PARSER: "embeddedHtmlParser";
 export declare const options: {
     readonly embeddedHtmlIdentifiers: {
@@ -21,6 +20,25 @@ export declare const options: {
             readonly value: ["html", "xhtml"];
         }];
         readonly description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded HTML language.";
+        readonly deprecated: "Please use `embeddedHtmlComments` or `embeddedHtmlTags`.";
+    };
+    readonly embeddedHtmlComments: {
+        readonly category: "Embed";
+        readonly type: "string";
+        readonly array: true;
+        readonly default: [{
+            readonly value: [];
+        }];
+        readonly description: "Block comments that make their subsequent template literals be identified as embedded HTML language.";
+    };
+    readonly embeddedHtmlTags: {
+        readonly category: "Embed";
+        readonly type: "string";
+        readonly array: true;
+        readonly default: [{
+            readonly value: [];
+        }];
+        readonly description: "Tags that make their subsequent template literals be identified as embedded HTML language.";
     };
     readonly embeddedHtmlParser: {
         category: string;
@@ -37,10 +55,17 @@ type Options = typeof options;
 declare module "../types.js" {
     interface EmbeddedOptions extends Options {
     }
-    interface EmbeddedDefaultIdentifiersHolder extends DefaultIdentifiersHolder {
+    interface EmbeddedDefaultCommentsHolder extends DefaultCommentsHolder {
+    }
+    interface EmbeddedDefaultTagsHolder extends DefaultTagsHolder {
     }
     interface PluginEmbedOptions {
-        [EMBEDDED_LANGUAGE_IDENTIFIERS]?: Identifiers;
+        /**
+         * @deprecated Please use `embeddedHtmlComments` or `embeddedHtmlTags`.
+         */
+        [EMBEDDED_LANGUAGE_IDENTIFIERS]?: (Comments[number] | Tags[number])[];
+        [EMBEDDED_LANGUAGE_COMMENTS]?: Comments;
+        [EMBEDDED_LANGUAGE_TAGS]?: Tags;
         [EMBEDDED_LANGUAGE_PARSER]?: HtmlParser;
     }
 }

package/dist/embedded/index.d.ts

@@ -1,3 +1,3 @@
 export * from "./register.js";
-export type { EmbeddedDefaultIdentifier, EmbeddedEmbedders, EmbeddedLanguage, EmbeddedOptions, EmbeddedParsers, PluginEmbedOptions, } from "./types.js";
-export { makeIdentifiersOptionName, type AutocompleteStringList, } from "./utils.js";
+export type { EmbeddedDefaultComment, EmbeddedDefaultTag, EmbeddedEmbedders, EmbeddedLanguage, EmbeddedOptions, EmbeddedParsers, EmbeddedComment, EmbeddedTag, PluginEmbedOptions, } from "./types.js";
+export { makeIdentifiersOptionName, makeCommentsOptionName, makeTagsOptionName, type AutocompleteStringList, } from "./utils.js";

package/dist/embedded/ini/options.d.ts

@@ -1,13 +1,13 @@
 import { type AutocompleteStringList, type StringListToInterfaceKey } from "../utils.js";
-/**
- * References:
- *
- * - https://github.com/github-linguist/linguist/blob/7ca3799b8b5f1acde1dd7a8dfb7ae849d3dfb4cd/lib/linguist/languages.yml#L2928
- */
-declare const DEFAULT_IDENTIFIERS: readonly ["ini", "cfg", "pro"];
-type Identifiers = AutocompleteStringList<(typeof DEFAULT_IDENTIFIERS)[number]>;
-type DefaultIdentifiersHolder = StringListToInterfaceKey<typeof DEFAULT_IDENTIFIERS>;
+declare const DEFAULT_COMMENTS: readonly ["ini", "cfg", "pro"];
+type Comments = AutocompleteStringList<(typeof DEFAULT_COMMENTS)[number]>;
+type DefaultCommentsHolder = StringListToInterfaceKey<typeof DEFAULT_COMMENTS>;
+declare const DEFAULT_TAGS: readonly ["ini", "cfg", "pro"];
+type Tags = AutocompleteStringList<(typeof DEFAULT_TAGS)[number]>;
+type DefaultTagsHolder = StringListToInterfaceKey<typeof DEFAULT_TAGS>;
 declare const EMBEDDED_LANGUAGE_IDENTIFIERS: "embeddedIniIdentifiers";
+declare const EMBEDDED_LANGUAGE_COMMENTS: "embeddedIniComments";
+declare const EMBEDDED_LANGUAGE_TAGS: "embeddedIniTags";
 export declare const options: {
     readonly embeddedIniIdentifiers: {
         readonly category: "Embed";
@@ -17,16 +17,42 @@ export declare const options: {
             readonly value: ["ini", "cfg", "pro"];
         }];
         readonly 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.";
+        readonly deprecated: "Please use `embeddedIniComments` or `embeddedIniTags`.";
+    };
+    readonly embeddedIniComments: {
+        readonly category: "Embed";
+        readonly type: "string";
+        readonly array: true;
+        readonly default: [{
+            readonly value: [];
+        }];
+        readonly description: "Block comments that make their subsequent template literals be identified as embedded INI language. This option requires the `prettier-plugin-ini` plugin.";
+    };
+    readonly embeddedIniTags: {
+        readonly category: "Embed";
+        readonly type: "string";
+        readonly array: true;
+        readonly default: [{
+            readonly value: [];
+        }];
+        readonly description: "Tags that make their subsequent template literals be identified as embedded INI language. This option requires the `prettier-plugin-ini` plugin.";
     };
 };
 type Options = typeof options;
 declare module "../types.js" {
     interface EmbeddedOptions extends Options {
     }
-    interface EmbeddedDefaultIdentifiersHolder extends DefaultIdentifiersHolder {
+    interface EmbeddedDefaultCommentsHolder extends DefaultCommentsHolder {
+    }
+    interface EmbeddedDefaultTagsHolder extends DefaultTagsHolder {
     }
     interface PluginEmbedOptions {
-        [EMBEDDED_LANGUAGE_IDENTIFIERS]?: Identifiers;
+        /**
+         * @deprecated Please use `embeddedIniComments` or `embeddedIniTags`.
+         */
+        [EMBEDDED_LANGUAGE_IDENTIFIERS]?: (Comments[number] | Tags[number])[];
+        [EMBEDDED_LANGUAGE_COMMENTS]?: Comments;
+        [EMBEDDED_LANGUAGE_TAGS]?: Tags;
     }
 }
 export {};

package/dist/embedded/java/options.d.ts

@@ -1,8 +1,13 @@
 import { type AutocompleteStringList, type StringListToInterfaceKey } from "../utils.js";
-declare const DEFAULT_IDENTIFIERS: readonly ["java"];
-type Identifiers = AutocompleteStringList<(typeof DEFAULT_IDENTIFIERS)[number]>;
-type DefaultIdentifiersHolder = StringListToInterfaceKey<typeof DEFAULT_IDENTIFIERS>;
+declare const DEFAULT_COMMENTS: readonly ["java"];
+type Comments = AutocompleteStringList<(typeof DEFAULT_COMMENTS)[number]>;
+type DefaultCommentsHolder = StringListToInterfaceKey<typeof DEFAULT_COMMENTS>;
+declare const DEFAULT_TAGS: readonly ["java"];
+type Tags = AutocompleteStringList<(typeof DEFAULT_TAGS)[number]>;
+type DefaultTagsHolder = StringListToInterfaceKey<typeof DEFAULT_TAGS>;
 declare const EMBEDDED_LANGUAGE_IDENTIFIERS: "embeddedJavaIdentifiers";
+declare const EMBEDDED_LANGUAGE_COMMENTS: "embeddedJavaComments";
+declare const EMBEDDED_LANGUAGE_TAGS: "embeddedJavaTags";
 export declare const options: {
     readonly embeddedJavaIdentifiers: {
         readonly category: "Embed";
@@ -12,16 +17,42 @@ export declare const options: {
             readonly value: ["java"];
         }];
         readonly 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.";
+        readonly deprecated: "Please use `embeddedJavaComments` or `embeddedJavaTags`.";
+    };
+    readonly embeddedJavaComments: {
+        readonly category: "Embed";
+        readonly type: "string";
+        readonly array: true;
+        readonly default: [{
+            readonly value: [];
+        }];
+        readonly description: "Block comments that make their subsequent template literals be identified as embedded Java language. This option requires the `prettier-plugin-java` plugin.";
+    };
+    readonly embeddedJavaTags: {
+        readonly category: "Embed";
+        readonly type: "string";
+        readonly array: true;
+        readonly default: [{
+            readonly value: [];
+        }];
+        readonly description: "Tags that make their subsequent template literals be identified as embedded Java language. This option requires the `prettier-plugin-java` plugin.";
     };
 };
 type Options = typeof options;
 declare module "../types.js" {
     interface EmbeddedOptions extends Options {
     }
-    interface EmbeddedDefaultIdentifiersHolder extends DefaultIdentifiersHolder {
+    interface EmbeddedDefaultCommentsHolder extends DefaultCommentsHolder {
+    }
+    interface EmbeddedDefaultTagsHolder extends DefaultTagsHolder {
     }
     interface PluginEmbedOptions {
-        [EMBEDDED_LANGUAGE_IDENTIFIERS]?: Identifiers;
+        /**
+         * @deprecated Please use `embeddedJavaComments` or `embeddedJavaTags`.
+         */
+        [EMBEDDED_LANGUAGE_IDENTIFIERS]?: (Comments[number] | Tags[number])[];
+        [EMBEDDED_LANGUAGE_COMMENTS]?: Comments;
+        [EMBEDDED_LANGUAGE_TAGS]?: Tags;
     }
 }
 export {};

package/dist/embedded/json/options.d.ts

@@ -1,16 +1,16 @@
 import { type AutocompleteStringList, type StringListToInterfaceKey } from "../utils.js";
-/**
- * References:
- *
- * - https://github.com/github-linguist/linguist/blob/7ca3799b8b5f1acde1dd7a8dfb7ae849d3dfb4cd/lib/linguist/languages.yml#L3141
- */
-declare const DEFAULT_IDENTIFIERS: readonly ["json", "jsonl"];
-type Identifiers = AutocompleteStringList<(typeof DEFAULT_IDENTIFIERS)[number]>;
-type DefaultIdentifiersHolder = StringListToInterfaceKey<typeof DEFAULT_IDENTIFIERS>;
+declare const DEFAULT_COMMENTS: readonly ["json", "jsonl"];
+type Comments = AutocompleteStringList<(typeof DEFAULT_COMMENTS)[number]>;
+type DefaultCommentsHolder = StringListToInterfaceKey<typeof DEFAULT_COMMENTS>;
+declare const DEFAULT_TAGS: readonly ["json", "jsonl"];
+type Tags = AutocompleteStringList<(typeof DEFAULT_TAGS)[number]>;
+type DefaultTagsHolder = StringListToInterfaceKey<typeof DEFAULT_TAGS>;
 declare const JSON_PARSERS: readonly ["json", "json5", "jsonc", "json-stringify"];
 type JsonParser = (typeof JSON_PARSERS)[number];
-declare const EMBEDDED_LANGUAGE_PARSER: "embeddedJsonParser";
 declare const EMBEDDED_LANGUAGE_IDENTIFIERS: "embeddedJsonIdentifiers";
+declare const EMBEDDED_LANGUAGE_COMMENTS: "embeddedJsonComments";
+declare const EMBEDDED_LANGUAGE_TAGS: "embeddedJsonTags";
+declare const EMBEDDED_LANGUAGE_PARSER: "embeddedJsonParser";
 export declare const options: {
     readonly embeddedJsonIdentifiers: {
         readonly category: "Embed";
@@ -20,6 +20,25 @@ export declare const options: {
             readonly value: ["json", "jsonl"];
         }];
         readonly description: "Tag or comment identifiers that make their subsequent template literals be identified as embedded JSON language.";
+        readonly deprecated: "Please use `embeddedJsonComments` or `embeddedJsonTags`.";
+    };
+    readonly embeddedJsonComments: {
+        readonly category: "Embed";
+        readonly type: "string";
+        readonly array: true;
+        readonly default: [{
+            readonly value: [];
+        }];
+        readonly description: "Block comments that make their subsequent template literals be identified as embedded JSON language.";
+    };
+    readonly embeddedJsonTags: {
+        readonly category: "Embed";
+        readonly type: "string";
+        readonly array: true;
+        readonly default: [{
+            readonly value: [];
+        }];
+        readonly description: "Tags that make their subsequent template literals be identified as embedded JSON language.";
     };
     readonly embeddedJsonParser: {
         category: string;
@@ -36,10 +55,17 @@ type Options = typeof options;
 declare module "../types.js" {
     interface EmbeddedOptions extends Options {
     }
-    interface EmbeddedDefaultIdentifiersHolder extends DefaultIdentifiersHolder {
+    interface EmbeddedDefaultCommentsHolder extends DefaultCommentsHolder {
+    }
+    interface EmbeddedDefaultTagsHolder extends DefaultTagsHolder {
     }
     interface PluginEmbedOptions {
-        [EMBEDDED_LANGUAGE_IDENTIFIERS]?: Identifiers;
+        /**
+         * @deprecated Please use `embeddedJsonComments` or `embeddedJsonTags`.
+         */
+        [EMBEDDED_LANGUAGE_IDENTIFIERS]?: (Comments[number] | Tags[number])[];
+        [EMBEDDED_LANGUAGE_COMMENTS]?: Comments;
+        [EMBEDDED_LANGUAGE_TAGS]?: Tags;
         [EMBEDDED_LANGUAGE_PARSER]?: JsonParser;
     }
 }

package/dist/embedded/jsonata/options.d.ts

@@ -1,8 +1,13 @@
 import { type AutocompleteStringList, type StringListToInterfaceKey } from "../utils.js";
-declare const DEFAULT_IDENTIFIERS: readonly ["jsonata"];
-type Identifiers = AutocompleteStringList<(typeof DEFAULT_IDENTIFIERS)[number]>;
-type DefaultIdentifiersHolder = StringListToInterfaceKey<typeof DEFAULT_IDENTIFIERS>;
+declare const DEFAULT_COMMENTS: readonly ["jsonata"];
+type Comments = AutocompleteStringList<(typeof DEFAULT_COMMENTS)[number]>;
+type DefaultCommentsHolder = StringListToInterfaceKey<typeof DEFAULT_COMMENTS>;
+declare const DEFAULT_TAGS: readonly ["jsonata"];
+type Tags = AutocompleteStringList<(typeof DEFAULT_TAGS)[number]>;
+type DefaultTagsHolder = StringListToInterfaceKey<typeof DEFAULT_TAGS>;
 declare const EMBEDDED_LANGUAGE_IDENTIFIERS: "embeddedJsonataIdentifiers";
+declare const EMBEDDED_LANGUAGE_COMMENTS: "embeddedJsonataComments";
+declare const EMBEDDED_LANGUAGE_TAGS: "embeddedJsonataTags";
 export declare const options: {
     readonly embeddedJsonataIdentifiers: {
         readonly category: "Embed";
@@ -12,16 +17,42 @@ export declare const options: {
             readonly value: ["jsonata"];
         }];
         readonly 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.";
+        readonly deprecated: "Please use `embeddedJsonataComments` or `embeddedJsonataTags`.";
+    };
+    readonly embeddedJsonataComments: {
+        readonly category: "Embed";
+        readonly type: "string";
+        readonly array: true;
+        readonly default: [{
+            readonly value: [];
+        }];
+        readonly description: "Block comments that make their subsequent template literals be identified as embedded JSONata language. This option requires the `@stedi/prettier-plugin-jsonata` plugin.";
+    };
+    readonly embeddedJsonataTags: {
+        readonly category: "Embed";
+        readonly type: "string";
+        readonly array: true;
+        readonly default: [{
+            readonly value: [];
+        }];
+        readonly description: "Tags that make their subsequent template literals be identified as embedded JSONata language. This option requires the `@stedi/prettier-plugin-jsonata` plugin.";
     };
 };
 type Options = typeof options;
 declare module "../types.js" {
     interface EmbeddedOptions extends Options {
     }
-    interface EmbeddedDefaultIdentifiersHolder extends DefaultIdentifiersHolder {
+    interface EmbeddedDefaultCommentsHolder extends DefaultCommentsHolder {
+    }
+    interface EmbeddedDefaultTagsHolder extends DefaultTagsHolder {
     }
     interface PluginEmbedOptions {
-        [EMBEDDED_LANGUAGE_IDENTIFIERS]?: Identifiers;
+        /**
+         * @deprecated Please use `embeddedJsonataComments` or `embeddedJsonataTags`.
+         */
+        [EMBEDDED_LANGUAGE_IDENTIFIERS]?: (Comments[number] | Tags[number])[];
+        [EMBEDDED_LANGUAGE_COMMENTS]?: Comments;
+        [EMBEDDED_LANGUAGE_TAGS]?: Tags;
     }
 }
 export {};