@projectwallace/format-css 2.2.5 → 3.0.0

package/README.md

@@ -41,10 +41,10 @@ npm install @projectwallace/format-css
 ## Usage
 
 ```js
-import { format } from "@projectwallace/format-css";
+import { format } from '@projectwallace/format-css'
 
-let old_css = "/* Your old CSS here */";
-let new_css = format(old_css);
+let old_css = '/* Your old CSS here */'
+let new_css = format(old_css)
 ```
 
 Need more examples?
@@ -65,34 +65,64 @@ Need more examples?
 1. Multiline tokens like **Selectors, Values, etc.** are rendered on a single line
 1. Unknown syntax is rendered as-is, with multi-line formatting kept intact
 
-## Minify CSS
+## Options
+
+### Minify CSS
 
 This package also exposes a minifier function since minifying CSS follows many of the same rules as formatting.
 
 ```js
-import { format, minify } from "@projectwallace/format-css";
+import { format, minify } from '@projectwallace/format-css'
 
-let minified = minify("a {}");
+let minified = minify('a {}')
 
 // which is an alias for
 
-let formatted_mini = format("a {}", { minify: true });
+let formatted_mini = format('a {}', { minify: true })
 ```
 
-## Tab size
+### Tab size
 
 For cases where you cannot control the tab size with CSS there is an option to override the default tabbed indentation with N spaces.
 
 ```js
-import { format } from "@projectwallace/format-css";
+import { format } from '@projectwallace/format-css'
+
+let formatted = format('a { color: red; }', {
+	tab_size: 2,
+})
+```
+
+## CLI
+
+This library also ships a CLI tools that's a small wrapper around the library.
+
+```
+USAGE
+  format-css [options] [file...]
+  cat styles.css | format-css [options]
+
+OPTIONS
+  --minify            Minify the CSS output
+  --tab-size=<n>      Use N spaces for indentation instead of tabs
+  --help, -h          Show this help
+
+EXAMPLES
+  # Format a file
+  format-css styles.css
+
+  # Format with 2-space indentation
+  format-css styles.css --tab-size=2
+
+  # Minify
+  format-css styles.css --minify
 
-let formatted = format("a { color: red; }", {
-	tab_size: 2
-});
+  # Via pipe
+  cat styles.css | format-css
 ```
 
 ## Related projects
 
