@master/eslint-plugin-css 2.0.0-rc.73 → 2.0.0-rc.75

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) Aoyue Design LLC.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/dist/configs/base.d.ts

@@ -1,3 +1,6 @@
-import type { Linter } from 'eslint';
+import { Linter } from "eslint";
+
+//#region src/configs/base.d.ts
 declare const _default: Linter.Config;
-export default _default;
+//#endregion
+export { _default as default };

package/dist/configs/base.js

@@ -0,0 +1,5 @@
+import plugin from "../plugin.js";
+//#region src/configs/base.ts
+var base_default = { plugins: { "@master/css": plugin } };
+//#endregion
+export { base_default as default };

package/dist/configs/legacy.d.ts

@@ -1,3 +1,6 @@
-import type { Linter } from 'eslint';
+import { Linter } from "eslint";
+
+//#region src/configs/legacy.d.ts
 declare const _default: Linter.LegacyConfig;
-export default _default;
+//#endregion
+export { _default as default };

package/dist/configs/legacy.js

@@ -0,0 +1,9 @@
+import recommended_default from "./recommended.js";
+//#region src/configs/legacy.ts
+var legacy_default = {
+	plugins: ["@master/css"],
+	rules: recommended_default.rules,
+	parserOptions: { ecmaFeatures: { jsx: true } }
+};
+//#endregion
+export { legacy_default as default };

package/dist/configs/recommended.d.ts

@@ -1,3 +1,6 @@
-import type { Linter } from 'eslint';
+import { Linter } from "eslint";
+
+//#region src/configs/recommended.d.ts
 declare const _default: Linter.Config;
-export default _default;
+//#endregion
+export { _default as default };

package/dist/configs/recommended.js

@@ -0,0 +1,13 @@
+import base_default from "./base.js";
+//#region src/configs/recommended.ts
+var recommended_default = {
+	...base_default,
+	rules: {
+		"@master/css/sort-classes": "warn",
+		"@master/css/no-invalid-classes": "error",
+		"@master/css/no-conflicting-classes": "warn",
+		"@master/css/prefer-canonical-classes": "warn"
+	}
+};
+//#endregion
+export { recommended_default as default };

package/dist/create-rule.d.ts

@@ -1,5 +1,12 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-declare const _default: <Options extends readonly unknown[], MessageIds extends string>({ meta, name, ...rule }: Readonly<ESLintUtils.RuleWithMetaAndName<Options, MessageIds, unknown>>) => ESLintUtils.RuleModule<MessageIds, Options, unknown, ESLintUtils.RuleListener> & {
-    name: string;
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+//#region src/create-rule.d.ts
+declare const _default: <Options extends readonly unknown[], MessageIds extends string>({
+  meta,
+  name,
+  ...rule
+}: Readonly<ESLintUtils.RuleWithMetaAndName<Options, MessageIds, unknown>>) => ESLintUtils.RuleModule<MessageIds, Options, unknown, ESLintUtils.RuleListener> & {
+  name: string;
 };
-export default _default;
+//#endregion
+export { _default as default };

package/dist/create-rule.js

@@ -0,0 +1,5 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+//#region src/create-rule.ts
+var create_rule_default = ESLintUtils.RuleCreator((name) => new URL(`/guide/code-linting#${name}`, "https://rc.css.master.co").href);
+//#endregion
+export { create_rule_default as default };

package/dist/index.d.ts

@@ -1,12 +1,15 @@
-import settings from './settings';
-import type { Linter } from 'eslint';
-import type { TSESLint } from '@typescript-eslint/utils';
+import { TSESLint } from "@typescript-eslint/utils";
+import { Linter } from "eslint";
+import settings from "./settings.js";
+
+//#region src/index.d.ts
 declare const masterCSSPlugin: Omit<TSESLint.Linter.Plugin, 'configs'> & {
-    configs: {
-        legacy: unknown;
-        base: Linter.Config;
-        recommended: Linter.Config;
-    };
-    settings: typeof settings;
+  configs: {
+    legacy: unknown;
+    base: Linter.Config;
+    recommended: Linter.Config;
+  };
+  settings: typeof settings;
 };
-export default masterCSSPlugin;
+//#endregion
+export { masterCSSPlugin as default };

package/dist/index.js

@@ -0,0 +1,17 @@
+import settings from "./settings.js";
+import plugin from "./plugin.js";
+import base_default from "./configs/base.js";
+import recommended_default from "./configs/recommended.js";
+import legacy_default from "./configs/legacy.js";
+//#region src/index.ts
+const masterCSSPlugin = {
+	...plugin,
+	configs: {
+		legacy: legacy_default,
+		base: base_default,
+		recommended: recommended_default
+	},
+	settings
+};
+//#endregion
+export { masterCSSPlugin as default };

package/dist/plugin.d.ts

@@ -1,3 +1,6 @@
-import type { TSESLint } from '@typescript-eslint/utils';
+import { TSESLint } from "@typescript-eslint/utils";
+
+//#region src/plugin.d.ts
 declare const plugin: TSESLint.Linter.Plugin;
-export default plugin;
+//#endregion
+export { plugin as default };

package/dist/plugin.js

@@ -0,0 +1,26 @@
+import no_conflicting_classes_default from "./rules/no-conflicting-classes.js";
+import no_invalid_classes_default from "./rules/no-invalid-classes.js";
+import no_unapproved_raw_values_default from "./rules/no-unapproved-raw-values.js";
+import prefer_canonical_classes_default from "./rules/prefer-canonical-classes.js";
+import sort_classes_default from "./rules/sort-classes.js";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, resolve } from "path";
+//#region src/plugin.ts
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(resolve(__dirname, "..", "package.json"), "utf-8"));
+const plugin = {
+	meta: {
+		name: pkg.name,
+		version: pkg.version
+	},
+	rules: {
+		"no-conflicting-classes": no_conflicting_classes_default,
+		"no-invalid-classes": no_invalid_classes_default,
+		"no-unapproved-raw-values": no_unapproved_raw_values_default,
+		"prefer-canonical-classes": prefer_canonical_classes_default,
+		"sort-classes": sort_classes_default
+	}
+};
+//#endregion
+export { plugin as default };

