@projectwallace/format-css 2.2.4 → 2.2.6

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?
@@ -70,13 +70,13 @@ Need more examples?
 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
@@ -84,17 +84,13 @@ let formatted_mini = format("a {}", { minify: true });
 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
-});
+let formatted = format('a { color: red; }', {
+	tab_size: 2,
+})
 ```
 
-## Acknowledgements
-
-- Thanks to [CSSTree](https://github.com/csstree/csstree) for providing the necessary parser and the interfaces for our CSS Types (the **bold** elements in the list above)
-
 ## 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!

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 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 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,57 @@
 {
 	"name": "@projectwallace/format-css",
-	"version": "2.2.4",
+	"version": "2.2.6",
 	"description": "Fast, small, zero-config library to format or minify CSS with basic rules.",
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/projectwallace/format-css.git"
-	},
+	"keywords": [
+		"css",
+		"format",
+		"formatter",
+		"prettier",
+		"prettifier",
+		"pretty",
+		"print",
+		"style",
+		"stylesheet"
+	],
 	"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"
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/projectwallace/format-css.git"
 	},
+	"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",
 		"@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": ">=18.0.0"
 	},
-	"dependencies": {
-		"@projectwallace/css-parser": "^0.13.1"
-	}
+	"issues": "https://github.com/projectwallace/format-css/issues"
 }

package/dist/format-css.js

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