@projectwallace/format-css 2.0.0 → 2.1.0

package/README.md

@@ -79,6 +79,18 @@ let minified = minify("a {}");
 let formatted_mini = format("a {}", { minify: true });
 ```
 
+## 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";
+
+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)

package/dist/format-css.js

@@ -1,83 +1,88 @@
-import h from "css-tree/parser";
-const o = " ", i = "", N = ":", x = ";", L = '"', I = "(", g = ")", d = "[", ee = "]", H = "{", V = "}", te = "{}", W = ",", Z = "Atrule", z = "Rule", F = "Block", G = "SelectorList", Y = "Selector", B = "Declaration", $ = "Operator";
-function b(_) {
-  return /[A-Z]/.test(_) ? _.toLowerCase() : _;
+import d from "css-tree/parser";
+const a = " ", c = "", $ = ":", x = ";", g = '"', I = "(", v = ")", ee = "[", te = "]", V = "{", W = "}", re = "{}", Z = ",", j = "Atrule", F = "Rule", G = "Block", Q = "SelectorList", Y = "Selector", w = "Declaration", B = "Operator";
+function C(y) {
+  return /[A-Z]/.test(y) ? y.toLowerCase() : y;
 }
-function re(_, { minify: P = !1 } = {}) {
-  let O = [], v = h(_, {
+function ne(y, {
+  minify: O = !1,
+  tab_size: T = void 0
+} = /* @__PURE__ */ Object.create(null)) {
+  if (T !== void 0 && Number(T) < 1)
+    throw new TypeError("tab_size must be a number greater than 0");
+  let A = [], R = d(y, {
     positions: !0,
     parseAtrulePrelude: !1,
     parseCustomProperty: !0,
     parseValue: !0,
     onComment: (n, e) => {
-      O.push(e.start.offset, e.end.offset);
+      A.push(e.start.offset, e.end.offset);
     }
   });
-  const u = P ? i : `
-`, C = P ? i : o, Q = P ? i : x;
-  let a = 0;
-  function s(n) {
-    return P ? i : "	".repeat(n);
+  const u = O ? c : `
+`, p = O ? c : a, h = O ? c : x;
+  let s = 0;
+  function i(n) {
+    return O ? c : T ? a.repeat(T * n) : "	".repeat(n);
   }
-  function A(n) {
+  function P(n) {
     let e = n.loc;
-    return e ? _.slice(e.start.offset, e.end.offset) : i;
+    return e ? y.slice(e.start.offset, e.end.offset) : c;
   }
-  function y(n) {
+  function b(n) {
     return /** @type {import('css-tree').CssLocation} */ n.loc.start.offset;
   }
-  function c(n) {
+  function E(n) {
     return /** @type {import('css-tree').CssLocation} */ n.loc.end.offset;
   }
-  function E(n, e) {
-    if (P || n === void 0 || e === void 0)
-      return i;
+  function m(n, e) {
+    if (O || n === void 0 || e === void 0)
+      return c;
     let t = "";
-    for (let r = 0; r < O.length; r += 2) {
-      let l = O[r];
+    for (let r = 0; r < A.length; r += 2) {
+      let l = A[r];
       if (l === void 0 || l < n) continue;
-      let f = O[r + 1];
+      let f = A[r + 1];
       if (f === void 0 || f > e) break;
-      t.length > 0 && (t += u + s(a)), t += _.slice(l, f);
+      t.length > 0 && (t += u + i(s)), t += y.slice(l, f);
     }
     return t;
   }
-  function w(n) {
+  function M(n) {
     let e, t = n.prelude, r = n.block;
-    t.type === G && (e = j(t));
-    let l = E(c(t), y(r));
-    return l && (e += u + s(a) + l), r.type === F && (e += M(r)), e;
+    t.type === Q && (e = q(t));
+    let l = m(E(t), b(r));
+    return l && (e += u + i(s) + l), r.type === G && (e += K(r)), e;
   }
-  function j(n) {
-    let e = i;
+  function q(n) {
+    let e = c;
     return n.children.forEach((t, r) => {
-      t.type === Y && (e += s(a) + S(t)), r.next !== null && (e += W + u);
-      let l = r.next !== null ? y(r.next.data) : c(n), f = E(c(t), l);
-      f && (e += s(a) + f + u);
+      t.type === Y && (e += i(s) + S(t)), r.next !== null && (e += Z + u);
+      let l = r.next !== null ? b(r.next.data) : E(n), f = m(E(t), l);
+      f && (e += i(s) + f + u);
     }), e;
   }
   function S(n) {
-    let e = i;
+    let e = c;
     return (n.children || []).forEach((r) => {
       switch (r.type) {
         case "TypeSelector": {
-          e += b(r.name);
+          e += C(r.name);
           break;
         }
         case "Combinator": {
-          e += o, r.name !== " " && (e += r.name + o);
+          e += a, r.name !== " " && (e += r.name + a);
           break;
         }
         case "PseudoClassSelector":
         case "PseudoElementSelector": {
-          e += N;
-          let l = b(r.name);
-          (l === "before" || l === "after" || r.type === "PseudoElementSelector") && (e += N), e += l, r.children && (e += I + S(r) + g);
+          e += $;
+          let l = C(r.name);
+          (l === "before" || l === "after" || r.type === "PseudoElementSelector") && (e += $), e += l, r.children && (e += I + S(r) + v);
           break;
         }
-        case G: {
+        case Q: {
           r.children.forEach((l, f) => {
-            l.type === Y && (e += S(l)), f.next && f.next.data.type === Y && (e += W + C);
+            l.type === Y && (e += S(l)), f.next && f.next.data.type === Y && (e += Z + p);
           });
           break;
         }
@@ -85,101 +90,104 @@ function re(_, { minify: P = !1 } = {}) {
           let l = r.nth;
           if (l)
             if (l.type === "AnPlusB") {
-              let f = l.a, p = l.b;
-              f !== null && (e += f + "n"), f !== null && p !== null && (e += o), p !== null && (f !== null && !p.startsWith("-") && (e += "+" + o), e += p);
+              let f = l.a, o = l.b;
+              f !== null && (e += f + "n"), f !== null && o !== null && (e += a), o !== null && (f !== null && !o.startsWith("-") && (e += "+" + a), e += o);
             } else
-              e += A(l);
-          r.selector !== null && (e += o + "of" + o + S(r.selector));
+              e += P(l);
+          r.selector !== null && (e += a + "of" + a + S(r.selector));
           break;
         }
         case "AttributeSelector": {
-          e += d, e += r.name.name, r.matcher && r.value && (e += r.matcher, e += L, r.value.type === "String" ? e += r.value.value : r.value.type === "Identifier" && (e += r.value.name), e += L), r.flags && (e += o + r.flags), e += ee;
+          e += ee, e += r.name.name, r.matcher && r.value && (e += r.matcher, e += g, r.value.type === "String" ? e += r.value.value : r.value.type === "Identifier" && (e += r.value.name), e += g), r.flags && (e += a + r.flags), e += te;
           break;
         }
         default: {
-          e += A(r);
+          e += P(r);
           break;
         }
       }
     }), e;
   }
-  function M(n) {
-    let e = n.children, t = C;
+  function K(n) {
+    let e = n.children, t = p;
     if (e.isEmpty) {
-      let f = E(y(n), c(n));
-      return f ? (t += H + u, t += s(a + 1) + f, t += u + s(a) + V, t) : t + te;
+      let f = m(b(n), E(n));
+      return f ? (t += V + u, t += i(s + 1) + f, t += u + i(s) + W, t) : t + re;
     }
-    t += H + u, a++;
-    let r = E(y(n), y(
+    t += V + u, s++;
+    let r = m(b(n), b(
       /** @type {import('css-tree').CssNode} */
       e.first
     ));
-    r && (t += s(a) + r + u), e.forEach((f, p) => {
-      if (p.prev !== null) {
-        let D = E(c(p.prev.data), y(f));
-        D && (t += s(a) + D + u);
+    r && (t += i(s) + r + u), e.forEach((f, o) => {
+      if (o.prev !== null) {
+        let H = m(E(o.prev.data), b(f));
+        H && (t += i(s) + H + u);
       }
-      f.type === B ? (t += J(f), p.next === null ? t += Q : t += x) : (p.prev !== null && p.prev.data.type === B && (t += u), f.type === z ? t += w(f) : f.type === Z ? t += K(f) : t += k(f, a)), p.next !== null && (t += u, f.type !== B && (t += u));
+      f.type === w ? (t += X(f), o.next === null ? t += h : t += x) : (o.prev !== null && o.prev.data.type === w && (t += u), f.type === F ? t += M(f) : f.type === j ? t += U(f) : t += N(f, s)), o.next !== null && (t += u, f.type !== w && (t += u));
     });
-    let l = E(c(
+    let l = m(E(
       /** @type {import('css-tree').CssNode} */
       e.last
-    ), c(n));
-    return l && (t += u + s(a) + l), a--, t += u + s(a) + V, t;
+    ), E(n));
+    return l && (t += u + i(s) + l), s--, t += u + i(s) + W, t;
   }
-  function K(n) {
-    let e = s(a) + "@", t = n.prelude, r = n.block;
-    return e += b(n.name), t !== null && (e += o + q(t)), r === null ? e += x : r.type === F && (e += M(r)), e;
-  }
-  function q(n) {
-    let e = A(n);
-    return e.replace(/\s*([:,])/g, e.toLowerCase().includes("selector(") ? "$1" : "$1 ").replace(/\s*(=>|<=)\s*/g, " $1 ").replace(/\)([a-zA-Z])/g, ") $1").replace(new RegExp("(?<!<=)(?<!=>)(?<!<= )([<>])(?![<= ])(?![=> ])(?![ =>])", "g"), " $1 ").replace(/calc\(([^*]*)\*([^*])/g, "calc($1 * $2").replace(/\s+/g, o).replace(/selector|url|supports|layer\(/ig, (t) => b(t));
+  function U(n) {
+    let e = i(s) + "@", t = n.prelude, r = n.block;
+    return e += C(n.name), t !== null && (e += a + J(t)), r === null ? e += x : r.type === G && (e += K(r)), e;
   }
   function J(n) {
+    let e = P(n);
+    return e.replace(/\s*([:,])/g, e.toLowerCase().includes("selector(") ? "$1" : "$1 ").replace(/\)([a-zA-Z])/g, ") $1").replace(/\s*(=>|<=)\s*/g, " $1 ").replace(/([^<>=\s])([<>])([^<>=\s])/g, `$1${p}$2${p}$3`).replace(/\s+/g, p).replace(/calc\(\s*([^()+\-*/]+)\s*([*/+-])\s*([^()+\-*/]+)\s*\)/g, (t, r, l, f) => {
+      let o = l === "+" || l === "-" ? a : p;
+      return `calc(${r.trim()}${o}${l}${o}${f.trim()})`;
+    }).replace(/selector|url|supports|layer\(/ig, (t) => C(t));
+  }
+  function X(n) {
     let e = n.property;
-    e.charCodeAt(0) === 45 && e.charCodeAt(1) === 45 || (e = b(e));
-    let t = U(n.value);
-    return e === "font" && (t = t.replace(/\s*\/\s*/, "/")), t === i && P && (t += o), n.important === !0 ? t += C + "!important" : typeof n.important == "string" && (t += C + "!" + b(n.important)), s(a) + e + N + C + t;
+    e.charCodeAt(0) === 45 && e.charCodeAt(1) === 45 || (e = C(e));
+    let t = D(n.value);
+    return e === "font" && (t = t.replace(/\s*\/\s*/, "/")), t === c && O && (t += a), n.important === !0 ? t += p + "!important" : typeof n.important == "string" && (t += p + "!" + C(n.important)), i(s) + e + $ + p + t;
   }
-  function R(n) {
-    let e = i;
+  function k(n) {
+    let e = c;
     return n.forEach((t, r) => {
-      t.type === "Identifier" ? e += t.name : t.type === "Function" ? e += b(t.name) + I + R(t.children) + g : t.type === "Dimension" ? e += t.value + b(t.unit) : t.type === "Value" ? e += U(t) : t.type === $ ? e += X(t) : t.type === "Parentheses" ? e += I + R(t.children) + g : t.type === "Url" ? e += "url(" + L + t.value + L + g : e += A(t), t.type !== $ && r.next !== null && r.next.data.type !== $ && (e += o);
+      t.type === "Identifier" ? e += t.name : t.type === "Function" ? e += C(t.name) + I + k(t.children) + v : t.type === "Dimension" ? e += t.value + C(t.unit) : t.type === "Value" ? e += D(t) : t.type === B ? e += z(t) : t.type === "Parentheses" ? e += I + k(t.children) + v : t.type === "Url" ? e += "url(" + g + t.value + g + v : e += P(t), t.type !== B && r.next !== null && r.next.data.type !== B && (e += a);
     }), e;
   }
-  function X(n) {
-    let e = i, t = n.value.trim(), r = t.charCodeAt(0);
-    return r === 43 || r === 45 ? e += o : r !== 44 && (e += C), e += t, r === 43 || r === 45 ? e += o : e += C, e;
+  function z(n) {
+    let e = c, t = n.value.trim(), r = t.charCodeAt(0);
+    return r === 43 || r === 45 ? e += a : r !== 44 && (e += p), e += t, r === 43 || r === 45 ? e += a : e += p, e;
   }
-  function U(n) {
-    return n.type === "Raw" ? k(n, 0) : R(n.children);
-  }
-  function k(n, e) {
-    return s(e) + A(n).trim();
-  }
-  let T = v.children, m = i;
-  if (T.first) {
-    let n = E(0, y(T.first));
-    n && (m += n + u), T.forEach((t, r) => {
-      if (t.type === z ? m += w(t) : t.type === Z ? m += K(t) : m += k(t, a), r.next !== null) {
-        m += u;
-        let l = E(c(t), y(r.next.data));
-        l && (m += s(a) + l), m += u;
+  function D(n) {
+    return n.type === "Raw" ? N(n, 0) : k(n.children);
+  }
+  function N(n, e) {
+    return i(e) + P(n).trim();
+  }
+  let L = R.children, _ = c;
+  if (L.first) {
+    let n = m(0, b(L.first));
+    n && (_ += n + u), L.forEach((t, r) => {
+      if (t.type === F ? _ += M(t) : t.type === j ? _ += U(t) : _ += N(t, s), r.next !== null) {
+        _ += u;
+        let l = m(E(t), b(r.next.data));
+        l && (_ += i(s) + l), _ += u;
       }
     });
-    let e = E(c(
+    let e = m(E(
       /** @type {import('css-tree').CssNode} */
-      T.last
-    ), c(v));
-    e && (m += u + e);
+      L.last
+    ), E(R));
+    e && (_ += u + e);
   } else
-    m += E(0, c(v));
-  return m;
+    _ += m(0, E(R));
+  return _;
 }
-function le(_) {
-  return re(_, { minify: !0 });
+function fe(y) {
+  return ne(y, { minify: !0 });
 }
 export {
-  re as format,
-  le as minify
+  ne as format,
+  fe as minify
 };

package/dist/index.d.ts

@@ -1,13 +1,14 @@
 /**
  * @typedef {Object} Options
  * @property {boolean} [minify] Whether to minify the CSS or keep it formatted
+ * @property {number} [tab_size] Tell the formatter to use N spaces instead of tabs
  *
  * Format a string of CSS using some simple rules
  * @param {string} css The original CSS
  * @param {Options} options
  * @returns {string} The formatted CSS
  */
-export function format(css: string, { minify }?: Options): string;
+export function format(css: string, { minify, tab_size, }?: Options): string;
 /**
  * Minify a string of CSS
  * @param {string} css The original CSS
@@ -17,8 +18,12 @@ export function minify(css: string): string;
 export type Options = {
     /**
      * Whether to minify the CSS or keep it formatted
+     */
+    minify?: boolean | undefined;
+    /**
+     * Tell the formatter to use N spaces instead of tabs
      *
      * Format a string of CSS using some simple rules
      */
-    minify?: boolean | undefined;
+    tab_size?: number | undefined;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@projectwallace/format-css",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Fast, small, zero-config library to format or minify CSS with basic rules.",
   "repository": {
     "type": "git",
@@ -26,16 +26,14 @@
     "prettier": "prettier --check index.js test/**/*.js"
   },
   "devDependencies": {
-    "@codecov/vite-plugin": "^1.4.0",
-    "@codspeed/tinybench-plugin": "^3.1.1",
-    "@types/css-tree": "^2.3.9",
-    "c8": "^10.1.2",
-    "prettier": "^3.3.3",
-    "tinybench": "^2.8.0",
-    "typescript": "^5.6.3",
+    "@codecov/vite-plugin": "^1.9.0",
+    "@types/css-tree": "^2.3.10",
+    "c8": "^10.1.3",
+    "prettier": "^3.5.3",
+    "typescript": "^5.8.3",
     "uvu": "^0.5.6",
-    "vite": "^5.4.11",
-    "vite-plugin-dts": "^4.3.0"
+    "vite": "^6.2.6",
+    "vite-plugin-dts": "^4.5.3"
   },
   "dependencies": {
     "css-tree": "^3.0.1"