@projectwallace/format-css 2.0.1 → 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,25 +1,30 @@
-import h from "css-tree/parser";
-const o = " ", c = "", N = ":", $ = ";", L = '"', x = "(", g = ")", d = "[", ee = "]", H = "{", V = "}", te = "{}", W = ",", Z = "Atrule", z = "Rule", F = "Block", G = "SelectorList", I = "Selector", Y = "Declaration", B = "Operator";
+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(y, { minify: P = !1 } = {}) {
-  let O = [], v = h(y, {
+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 ? c : `
-`, p = P ? c : o, Q = P ? c : $;
+  const u = O ? c : `
+`, p = O ? c : a, h = O ? c : x;
   let s = 0;
-  function a(n) {
-    return P ? c : "	".repeat(n);
+  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 ? y.slice(e.start.offset, e.end.offset) : c;
   }
@@ -30,30 +35,30 @@ function re(y, { minify: P = !1 } = {}) {
     return /** @type {import('css-tree').CssLocation} */ n.loc.end.offset;
   }
   function m(n, e) {
-    if (P || n === void 0 || e === void 0)
+    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 + a(s)), t += y.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));
+    t.type === Q && (e = q(t));
     let l = m(E(t), b(r));
-    return l && (e += u + a(s) + l), r.type === F && (e += M(r)), e;
+    return l && (e += u + i(s) + l), r.type === G && (e += K(r)), e;
   }
-  function j(n) {
+  function q(n) {
     let e = c;
     return n.children.forEach((t, r) => {
-      t.type === I && (e += a(s) + S(t)), r.next !== null && (e += W + 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 += a(s) + f + u);
+      f && (e += i(s) + f + u);
     }), e;
   }
   function S(n) {
@@ -65,19 +70,19 @@ function re(y, { minify: P = !1 } = {}) {
           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;
+          e += $;
           let l = C(r.name);
-          (l === "before" || l === "after" || r.type === "PseudoElementSelector") && (e += N), e += l, r.children && (e += x + S(r) + g);
+          (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 === I && (e += S(l)), f.next && f.next.data.type === I && (e += W + p);
+            l.type === Y && (e += S(l)), f.next && f.next.data.type === Y && (e += Z + p);
           });
           break;
         }
@@ -85,104 +90,104 @@ function re(y, { minify: P = !1 } = {}) {
           let l = r.nth;
           if (l)
             if (l.type === "AnPlusB") {
-              let f = l.a, i = l.b;
-              f !== null && (e += f + "n"), f !== null && i !== null && (e += o), i !== null && (f !== null && !i.startsWith("-") && (e += "+" + o), e += i);
+              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) {
+  function K(n) {
     let e = n.children, t = p;
     if (e.isEmpty) {
       let f = m(b(n), E(n));
-      return f ? (t += H + u, t += a(s + 1) + f, t += u + a(s) + V, t) : t + te;
+      return f ? (t += V + u, t += i(s + 1) + f, t += u + i(s) + W, t) : t + re;
     }
-    t += H + u, s++;
+    t += V + u, s++;
     let r = m(b(n), b(
       /** @type {import('css-tree').CssNode} */
       e.first
     ));
-    r && (t += a(s) + r + u), e.forEach((f, i) => {
-      if (i.prev !== null) {
-        let D = m(E(i.prev.data), b(f));
-        D && (t += a(s) + 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 === Y ? (t += J(f), i.next === null ? t += Q : t += $) : (i.prev !== null && i.prev.data.type === Y && (t += u), f.type === z ? t += w(f) : f.type === Z ? t += K(f) : t += k(f, s)), i.next !== null && (t += u, f.type !== Y && (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 = m(E(
       /** @type {import('css-tree').CssNode} */
       e.last
     ), E(n));
-    return l && (t += u + a(s) + l), s--, t += u + a(s) + V, t;
+    return l && (t += u + i(s) + l), s--, t += u + i(s) + W, t;
   }
-  function K(n) {
-    let e = a(s) + "@", t = n.prelude, r = n.block;
-    return e += C(n.name), t !== null && (e += o + q(t)), r === null ? e += $ : r.type === F && (e += M(r)), e;
+  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 q(n) {
-    let e = A(n);
+  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 i = l === "+" || l === "-" ? o : p;
-      return `calc(${r.trim()}${i}${l}${i}${f.trim()})`;
+      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 J(n) {
+  function X(n) {
     let e = n.property;
     e.charCodeAt(0) === 45 && e.charCodeAt(1) === 45 || (e = C(e));
-    let t = U(n.value);
-    return e === "font" && (t = t.replace(/\s*\/\s*/, "/")), t === c && P && (t += o), n.important === !0 ? t += p + "!important" : typeof n.important == "string" && (t += p + "!" + C(n.important)), a(s) + e + N + p + t;
+    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) {
+  function k(n) {
     let e = c;
     return n.forEach((t, r) => {
-      t.type === "Identifier" ? e += t.name : t.type === "Function" ? e += C(t.name) + x + R(t.children) + g : t.type === "Dimension" ? e += t.value + C(t.unit) : t.type === "Value" ? e += U(t) : t.type === B ? e += X(t) : t.type === "Parentheses" ? e += x + R(t.children) + g : t.type === "Url" ? e += "url(" + L + t.value + L + g : e += A(t), t.type !== B && r.next !== null && r.next.data.type !== B && (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) {
+  function z(n) {
     let e = c, t = n.value.trim(), r = t.charCodeAt(0);
-    return r === 43 || r === 45 ? e += o : r !== 44 && (e += p), e += t, r === 43 || r === 45 ? e += o : e += p, e;
+    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 D(n) {
+    return n.type === "Raw" ? N(n, 0) : k(n.children);
   }
-  function k(n, e) {
-    return a(e) + A(n).trim();
+  function N(n, e) {
+    return i(e) + P(n).trim();
   }
-  let T = v.children, _ = c;
-  if (T.first) {
-    let n = m(0, b(T.first));
-    n && (_ += n + u), T.forEach((t, r) => {
-      if (t.type === z ? _ += w(t) : t.type === Z ? _ += K(t) : _ += k(t, s), r.next !== null) {
+  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 && (_ += a(s) + l), _ += u;
+        l && (_ += i(s) + l), _ += u;
       }
     });
     let e = m(E(
       /** @type {import('css-tree').CssNode} */
-      T.last
-    ), E(v));
+      L.last
+    ), E(R));
     e && (_ += u + e);
   } else
-    _ += m(0, E(v));
+    _ += m(0, E(R));
   return _;
 }
-function le(y) {
-  return re(y, { 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.1",
+  "version": "2.1.0",
   "description": "Fast, small, zero-config library to format or minify CSS with basic rules.",
   "repository": {
     "type": "git",