package/dist/rules/no-conflicting-classes.d.ts

@@ -1,4 +1,6 @@
+//#region src/rules/no-conflicting-classes.d.ts
 declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"collisionClass" | "partialCollisionClass", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
-    name: string;
+  name: string;
 };
-export default _default;
+//#endregion
+export { _default as default };

package/dist/rules/no-conflicting-classes.js

@@ -0,0 +1,76 @@
+import create_rule_default from "../create-rule.js";
+import defineVisitors from "../utils/define-visitors.js";
+import resolveContext from "../utils/resolve-context.js";
+import { findClassConflicts, findPartialClassConflicts, removeClassNamesFromClassList, replaceClassNameInClassList } from "@master/css-lint";
+//#region src/rules/no-conflicting-classes.ts
+var no_conflicting_classes_default = create_rule_default({
+	name: "no-conflicting-classes",
+	meta: {
+		type: "layout",
+		docs: { description: "Disallow conflicting Master CSS classes" },
+		messages: {
+			collisionClass: "{{message}}",
+			partialCollisionClass: "Prefer \"{{replacement}}\" over \"{{actual}}\" because \"{{conflict}}\" overrides part of it."
+		},
+		fixable: "code",
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { settings, css } = resolveContext(context);
+		return defineVisitors({
+			context,
+			settings
+		}, (_, { raw, start, end, unescape, classNodes, classValues }) => {
+			const conflicts = findClassConflicts(classValues, css);
+			if (conflicts.length) {
+				const classNamesToRemove = conflicts.map(({ className }) => className);
+				const keptClassNames = [...new Set(conflicts.flatMap(({ conflicts }) => conflicts))];
+				const formatClassName = (className) => `"${className}"`;
+				const formatClassList = (classNames) => {
+					if (classNames.length <= 2) return classNames.map(formatClassName).join(" and ");
+					return `${classNames.slice(0, -1).map(formatClassName).join(", ")}, and ${formatClassName(classNames[classNames.length - 1])}`;
+				};
+				const fixedRaw = removeClassNamesFromClassList(raw, classNamesToRemove, { unescape });
+				const firstClassNode = classNodes.find((node) => node.value === classNamesToRemove[0]);
+				context.report({
+					loc: firstClassNode.loc,
+					messageId: "collisionClass",
+					data: { message: `${formatClassList(classNamesToRemove)} ${classNamesToRemove.length === 1 ? "is" : "are"} overridden by ${formatClassList(keptClassNames)}.` },
+					fix: function(fixer) {
+						return fixer.replaceTextRange([start, end], fixedRaw);
+					}
+				});
+				return;
+			}
+			const partialConflicts = findPartialClassConflicts(classValues, css);
+			if (!partialConflicts.length) return;
+			let fixedRaw = raw;
+			for (const conflict of partialConflicts) fixedRaw = replaceClassNameInClassList(fixedRaw, conflict.className, conflict.replacement, { unescape });
+			const classNodeQueues = /* @__PURE__ */ new Map();
+			for (const classNode of classNodes) {
+				const queue = classNodeQueues.get(classNode.value);
+				if (queue) queue.push(classNode);
+				else classNodeQueues.set(classNode.value, [classNode]);
+			}
+			for (const conflict of partialConflicts) {
+				const classNode = classNodeQueues.get(conflict.className)?.shift();
+				if (!classNode) continue;
+				context.report({
+					loc: classNode.loc,
+					messageId: "partialCollisionClass",
+					data: {
+						actual: conflict.className,
+						replacement: conflict.replacement,
+						conflict: conflict.conflict
+					},
+					fix(fixer) {
+						return fixer.replaceTextRange([start, end], fixedRaw);
+					}
+				});
+			}
+		});
+	}
+});
+//#endregion
+export { no_conflicting_classes_default as default };

