@stacksjs/ts-css 0.1.0

package/dist/optimize/index.js

@@ -0,0 +1,3390 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __require = import.meta.require;
+
+// src/parse/index.ts
+var exports_parse = {};
+__export(exports_parse, {
+  walk: () => walk,
+  parse: () => parse,
+  makeList: () => makeList,
+  generate: () => generate,
+  decodeName: () => decodeName,
+  clone: () => clone,
+  Tokenizer: () => Tokenizer,
+  TokenType: () => TokenType,
+  List: () => CssList
+});
+
+// src/parse/list.ts
+function createItem(data) {
+  return { prev: null, next: null, data };
+}
+
+class CssList {
+  head = null;
+  tail = null;
+  cursors = [];
+  allocateCursor(prev, next) {
+    const cursor = { prev, next };
+    this.cursors.push(cursor);
+    return cursor;
+  }
+  releaseCursor() {
+    this.cursors.pop();
+  }
+  updateCursors(prevOld, prevNew, nextOld, nextNew) {
+    for (const c of this.cursors) {
+      if (c.prev === prevOld)
+        c.prev = prevNew;
+      if (c.next === nextOld)
+        c.next = nextNew;
+    }
+  }
+  static createItem(data) {
+    return createItem(data);
+  }
+  createItem(data) {
+    return createItem(data);
+  }
+  get isEmpty() {
+    return this.head === null;
+  }
+  get first() {
+    return this.head?.data ?? null;
+  }
+  get last() {
+    return this.tail?.data ?? null;
+  }
+  *[Symbol.iterator]() {
+    for (let cur = this.head;cur != null; cur = cur.next)
+      yield cur.data;
+  }
+  fromArray(items) {
+    let prev = null;
+    this.head = null;
+    for (const data of items) {
+      const item = createItem(data);
+      item.prev = prev;
+      if (prev)
+        prev.next = item;
+      else
+        this.head = item;
+      prev = item;
+    }
+    this.tail = prev;
+    return this;
+  }
+  toArray() {
+    const out = [];
+    for (let cur = this.head;cur != null; cur = cur.next)
+      out.push(cur.data);
+    return out;
+  }
+  toJSON() {
+    return this.toArray();
+  }
+  forEach(fn, thisArg) {
+    const cursor = this.allocateCursor(null, this.head);
+    while (cursor.next !== null) {
+      const item = cursor.next;
+      cursor.prev = item;
+      cursor.next = item.next;
+      fn.call(thisArg, item.data, item, this);
+    }
+    this.releaseCursor();
+  }
+  forEachRight(fn, thisArg) {
+    const cursor = this.allocateCursor(this.tail, null);
+    while (cursor.prev !== null) {
+      const item = cursor.prev;
+      cursor.next = item;
+      cursor.prev = item.prev;
+      fn.call(thisArg, item.data, item, this);
+    }
+    this.releaseCursor();
+  }
+  reduce(fn, initial) {
+    let acc = initial;
+    let i = 0;
+    for (let cur = this.head;cur != null; cur = cur.next)
+      acc = fn(acc, cur.data, i++, this);
+    return acc;
+  }
+  some(fn) {
+    let i = 0;
+    for (let cur = this.head;cur != null; cur = cur.next) {
+      if (fn(cur.data, i++, this))
+        return true;
+    }
+    return false;
+  }
+  map(fn) {
+    const result = new CssList;
+    let prev = null;
+    let i = 0;
+    for (let cur = this.head;cur != null; cur = cur.next) {
+      const item = createItem(fn(cur.data, i++, this));
+      item.prev = prev;
+      if (prev)
+        prev.next = item;
+      else
+        result.head = item;
+      prev = item;
+    }
+    result.tail = prev;
+    return result;
+  }
+  filter(fn) {
+    const result = new CssList;
+    let prev = null;
+    let i = 0;
+    for (let cur = this.head;cur != null; cur = cur.next) {
+      if (fn(cur.data, i++, this)) {
+        const item = createItem(cur.data);
+        item.prev = prev;
+        if (prev)
+          prev.next = item;
+        else
+          result.head = item;
+        prev = item;
+      }
+    }
+    result.tail = prev;
+    return result;
+  }
+  clear() {
+    let cur = this.head;
+    while (cur) {
+      const nxt = cur.next;
+      cur.prev = null;
+      cur.next = null;
+      cur = nxt;
+    }
+    this.head = null;
+    this.tail = null;
+  }
+  copy() {
+    const result = new CssList;
+    let prev = null;
+    for (let cur = this.head;cur != null; cur = cur.next) {
+      const item = createItem(cur.data);
+      item.prev = prev;
+      if (prev)
+        prev.next = item;
+      else
+        result.head = item;
+      prev = item;
+    }
+    result.tail = prev;
+    return result;
+  }
+  prepend(item) {
+    return this.insert(item, this.head);
+  }
+  prependData(data) {
+    return this.insert(createItem(data), this.head);
+  }
+  append(item) {
+    return this.insert(item, null);
+  }
+  appendData(data) {
+    return this.insert(createItem(data), null);
+  }
+  insert(item, before = null) {
+    if (before != null) {
+      this.updateCursors(before.prev, item, before, item);
+      if (before.prev === null) {
+        if (this.head !== before)
+          throw new Error("before doesn't belong to list");
+        this.head = item;
+        before.prev = item;
+        item.next = before;
+        this.updateCursors(null, item, null, null);
+      } else {
+        before.prev.next = item;
+        item.prev = before.prev;
+        before.prev = item;
+        item.next = before;
+      }
+    } else {
+      this.updateCursors(this.tail, item, null, item);
+      if (this.tail !== null) {
+        this.tail.next = item;
+        item.prev = this.tail;
+        this.tail = item;
+      } else {
+        this.head = item;
+        this.tail = item;
+      }
+    }
+    return this;
+  }
+  insertData(data, before = null) {
+    return this.insert(createItem(data), before);
+  }
+  remove(item) {
+    this.updateCursors(item, item.prev, item, item.next);
+    if (item.prev !== null)
+      item.prev.next = item.next;
+    else if (this.head === item)
+      this.head = item.next;
+    else
+      throw new Error("item doesn't belong to list");
+    if (item.next !== null)
+      item.next.prev = item.prev;
+    else if (this.tail === item)
+      this.tail = item.prev;
+    else
+      throw new Error("item doesn't belong to list");
+    item.prev = null;
+    item.next = null;
+    return item;
+  }
+  push(data) {
+    this.insert(createItem(data), null);
+  }
+  pop() {
+    if (this.tail === null)
+      return null;
+    return this.remove(this.tail);
+  }
+  unshift(data) {
+    this.prependData(data);
+  }
+  shift() {
+    if (this.head === null)
+      return null;
+    return this.remove(this.head);
+  }
+  prependList(list) {
+    return this.insertList(list, this.head);
+  }
+  appendList(list) {
+    return this.insertList(list, null);
+  }
+  insertList(list, before = null) {
+    if (list.head === null)
+      return this;
+    if (before !== null) {
+      this.updateCursors(before.prev, list.tail, before, list.head);
+      if (before.prev !== null) {
+        before.prev.next = list.head;
+        list.head.prev = before.prev;
+      } else {
+        this.head = list.head;
+      }
+      before.prev = list.tail;
+      list.tail.next = before;
+    } else {
+      this.updateCursors(this.tail, list.tail, null, list.head);
+      if (this.tail !== null) {
+        this.tail.next = list.head;
+        list.head.prev = this.tail;
+      } else {
+        this.head = list.head;
+      }
+      this.tail = list.tail;
+    }
+    list.head = null;
+    list.tail = null;
+    return this;
+  }
+  replace(oldItem, newItemOrList) {
+    if (newItemOrList instanceof CssList) {
+      this.insertList(newItemOrList, oldItem);
+      this.remove(oldItem);
+    } else {
+      this.insert(newItemOrList, oldItem);
+      this.remove(oldItem);
+    }
+  }
+}
+function makeList() {
+  return new CssList;
+}
+
+// src/parse/clone.ts
+function clone(node) {
+  return cloneAny(node);
+}
+function cloneAny(value) {
+  if (value === null || typeof value !== "object")
+    return value;
+  if (value instanceof CssList) {
+    const out2 = new CssList;
+    for (const child of value)
+      out2.appendData(cloneAny(child));
+    return out2;
+  }
+  if (Array.isArray(value))
+    return value.map(cloneAny);
+  if ("type" in value && typeof value.type === "string") {
+    const out2 = { type: value.type };
+    for (const k of Object.keys(value)) {
+      if (k === "type")
+        continue;
+      out2[k] = cloneAny(value[k]);
+    }
+    return out2;
+  }
+  const out = {};
+  for (const k of Object.keys(value))
+    out[k] = cloneAny(value[k]);
+  return out;
+}
+// src/parse/generator.ts
+function generate(node) {
+  switch (node.type) {
+    case "StyleSheet":
+      return joinChildren(node.children, "");
+    case "Rule":
+      return `${generate(node.prelude)}{${generate(node.block)}}`;
+    case "Block":
+      return joinBlockChildren(node.children);
+    case "Atrule": {
+      let out = `@${node.name}`;
+      if (node.prelude) {
+        const p = generate(node.prelude);
+        if (p)
+          out += ` ${p}`;
+      }
+      if (node.block) {
+        out += `{${generate(node.block)}}`;
+      } else {
+        out += ";";
+      }
+      return out;
+    }
+    case "AtrulePrelude":
+      return joinChildren(node.children, "");
+    case "SelectorList":
+      return joinChildren(node.children, ",");
+    case "Selector":
+      return joinChildren(node.children, "");
+    case "TypeSelector":
+      return node.name;
+    case "IdSelector":
+      return `#${node.name}`;
+    case "ClassSelector":
+      return `.${node.name}`;
+    case "NestingSelector":
+      return "&";
+    case "AttributeSelector": {
+      let out = `[${node.name.name}`;
+      if (node.matcher && node.value) {
+        out += node.matcher;
+        if (node.value.type === "String")
+          out += `"${escapeStringContent(node.value.value)}"`;
+        else
+          out += node.value.name;
+      }
+      if (node.flags)
+        out += ` ${node.flags}`;
+      out += "]";
+      return out;
+    }
+    case "PseudoClassSelector":
+      return node.children ? `:${node.name}(${joinChildren(node.children, "")})` : `:${node.name}`;
+    case "PseudoElementSelector":
+      return node.children ? `::${node.name}(${joinChildren(node.children, "")})` : `::${node.name}`;
+    case "Combinator":
+      return node.name === " " ? " " : node.name;
+    case "Declaration":
+      return `${node.property}:${generate(node.value)}${node.important ? "!important" : ""}`;
+    case "DeclarationList":
+      return joinChildren(node.children, ";");
+    case "Value":
+      return joinChildren(node.children, "");
+    case "Identifier":
+      return node.name;
+    case "Number":
+      return node.value;
+    case "Percentage":
+      return `${node.value}%`;
+    case "Dimension":
+      return node.value + node.unit;
+    case "String":
+      return `"${escapeStringContent(node.value)}"`;
+    case "Url":
+      return /[\s"'()\\\u0000-\u001F\u007F]/.test(node.value) ? `url("${escapeStringContent(node.value)}")` : `url(${node.value})`;
+    case "Hash":
+      return `#${node.name}`;
+    case "Operator":
+      return node.value;
+    case "Function":
+      return `${node.name}(${joinChildren(node.children, "")})`;
+    case "Parentheses":
+      return `(${joinChildren(node.children, "")})`;
+    case "Brackets":
+      return `[${joinChildren(node.children, "")}]`;
+    case "Raw":
+      return node.value;
+    case "Comment":
+      return node.value.startsWith("!") ? `/*${node.value}*/` : "";
+    case "WhiteSpace":
+      return " ";
+    case "CDO":
+      return "<!--";
+    case "CDC":
+      return "-->";
+    case "AnPlusB": {
+      const a = node.a ?? "";
+      const b = node.b ?? "";
+      if (a && b) {
+        const bn = Number(b);
+        return `${a === "1" ? "" : a === "-1" ? "-" : a}n${bn >= 0 ? `+${b}` : b}`;
+      }
+      if (a)
+        return `${a === "1" ? "" : a === "-1" ? "-" : a}n`;
+      return b;
+    }
+    case "Ratio":
+      return `${node.left.value}/${node.right.value}`;
+    case "UnicodeRange":
+      return node.value;
+    case "Nth":
+      return node.selector ? `${generate(node.nth)} of ${generate(node.selector)}` : generate(node.nth);
+    case "MediaQueryList":
+      return joinChildren(node.children, ",");
+    case "MediaQuery":
+      return joinChildren(node.children, "");
+    case "MediaFeature": {
+      let out = `(${node.name}`;
+      if (node.value)
+        out += `:${generate(node.value)}`;
+      out += ")";
+      return out;
+    }
+  }
+  return "";
+}
+function joinChildren(list, separator) {
+  let out = "";
+  let first = true;
+  let prev = null;
+  let cur = list.head;
+  while (cur != null) {
+    const child = cur.data;
+    if (child.type === "WhiteSpace") {
+      const nextNode = cur.next ? cur.next.data : null;
+      if (isCompactOperator(prev) || isCompactOperator(nextNode)) {
+        cur = cur.next;
+        continue;
+      }
+    }
+    const text = generate(child);
+    if (!text) {
+      cur = cur.next;
+      continue;
+    }
+    if (!first && separator && !isStructuralSeparator(prev))
+      out += separator;
+    first = false;
+    out += text;
+    prev = child;
+    cur = cur.next;
+  }
+  return out;
+}
+function joinBlockChildren(list) {
+  let out = "";
+  let prev = null;
+  let cur = list.head;
+  while (cur != null) {
+    const child = cur.data;
+    const text = generate(child);
+    if (!text) {
+      cur = cur.next;
+      continue;
+    }
+    if (prev && needsSemicolon(prev, child))
+      out += ";";
+    out += text;
+    prev = child;
+    cur = cur.next;
+  }
+  return out;
+}
+function needsSemicolon(prev, next) {
+  return prev.type === "Declaration" && next.type !== "Comment";
+}
+function isCompactOperator(node) {
+  if (!node || node.type !== "Operator")
+    return false;
+  const v = node.value;
+  return v === ":" || v === "," || v === "/";
+}
+function isStructuralSeparator(node) {
+  if (!node)
+    return false;
+  return node.type === "Operator" || node.type === "Combinator";
+}
+function escapeStringContent(s) {
+  let out = "";
+  for (let i = 0;i < s.length; i++) {
+    const ch = s.charCodeAt(i);
+    if (ch === 92) {
+      out += "\\\\";
+    } else if (ch === 34) {
+      out += "\\\"";
+    } else if (ch < 32 || ch === 127) {
+      const hex = ch.toString(16);
+      const next = i + 1 < s.length ? s.charCodeAt(i + 1) : -1;
+      const needsSpace = next === 32 || next === 9 || next === 10 || next === 12 || next === 13 || next >= 48 && next <= 57 || next >= 65 && next <= 70 || next >= 97 && next <= 102;
+      out += `\\${hex}${needsSpace ? " " : ""}`;
+    } else {
+      out += s[i];
+    }
+  }
+  return out;
+}
+// src/parse/tokenizer.ts
+var TokenType;
+((TokenType2) => {
+  TokenType2[TokenType2["EOF"] = 0] = "EOF";
+  TokenType2[TokenType2["Ident"] = 1] = "Ident";
+  TokenType2[TokenType2["Function"] = 2] = "Function";
+  TokenType2[TokenType2["AtKeyword"] = 3] = "AtKeyword";
+  TokenType2[TokenType2["Hash"] = 4] = "Hash";
+  TokenType2[TokenType2["String"] = 5] = "String";
+  TokenType2[TokenType2["BadString"] = 6] = "BadString";
+  TokenType2[TokenType2["Url"] = 7] = "Url";
+  TokenType2[TokenType2["BadUrl"] = 8] = "BadUrl";
+  TokenType2[TokenType2["Delim"] = 9] = "Delim";
+  TokenType2[TokenType2["Number"] = 10] = "Number";
+  TokenType2[TokenType2["Percentage"] = 11] = "Percentage";
+  TokenType2[TokenType2["Dimension"] = 12] = "Dimension";
+  TokenType2[TokenType2["WhiteSpace"] = 13] = "WhiteSpace";
+  TokenType2[TokenType2["CDO"] = 14] = "CDO";
+  TokenType2[TokenType2["CDC"] = 15] = "CDC";
+  TokenType2[TokenType2["Colon"] = 16] = "Colon";
+  TokenType2[TokenType2["Semicolon"] = 17] = "Semicolon";
+  TokenType2[TokenType2["Comma"] = 18] = "Comma";
+  TokenType2[TokenType2["LeftSquareBracket"] = 19] = "LeftSquareBracket";
+  TokenType2[TokenType2["RightSquareBracket"] = 20] = "RightSquareBracket";
+  TokenType2[TokenType2["LeftParenthesis"] = 21] = "LeftParenthesis";
+  TokenType2[TokenType2["RightParenthesis"] = 22] = "RightParenthesis";
+  TokenType2[TokenType2["LeftCurlyBracket"] = 23] = "LeftCurlyBracket";
+  TokenType2[TokenType2["RightCurlyBracket"] = 24] = "RightCurlyBracket";
+  TokenType2[TokenType2["Comment"] = 25] = "Comment";
+})(TokenType ||= {});
+var REPLACEMENT = 65533;
+var CHAR_CLASS = (() => {
+  const t = new Uint8Array(128);
+  for (let c = 0;c < 128; c++) {
+    let bits = 0;
+    if (c === 32 || c === 9 || c === 10 || c === 12 || c === 13)
+      bits |= 1;
+    if (c >= 48 && c <= 57)
+      bits |= 2;
+    if (c >= 48 && c <= 57 || c >= 65 && c <= 70 || c >= 97 && c <= 102)
+      bits |= 4;
+    if (c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 95)
+      bits |= 8;
+    if (c === 10 || c === 12 || c === 13)
+      bits |= 16;
+    t[c] = bits;
+  }
+  return t;
+})();
+function isDigit(code) {
+  return code < 128 && (CHAR_CLASS[code] & 2) !== 0;
+}
+function isHexDigit(code) {
+  return code < 128 && (CHAR_CLASS[code] & 4) !== 0;
+}
+function isNameStart(code) {
+  return code >= 128 || code < 128 && (CHAR_CLASS[code] & 8) !== 0;
+}
+function isName(code) {
+  return code === 45 || code >= 128 || code < 128 && (CHAR_CLASS[code] & (2 | 8)) !== 0;
+}
+function isNonPrintable(code) {
+  return code >= 0 && code <= 8 || code === 11 || code >= 14 && code <= 31 || code === 127;
+}
+function isNewline(code) {
+  return code < 128 && (CHAR_CLASS[code] & 16) !== 0;
+}
+function isWhitespace(code) {
+  return code < 128 && (CHAR_CLASS[code] & 1) !== 0;
+}
+function isValidEscape(c1, c2) {
+  if (c1 !== 92)
+    return false;
+  if (isNewline(c2))
+    return false;
+  return true;
+}
+function startsIdentifier(c1, c2, c3) {
+  if (c1 === 45) {
+    return isNameStart(c2) || c2 === 45 || isValidEscape(c2, c3);
+  }
+  if (isNameStart(c1))
+    return true;
+  if (c1 === 92)
+    return isValidEscape(c1, c2);
+  return false;
+}
+function startsNumber(c1, c2, c3) {
+  if (c1 === 43 || c1 === 45) {
+    if (isDigit(c2))
+      return true;
+    if (c2 === 46 && isDigit(c3))
+      return true;
+    return false;
+  }
+  if (c1 === 46)
+    return isDigit(c2);
+  return isDigit(c1);
+}
+
+class Tokenizer {
+  source;
+  offset = 0;
+  types;
+  starts;
+  ends;
+  count = 0;
+  _tokens = null;
+  _lineStarts = null;
+  constructor(source) {
+    this.source = source;
+    const cap = Math.max(64, Math.ceil(source.length / 3));
+    this.types = new Uint8Array(cap);
+    this.starts = new Uint32Array(cap);
+    this.ends = new Uint32Array(cap);
+    this.tokenize();
+  }
+  get lineStarts() {
+    if (this._lineStarts == null)
+      this._lineStarts = buildLineStarts(this.source);
+    return this._lineStarts;
+  }
+  get tokens() {
+    if (this._tokens != null)
+      return this._tokens;
+    const out = Array.from({ length: this.count });
+    for (let i = 0;i < this.count; i++)
+      out[i] = { type: this.types[i], start: this.starts[i], end: this.ends[i] };
+    this._tokens = out;
+    return out;
+  }
+  addToken(type, start, end) {
+    if (this.count >= this.types.length)
+      this.grow();
+    this.types[this.count] = type;
+    this.starts[this.count] = start;
+    this.ends[this.count] = end;
+    this.count++;
+  }
+  grow() {
+    const oldLen = this.types.length;
+    const newLen = oldLen * 2;
+    const t = new Uint8Array(newLen);
+    t.set(this.types);
+    this.types = t;
+    const s = new Uint32Array(newLen);
+    s.set(this.starts);
+    this.starts = s;
+    const e = new Uint32Array(newLen);
+    e.set(this.ends);
+    this.ends = e;
+  }
+  tokenize() {
+    const src = this.source;
+    let i = 0;
+    const len = src.length;
+    while (i < len) {
+      const c1 = src.charCodeAt(i);
+      if (c1 === 47 && src.charCodeAt(i + 1) === 42) {
+        const start = i;
+        i += 2;
+        while (i < len && !(src.charCodeAt(i) === 42 && src.charCodeAt(i + 1) === 47))
+          i++;
+        i = i < len ? i + 2 : len;
+        this.addToken(25 /* Comment */, start, i);
+        continue;
+      }
+      if (isWhitespace(c1)) {
+        const start = i;
+        while (i < len && isWhitespace(src.charCodeAt(i)))
+          i++;
+        this.addToken(13 /* WhiteSpace */, start, i);
+        continue;
+      }
+      if (c1 === 34 || c1 === 39) {
+        i = this.consumeString(c1, i);
+        continue;
+      }
+      if (c1 === 35) {
+        if (i + 1 < len && (isName(src.charCodeAt(i + 1)) || isValidEscape(src.charCodeAt(i + 1), src.charCodeAt(i + 2)))) {
+          const start = i;
+          i++;
+          i = this.consumeName(i);
+          this.addToken(4 /* Hash */, start, i);
+          continue;
+        }
+        this.addToken(9 /* Delim */, i, i + 1);
+        i++;
+        continue;
+      }
+      switch (c1) {
+        case 40:
+          this.addToken(21 /* LeftParenthesis */, i, i + 1);
+          i++;
+          continue;
+        case 41:
+          this.addToken(22 /* RightParenthesis */, i, i + 1);
+          i++;
+          continue;
+        case 91:
+          this.addToken(19 /* LeftSquareBracket */, i, i + 1);
+          i++;
+          continue;
+        case 93:
+          this.addToken(20 /* RightSquareBracket */, i, i + 1);
+          i++;
+          continue;
+        case 123:
+          this.addToken(23 /* LeftCurlyBracket */, i, i + 1);
+          i++;
+          continue;
+        case 125:
+          this.addToken(24 /* RightCurlyBracket */, i, i + 1);
+          i++;
+          continue;
+        case 44:
+          this.addToken(18 /* Comma */, i, i + 1);
+          i++;
+          continue;
+        case 58:
+          this.addToken(16 /* Colon */, i, i + 1);
+          i++;
+          continue;
+        case 59:
+          this.addToken(17 /* Semicolon */, i, i + 1);
+          i++;
+          continue;
+      }
+      if (c1 === 60 && src.startsWith("!--", i + 1)) {
+        this.addToken(14 /* CDO */, i, i + 4);
+        i += 4;
+        continue;
+      }
+      if (c1 === 45 && src.startsWith("->", i + 1)) {
+        this.addToken(15 /* CDC */, i, i + 3);
+        i += 3;
+        continue;
+      }
+      if (c1 === 64) {
+        const c22 = src.charCodeAt(i + 1);
+        const c32 = src.charCodeAt(i + 2);
+        const c4 = src.charCodeAt(i + 3);
+        if (startsIdentifier(c22, c32, c4)) {
+          const start = i;
+          i++;
+          i = this.consumeName(i);
+          this.addToken(3 /* AtKeyword */, start, i);
+          continue;
+        }
+        this.addToken(9 /* Delim */, i, i + 1);
+        i++;
+        continue;
+      }
+      const c2 = src.charCodeAt(i + 1);
+      const c3 = src.charCodeAt(i + 2);
+      if (startsNumber(c1, c2, c3)) {
+        i = this.consumeNumeric(i);
+        continue;
+      }
+      if (startsIdentifier(c1, c2, c3)) {
+        i = this.consumeIdentLike(i);
+        continue;
+      }
+      if (c1 === 92) {
+        if (isValidEscape(c1, c2)) {
+          i = this.consumeIdentLike(i);
+          continue;
+        }
+        this.addToken(9 /* Delim */, i, i + 1);
+        i++;
+        continue;
+      }
+      this.addToken(9 /* Delim */, i, i + 1);
+      i++;
+    }
+    this.addToken(0 /* EOF */, len, len);
+  }
+  consumeString(quote, start) {
+    const src = this.source;
+    const len = src.length;
+    let i = start + 1;
+    while (i < len) {
+      const c = src.charCodeAt(i);
+      if (c === quote) {
+        i++;
+        this.addToken(5 /* String */, start, i);
+        return i;
+      }
+      if (isNewline(c)) {
+        this.addToken(6 /* BadString */, start, i);
+        return i;
+      }
+      if (c === 92) {
+        const c2 = src.charCodeAt(i + 1);
+        if (isNewline(c2)) {
+          i += 2;
+          continue;
+        }
+        if (i + 1 < len) {
+          i = this.consumeEscapeSkip(i + 1);
+          continue;
+        }
+      }
+      i++;
+    }
+    this.addToken(5 /* String */, start, i);
+    return i;
+  }
+  consumeEscapeSkip(i) {
+    const src = this.source;
+    if (i >= src.length)
+      return i;
+    const c = src.charCodeAt(i);
+    if (isHexDigit(c)) {
+      let n = 1;
+      i++;
+      while (n < 6 && i < src.length && isHexDigit(src.charCodeAt(i))) {
+        i++;
+        n++;
+      }
+      if (i < src.length && isWhitespace(src.charCodeAt(i)))
+        i++;
+      return i;
+    }
+    return i + 1;
+  }
+  consumeName(start) {
+    const src = this.source;
+    const len = src.length;
+    let i = start;
+    while (i < len) {
+      const c = src.charCodeAt(i);
+      if (c < 128 && (CHAR_CLASS[c] & (2 | 8)) !== 0) {
+        i++;
+        continue;
+      }
+      if (c === 45) {
+        i++;
+        continue;
+      }
+      if (c >= 128) {
+        i++;
+        continue;
+      }
+      if (c === 92 && isValidEscape(c, src.charCodeAt(i + 1))) {
+        i = this.consumeEscapeSkip(i + 1);
+        continue;
+      }
+      break;
+    }
+    return i;
+  }
+  consumeNumber(start) {
+    const src = this.source;
+    let i = start;
+    if (src.charCodeAt(i) === 43 || src.charCodeAt(i) === 45)
+      i++;
+    while (i < src.length && isDigit(src.charCodeAt(i)))
+      i++;
+    if (src.charCodeAt(i) === 46 && isDigit(src.charCodeAt(i + 1))) {
+      i += 2;
+      while (i < src.length && isDigit(src.charCodeAt(i)))
+        i++;
+    }
+    const eC = src.charCodeAt(i);
+    if (eC === 69 || eC === 101) {
+      const next = src.charCodeAt(i + 1);
+      const next2 = src.charCodeAt(i + 2);
+      if (isDigit(next)) {
+        i += 2;
+        while (i < src.length && isDigit(src.charCodeAt(i)))
+          i++;
+      } else if ((next === 43 || next === 45) && isDigit(next2)) {
+        i += 3;
+        while (i < src.length && isDigit(src.charCodeAt(i)))
+          i++;
+      }
+    }
+    return i;
+  }
+  consumeNumeric(start) {
+    const src = this.source;
+    const numEnd = this.consumeNumber(start);
+    const c1 = src.charCodeAt(numEnd);
+    const c2 = src.charCodeAt(numEnd + 1);
+    const c3 = src.charCodeAt(numEnd + 2);
+    if (startsIdentifier(c1, c2, c3)) {
+      const end = this.consumeName(numEnd);
+      this.addToken(12 /* Dimension */, start, end);
+      return end;
+    }
+    if (c1 === 37) {
+      this.addToken(11 /* Percentage */, start, numEnd + 1);
+      return numEnd + 1;
+    }
+    this.addToken(10 /* Number */, start, numEnd);
+    return numEnd;
+  }
+  consumeIdentLike(start) {
+    const src = this.source;
+    const nameEnd = this.consumeName(start);
+    const c = src.charCodeAt(nameEnd);
+    if (c === 40 && nameEnd - start === 3) {
+      const c0 = src.charCodeAt(start) | 32;
+      const c1 = src.charCodeAt(start + 1) | 32;
+      const c2 = src.charCodeAt(start + 2) | 32;
+      if (c0 === 117 && c1 === 114 && c2 === 108) {
+        let i = nameEnd + 1;
+        while (i < src.length && isWhitespace(src.charCodeAt(i)))
+          i++;
+        const next = src.charCodeAt(i);
+        if (next === 34 || next === 39) {
+          this.addToken(2 /* Function */, start, nameEnd + 1);
+          return nameEnd + 1;
+        }
+        return this.consumeUrl(start, nameEnd);
+      }
+    }
+    if (c === 40) {
+      this.addToken(2 /* Function */, start, nameEnd + 1);
+      return nameEnd + 1;
+    }
+    this.addToken(1 /* Ident */, start, nameEnd);
+    return nameEnd;
+  }
+  consumeUrl(start, nameEnd) {
+    const src = this.source;
+    const len = src.length;
+    let i = nameEnd + 1;
+    while (i < len && isWhitespace(src.charCodeAt(i)))
+      i++;
+    while (i < len) {
+      const c = src.charCodeAt(i);
+      if (c === 41) {
+        i++;
+        this.addToken(7 /* Url */, start, i);
+        return i;
+      }
+      if (isWhitespace(c)) {
+        const wsStart = i;
+        while (i < len && isWhitespace(src.charCodeAt(i)))
+          i++;
+        if (i >= len) {
+          this.addToken(7 /* Url */, start, i);
+          return i;
+        }
+        if (src.charCodeAt(i) === 41) {
+          i++;
+          this.addToken(7 /* Url */, start, i);
+          return i;
+        }
+        return this.consumeBadUrl(start, wsStart);
+      }
+      if (c === 34 || c === 39 || c === 40 || isNonPrintable(c)) {
+        return this.consumeBadUrl(start, i);
+      }
+      if (c === 92) {
+        if (isValidEscape(c, src.charCodeAt(i + 1))) {
+          i = this.consumeEscapeSkip(i + 1);
+          continue;
+        }
+        return this.consumeBadUrl(start, i);
+      }
+      i++;
+    }
+    this.addToken(7 /* Url */, start, i);
+    return i;
+  }
+  consumeBadUrl(start, from) {
+    const src = this.source;
+    let i = from;
+    while (i < src.length) {
+      const c = src.charCodeAt(i);
+      if (c === 41) {
+        i++;
+        break;
+      }
+      if (c === 92 && isValidEscape(c, src.charCodeAt(i + 1))) {
+        i = this.consumeEscapeSkip(i + 1);
+        continue;
+      }
+      i++;
+    }
+    this.addToken(8 /* BadUrl */, start, i);
+    return i;
+  }
+  locate(offset) {
+    const ls = this.lineStarts;
+    let lo = 0;
+    let hi = ls.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if (ls[mid] <= offset)
+        lo = mid;
+      else
+        hi = mid - 1;
+    }
+    const lineStart = ls[lo];
+    return { line: lo + 1, column: offset - lineStart + 1 };
+  }
+}
+function buildLineStarts(source) {
+  const out = [0];
+  const len = source.length;
+  for (let i = 0;i < len; i++) {
+    const c = source.charCodeAt(i);
+    if (c === 10) {
+      out.push(i + 1);
+    } else if (c === 13) {
+      if (source.charCodeAt(i + 1) !== 10)
+        out.push(i + 1);
+    }
+  }
+  return out;
+}
+function decodeString(source, start, end) {
+  for (let k = start;k < end; k++) {
+    if (source.charCodeAt(k) === 92)
+      return decodeStringSlow(source, start, end, k);
+  }
+  return source.slice(start, end);
+}
+function decodeStringSlow(source, start, end, firstEscape) {
+  let out = source.slice(start, firstEscape);
+  let i = firstEscape;
+  while (i < end) {
+    const c = source.charCodeAt(i);
+    if (c !== 92) {
+      out += source[i];
+      i++;
+      continue;
+    }
+    if (i + 1 >= end) {
+      i++;
+      continue;
+    }
+    const next = source.charCodeAt(i + 1);
+    if (next === 10) {
+      i += 2;
+      continue;
+    }
+    if (next === 13) {
+      i += source.charCodeAt(i + 2) === 10 ? 3 : 2;
+      continue;
+    }
+    if (isHexDigit(next)) {
+      let j = i + 1;
+      let hex = "";
+      while (hex.length < 6 && j < end && isHexDigit(source.charCodeAt(j))) {
+        hex += source[j];
+        j++;
+      }
+      const code = Number.parseInt(hex, 16);
+      if (j < end && isWhitespace(source.charCodeAt(j)))
+        j++;
+      out += code === 0 || code >= 55296 && code <= 57343 || code > 1114111 ? String.fromCodePoint(REPLACEMENT) : String.fromCodePoint(code);
+      i = j;
+      continue;
+    }
+    out += source[i + 1];
+    i += 2;
+  }
+  return out;
+}
+function decodeName(source, start, end) {
+  for (let k = start;k < end; k++) {
+    if (source.charCodeAt(k) === 92)
+      return decodeNameSlow(source, start, end, k);
+  }
+  return source.slice(start, end);
+}
+function decodeNameSlow(source, start, end, firstEscape) {
+  let out = source.slice(start, firstEscape);
+  let i = firstEscape;
+  while (i < end) {
+    const c = source.charCodeAt(i);
+    if (c !== 92) {
+      out += source[i];
+      i++;
+      continue;
+    }
+    let j = i + 1;
+    let hex = "";
+    while (hex.length < 6 && j < end && isHexDigit(source.charCodeAt(j))) {
+      hex += source[j];
+      j++;
+    }
+    if (hex.length > 0) {
+      const code = Number.parseInt(hex, 16);
+      if (j < end && isWhitespace(source.charCodeAt(j)))
+        j++;
+      out += code === 0 || code >= 55296 && code <= 57343 || code > 1114111 ? String.fromCodePoint(REPLACEMENT) : String.fromCodePoint(code);
+      i = j;
+      continue;
+    }
+    if (j < end) {
+      out += source[j];
+      i = j + 1;
+      continue;
+    }
+    out += String.fromCodePoint(REPLACEMENT);
+    i = j;
+  }
+  return out;
+}
+
+// src/parse/parser/index.ts
+function makeState(source, options) {
+  const tokenizer = new Tokenizer(source);
+  return {
+    source,
+    types: tokenizer.types,
+    starts: tokenizer.starts,
+    ends: tokenizer.ends,
+    count: tokenizer.count,
+    end: tokenizer.count,
+    pos: 0,
+    positions: options.positions ?? false,
+    filename: options.filename,
+    parseValue: options.parseValue ?? true,
+    parseAtrulePrelude: options.parseAtrulePrelude ?? true,
+    parseCustomProperty: options.parseCustomProperty ?? false,
+    parseRulePrelude: options.parseRulePrelude ?? true,
+    onParseError: options.onParseError,
+    tokenizer
+  };
+}
+function peekType(s) {
+  return s.pos < s.end ? s.types[s.pos] : 0 /* EOF */;
+}
+function peek(s) {
+  const i = s.pos;
+  if (i >= s.end)
+    return { type: 0 /* EOF */, start: s.starts[i] ?? s.source.length, end: s.ends[i] ?? s.source.length };
+  return { type: s.types[i], start: s.starts[i], end: s.ends[i] };
+}
+function consume(s) {
+  const i = s.pos++;
+  if (i >= s.end)
+    return { type: 0 /* EOF */, start: s.starts[i] ?? s.source.length, end: s.ends[i] ?? s.source.length };
+  return { type: s.types[i], start: s.starts[i], end: s.ends[i] };
+}
+function tokenSlice(s, t) {
+  return s.source.slice(t.start, t.end);
+}
+function skipWhitespace(s) {
+  const types = s.types;
+  const end = s.end;
+  while (s.pos < end) {
+    const t = types[s.pos];
+    if (t === 13 /* WhiteSpace */ || t === 25 /* Comment */)
+      s.pos++;
+    else
+      break;
+  }
+}
+function skipWhitespaceOnly(s) {
+  const types = s.types;
+  const end = s.end;
+  while (s.pos < end && types[s.pos] === 13 /* WhiteSpace */)
+    s.pos++;
+}
+function loc(s, startTok, endTok) {
+  if (!s.positions)
+    return null;
+  const start = s.tokenizer.locate(startTok.start);
+  const end = s.tokenizer.locate(endTok.end);
+  return {
+    source: s.filename ?? "<unknown>",
+    start: { offset: startTok.start, line: start.line, column: start.column },
+    end: { offset: endTok.end, line: end.line, column: end.column }
+  };
+}
+function emptyLoc(s) {
+  if (!s.positions)
+    return null;
+  const t = peek(s);
+  const p = s.tokenizer.locate(t.start);
+  return {
+    source: s.filename ?? "<unknown>",
+    start: { offset: t.start, line: p.line, column: p.column },
+    end: { offset: t.start, line: p.line, column: p.column }
+  };
+}
+function rawNode(value, start, end, s) {
+  return { type: "Raw", value, loc: loc(s, start, end) };
+}
+function newList() {
+  return new CssList;
+}
+function reportError(s, message, at, fallback) {
+  if (s.onParseError) {
+    const { line, column } = s.tokenizer.locate(at.start);
+    const err = new SyntaxError(`${s.filename ?? "<input>"}:${line}:${column}: ${message}`);
+    err.line = line;
+    err.column = column;
+    err.offset = at.start;
+    s.onParseError(err, fallback);
+  }
+  return fallback;
+}
+function parse(source, options = {}) {
+  const s = makeState(source, options);
+  const ctx = options.context ?? "stylesheet";
+  switch (ctx) {
+    case "stylesheet":
+      return parseStyleSheet(s);
+    case "atrule":
+      return parseAtrule(s) ?? makeEmptyStyleSheet(s);
+    case "atrulePrelude":
+      return parseAtrulePreludeContext(s);
+    case "mediaQuery":
+    case "mediaQueryList":
+      return parseRawAsValue(s);
+    case "rule":
+      return parseRule(s);
+    case "selectorList":
+      return parseSelectorList(s);
+    case "selector":
+      return parseSelector(s);
+    case "block":
+      return parseBlock(s);
+    case "declarationList":
+      return parseDeclarationList(s);
+    case "declaration":
+      return parseDeclaration(s) ?? makeEmptyStyleSheet(s);
+    case "value":
+      return parseValue(s);
+    case "raw":
+      return parseRawAsValue(s);
+    default:
+      return parseStyleSheet(s);
+  }
+}
+function makeEmptyStyleSheet(s) {
+  return { type: "StyleSheet", children: newList(), loc: emptyLoc(s) };
+}
+function parseRawAsValue(s) {
+  const start = peek(s);
+  let end = start;
+  while (peekType(s) !== 0 /* EOF */) {
+    end = consume(s);
+  }
+  return { type: "Raw", value: s.source.slice(start.start, end.end), loc: loc(s, start, end) };
+}
+function parseStyleSheet(s) {
+  const startTok = peek(s);
+  const children = newList();
+  const types = s.types;
+  const end = s.end;
+  while (s.pos < end) {
+    const t = types[s.pos];
+    if (t === 13 /* WhiteSpace */) {
+      s.pos++;
+      continue;
+    }
+    if (t === 25 /* Comment */) {
+      const tok = { type: 25 /* Comment */, start: s.starts[s.pos], end: s.ends[s.pos] };
+      const node = makeComment(s, tok);
+      s.pos++;
+      children.appendData(node);
+      continue;
+    }
+    if (t === 0 /* EOF */)
+      break;
+    if (t === 14 /* CDO */ || t === 15 /* CDC */) {
+      s.pos++;
+      continue;
+    }
+    if (t === 3 /* AtKeyword */) {
+      const at = parseAtrule(s);
+      if (at)
+        children.appendData(at);
+      continue;
+    }
+    if (t === 24 /* RightCurlyBracket */) {
+      s.pos++;
+      continue;
+    }
+    const before = s.pos;
+    const r = parseRule(s);
+    children.appendData(r);
+    if (s.pos === before)
+      s.pos++;
+  }
+  const lastIdx = s.end - 1;
+  const endTok = lastIdx >= 0 ? { type: s.types[lastIdx], start: s.starts[lastIdx], end: s.ends[lastIdx] } : { type: 0 /* EOF */, start: 0, end: 0 };
+  return { type: "StyleSheet", children, loc: loc(s, startTok, endTok) };
+}
+function makeComment(s, t) {
+  return { type: "Comment", value: s.source.slice(t.start + 2, t.end - 2), loc: loc(s, t, t) };
+}
+function parseAtrule(s) {
+  const startTok = peek(s);
+  if (startTok.type !== 3 /* AtKeyword */)
+    return null;
+  s.pos++;
+  const name = lowerIfNeeded(s.source, startTok.start + 1, startTok.end);
+  skipWhitespace(s);
+  const preludeStartPos = s.pos;
+  const preludeStartTok = peek(s);
+  const types = s.types;
+  const tend = s.end;
+  let scanPos = preludeStartPos;
+  let preludeEndPos = preludeStartPos;
+  while (scanPos < tend) {
+    const t = types[scanPos];
+    if (t === 0 /* EOF */ || t === 17 /* Semicolon */ || t === 23 /* LeftCurlyBracket */)
+      break;
+    if (t !== 13 /* WhiteSpace */ && t !== 25 /* Comment */)
+      preludeEndPos = scanPos + 1;
+    scanPos++;
+  }
+  let prelude = null;
+  if (preludeEndPos > preludeStartPos) {
+    const preludeStartByte = s.starts[preludeStartPos];
+    const preludeEndByte = s.ends[preludeEndPos - 1];
+    const preludeEndTok = { type: types[preludeEndPos - 1], start: s.starts[preludeEndPos - 1], end: preludeEndByte };
+    const raw = s.source.slice(preludeStartByte, preludeEndByte).trim();
+    if (raw.length > 0) {
+      if (s.parseAtrulePrelude) {
+        try {
+          const savedEnd = s.end;
+          s.end = preludeEndPos;
+          s.pos = preludeStartPos;
+          const children = newList();
+          while (peekType(s) !== 0 /* EOF */) {
+            const node = parseValueChild(s);
+            if (node)
+              children.appendData(node);
+          }
+          promoteRatiosDeep(children);
+          s.end = savedEnd;
+          s.pos = scanPos;
+          if (children.isEmpty)
+            prelude = rawNode(raw, preludeStartTok, preludeEndTok, s);
+          else
+            prelude = { type: "AtrulePrelude", children, loc: null };
+        } catch (err) {
+          const fallback = rawNode(raw, preludeStartTok, preludeEndTok, s);
+          reportError(s, `Failed to parse @${name} prelude: ${err.message}`, preludeStartTok, fallback);
+          prelude = fallback;
+          s.pos = scanPos;
+        }
+      } else {
+        prelude = rawNode(raw, preludeStartTok, preludeEndTok, s);
+        s.pos = scanPos;
+      }
+    } else {
+      s.pos = scanPos;
+    }
+  } else {
+    s.pos = scanPos;
+  }
+  let block = null;
+  if (peekType(s) === 17 /* Semicolon */) {
+    consume(s);
+  } else if (peekType(s) === 23 /* LeftCurlyBracket */) {
+    block = parseBlock(s, AT_RULES_WITH_NESTED_RULES.has(name));
+  }
+  return { type: "Atrule", name, prelude, block, loc: loc(s, startTok, peek(s)) };
+}
+var SELECTOR_LIST_PSEUDOS_PARSE = new Set([
+  "is",
+  "not",
+  "where",
+  "has",
+  "matches",
+  "-moz-any",
+  "-webkit-any"
+]);
+var AT_RULES_WITH_NESTED_RULES = new Set([
+  "media",
+  "supports",
+  "document",
+  "layer",
+  "container",
+  "scope",
+  "starting-style",
+  "-moz-document",
+  "keyframes",
+  "-webkit-keyframes",
+  "-moz-keyframes",
+  "-o-keyframes"
+]);
+function parseAtrulePreludeContext(s) {
+  const startTok = peek(s);
+  const children = newList();
+  while (peekType(s) !== 0 /* EOF */) {
+    const t = peek(s);
+    if (t.type === 13 /* WhiteSpace */) {
+      s.pos++;
+      continue;
+    }
+    const node = parseValueChild(s);
+    if (node)
+      children.appendData(node);
+  }
+  return { type: "AtrulePrelude", children, loc: loc(s, startTok, peek(s)) };
+}
+function parseRule(s) {
+  const startTok = peek(s);
+  let prelude;
+  if (s.parseRulePrelude) {
+    prelude = parseSelectorList(s);
+  } else {
+    const preludeStart = peek(s);
+    let preludeEnd = preludeStart;
+    while (peekType(s) !== 0 /* EOF */ && peekType(s) !== 23 /* LeftCurlyBracket */)
+      preludeEnd = consume(s);
+    const preludeText = s.source.slice(preludeStart.start, preludeEnd.end).trim();
+    prelude = rawNode(preludeText, preludeStart, preludeEnd, s);
+  }
+  const block = parseBlock(s, true);
+  return { type: "Rule", prelude, block, loc: loc(s, startTok, peek(s)) };
+}
+function parseBlock(s, allowNested = false) {
+  const startTok = peek(s);
+  if (peekType(s) !== 23 /* LeftCurlyBracket */)
+    return { type: "Block", children: newList(), loc: emptyLoc(s) };
+  s.pos++;
+  const children = newList();
+  const types = s.types;
+  const end = s.end;
+  while (s.pos < end) {
+    const t = types[s.pos];
+    if (t === 24 /* RightCurlyBracket */ || t === 0 /* EOF */)
+      break;
+    if (t === 13 /* WhiteSpace */) {
+      s.pos++;
+      continue;
+    }
+    if (t === 25 /* Comment */) {
+      const tok = { type: 25 /* Comment */, start: s.starts[s.pos], end: s.ends[s.pos] };
+      s.pos++;
+      children.appendData(makeComment(s, tok));
+      continue;
+    }
+    if (t === 3 /* AtKeyword */) {
+      const at = parseAtrule(s);
+      if (at)
+        children.appendData(at);
+      continue;
+    }
+    if (allowNested && lookahead(s, isCurlyAheadBeforeSemicolon)) {
+      const r = parseRule(s);
+      children.appendData(r);
+      continue;
+    }
+    const decl = parseDeclaration(s);
+    if (decl)
+      children.appendData(decl);
+    if (s.pos < end && types[s.pos] === 17 /* Semicolon */)
+      s.pos++;
+  }
+  if (peekType(s) === 24 /* RightCurlyBracket */)
+    s.pos++;
+  return { type: "Block", children, loc: loc(s, startTok, peek(s)) };
+}
+function lookahead(s, predicate) {
+  const saved = s.pos;
+  const r = predicate(s);
+  s.pos = saved;
+  return r;
+}
+function isCurlyAheadBeforeSemicolon(s) {
+  const types = s.types;
+  const end = s.end;
+  while (s.pos < end) {
+    const t = types[s.pos];
+    if (t === 23 /* LeftCurlyBracket */)
+      return true;
+    if (t === 17 /* Semicolon */ || t === 24 /* RightCurlyBracket */ || t === 0 /* EOF */)
+      return false;
+    s.pos++;
+  }
+  return false;
+}
+function parseDeclarationList(s) {
+  const startTok = peek(s);
+  const children = newList();
+  while (peekType(s) !== 0 /* EOF */ && peekType(s) !== 24 /* RightCurlyBracket */) {
+    const t = peek(s);
+    if (t.type === 13 /* WhiteSpace */) {
+      s.pos++;
+      continue;
+    }
+    if (t.type === 25 /* Comment */) {
+      children.appendData(makeComment(s, consume(s)));
+      continue;
+    }
+    if (t.type === 17 /* Semicolon */) {
+      s.pos++;
+      continue;
+    }
+    if (t.type === 3 /* AtKeyword */) {
+      const at = parseAtrule(s);
+      if (at)
+        children.appendData(at);
+      continue;
+    }
+    const decl = parseDeclaration(s);
+    if (decl)
+      children.appendData(decl);
+    if (peekType(s) === 17 /* Semicolon */)
+      consume(s);
+  }
+  return { type: "DeclarationList", children, loc: loc(s, startTok, peek(s)) };
+}
+function parseDeclaration(s) {
+  skipWhitespace(s);
+  const startTok = peek(s);
+  if (startTok.type !== 1 /* Ident */ && startTok.type !== 4 /* Hash */ && !(startTok.type === 9 /* Delim */ && s.source[startTok.start] === "*" && s.source[startTok.start + 1] === " ")) {
+    if (startTok.type === 9 /* Delim */ && s.source[startTok.start] === "*") {
+      s.pos++;
+    } else {
+      reportError(s, `Expected property name`, startTok, { type: "Raw", value: "", loc: null });
+      const types2 = s.types;
+      const end = s.end;
+      while (s.pos < end) {
+        const t = types2[s.pos];
+        if (t === 0 /* EOF */ || t === 17 /* Semicolon */ || t === 24 /* RightCurlyBracket */)
+          break;
+        s.pos++;
+      }
+      return null;
+    }
+  }
+  const propStart = s.starts[s.pos];
+  const propEnd = s.ends[s.pos];
+  s.pos++;
+  const property = s.source.slice(propStart, propEnd);
+  skipWhitespaceOnly(s);
+  if (peekType(s) !== 16 /* Colon */) {
+    reportError(s, `Expected ':' after property "${property}"`, peek(s), { type: "Raw", value: "", loc: null });
+    const types2 = s.types;
+    const end = s.end;
+    while (s.pos < end) {
+      const t = types2[s.pos];
+      if (t === 0 /* EOF */ || t === 17 /* Semicolon */ || t === 24 /* RightCurlyBracket */)
+        break;
+      s.pos++;
+    }
+    return null;
+  }
+  s.pos++;
+  skipWhitespaceOnly(s);
+  const types = s.types;
+  const starts = s.starts;
+  const tend = s.end;
+  const valueStartPos = s.pos;
+  let scanPos = valueStartPos;
+  let lastNonWsPos = valueStartPos;
+  let importantIdentPos = -1;
+  let bangPos = -1;
+  while (scanPos < tend) {
+    const t = types[scanPos];
+    if (t === 0 /* EOF */ || t === 17 /* Semicolon */ || t === 24 /* RightCurlyBracket */)
+      break;
+    if (t === 9 /* Delim */ && s.source.charCodeAt(starts[scanPos]) === 33) {
+      let look = scanPos + 1;
+      while (look < tend && types[look] === 13 /* WhiteSpace */)
+        look++;
+      if (look < tend && types[look] === 1 /* Ident */) {
+        const ts = starts[look];
+        const te = s.ends[look];
+        if (te - ts === 9 && (s.source.charCodeAt(ts) | 32) === 105 && (s.source.charCodeAt(ts + 1) | 32) === 109 && (s.source.charCodeAt(ts + 2) | 32) === 112 && (s.source.charCodeAt(ts + 3) | 32) === 111 && (s.source.charCodeAt(ts + 4) | 32) === 114 && (s.source.charCodeAt(ts + 5) | 32) === 116 && (s.source.charCodeAt(ts + 6) | 32) === 97 && (s.source.charCodeAt(ts + 7) | 32) === 110 && (s.source.charCodeAt(ts + 8) | 32) === 116) {
+          bangPos = scanPos;
+          importantIdentPos = look;
+          scanPos = look + 1;
+          continue;
+        }
+      }
+    }
+    if (t !== 13 /* WhiteSpace */ && t !== 25 /* Comment */)
+      lastNonWsPos = scanPos + 1;
+    scanPos++;
+  }
+  const valueEndPos = lastNonWsPos;
+  const importantTok = importantIdentPos >= 0 ? { type: 1 /* Ident */, start: starts[importantIdentPos], end: s.ends[importantIdentPos] } : null;
+  const isCustom = property.startsWith("--");
+  let value;
+  const valueStartByte = starts[valueStartPos];
+  const valueEndByte = valueEndPos > valueStartPos ? s.ends[valueEndPos - 1] : valueStartByte;
+  const valueStartTok = { type: types[valueStartPos], start: valueStartByte, end: s.ends[valueStartPos] };
+  const valueEndTok = valueEndPos > valueStartPos ? { type: types[valueEndPos - 1], start: starts[valueEndPos - 1], end: valueEndByte } : valueStartTok;
+  if (isCustom && !s.parseCustomProperty || !s.parseValue) {
+    const valueText = s.source.slice(valueStartByte, valueEndByte).trim();
+    value = { type: "Raw", value: valueText, loc: loc(s, valueStartTok, valueEndTok) };
+  } else if (valueEndPos === valueStartPos) {
+    value = { type: "Value", children: newList(), loc: loc(s, valueStartTok, valueEndTok) };
+  } else {
+    const savedEnd = s.end;
+    s.end = valueEndPos;
+    s.pos = valueStartPos;
+    value = parseValueChildren(s);
+    s.end = savedEnd;
+  }
+  s.pos = scanPos;
+  return {
+    type: "Declaration",
+    property,
+    important: importantTok ? true : false,
+    value,
+    loc: loc(s, startTok, peek(s))
+  };
+}
+function parseValue(s) {
+  return parseValueChildren(s);
+}
+function parseValueChildren(s) {
+  const startTok = peek(s);
+  const children = newList();
+  while (peekType(s) !== 0 /* EOF */ && peekType(s) !== 17 /* Semicolon */ && peekType(s) !== 24 /* RightCurlyBracket */ && peekType(s) !== 22 /* RightParenthesis */ && peekType(s) !== 20 /* RightSquareBracket */) {
+    const node = parseValueChild(s);
+    if (node)
+      children.appendData(node);
+  }
+  promoteRatios(children);
+  return { type: "Value", children, loc: loc(s, startTok, peek(s)) };
+}
+function promoteRatiosDeep(list) {
+  for (const child of list) {
+    if ("children" in child && child.children instanceof CssList)
+      promoteRatiosDeep(child.children);
+  }
+  promoteRatios(list);
+}
+function promoteRatios(list) {
+  let cur = list.head;
+  while (cur) {
+    if (cur.data.type === "Number") {
+      let slashItem = cur.next;
+      while (slashItem && slashItem.data.type === "WhiteSpace")
+        slashItem = slashItem.next;
+      if (slashItem && slashItem.data.type === "Operator" && slashItem.data.value === "/") {
+        let rightItem = slashItem.next;
+        while (rightItem && rightItem.data.type === "WhiteSpace")
+          rightItem = rightItem.next;
+        if (rightItem && rightItem.data.type === "Number") {
+          const ratio = {
+            type: "Ratio",
+            left: cur.data,
+            right: rightItem.data,
+            loc: null
+          };
+          let toRemove = cur.next;
+          while (toRemove && toRemove !== rightItem.next) {
+            const nxt = toRemove.next;
+            list.remove(toRemove);
+            toRemove = nxt;
+          }
+          list.replace(cur, list.createItem(ratio));
+          cur = list.head;
+          continue;
+        }
+      }
+    }
+    cur = cur.next;
+  }
+}
+function parseValueChild(s) {
+  const i = s.pos;
+  if (i >= s.end)
+    return null;
+  const ttype = s.types[i];
+  const tstart = s.starts[i];
+  const tend = s.ends[i];
+  const src = s.source;
+  switch (ttype) {
+    case 13 /* WhiteSpace */: {
+      s.pos++;
+      return s.positions ? { type: "WhiteSpace", value: " ", loc: locRange(s, tstart, tend) } : { type: "WhiteSpace", value: " ", loc: null };
+    }
+    case 25 /* Comment */: {
+      s.pos++;
+      return { type: "Comment", value: src.slice(tstart + 2, tend - 2), loc: s.positions ? locRange(s, tstart, tend) : null };
+    }
+    case 10 /* Number */: {
+      s.pos++;
+      return { type: "Number", value: src.slice(tstart, tend), loc: s.positions ? locRange(s, tstart, tend) : null };
+    }
+    case 11 /* Percentage */: {
+      s.pos++;
+      return { type: "Percentage", value: src.slice(tstart, tend - 1), loc: s.positions ? locRange(s, tstart, tend) : null };
+    }
+    case 12 /* Dimension */: {
+      s.pos++;
+      let unitStart = tstart;
+      const c0 = src.charCodeAt(unitStart);
+      if (c0 === 43 || c0 === 45)
+        unitStart++;
+      let sawDot = false;
+      while (unitStart < tend) {
+        const c = src.charCodeAt(unitStart);
+        if (c >= 48 && c <= 57) {
+          unitStart++;
+          continue;
+        }
+        if (c === 46 && !sawDot) {
+          sawDot = true;
+          unitStart++;
+          continue;
+        }
+        break;
+      }
+      const eC = src.charCodeAt(unitStart);
+      if (eC === 69 || eC === 101) {
+        let look = unitStart + 1;
+        const sgn = src.charCodeAt(look);
+        if (sgn === 43 || sgn === 45)
+          look++;
+        let any = false;
+        while (look < tend) {
+          const c = src.charCodeAt(look);
+          if (c >= 48 && c <= 57) {
+            look++;
+            any = true;
+            continue;
+          }
+          break;
+        }
+        if (any)
+          unitStart = look;
+      }
+      return {
+        type: "Dimension",
+        value: src.slice(tstart, unitStart),
+        unit: src.slice(unitStart, tend),
+        loc: s.positions ? locRange(s, tstart, tend) : null
+      };
+    }
+    case 1 /* Ident */: {
+      s.pos++;
+      return { type: "Identifier", name: decodeName(src, tstart, tend), loc: s.positions ? locRange(s, tstart, tend) : null };
+    }
+    case 5 /* String */: {
+      s.pos++;
+      const innerStart = tstart + 1;
+      const closesProperly = tend - tstart >= 2 && src.charCodeAt(tend - 1) === src.charCodeAt(tstart);
+      const innerEnd = closesProperly ? tend - 1 : tend;
+      const value = decodeString(src, innerStart, innerEnd);
+      return { type: "String", value, loc: s.positions ? locRange(s, tstart, tend) : null };
+    }
+    case 7 /* Url */: {
+      s.pos++;
+      let a = tstart + 4;
+      while (a < tend && isWhitespaceCode(src.charCodeAt(a)))
+        a++;
+      let b = tend;
+      if (b > a && src.charCodeAt(b - 1) === 41)
+        b--;
+      while (b > a && isWhitespaceCode(src.charCodeAt(b - 1)))
+        b--;
+      let value;
+      if (b - a >= 2) {
+        const q0 = src.charCodeAt(a);
+        const q1 = src.charCodeAt(b - 1);
+        if ((q0 === 34 || q0 === 39) && q0 === q1)
+          value = src.slice(a + 1, b - 1);
+        else
+          value = src.slice(a, b);
+      } else {
+        value = src.slice(a, b);
+      }
+      return { type: "Url", value, loc: s.positions ? locRange(s, tstart, tend) : null };
+    }
+    case 4 /* Hash */: {
+      s.pos++;
+      return { type: "Hash", name: src.slice(tstart + 1, tend), loc: s.positions ? locRange(s, tstart, tend) : null };
+    }
+    case 2 /* Function */: {
+      return parseFunction(s);
+    }
+    case 21 /* LeftParenthesis */: {
+      return parseParentheses(s);
+    }
+    case 18 /* Comma */: {
+      s.pos++;
+      return { type: "Operator", value: ",", loc: s.positions ? locRange(s, tstart, tend) : null };
+    }
+    case 16 /* Colon */: {
+      s.pos++;
+      return { type: "Operator", value: ":", loc: s.positions ? locRange(s, tstart, tend) : null };
+    }
+    case 9 /* Delim */: {
+      s.pos++;
+      const code = src.charCodeAt(tstart);
+      const ch = src[tstart];
+      if (isValueOperatorChar(code))
+        return { type: "Operator", value: ch, loc: s.positions ? locRange(s, tstart, tend) : null };
+      return { type: "Identifier", name: ch, loc: s.positions ? locRange(s, tstart, tend) : null };
+    }
+    case 19 /* LeftSquareBracket */: {
+      s.pos++;
+      const children = newList();
+      while (peekType(s) !== 0 /* EOF */ && peekType(s) !== 20 /* RightSquareBracket */) {
+        const inner = parseValueChild(s);
+        if (inner)
+          children.appendData(inner);
+      }
+      const endByte = s.pos < s.end ? s.ends[s.pos] : tend;
+      if (peekType(s) === 20 /* RightSquareBracket */)
+        s.pos++;
+      return { type: "Brackets", children, loc: s.positions ? locRange(s, tstart, endByte) : null };
+    }
+    case 3 /* AtKeyword */:
+    case 23 /* LeftCurlyBracket */:
+    case 24 /* RightCurlyBracket */:
+    case 22 /* RightParenthesis */:
+    case 20 /* RightSquareBracket */:
+    case 17 /* Semicolon */:
+    case 0 /* EOF */:
+    case 14 /* CDO */:
+    case 15 /* CDC */:
+    case 6 /* BadString */:
+    case 8 /* BadUrl */: {
+      s.pos++;
+      return { type: "Raw", value: src.slice(tstart, tend), loc: s.positions ? locRange(s, tstart, tend) : null };
+    }
+  }
+  s.pos++;
+  return null;
+}
+function isWhitespaceCode(c) {
+  return c === 32 || c === 9 || c === 10 || c === 12 || c === 13;
+}
+function isValueOperatorChar(code) {
+  return code === 47 || code === 43 || code === 45 || code === 42 || code === 61 || code === 62 || code === 60 || code === 126 || code === 124 || code === 36 || code === 94 || code === 33 || code === 38;
+}
+function lowerIfNeeded(source, start, end) {
+  for (let i = start;i < end; i++) {
+    const c = source.charCodeAt(i);
+    if (c >= 65 && c <= 90)
+      return source.slice(start, end).toLowerCase();
+  }
+  return source.slice(start, end);
+}
+function locRange(s, startByte, endByte) {
+  const start = s.tokenizer.locate(startByte);
+  const end = s.tokenizer.locate(endByte);
+  return {
+    source: s.filename ?? "<unknown>",
+    start: { offset: startByte, line: start.line, column: start.column },
+    end: { offset: endByte, line: end.line, column: end.column }
+  };
+}
+function parseFunction(s) {
+  const startTok = consume(s);
+  const name = lowerIfNeeded(s.source, startTok.start, startTok.end - 1);
+  const children = newList();
+  while (peekType(s) !== 0 /* EOF */ && peekType(s) !== 22 /* RightParenthesis */) {
+    const node = parseValueChild(s);
+    if (node)
+      children.appendData(node);
+  }
+  if (peekType(s) === 22 /* RightParenthesis */)
+    consume(s);
+  if (name === "url") {
+    for (let cur = children.head;cur != null; cur = cur.next) {
+      if (cur.data.type === "String")
+        return { type: "Url", value: cur.data.value, loc: loc(s, startTok, peek(s)) };
+    }
+  }
+  return { type: "Function", name, children, loc: loc(s, startTok, peek(s)) };
+}
+function parseParentheses(s) {
+  const startTok = consume(s);
+  const children = newList();
+  while (peekType(s) !== 0 /* EOF */ && peekType(s) !== 22 /* RightParenthesis */) {
+    const node = parseValueChild(s);
+    if (node)
+      children.appendData(node);
+  }
+  if (peekType(s) === 22 /* RightParenthesis */)
+    consume(s);
+  return { type: "Parentheses", children, loc: loc(s, startTok, peek(s)) };
+}
+function parseSelectorList(s) {
+  const startTok = peek(s);
+  const children = newList();
+  while (peekType(s) !== 0 /* EOF */) {
+    skipWhitespace(s);
+    if (peekType(s) === 0 /* EOF */ || peekType(s) === 23 /* LeftCurlyBracket */)
+      break;
+    const sel = parseSelector(s);
+    if (sel.children.head !== null)
+      children.appendData(sel);
+    skipWhitespace(s);
+    if (peekType(s) === 18 /* Comma */) {
+      consume(s);
+      continue;
+    }
+    break;
+  }
+  return { type: "SelectorList", children, loc: loc(s, startTok, peek(s)) };
+}
+function parseSelector(s) {
+  const startTok = peek(s);
+  const children = newList();
+  let lastWasCombinator = true;
+  while (peekType(s) !== 0 /* EOF */ && peekType(s) !== 18 /* Comma */ && peekType(s) !== 23 /* LeftCurlyBracket */) {
+    const t = peek(s);
+    if (t.type === 13 /* WhiteSpace */) {
+      consume(s);
+      if (!lastWasCombinator && peekType(s) !== 0 /* EOF */ && peekType(s) !== 18 /* Comma */ && peekType(s) !== 23 /* LeftCurlyBracket */ && !isExplicitCombinator(s) && !isColumnCombinator(s)) {
+        const c = { type: "Combinator", name: " ", loc: loc(s, t, t) };
+        children.appendData(c);
+        lastWasCombinator = true;
+      }
+      continue;
+    }
+    if (t.type === 9 /* Delim */ && s.source.charCodeAt(t.start) === 124 && s.types[s.pos + 1] === 9 /* Delim */ && s.source.charCodeAt(s.starts[s.pos + 1]) === 124) {
+      const startCol = peek(s);
+      consume(s);
+      const endCol = consume(s);
+      const c = { type: "Combinator", name: "||", loc: loc(s, startCol, endCol) };
+      children.appendData(c);
+      lastWasCombinator = true;
+      skipWhitespace(s);
+      continue;
+    }
+    if (isExplicitCombinator(s)) {
+      const ct = consume(s);
+      const ch = s.source[ct.start];
+      const c = { type: "Combinator", name: ch, loc: loc(s, ct, ct) };
+      children.appendData(c);
+      lastWasCombinator = true;
+      skipWhitespace(s);
+      continue;
+    }
+    const seg = parseSelectorSegment(s);
+    if (!seg)
+      break;
+    children.appendData(seg);
+    lastWasCombinator = false;
+  }
+  while (children.tail && children.tail.data.type === "Combinator")
+    children.remove(children.tail);
+  return { type: "Selector", children, loc: loc(s, startTok, peek(s)) };
+}
+function isExplicitCombinator(s) {
+  const t = peek(s);
+  if (t.type !== 9 /* Delim */)
+    return false;
+  const ch = s.source[t.start];
+  return ch === ">" || ch === "+" || ch === "~";
+}
+function isColumnCombinator(s) {
+  if (s.types[s.pos] !== 9 /* Delim */)
+    return false;
+  if (s.source.charCodeAt(s.starts[s.pos]) !== 124)
+    return false;
+  if (s.types[s.pos + 1] !== 9 /* Delim */)
+    return false;
+  return s.source.charCodeAt(s.starts[s.pos + 1]) === 124;
+}
+function parseSelectorSegment(s) {
+  const t = peek(s);
+  switch (t.type) {
+    case 1 /* Ident */: {
+      consume(s);
+      if (peekType(s) === 9 /* Delim */ && s.source[peek(s).start] === "|" && s.source[peek(s).start + 1] !== "=" && !(s.types[s.pos + 1] === 9 /* Delim */ && s.source.charCodeAt(s.starts[s.pos + 1]) === 124)) {
+        consume(s);
+        if (peekType(s) === 1 /* Ident */) {
+          const local = consume(s);
+          const node2 = {
+            type: "TypeSelector",
+            name: `${tokenSlice(s, t)}|${tokenSlice(s, local)}`,
+            loc: loc(s, t, local)
+          };
+          return node2;
+        }
+        if (peekType(s) === 9 /* Delim */ && s.source[peek(s).start] === "*") {
+          const star = consume(s);
+          const node2 = {
+            type: "TypeSelector",
+            name: `${tokenSlice(s, t)}|*`,
+            loc: loc(s, t, star)
+          };
+          return node2;
+        }
+      }
+      const node = { type: "TypeSelector", name: tokenSlice(s, t), loc: loc(s, t, t) };
+      return node;
+    }
+    case 11 /* Percentage */: {
+      consume(s);
+      const node = { type: "TypeSelector", name: tokenSlice(s, t), loc: loc(s, t, t) };
+      return node;
+    }
+    case 10 /* Number */: {
+      consume(s);
+      const node = { type: "TypeSelector", name: tokenSlice(s, t), loc: loc(s, t, t) };
+      return node;
+    }
+    case 9 /* Delim */: {
+      const ch = s.source[t.start];
+      if (ch === "*") {
+        consume(s);
+        const node = { type: "TypeSelector", name: "*", loc: loc(s, t, t) };
+        return node;
+      }
+      if (ch === ".") {
+        consume(s);
+        if (peekType(s) === 1 /* Ident */) {
+          const id = consume(s);
+          const node = { type: "ClassSelector", name: tokenSlice(s, id), loc: loc(s, t, id) };
+          return node;
+        }
+        return null;
+      }
+      if (ch === "&") {
+        consume(s);
+        return { type: "NestingSelector", loc: loc(s, t, t) };
+      }
+      consume(s);
+      return null;
+    }
+    case 4 /* Hash */: {
+      consume(s);
+      const node = { type: "IdSelector", name: s.source.slice(t.start + 1, t.end), loc: loc(s, t, t) };
+      return node;
+    }
+    case 16 /* Colon */: {
+      consume(s);
+      const isElement = peekType(s) === 16 /* Colon */;
+      if (isElement)
+        consume(s);
+      return parsePseudo(s, isElement, t);
+    }
+    case 19 /* LeftSquareBracket */: {
+      return parseAttribute(s);
+    }
+  }
+  return null;
+}
+function parsePseudo(s, isElement, startTok) {
+  const t = peek(s);
+  if (t.type === 1 /* Ident */) {
+    consume(s);
+    const name = lowerIfNeeded(s.source, t.start, t.end);
+    const node = isElement ? { type: "PseudoElementSelector", name, children: null, loc: loc(s, startTok, t) } : { type: "PseudoClassSelector", name, children: null, loc: loc(s, startTok, t) };
+    return node;
+  }
+  if (t.type === 2 /* Function */) {
+    consume(s);
+    const name = lowerIfNeeded(s.source, t.start, t.end - 1);
+    const children = newList();
+    const isSelectorListPseudo = !isElement && SELECTOR_LIST_PSEUDOS_PARSE.has(name);
+    if (isSelectorListPseudo) {
+      const argStart = peek(s);
+      let argEnd = argStart;
+      let depth = 1;
+      while (peekType(s) !== 0 /* EOF */ && depth > 0) {
+        if (peekType(s) === 21 /* LeftParenthesis */ || peekType(s) === 2 /* Function */)
+          depth++;
+        else if (peekType(s) === 22 /* RightParenthesis */) {
+          depth--;
+          if (depth === 0)
+            break;
+        }
+        argEnd = consume(s);
+      }
+      if (peekType(s) === 22 /* RightParenthesis */)
+        consume(s);
+      const inner = s.source.slice(argStart.start, argEnd.end).trim();
+      if (inner.length > 0) {
+        const sub = makeState(inner, { positions: false });
+        const list = parseSelectorList(sub);
+        children.appendData(list);
+      }
+    } else {
+      while (peekType(s) !== 0 /* EOF */ && peekType(s) !== 22 /* RightParenthesis */) {
+        const inner = parseValueChild(s);
+        if (inner)
+          children.appendData(inner);
+      }
+      if (peekType(s) === 22 /* RightParenthesis */)
+        consume(s);
+    }
+    if (isElement) {
+      const node2 = { type: "PseudoElementSelector", name, children, loc: loc(s, startTok, peek(s)) };
+      return node2;
+    }
+    const node = { type: "PseudoClassSelector", name, children, loc: loc(s, startTok, peek(s)) };
+    return node;
+  }
+  return null;
+}
+function parseAttribute(s) {
+  const startTok = consume(s);
+  skipWhitespace(s);
+  const nameTok = peek(s);
+  if (nameTok.type !== 1 /* Ident */)
+    return null;
+  consume(s);
+  const name = { type: "Identifier", name: tokenSlice(s, nameTok), loc: loc(s, nameTok, nameTok) };
+  skipWhitespace(s);
+  let matcher = null;
+  let value = null;
+  let flags = null;
+  const next = peek(s);
+  if (next.type === 9 /* Delim */) {
+    const ch = s.source[next.start];
+    const ch2 = s.source[next.start + 1];
+    if (ch === "=") {
+      matcher = "=";
+      consume(s);
+    } else if ((ch === "~" || ch === "|" || ch === "^" || ch === "$" || ch === "*") && ch2 === "=") {
+      consume(s);
+      const eq = peek(s);
+      if (eq.type === 9 /* Delim */ && s.source[eq.start] === "=") {
+        consume(s);
+        matcher = `${ch}=`;
+      }
+    }
+    skipWhitespace(s);
+    const v = peek(s);
+    if (v.type === 5 /* String */) {
+      consume(s);
+      const closesProperly = v.end - v.start >= 2 && s.source.charCodeAt(v.end - 1) === s.source.charCodeAt(v.start);
+      const text = decodeString(s.source, v.start + 1, closesProperly ? v.end - 1 : v.end);
+      value = { type: "String", value: text, loc: loc(s, v, v) };
+    } else if (v.type === 1 /* Ident */) {
+      consume(s);
+      value = { type: "Identifier", name: tokenSlice(s, v), loc: loc(s, v, v) };
+    }
+    skipWhitespace(s);
+    const flagTok = peek(s);
+    if (flagTok.type === 1 /* Ident */) {
+      consume(s);
+      flags = tokenSlice(s, flagTok);
+    }
+  }
+  skipWhitespace(s);
+  let endTok = peek(s);
+  if (peekType(s) === 20 /* RightSquareBracket */) {
+    endTok = consume(s);
+  }
+  return { type: "AttributeSelector", name, matcher, value, flags, loc: loc(s, startTok, endTok) };
+}
+// src/parse/walker.ts
+var SKIP = Symbol("walkSkip");
+var STOP = Symbol("walkStop");
+function newContext(root) {
+  return {
+    root,
+    stylesheet: null,
+    atrule: null,
+    atrulePrelude: null,
+    rule: null,
+    selector: null,
+    block: null,
+    declaration: null,
+    function: null
+  };
+}
+function walkImpl(root, visitor) {
+  const ctx = newContext(root);
+  const enter = typeof visitor === "function" ? visitor : visitor.enter;
+  const leave = typeof visitor === "function" ? null : visitor.leave ?? null;
+  const filter = typeof visitor === "function" ? null : visitor.visit ?? null;
+  const reverse = typeof visitor === "function" ? false : visitor.reverse ?? false;
+  function visitNode(node, item, list) {
+    let pushed = null;
+    let prev;
+    switch (node.type) {
+      case "StyleSheet":
+        pushed = "stylesheet";
+        prev = ctx.stylesheet;
+        ctx.stylesheet = node;
+        break;
+      case "Atrule":
+        pushed = "atrule";
+        prev = ctx.atrule;
+        ctx.atrule = node;
+        break;
+      case "AtrulePrelude":
+        pushed = "atrulePrelude";
+        prev = ctx.atrulePrelude;
+        ctx.atrulePrelude = node;
+        break;
+      case "Rule":
+        pushed = "rule";
+        prev = ctx.rule;
+        ctx.rule = node;
+        break;
+      case "Selector":
+        pushed = "selector";
+        prev = ctx.selector;
+        ctx.selector = node;
+        break;
+      case "Block":
+        pushed = "block";
+        prev = ctx.block;
+        ctx.block = node;
+        break;
+      case "Declaration":
+        pushed = "declaration";
+        prev = ctx.declaration;
+        ctx.declaration = node;
+        break;
+      case "Function":
+        pushed = "function";
+        prev = ctx.function;
+        ctx.function = node;
+        break;
+    }
+    let result;
+    if ((filter === null || filter === node.type) && enter) {
+      const r = enter.call(ctx, node, item, list);
+      if (r === SKIP) {
+        if (pushed)
+          ctx[pushed] = prev;
+        return;
+      }
+      if (r === STOP) {
+        if (pushed)
+          ctx[pushed] = prev;
+        return STOP;
+      }
+    }
+    result = walkChildren(node, reverse, visitNode);
+    if (result === STOP) {
+      if (pushed)
+        ctx[pushed] = prev;
+      return STOP;
+    }
+    if ((filter === null || filter === node.type) && leave) {
+      const r = leave.call(ctx, node, item, list);
+      if (r === STOP) {
+        if (pushed)
+          ctx[pushed] = prev;
+        return STOP;
+      }
+    }
+    if (pushed)
+      ctx[pushed] = prev;
+    return;
+  }
+  return visitNode(root, null, null);
+}
+var walk = Object.assign(walkImpl, { skip: SKIP, stop: STOP });
+function walkChildren(node, reverse, visitNode) {
+  if ("children" in node && node.children instanceof CssList) {
+    return walkList(node.children, reverse, visitNode);
+  }
+  if (node.type === "Rule") {
+    const r1 = visitNode(node.prelude, null, null);
+    if (r1 === STOP)
+      return STOP;
+    const r2 = visitNode(node.block, null, null);
+    if (r2 === STOP)
+      return STOP;
+    return;
+  }
+  if (node.type === "Atrule") {
+    if (node.prelude) {
+      const r = visitNode(node.prelude, null, null);
+      if (r === STOP)
+        return STOP;
+    }
+    if (node.block) {
+      const r = visitNode(node.block, null, null);
+      if (r === STOP)
+        return STOP;
+    }
+    return;
+  }
+  if (node.type === "Declaration") {
+    return visitNode(node.value, null, null);
+  }
+  if (node.type === "AttributeSelector") {
+    const r = visitNode(node.name, null, null);
+    if (r === STOP)
+      return STOP;
+    if (node.value)
+      return visitNode(node.value, null, null);
+    return;
+  }
+  return;
+}
+function walkList(list, reverse, visitNode) {
+  let stopped;
+  if (reverse) {
+    list.forEachRight((data, item, l) => {
+      if (stopped)
+        return;
+      const r = visitNode(data, item, l);
+      if (r === STOP)
+        stopped = STOP;
+    });
+  } else {
+    list.forEach((data, item, l) => {
+      if (stopped)
+        return;
+      const r = visitNode(data, item, l);
+      if (r === STOP)
+        stopped = STOP;
+    });
+  }
+  return stopped;
+}
+// src/what/index.ts
+var exports_what = {};
+__export(exports_what, {
+  stringify: () => stringify,
+  parse: () => parse2,
+  isTraversal: () => isTraversal,
+  IgnoreCaseMode: () => IgnoreCaseMode
+});
+
+// src/what/parse.ts
+var RE_NAME_STICKY = /(?:\\(?:[\dA-Fa-f]{1,6} ?|[^])|[\w\-\u00B0-\uFFFF])+/y;
+var RE_ESCAPE = /\\([\dA-Fa-f]{1,6} ?|[^])/g;
+function unescape(name) {
+  return name.replace(RE_ESCAPE, (_m, escape) => {
+    if (escape.length > 1 && /^[\dA-Fa-f]/.test(escape)) {
+      const code = Number.parseInt(escape, 16);
+      if (code >= 55296 && code <= 57343)
+        return "\uFFFD";
+      return String.fromCodePoint(code);
+    }
+    return escape;
+  });
+}
+function unescapeIfNeeded(name) {
+  return name.indexOf("\\") < 0 ? name : unescape(name);
+}
+var ATTRIBUTES_QUIRKS = new Set([
+  "accept",
+  "accept-charset",
+  "align",
+  "alink",
+  "axis",
+  "bgcolor",
+  "charset",
+  "checked",
+  "clear",
+  "codetype",
+  "color",
+  "compact",
+  "declare",
+  "defer",
+  "dir",
+  "direction",
+  "disabled",
+  "enctype",
+  "face",
+  "frame",
+  "hreflang",
+  "http-equiv",
+  "lang",
+  "language",
+  "link",
+  "media",
+  "method",
+  "multiple",
+  "nohref",
+  "noresize",
+  "noshade",
+  "nowrap",
+  "readonly",
+  "rel",
+  "rev",
+  "rules",
+  "scope",
+  "scrolling",
+  "selected",
+  "shape",
+  "target",
+  "text",
+  "type",
+  "valign",
+  "valuetype",
+  "vlink"
+]);
+function actionFromChar(ch) {
+  switch (ch) {
+    case 126:
+      return "element";
+    case 94:
+      return "start";
+    case 36:
+      return "end";
+    case 42:
+      return "any";
+    case 33:
+      return "not";
+    case 124:
+      return "hyphen";
+    default:
+      return null;
+  }
+}
+function isWsCode(c) {
+  return c === 32 || c === 9 || c === 10 || c === 13 || c === 12;
+}
+function parse2(selector, options = {}) {
+  const subselects = [];
+  const endIndex = parseSelectorImpl(subselects, selector, options, 0);
+  if (endIndex < selector.length)
+    throw new Error(`Unmatched selector: ${selector.slice(endIndex)}`);
+  return subselects;
+}
+function readName(selector, from) {
+  RE_NAME_STICKY.lastIndex = from;
+  const m = RE_NAME_STICKY.exec(selector);
+  if (!m)
+    throw new Error(`Expected name, found ${selector.slice(from)}`);
+  return { value: unescapeIfNeeded(m[0]), end: from + m[0].length };
+}
+function stripWS(selector, from) {
+  while (from < selector.length && isWsCode(selector.charCodeAt(from)))
+    from++;
+  return from;
+}
+function parseSelectorImpl(subselects, selector, options, startIndex) {
+  let tokens = [];
+  let i = stripWS(selector, startIndex);
+  const len = selector.length;
+  const xmlMode = options.xmlMode === true;
+  const lowerCaseAttrs = options.lowerCaseAttributeNames !== false && !xmlMode;
+  const lowerCaseTagsFlag = options.lowerCaseTags !== false;
+  while (i < len) {
+    const code = selector.charCodeAt(i);
+    if (isWsCode(code)) {
+      let trimmed = i + 1;
+      while (trimmed < len && isWsCode(selector.charCodeAt(trimmed)))
+        trimmed++;
+      if (tokens.length === 0)
+        return trimmed;
+      i = trimmed;
+      addTraversal(tokens, "descendant");
+      continue;
+    }
+    if (code === 62 || code === 60 || code === 126 || code === 43 || code === 124) {
+      let j = i + 1;
+      while (j < len && isWsCode(selector.charCodeAt(j)))
+        j++;
+      i = j;
+      switch (code) {
+        case 62:
+          addTraversal(tokens, "child");
+          break;
+        case 60:
+          addTraversal(tokens, "parent");
+          break;
+        case 126:
+          addTraversal(tokens, "sibling");
+          break;
+        case 43:
+          addTraversal(tokens, "adjacent");
+          break;
+        case 124:
+          if (i < len && selector.charCodeAt(i) === 124) {
+            i++;
+            i = stripWS(selector, i);
+            addTraversal(tokens, "column-combinator");
+          } else {
+            tokens.push({ type: "tag", name: "", namespace: "" });
+          }
+          break;
+      }
+      continue;
+    }
+    if (code === 44) {
+      if (tokens.length === 0)
+        throw new Error("Empty sub-selector");
+      subselects.push(tokens);
+      tokens = [];
+      i = stripWS(selector, i + 1);
+      continue;
+    }
+    if (code === 47 && selector.charCodeAt(i + 1) === 42) {
+      const end = selector.indexOf("*/", i + 2);
+      if (end < 0)
+        throw new Error("Unmatched comment");
+      i = stripWS(selector, end + 2);
+      continue;
+    }
+    if (code === 42) {
+      i++;
+      tokens.push({ type: "universal", namespace: null });
+      continue;
+    }
+    if (code === 35) {
+      const r = readName(selector, i + 1);
+      i = r.end;
+      tokens.push({
+        type: "attribute",
+        name: "id",
+        action: "equals",
+        value: r.value,
+        namespace: null,
+        ignoreCase: false
+      });
+      continue;
+    }
+    if (code === 46) {
+      const r = readName(selector, i + 1);
+      i = r.end;
+      tokens.push({
+        type: "attribute",
+        name: "class",
+        action: "element",
+        value: r.value,
+        namespace: null,
+        ignoreCase: false
+      });
+      continue;
+    }
+    if (code === 91) {
+      i = parseAttribute2(selector, i, tokens, options, xmlMode, lowerCaseAttrs);
+      continue;
+    }
+    if (code === 58) {
+      i = parsePseudo2(selector, i, tokens, options);
+      continue;
+    }
+    if (code === 124) {
+      i++;
+      const r = readName(selector, i);
+      i = r.end;
+      tokens.push({ type: "tag", name: lowerCaseTagsFlag ? r.value.toLowerCase() : r.value, namespace: "" });
+      continue;
+    }
+    {
+      const r1 = readName(selector, i);
+      i = r1.end;
+      if (i < len && selector.charCodeAt(i) === 124 && selector.charCodeAt(i + 1) !== 61) {
+        i++;
+        const r2 = readName(selector, i);
+        i = r2.end;
+        tokens.push({ type: "tag", name: lowerCaseTagsFlag ? r2.value.toLowerCase() : r2.value, namespace: r1.value });
+      } else {
+        tokens.push({ type: "tag", name: lowerCaseTagsFlag ? r1.value.toLowerCase() : r1.value, namespace: null });
+      }
+    }
+  }
+  if (tokens.length > 0)
+    subselects.push(tokens);
+  return i;
+}
+function parseAttribute2(selector, idx, tokens, options, xmlMode, lowerCaseAttrs) {
+  let i = idx + 1;
+  const len = selector.length;
+  let attribute;
+  if (selector.charCodeAt(i) === 124)
+    throw new Error("Empty namespace not supported");
+  if (selector.charCodeAt(i) === 42 && selector.charCodeAt(i + 1) === 124) {
+    i += 2;
+    const r = readName(selector, i);
+    i = r.end;
+    attribute = r.value;
+  } else {
+    const r = readName(selector, i);
+    i = r.end;
+    attribute = r.value;
+    if (selector.charCodeAt(i) === 124 && selector.charCodeAt(i + 1) !== 61) {
+      i++;
+      const r2 = readName(selector, i);
+      i = r2.end;
+      attribute = r2.value;
+    }
+  }
+  i = stripWS(selector, i);
+  let action = "exists";
+  let value = "";
+  let ignoreCase = null;
+  const opCode = selector.charCodeAt(i);
+  if (opCode === 61) {
+    action = "equals";
+    i++;
+  } else if (opCode === 33 && selector.charCodeAt(i + 1) === 61) {
+    action = "not";
+    i += 2;
+  } else {
+    const a = actionFromChar(opCode);
+    if (a !== null && selector.charCodeAt(i + 1) === 61) {
+      action = a;
+      i += 2;
+    }
+  }
+  if (action !== "exists") {
+    i = stripWS(selector, i);
+    const q = selector.charCodeAt(i);
+    if (q === 34 || q === 39) {
+      const end = findEndOfString(selector, i + 1, q);
+      value = unescapeIfNeeded(selector.slice(i + 1, end));
+      i = end + 1;
+    } else {
+      const r = readName(selector, i);
+      value = r.value;
+      i = r.end;
+    }
+    i = stripWS(selector, i);
+    const flag = selector.charCodeAt(i);
+    if (flag === 105 || flag === 73) {
+      ignoreCase = true;
+      i++;
+    } else if (flag === 115 || flag === 83) {
+      ignoreCase = false;
+      i++;
+    }
+  }
+  if (selector.charCodeAt(i) !== 93)
+    throw new Error("Expected ]");
+  i++;
+  if (ignoreCase === null && !xmlMode && ATTRIBUTES_QUIRKS.has(attribute.toLowerCase()))
+    ignoreCase = "quirks";
+  tokens.push({
+    type: "attribute",
+    name: lowerCaseAttrs ? attribute.toLowerCase() : attribute,
+    action,
+    value,
+    namespace: null,
+    ignoreCase
+  });
+  return i;
+}
+function parsePseudo2(selector, idx, tokens, options) {
+  if (selector.charCodeAt(idx + 1) === 58) {
+    let i2 = idx + 2;
+    const r2 = readName(selector, i2);
+    i2 = r2.end;
+    const name2 = r2.value.toLowerCase();
+    let data = null;
+    if (selector.charCodeAt(i2) === 40) {
+      const end = findClose(selector, i2);
+      data = selector.slice(i2 + 1, end).trim();
+      i2 = end + 1;
+    }
+    tokens.push({ type: "pseudo-element", name: name2, data });
+    return i2;
+  }
+  let i = idx + 1;
+  const r = readName(selector, i);
+  i = r.end;
+  const name = r.value.toLowerCase();
+  if (selector.charCodeAt(i) === 40) {
+    const end = findClose(selector, i);
+    const inner = selector.slice(i + 1, end);
+    i = end + 1;
+    if (name === "is" || name === "not" || name === "where" || name === "has" || name === "matches" || name === "-moz-any" || name === "-webkit-any") {
+      const sub = [];
+      parseSelectorImpl(sub, inner.trim(), options, 0);
+      tokens.push({ type: "pseudo", name, data: sub });
+    } else {
+      tokens.push({ type: "pseudo", name, data: inner.trim() });
+    }
+  } else {
+    tokens.push({ type: "pseudo", name, data: null });
+  }
+  return i;
+}
+function addTraversal(tokens, type) {
+  if (tokens.length > 0 && tokens[tokens.length - 1].type === "descendant" && type !== "descendant")
+    tokens.pop();
+  if (tokens.length > 0 && tokens[tokens.length - 1].type === type)
+    return;
+  tokens.push({ type });
+}
+function findEndOfString(selector, start, qCode) {
+  let i = start;
+  const len = selector.length;
+  while (i < len) {
+    const c = selector.charCodeAt(i);
+    if (c === 92) {
+      i += 2;
+      continue;
+    }
+    if (c === qCode)
+      return i;
+    i++;
+  }
+  throw new Error("Unterminated string");
+}
+function findClose(selector, openParen) {
+  let depth = 1;
+  let i = openParen + 1;
+  const len = selector.length;
+  while (i < len) {
+    const c = selector.charCodeAt(i);
+    if (c === 92) {
+      i += 2;
+      continue;
+    }
+    if (c === 34 || c === 39) {
+      i = findEndOfString(selector, i + 1, c) + 1;
+      continue;
+    }
+    if (c === 40)
+      depth++;
+    else if (c === 41) {
+      depth--;
+      if (depth === 0)
+        return i;
+    }
+    i++;
+  }
+  throw new Error("Unterminated parenthesis");
+}
+// src/what/stringify.ts
+var COMBINATORS = {
+  child: " > ",
+  parent: " < ",
+  sibling: " ~ ",
+  adjacent: " + ",
+  descendant: " ",
+  "column-combinator": " || "
+};
+function stringify(selector) {
+  return selector.map(stringifySegments).join(", ");
+}
+function stringifySegments(tokens) {
+  return tokens.map((t, i) => stringifyOne(t, tokens[i - 1])).join("");
+}
+function stringifyOne(token, _prev) {
+  switch (token.type) {
+    case "tag":
+      return `${nsPrefix(token.namespace)}${escapeIdent(token.name)}`;
+    case "universal":
+      return `${nsPrefix(token.namespace)}*`;
+    case "attribute": {
+      if (token.name === "id" && token.action === "equals" && !token.ignoreCase && !token.namespace)
+        return `#${escapeIdent(token.value)}`;
+      if (token.name === "class" && token.action === "element" && !token.ignoreCase && !token.namespace)
+        return `.${escapeIdent(token.value)}`;
+      let out = `[${nsPrefix(token.namespace)}${escapeIdent(token.name)}`;
+      if (token.action !== "exists") {
+        const op = ACTION_OP[token.action] ?? "=";
+        out += op;
+        out += `"${token.value.replace(/"/g, "\\\"")}"`;
+        if (token.ignoreCase === true)
+          out += " i";
+        else if (token.ignoreCase === false)
+          out += " s";
+      }
+      out += "]";
+      return out;
+    }
+    case "pseudo":
+      if (token.data === null)
+        return `:${token.name}`;
+      if (typeof token.data === "string")
+        return `:${token.name}(${token.data})`;
+      return `:${token.name}(${stringify(token.data)})`;
+    case "pseudo-element":
+      return token.data === null ? `::${token.name}` : `::${token.name}(${token.data})`;
+    case "descendant":
+    case "child":
+    case "parent":
+    case "sibling":
+    case "adjacent":
+    case "column-combinator":
+      return COMBINATORS[token.type] ?? " ";
+  }
+  return "";
+}
+var ACTION_OP = {
+  equals: "=",
+  element: "~=",
+  start: "^=",
+  end: "$=",
+  any: "*=",
+  not: "!=",
+  hyphen: "|="
+};
+function nsPrefix(ns) {
+  if (ns === null)
+    return "";
+  if (ns === "")
+    return "|";
+  return `${escapeIdent(ns)}|`;
+}
+var RE_INVALID_ID_CHAR = /[^\w\u00B0-\uFFFF-]/g;
+function escapeIdent(name) {
+  if (name === "")
+    return "";
+  return name.replace(RE_INVALID_ID_CHAR, (m) => `\\${m}`);
+}
+// src/what/traversal.ts
+var TRAVERSAL_TYPES = new Set(["adjacent", "child", "descendant", "parent", "sibling", "column-combinator"]);
+function isTraversal(token) {
+  return TRAVERSAL_TYPES.has(token.type);
+}
+// src/what/types.ts
+var IgnoreCaseMode = {
+  Unknown: null,
+  QuirksMode: "quirks",
+  IgnoreCase: true,
+  CaseSensitive: false
+};
+// src/optimize/index.ts
+var exports_optimize = {};
+__export(exports_optimize, {
+  syntax: () => syntax,
+  specificityToString: () => specificityToString,
+  specificity: () => specificity,
+  removeComments: () => removeComments,
+  minifyBlock: () => minifyBlock,
+  minify: () => minify,
+  dedupeDeclarations: () => dedupeDeclarations,
+  compressTree: () => compressTree
+});
+
+// src/optimize/clean/comment.ts
+function removeComments(ast, options = {}) {
+  const exclamation = options.exclamation ?? false;
+  let firstSeen = false;
+  walk(ast, (node, item, list) => {
+    if (node.type !== "Comment")
+      return;
+    const isExclamation = node.value.startsWith("!");
+    if (exclamation === true && isExclamation)
+      return;
+    if (exclamation === "first-exclamation" && isExclamation && !firstSeen) {
+      firstSeen = true;
+      return;
+    }
+    if (item && list)
+      list.remove(item);
+  });
+}
+// src/optimize/clean/declaration.ts
+function dedupeDeclarations(ast) {
+  walk(ast, (node) => {
+    if (node.type !== "Block" && node.type !== "DeclarationList")
+      return;
+    if (!("children" in node) || !node.children)
+      return;
+    const list = node.children;
+    let head = list.head;
+    if (head == null || head.next == null)
+      return;
+    let declCount = 0;
+    for (let it = head;it != null; it = it.next) {
+      if (it.data.type === "Declaration") {
+        declCount++;
+        if (declCount >= 2)
+          break;
+      }
+    }
+    if (declCount < 2)
+      return;
+    const seen = new Map;
+    const toRemove = [];
+    for (let item = head;item != null; item = item.next) {
+      const data = item.data;
+      if (data.type !== "Declaration")
+        continue;
+      const key = data.property;
+      const prev = seen.get(key);
+      if (prev) {
+        const prevImp = !!prev.decl.important;
+        const curImp = !!data.important;
+        if (curImp || prevImp === curImp) {
+          toRemove.push(prev.item);
+          seen.set(key, { item, decl: data });
+        } else {
+          toRemove.push(item);
+        }
+      } else {
+        seen.set(key, { item, decl: data });
+      }
+    }
+    for (const it of toRemove)
+      list.remove(it);
+  });
+}
+// src/optimize/compress/color.ts
+var NAMED_TO_HEX = {
+  black: "#000",
+  fuchsia: "#f0f",
+  white: "#fff",
+  red: "#f00",
+  cyan: "#0ff",
+  blue: "#00f",
+  yellow: "#ff0",
+  magenta: "#f0f",
+  lime: "#0f0",
+  silver: "#c0c0c0",
+  gray: "#808080",
+  maroon: "#800000",
+  olive: "#808000",
+  green: "#008000",
+  purple: "#800080",
+  teal: "#008080",
+  navy: "#000080"
+};
+var HEX_TO_SHORT_NAME = {
+  "#f00": "red",
+  "#ff0000": "red",
+  "#000080": "navy",
+  "#008080": "teal"
+};
+function shortenHex(hex) {
+  if (!hex.startsWith("#"))
+    return hex;
+  const body = hex.slice(1);
+  if (body.length === 6) {
+    if (body[0] === body[1] && body[2] === body[3] && body[4] === body[5])
+      return `#${body[0]}${body[2]}${body[4]}`;
+  }
+  if (body.length === 8) {
+    if (body[0] === body[1] && body[2] === body[3] && body[4] === body[5] && body[6] === body[7])
+      return `#${body[0]}${body[2]}${body[4]}${body[6]}`;
+  }
+  return hex;
+}
+function colorNameToHex(name) {
+  const lower = name.toLowerCase();
+  return NAMED_TO_HEX[lower] ?? null;
+}
+function hexToShortName(hex) {
+  const lower = hex.toLowerCase();
+  return HEX_TO_SHORT_NAME[lower] ?? null;
+}
+function rgbToHex(r, g, b) {
+  const hex = (r << 16 | g << 8 | b).toString(16).padStart(6, "0");
+  return shortenHex(`#${hex}`);
+}
+var RGB_RE = /^rgba?\(\s*([+-]?\d*\.?\d+%?)\s*[,\s]\s*([+-]?\d*\.?\d+%?)\s*[,\s]\s*([+-]?\d*\.?\d+%?)\s*(?:[,/]\s*([+-]?\d*\.?\d+%?)\s*)?\)$/;
+function compressRgbToHex(value) {
+  const m = RGB_RE.exec(value.trim());
+  if (!m)
+    return value;
+  const r = parseChannel(m[1]);
+  const g = parseChannel(m[2]);
+  const b = parseChannel(m[3]);
+  if (m[4] !== undefined && !isAlphaOne(m[4])) {
+    return value;
+  }
+  return rgbToHex(r, g, b);
+}
+function isAlphaOne(s) {
+  if (s.endsWith("%"))
+    return Number.parseFloat(s) >= 100;
+  return Number.parseFloat(s) >= 1;
+}
+function parseChannel(s) {
+  if (s.endsWith("%"))
+    return Math.max(0, Math.min(255, Math.round(Number.parseFloat(s) * 2.55)));
+  return Math.max(0, Math.min(255, Math.round(Number.parseFloat(s))));
+}
+
+// src/optimize/compress/number.ts
+var ZERO_UNITS = new Set([
+  "px",
+  "pt",
+  "pc",
+  "in",
+  "cm",
+  "mm",
+  "q",
+  "em",
+  "rem",
+  "ex",
+  "ch",
+  "cap",
+  "ic",
+  "lh",
+  "rlh",
+  "vw",
+  "vh",
+  "vi",
+  "vb",
+  "vmin",
+  "vmax",
+  "svw",
+  "svh",
+  "svi",
+  "svb",
+  "svmin",
+  "svmax",
+  "lvw",
+  "lvh",
+  "lvi",
+  "lvb",
+  "lvmin",
+  "lvmax",
+  "dvw",
+  "dvh",
+  "dvi",
+  "dvb",
+  "dvmin",
+  "dvmax",
+  "cqw",
+  "cqh",
+  "cqi",
+  "cqb",
+  "cqmin",
+  "cqmax"
+]);
+function compressNumber(value) {
+  if (value.charCodeAt(0) === 43)
+    value = value.slice(1);
+  if (value.includes(".")) {
+    let v = value.replace(/(\.\d*?)0+($|[eE])/, "$1$2");
+    v = v.replace(/\.($|[eE])/, "$1");
+    value = v;
+  }
+  if (value.startsWith("0.") && value.length > 2)
+    value = value.slice(1);
+  else if (value.startsWith("-0.") && value.length > 3)
+    value = `-${value.slice(2)}`;
+  if (value === "-0" || value === "-.0" || value === "-0.0")
+    value = "0";
+  return value;
+}
+function compressDimension(value, unit) {
+  const compressed = compressNumber(value);
+  if ((compressed === "0" || compressed === "-0") && ZERO_UNITS.has(unit.toLowerCase()))
+    return { value: "0", unit: "" };
+  return { value: compressed, unit };
+}
+function compressPercentage(value) {
+  const compressed = compressNumber(value);
+  return compressed;
+}
+function roundNumberString(value, precision) {
+  const n = Number.parseFloat(value);
+  if (!Number.isFinite(n))
+    return value;
+  const p = precision < 0 ? 0 : precision;
+  return n.toFixed(p);
+}
+
+// src/optimize/compress/index.ts
+var COLOR_PROPERTIES = new Set([
+  "color",
+  "background",
+  "background-color",
+  "border",
+  "border-color",
+  "border-top",
+  "border-top-color",
+  "border-right",
+  "border-right-color",
+  "border-bottom",
+  "border-bottom-color",
+  "border-left",
+  "border-left-color",
+  "border-block",
+  "border-block-color",
+  "border-block-start-color",
+  "border-block-end-color",
+  "border-inline",
+  "border-inline-color",
+  "border-inline-start-color",
+  "border-inline-end-color",
+  "outline",
+  "outline-color",
+  "caret-color",
+  "fill",
+  "stroke",
+  "flood-color",
+  "lighting-color",
+  "stop-color",
+  "column-rule",
+  "column-rule-color",
+  "text-decoration",
+  "text-decoration-color",
+  "text-emphasis",
+  "text-emphasis-color",
+  "text-shadow",
+  "box-shadow",
+  "accent-color",
+  "scrollbar-color"
+]);
+function isCompactableOperator(node) {
+  if (!node || node.type !== "Operator")
+    return false;
+  const v = node.value;
+  return v === ":" || v === "," || v === "/";
+}
+function compactContainerWhitespace(node) {
+  const list = node.children;
+  if (!list)
+    return;
+  while (list.head && list.head.data.type === "WhiteSpace")
+    list.remove(list.head);
+  while (list.tail && list.tail.data.type === "WhiteSpace")
+    list.remove(list.tail);
+  let cur = list.head;
+  while (cur) {
+    const nxt = cur.next;
+    if (cur.data.type === "WhiteSpace") {
+      const prevIsOp = cur.prev && isCompactableOperator(cur.prev.data);
+      const nextIsOp = nxt && isCompactableOperator(nxt.data);
+      if (prevIsOp || nextIsOp)
+        list.remove(cur);
+    }
+    cur = nxt;
+  }
+}
+function compressTree(ast, options = {}) {
+  const fp = options.floatPrecision ?? null;
+  const round = fp === null ? null : (s) => roundNumberString(s, fp);
+  walk(ast, {
+    enter(node, item, list) {
+      switch (node.type) {
+        case "Number": {
+          const v = round ? round(node.value) : node.value;
+          node.value = compressNumber(v);
+          return;
+        }
+        case "Percentage": {
+          const v = round ? round(node.value) : node.value;
+          node.value = compressPercentage(v);
+          return;
+        }
+        case "Dimension": {
+          const v = round ? round(node.value) : node.value;
+          const c = compressDimension(v, node.unit);
+          node.value = c.value;
+          node.unit = c.unit;
+          return;
+        }
+        case "Hash": {
+          const newName = shortenHex(`#${node.name}`).slice(1);
+          node.name = newName;
+          if (item && list && this.declaration && COLOR_PROPERTIES.has(this.declaration.property.toLowerCase())) {
+            const short = hexToShortName(`#${newName}`);
+            if (short && short.length < newName.length + 1) {
+              const ident = { type: "Identifier", name: short, loc: node.loc };
+              list.replace(item, list.createItem(ident));
+            }
+          }
+          return;
+        }
+        case "Identifier": {
+          if (!item || !list || !this.declaration)
+            return;
+          if (!COLOR_PROPERTIES.has(this.declaration.property.toLowerCase()))
+            return;
+          const hex = colorNameToHex(node.name);
+          if (hex && hex.length < node.name.length) {
+            const hashNode = { type: "Hash", name: hex.slice(1), loc: node.loc };
+            list.replace(item, list.createItem(hashNode));
+          }
+          return;
+        }
+        case "Url":
+          return;
+        case "Function": {
+          const lname = node.name.toLowerCase();
+          if ((lname === "rgb" || lname === "rgba") && item && list)
+            node.__rgbReplaceCandidate = true;
+        }
+      }
+    },
+    leave(node, item, list) {
+      if (node.type === "Parentheses" || node.type === "Function" || node.type === "Value")
+        compactContainerWhitespace(node);
+      if (node.type === "Function" && node.__rgbReplaceCandidate && item && list) {
+        const text = generate(node);
+        const replacement = compressRgbToHex(text);
+        if (replacement !== text && replacement.startsWith("#")) {
+          const hashNode = { type: "Hash", name: replacement.slice(1), loc: node.loc };
+          list.replace(item, list.createItem(hashNode));
+        }
+      }
+    }
+  });
+}
+// src/optimize/minify.ts
+function minify(source, options = {}) {
+  const ast = parse(source, { context: "stylesheet" });
+  return runPipeline(ast, options);
+}
+function minifyBlock(source, options = {}) {
+  const ast = parse(source, { context: "declarationList" });
+  return runPipeline(ast, options);
+}
+function runPipeline(ast, options) {
+  if (options.comments === false) {
+    removeComments(ast, { exclamation: false });
+  } else if (options.comments === "first-exclamation") {
+    removeComments(ast, { exclamation: "first-exclamation" });
+  } else {
+    removeComments(ast, { exclamation: true });
+  }
+  compressTree(ast, { floatPrecision: options.floatPrecision ?? null });
+  dedupeDeclarations(ast);
+  return { css: generate(ast), ast };
+}
+// src/optimize/specificity.ts
+function specificity(input) {
+  const result = [0, 0, 0];
+  if (typeof input === "string") {
+    const ast = parse2(input);
+    visitWhat(ast, result);
+    return result;
+  }
+  if (Array.isArray(input)) {
+    if (input.length === 0)
+      return result;
+    if (Array.isArray(input[0]))
+      visitWhat(input, result);
+    else
+      visitWhatGroup(input, result);
+    return result;
+  }
+  visit(input, result);
+  return result;
+}
+function visit(node, result) {
+  switch (node.type) {
+    case "IdSelector":
+      result[0]++;
+      return;
+    case "ClassSelector":
+    case "AttributeSelector":
+      result[1]++;
+      return;
+    case "TypeSelector":
+      if (node.name !== "*")
+        result[2]++;
+      return;
+    case "PseudoClassSelector": {
+      const name = node.name.toLowerCase();
+      if (name === "is" || name === "matches" || name === "-moz-any" || name === "-webkit-any" || name === "not" || name === "has") {
+        if (node.children) {
+          const selectors = [];
+          for (const inner of node.children) {
+            if (inner.type === "SelectorList" && "children" in inner && inner.children) {
+              for (const s of inner.children)
+                selectors.push(s);
+            } else if (inner.type === "Selector") {
+              selectors.push(inner);
+            }
+          }
+          let max = [0, 0, 0];
+          for (const sel of selectors) {
+            const s = specificity(sel);
+            if (compareSpec(s, max) > 0)
+              max = s;
+          }
+          result[0] += max[0];
+          result[1] += max[1];
+          result[2] += max[2];
+        }
+        return;
+      }
+      if (name === "where")
+        return;
+      result[1]++;
+      return;
+    }
+    case "PseudoElementSelector":
+      result[2]++;
+      return;
+    case "Selector":
+    case "SelectorList":
+    case "AtrulePrelude":
+      if ("children" in node && node.children) {
+        for (const child of node.children)
+          visit(child, result);
+      }
+      return;
+    case "NestingSelector":
+      return;
+  }
+}
+function visitWhat(groups, result) {
+  for (const g of groups)
+    visitWhatGroup(g, result);
+}
+function visitWhatGroup(tokens, result) {
+  for (const t of tokens) {
+    switch (t.type) {
+      case "tag":
+        if (t.name !== "*")
+          result[2]++;
+        break;
+      case "attribute":
+        if (t.name === "id" && t.action === "equals")
+          result[0]++;
+        else
+          result[1]++;
+        break;
+      case "pseudo": {
+        const name = t.name.toLowerCase();
+        if (name === "is" || name === "matches" || name === "not" || name === "has" || name === "-moz-any" || name === "-webkit-any") {
+          if (Array.isArray(t.data)) {
+            let max = [0, 0, 0];
+            for (const inner of t.data) {
+              const s = [0, 0, 0];
+              visitWhatGroup(inner, s);
+              if (compareSpec(s, max) > 0)
+                max = s;
+            }
+            result[0] += max[0];
+            result[1] += max[1];
+            result[2] += max[2];
+          }
+          break;
+        }
+        if (name === "where")
+          break;
+        result[1]++;
+        break;
+      }
+      case "pseudo-element":
+        result[2]++;
+        break;
+    }
+  }
+}
+function compareSpec(a, b) {
+  for (let i = 0;i < 3; i++) {
+    if (a[i] !== b[i])
+      return a[i] - b[i];
+  }
+  return 0;
+}
+function specificityToString(s) {
+  return s.join(",");
+}
+// src/optimize/index.ts
+var syntax = {
+  specificity
+};
+export {
+  syntax,
+  specificityToString,
+  specificity,
+  removeComments,
+  minifyBlock,
+  minify,
+  dedupeDeclarations,
+  compressTree
+};