@projectwallace/stylelint-plugin 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Project Wallace
+
+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/README.md

@@ -0,0 +1,58 @@
+# @projectwallace/stylelint-plugin
+
+A stylelint plugin that checks the complexity of your CSS.
+
+> Only use this plugin with standard CSS. Non-standard CSS (Sass, Less, etc.) is not supported.
+
+## Installation
+
+```sh
+npm install --save-dev @projectwallace/stylelint-plugin
+```
+
+## Usage
+
+Add the plugin and configure rules in your stylelint config:
+
+```json
+{
+	"plugins": ["@projectwallace/stylelint-plugin"],
+	"rules": {
+		"projectwallace/max-lines-of-code": 200,
+		"projectwallace/max-selector-complexity": 5,
+		"projectwallace/no-anonymous-layers": true,
+		"projectwallace/no-property-browserhacks": true,
+		"projectwallace/no-static-container-query": true,
+		"projectwallace/no-static-media-query": true,
+		"projectwallace/no-undeclared-container-names": true,
+		"projectwallace/no-unknown-custom-property": true,
+		"projectwallace/no-unreachable-media-conditions": true,
+		"projectwallace/no-unused-container-names": true,
+		"projectwallace/no-unused-custom-properties": true,
+		"projectwallace/no-unused-layers": true,
+		"projectwallace/no-useless-custom-property-assignment": true
+	}
+}
+```
+
+## Rules
+
+| Rule                                                                                               | Description                                                                |
+| -------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------- |
+| [max-lines-of-code](src/rules/max-lines-of-code/README.md)                                         | Prevent a stylesheet from exceeding a predefined number of lines of code   |
+| [no-anonymous-layers](src/rules/no-anonymous-layers/README.md)                                     | Disallow anonymous (unnamed) `@layer` blocks                               |
+| [max-selector-complexity](src/rules/max-selector-complexity/README.md)                             | Prevent selector complexity from going over a predefined maximum           |
+| [no-property-browserhacks](src/rules/no-property-browserhacks/README.md)                           | Prevent the use of known browserhacks for properties                       |
+| [no-undeclared-container-names](src/rules/no-undeclared-container-names/README.md)                 | Disallow container names in `@container` that were never declared          |
+| [no-unknown-custom-property](src/rules/no-unknown-custom-property/README.md)                       | Disallow the use of undeclared custom properties in a `var()`              |
+| [no-useless-custom-property-assignment](src/rules/no-useless-custom-property-assignment/README.md) | Disallow custom property assignments that reference themselves via `var()` |
+| [no-unused-container-names](src/rules/no-unused-container-names/README.md)                         | Disallow container names that are declared but never queried               |
+| [no-unused-custom-properties](src/rules/no-unused-custom-properties/README.md)                     | Disallow custom properties that are never used in a `var()`                |
+| [no-static-container-query](src/rules/no-static-container-query/README.md)                         | Disallow static (exact-match) numeric container feature conditions         |
+| [no-static-media-query](src/rules/no-static-media-query/README.md)                                 | Disallow static (exact-match) numeric media feature conditions             |
+| [no-unreachable-media-conditions](src/rules/no-unreachable-media-conditions/README.md)             | Disallow media queries with contradictory conditions that can never match  |
+| [no-unused-layers](src/rules/no-unused-layers/README.md)                                           | Disallow `@layer` names that are declared but never defined                |
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,6 @@
+import stylelint from "stylelint";
+
+//#region src/index.d.ts
+declare const plugins: stylelint.Plugin[];
+//#endregion
+export { plugins as default };

package/dist/index.mjs