package/dist/rules/no-invalid-classes.d.ts

@@ -1,4 +1,6 @@
-declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"disallowUnknownClass" | "invalidClass", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
-    name: string;
+//#region src/rules/no-invalid-classes.d.ts
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidClass" | "disallowUnknownClass", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+  name: string;
 };
-export default _default;
+//#endregion
+export { _default as default };

package/dist/rules/no-invalid-classes.js

@@ -0,0 +1,41 @@
+import create_rule_default from "../create-rule.js";
+import defineVisitors from "../utils/define-visitors.js";
+import resolveContext from "../utils/resolve-context.js";
+import { noInvalidClassesOptionsSchema } from "../settings-schema.js";
+import { getClassValidationIssues } from "@master/css-lint";
+//#region src/rules/no-invalid-classes.ts
+var no_invalid_classes_default = create_rule_default({
+	name: "no-invalid-classes",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow invalid Master CSS classes" },
+		messages: {
+			invalidClass: "{{message}}",
+			disallowUnknownClass: "{{message}}"
+		},
+		fixable: null,
+		schema: [noInvalidClassesOptionsSchema]
+	},
+	defaultOptions: [],
+	create: function(context) {
+		const { options, settings, css } = resolveContext(context);
+		return defineVisitors({
+			context,
+			settings
+		}, (_, { classNodes }) => {
+			for (const node of classNodes) {
+				const issues = getClassValidationIssues(node.value, css, {
+					disallowUnknownClass: options.disallowUnknownClass,
+					displayClassName: node.raw
+				});
+				for (const issue of issues) context.report({
+					loc: node.loc,
+					messageId: issue.kind === "invalid" ? "invalidClass" : "disallowUnknownClass",
+					data: { message: issue.message }
+				});
+			}
+		});
+	}
+});
+//#endregion
+export { no_invalid_classes_default as default };

package/dist/rules/no-unapproved-raw-values.d.ts

@@ -1,8 +1,10 @@
+//#region src/rules/no-unapproved-raw-values.d.ts
 declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unapprovedRawValue", [{
-    allowRawValues: boolean;
-    allowProperties: any[];
-    allowedPatterns: any[];
+  allowRawValues: boolean;
+  allowProperties: any[];
+  allowedPatterns: any[];
 }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
-    name: string;
+  name: string;
 };
-export default _default;
+//#endregion
+export { _default as default };

package/dist/rules/no-unapproved-raw-values.js

@@ -0,0 +1,61 @@
+import create_rule_default from "../create-rule.js";
+import defineVisitors from "../utils/define-visitors.js";
+import resolveContext from "../utils/resolve-context.js";
+import { findUnapprovedRawValueClasses } from "@master/css-lint";
+//#region src/rules/no-unapproved-raw-values.ts
+var no_unapproved_raw_values_default = create_rule_default({
+	name: "no-unapproved-raw-values",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow unapproved raw values in token-backed Master CSS classes" },
+		messages: { unapprovedRawValue: "Unexpected raw value \"{{value}}\" in \"{{className}}\". Use a token or allow it explicitly." },
+		fixable: null,
+		schema: [{
+			type: "object",
+			properties: {
+				allowRawValues: { type: "boolean" },
+				allowProperties: {
+					type: "array",
+					items: { type: "string" },
+					uniqueItems: true
+				},
+				allowedPatterns: {
+					type: "array",
+					items: { type: "string" },
+					uniqueItems: true
+				}
+			},
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{
+		allowRawValues: false,
+		allowProperties: [],
+		allowedPatterns: []
+	}],
+	create(context) {
+		const { settings, css } = resolveContext(context);
+		const options = context.options[0] || {};
+		return defineVisitors({
+			context,
+			settings
+		}, (node, { classNodes, classValues }) => {
+			const issues = findUnapprovedRawValueClasses(classValues, css, options);
+			for (const issue of issues) {
+				const classNode = classNodes.find((node) => node.value === issue.className);
+				if (!classNode) continue;
+				context.report({
+					node,
+					loc: classNode.loc,
+					messageId: "unapprovedRawValue",
+					data: {
+						className: issue.className,
+						value: issue.value
+					}
+				});
+			}
+		});
+	}
+});
+//#endregion
+export { no_unapproved_raw_values_default as default };

package/dist/rules/prefer-canonical-classes.d.ts

@@ -1,5 +1,8 @@
-import { type CanonicalClassNameOptions } from '@master/css-lint';
+import { CanonicalClassNameOptions } from "@master/css-lint";
+
+//#region src/rules/prefer-canonical-classes.d.ts
 declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferClass", [Required<CanonicalClassNameOptions>], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
-    name: string;
+  name: string;
 };