-- [Format CSS online](https://www.projectwallace.com/prettify-css?utm_source=github&utm_medium=wallace_format_css_related_projects) - See this formatter in action online!
-- [Minify CSS online](https://www.projectwallace.com/minify-css?utm_source=github&utm_medium=wallace_format_css_related_projects) - See this minifier in action online!
-- [CSS Analyzer](https://github.com/projectwallace/css-analyzer) - The best CSS analyzer that powers all analysis on [projectwallace.com](https://www.projectwallace.com?utm_source=github&utm_medium=wallace_format_css_related_projects)
+- [Format CSS online](https://www.projectwallace.com/prettify-css) - See this formatter in action online!
+- [Minify CSS online](https://www.projectwallace.com/minify-css) - See this minifier in action online!
+- [CSS Analyzer](https://github.com/projectwallace/css-analyzer) - The best CSS analyzer that powers all analysis on [projectwallace.com](https://www.projectwallace.com)

package/dist/cli.mjs

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+import { parseArgs, styleText } from "node:util";
+import { readFileSync } from "node:fs";
+import { resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { format } from "@projectwallace/format-css";
+//#region src/cli/cli.ts
+function help() {
+	return `
+${styleText("bold", "USAGE")}
+  format-css [options] [file...]
+  cat styles.css | format-css [options]
+
+${styleText("bold", "OPTIONS")}
+  --minify            Minify the CSS output
+  --tab-size=<n>      Use N spaces for indentation instead of tabs
+  --help, -h          Show this help
+
+${styleText("bold", "EXAMPLES")}
+  ${styleText("dim", "# Format a file")}
+  format-css styles.css
+
+  ${styleText("dim", "# Format with 2-space indentation")}
+  format-css styles.css --tab-size=2
+
+  ${styleText("dim", "# Minify")}
+  format-css styles.css --minify
+
+  ${styleText("dim", "# Via pipe")}
+  cat styles.css | format-css
+	`.trim();
+}
+function parse_arguments(args) {
+	const { values, positionals } = parseArgs({
+		args,
+		allowPositionals: true,
+		options: {
+			minify: {
+				type: "boolean",
+				default: false
+			},
+			"tab-size": { type: "string" }
+		}
+	});
+	const issues = [];
+	let tab_size;
+	if (values["tab-size"] !== void 0) {
+		tab_size = Number(values["tab-size"]);
+		if (isNaN(tab_size) || tab_size < 1) issues.push("--tab-size must be a positive integer");
+	}
+	const cwd = process.cwd();
+	const files = [];
+	for (const file of positionals) {
+		const resolved = resolve(file);
+		if (resolved !== cwd && !resolved.startsWith(cwd + sep)) issues.push(`Invalid path: ${file}`);
+		else files.push(resolved);
+	}
+	if (issues.length > 0) throw new Error(issues.join("\n"));
+	return {
+		files,
+		minify: values.minify ?? false,
+		tab_size
+	};
+}
+async function run(args, io) {
+	if (args.includes("--help") || args.includes("-h")) {
+		io.write(help() + "\n");
+		return;
+	}
+	const { files, minify, tab_size } = parse_arguments(args);
+	const options = {
+		minify,
+		tab_size
+	};
+	if (files.length > 0) for (const file of files) io.write(format(io.readFile(file), options));
+	else if (!io.isTTY) io.write(format(await io.readStdin(), options));
+	else io.write(help() + "\n");
+}
+async function read_stdin() {
+	const chunks = [];
+	for await (const chunk of process.stdin) chunks.push(chunk);
+	return Buffer.concat(chunks).toString("utf-8");
+}
+if (process.argv[1] === fileURLToPath(import.meta.url)) try {
+	await run(process.argv.slice(2), {
+		readFile: (path) => readFileSync(path, "utf-8"),
+		readStdin: read_stdin,
+		write: (output) => process.stdout.write(output),
+		isTTY: process.stdin.isTTY === true
+	});
+} catch (error) {
+	console.error(error instanceof Error ? error.message : String(error));
+	process.exit(1);
+}
+//#endregion
+export { parse_arguments, run };

package/dist/index.d.ts

@@ -1,16 +1,20 @@
-export type FormatOptions = {
-    /** Whether to minify the CSS or keep it formatted */
-    minify?: boolean;
-    /** Tell the formatter to use N spaces instead of tabs  */
-    tab_size?: number;
+//#region src/lib/index.d.ts
+type FormatOptions = {
+  /** Whether to minify the CSS or keep it formatted */minify?: boolean; /** Tell the formatter to use N spaces instead of tabs  */
+  tab_size?: number;
 };
 /**
  * Format a string of CSS using some simple rules
  */
-export declare function format(css: string, { minify, tab_size }?: FormatOptions): string;
+declare function format(css: string, {
+  minify,
+  tab_size
+}?: FormatOptions): string;
 /**
  * Minify a string of CSS
  * @param {string} css The original CSS
  * @returns {string} The minified CSS
  */
-export declare function minify(css: string): string;
+declare function minify(css: string): string;
+//#endregion
+export { FormatOptions, format, minify };

package/dist/index.js

@@ -0,0 +1,335 @@
+import { ATTR_FLAG_NAMES, ATTR_OPERATOR_NAMES, NODE_TYPES, parse } from "@projectwallace/css-parser";
+//#region src/lib/index.ts
+const SPACE = " ";
+const EMPTY_STRING = "";
+const COLON = ":";
+const SEMICOLON = ";";
+const QUOTE = "\"";
+const OPEN_PARENTHESES = "(";
+const CLOSE_PARENTHESES = ")";
+const OPEN_BRACKET = "[";
+const CLOSE_BRACKET = "]";
+const OPEN_BRACE = "{";
+const CLOSE_BRACE = "}";
+const COMMA = ",";
+/**
+* Format a string of CSS using some simple rules
+*/
+function format(css, { minify = false, tab_size = void 0 } = Object.create(null)) {
+	if (tab_size !== void 0 && Number(tab_size) < 1) throw new TypeError("tab_size must be a number greater than 0");
+	const NEWLINE = minify ? EMPTY_STRING : "\n";
+	const OPTIONAL_SPACE = minify ? EMPTY_STRING : SPACE;
+	const LAST_SEMICOLON = minify ? EMPTY_STRING : SEMICOLON;
+	let comments = [];
+	let ast = parse(css, {
+		parse_atrule_preludes: false,
+		on_comment: minify ? void 0 : ({ start, end }) => {
+			comments.push(start, end);
+		}
+	});
+	let depth = 0;
+	function indent(size) {
+		if (minify === true) return EMPTY_STRING;
+		if (tab_size !== void 0) return SPACE.repeat(tab_size * size);
+		return "	".repeat(size);
+	}
+	/**
+	* Get and format comments from the CSS string within a range
+	* @param after After which offset to look for comments
+	* @param before Before which offset to look for comments
+	* @param level Indentation level (uses current depth if not specified)
+	* @returns The formatted comment string, or empty string if no comment found
+	*/
+	function get_comment(after, before, level = depth) {
+		if (minify || after === void 0 || before === void 0) return EMPTY_STRING;
+		let buffer = EMPTY_STRING;
+		for (let i = 0; i < comments.length; i += 2) {
+			let start = comments[i];
+			if (start === void 0 || start < after) continue;
+			let end = comments[i + 1];
+			if (end === void 0 || end > before) break;
+			if (buffer.length > 0) buffer += NEWLINE + indent(level);
+			buffer += css.slice(start, end);
+		}
+		return buffer;
+	}
+	function unquote(str) {
+		return str.replace(/(?:^['"])|(?:['"]$)/g, EMPTY_STRING);
+	}
+	function print_string(str) {
+		str = str?.toString() || "";
+		return QUOTE + unquote(str) + QUOTE;
+	}
+	function print_operator(node) {
+		let parts = [];
+		let operator = node.text;
+		let code = operator.charCodeAt(0);
+		if (code === 43 || code === 45) parts.push(SPACE);
+		else if (code !== 44) parts.push(OPTIONAL_SPACE);
+		parts.push(operator);
+		if (code === 43 || code === 45) parts.push(SPACE);
+		else parts.push(OPTIONAL_SPACE);
+		return parts.join(EMPTY_STRING);
+	}
+	function print_list(nodes) {
+		let parts = [];
+		for (let node of nodes) {
+			if (node.type === NODE_TYPES.FUNCTION) {
+				let fn = node.name?.toLowerCase();
+				parts.push(fn, OPEN_PARENTHESES);
+				parts.push(print_list(node.children));
+				parts.push(CLOSE_PARENTHESES);
+			} else if (node.type === NODE_TYPES.DIMENSION) parts.push(node.value, node.unit?.toLowerCase());
+			else if (node.type === NODE_TYPES.STRING) parts.push(print_string(node.text));
+			else if (node.type === NODE_TYPES.OPERATOR) parts.push(print_operator(node));
+			else if (node.type === NODE_TYPES.PARENTHESIS) parts.push(OPEN_PARENTHESES, print_list(node.children), CLOSE_PARENTHESES);
+			else if (node.type === NODE_TYPES.URL && typeof node.value === "string") {
+				parts.push("url(");
+				let { value } = node;
+				if (/^['"]?data:/i.test(value)) parts.push(unquote(value));
+				else parts.push(print_string(value));
+				parts.push(CLOSE_PARENTHESES);
+			} else parts.push(node.text);
+			if (node.type !== NODE_TYPES.OPERATOR) {
+				if (node.has_next) {
+					if (node.next_sibling?.type !== NODE_TYPES.OPERATOR) parts.push(SPACE);
+				}
+			}
+		}
+		return parts.join(EMPTY_STRING);
+	}
+	function print_value(nodes) {
+		if (nodes === null) return EMPTY_STRING;
+		return print_list(nodes);
+	}
+	function print_declaration(node) {
+		let important = [];
+		if (node.is_important) {
+			let text = node.text;
+			let has_semicolon = text.endsWith(SEMICOLON);
+			let start = text.lastIndexOf("!");
+			let end = has_semicolon ? -1 : void 0;
+			important.push(OPTIONAL_SPACE, text.slice(start, end).toLowerCase());
+		}
+		let value = print_value(node.value);
+		let property = node.property;
+		if (property === "font") value = value.replace(/\s*\/\s*/, "/");
+		if (value === EMPTY_STRING && minify === true) value += SPACE;
+		if (!property.startsWith("--")) property = property.toLowerCase();
+		return property + COLON + OPTIONAL_SPACE + value + important.join(EMPTY_STRING);
+	}
+	function print_nth(node) {
+		let parts = [];
+		let a = node.nth_a;
+		let b = node.nth_b;
+		if (a) parts.push(a);
+		if (a && b) parts.push(OPTIONAL_SPACE);
+		if (b) {
+			if (a && !b.startsWith("-")) parts.push("+", OPTIONAL_SPACE);
+			parts.push(parseFloat(b));
+		}
+		return parts.join(EMPTY_STRING);
+	}
+	function print_nth_of(node) {
+		let parts = [];
+		if (node.children[0]?.type === NODE_TYPES.NTH_SELECTOR) {
+			parts.push(print_nth(node.children[0]));
+			parts.push(SPACE, "of", SPACE);
+		}
+		if (node.children[1]?.type === NODE_TYPES.SELECTOR_LIST) parts.push(print_inline_selector_list(node.children[1]));
+		return parts.join(EMPTY_STRING);
+	}
+	function print_simple_selector(node, is_first = false) {
+		let name = node.name ?? "";
+		switch (node.type) {
+			case NODE_TYPES.TYPE_SELECTOR: return name.toLowerCase() ?? "";
+			case NODE_TYPES.COMBINATOR: {
+				let text = node.text;
+				if (/^\s+$/.test(text)) return SPACE;
+				return (is_first ? EMPTY_STRING : OPTIONAL_SPACE) + text + OPTIONAL_SPACE;
+			}
+			case NODE_TYPES.PSEUDO_ELEMENT_SELECTOR:
+			case NODE_TYPES.PSEUDO_CLASS_SELECTOR: {
+				let parts = [COLON];
+				name = name.toLowerCase();
+				if (name === "before" || name === "after" || node.type === NODE_TYPES.PSEUDO_ELEMENT_SELECTOR) parts.push(COLON);
+				parts.push(name);
+				if (node.has_children) {
+					parts.push(OPEN_PARENTHESES);
+					if (node.children.length > 0) if (name === "highlight") parts.push(print_list(node.children));
+					else parts.push(print_inline_selector_list(node));
+					parts.push(CLOSE_PARENTHESES);
+				}
+				return parts.join(EMPTY_STRING);
+			}
+			case NODE_TYPES.ATTRIBUTE_SELECTOR: {
+				let parts = [OPEN_BRACKET, name.toLowerCase()];
+				if (node.attr_operator) {
+					parts.push(ATTR_OPERATOR_NAMES[node.attr_operator] ?? "");
+					if (typeof node.value === "string") parts.push(print_string(node.value));
+					if (node.attr_flags) parts.push(SPACE, ATTR_FLAG_NAMES[node.attr_flags] ?? "");
+				}
+				parts.push(CLOSE_BRACKET);
+				return parts.join(EMPTY_STRING);
+			}
+			default: return node.text;
+		}
+	}
+	function print_selector(node) {
+		if (node.type === NODE_TYPES.NTH_SELECTOR) return print_nth(node);
+		if (node.type === NODE_TYPES.NTH_OF_SELECTOR) return print_nth_of(node);
+		if (node.type === NODE_TYPES.SELECTOR_LIST) return print_inline_selector_list(node);
+		if (node.type === NODE_TYPES.LANG_SELECTOR) return print_string(node.text);
+		let parts = [];
+		node.children.forEach((child, index) => {
+			const part = print_simple_selector(child, index === 0);
+			parts.push(part);
+		});
+		return parts.join(EMPTY_STRING);
+	}
+	function print_inline_selector_list(node) {
+		let parts = [];
+		for (let selector of node) {
+			parts.push(print_selector(selector));
+			if (selector.has_next) parts.push(COMMA, OPTIONAL_SPACE);
+		}
+		return parts.join(EMPTY_STRING);
+	}
+	function print_selector_list(node) {
+		let lines = [];
+		let prev_end;
+		for (let selector of node) {
+			if (prev_end !== void 0) {
+				let comment = get_comment(prev_end, selector.start);
+				if (comment) lines.push(indent(depth) + comment);
+			}
+			let printed = print_selector(selector);
+			if (selector.has_next) printed += COMMA;
+			lines.push(indent(depth) + printed);
+			prev_end = selector.end;
+		}
+		return lines.join(NEWLINE);
+	}
+	function print_block(node) {
+		let lines = [];
+		depth++;
+		let children = node.children;
+		if (children.length === 0) {
+			let comment = get_comment(node.start, node.end);
+			if (comment) {
+				lines.push(indent(depth) + comment);
+				depth--;
+				lines.push(indent(depth) + CLOSE_BRACE);
+				return lines.join(NEWLINE);
+			}
+		}
+		let first_child = children[0];
+		let comment_before_first = get_comment(node.start, first_child?.start);
+		if (comment_before_first) lines.push(indent(depth) + comment_before_first);
+		let prev_end;
+		for (let child of children) {
+			if (prev_end !== void 0) {
+				let comment = get_comment(prev_end, child.start);
+				if (comment) lines.push(indent(depth) + comment);
+			}
+			let is_last = child.next_sibling?.type !== NODE_TYPES.DECLARATION;
+			if (child.type === NODE_TYPES.DECLARATION) {
+				let declaration = print_declaration(child);
+				let semi = is_last ? LAST_SEMICOLON : SEMICOLON;
+				lines.push(indent(depth) + declaration + semi);
+			} else if (child.type === NODE_TYPES.STYLE_RULE) {
+				if (prev_end !== void 0 && lines.length !== 0) lines.push(EMPTY_STRING);
+				lines.push(print_rule(child));
+			} else if (child.type === NODE_TYPES.AT_RULE) {
+				if (prev_end !== void 0 && lines.length !== 0) lines.push(EMPTY_STRING);
+				lines.push(indent(depth) + print_atrule(child));
+			}
+			prev_end = child.end;
+		}
+		let comment_after_last = get_comment(prev_end, node.end);
+		if (comment_after_last) lines.push(indent(depth) + comment_after_last);
+		depth--;
+		lines.push(indent(depth) + CLOSE_BRACE);
+		return lines.join(NEWLINE);
+	}
+	function print_rule(node) {
+		let lines = [];
+		if (node.first_child?.type === NODE_TYPES.SELECTOR_LIST) {
+			let list = print_selector_list(node.first_child);
+			let comment = get_comment(node.first_child.end, node.block?.start);
+			if (comment) list += NEWLINE + indent(depth) + comment;
+			list += OPTIONAL_SPACE + OPEN_BRACE;
+			if (!(node.block && (node.block.has_children || get_comment(node.block.start, node.block.end)))) list += CLOSE_BRACE;
+			lines.push(list);
+		}
+		if (node.block) {
+			if (node.block.has_children || get_comment(node.block.start, node.block.end)) lines.push(print_block(node.block));
+		}
+		return lines.join(NEWLINE);
+	}
+	/**
+	* Pretty-printing atrule preludes takes an insane amount of rules,
+	* so we're opting for a couple of 'good-enough' string replacements
+	* here to force some nice formatting.
+	* Should be OK perf-wise, since the amount of atrules in most
+	* stylesheets are limited, so this won't be called too often.
+	*/
+	function print_atrule_prelude(prelude) {
+		return prelude.replace(/\s*([:,])/g, prelude.toLowerCase().includes("selector(") ? "$1" : "$1 ").replace(/\)([a-zA-Z])/g, ") $1").replace(/\s*(=>|<=)\s*/g, " $1 ").replace(/([^<>=\s])([<>])([^<>=\s])/g, `$1${OPTIONAL_SPACE}$2${OPTIONAL_SPACE}$3`).replace(/\s+/g, OPTIONAL_SPACE).replace(/calc\(\s*([^()+\-*/]+)\s*([*/+-])\s*([^()+\-*/]+)\s*\)/g, (_, left, operator, right) => {
+			let space = operator === "+" || operator === "-" ? SPACE : OPTIONAL_SPACE;
+			return `calc(${left.trim()}${space}${operator}${space}${right.trim()})`;
+		}).replace(/selector|url|supports|layer\(/gi, (match) => match.toLowerCase());
+	}
+	function print_atrule(node) {
+		let lines = [];
+		let name = [`@`, node.name.toLowerCase()];
+		if (node.prelude) name.push(SPACE, print_atrule_prelude(node.prelude.text));
+		if (node.block === null) name.push(SEMICOLON);
+		else {
+			name.push(OPTIONAL_SPACE, OPEN_BRACE);
+			if (!(!node.block.is_empty || get_comment(node.block.start, node.block.end))) name.push(CLOSE_BRACE);
+		}
+		lines.push(name.join(EMPTY_STRING));
+		if (node.block !== null) {
+			if (!node.block.is_empty || get_comment(node.block.start, node.block.end)) lines.push(print_block(node.block));
+		}
+		return lines.join(NEWLINE);
+	}
+	function print_stylesheet(node) {
+		let lines = [];
+		let children = node.children;
+		if (children.length === 0) return get_comment(0, node.end, 0);
+		let first_child = children[0];
+		if (first_child) {
+			let comment_before_first = get_comment(0, first_child.start, 0);
+			if (comment_before_first) lines.push(comment_before_first);
+		}
+		let prev_end;
+		for (let child of node) {
+			if (prev_end !== void 0) {
+				let comment = get_comment(prev_end, child.start, 0);
+				if (comment) lines.push(comment);
+			}
+			if (child.type === NODE_TYPES.STYLE_RULE) lines.push(print_rule(child));
+			else if (child.type === NODE_TYPES.AT_RULE) lines.push(print_atrule(child));
+			prev_end = child.end;
+			if (child.has_next) {
+				if (!(child.next_sibling && get_comment(child.end, child.next_sibling.start, 0))) lines.push(EMPTY_STRING);
+			}
+		}
+		let comment_after_last = get_comment(prev_end, node.end, 0);
+		if (comment_after_last) lines.push(comment_after_last);
+		return lines.join(NEWLINE);
+	}
+	return print_stylesheet(ast).trimEnd();
+}
+/**
+* Minify a string of CSS
+* @param {string} css The original CSS
+* @returns {string} The minified CSS
+*/
+function minify(css) {
+	return format(css, { minify: true });
+}
+//#endregion
+export { format, minify };

package/package.json

@@ -1,65 +1,61 @@
 {
 	"name": "@projectwallace/format-css",
-	"version": "2.2.5",
+	"version": "3.0.0",
 	"description": "Fast, small, zero-config library to format or minify CSS with basic rules.",
+	"keywords": [
+		"css",
+		"format",
+		"formatter",
+		"prettier",
+		"prettifier",
+		"pretty",
+		"print",
+		"style",
+		"stylesheet"
+	],
+	"homepage": "https://github.com/projectwallace/format-css",
+	"license": "MIT",
+	"author": "Bart Veneman <bart@projectwallace.com>",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/projectwallace/format-css.git"
 	},
-	"homepage": "https://github.com/projectwallace/format-css",
-	"issues": "https://github.com/projectwallace/format-css/issues",
-	"license": "MIT",
-	"author": "Bart Veneman <bart@projectwallace.com>",
-	"engines": {
-		"node": ">=18.0.0"
+	"bin": {
+		"format-css": "./dist/cli.mjs"
 	},
+	"files": [
+		"dist"
+	],
 	"type": "module",
-	"main": "./dist/format-css.js",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
 	"exports": {
 		"types": "./dist/index.d.ts",
-		"default": "./dist/format-css.js"
+		"default": "./dist/index.js"
 	},
-	"types": "./dist/index.d.ts",
 	"scripts": {
-		"build": "vite build",
+		"build": "tsdown",
 		"test": "vitest --coverage",
 		"check": "tsc",
 		"prettier": "prettier --check index.ts test/**/*.ts",
-		"lint": "oxlint",
-		"lint-package": "publint"
+		"lint": "oxlint && oxfmt --check"
+	},
+	"dependencies": {
+		"@projectwallace/css-parser": "^0.13.5"
 	},
 	"devDependencies": {
-		"@codecov/vite-plugin": "^1.9.1",
+		"@codecov/rollup-plugin": "^1.9.1",
+		"@types/node": "^25.5.0",
 		"@vitest/coverage-v8": "^4.0.3",
-		"c8": "^10.1.3",
+		"oxfmt": "^0.36.0",
 		"oxlint": "^1.24.0",
-		"prettier": "^3.6.2",
 		"publint": "^0.3.15",
+		"tsdown": "^0.21.0",
 		"typescript": "^5.9.3",
-		"vite": "^6.2.6",
-		"vite-plugin-dts": "^4.5.4",
 		"vitest": "^4.0.3"
 	},
-	"files": [
-		"dist"
-	],
-	"keywords": [
-		"css",
-		"stylesheet",
-		"formatter",
-		"format",
-		"print",
-		"prettifier",
-		"pretty",
-		"prettier"
-	],
-	"prettier": {
-		"semi": false,
-		"useTabs": true,
-		"printWidth": 140,
-		"singleQuote": true
+	"engines": {
+		"node": ">=20.12.0"
 	},
-	"dependencies": {
-		"@projectwallace/css-parser": "^0.13.5"
-	}
+	"issues": "https://github.com/projectwallace/format-css/issues"
 }

package/dist/format-css.js

@@ -1,216 +0,0 @@
-import { parse as V, NODE_TYPES as u, ATTR_OPERATOR_NAMES as X, ATTR_FLAG_NAMES as z } from "@projectwallace/css-parser";
-const _ = " ", p = "", y = ":", A = ";", d = '"', v = "(", g = ")", tt = "[", et = "]", M = "{", N = "}", U = ",";
-function rt(L, { minify: O = !1, tab_size: m = void 0 } = /* @__PURE__ */ Object.create(null)) {
-  if (m !== void 0 && Number(m) < 1)
-    throw new TypeError("tab_size must be a number greater than 0");
-  const E = O ? p : `
-`, c = O ? p : _, D = O ? p : A;
-  let S = [], B = V(L, {
-    parse_atrule_preludes: !1,
-    on_comment: O ? void 0 : ({ start: t, end: e }) => {
-      S.push(t, e);
-    }
-  }), a = 0;
-  function o(t) {
-    return O === !0 ? p : m !== void 0 ? _.repeat(m * t) : "	".repeat(t);
-  }
-  function f(t, e, s = a) {
-    if (O || t === void 0 || e === void 0)
-      return p;
-    let r = p;
-    for (let i = 0; i < S.length; i += 2) {
-      let l = S[i];
-      if (l === void 0 || l < t) continue;
-      let n = S[i + 1];
-      if (n === void 0 || n > e) break;
-      r.length > 0 && (r += E + o(s)), r += L.slice(l, n);
-    }
-    return r;
-  }
-  function x(t) {
-    return t.replace(/(?:^['"])|(?:['"]$)/g, p);
-  }
-  function C(t) {
-    return t = (t == null ? void 0 : t.toString()) || "", d + x(t) + d;
-  }
-  function H(t) {
-    let e = [], s = t.text, r = s.charCodeAt(0);
-    return r === 43 || r === 45 ? e.push(_) : r !== 44 && e.push(c), e.push(s), r === 43 || r === 45 ? e.push(_) : e.push(c), e.join(p);
-  }
-  function b(t) {
-    var s, r, i;
-    let e = [];
-    for (let l of t) {
-      if (l.type === u.FUNCTION) {
-        let n = (s = l.name) == null ? void 0 : s.toLowerCase();
-        e.push(n, v), e.push(b(l.children)), e.push(g);
-      } else if (l.type === u.DIMENSION)
-        e.push(l.value, (r = l.unit) == null ? void 0 : r.toLowerCase());
-      else if (l.type === u.STRING)
-        e.push(C(l.text));
-      else if (l.type === u.OPERATOR)
-        e.push(H(l));
-      else if (l.type === u.PARENTHESIS)
-        e.push(v, b(l.children), g);
-      else if (l.type === u.URL && typeof l.value == "string") {
-        e.push("url(");
-        let { value: n } = l;
-        /^['"]?data:/i.test(n) ? e.push(x(n)) : e.push(C(n)), e.push(g);
-      } else
-        e.push(l.text);
-      l.type !== u.OPERATOR && l.has_next && ((i = l.next_sibling) == null ? void 0 : i.type) !== u.OPERATOR && e.push(_);
-    }
-    return e.join(p);
-  }
-  function Y(t) {
-    return t === null ? p : b(t);
-  }
-  function F(t) {
-    let e = [];
-    if (t.is_important) {
-      let i = t.text, l = i.endsWith(A), n = i.lastIndexOf("!"), T = l ? -1 : void 0;
-      e.push(c, i.slice(n, T).toLowerCase());
-    }
-    let s = Y(t.value), r = t.property;
-    return r === "font" && (s = s.replace(/\s*\/\s*/, "/")), s === p && O === !0 && (s += _), r.startsWith("--") || (r = r.toLowerCase()), r + y + c + s + e.join(p);
-  }
-  function P(t) {
-    let e = [], s = t.nth_a, r = t.nth_b;
-    return s && e.push(s), s && r && e.push(c), r && (s && !r.startsWith("-") && e.push("+", c), e.push(parseFloat(r))), e.join(p);
-  }
-  function G(t) {
-    var s, r;
-    let e = [];
-    return ((s = t.children[0]) == null ? void 0 : s.type) === u.NTH_SELECTOR && (e.push(P(t.children[0])), e.push(_, "of", _)), ((r = t.children[1]) == null ? void 0 : r.type) === u.SELECTOR_LIST && e.push(k(t.children[1])), e.join(p);
-  }
-  function W(t, e = !1) {
-    let s = t.name ?? "";
-    switch (t.type) {
-      case u.TYPE_SELECTOR:
-        return s.toLowerCase() ?? "";
-      case u.COMBINATOR: {
-        let r = t.text;
-        return /^\s+$/.test(r) ? _ : (e ? p : c) + r + c;
-      }
-      case u.PSEUDO_ELEMENT_SELECTOR:
-      case u.PSEUDO_CLASS_SELECTOR: {
-        let r = [y];
-        return s = s.toLowerCase(), (s === "before" || s === "after" || t.type === u.PSEUDO_ELEMENT_SELECTOR) && r.push(y), r.push(s), t.has_children && (r.push(v), t.children.length > 0 && (s === "highlight" ? r.push(b(t.children)) : r.push(k(t))), r.push(g)), r.join(p);
-      }
-      case u.ATTRIBUTE_SELECTOR: {
-        let r = [tt, s.toLowerCase()];
-        return t.attr_operator && (r.push(X[t.attr_operator] ?? ""), typeof t.value == "string" && r.push(C(t.value)), t.attr_flags && r.push(_, z[t.attr_flags] ?? "")), r.push(et), r.join(p);
-      }
-      default:
-        return t.text;
-    }
-  }
-  function I(t) {
-    if (t.type === u.NTH_SELECTOR)
-      return P(t);
-    if (t.type === u.NTH_OF_SELECTOR)
-      return G(t);
-    if (t.type === u.SELECTOR_LIST)
-      return k(t);
-    if (t.type === u.LANG_SELECTOR)
-      return C(t.text);
-    let e = [];
-    return t.children.forEach((s, r) => {
-      const i = W(s, r === 0);
-      e.push(i);
-    }), e.join(p);
-  }
-  function k(t) {
-    let e = [];
-    for (let s of t)
-      e.push(I(s)), s.has_next && e.push(U, c);
-    return e.join(p);
-  }
-  function K(t) {
-    let e = [], s;
-    for (let r of t) {
-      if (s !== void 0) {
-        let l = f(s, r.start);
-        l && e.push(o(a) + l);
-      }
-      let i = I(r);
-      r.has_next && (i += U), e.push(o(a) + i), s = r.end;
-    }
-    return e.join(E);
-  }
-  function j(t) {
-    var T;
-    let e = [];
-    a++;
-    let s = t.children;
-    if (s.length === 0) {
-      let h = f(t.start, t.end);
-      if (h)
-        return e.push(o(a) + h), a--, e.push(o(a) + N), e.join(E);
-    }
-    let r = s[0], i = f(t.start, r == null ? void 0 : r.start);
-    i && e.push(o(a) + i);
-    let l;
-    for (let h of s) {
-      if (l !== void 0) {
-        let R = f(l, h.start);
-        R && e.push(o(a) + R);
-      }
-      let Z = ((T = h.next_sibling) == null ? void 0 : T.type) !== u.DECLARATION;
-      if (h.type === u.DECLARATION) {
-        let R = F(h), J = Z ? D : A;
-        e.push(o(a) + R + J);
-      } else h.type === u.STYLE_RULE ? (l !== void 0 && e.length !== 0 && e.push(p), e.push($(h))) : h.type === u.AT_RULE && (l !== void 0 && e.length !== 0 && e.push(p), e.push(o(a) + w(h)));
-      l = h.end;
-    }
-    let n = f(l, t.end);
-    return n && e.push(o(a) + n), a--, e.push(o(a) + N), e.join(E);
-  }
-  function $(t) {
-    var s, r;
-    let e = [];
-    if (((s = t.first_child) == null ? void 0 : s.type) === u.SELECTOR_LIST) {
-      let i = K(t.first_child), l = f(t.first_child.end, (r = t.block) == null ? void 0 : r.start);
-      l && (i += E + o(a) + l), i += c + M, t.block && (t.block.has_children || f(t.block.start, t.block.end)) || (i += N), e.push(i);
-    }
-    return t.block && (t.block.has_children || f(t.block.start, t.block.end)) && e.push(j(t.block)), e.join(E);
-  }
-  function q(t) {
-    return t.replace(/\s*([:,])/g, t.toLowerCase().includes("selector(") ? "$1" : "$1 ").replace(/\)([a-zA-Z])/g, ") $1").replace(/\s*(=>|<=)\s*/g, " $1 ").replace(/([^<>=\s])([<>])([^<>=\s])/g, `$1${c}$2${c}$3`).replace(/\s+/g, c).replace(/calc\(\s*([^()+\-*/]+)\s*([*/+-])\s*([^()+\-*/]+)\s*\)/g, (e, s, r, i) => {
-      let l = r === "+" || r === "-" ? _ : c;
-      return `calc(${s.trim()}${l}${r}${l}${i.trim()})`;
-    }).replace(/selector|url|supports|layer\(/gi, (e) => e.toLowerCase());
-  }
-  function w(t) {
-    let e = [], s = ["@", t.name.toLowerCase()];
-    return t.prelude && s.push(_, q(t.prelude.text)), t.block === null ? s.push(A) : (s.push(c, M), !t.block.is_empty || f(t.block.start, t.block.end) || s.push(N)), e.push(s.join(p)), t.block !== null && (!t.block.is_empty || f(t.block.start, t.block.end)) && e.push(j(t.block)), e.join(E);
-  }
-  function Q(t) {
-    let e = [], s = t.children;
-    if (s.length === 0)
-      return f(0, t.end, 0);
-    let r = s[0];
-    if (r) {
-      let n = f(0, r.start, 0);
-      n && e.push(n);
-    }
-    let i;
-    for (let n of t) {
-      if (i !== void 0) {
-        let T = f(i, n.start, 0);
-        T && e.push(T);
-      }
-      n.type === u.STYLE_RULE ? e.push($(n)) : n.type === u.AT_RULE && e.push(w(n)), i = n.end, n.has_next && (n.next_sibling && f(n.end, n.next_sibling.start, 0) || e.push(p));
-    }
-    let l = f(i, t.end, 0);
-    return l && e.push(l), e.join(E);
-  }
-  return Q(B).trimEnd();
-}
-function lt(L) {
-  return rt(L, { minify: !0 });
-}
-export {
-  rt as format,
-  lt as minify
-};