@projectwallace/css-analyzer 6.0.0 → 7.0.0

package/dist/css-analyzer.js

@@ -0,0 +1,1131 @@
+import Dt from "css-tree/parser";
+import A from "css-tree/walker";
+import { calculateForAST as Ft } from "@bramus/specificity/core";
+function Re(i, t) {
+  return t >= 65 && t <= 90 && (t = t | 32), i === t;
+}
+function z(i, t) {
+  if (i === t) return !0;
+  let r = i.length;
+  if (r !== t.length) return !1;
+  for (let e = 0; e < r; e++)
+    if (Re(i.charCodeAt(e), t.charCodeAt(e)) === !1)
+      return !1;
+  return !0;
+}
+function L(i, t) {
+  if (i === t) return !0;
+  let r = t.length, e = r - i.length;
+  if (e < 0)
+    return !1;
+  for (let n = r - 1; n >= e; n--)
+    if (Re(i.charCodeAt(n - e), t.charCodeAt(n)) === !1)
+      return !1;
+  return !0;
+}
+function Ee(i, t) {
+  if (i === t) return !0;
+  let r = i.length;
+  if (t.length < r) return !1;
+  for (let e = 0; e < r; e++)
+    if (Re(i.charCodeAt(e), t.charCodeAt(e)) === !1)
+      return !1;
+  return !0;
+}
+const Mt = "Atrule", Ut = "MediaQuery", Tt = "MediaFeature", It = "Rule", De = "Selector", zt = "TypeSelector", Y = "PseudoClassSelector", St = "AttributeSelector", vt = "PseudoElementSelector", Oe = "Declaration", Ht = "Value", P = "Identifier", Vt = "Nth", Wt = "Combinator", Kt = "Number", qt = "Dimension", H = "Operator", jt = "Hash", Bt = "Url", Fe = "Function";
+function kt(i, t, r) {
+  let e = i.value.children.first;
+  return z(t, i.property) && e.type === P && z(r, e.name);
+}
+function Yt(i) {
+  let t = !1;
+  return A(i, function(r) {
+    if (r.type === Oe && (kt(r, "-webkit-appearance", "none") || kt(r, "-moz-appearance", "meterbar")))
+      return t = !0, this.break;
+  }), t;
+}
+function Gt(i) {
+  let t = !1;
+  return A(i, function(r) {
+    let e = r.children, n = r.name, l = r.value;
+    if (r.type === Ut && e.size === 1 && e.first.type === P) {
+      let d = e.first.name;
+      if (Ee("\\0", d) || L("\\9 ", d))
+        return t = !0, this.break;
+    } else if (r.type === Tt) {
+      if (l && l.unit && l.unit === "\\0")
+        return t = !0, this.break;
+      if (z("-moz-images-in-menus", n) || z("min--moz-device-pixel-ratio", n) || z("-ms-high-contrast", n))
+        return t = !0, this.break;
+      if (z("min-resolution", n) && l && z(".001", l.value) && z("dpcm", l.unit))
+        return t = !0, this.break;
+      if (z("-webkit-min-device-pixel-ratio", n) && l && l.value && (z("0", l.value) || z("10000", l.value)))
+        return t = !0, this.break;
+    }
+  }), t;
+}
+const xt = 45;
+function R(i) {
+  return i.charCodeAt(0) === xt && i.charCodeAt(1) !== xt && i.indexOf("-", 2) !== -1;
+}
+class q {
+  /** @param {string[]} items */
+  constructor(t) {
+    this.set = new Set(t);
+  }
+  /** @param {string} item */
+  has(t) {
+    return this.set.has(t.toLowerCase());
+  }
+}
+function At(i, t) {
+  let r = [];
+  return A(i, {
+    visit: De,
+    enter: function(e) {
+      r.push(t(e));
+    }
+  }), r;
+}
+const Pt = new q([
+  "nth-child",
+  "where",
+  "not",
+  "is",
+  "has",
+  "nth-last-child",
+  "matches",
+  "-webkit-any",
+  "-moz-any"
+]);
+function Lt(i) {
+  let t = !1;
+  return A(i, function(r) {
+    if (r.type === St) {
+      let e = r.name.name;
+      if (z("role", e) || Ee("aria-", e))
+        return t = !0, this.break;
+    } else if (r.type === Y && Pt.has(r.name)) {
+      let e = At(r, Lt);
+      for (let n of e)
+        if (n === !0) {
+          t = !0;
+          break;
+        }
+      return this.skip;
+    }
+  }), t;
+}
+function Qt(i) {
+  let t = !1;
+  return A(i, function(r) {
+    let e = r.type;
+    if ((e === vt || e === zt || e === Y) && R(r.name))
+      return t = !0, this.break;
+  }), t;
+}
+function Zt(i) {
+  let t = [];
+  return A(i, function(r) {
+    r.type === Y && t.push(r.name);
+  }), t.length === 0 ? !1 : t;
+}
+function Ot(i) {
+  let t = 0;
+  return A(i, function(r) {
+    let e = r.type;
+    if (!(e === De || e === Vt)) {
+      if (t++, (e === vt || e === zt || e === Y) && R(r.name) && t++, e === St)
+        return r.value && t++, this.skip;
+      if (e === Y && Pt.has(r.name)) {
+        let n = At(r, Ot);
+        if (n.length === 0) return;
+        for (let l of n)
+          t += l;
+        return this.skip;
+      }
+    }
+  }), t;
+}
+function Jt(i, t) {
+  A(i, function(r, e) {
+    if (r.type === Wt) {
+      let n = r.loc, l = r.name;
+      if (n === null) {
+        let d = e.prev.data.loc.end, m = {
+          offset: d.offset,
+          line: d.line,
+          column: d.column
+        };
+        t({
+          name: l,
+          loc: {
+            start: m,
+            end: {
+              offset: m.offset + 1,
+              line: m.line,
+              column: m.column + 1
+            }
+          }
+        });
+      } else
+        t({
+          name: l,
+          loc: n
+        });
+    }
+  });
+}
+const Xt = new q([
+  // CSS Named Colors
+  // Spec: https://drafts.csswg.org/css-color/#named-colors
+  // Heuristic: popular names first for quick finding in set.has()
+  // See: https://docs.google.com/spreadsheets/d/1OU8ahxC5oYU8VRryQs9BzHToaXcOntVlh6KUHjm15G4/edit#gid=2096495459
+  "white",
+  "black",
+  "red",
+  "gray",
+  "silver",
+  "grey",
+  "green",
+  "orange",
+  "blue",
+  "dimgray",
+  "whitesmoke",
+  "lightgray",
+  "lightgrey",
+  "yellow",
+  "gold",
+  "pink",
+  "gainsboro",
+  "magenta",
+  "purple",
+  "darkgray",
+  "navy",
+  "darkred",
+  "teal",
+  "maroon",
+  "darkgrey",
+  "tomato",
+  "darkorange",
+  "brown",
+  "crimson",
+  "lightyellow",
+  "slategray",
+  "salmon",
+  "lightgreen",
+  "lightblue",
+  "orangered",
+  "aliceblue",
+  "dodgerblue",
+  "lime",
+  "darkblue",
+  "darkgoldenrod",
+  "skyblue",
+  "royalblue",
+  "darkgreen",
+  "ivory",
+  "olive",
+  "aqua",
+  "turquoise",
+  "cyan",
+  "khaki",
+  "beige",
+  "snow",
+  "ghostwhite",
+  "limegreen",
+  "coral",
+  "dimgrey",
+  "hotpink",
+  "midnightblue",
+  "firebrick",
+  "indigo",
+  "wheat",
+  "mediumblue",
+  "lightpink",
+  "plum",
+  "azure",
+  "violet",
+  "lavender",
+  "deepskyblue",
+  "darkslategrey",
+  "goldenrod",
+  "cornflowerblue",
+  "lightskyblue",
+  "indianred",
+  "yellowgreen",
+  "saddlebrown",
+  "palegreen",
+  "bisque",
+  "tan",
+  "antiquewhite",
+  "steelblue",
+  "forestgreen",
+  "fuchsia",
+  "mediumaquamarine",
+  "seagreen",
+  "sienna",
+  "deeppink",
+  "mediumseagreen",
+  "peru",
+  "greenyellow",
+  "lightgoldenrodyellow",
+  "orchid",
+  "cadetblue",
+  "navajowhite",
+  "lightsteelblue",
+  "slategrey",
+  "linen",
+  "lightseagreen",
+  "darkcyan",
+  "lightcoral",
+  "aquamarine",
+  "blueviolet",
+  "cornsilk",
+  "lightsalmon",
+  "chocolate",
+  "lightslategray",
+  "floralwhite",
+  "darkturquoise",
+  "darkslategray",
+  "rebeccapurple",
+  "burlywood",
+  "chartreuse",
+  "lightcyan",
+  "lemonchiffon",
+  "palevioletred",
+  "darkslateblue",
+  "mediumpurple",
+  "lawngreen",
+  "slateblue",
+  "darkseagreen",
+  "blanchedalmond",
+  "mistyrose",
+  "darkolivegreen",
+  "seashell",
+  "olivedrab",
+  "peachpuff",
+  "darkviolet",
+  "powderblue",
+  "darkmagenta",
+  "lightslategrey",
+  "honeydew",
+  "palegoldenrod",
+  "darkkhaki",
+  "oldlace",
+  "mintcream",
+  "sandybrown",
+  "mediumturquoise",
+  "papayawhip",
+  "paleturquoise",
+  "mediumvioletred",
+  "thistle",
+  "springgreen",
+  "moccasin",
+  "rosybrown",
+  "lavenderblush",
+  "mediumslateblue",
+  "darkorchid",
+  "mediumorchid",
+  "darksalmon",
+  "mediumspringgreen"
+]), $t = new q([
+  // CSS System Colors
+  // Spec: https://drafts.csswg.org/css-color/#css-system-colors
+  "accentcolor",
+  "accentcolortext",
+  "activetext",
+  "buttonborder",
+  "buttonface",
+  "buttontext",
+  "canvas",
+  "canvastext",
+  "field",
+  "fieldtext",
+  "graytext",
+  "highlight",
+  "highlighttext",
+  "linktext",
+  "mark",
+  "marktext",
+  "selecteditem",
+  "selecteditemtext",
+  "visitedtext"
+]), Nt = new q([
+  "rgba",
+  "rgb",
+  "hsla",
+  "hsl",
+  "oklch",
+  "color",
+  "hwb",
+  "lch",
+  "lab",
+  "oklab"
+]), ei = new q([
+  "transparent",
+  "currentcolor"
+]), N = new q([
+  "auto",
+  "none",
+  // for `text-shadow`, `box-shadow` and `background`
+  "inherit",
+  "initial",
+  "unset",
+  "revert",
+  "revert-layer"
+]);
+function $(i) {
+  let t = i.children, r = t.size;
+  if (!t || r > 1 || r === 0) return !1;
+  let e = t.first;
+  return e.type === P && N.has(e.name);
+}
+const ti = new q([
+  "caption",
+  "icon",
+  "menu",
+  "message-box",
+  "small-caption",
+  "status-bar"
+]), ii = new q([
+  /* <absolute-size> values */
+  "xx-small",
+  "x-small",
+  "small",
+  "medium",
+  "large",
+  "x-large",
+  "xx-large",
+  "xxx-large",
+  /* <relative-size> values */
+  "smaller",
+  "larger"
+]), ri = 44, Ct = 47;
+function Pe(i) {
+  let t = i.children.first;
+  return t === null ? !1 : t.type === P && ti.has(t.name);
+}
+function si(i, t, r) {
+  let e = Array.from({ length: 2 }), n, l;
+  i.children.forEach(function(m, b) {
+    let C = b.prev ? b.prev.data : void 0, y = b.next ? b.next.data : void 0;
+    if (m.type === P && N.has(m.name) && r({
+      type: "keyword",
+      value: m.name
+    }), y && y.type === H && y.value.charCodeAt(0) === Ct) {
+      n = t(m);
+      return;
+    }
+    if (C && C.type === H && C.value.charCodeAt(0) === Ct) {
+      l = t(m);
+      return;
+    }
+    if (y && y.type === H && y.value.charCodeAt(0) === ri && !e[0]) {
+      e[0] = m, !n && C && (n = t(C));
+      return;
+    }
+    if (m.type !== Kt) {
+      if (b.next === null) {
+        e[1] = m, !n && !e[0] && C && (n = t(C));
+        return;
+      }
+      if (m.type === P) {
+        let M = m.name;
+        if (ii.has(M)) {
+          n = M;
+          return;
+        }
+      }
+    }
+  });
+  let d = e[0] || e[1] ? t({
+    loc: {
+      start: {
+        offset: (e[0] || e[1]).loc.start.offset
+      },
+      end: {
+        offset: e[1].loc.end.offset
+      }
+    }
+  }) : null;
+  return {
+    font_size: n,
+    line_height: l,
+    font_family: d
+  };
+}
+const li = new q([
+  "linear",
+  "ease",
+  "ease-in",
+  "ease-out",
+  "ease-in-out",
+  "step-start",
+  "step-end"
+]), ni = new q([
+  "cubic-bezier",
+  "steps"
+]);
+function ai(i, t) {
+  let r = !1;
+  for (let e of i) {
+    let n = e.type, l = e.name;
+    n === H ? r = !1 : n === qt && r === !1 ? (r = !0, t({
+      type: "duration",
+      value: e
+    })) : n === P ? li.has(l) ? t({
+      type: "fn",
+      value: e
+    }) : N.has(l) && t({
+      type: "keyword",
+      value: e
+    }) : n === Fe && ni.has(l) && t({
+      type: "fn",
+      value: e
+    });
+  }
+}
+function Rt(i) {
+  let t = i.children;
+  if (!t)
+    return !1;
+  for (let r of t) {
+    let { type: e, name: n } = r;
+    if (e === P && R(n) || e === Fe && (R(n) || Rt(r)))
+      return !0;
+  }
+  return !1;
+}
+class o {
+  /** @param {boolean} useLocations */
+  constructor(t = !1) {
+    this._items = /* @__PURE__ */ new Map(), this._total = 0, t && (this._nodes = []), this._useLocations = t;
+  }
+  /**
+   * @param {string | number} item
+   * @param {import('css-tree').CssLocation} node_location
+   */
+  p(t, r) {
+    let e = this._total;
+    if (this._useLocations) {
+      let n = r.start, l = n.offset, d = e * 4;
+      this._nodes[d] = n.line, this._nodes[d + 1] = n.column, this._nodes[d + 2] = l, this._nodes[d + 3] = r.end.offset - l;
+    }
+    if (this._items.has(t)) {
+      this._items.get(t).push(e), this._total++;
+      return;
+    }
+    this._items.set(t, [e]), this._total++;
+  }
+  size() {
+    return this._total;
+  }
+  /**
+   * @typedef CssLocation
+   * @property {number} line
+   * @property {number} column
+   * @property {number} offset
+   * @property {number} length
+   *
+   * @returns {{
+   * 	total: number;
+   * 	totalUnique: number;
+   * 	uniquenessRatio: number;
+   * 	unique: Record<string, number>;
+   * } & ({
+   * 	uniqueWithLocations: Record<string, CssLocation[]>
+   * } | {
+   * 	uniqueWithLocations?: undefined
+   * })}
+   */
+  c() {
+    let t = /* @__PURE__ */ new Map(), r = {}, e = this._useLocations, n = this._items, l = this._nodes, d = n.size;
+    n.forEach((C, y) => {
+      if (e) {
+        let M = C.map(function(V) {
+          let E = V * 4;
+          return {
+            line: l[E],
+            column: l[E + 1],
+            offset: l[E + 2],
+            length: l[E + 3]
+          };
+        });
+        t.set(y, M);
+      } else
+        r[y] = C.length;
+    });
+    let m = this._total, b = {
+      total: m,
+      totalUnique: d,
+      unique: r,
+      uniquenessRatio: m === 0 ? 0 : d / m
+    };
+    return e && (b.uniqueWithLocations = Object.fromEntries(t)), b;
+  }
+}
+class Le {
+  /** @param {boolean} useLocations */
+  constructor(t) {
+    this._list = new o(t), this._contexts = /* @__PURE__ */ new Map(), this._useLocations = t;
+  }
+  /**
+   * Add an item to this _list's context
+   * @param {string} item Item to push
+   * @param {string} context Context to push Item to
+   * @param {import('css-tree').CssLocation} node_location
+   */
+  push(t, r, e) {
+    this._list.p(t, e), this._contexts.has(r) || this._contexts.set(r, new o(this._useLocations)), this._contexts.get(r).p(t, e);
+  }
+  count() {
+    let t = /* @__PURE__ */ new Map();
+    for (let [r, e] of this._contexts.entries())
+      t.set(r, e.c());
+    return Object.assign(this._list.c(), {
+      itemsPerContext: Object.fromEntries(t)
+    });
+  }
+}
+function oi(i) {
+  let t = /* @__PURE__ */ new Map(), r = -1, e = 0, n = 0, l = i.length;
+  for (let d = 0; d < l; d++) {
+    let m = i[d], b = (t.get(m) || 0) + 1;
+    t.set(m, b), b > r && (r = b, e = 0, n = 0), b >= r && (e++, n += m);
+  }
+  return n / e;
+}
+class v {
+  constructor() {
+    this._items = [], this._sum = 0;
+  }
+  /**
+   * Add a new Integer at the end of this AggregateCollection
+   * @param {number} item - The item to add
+   */
+  push(t) {
+    this._items.push(t), this._sum += t;
+  }
+  size() {
+    return this._items.length;
+  }
+  aggregate() {
+    let t = this._items.length;
+    if (t === 0)
+      return {
+        min: 0,
+        max: 0,
+        mean: 0,
+        mode: 0,
+        range: 0,
+        sum: 0
+      };
+    let r = this._items.slice().sort((m, b) => m - b), e = r[0], n = r[t - 1], l = oi(r), d = this._sum;
+    return {
+      min: e,
+      max: n,
+      mean: d / t,
+      mode: l,
+      range: n - e,
+      sum: d
+    };
+  }
+  /**
+   * @returns {number[]} All _items in this collection
+   */
+  toArray() {
+    return this._items;
+  }
+}
+function ui(i) {
+  if (Me(i) || R(i)) return !1;
+  let t = i.charCodeAt(0);
+  return t === 47 || t === 42 || t === 95 || t === 43 || t === 38 || t === 36 || t === 35;
+}
+function Me(i) {
+  return i.length < 3 ? !1 : i.charCodeAt(0) === 45 && i.charCodeAt(1) === 45;
+}
+function _(i, t) {
+  return Me(t) ? !1 : L(i, t);
+}
+function ci(i) {
+  return R(i) ? i.slice(i.indexOf("-", 2) + 1) : i;
+}
+function fi(i) {
+  let t = 5, r = i.indexOf(";"), e = i.indexOf(",");
+  return r === -1 || e !== -1 && e < r ? i.substring(t, e) : i.substring(t, r);
+}
+function pi(i) {
+  let t = i.children;
+  if (t) {
+    let r = t.last;
+    return r && r.type === P && L("\\9", r.name);
+  }
+  return !1;
+}
+let hi = new q([
+  "border-radius",
+  "border-top-left-radius",
+  "border-top-right-radius",
+  "border-bottom-right-radius",
+  "border-bottom-left-radius",
+  "border-start-start-radius",
+  "border-start-end-radius",
+  "border-end-end-radius",
+  "border-end-start-radius"
+]);
+function x(i, t) {
+  return t === 0 ? 0 : i / t;
+}
+let mi = {
+  useLocations: !1
+};
+function wi(i, t = {}) {
+  let e = Object.assign({}, mi, t).useLocations === !0, n = Date.now();
+  function l(s) {
+    return d(s).trim();
+  }
+  function d(s) {
+    let f = s.loc;
+    return i.substring(f.start.offset, f.end.offset);
+  }
+  let m = 0, b = 0, C = 0, y = {
+    total: 0,
+    /** @type {Map<string, { size: number, count: number } & ({ uniqueWithLocations?: undefined } | ({ uniqueWithLocations: { offset: number, line: number, column: number, length: number }[] })) }>} */
+    unique: /* @__PURE__ */ new Map()
+  }, M = Date.now(), V = Dt(i, {
+    parseCustomProperty: !0,
+    // To find font-families, colors, etc.
+    positions: !0,
+    // So we can use stringifyNode()
+    /** @param {string} comment */
+    onComment: function(s) {
+      m++, b += s.length;
+    }
+  }), E = Date.now(), Et = V.loc.end.line - V.loc.start.line + 1, ee = 0, te = new v(), ie = [], Ue = new o(e), re = new o(e), Te = new o(e), Ie = new o(e), He = new o(e), Ve = new o(e), We = new o(e), Ke = new o(e), se = new o(e), le = new o(e), je = new o(e), Be = new o(e), ne = 0, ae = 0, oe = new v(), ue = new v(), ce = new v(), Ye = new o(e), Ge = new o(e), Qe = new o(e), fe = new o(e), Ze = /* @__PURE__ */ new Set(), pe = new o(e), D, F, Je = new v(), Xe = new v(), $e = new v(), Ne = new o(e), G = new v(), et = new o(e), tt = [], he = new o(e), me = new o(e), it = new o(e), rt = new o(e), st = /* @__PURE__ */ new Set(), W = 0, lt = new v(), Q = 0, de = 0, ge = new o(e), K = new o(e), ye = new o(e), we = new o(e), Z = new o(e), j = new v(), be = new v(), nt = new o(e), ke = new o(e), at = new o(e), ot = new o(e), ut = new o(e), xe = new o(e), Ce = new o(e), _e = new o(e), J = new o(e), X = new o(e), U = new Le(e), T = new o(e), ze = new Le(e), ct = new o(e), B = new o(e), ft = new Le(e);
+  A(V, function(s) {
+    switch (s.type) {
+      case Mt: {
+        ee++;
+        let f = s.name;
+        if (f === "font-face") {
+          let g = {};
+          e && Ue.p(s.loc.start.offset, s.loc), s.block.children.forEach((u) => {
+            u.type === Oe && (g[u.property] = l(u.value));
+          }), ie.push(g), te.push(1);
+          break;
+        }
+        let a = 1;
+        if (s.prelude !== null) {
+          let g = s.prelude, u = g && l(s.prelude), p = g.loc;
+          if (f === "media")
+            Ie.p(u, p), Gt(g) && (He.p(u, p), a++);
+          else if (f === "supports")
+            We.p(u, p), Yt(g) && (Ke.p(u, p), a++);
+          else if (L("keyframes", f)) {
+            let c = "@" + f + " " + u;
+            R(f) && (le.p(c, p), a++), se.p(c, p);
+          } else f === "import" ? Te.p(u, p) : f === "charset" ? Ve.p(u, p) : f === "container" ? je.p(u, p) : f === "layer" ? u.split(",").forEach((c) => re.p(c.trim(), p)) : f === "property" && Be.p(u, p);
+        } else
+          f === "layer" && (re.p("<anonymous>", s.loc), a++);
+        te.push(a);
+        break;
+      }
+      case It: {
+        let f = s.prelude, a = s.block, g = f.children, u = a.children, p = g ? g.size : 0, c = u ? u.size : 0;
+        oe.push(p + c), Ye.p(p + c, s.loc), ue.push(p), Ge.p(p, f.loc), ce.push(c), Qe.p(c, a.loc), ne++, c === 0 && ae++;
+        break;
+      }
+      case De: {
+        let f = l(s);
+        if (this.atrule && L("keyframes", this.atrule.name))
+          return fe.p(f, s.loc), this.skip;
+        Lt(s) && me.p(f, s.loc);
+        let a = Zt(s);
+        if (a !== !1)
+          for (let k of a)
+            it.p(k, s.loc);
+        let g = Ot(s);
+        Qt(s) && pe.p(f, s.loc), Ze.add(f), G.push(g), et.p(g, s.loc);
+        let u = Ft(s).toArray(), [p, c, h] = u;
+        return Ne.p(u.toString(), s.loc), Je.push(p), Xe.push(c), $e.push(h), D === void 0 && (D = u), F === void 0 && (F = u), F !== void 0 && _t(F, u) < 0 && (F = u), D !== void 0 && _t(D, u) > 0 && (D = u), tt.push(u), p > 0 && he.p(f, s.loc), Jt(s, function(S) {
+          rt.p(S.name, S.loc);
+        }), this.skip;
+      }
+      case qt: {
+        if (!this.declaration)
+          break;
+        let f = s.unit;
+        return L("\\9", f) ? ze.push(f.substring(0, f.length - 2), this.declaration.property, s.loc) : ze.push(f, this.declaration.property, s.loc), this.skip;
+      }
+      case Bt: {
+        if (Ee("data:", s.value)) {
+          let f = s.value, a = f.length, g = fi(f);
+          y.total++, C += a;
+          let u = {
+            /** @type {number} */
+            line: s.loc.start.line,
+            /** @type {number} */
+            column: s.loc.start.column,
+            /** @type {number} */
+            offset: s.loc.start.offset,
+            /** @type {number} */
+            length: s.loc.end.offset - s.loc.start.offset
+          };
+          if (y.unique.has(g)) {
+            let p = y.unique.get(g);
+            p.count++, p.size += a, y.unique.set(g, p), e && p.uniqueWithLocations.push(u);
+          } else {
+            let p = {
+              count: 1,
+              size: a
+            };
+            e && (p.uniqueWithLocations = [u]), y.unique.set(g, p);
+          }
+        }
+        break;
+      }
+      case Ht: {
+        if ($(s)) {
+          be.push(1), B.p(l(s), s.loc);
+          break;
+        }
+        let f = this.declaration, { property: a, important: g } = f, u = 1;
+        Rt(s) && (nt.p(l(s), s.loc), u++), typeof g == "string" && (ke.p(d(s) + "!" + g, s.loc), u++), pi(s) && (ke.p(l(s), s.loc), u++);
+        let p = s.children, c = s.loc;
+        if (be.push(u), _("z-index", a))
+          return at.p(l(s), c), this.skip;
+        if (_("font", a)) {
+          if (Pe(s)) return;
+          let { font_size: h, line_height: k, font_family: S } = si(s, l, function(O) {
+            O.type === "keyword" && B.p(O.value, c);
+          });
+          S && xe.p(S, c), h && Ce.p(h, c), k && _e.p(k, c);
+          break;
+        } else if (_("font-size", a)) {
+          Pe(s) || Ce.p(l(s), c);
+          break;
+        } else if (_("font-family", a)) {
+          Pe(s) || xe.p(l(s), c);
+          break;
+        } else if (_("line-height", a))
+          _e.p(l(s), c);
+        else if (_("transition", a) || _("animation", a)) {
+          ai(p, function(h) {
+            h.type === "fn" ? J.p(l(h.value), c) : h.type === "duration" ? X.p(l(h.value), c) : h.type === "keyword" && B.p(l(h.value), c);
+          });
+          break;
+        } else if (_("animation-duration", a) || _("transition-duration", a)) {
+          p && p.size > 1 ? p.forEach((h) => {
+            h.type !== H && X.p(l(h), c);
+          }) : X.p(l(s), c);
+          break;
+        } else if (_("transition-timing-function", a) || _("animation-timing-function", a)) {
+          p && p.size > 1 ? p.forEach((h) => {
+            h.type !== H && J.p(l(h), c);
+          }) : J.p(l(s), c);
+          break;
+        } else if (hi.has(ci(a))) {
+          $(s) || ft.push(l(s), a, c);
+          break;
+        } else _("text-shadow", a) ? $(s) || ot.p(l(s), c) : _("box-shadow", a) && ($(s) || ut.p(l(s), c));
+        A(s, function(h) {
+          let k = h.name;
+          switch (h.type) {
+            case jt: {
+              let S = h.value.length;
+              return L("\\9", h.value) && (S = S - 2), U.push("#" + h.value, a, c), T.p("hex" + S, c), this.skip;
+            }
+            case P: {
+              N.has(k) && B.p(k, c);
+              let S = k.length;
+              if (S > 20 || S < 3)
+                return this.skip;
+              if (ei.has(k)) {
+                let O = l(h);
+                U.push(O, a, c), T.p(k.toLowerCase(), c);
+                return;
+              }
+              if (Xt.has(k)) {
+                let O = l(h);
+                U.push(O, a, c), T.p("named", c);
+                return;
+              }
+              if ($t.has(k)) {
+                let O = l(h);
+                U.push(O, a, c), T.p("system", c);
+                return;
+              }
+              return this.skip;
+            }
+            case Fe: {
+              if (z("var", k))
+                return this.skip;
+              if (Nt.has(k)) {
+                U.push(l(h), a, h.loc), T.p(k.toLowerCase(), h.loc);
+                return;
+              }
+              if (L("gradient", k)) {
+                ct.p(l(h), h.loc);
+                return;
+              }
+            }
+          }
+        });
+        break;
+      }
+      case Oe: {
+        if (this.atrulePrelude !== null)
+          return this.skip;
+        W++;
+        let f = 1;
+        st.add(l(s)), s.important === !0 && (Q++, f++, this.atrule && L("keyframes", this.atrule.name) && (de++, f++)), lt.push(f);
+        let { property: a, loc: { start: g } } = s, u = {
+          start: {
+            line: g.line,
+            column: g.column,
+            offset: g.offset
+          },
+          end: {
+            offset: g.offset + a.length
+          }
+        };
+        K.p(a, u), R(a) ? (we.p(a, u), j.push(2)) : ui(a) ? (ye.p(a, u), j.push(2)) : Me(a) ? (Z.p(a, u), j.push(s.important ? 3 : 2), s.important === !0 && ge.p(a, u)) : j.push(1);
+        break;
+      }
+    }
+  });
+  let pt = st.size, I = G.size(), Se = Je.aggregate(), ve = Xe.aggregate(), qe = $e.aggregate(), ht = Ze.size, w = Object.assign, mt = i.length, Ae = ie.length, dt = te.aggregate(), gt = G.aggregate(), yt = lt.aggregate(), wt = j.aggregate(), bt = be.aggregate();
+  return {
+    stylesheet: {
+      sourceLinesOfCode: ee + I + W + fe.size(),
+      linesOfCode: Et,
+      size: mt,
+      complexity: dt.sum + gt.sum + yt.sum + wt.sum + bt.sum,
+      comments: {
+        total: m,
+        size: b
+      },
+      embeddedContent: {
+        size: {
+          total: C,
+          ratio: x(C, mt)
+        },
+        types: {
+          total: y.total,
+          totalUnique: y.unique.size,
+          uniquenessRatio: x(y.unique.size, y.total),
+          unique: Object.fromEntries(y.unique)
+        }
+      }
+    },
+    atrules: {
+      fontface: w({
+        total: Ae,
+        totalUnique: Ae,
+        unique: ie,
+        uniquenessRatio: Ae === 0 ? 0 : 1
+      }, e ? {
+        uniqueWithLocations: Ue.c().uniqueWithLocations
+      } : {}),
+      import: Te.c(),
+      media: w(
+        Ie.c(),
+        {
+          browserhacks: He.c()
+        }
+      ),
+      charset: Ve.c(),
+      supports: w(
+        We.c(),
+        {
+          browserhacks: Ke.c()
+        }
+      ),
+      keyframes: w(
+        se.c(),
+        {
+          prefixed: w(
+            le.c(),
+            {
+              ratio: x(le.size(), se.size())
+            }
+          )
+        }
+      ),
+      container: je.c(),
+      layer: re.c(),
+      property: Be.c(),
+      total: ee,
+      complexity: dt
+    },
+    rules: {
+      total: ne,
+      empty: {
+        total: ae,
+        ratio: x(ae, ne)
+      },
+      sizes: w(
+        oe.aggregate(),
+        {
+          items: oe.toArray()
+        },
+        Ye.c()
+      ),
+      selectors: w(
+        ue.aggregate(),
+        {
+          items: ue.toArray()
+        },
+        Ge.c()
+      ),
+      declarations: w(
+        ce.aggregate(),
+        {
+          items: ce.toArray()
+        },
+        Qe.c()
+      )
+    },
+    selectors: {
+      total: I,
+      totalUnique: ht,
+      uniquenessRatio: x(ht, I),
+      specificity: w(
+        {
+          /** @type Specificity */
+          min: F === void 0 ? [0, 0, 0] : F,
+          /** @type Specificity */
+          max: D === void 0 ? [0, 0, 0] : D,
+          /** @type Specificity */
+          sum: [Se.sum, ve.sum, qe.sum],
+          /** @type Specificity */
+          mean: [Se.mean, ve.mean, qe.mean],
+          /** @type Specificity */
+          mode: [Se.mode, ve.mode, qe.mode],
+          /** @type Specificity */
+          items: tt
+        },
+        Ne.c()
+      ),
+      complexity: w(
+        gt,
+        et.c(),
+        {
+          items: G.toArray()
+        }
+      ),
+      id: w(
+        he.c(),
+        {
+          ratio: x(he.size(), I)
+        }
+      ),
+      pseudoClasses: it.c(),
+      accessibility: w(
+        me.c(),
+        {
+          ratio: x(me.size(), I)
+        }
+      ),
+      keyframes: fe.c(),
+      prefixed: w(
+        pe.c(),
+        {
+          ratio: x(pe.size(), I)
+        }
+      ),
+      combinators: rt.c()
+    },
+    declarations: {
+      total: W,
+      totalUnique: pt,
+      uniquenessRatio: x(pt, W),
+      importants: {
+        total: Q,
+        ratio: x(Q, W),
+        inKeyframes: {
+          total: de,
+          ratio: x(de, Q)
+        }
+      },
+      complexity: yt
+    },
+    properties: w(
+      K.c(),
+      {
+        prefixed: w(
+          we.c(),
+          {
+            ratio: x(we.size(), K.size())
+          }
+        ),
+        custom: w(
+          Z.c(),
+          {
+            ratio: x(Z.size(), K.size()),
+            importants: w(
+              ge.c(),
+              {
+                ratio: x(ge.size(), Z.size())
+              }
+            )
+          }
+        ),
+        browserhacks: w(
+          ye.c(),
+          {
+            ratio: x(ye.size(), K.size())
+          }
+        ),
+        complexity: wt
+      }
+    ),
+    values: {
+      colors: w(
+        U.count(),
+        {
+          formats: T.c()
+        }
+      ),
+      gradients: ct.c(),
+      fontFamilies: xe.c(),
+      fontSizes: Ce.c(),
+      lineHeights: _e.c(),
+      zindexes: at.c(),
+      textShadows: ot.c(),
+      boxShadows: ut.c(),
+      borderRadiuses: ft.count(),
+      animations: {
+        durations: X.c(),
+        timingFunctions: J.c()
+      },
+      prefixes: nt.c(),
+      browserhacks: ke.c(),
+      units: ze.count(),
+      complexity: bt,
+      keywords: B.c()
+    },
+    __meta__: {
+      parseTime: E - M,
+      analyzeTime: Date.now() - E,
+      total: Date.now() - n
+    }
+  };
+}
+function _t(i, t) {
+  return i[0] === t[0] ? i[1] === t[1] ? t[2] - i[2] : t[1] - i[1] : t[0] - i[0];
+}
+export {
+  wi as analyze,
+  _t as compareSpecificity,
+  R as hasVendorPrefix,
+  Lt as isAccessibilitySelector,
+  Gt as isMediaBrowserhack,
+  ui as isPropertyHack,
+  Qt as isSelectorPrefixed,
+  Yt as isSupportsBrowserhack,
+  Rt as isValuePrefixed,
+  Ot as selectorComplexity
+};