-export default _default;
+//#endregion
+export { _default as default };

package/dist/rules/prefer-canonical-classes.js

@@ -0,0 +1,79 @@
+import create_rule_default from "../create-rule.js";
+import defineVisitors from "../utils/define-visitors.js";
+import resolveContext from "../utils/resolve-context.js";
+import { defaultCanonicalClassNameOptions, replaceClassGroupInClassList, replaceClassNameInClassList, suggestCanonicalClassGroups, suggestCanonicalClassName } from "@master/css-lint";
+//#region src/rules/prefer-canonical-classes.ts
+var prefer_canonical_classes_default = create_rule_default({
+	name: "prefer-canonical-classes",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Prefer canonical Master CSS classes" },
+		messages: { preferClass: "Prefer \"{{recommended}}\" over \"{{actual}}\"." },
+		fixable: "code",
+		schema: [{
+			type: "object",
+			properties: {
+				preferStaticUtilities: { type: "boolean" },
+				preferThemeTokens: { type: "boolean" },
+				preferPropertyAliases: { type: "boolean" },
+				preferVariableReferences: { type: "boolean" },
+				preferMultiValueTokens: { type: "boolean" },
+				preferCompositionUtilities: { type: "boolean" },
+				preferConditionOrder: { type: "boolean" }
+			},
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [defaultCanonicalClassNameOptions],
+	create(context) {
+		const { settings, css } = resolveContext(context);
+		const options = {
+			...defaultCanonicalClassNameOptions,
+			...context.options[0] || {}
+		};
+		return defineVisitors({
+			context,
+			settings
+		}, (node, { raw, start, end, unescape, classNodes, classValues }) => {
+			const groupSuggestions = suggestCanonicalClassGroups(classValues, css, options);
+			const coveredClassNames = new Set(groupSuggestions.flatMap((suggestion) => suggestion.classNames));
+			const reports = [];
+			let fixedRaw = raw;
+			for (const suggestion of groupSuggestions) {
+				const firstClassNode = classNodes.find((node) => node.value === suggestion.classNames[0]);
+				if (!firstClassNode) continue;
+				fixedRaw = replaceClassGroupInClassList(fixedRaw, suggestion.classNames, suggestion.recommended, { unescape });
+				reports.push({
+					loc: firstClassNode.loc,
+					actual: suggestion.classNames.join(" "),
+					recommended: suggestion.recommended
+				});
+			}
+			for (const classNode of classNodes) {
+				if (coveredClassNames.has(classNode.value)) continue;
+				const recommended = suggestCanonicalClassName(classNode.value, css, options);
+				if (!recommended) continue;
+				fixedRaw = replaceClassNameInClassList(fixedRaw, classNode.value, recommended, { unescape });
+				reports.push({
+					loc: classNode.loc,
+					actual: classNode.value,
+					recommended
+				});
+			}
+			for (const report of reports) context.report({
+				node,
+				loc: report.loc,
+				messageId: "preferClass",
+				data: {
+					actual: report.actual,
+					recommended: report.recommended
+				},
+				fix(fixer) {
+					return fixer.replaceTextRange([start, end], fixedRaw);
+				}
+			});
+		});
+	}
+});
+//#endregion
+export { prefer_canonical_classes_default as default };

package/dist/rules/sort-classes.d.ts

@@ -1,4 +1,6 @@
+//#region src/rules/sort-classes.d.ts
 declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidClassOrder", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
-    name: string;
+  name: string;
 };
-export default _default;
+//#endregion
+export { _default as default };

package/dist/rules/sort-classes.js

@@ -0,0 +1,40 @@
+import create_rule_default from "../create-rule.js";
+import defineVisitors from "../utils/define-visitors.js";
+import resolveContext from "../utils/resolve-context.js";
+import { sortClassList } from "@master/css-lint";
+//#region src/rules/sort-classes.ts
+var sort_classes_default = create_rule_default({
+	name: "sort-classes",
+	meta: {
+		type: "layout",
+		fixable: "code",
+		docs: { description: "Sort Master CSS classes" },
+		messages: { invalidClassOrder: "No consistent class order followed." },
+		schema: []
+	},
+	defaultOptions: [],
+	create: function(context) {
+		const { settings, css } = resolveContext(context);
+		const { sourceCode } = context;
+		return defineVisitors({
+			context,
+			settings
+		}, (node, { raw, start, end, nodes, unescape }) => {
+			if (nodes.length <= 1) return;
+			const orderedRaw = sortClassList(raw, css, { unescape });
+			if (raw !== orderedRaw) context.report({
+				node,
+				loc: {
+					start: sourceCode.getLocFromIndex(start),
+					end: sourceCode.getLocFromIndex(end)
+				},
+				messageId: "invalidClassOrder",
+				fix: function(fixer) {
+					return fixer.replaceTextRange([start, end], orderedRaw);
+				}
+			});
+		});
+	}
+});
+//#endregion
+export { sort_classes_default as default };

package/dist/settings-schema.d.ts

@@ -1,4 +1,7 @@
-import type { JSONSchema4 } from '@typescript-eslint/utils/json-schema';
-export declare const masterCSSSettingsSchema: JSONSchema4;
-export declare const noInvalidClassesOptionsSchema: JSONSchema4;
-export default masterCSSSettingsSchema;
+import { JSONSchema4 } from "@typescript-eslint/utils/json-schema";
+
+//#region src/settings-schema.d.ts
+declare const masterCSSSettingsSchema: JSONSchema4;
+declare const noInvalidClassesOptionsSchema: JSONSchema4;
+//#endregion
+export { masterCSSSettingsSchema as default, masterCSSSettingsSchema, noInvalidClassesOptionsSchema };

package/dist/settings-schema.js

@@ -0,0 +1,27 @@
+//#region src/settings-schema.ts
+const sourceMatcherSchema = {
+	type: "array",
+	items: {
+		type: "string",
+		minLength: 1
+	},
+	uniqueItems: true
+};
+const masterCSSSettingsSchema = {
+	type: "object",
+	properties: {
+		classAttributes: sourceMatcherSchema,
+		classFunctions: sourceMatcherSchema,
+		classDeclarations: sourceMatcherSchema,
+		ignoredKeys: sourceMatcherSchema,
+		manifest: { type: "object" }
+	},
+	additionalProperties: false
+};
+const noInvalidClassesOptionsSchema = {
+	type: "object",
+	properties: { disallowUnknownClass: { type: "boolean" } },
+	additionalProperties: false
+};
+//#endregion
+export { masterCSSSettingsSchema as default, masterCSSSettingsSchema, noInvalidClassesOptionsSchema };

package/dist/settings.d.ts

@@ -1,16 +1,19 @@
-import type { MasterCSSManifest } from './utils/master-css';
+import { MasterCSSManifest } from "./utils/master-css.js";
+
+//#region src/settings.d.ts
 declare const settings: {
-    manifest: any;
-    classAttributes: string[];
-    classFunctions: string[];
-    classDeclarations: string[];
-    ignoredKeys: string[];
+  manifest: any;
+  classAttributes: string[];
+  classFunctions: string[];
+  classDeclarations: string[];
+  ignoredKeys: string[];
 };
-export default settings;
-export interface Settings {
-    classAttributes?: string[];
-    classFunctions?: string[];
-    classDeclarations?: string[];
-    ignoredKeys: string[];
-    manifest?: MasterCSSManifest;
+interface Settings {
+  classAttributes?: string[];
+  classFunctions?: string[];
+  classDeclarations?: string[];
+  ignoredKeys: string[];
+  manifest?: MasterCSSManifest;
 }
+//#endregion
+export { Settings, settings as default };

package/dist/settings.js

@@ -0,0 +1,8 @@
+import { defaultClassLintSettings } from "@master/css-lint";
+//#region src/settings.ts
+const settings = {
+	...defaultClassLintSettings,
+	manifest: void 0
+};
+//#endregion
+export { settings as default };