@@ -0,0 +1,424 @@
+import stylelint from "stylelint";
+import { FUNCTION, IDENTIFIER, parse_declaration, parse_selector, walk } from "@projectwallace/css-parser";
+import { analyze, selectorComplexity } from "@projectwallace/css-analyzer";
+//#region src/rules/max-selector-complexity/index.ts
+const { createPlugin: createPlugin$9, utils: utils$9 } = stylelint;
+const rule_name$9 = "project-wallace/max-selector-complexity";
+const messages$9 = utils$9.ruleMessages(rule_name$9, { rejected: (selector, actual, expected) => `Selector complexity of "${selector}" is ${actual} which is greater than the allowed ${expected}` });
+const meta$9 = { url: "https://github.com/projectwallace/stylelint-plugins" };
+const ruleFunction$9 = (primaryOption) => {
+	return (root, result) => {
+		if (!utils$9.validateOptions(result, rule_name$9, {
+			actual: primaryOption,
+			possible: [Number]
+		}) || !Number.isInteger(primaryOption) || primaryOption <= 1) return;
+		root.walkRules((rule) => {
+			const selector = rule.selector;
+			const parsed = parse_selector(selector);
+			for (const sel of parsed.children) {
+				const complexity = selectorComplexity(sel);
+				const stringified = sel.text.replace(/\n/g, "");
+				if (complexity > primaryOption) utils$9.report({
+					message: messages$9.rejected(stringified, complexity, primaryOption),
+					node: rule,
+					result,
+					ruleName: rule_name$9
+				});
+			}
+		});
+	};
+};
+ruleFunction$9.ruleName = rule_name$9;
+ruleFunction$9.messages = messages$9;
+ruleFunction$9.meta = meta$9;
+var max_selector_complexity_default = createPlugin$9(rule_name$9, ruleFunction$9);
+//#endregion
+//#region src/utils/custom-properties.ts
+function collect_declared_properties(root) {
+	const properties = /* @__PURE__ */ new Map();
+	root.walkAtRules("property", function(atRule) {
+		const property_name = atRule.params.trim();
+		if (property_name.startsWith("--")) properties.set(property_name, atRule);
+	});
+	root.walkDecls(function(declaration) {
+		if (declaration.prop.startsWith("--")) properties.set(declaration.prop, declaration);
+	});
+	return properties;
+}
+function collect_var_usages(root) {
+	const usages = [];
+	root.walkDecls(function(declaration) {
+		walk(parse_declaration(root.source.input.css.substring(declaration.source.start.offset, declaration.source.end.offset)), (node) => {
+			if (node.type === FUNCTION && node.name === "var") {
+				let found_name = null;
+				let has_fallback = false;
+				for (const child of node.children) if (found_name === null && child.type === IDENTIFIER && child.text.startsWith("--")) found_name = child.text;
+				else if (found_name !== null) {
+					has_fallback = true;
+					break;
+				}
+				if (found_name !== null) usages.push({
+					name: found_name,
+					has_fallback,
+					node: declaration
+				});
+			}
+		});
+	});
+	return usages;
+}
+//#endregion
+//#region src/rules/no-unused-custom-properties/index.ts
+const { createPlugin: createPlugin$8, utils: utils$8 } = stylelint;
+const rule_name$8 = "project-wallace/no-unused-custom-properties";
+const messages$8 = utils$8.ruleMessages(rule_name$8, { rejected: (property) => `"${property}" was declared but never used in a var()` });
+const meta$8 = { url: "https://github.com/projectwallace/stylelint-plugins" };
+const ruleFunction$8 = (primaryOptions, secondaryOptions) => {
+	return (root, result) => {
+		if (!utils$8.validateOptions(result, rule_name$8, {
+			actual: primaryOptions,
+			possible: [true]
+		})) return;
+		const declared_properties = collect_declared_properties(root);
+		const used_names = new Set(collect_var_usages(root).map((u) => u.name));
+		for (const [prop, node] of declared_properties) {
+			if (used_names.has(prop)) continue;
+			if (secondaryOptions?.ignoreProperties) {
+				if (secondaryOptions.ignoreProperties.some((pattern) => typeof pattern === "string" && pattern === prop || pattern instanceof RegExp && pattern.test(prop))) continue;
+			}
+			utils$8.report({
+				result,
+				ruleName: rule_name$8,
+				message: messages$8.rejected(prop),
+				node,
+				word: prop
+			});
+		}
+	};
+};
+ruleFunction$8.ruleName = rule_name$8;
+ruleFunction$8.messages = messages$8;
+ruleFunction$8.meta = meta$8;
+var no_unused_custom_properties_default = createPlugin$8(rule_name$8, ruleFunction$8);
+//#endregion
+//#region src/rules/no-unknown-custom-property/index.ts
+const { createPlugin: createPlugin$7, utils: utils$7 } = stylelint;
+const rule_name$7 = "project-wallace/no-unknown-custom-property";
+const messages$7 = utils$7.ruleMessages(rule_name$7, { rejected: (property) => `"${property}" is used in a var() but was never declared` });
+const meta$7 = { url: "https://github.com/projectwallace/stylelint-plugins" };
+const ruleFunction$7 = (primaryOptions, secondaryOptions) => {
+	return (root, result) => {
+		if (!utils$7.validateOptions(result, rule_name$7, {
+			actual: primaryOptions,
+			possible: [true]
+		})) return;
+		const declared_properties = collect_declared_properties(root);
+		const usages = collect_var_usages(root);
+		for (const usage of usages) {
+			if (declared_properties.has(usage.name)) continue;
+			if (secondaryOptions?.allowFallback && usage.has_fallback) continue;
+			if (secondaryOptions?.allowList) {
+				if (secondaryOptions.allowList.some((pattern) => typeof pattern === "string" && pattern === usage.name || pattern instanceof RegExp && pattern.test(usage.name))) continue;
+			}
+			utils$7.report({
+				result,
+				ruleName: rule_name$7,
+				message: messages$7.rejected(usage.name),
+				node: usage.node,
+				word: usage.name
+			});
+		}
+	};
+};
+ruleFunction$7.ruleName = rule_name$7;
+ruleFunction$7.messages = messages$7;
+ruleFunction$7.meta = meta$7;
+var no_unknown_custom_property_default = createPlugin$7(rule_name$7, ruleFunction$7);
+//#endregion
+//#region src/rules/no-property-browserhacks/index.ts
+const { createPlugin: createPlugin$6, utils: utils$6 } = stylelint;
+const rule_name$6 = "project-wallace/no-property-browserhacks";
+const messages$6 = utils$6.ruleMessages(rule_name$6, { rejected: (property) => `Property "${property}" is a browserhack and is not allowed` });
+const meta$6 = { url: "https://github.com/projectwallace/stylelint-plugins" };
+const ruleFunction$6 = (primaryOption) => {
+	return (root, result) => {
+		if (!utils$6.validateOptions(result, rule_name$6, {
+			actual: primaryOption,
+			possible: [true]
+		})) return;
+		root.walkDecls((declaration) => {
+			const parsed = parse_declaration(root.source.input.css.substring(declaration.source.start.offset, declaration.source.end.offset));
+			if (parsed.is_browserhack) utils$6.report({
+				message: messages$6.rejected(parsed.property),
+				node: declaration,
+				result,
+				ruleName: rule_name$6
+			});
+		});
+	};
+};
+ruleFunction$6.ruleName = rule_name$6;
+ruleFunction$6.messages = messages$6;
+ruleFunction$6.meta = meta$6;
+var no_property_browserhacks_default = createPlugin$6(rule_name$6, ruleFunction$6);
+//#endregion
+//#region src/rules/max-lines-of-code/index.ts
+const { createPlugin: createPlugin$5, utils: utils$5 } = stylelint;
+const rule_name$5 = "project-wallace/max-lines-of-code";
+const messages$5 = utils$5.ruleMessages(rule_name$5, { rejected: (actual, expected) => `Counted ${actual} Lines of Code which is greater than the allowed ${expected}` });
+const meta$5 = { url: "https://github.com/projectwallace/stylelint-plugins" };
+const ruleFunction$5 = (primaryOption) => {
+	return (root, result) => {
+		if (!utils$5.validateOptions(result, rule_name$5, {
+			actual: primaryOption,
+			possible: [Number]
+		}) || !Number.isInteger(primaryOption) || primaryOption <= 0) return;
+		const actual = analyze(root.source.input.css).stylesheet.sourceLinesOfCode;
+		if (actual > primaryOption) utils$5.report({
+			message: messages$5.rejected(actual, primaryOption),
+			node: root,
+			result,
+			ruleName: rule_name$5
+		});
+	};
+};
+ruleFunction$5.ruleName = rule_name$5;
+ruleFunction$5.messages = messages$5;
+ruleFunction$5.meta = meta$5;
+var max_lines_of_code_default = createPlugin$5(rule_name$5, ruleFunction$5);
+//#endregion
+//#region src/rules/no-unused-layers/index.ts
+const { createPlugin: createPlugin$4, utils: utils$4 } = stylelint;
+const rule_name$4 = "project-wallace/no-unused-layers";
+const messages$4 = utils$4.ruleMessages(rule_name$4, { rejected: (layer) => `Layer "${layer}" was declared but never defined` });
+const meta$4 = { url: "https://github.com/projectwallace/stylelint-plugin" };
+const ruleFunction$4 = (primaryOptions, secondaryOptions) => {
+	return (root, result) => {
+		if (!utils$4.validateOptions(result, rule_name$4, {
+			actual: primaryOptions,
+			possible: [true]
+		})) return;
+		const declared_layers = /* @__PURE__ */ new Map();
+		const defined_layers = /* @__PURE__ */ new Set();
+		root.walkAtRules("layer", (atRule) => {
+			if (atRule.nodes !== void 0) {
+				const name = atRule.params.trim();
+				if (name) defined_layers.add(name);
+			} else {
+				const names = atRule.params.split(",").map((n) => n.trim()).filter(Boolean);
+				for (const name of names) if (!declared_layers.has(name)) declared_layers.set(name, atRule);
+			}
+		});
+		for (const [layer, node] of declared_layers) {
+			if (defined_layers.has(layer)) continue;
+			if (secondaryOptions?.allowlist) {
+				if (secondaryOptions.allowlist.some((pattern) => typeof pattern === "string" && pattern === layer || pattern instanceof RegExp && pattern.test(layer))) continue;
+			}
+			utils$4.report({
+				result,
+				ruleName: rule_name$4,
+				message: messages$4.rejected(layer),
+				node,
+				word: layer
+			});
+		}
+	};
+};
+ruleFunction$4.ruleName = rule_name$4;
+ruleFunction$4.messages = messages$4;
+ruleFunction$4.meta = meta$4;
+var no_unused_layers_default = createPlugin$4(rule_name$4, ruleFunction$4);
+//#endregion
+//#region src/utils/container-names.ts
+function collect_declared_container_names(root) {
+	const names = /* @__PURE__ */ new Map();
+	root.walkDecls(/^container(-name)?$/i, (decl) => {
+		let value = decl.value.trim();
+		if (decl.prop.toLowerCase() === "container") {
+			const slash_index = value.indexOf("/");
+			if (slash_index !== -1) value = value.substring(0, slash_index).trim();
+		}
+		if (value.toLowerCase() === "none") return;
+		const name_list = value.split(/\s+/).filter(Boolean);
+		for (const name of name_list) if (!names.has(name)) names.set(name, decl);
+	});
+	return names;
+}
+function collect_container_name_usages(root) {
+	const usages = [];
+	root.walkAtRules("container", (atRule) => {
+		const params = atRule.params.trim();
+		if (/^\(|^not[\s(]|^style\s*\(|^and[\s(]|^or[\s(]/.test(params)) return;
+		const match = params.match(/^([\w-]+)/);
+		if (match && match[1].toLowerCase() !== "none") usages.push({
+			name: match[1],
+			node: atRule
+		});
+	});
+	return usages;
+}
+//#endregion
+//#region src/rules/no-unused-container-names/index.ts
+const { createPlugin: createPlugin$3, utils: utils$3 } = stylelint;
+const rule_name$3 = "project-wallace/no-unused-container-names";
+const messages$3 = utils$3.ruleMessages(rule_name$3, { rejected: (name) => `Container name "${name}" was declared but never used in a @container query` });
+const meta$3 = { url: "https://github.com/projectwallace/stylelint-plugin" };
+const ruleFunction$3 = (primaryOptions, secondaryOptions) => {
+	return (root, result) => {
+		if (!utils$3.validateOptions(result, rule_name$3, {
+			actual: primaryOptions,
+			possible: [true]
+		})) return;
+		const declared_names = collect_declared_container_names(root);
+		const used_names = new Set(collect_container_name_usages(root).map((u) => u.name));
+		for (const [name, node] of declared_names) {
+			if (used_names.has(name)) continue;
+			if (secondaryOptions?.allowList) {
+				if (secondaryOptions.allowList.some((pattern) => typeof pattern === "string" && pattern === name || pattern instanceof RegExp && pattern.test(name))) continue;
+			}
+			utils$3.report({
+				result,
+				ruleName: rule_name$3,
+				message: messages$3.rejected(name),
+				node,
+				word: name
+			});
+		}
+	};
+};
+ruleFunction$3.ruleName = rule_name$3;
+ruleFunction$3.messages = messages$3;
+ruleFunction$3.meta = meta$3;
+var no_unused_container_names_default = createPlugin$3(rule_name$3, ruleFunction$3);
+//#endregion
+//#region src/rules/no-undeclared-container-names/index.ts
+const { createPlugin: createPlugin$2, utils: utils$2 } = stylelint;
+const rule_name$2 = "project-wallace/no-undeclared-container-names";
+const messages$2 = utils$2.ruleMessages(rule_name$2, { rejected: (name) => `Container name "${name}" is used in a @container query but was never declared` });
+const meta$2 = { url: "https://github.com/projectwallace/stylelint-plugin" };
+const ruleFunction$2 = (primaryOptions, secondaryOptions) => {
+	return (root, result) => {
+		if (!utils$2.validateOptions(result, rule_name$2, {
+			actual: primaryOptions,
+			possible: [true]
+		})) return;
+		const declared_names = collect_declared_container_names(root);
+		const usages = collect_container_name_usages(root);
+		for (const usage of usages) {
+			if (declared_names.has(usage.name)) continue;
+			if (secondaryOptions?.allowList) {
+				if (secondaryOptions.allowList.some((pattern) => typeof pattern === "string" && pattern === usage.name || pattern instanceof RegExp && pattern.test(usage.name))) continue;
+			}
+			utils$2.report({
+				result,
+				ruleName: rule_name$2,
+				message: messages$2.rejected(usage.name),
+				node: usage.node,
+				word: usage.name
+			});
+		}
+	};
+};
+ruleFunction$2.ruleName = rule_name$2;
+ruleFunction$2.messages = messages$2;
+ruleFunction$2.meta = meta$2;
+var no_undeclared_container_names_default = createPlugin$2(rule_name$2, ruleFunction$2);
+//#endregion
+//#region src/rules/no-anonymous-layers/index.ts
+const { createPlugin: createPlugin$1, utils: utils$1 } = stylelint;
+const rule_name$1 = "project-wallace/no-anonymous-layers";
+const messages$1 = utils$1.ruleMessages(rule_name$1, { rejected: () => `Anonymous @layer is not allowed` });
+const meta$1 = { url: "https://github.com/projectwallace/stylelint-plugin" };
+const ruleFunction$1 = (primaryOptions) => {
+	return (root, result) => {
+		if (!utils$1.validateOptions(result, rule_name$1, {
+			actual: primaryOptions,
+			possible: [true]
+		})) return;
+		root.walkAtRules("layer", (atRule) => {
+			if (atRule.nodes !== void 0 && atRule.params.trim() === "") utils$1.report({
+				result,
+				ruleName: rule_name$1,
+				message: messages$1.rejected(),
+				node: atRule,
+				word: "@layer"
+			});
+		});
+		root.walkAtRules("import", (atRule) => {
+			const params = atRule.params;
+			if (!/\blayer\b/.test(params)) return;
+			if (/\blayer\([^)]+\)/.test(params)) return;
+			utils$1.report({
+				result,
+				ruleName: rule_name$1,
+				message: messages$1.rejected(),
+				node: atRule,
+				word: "layer"
+			});
+		});
+	};
+};
+ruleFunction$1.ruleName = rule_name$1;
+ruleFunction$1.messages = messages$1;
+ruleFunction$1.meta = meta$1;
+var no_anonymous_layers_default = createPlugin$1(rule_name$1, ruleFunction$1);
+//#endregion
+//#region src/rules/no-useless-custom-property-assignment/index.ts
+const { createPlugin, utils } = stylelint;
+const rule_name = "project-wallace/no-useless-custom-property-assignment";
+const messages = utils.ruleMessages(rule_name, { rejected: (property) => `"${property}" is assigned to itself via var(), which has no effect` });
+const meta = { url: "https://github.com/projectwallace/stylelint-plugins" };
+const ruleFunction = (primaryOptions, secondaryOptions) => {
+	return (root, result) => {
+		if (!utils.validateOptions(result, rule_name, {
+			actual: primaryOptions,
+			possible: [true]
+		})) return;
+		root.walkDecls(function(declaration) {
+			const prop = declaration.prop;
+			if (!prop.startsWith("--")) return;
+			if (secondaryOptions?.allowList) {
+				if (secondaryOptions.allowList.some((pattern) => typeof pattern === "string" && pattern === prop || pattern instanceof RegExp && pattern.test(prop))) return;
+			}
+			const parsed = parse_declaration(root.source.input.css.substring(declaration.source.start.offset, declaration.source.end.offset));
+			let reported = false;
+			walk(parsed, (node) => {
+				if (reported) return;
+				if (node.type !== FUNCTION || node.name !== "var") return;
+				for (const child of node.children) {
+					if (child.type === IDENTIFIER && child.text === prop) {
+						utils.report({
+							result,
+							ruleName: rule_name,
+							message: messages.rejected(prop),
+							node: declaration,
+							word: prop
+						});
+						reported = true;
+						return;
+					}
+					if (child.type === IDENTIFIER && child.text.startsWith("--")) break;
+				}
+			});
+		});
+	};
+};
+ruleFunction.ruleName = rule_name;
+ruleFunction.messages = messages;
+ruleFunction.meta = meta;
+//#endregion
+//#region src/index.ts
+const plugins = [
+	max_selector_complexity_default,
+	max_lines_of_code_default,
+	no_unused_custom_properties_default,
+	no_unknown_custom_property_default,
+	no_property_browserhacks_default,
+	no_unused_layers_default,
+	no_unused_container_names_default,
+	no_undeclared_container_names_default,
+	no_anonymous_layers_default,
+	createPlugin(rule_name, ruleFunction)
+];
+//#endregion
+export { plugins as default };

package/package.json

@@ -0,0 +1,54 @@
+{
+	"name": "@projectwallace/stylelint-plugin",
+	"version": "0.1.0",
+	"description": "A stylelint plugin that checks the complexity of your CSS.",
+	"keywords": [
+		"complexity",
+		"css",
+		"lint",
+		"stylelint",
+		"stylelint-plugin",
+		"wallace"
+	],
+	"homepage": "https://github.com/projectwallace/stylelint-plugin",
+	"bugs": "https://github.com/projectwallace/stylelint-plugin/issues",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/projectwallace/stylelint-plugin.git"
+	},
+	"files": [
+		"dist"
+	],
+	"type": "module",
+	"main": "./dist/index.mjs",
+	"exports": {
+		".": "./dist/index.mjs",
+		"./configs/recommended": "./dist/configs/recommended.mjs"
+	},
+	"scripts": {
+		"test": "vitest --coverage",
+		"check": "tsc --noEmit",
+		"lint": "oxlint -D perf; oxfmt --check",
+		"build": "tsdown"
+	},
+	"dependencies": {
+		"@projectwallace/css-analyzer": "^9.4.0",
+		"@projectwallace/css-parser": "^0.13.9"
+	},
+	"devDependencies": {
+		"@codecov/rollup-plugin": "^1.9.1",
+		"@types/node": "^25.5.0",
+		"@vitest/coverage-v8": "^4.0.0",
+		"oxfmt": "^0.41.0",
+		"oxlint": "^1.56.0",
+		"publint": "^0.3.18",
+		"stylelint": "^17.0.0",
+		"tsdown": "^0.21.4",
+		"typescript": "^5.9.3",
+		"vitest": "^4.0.0"
+	},
+	"peerDependencies": {
+		"stylelint": "^17.0.0"
+	}
+}