@pathscale/rsbuild-plugin-ui-css-purge 0.9.10 → 0.9.11

package/dist/postbuild-purge.js

@@ -0,0 +1,1604 @@
+#!/usr/bin/env bun
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = import.meta.require;
+
+// node_modules/detect-libc/lib/process.js
+var require_process = __commonJS((exports, module) => {
+  var isLinux = () => process.platform === "linux";
+  var report = null;
+  var getReport = () => {
+    if (!report) {
+      if (isLinux() && process.report) {
+        const orig = process.report.excludeNetwork;
+        process.report.excludeNetwork = true;
+        report = process.report.getReport();
+        process.report.excludeNetwork = orig;
+      } else {
+        report = {};
+      }
+    }
+    return report;
+  };
+  module.exports = { isLinux, getReport };
+});
+
+// node_modules/detect-libc/lib/filesystem.js
+var require_filesystem = __commonJS((exports, module) => {
+  var fs = __require("fs");
+  var LDD_PATH = "/usr/bin/ldd";
+  var SELF_PATH = "/proc/self/exe";
+  var MAX_LENGTH = 2048;
+  var readFileSync = (path) => {
+    const fd = fs.openSync(path, "r");
+    const buffer = Buffer.alloc(MAX_LENGTH);
+    const bytesRead = fs.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+    fs.close(fd, () => {});
+    return buffer.subarray(0, bytesRead);
+  };
+  var readFile = (path) => new Promise((resolve, reject) => {
+    fs.open(path, "r", (err, fd) => {
+      if (err) {
+        reject(err);
+      } else {
+        const buffer = Buffer.alloc(MAX_LENGTH);
+        fs.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+          resolve(buffer.subarray(0, bytesRead));
+          fs.close(fd, () => {});
+        });
+      }
+    });
+  });
+  module.exports = {
+    LDD_PATH,
+    SELF_PATH,
+    readFileSync,
+    readFile
+  };
+});
+
+// node_modules/detect-libc/lib/elf.js
+var require_elf = __commonJS((exports, module) => {
+  var interpreterPath = (elf) => {
+    if (elf.length < 64) {
+      return null;
+    }
+    if (elf.readUInt32BE(0) !== 2135247942) {
+      return null;
+    }
+    if (elf.readUInt8(4) !== 2) {
+      return null;
+    }
+    if (elf.readUInt8(5) !== 1) {
+      return null;
+    }
+    const offset = elf.readUInt32LE(32);
+    const size = elf.readUInt16LE(54);
+    const count = elf.readUInt16LE(56);
+    for (let i = 0;i < count; i++) {
+      const headerOffset = offset + i * size;
+      const type = elf.readUInt32LE(headerOffset);
+      if (type === 3) {
+        const fileOffset = elf.readUInt32LE(headerOffset + 8);
+        const fileSize = elf.readUInt32LE(headerOffset + 32);
+        return elf.subarray(fileOffset, fileOffset + fileSize).toString().replace(/\0.*$/g, "");
+      }
+    }
+    return null;
+  };
+  module.exports = {
+    interpreterPath
+  };
+});
+
+// node_modules/detect-libc/lib/detect-libc.js
+var require_detect_libc = __commonJS((exports, module) => {
+  var childProcess = __require("child_process");
+  var { isLinux, getReport } = require_process();
+  var { LDD_PATH, SELF_PATH, readFile, readFileSync } = require_filesystem();
+  var { interpreterPath } = require_elf();
+  var cachedFamilyInterpreter;
+  var cachedFamilyFilesystem;
+  var cachedVersionFilesystem;
+  var command = "getconf GNU_LIBC_VERSION 2>&1 || true; ldd --version 2>&1 || true";
+  var commandOut = "";
+  var safeCommand = () => {
+    if (!commandOut) {
+      return new Promise((resolve) => {
+        childProcess.exec(command, (err, out) => {
+          commandOut = err ? " " : out;
+          resolve(commandOut);
+        });
+      });
+    }
+    return commandOut;
+  };
+  var safeCommandSync = () => {
+    if (!commandOut) {
+      try {
+        commandOut = childProcess.execSync(command, { encoding: "utf8" });
+      } catch (_err) {
+        commandOut = " ";
+      }
+    }
+    return commandOut;
+  };
+  var GLIBC = "glibc";
+  var RE_GLIBC_VERSION = /LIBC[a-z0-9 \-).]*?(\d+\.\d+)/i;
+  var MUSL = "musl";
+  var isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
+  var familyFromReport = () => {
+    const report = getReport();
+    if (report.header && report.header.glibcVersionRuntime) {
+      return GLIBC;
+    }
+    if (Array.isArray(report.sharedObjects)) {
+      if (report.sharedObjects.some(isFileMusl)) {
+        return MUSL;
+      }
+    }
+    return null;
+  };
+  var familyFromCommand = (out) => {
+    const [getconf, ldd1] = out.split(/[\r\n]+/);
+    if (getconf && getconf.includes(GLIBC)) {
+      return GLIBC;
+    }
+    if (ldd1 && ldd1.includes(MUSL)) {
+      return MUSL;
+    }
+    return null;
+  };
+  var familyFromInterpreterPath = (path) => {
+    if (path) {
+      if (path.includes("/ld-musl-")) {
+        return MUSL;
+      } else if (path.includes("/ld-linux-")) {
+        return GLIBC;
+      }
+    }
+    return null;
+  };
+  var getFamilyFromLddContent = (content) => {
+    content = content.toString();
+    if (content.includes("musl")) {
+      return MUSL;
+    }
+    if (content.includes("GNU C Library")) {
+      return GLIBC;
+    }
+    return null;
+  };
+  var familyFromFilesystem = async () => {
+    if (cachedFamilyFilesystem !== undefined) {
+      return cachedFamilyFilesystem;
+    }
+    cachedFamilyFilesystem = null;
+    try {
+      const lddContent = await readFile(LDD_PATH);
+      cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
+    } catch (e) {}
+    return cachedFamilyFilesystem;
+  };
+  var familyFromFilesystemSync = () => {
+    if (cachedFamilyFilesystem !== undefined) {
+      return cachedFamilyFilesystem;
+    }
+    cachedFamilyFilesystem = null;
+    try {
+      const lddContent = readFileSync(LDD_PATH);
+      cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
+    } catch (e) {}
+    return cachedFamilyFilesystem;
+  };
+  var familyFromInterpreter = async () => {
+    if (cachedFamilyInterpreter !== undefined) {
+      return cachedFamilyInterpreter;
+    }
+    cachedFamilyInterpreter = null;
+    try {
+      const selfContent = await readFile(SELF_PATH);
+      const path = interpreterPath(selfContent);
+      cachedFamilyInterpreter = familyFromInterpreterPath(path);
+    } catch (e) {}
+    return cachedFamilyInterpreter;
+  };
+  var familyFromInterpreterSync = () => {
+    if (cachedFamilyInterpreter !== undefined) {
+      return cachedFamilyInterpreter;
+    }
+    cachedFamilyInterpreter = null;
+    try {
+      const selfContent = readFileSync(SELF_PATH);
+      const path = interpreterPath(selfContent);
+      cachedFamilyInterpreter = familyFromInterpreterPath(path);
+    } catch (e) {}
+    return cachedFamilyInterpreter;
+  };
+  var family = async () => {
+    let family2 = null;
+    if (isLinux()) {
+      family2 = await familyFromInterpreter();
+      if (!family2) {
+        family2 = await familyFromFilesystem();
+        if (!family2) {
+          family2 = familyFromReport();
+        }
+        if (!family2) {
+          const out = await safeCommand();
+          family2 = familyFromCommand(out);
+        }
+      }
+    }
+    return family2;
+  };
+  var familySync = () => {
+    let family2 = null;
+    if (isLinux()) {
+      family2 = familyFromInterpreterSync();
+      if (!family2) {
+        family2 = familyFromFilesystemSync();
+        if (!family2) {
+          family2 = familyFromReport();
+        }
+        if (!family2) {
+          const out = safeCommandSync();
+          family2 = familyFromCommand(out);
+        }
+      }
+    }
+    return family2;
+  };
+  var isNonGlibcLinux = async () => isLinux() && await family() !== GLIBC;
+  var isNonGlibcLinuxSync = () => isLinux() && familySync() !== GLIBC;
+  var versionFromFilesystem = async () => {
+    if (cachedVersionFilesystem !== undefined) {
+      return cachedVersionFilesystem;
+    }
+    cachedVersionFilesystem = null;
+    try {
+      const lddContent = await readFile(LDD_PATH);
+      const versionMatch = lddContent.match(RE_GLIBC_VERSION);
+      if (versionMatch) {
+        cachedVersionFilesystem = versionMatch[1];
+      }
+    } catch (e) {}
+    return cachedVersionFilesystem;
+  };
+  var versionFromFilesystemSync = () => {
+    if (cachedVersionFilesystem !== undefined) {
+      return cachedVersionFilesystem;
+    }
+    cachedVersionFilesystem = null;
+    try {
+      const lddContent = readFileSync(LDD_PATH);
+      const versionMatch = lddContent.match(RE_GLIBC_VERSION);
+      if (versionMatch) {
+        cachedVersionFilesystem = versionMatch[1];
+      }
+    } catch (e) {}
+    return cachedVersionFilesystem;
+  };
+  var versionFromReport = () => {
+    const report = getReport();
+    if (report.header && report.header.glibcVersionRuntime) {
+      return report.header.glibcVersionRuntime;
+    }
+    return null;
+  };
+  var versionSuffix = (s) => s.trim().split(/\s+/)[1];
+  var versionFromCommand = (out) => {
+    const [getconf, ldd1, ldd2] = out.split(/[\r\n]+/);
+    if (getconf && getconf.includes(GLIBC)) {
+      return versionSuffix(getconf);
+    }
+    if (ldd1 && ldd2 && ldd1.includes(MUSL)) {
+      return versionSuffix(ldd2);
+    }
+    return null;
+  };
+  var version = async () => {
+    let version2 = null;
+    if (isLinux()) {
+      version2 = await versionFromFilesystem();
+      if (!version2) {
+        version2 = versionFromReport();
+      }
+      if (!version2) {
+        const out = await safeCommand();
+        version2 = versionFromCommand(out);
+      }
+    }
+    return version2;
+  };
+  var versionSync = () => {
+    let version2 = null;
+    if (isLinux()) {
+      version2 = versionFromFilesystemSync();
+      if (!version2) {
+        version2 = versionFromReport();
+      }
+      if (!version2) {
+        const out = safeCommandSync();
+        version2 = versionFromCommand(out);
+      }
+    }
+    return version2;
+  };
+  module.exports = {
+    GLIBC,
+    MUSL,
+    family,
+    familySync,
+    isNonGlibcLinux,
+    isNonGlibcLinuxSync,
+    version,
+    versionSync
+  };
+});
+
+// node_modules/lightningcss/node/browserslistToTargets.js
+var require_browserslistToTargets = __commonJS((exports, module) => {
+  var BROWSER_MAPPING = {
+    and_chr: "chrome",
+    and_ff: "firefox",
+    ie_mob: "ie",
+    op_mob: "opera",
+    and_qq: null,
+    and_uc: null,
+    baidu: null,
+    bb: null,
+    kaios: null,
+    op_mini: null
+  };
+  function browserslistToTargets(browserslist) {
+    let targets = {};
+    for (let browser of browserslist) {
+      let [name, v] = browser.split(" ");
+      if (BROWSER_MAPPING[name] === null) {
+        continue;
+      }
+      let version = parseVersion(v);
+      if (version == null) {
+        continue;
+      }
+      if (targets[name] == null || version < targets[name]) {
+        targets[name] = version;
+      }
+    }
+    return targets;
+  }
+  function parseVersion(version) {
+    let [major, minor = 0, patch = 0] = version.split("-")[0].split(".").map((v) => parseInt(v, 10));
+    if (isNaN(major) || isNaN(minor) || isNaN(patch)) {
+      return null;
+    }
+    return major << 16 | minor << 8 | patch;
+  }
+  module.exports = browserslistToTargets;
+});
+
+// node_modules/lightningcss/node/composeVisitors.js
+var require_composeVisitors = __commonJS((exports, module) => {
+  function composeVisitors(visitors) {
+    if (visitors.length === 1) {
+      return visitors[0];
+    }
+    if (visitors.some((v) => typeof v === "function")) {
+      return (opts) => {
+        let v = visitors.map((v2) => typeof v2 === "function" ? v2(opts) : v2);
+        return composeVisitors(v);
+      };
+    }
+    let res = {};
+    composeSimpleVisitors(res, visitors, "StyleSheet");
+    composeSimpleVisitors(res, visitors, "StyleSheetExit");
+    composeObjectVisitors(res, visitors, "Rule", ruleVisitor, wrapCustomAndUnknownAtRule);
+    composeObjectVisitors(res, visitors, "RuleExit", ruleVisitor, wrapCustomAndUnknownAtRule);
+    composeObjectVisitors(res, visitors, "Declaration", declarationVisitor, wrapCustomProperty);
+    composeObjectVisitors(res, visitors, "DeclarationExit", declarationVisitor, wrapCustomProperty);
+    composeSimpleVisitors(res, visitors, "Url");
+    composeSimpleVisitors(res, visitors, "Color");
+    composeSimpleVisitors(res, visitors, "Image");
+    composeSimpleVisitors(res, visitors, "ImageExit");
+    composeSimpleVisitors(res, visitors, "Length");
+    composeSimpleVisitors(res, visitors, "Angle");
+    composeSimpleVisitors(res, visitors, "Ratio");
+    composeSimpleVisitors(res, visitors, "Resolution");
+    composeSimpleVisitors(res, visitors, "Time");
+    composeSimpleVisitors(res, visitors, "CustomIdent");
+    composeSimpleVisitors(res, visitors, "DashedIdent");
+    composeArrayFunctions(res, visitors, "MediaQuery");
+    composeArrayFunctions(res, visitors, "MediaQueryExit");
+    composeSimpleVisitors(res, visitors, "SupportsCondition");
+    composeSimpleVisitors(res, visitors, "SupportsConditionExit");
+    composeArrayFunctions(res, visitors, "Selector");
+    composeTokenVisitors(res, visitors, "Token", "token", false);
+    composeTokenVisitors(res, visitors, "Function", "function", false);
+    composeTokenVisitors(res, visitors, "FunctionExit", "function", true);
+    composeTokenVisitors(res, visitors, "Variable", "var", false);
+    composeTokenVisitors(res, visitors, "VariableExit", "var", true);
+    composeTokenVisitors(res, visitors, "EnvironmentVariable", "env", false);
+    composeTokenVisitors(res, visitors, "EnvironmentVariableExit", "env", true);
+    return res;
+  }
+  module.exports = composeVisitors;
+  function wrapCustomAndUnknownAtRule(k, f) {
+    if (k === "unknown") {
+      return (value) => f({ type: "unknown", value });
+    }
+    if (k === "custom") {
+      return (value) => f({ type: "custom", value });
+    }
+    return f;
+  }
+  function wrapCustomProperty(k, f) {
+    return k === "custom" ? (value) => f({ property: "custom", value }) : f;
+  }
+  function ruleVisitor(f, item) {
+    if (typeof f === "object") {
+      if (item.type === "unknown") {
+        let v = f.unknown;
+        if (typeof v === "object") {
+          v = v[item.value.name];
+        }
+        return v?.(item.value);
+      }
+      if (item.type === "custom") {
+        let v = f.custom;
+        if (typeof v === "object") {
+          v = v[item.value.name];
+        }
+        return v?.(item.value);
+      }
+      return f[item.type]?.(item);
+    }
+    return f?.(item);
+  }
+  function declarationVisitor(f, item) {
+    if (typeof f === "object") {
+      let name = item.property;
+      if (item.property === "unparsed") {
+        name = item.value.propertyId.property;
+      } else if (item.property === "custom") {
+        let v = f.custom;
+        if (typeof v === "object") {
+          v = v[item.value.name];
+        }
+        return v?.(item.value);
+      }
+      return f[name]?.(item);
+    }
+    return f?.(item);
+  }
+  function extractObjectsOrFunctions(visitors, key) {
+    let values = [];
+    let hasFunction = false;
+    let allKeys = new Set;
+    for (let visitor of visitors) {
+      let v = visitor[key];
+      if (v) {
+        if (typeof v === "function") {
+          hasFunction = true;
+        } else {
+          for (let key2 in v) {
+            allKeys.add(key2);
+          }
+        }
+        values.push(v);
+      }
+    }
+    return [values, hasFunction, allKeys];
+  }
+  function composeObjectVisitors(res, visitors, key, apply, wrapKey) {
+    let [values, hasFunction, allKeys] = extractObjectsOrFunctions(visitors, key);
+    if (values.length === 0) {
+      return;
+    }
+    if (values.length === 1) {
+      res[key] = values[0];
+      return;
+    }
+    let f = createArrayVisitor(visitors, (visitor, item) => apply(visitor[key], item));
+    if (hasFunction) {
+      res[key] = f;
+    } else {
+      let v = {};
+      for (let k of allKeys) {
+        v[k] = wrapKey(k, f);
+      }
+      res[key] = v;
+    }
+  }
+  function composeTokenVisitors(res, visitors, key, type, isExit) {
+    let [values, hasFunction, allKeys] = extractObjectsOrFunctions(visitors, key);
+    if (values.length === 0) {
+      return;
+    }
+    if (values.length === 1) {
+      res[key] = values[0];
+      return;
+    }
+    let f = createTokenVisitor(visitors, type, isExit);
+    if (hasFunction) {
+      res[key] = f;
+    } else {
+      let v = {};
+      for (let key2 of allKeys) {
+        v[key2] = f;
+      }
+      res[key] = v;
+    }
+  }
+  function createTokenVisitor(visitors, type, isExit) {
+    let v = createArrayVisitor(visitors, (visitor, item) => {
+      let f;
+      switch (item.type) {
+        case "token":
+          f = visitor.Token;
+          if (typeof f === "object") {
+            f = f[item.value.type];
+          }
+          break;
+        case "function":
+          f = isExit ? visitor.FunctionExit : visitor.Function;
+          if (typeof f === "object") {
+            f = f[item.value.name];
+          }
+          break;
+        case "var":
+          f = isExit ? visitor.VariableExit : visitor.Variable;
+          break;
+        case "env":
+          f = isExit ? visitor.EnvironmentVariableExit : visitor.EnvironmentVariable;
+          if (typeof f === "object") {
+            let name;
+            switch (item.value.name.type) {
+              case "ua":
+              case "unknown":
+                name = item.value.name.value;
+                break;
+              case "custom":
+                name = item.value.name.ident;
+                break;
+            }
+            f = f[name];
+          }
+          break;
+        case "color":
+          f = visitor.Color;
+          break;
+        case "url":
+          f = visitor.Url;
+          break;
+        case "length":
+          f = visitor.Length;
+          break;
+        case "angle":
+          f = visitor.Angle;
+          break;
+        case "time":
+          f = visitor.Time;
+          break;
+        case "resolution":
+          f = visitor.Resolution;
+          break;
+        case "dashed-ident":
+          f = visitor.DashedIdent;
+          break;
+      }
+      if (!f) {
+        return;
+      }
+      let res = f(item.value);
+      switch (item.type) {
+        case "color":
+        case "url":
+        case "length":
+        case "angle":
+        case "time":
+        case "resolution":
+        case "dashed-ident":
+          if (Array.isArray(res)) {
+            res = res.map((value) => ({ type: item.type, value }));
+          } else if (res) {
+            res = { type: item.type, value: res };
+          }
+          break;
+      }
+      return res;
+    });
+    return (value) => v({ type, value });
+  }
+  function extractFunctions(visitors, key) {
+    let functions = [];
+    for (let visitor of visitors) {
+      let f = visitor[key];
+      if (f) {
+        functions.push(f);
+      }
+    }
+    return functions;
+  }
+  function composeSimpleVisitors(res, visitors, key) {
+    let functions = extractFunctions(visitors, key);
+    if (functions.length === 0) {
+      return;
+    }
+    if (functions.length === 1) {
+      res[key] = functions[0];
+      return;
+    }
+    res[key] = (arg) => {
+      let mutated = false;
+      for (let f of functions) {
+        let res2 = f(arg);
+        if (res2) {
+          arg = res2;
+          mutated = true;
+        }
+      }
+      return mutated ? arg : undefined;
+    };
+  }
+  function composeArrayFunctions(res, visitors, key) {
+    let functions = extractFunctions(visitors, key);
+    if (functions.length === 0) {
+      return;
+    }
+    if (functions.length === 1) {
+      res[key] = functions[0];
+      return;
+    }
+    res[key] = createArrayVisitor(functions, (f, item) => f(item));
+  }
+  function createArrayVisitor(visitors, apply) {
+    let seen = new Bitset(visitors.length);
+    return (arg) => {
+      let arr = [arg];
+      let mutated = false;
+      seen.clear();
+      for (let i = 0;i < arr.length; i++) {
+        for (let v = 0;v < visitors.length && i < arr.length; ) {
+          if (seen.get(v)) {
+            v++;
+            continue;
+          }
+          let item = arr[i];
+          let visitor = visitors[v];
+          let res = apply(visitor, item);
+          if (Array.isArray(res)) {
+            if (res.length === 0) {
+              arr.splice(i, 1);
+            } else if (res.length === 1) {
+              arr[i] = res[0];
+            } else {
+              arr.splice(i, 1, ...res);
+            }
+            mutated = true;
+            seen.set(v);
+            v = 0;
+          } else if (res) {
+            arr[i] = res;
+            mutated = true;
+            seen.set(v);
+            v = 0;
+          } else {
+            v++;
+          }
+        }
+      }
+      if (!mutated) {
+        return;
+      }
+      return arr.length === 1 ? arr[0] : arr;
+    };
+  }
+
+  class Bitset {
+    constructor(maxBits = 32) {
+      this.bits = 0;
+      this.more = maxBits > 32 ? new Uint32Array(Math.ceil((maxBits - 32) / 32)) : null;
+    }
+    get(bit) {
+      if (bit >= 32 && this.more) {
+        let i = Math.floor((bit - 32) / 32);
+        let b = bit % 32;
+        return Boolean(this.more[i] & 1 << b);
+      } else {
+        return Boolean(this.bits & 1 << bit);
+      }
+    }
+    set(bit) {
+      if (bit >= 32 && this.more) {
+        let i = Math.floor((bit - 32) / 32);
+        let b = bit % 32;
+        this.more[i] |= 1 << b;
+      } else {
+        this.bits |= 1 << bit;
+      }
+    }
+    clear() {
+      this.bits = 0;
+      if (this.more) {
+        this.more.fill(0);
+      }
+    }
+  }
+});
+
+// node_modules/lightningcss/node/flags.js
+var require_flags = __commonJS((exports) => {
+  exports.Features = {
+    Nesting: 1,
+    NotSelectorList: 2,
+    DirSelector: 4,
+    LangSelectorList: 8,
+    IsSelector: 16,
+    TextDecorationThicknessPercent: 32,
+    MediaIntervalSyntax: 64,
+    MediaRangeSyntax: 128,
+    CustomMediaQueries: 256,
+    ClampFunction: 512,
+    ColorFunction: 1024,
+    OklabColors: 2048,
+    LabColors: 4096,
+    P3Colors: 8192,
+    HexAlphaColors: 16384,
+    SpaceSeparatedColorNotation: 32768,
+    FontFamilySystemUi: 65536,
+    DoublePositionGradients: 131072,
+    VendorPrefixes: 262144,
+    LogicalProperties: 524288,
+    LightDark: 1048576,
+    Selectors: 31,
+    MediaQueries: 448,
+    Colors: 1113088
+  };
+});
+
+// node_modules/lightningcss/node/index.js
+var require_node = __commonJS((exports, module) => {
+  var parts = [process.platform, process.arch];
+  if (process.platform === "linux") {
+    const { MUSL, familySync } = require_detect_libc();
+    const family = familySync();
+    if (family === MUSL) {
+      parts.push("musl");
+    } else if (process.arch === "arm") {
+      parts.push("gnueabihf");
+    } else {
+      parts.push("gnu");
+    }
+  } else if (process.platform === "win32") {
+    parts.push("msvc");
+  }
+  var native;
+  try {
+    native = __require(`lightningcss-${parts.join("-")}`);
+  } catch (err) {
+    native = __require(`../lightningcss.${parts.join("-")}.node`);
+  }
+  exports.transform = wrap(native.transform);
+  exports.transformStyleAttribute = wrap(native.transformStyleAttribute);
+  exports.bundle = wrap(native.bundle);
+  exports.bundleAsync = wrap(native.bundleAsync);
+  exports.browserslistToTargets = require_browserslistToTargets();
+  exports.composeVisitors = require_composeVisitors();
+  exports.Features = require_flags().Features;
+  function wrap(call) {
+    return (options) => {
+      if (typeof options.visitor === "function") {
+        let deps = [];
+        options.visitor = options.visitor({
+          addDependency(dep) {
+            deps.push(dep);
+          }
+        });
+        let result = call(options);
+        if (result instanceof Promise) {
+          result = result.then((res) => {
+            if (deps.length) {
+              res.dependencies ??= [];
+              res.dependencies.push(...deps);
+            }
+            return res;
+          });
+        } else if (deps.length) {
+          result.dependencies ??= [];
+          result.dependencies.push(...deps);
+        }
+        return result;
+      } else {
+        return call(options);
+      }
+    };
+  }
+});
+
+// src/postbuild-purge.ts
+var {Glob: Glob2 } = globalThis.Bun;
+
+// node_modules/lightningcss/node/index.mjs
+var import__ = __toESM(require_node(), 1);
+var { transform, transformStyleAttribute, bundle, bundleAsync, browserslistToTargets, composeVisitors, Features } = import__.default;
+
+// src/postbuild-purge.ts
+import postcss from "postcss";
+
+// src/scan-consumer.ts
+import swc from "@swc/core";
+var {Glob } = globalThis.Bun;
+function walkAST(node, visitor) {
+  if (!isRecord(node))
+    return;
+  visitor(node);
+  for (const key of Object.keys(node)) {
+    if (key === "span")
+      continue;
+    const val = node[key];
+    if (Array.isArray(val)) {
+      for (const item of val)
+        walkAST(item, visitor);
+    } else if (val && typeof val === "object") {
+      walkAST(val, visitor);
+    }
+  }
+}
+function kebabToPascal(s) {
+  return s.split("-").filter(Boolean).map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+}
+function componentFromDeepImport(source) {
+  const match = source.match(/^@pathscale\/ui\/components\/([^/]+)/);
+  if (!match)
+    return null;
+  return kebabToPascal(match[1]);
+}
+function isUiImport(source) {
+  return Boolean(source?.startsWith("@pathscale/ui"));
+}
+function isRecord(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function getString(value, key) {
+  if (!isRecord(value))
+    return;
+  const prop = value[key];
+  return typeof prop === "string" ? prop : undefined;
+}
+function getBoolean(value, key) {
+  if (!isRecord(value))
+    return false;
+  return value[key] === true;
+}
+function getPathString(value, ...keys) {
+  let current = value;
+  for (const key of keys) {
+    if (!isRecord(current))
+      return;
+    current = current[key];
+  }
+  return typeof current === "string" ? current : undefined;
+}
+function getArray(value, key) {
+  if (!isRecord(value))
+    return [];
+  const prop = value[key];
+  return Array.isArray(prop) ? prop : [];
+}
+function joinPath(base, rel) {
+  return `${base.replace(/\/+$/, "")}/${rel.replace(/^\/+/, "")}`;
+}
+function canonicalImportedName(spec, source) {
+  const importedName = getPathString(spec, "imported", "value") ?? getPathString(spec, "local", "value") ?? null;
+  const deep = (c, t) => {
+    if (t !== "ImportSpecifier")
+      return c;
+    if (!importedName)
+      return null;
+    if (importedName === c)
+      return c;
+    return `${c}.${importedName}`;
+  };
+  const type = getString(spec, "type");
+  if (getBoolean(spec, "isTypeOnly"))
+    return null;
+  const deepComponent = componentFromDeepImport(source);
+  if (deepComponent)
+    return deep(deepComponent, type);
+  if (source === "@pathscale/ui" && type === "ImportSpecifier")
+    return importedName;
+  return null;
+}
+function conservativeUsage(component, source) {
+  return {
+    component,
+    props: new Map,
+    booleanProps: new Set,
+    hasSpread: true,
+    source
+  };
+}
+function extractUIBindings(ast) {
+  const bindings = {
+    components: new Map,
+    namespaces: new Map,
+    conservativeUsages: []
+  };
+  for (const node of getArray(ast, "body")) {
+    const nodeType = getString(node, "type");
+    if (nodeType === "ImportDeclaration") {
+      const source = getPathString(node, "source", "value");
+      if (!isUiImport(source))
+        continue;
+      for (const spec of getArray(node, "specifiers")) {
+        const specType = getString(spec, "type");
+        if (specType === "ImportSpecifier") {
+          const local = getPathString(spec, "local", "value");
+          const canonical = canonicalImportedName(spec, source);
+          if (local && canonical)
+            bindings.components.set(local, canonical);
+        } else if (specType === "ImportDefaultSpecifier") {
+          const local = getPathString(spec, "local", "value");
+          const canonical = componentFromDeepImport(source) ?? local;
+          if (local && canonical)
+            bindings.components.set(local, canonical);
+        } else if (specType === "ImportNamespaceSpecifier") {
+          const local = getPathString(spec, "local", "value");
+          if (local)
+            bindings.namespaces.set(local, componentFromDeepImport(source));
+        }
+      }
+    }
+    if (nodeType === "ExportNamedDeclaration" && isUiImport(getPathString(node, "source", "value"))) {
+      const source = getPathString(node, "source", "value");
+      if (!source)
+        continue;
+      const deepComponent = componentFromDeepImport(source);
+      for (const spec of getArray(node, "specifiers")) {
+        const exported = getPathString(spec, "orig", "value") ?? getPathString(spec, "local", "value") ?? getPathString(spec, "exported", "value") ?? deepComponent;
+        const canonical = deepComponent ?? exported;
+        if (canonical)
+          bindings.conservativeUsages.push(conservativeUsage(canonical, source));
+      }
+    }
+    if (nodeType === "ExportAllDeclaration" && isUiImport(getPathString(node, "source", "value"))) {
+      const source = getPathString(node, "source", "value");
+      if (!source)
+        continue;
+      const deepComponent = componentFromDeepImport(source);
+      if (deepComponent) {
+        bindings.conservativeUsages.push(conservativeUsage(deepComponent, source));
+      }
+    }
+  }
+  return bindings;
+}
+function extractUIImports(ast) {
+  return extractUIBindings(ast).components;
+}
+function jsxNameParts(name) {
+  if (!name)
+    return [];
+  const type = getString(name, "type");
+  const value = getString(name, "value");
+  if ((type === "Identifier" || type === "JSXIdentifier") && value)
+    return [value];
+  if (type === "JSXMemberExpression") {
+    return [
+      ...jsxNameParts(isRecord(name) ? name.object : undefined),
+      ...jsxNameParts(isRecord(name) ? name.property : undefined)
+    ];
+  }
+  return [];
+}
+function canonicalComponentFromJsx(parts, bindings) {
+  if (parts.length === 0)
+    return null;
+  const [root, ...members] = parts;
+  const namespaceComponent = bindings.namespaces.get(root);
+  if (bindings.namespaces.has(root)) {
+    if (namespaceComponent) {
+      const lower2 = members.map((m) => m.toLowerCase());
+      return [namespaceComponent, ...lower2].join(".");
+    }
+    return members.join(".") || null;
+  }
+  const rootComponent = bindings.components.get(root);
+  if (!rootComponent)
+    return null;
+  const lower = members.map((m) => m.toLowerCase());
+  return [rootComponent, ...lower].join(".");
+}
+function extractJSXUsages(ast, uiComponents) {
+  const bindings = {
+    components: uiComponents,
+    namespaces: extractUIBindings(ast).namespaces,
+    conservativeUsages: []
+  };
+  const usages = [];
+  walkAST(ast, (node) => {
+    if (getString(node, "type") !== "JSXOpeningElement")
+      return;
+    const component = canonicalComponentFromJsx(jsxNameParts(node.name), bindings);
+    if (!component)
+      return;
+    const usage = {
+      component,
+      props: new Map,
+      booleanProps: new Set,
+      hasSpread: false
+    };
+    for (const attr of getArray(node, "attributes")) {
+      const attrType = getString(attr, "type");
+      if (attrType === "SpreadElement" || attrType === "JSXSpreadAttribute") {
+        usage.hasSpread = true;
+        continue;
+      }
+      if (attrType !== "JSXAttribute")
+        continue;
+      const propName = getPathString(attr, "name", "value");
+      if (!propName)
+        continue;
+      const attrValue = isRecord(attr) ? attr.value : undefined;
+      const attrValueType = getString(attrValue, "type");
+      if (!attrValue) {
+        usage.booleanProps.add(propName);
+      } else if (attrValueType === "StringLiteral") {
+        usage.props.set(propName, getString(attrValue, "value") ?? "");
+      } else {
+        usage.props.set(propName, "DYNAMIC");
+      }
+    }
+    usages.push(usage);
+  });
+  return usages;
+}
+function manifestComponents(manifest) {
+  if (isPurgeDatabaseV2(manifest)) {
+    return manifest.components;
+  }
+  return manifest;
+}
+function isPurgeDatabaseV2(manifest) {
+  return manifest.version === 2 && isRecord(manifest.components);
+}
+function buildSafelists(allUsages, manifest) {
+  const classSafelist = new Set;
+  const attrSafelist = new Set;
+  const usedComponents = new Set;
+  const dynamicComponents = new Set;
+  const componentUsages = new Map;
+  const components = manifestComponents(manifest);
+  for (const usage of expandDependencyUsages(allUsages, components)) {
+    const existing = componentUsages.get(usage.component) ?? [];
+    existing.push(usage);
+    componentUsages.set(usage.component, existing);
+    usedComponents.add(usage.component);
+    if (usage.hasSpread || [...usage.props.values()].includes("DYNAMIC")) {
+      dynamicComponents.add(usage.component);
+    }
+  }
+  for (const [entryName, entry] of Object.entries(components)) {
+    const matchingUsages = findMatchingUsages(entryName, componentUsages);
+    if (matchingUsages.length === 0)
+      continue;
+    usedComponents.add(entryName);
+    for (const cls of entry.classes.always) {
+      classSafelist.add(cls);
+    }
+    for (const [propOrSlot, value] of Object.entries(entry.classes.byProp)) {
+      if (Array.isArray(value)) {
+        if (isPropUsed(propOrSlot, matchingUsages)) {
+          for (const cls of value)
+            classSafelist.add(cls);
+        }
+      } else {
+        const usedValues = getUsedEnumValues(propOrSlot, matchingUsages);
+        if (usedValues === "ALL") {
+          for (const classes of Object.values(value)) {
+            for (const cls of classes)
+              classSafelist.add(cls);
+          }
+        } else {
+          for (const val of usedValues) {
+            if (value[val]) {
+              for (const cls of value[val])
+                classSafelist.add(cls);
+            }
+          }
+        }
+      }
+    }
+    if (entry.attrs) {
+      for (const [propName, attrMap] of Object.entries(entry.attrs)) {
+        if (isPropUsed(propName, matchingUsages)) {
+          for (const [attr, val] of Object.entries(attrMap)) {
+            attrSafelist.add(`[${attr}="${val}"]`);
+          }
+        }
+      }
+    }
+  }
+  return { classSafelist, attrSafelist, usedComponents, dynamicComponents };
+}
+function expandDependencyUsages(allUsages, manifest) {
+  const result = [...allUsages];
+  const queue = [...allUsages.map((usage) => rootComponent(usage.component))];
+  const seen = new Set(queue);
+  while (queue.length > 0) {
+    const root = queue.pop();
+    if (!root)
+      continue;
+    const deps = depsForRoot(root, manifest);
+    for (const dep of deps) {
+      if (seen.has(dep))
+        continue;
+      seen.add(dep);
+      queue.push(dep);
+      result.push(conservativeUsage(dep, "manifest-dependency"));
+    }
+  }
+  return result;
+}
+function depsForRoot(root, manifest) {
+  const deps = new Set;
+  for (const [key, entry] of Object.entries(manifest)) {
+    if (rootComponent(key) !== root)
+      continue;
+    for (const dep of entry.deps ?? [])
+      deps.add(dep);
+  }
+  return [...deps];
+}
+function rootComponent(component) {
+  return component.split(".")[0];
+}
+function findMatchingUsages(entryName, usageMap) {
+  const direct = usageMap.get(entryName) ?? [];
+  const results = [...direct];
+  const entryRoot = rootComponent(entryName);
+  for (const [usageName, usages] of usageMap) {
+    if (usageName === entryName)
+      continue;
+    if (entryName.includes(".") && usageName === entryRoot) {
+      results.push(...usages);
+    }
+  }
+  return results;
+}
+function isPropUsed(propName, usages) {
+  for (const usage of usages) {
+    if (usage.hasSpread)
+      return true;
+    if (usage.booleanProps.has(propName))
+      return true;
+    if (usage.props.has(propName))
+      return true;
+  }
+  return false;
+}
+function getUsedEnumValues(slotName, usages) {
+  const values = new Set;
+  for (const usage of usages) {
+    if (usage.hasSpread)
+      return "ALL";
+    const val = usage.props.get(slotName);
+    if (val === "DYNAMIC")
+      return "ALL";
+    if (val !== undefined)
+      values.add(val);
+    if (usage.booleanProps.has(slotName))
+      return "ALL";
+  }
+  return values;
+}
+async function scanConsumerSource(srcDir) {
+  const allUsages = [];
+  const glob = new Glob("**/*.{tsx,ts,jsx,js}");
+  for await (const relPath of glob.scan({ cwd: srcDir })) {
+    if (relPath.includes("node_modules"))
+      continue;
+    const fullPath = joinPath(srcDir, relPath);
+    const code = await Bun.file(fullPath).text();
+    if (!code.includes("@pathscale/ui"))
+      continue;
+    const isTsx = /\.[tj]sx$/.test(relPath);
+    const ast = await swc.parse(code, { syntax: "typescript", tsx: isTsx });
+    const bindings = extractUIBindings(ast);
+    if (bindings.components.size === 0 && bindings.namespaces.size === 0 && bindings.conservativeUsages.length === 0) {
+      continue;
+    }
+    allUsages.push(...bindings.conservativeUsages);
+    const jsxUsages = extractJSXUsages(ast, bindings.components);
+    allUsages.push(...jsxUsages);
+    for (const component of bindings.components.values()) {
+      if (jsxUsages.some((usage) => usage.component === component || usage.component.startsWith(`${component}.`))) {
+        continue;
+      }
+      allUsages.push(conservativeUsage(component, "import-without-direct-jsx"));
+    }
+  }
+  return allUsages;
+}
+if (false) {}
+
+// src/postbuild-purge.ts
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  let distDir = "./dist";
+  let srcDir = "./src";
+  let manifestPath = "";
+  for (let i = 0;i < args.length; i++) {
+    if (args[i] === "--dist" && args[i + 1])
+      distDir = args[++i];
+    else if (args[i] === "--src" && args[i + 1])
+      srcDir = args[++i];
+    else if (args[i] === "--manifest" && args[i + 1])
+      manifestPath = args[++i];
+  }
+  if (!manifestPath) {
+    console.error("Usage: bunx @pathscale/rsbuild-plugin-ui-css-purge --manifest <path> [--dist <path>] [--src <path>]");
+    process.exit(1);
+  }
+  return { distDir, srcDir, manifestPath };
+}
+function normalizePurgeDatabase(manifest) {
+  const rawComponents = "version" in manifest && manifest.version === 2 ? manifest.components : manifest;
+  const components = {};
+  for (const [key, record] of Object.entries(rawComponents)) {
+    const maybeV2 = record;
+    const [fallbackComponent, fallbackPart] = splitComponentKey(key);
+    components[key] = {
+      ...record,
+      key: maybeV2.key ?? key,
+      component: maybeV2.component ?? fallbackComponent,
+      part: maybeV2.part ?? fallbackPart,
+      selectors: maybeV2.selectors ?? [],
+      attributeSelectors: maybeV2.attributeSelectors ?? [],
+      cssVars: {
+        declared: maybeV2.cssVars?.declared ?? [],
+        referenced: maybeV2.cssVars?.referenced ?? []
+      },
+      keyframes: {
+        declared: maybeV2.keyframes?.declared ?? [],
+        referenced: maybeV2.keyframes?.referenced ?? []
+      }
+    };
+  }
+  return { version: 2, components };
+}
+function splitComponentKey(key) {
+  const [component, ...part] = key.split(".");
+  return [component, part.length > 0 ? part.join(".") : undefined];
+}
+function rootComponent2(key) {
+  return key.split(".")[0];
+}
+function collectClassesFromEntry(entry) {
+  const result = [...entry.classes.always];
+  for (const value of Object.values(entry.classes.byProp)) {
+    if (Array.isArray(value)) {
+      result.push(...value);
+    } else {
+      for (const classes of Object.values(value)) {
+        result.push(...classes);
+      }
+    }
+  }
+  return [...new Set(result)];
+}
+function buildClassOwners(database) {
+  const owners = new Map;
+  for (const [key, entry] of Object.entries(database.components)) {
+    for (const cls of collectClassesFromEntry(entry)) {
+      const existing = owners.get(cls) ?? new Set;
+      existing.add(key);
+      owners.set(cls, existing);
+    }
+  }
+  return owners;
+}
+function isRecordUsed(recordKey, safelists) {
+  return safelists.usedComponents.has(recordKey) || safelists.usedComponents.has(rootComponent2(recordKey));
+}
+function isClassAllowed(cls, owners, safelists) {
+  const classOwners = owners.get(cls);
+  if (!classOwners)
+    return true;
+  for (const owner of classOwners) {
+    if (isRecordUsed(owner, safelists) && safelists.classSafelist.has(cls)) {
+      return true;
+    }
+  }
+  return false;
+}
+function emptySelectorReport() {
+  return {
+    selectorsKeptKnown: 0,
+    selectorsKeptUnknown: 0,
+    selectorsRemoved: 0,
+    selectorsRemovedUnusedComponent: 0,
+    selectorsRemovedUnusedVariant: 0,
+    attrSelectorsSeen: 0,
+    keyframesRemoved: 0,
+    fontFacesRemoved: 0
+  };
+}
+function unescapeCss(s) {
+  return s.replace(/\\(.)/g, "$1");
+}
+function extractClassesFromSelector(selector) {
+  const matches = selector.matchAll(/\.([a-zA-Z_-](?:[a-zA-Z0-9_-]|\\[^\s.#:[>+~,)]*)*)/g);
+  return [...matches].map((m) => unescapeCss(m[1]));
+}
+function extractAttrsFromSelector(selector) {
+  const matches = selector.matchAll(/\[(data-[a-zA-Z0-9_-]+|aria-[a-zA-Z0-9_-]+)(?:=(?:"([^"]*)"|'([^']*)'|([^\]]+)))?\]/g);
+  return [...matches].map((m) => {
+    const value = m[2] ?? m[3] ?? m[4];
+    return value === undefined ? `[${m[1]}]` : `[${m[1]}="${value.trim()}"]`;
+  });
+}
+function selectorDecision(selector, owners, safelists) {
+  const attrs = extractAttrsFromSelector(selector);
+  if (attrs.some((attr) => safelists.attrSafelist.has(attr))) {
+    return "keep-known";
+  }
+  const classes = extractClassesFromSelector(selector);
+  if (classes.length === 0)
+    return "keep-unknown";
+  const hasUnknownClass = classes.some((cls) => !owners.has(cls));
+  if (hasUnknownClass)
+    return "keep-unknown";
+  const hasUsedOwner = classes.some((cls) => {
+    const classOwners = owners.get(cls);
+    return [...classOwners ?? []].some((owner) => isRecordUsed(owner, safelists));
+  });
+  if (!hasUsedOwner)
+    return "remove-unused-component";
+  if (classes.every((cls) => isClassAllowed(cls, owners, safelists))) {
+    return "keep-known";
+  }
+  return "remove-unused-variant";
+}
+function purgeCssWithDatabase(css, manifest, safelists) {
+  const database = normalizePurgeDatabase(manifest);
+  const classOwners = buildClassOwners(database);
+  const report = emptySelectorReport();
+  const root = postcss.parse(css);
+  root.walkRules((rule) => {
+    const selectors = rule.selectors;
+    const kept = [];
+    for (const selector of selectors) {
+      report.attrSelectorsSeen += extractAttrsFromSelector(selector).length;
+      const decision = selectorDecision(selector, classOwners, safelists);
+      if (decision === "keep-known") {
+        report.selectorsKeptKnown++;
+        kept.push(selector);
+      } else if (decision === "keep-unknown") {
+        report.selectorsKeptUnknown++;
+        kept.push(selector);
+      } else {
+        report.selectorsRemoved++;
+        if (decision === "remove-unused-component") {
+          report.selectorsRemovedUnusedComponent++;
+        } else {
+          report.selectorsRemovedUnusedVariant++;
+        }
+      }
+    }
+    if (kept.length === 0) {
+      rule.remove();
+    } else if (kept.length < selectors.length) {
+      rule.selectors = kept;
+    }
+  });
+  removeUnusedKeyframes(root, report);
+  removeUnusedFontFaces(root, report);
+  removeEmptyAtRules(root);
+  return { css: root.toString(), report };
+}
+function removeUnusedKeyframes(root, report) {
+  const usedKeyframes = new Set;
+  root.walkDecls(/^animation(-name)?$/, (decl) => {
+    for (const part of decl.value.split(",")) {
+      const name = part.trim().split(/\s+/)[0];
+      if (name && !["none", "initial", "inherit", "unset"].includes(name)) {
+        usedKeyframes.add(name);
+      }
+    }
+  });
+  root.walkAtRules("keyframes", (atRule) => {
+    if (!usedKeyframes.has(atRule.params.trim())) {
+      atRule.remove();
+      report.keyframesRemoved++;
+    }
+  });
+}
+function removeUnusedFontFaces(root, report) {
+  const usedFonts = new Set;
+  root.walkDecls(/^font(-family)?$/, (decl) => {
+    for (const part of decl.value.split(",")) {
+      const name = part.trim().replace(/^["']|["']$/g, "");
+      if (name)
+        usedFonts.add(name);
+    }
+  });
+  root.walkAtRules("font-face", (atRule) => {
+    let family = "";
+    atRule.walkDecls("font-family", (decl) => {
+      family = decl.value.trim().replace(/^["']|["']$/g, "");
+    });
+    if (family && !usedFonts.has(family)) {
+      atRule.remove();
+      report.fontFacesRemoved++;
+    }
+  });
+}
+function removeEmptyAtRules(root) {
+  let cleaned = true;
+  while (cleaned) {
+    cleaned = false;
+    root.walkAtRules((atRule) => {
+      if (atRule.nodes && atRule.nodes.length === 0) {
+        atRule.remove();
+        cleaned = true;
+      }
+    });
+  }
+}
+async function collectRuntimeCssVarRefs(distDir) {
+  const refs = new Set;
+  const glob = new Glob2("**/*.{js,mjs,cjs}");
+  for await (const relPath of glob.scan({ cwd: distDir })) {
+    const fullPath = `${distDir}/${relPath}`;
+    const code = await Bun.file(fullPath).text();
+    for (const match of code.matchAll(/var\(\s*(--[a-zA-Z0-9_-]+)/g)) {
+      refs.add(match[1]);
+    }
+  }
+  return refs;
+}
+function cleanUnusedVarsWithReport(css, externallyReferencedVars) {
+  let changed = true;
+  let result = css;
+  let removed = 0;
+  while (changed) {
+    changed = false;
+    const root = postcss.parse(result);
+    const declared = new Map;
+    root.walkDecls(/^--/, (decl) => {
+      const entries = declared.get(decl.prop) ?? [];
+      entries.push({ rule: decl.parent, prop: decl.prop });
+      declared.set(decl.prop, entries);
+    });
+    const referenced = new Set(externallyReferencedVars);
+    root.walkDecls((decl) => {
+      for (const ref of decl.value.matchAll(/var\(\s*(--[a-zA-Z0-9_-]+)/g)) {
+        referenced.add(ref[1]);
+      }
+    });
+    for (const [varName, entries] of declared) {
+      if (!referenced.has(varName)) {
+        for (const entry of entries) {
+          entry.rule.walkDecls(entry.prop, (decl) => {
+            decl.remove();
+            changed = true;
+            removed++;
+          });
+        }
+      }
+    }
+    root.walkRules((rule) => {
+      if (rule.nodes && rule.nodes.length === 0)
+        rule.remove();
+    });
+    removeEmptyAtRules(root);
+    result = root.toString();
+  }
+  return { css: result, removed };
+}
+function cleanUnusedVars(css, externallyReferencedVars) {
+  return cleanUnusedVarsWithReport(css, externallyReferencedVars).css;
+}
+function minify(css) {
+  const { code } = transform({
+    filename: "purged.css",
+    code: Buffer.from(css),
+    minify: true,
+    errorRecovery: true
+  });
+  return code.toString();
+}
+async function main() {
+  const { distDir, srcDir, manifestPath } = parseArgs(process.argv);
+  const manifest = JSON.parse(await Bun.file(manifestPath).text());
+  const database = normalizePurgeDatabase(manifest);
+  const roots = new Set(Object.keys(database.components).map(rootComponent2));
+  console.log(`[css-purge] Database loaded: ${Object.keys(database.components).length} records (${roots.size} components)`);
+  const usages = await scanConsumerSource(srcDir);
+  const safelists = buildSafelists(usages, manifest);
+  const usedRoots = new Set([...safelists.usedComponents].map(rootComponent2));
+  const removedRoots = [...roots].filter((root) => !usedRoots.has(root));
+  console.log(`[css-purge] Components detected: ${usedRoots.size} used, ${removedRoots.length} removable`);
+  if (usedRoots.size > 0) {
+    console.log(`[css-purge]   used: ${[...usedRoots].sort().join(", ")}`);
+  }
+  if (removedRoots.length > 0) {
+    console.log(`[css-purge]   removable: ${removedRoots.sort().join(", ")}`);
+  }
+  console.log(`[css-purge] Safelist facts: ${safelists.classSafelist.size} classes, ${safelists.attrSafelist.size} attr selectors`);
+  const runtimeCssVarRefs = await collectRuntimeCssVarRefs(distDir);
+  if (runtimeCssVarRefs.size > 0) {
+    console.log(`[css-purge] Runtime CSS vars referenced from JS: ${runtimeCssVarRefs.size}`);
+  }
+  const glob = new Glob2("**/*.css");
+  let totalBefore = 0;
+  let totalAfter = 0;
+  for await (const relPath of glob.scan({ cwd: distDir })) {
+    const fullPath = `${distDir}/${relPath}`;
+    const originalCss = await Bun.file(fullPath).text();
+    const originalSize = Buffer.byteLength(originalCss, "utf-8");
+    totalBefore += originalSize;
+    console.log(`[css-purge] Processing ${relPath} (${(originalSize / 1024).toFixed(1)} KB)`);
+    const purged = purgeCssWithDatabase(originalCss, database, safelists);
+    let purgedCss = purged.css;
+    const afterSelectors = Buffer.byteLength(purgedCss, "utf-8");
+    console.log(`[css-purge]   selectors: ${(originalSize / 1024).toFixed(1)} -> ${(afterSelectors / 1024).toFixed(1)} KB (${purged.report.selectorsRemoved} removed, ${purged.report.selectorsKeptUnknown} kept unknown)`);
+    console.log(`[css-purge]   attrs seen: ${purged.report.attrSelectorsSeen}; keyframes removed: ${purged.report.keyframesRemoved}`);
+    const vars = cleanUnusedVarsWithReport(purgedCss, runtimeCssVarRefs);
+    purgedCss = vars.css;
+    const afterVars = Buffer.byteLength(purgedCss, "utf-8");
+    console.log(`[css-purge]   vars: ${(afterSelectors / 1024).toFixed(1)} -> ${(afterVars / 1024).toFixed(1)} KB (${vars.removed} removed)`);
+    purgedCss = minify(purgedCss);
+    const finalSize = Buffer.byteLength(purgedCss, "utf-8");
+    totalAfter += finalSize;
+    console.log(`[css-purge]   minify: -> ${(finalSize / 1024).toFixed(1)} KB`);
+    console.log(`[css-purge]   final: ${(originalSize / 1024).toFixed(1)} -> ${(finalSize / 1024).toFixed(1)} KB (${((1 - finalSize / originalSize) * 100).toFixed(1)}% reduction)`);
+    await Bun.write(fullPath, purgedCss);
+  }
+  console.log(`
+[css-purge] Total: ${(totalBefore / 1024).toFixed(1)} -> ${(totalAfter / 1024).toFixed(1)} KB (${((1 - totalAfter / totalBefore) * 100).toFixed(1)}% reduction)`);
+}
+if (import.meta.main) {
+  main();
+}
+export {
+  purgeCssWithDatabase,
+  normalizePurgeDatabase,
+  cleanUnusedVarsWithReport,
+  cleanUnusedVars
+};
+
+//# debugId=577D5EB7CD27ECD164756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["..\\node_modules\\detect-libc\\lib\\process.js", "..\\node_modules\\detect-libc\\lib\\filesystem.js", "..\\node_modules\\detect-libc\\lib\\elf.js", "..\\node_modules\\detect-libc\\lib\\detect-libc.js", "..\\node_modules\\lightningcss\\node\\browserslistToTargets.js", "..\\node_modules\\lightningcss\\node\\composeVisitors.js", "..\\node_modules\\lightningcss\\node\\flags.js", "..\\node_modules\\lightningcss\\node\\index.js", "..\\src\\postbuild-purge.ts", "..\\node_modules\\lightningcss\\node\\index.mjs", "..\\src\\scan-consumer.ts"],
  "sourcesContent": [
    "// Copyright 2017 Lovell Fuller and others.\n// SPDX-License-Identifier: Apache-2.0\n\n'use strict';\n\nconst isLinux = () => process.platform === 'linux';\n\nlet report = null;\nconst getReport = () => {\n  if (!report) {\n    /* istanbul ignore next */\n    if (isLinux() && process.report) {\n      const orig = process.report.excludeNetwork;\n      process.report.excludeNetwork = true;\n      report = process.report.getReport();\n      process.report.excludeNetwork = orig;\n    } else {\n      report = {};\n    }\n  }\n  return report;\n};\n\nmodule.exports = { isLinux, getReport };\n",
    "// Copyright 2017 Lovell Fuller and others.\n// SPDX-License-Identifier: Apache-2.0\n\n'use strict';\n\nconst fs = require('fs');\n\nconst LDD_PATH = '/usr/bin/ldd';\nconst SELF_PATH = '/proc/self/exe';\nconst MAX_LENGTH = 2048;\n\n/**\n * Read the content of a file synchronous\n *\n * @param {string} path\n * @returns {Buffer}\n */\nconst readFileSync = (path) => {\n  const fd = fs.openSync(path, 'r');\n  const buffer = Buffer.alloc(MAX_LENGTH);\n  const bytesRead = fs.readSync(fd, buffer, 0, MAX_LENGTH, 0);\n  fs.close(fd, () => {});\n  return buffer.subarray(0, bytesRead);\n};\n\n/**\n * Read the content of a file\n *\n * @param {string} path\n * @returns {Promise<Buffer>}\n */\nconst readFile = (path) => new Promise((resolve, reject) => {\n  fs.open(path, 'r', (err, fd) => {\n    if (err) {\n      reject(err);\n    } else {\n      const buffer = Buffer.alloc(MAX_LENGTH);\n      fs.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {\n        resolve(buffer.subarray(0, bytesRead));\n        fs.close(fd, () => {});\n      });\n    }\n  });\n});\n\nmodule.exports = {\n  LDD_PATH,\n  SELF_PATH,\n  readFileSync,\n  readFile\n};\n",
    "// Copyright 2017 Lovell Fuller and others.\n// SPDX-License-Identifier: Apache-2.0\n\n'use strict';\n\nconst interpreterPath = (elf) => {\n  if (elf.length < 64) {\n    return null;\n  }\n  if (elf.readUInt32BE(0) !== 0x7F454C46) {\n    // Unexpected magic bytes\n    return null;\n  }\n  if (elf.readUInt8(4) !== 2) {\n    // Not a 64-bit ELF\n    return null;\n  }\n  if (elf.readUInt8(5) !== 1) {\n    // Not little-endian\n    return null;\n  }\n  const offset = elf.readUInt32LE(32);\n  const size = elf.readUInt16LE(54);\n  const count = elf.readUInt16LE(56);\n  for (let i = 0; i < count; i++) {\n    const headerOffset = offset + (i * size);\n    const type = elf.readUInt32LE(headerOffset);\n    if (type === 3) {\n      const fileOffset = elf.readUInt32LE(headerOffset + 8);\n      const fileSize = elf.readUInt32LE(headerOffset + 32);\n      return elf.subarray(fileOffset, fileOffset + fileSize).toString().replace(/\\0.*$/g, '');\n    }\n  }\n  return null;\n};\n\nmodule.exports = {\n  interpreterPath\n};\n",
    "// Copyright 2017 Lovell Fuller and others.\n// SPDX-License-Identifier: Apache-2.0\n\n'use strict';\n\nconst childProcess = require('child_process');\nconst { isLinux, getReport } = require('./process');\nconst { LDD_PATH, SELF_PATH, readFile, readFileSync } = require('./filesystem');\nconst { interpreterPath } = require('./elf');\n\nlet cachedFamilyInterpreter;\nlet cachedFamilyFilesystem;\nlet cachedVersionFilesystem;\n\nconst command = 'getconf GNU_LIBC_VERSION 2>&1 || true; ldd --version 2>&1 || true';\nlet commandOut = '';\n\nconst safeCommand = () => {\n  if (!commandOut) {\n    return new Promise((resolve) => {\n      childProcess.exec(command, (err, out) => {\n        commandOut = err ? ' ' : out;\n        resolve(commandOut);\n      });\n    });\n  }\n  return commandOut;\n};\n\nconst safeCommandSync = () => {\n  if (!commandOut) {\n    try {\n      commandOut = childProcess.execSync(command, { encoding: 'utf8' });\n    } catch (_err) {\n      commandOut = ' ';\n    }\n  }\n  return commandOut;\n};\n\n/**\n * A String constant containing the value `glibc`.\n * @type {string}\n * @public\n */\nconst GLIBC = 'glibc';\n\n/**\n * A Regexp constant to get the GLIBC Version.\n * @type {string}\n */\nconst RE_GLIBC_VERSION = /LIBC[a-z0-9 \\-).]*?(\\d+\\.\\d+)/i;\n\n/**\n * A String constant containing the value `musl`.\n * @type {string}\n * @public\n */\nconst MUSL = 'musl';\n\nconst isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-');\n\nconst familyFromReport = () => {\n  const report = getReport();\n  if (report.header && report.header.glibcVersionRuntime) {\n    return GLIBC;\n  }\n  if (Array.isArray(report.sharedObjects)) {\n    if (report.sharedObjects.some(isFileMusl)) {\n      return MUSL;\n    }\n  }\n  return null;\n};\n\nconst familyFromCommand = (out) => {\n  const [getconf, ldd1] = out.split(/[\\r\\n]+/);\n  if (getconf && getconf.includes(GLIBC)) {\n    return GLIBC;\n  }\n  if (ldd1 && ldd1.includes(MUSL)) {\n    return MUSL;\n  }\n  return null;\n};\n\nconst familyFromInterpreterPath = (path) => {\n  if (path) {\n    if (path.includes('/ld-musl-')) {\n      return MUSL;\n    } else if (path.includes('/ld-linux-')) {\n      return GLIBC;\n    }\n  }\n  return null;\n};\n\nconst getFamilyFromLddContent = (content) => {\n  content = content.toString();\n  if (content.includes('musl')) {\n    return MUSL;\n  }\n  if (content.includes('GNU C Library')) {\n    return GLIBC;\n  }\n  return null;\n};\n\nconst familyFromFilesystem = async () => {\n  if (cachedFamilyFilesystem !== undefined) {\n    return cachedFamilyFilesystem;\n  }\n  cachedFamilyFilesystem = null;\n  try {\n    const lddContent = await readFile(LDD_PATH);\n    cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);\n  } catch (e) {}\n  return cachedFamilyFilesystem;\n};\n\nconst familyFromFilesystemSync = () => {\n  if (cachedFamilyFilesystem !== undefined) {\n    return cachedFamilyFilesystem;\n  }\n  cachedFamilyFilesystem = null;\n  try {\n    const lddContent = readFileSync(LDD_PATH);\n    cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);\n  } catch (e) {}\n  return cachedFamilyFilesystem;\n};\n\nconst familyFromInterpreter = async () => {\n  if (cachedFamilyInterpreter !== undefined) {\n    return cachedFamilyInterpreter;\n  }\n  cachedFamilyInterpreter = null;\n  try {\n    const selfContent = await readFile(SELF_PATH);\n    const path = interpreterPath(selfContent);\n    cachedFamilyInterpreter = familyFromInterpreterPath(path);\n  } catch (e) {}\n  return cachedFamilyInterpreter;\n};\n\nconst familyFromInterpreterSync = () => {\n  if (cachedFamilyInterpreter !== undefined) {\n    return cachedFamilyInterpreter;\n  }\n  cachedFamilyInterpreter = null;\n  try {\n    const selfContent = readFileSync(SELF_PATH);\n    const path = interpreterPath(selfContent);\n    cachedFamilyInterpreter = familyFromInterpreterPath(path);\n  } catch (e) {}\n  return cachedFamilyInterpreter;\n};\n\n/**\n * Resolves with the libc family when it can be determined, `null` otherwise.\n * @returns {Promise<?string>}\n */\nconst family = async () => {\n  let family = null;\n  if (isLinux()) {\n    family = await familyFromInterpreter();\n    if (!family) {\n      family = await familyFromFilesystem();\n      if (!family) {\n        family = familyFromReport();\n      }\n      if (!family) {\n        const out = await safeCommand();\n        family = familyFromCommand(out);\n      }\n    }\n  }\n  return family;\n};\n\n/**\n * Returns the libc family when it can be determined, `null` otherwise.\n * @returns {?string}\n */\nconst familySync = () => {\n  let family = null;\n  if (isLinux()) {\n    family = familyFromInterpreterSync();\n    if (!family) {\n      family = familyFromFilesystemSync();\n      if (!family) {\n        family = familyFromReport();\n      }\n      if (!family) {\n        const out = safeCommandSync();\n        family = familyFromCommand(out);\n      }\n    }\n  }\n  return family;\n};\n\n/**\n * Resolves `true` only when the platform is Linux and the libc family is not `glibc`.\n * @returns {Promise<boolean>}\n */\nconst isNonGlibcLinux = async () => isLinux() && await family() !== GLIBC;\n\n/**\n * Returns `true` only when the platform is Linux and the libc family is not `glibc`.\n * @returns {boolean}\n */\nconst isNonGlibcLinuxSync = () => isLinux() && familySync() !== GLIBC;\n\nconst versionFromFilesystem = async () => {\n  if (cachedVersionFilesystem !== undefined) {\n    return cachedVersionFilesystem;\n  }\n  cachedVersionFilesystem = null;\n  try {\n    const lddContent = await readFile(LDD_PATH);\n    const versionMatch = lddContent.match(RE_GLIBC_VERSION);\n    if (versionMatch) {\n      cachedVersionFilesystem = versionMatch[1];\n    }\n  } catch (e) {}\n  return cachedVersionFilesystem;\n};\n\nconst versionFromFilesystemSync = () => {\n  if (cachedVersionFilesystem !== undefined) {\n    return cachedVersionFilesystem;\n  }\n  cachedVersionFilesystem = null;\n  try {\n    const lddContent = readFileSync(LDD_PATH);\n    const versionMatch = lddContent.match(RE_GLIBC_VERSION);\n    if (versionMatch) {\n      cachedVersionFilesystem = versionMatch[1];\n    }\n  } catch (e) {}\n  return cachedVersionFilesystem;\n};\n\nconst versionFromReport = () => {\n  const report = getReport();\n  if (report.header && report.header.glibcVersionRuntime) {\n    return report.header.glibcVersionRuntime;\n  }\n  return null;\n};\n\nconst versionSuffix = (s) => s.trim().split(/\\s+/)[1];\n\nconst versionFromCommand = (out) => {\n  const [getconf, ldd1, ldd2] = out.split(/[\\r\\n]+/);\n  if (getconf && getconf.includes(GLIBC)) {\n    return versionSuffix(getconf);\n  }\n  if (ldd1 && ldd2 && ldd1.includes(MUSL)) {\n    return versionSuffix(ldd2);\n  }\n  return null;\n};\n\n/**\n * Resolves with the libc version when it can be determined, `null` otherwise.\n * @returns {Promise<?string>}\n */\nconst version = async () => {\n  let version = null;\n  if (isLinux()) {\n    version = await versionFromFilesystem();\n    if (!version) {\n      version = versionFromReport();\n    }\n    if (!version) {\n      const out = await safeCommand();\n      version = versionFromCommand(out);\n    }\n  }\n  return version;\n};\n\n/**\n * Returns the libc version when it can be determined, `null` otherwise.\n * @returns {?string}\n */\nconst versionSync = () => {\n  let version = null;\n  if (isLinux()) {\n    version = versionFromFilesystemSync();\n    if (!version) {\n      version = versionFromReport();\n    }\n    if (!version) {\n      const out = safeCommandSync();\n      version = versionFromCommand(out);\n    }\n  }\n  return version;\n};\n\nmodule.exports = {\n  GLIBC,\n  MUSL,\n  family,\n  familySync,\n  isNonGlibcLinux,\n  isNonGlibcLinuxSync,\n  version,\n  versionSync\n};\n",
    "const BROWSER_MAPPING = {\n  and_chr: 'chrome',\n  and_ff: 'firefox',\n  ie_mob: 'ie',\n  op_mob: 'opera',\n  and_qq: null,\n  and_uc: null,\n  baidu: null,\n  bb: null,\n  kaios: null,\n  op_mini: null,\n};\n\nfunction browserslistToTargets(browserslist) {\n  let targets = {};\n  for (let browser of browserslist) {\n    let [name, v] = browser.split(' ');\n    if (BROWSER_MAPPING[name] === null) {\n      continue;\n    }\n\n    let version = parseVersion(v);\n    if (version == null) {\n      continue;\n    }\n\n    if (targets[name] == null || version < targets[name]) {\n      targets[name] = version;\n    }\n  }\n\n  return targets;\n}\n\nfunction parseVersion(version) {\n  let [major, minor = 0, patch = 0] = version\n    .split('-')[0]\n    .split('.')\n    .map(v => parseInt(v, 10));\n\n  if (isNaN(major) || isNaN(minor) || isNaN(patch)) {\n    return null;\n  }\n\n  return (major << 16) | (minor << 8) | patch;\n}\n\nmodule.exports = browserslistToTargets;\n",
    "// @ts-check\n/** @typedef {import('./index').Visitor} Visitor */\n/** @typedef {import('./index').VisitorFunction} VisitorFunction */\n\n/**\n * Composes multiple visitor objects into a single one.\n * @param {(Visitor | VisitorFunction)[]} visitors \n * @return {Visitor | VisitorFunction}\n */\nfunction composeVisitors(visitors) {\n  if (visitors.length === 1) {\n    return visitors[0];\n  }\n  \n  if (visitors.some(v => typeof v === 'function')) {\n    return (opts) => {\n      let v = visitors.map(v => typeof v === 'function' ? v(opts) : v);\n      return composeVisitors(v);\n    };\n  }\n\n  /** @type Visitor */\n  let res = {};\n  composeSimpleVisitors(res, visitors, 'StyleSheet');\n  composeSimpleVisitors(res, visitors, 'StyleSheetExit');\n  composeObjectVisitors(res, visitors, 'Rule', ruleVisitor, wrapCustomAndUnknownAtRule);\n  composeObjectVisitors(res, visitors, 'RuleExit', ruleVisitor, wrapCustomAndUnknownAtRule);\n  composeObjectVisitors(res, visitors, 'Declaration', declarationVisitor, wrapCustomProperty);\n  composeObjectVisitors(res, visitors, 'DeclarationExit', declarationVisitor, wrapCustomProperty);\n  composeSimpleVisitors(res, visitors, 'Url');\n  composeSimpleVisitors(res, visitors, 'Color');\n  composeSimpleVisitors(res, visitors, 'Image');\n  composeSimpleVisitors(res, visitors, 'ImageExit');\n  composeSimpleVisitors(res, visitors, 'Length');\n  composeSimpleVisitors(res, visitors, 'Angle');\n  composeSimpleVisitors(res, visitors, 'Ratio');\n  composeSimpleVisitors(res, visitors, 'Resolution');\n  composeSimpleVisitors(res, visitors, 'Time');\n  composeSimpleVisitors(res, visitors, 'CustomIdent');\n  composeSimpleVisitors(res, visitors, 'DashedIdent');\n  composeArrayFunctions(res, visitors, 'MediaQuery');\n  composeArrayFunctions(res, visitors, 'MediaQueryExit');\n  composeSimpleVisitors(res, visitors, 'SupportsCondition');\n  composeSimpleVisitors(res, visitors, 'SupportsConditionExit');\n  composeArrayFunctions(res, visitors, 'Selector');\n  composeTokenVisitors(res, visitors, 'Token', 'token', false);\n  composeTokenVisitors(res, visitors, 'Function', 'function', false);\n  composeTokenVisitors(res, visitors, 'FunctionExit', 'function', true);\n  composeTokenVisitors(res, visitors, 'Variable', 'var', false);\n  composeTokenVisitors(res, visitors, 'VariableExit', 'var', true);\n  composeTokenVisitors(res, visitors, 'EnvironmentVariable', 'env', false);\n  composeTokenVisitors(res, visitors, 'EnvironmentVariableExit', 'env', true);\n  return res;\n}\n\nmodule.exports = composeVisitors;\n\nfunction wrapCustomAndUnknownAtRule(k, f) {\n  if (k === 'unknown') {\n    return (value => f({ type: 'unknown', value }));\n  }\n  if (k === 'custom') {\n    return (value => f({ type: 'custom', value }));\n  }\n  return f;\n}\n\nfunction wrapCustomProperty(k, f) {\n  return k === 'custom' ? (value => f({ property: 'custom', value })) : f;\n}\n\n/**\n * @param {import('./index').Visitor['Rule']} f \n * @param {import('./ast').Rule} item \n */\nfunction ruleVisitor(f, item) {\n  if (typeof f === 'object') {\n    if (item.type === 'unknown') {\n      let v = f.unknown;\n      if (typeof v === 'object') {\n        v = v[item.value.name];\n      }\n      return v?.(item.value);\n    }\n    if (item.type === 'custom') {\n      let v = f.custom;\n      if (typeof v === 'object') {\n        v = v[item.value.name];\n      }\n      return v?.(item.value);\n    }\n    return f[item.type]?.(item);\n  }\n  return f?.(item);\n}\n\n/**\n * @param {import('./index').Visitor['Declaration']} f \n * @param {import('./ast').Declaration} item \n */\nfunction declarationVisitor(f, item) {\n  if (typeof f === 'object') {\n    /** @type {string} */\n    let name = item.property;\n    if (item.property === 'unparsed') {\n      name = item.value.propertyId.property;\n    } else if (item.property === 'custom') {\n      let v = f.custom;\n      if (typeof v === 'object') {\n        v = v[item.value.name];\n      }\n      return v?.(item.value);\n    }\n    return f[name]?.(item);\n  }\n  return f?.(item);\n}\n\n/**\n * \n * @param {Visitor[]} visitors \n * @param {string} key \n * @returns {[any[], boolean, Set<string>]}\n */\nfunction extractObjectsOrFunctions(visitors, key) {\n  let values = [];\n  let hasFunction = false;\n  let allKeys = new Set();\n  for (let visitor of visitors) {\n    let v = visitor[key];\n    if (v) {\n      if (typeof v === 'function') {\n        hasFunction = true;\n      } else {\n        for (let key in v) {\n          allKeys.add(key);\n        }\n      }\n      values.push(v);\n    }\n  }\n  return [values, hasFunction, allKeys];\n}\n\n/**\n * @template {keyof Visitor} K\n * @param {Visitor} res\n * @param {Visitor[]} visitors\n * @param {K} key\n * @param {(visitor: Visitor[K], item: any) => any | any[] | void} apply \n * @param {(k: string, f: any) => any} wrapKey \n */\nfunction composeObjectVisitors(res, visitors, key, apply, wrapKey) {\n  let [values, hasFunction, allKeys] = extractObjectsOrFunctions(visitors, key);\n  if (values.length === 0) {\n    return;\n  }\n\n  if (values.length === 1) {\n    res[key] = values[0];\n    return;\n  }\n\n  let f = createArrayVisitor(visitors, (visitor, item) => apply(visitor[key], item));\n  if (hasFunction) {\n    res[key] = f;\n  } else {\n    /** @type {any} */\n    let v = {};\n    for (let k of allKeys) {\n      v[k] = wrapKey(k, f);\n    }\n    res[key] = v;\n  }\n}\n\n/**\n * @param {Visitor} res \n * @param {Visitor[]} visitors \n * @param {string} key \n * @param {import('./ast').TokenOrValue['type']} type \n * @param {boolean} isExit \n */\nfunction composeTokenVisitors(res, visitors, key, type, isExit) {\n  let [values, hasFunction, allKeys] = extractObjectsOrFunctions(visitors, key);\n  if (values.length === 0) {\n    return;\n  }\n\n  if (values.length === 1) {\n    res[key] = values[0];\n    return;\n  }\n\n  let f = createTokenVisitor(visitors, type, isExit);\n  if (hasFunction) {\n    res[key] = f;\n  } else {\n    let v = {};\n    for (let key of allKeys) {\n      v[key] = f;\n    }\n    res[key] = v;\n  }\n}\n\n/**\n * @param {Visitor[]} visitors \n * @param {import('./ast').TokenOrValue['type']} type \n */\nfunction createTokenVisitor(visitors, type, isExit) {\n  let v = createArrayVisitor(visitors, (visitor, /** @type {import('./ast').TokenOrValue} */ item) => {\n    let f;\n    switch (item.type) {\n      case 'token':\n        f = visitor.Token;\n        if (typeof f === 'object') {\n          f = f[item.value.type];\n        }\n        break;\n      case 'function':\n        f = isExit ? visitor.FunctionExit : visitor.Function;\n        if (typeof f === 'object') {\n          f = f[item.value.name];\n        }\n        break;\n      case 'var':\n        f = isExit ? visitor.VariableExit : visitor.Variable;\n        break;\n      case 'env':\n        f = isExit ? visitor.EnvironmentVariableExit : visitor.EnvironmentVariable;\n        if (typeof f === 'object') {\n          let name;\n          switch (item.value.name.type) {\n            case 'ua':\n            case 'unknown':\n              name = item.value.name.value;\n              break;\n            case 'custom':\n              name = item.value.name.ident;\n              break;\n          }\n          f = f[name];\n        }\n        break;\n      case 'color':\n        f = visitor.Color;\n        break;\n      case 'url':\n        f = visitor.Url;\n        break;\n      case 'length':\n        f = visitor.Length;\n        break;\n      case 'angle':\n        f = visitor.Angle;\n        break;\n      case 'time':\n        f = visitor.Time;\n        break;\n      case 'resolution':\n        f = visitor.Resolution;\n        break;\n      case 'dashed-ident':\n        f = visitor.DashedIdent;\n        break;\n    }\n\n    if (!f) {\n      return;\n    }\n\n    let res = f(item.value);\n    switch (item.type) {\n      case 'color':\n      case 'url':\n      case 'length':\n      case 'angle':\n      case 'time':\n      case 'resolution':\n      case 'dashed-ident':\n        if (Array.isArray(res)) {\n          res = res.map(value => ({ type: item.type, value }))\n        } else if (res) {\n          res = { type: item.type, value: res };\n        }\n        break;\n    }\n\n    return res;\n  });\n\n  return value => v({ type, value });\n}\n\n/**\n * @param {Visitor[]} visitors \n * @param {string} key \n */\nfunction extractFunctions(visitors, key) {\n  let functions = [];\n  for (let visitor of visitors) {\n    let f = visitor[key];\n    if (f) {\n      functions.push(f);\n    }\n  }\n  return functions;\n}\n\n/**\n * @param {Visitor} res \n * @param {Visitor[]} visitors \n * @param {string} key \n */\nfunction composeSimpleVisitors(res, visitors, key) {\n  let functions = extractFunctions(visitors, key);\n  if (functions.length === 0) {\n    return;\n  }\n\n  if (functions.length === 1) {\n    res[key] = functions[0];\n    return;\n  }\n\n  res[key] = arg => {\n    let mutated = false;\n    for (let f of functions) {\n      let res = f(arg);\n      if (res) {\n        arg = res;\n        mutated = true;\n      }\n    }\n\n    return mutated ? arg : undefined;\n  };\n}\n\n/**\n * @param {Visitor} res \n * @param {Visitor[]} visitors \n * @param {string} key \n */\nfunction composeArrayFunctions(res, visitors, key) {\n  let functions = extractFunctions(visitors, key);\n  if (functions.length === 0) {\n    return;\n  }\n\n  if (functions.length === 1) {\n    res[key] = functions[0];\n    return;\n  }\n\n  res[key] = createArrayVisitor(functions, (f, item) => f(item));\n}\n\n/**\n * @template T\n * @template V\n * @param {T[]} visitors \n * @param {(visitor: T, item: V) => V | V[] | void} apply \n * @returns {(item: V) => V | V[] | void}\n */\nfunction createArrayVisitor(visitors, apply) {\n  let seen = new Bitset(visitors.length);\n  return arg => {\n    let arr = [arg];\n    let mutated = false;\n    seen.clear();\n    for (let i = 0; i < arr.length; i++) {\n      // For each value, call all visitors. If a visitor returns a new value,\n      // we start over, but skip the visitor that generated the value or saw\n      // it before (to avoid cycles). This way, visitors can be composed in any order. \n      for (let v = 0; v < visitors.length && i < arr.length;) {\n        if (seen.get(v)) {\n          v++;\n          continue;\n        }\n\n        let item = arr[i];\n        let visitor = visitors[v];\n        let res = apply(visitor, item);\n        if (Array.isArray(res)) {\n          if (res.length === 0) {\n            arr.splice(i, 1);\n          } else if (res.length === 1) {\n            arr[i] = res[0];\n          } else {\n            arr.splice(i, 1, ...res);\n          }\n          mutated = true;\n          seen.set(v);\n          v = 0;\n        } else if (res) {\n          arr[i] = res;\n          mutated = true;\n          seen.set(v);\n          v = 0;\n        } else {\n          v++;\n        }\n      }\n    }\n\n    if (!mutated) {\n      return;\n    }\n\n    return arr.length === 1 ? arr[0] : arr;\n  };\n}\n\nclass Bitset {\n  constructor(maxBits = 32) {\n    this.bits = 0;\n    this.more = maxBits > 32 ? new Uint32Array(Math.ceil((maxBits - 32) / 32)) : null;\n  }\n\n  /** @param {number} bit */\n  get(bit) {\n    if (bit >= 32 && this.more) {\n      let i = Math.floor((bit - 32) / 32);\n      let b = bit % 32;\n      return Boolean(this.more[i] & (1 << b));\n    } else {\n      return Boolean(this.bits & (1 << bit));\n    }\n  }\n\n  /** @param {number} bit */\n  set(bit) {\n    if (bit >= 32 && this.more) {\n      let i = Math.floor((bit - 32) / 32);\n      let b = bit % 32;\n      this.more[i] |= 1 << b;\n    } else {\n      this.bits |= 1 << bit;\n    }\n  }\n\n  clear() {\n    this.bits = 0;\n    if (this.more) {\n      this.more.fill(0);\n    }\n  }\n}\n",
    "// This file is autogenerated by build-prefixes.js. DO NOT EDIT!\n\nexports.Features = {\n  Nesting: 1,\n  NotSelectorList: 2,\n  DirSelector: 4,\n  LangSelectorList: 8,\n  IsSelector: 16,\n  TextDecorationThicknessPercent: 32,\n  MediaIntervalSyntax: 64,\n  MediaRangeSyntax: 128,\n  CustomMediaQueries: 256,\n  ClampFunction: 512,\n  ColorFunction: 1024,\n  OklabColors: 2048,\n  LabColors: 4096,\n  P3Colors: 8192,\n  HexAlphaColors: 16384,\n  SpaceSeparatedColorNotation: 32768,\n  FontFamilySystemUi: 65536,\n  DoublePositionGradients: 131072,\n  VendorPrefixes: 262144,\n  LogicalProperties: 524288,\n  LightDark: 1048576,\n  Selectors: 31,\n  MediaQueries: 448,\n  Colors: 1113088,\n};\n",
    "let parts = [process.platform, process.arch];\nif (process.platform === 'linux') {\n  const { MUSL, familySync } = require('detect-libc');\n  const family = familySync();\n  if (family === MUSL) {\n    parts.push('musl');\n  } else if (process.arch === 'arm') {\n    parts.push('gnueabihf');\n  } else {\n    parts.push('gnu');\n  }\n} else if (process.platform === 'win32') {\n  parts.push('msvc');\n}\n\nlet native;\ntry {\n  native = require(`lightningcss-${parts.join('-')}`);\n} catch (err) {\n  native = require(`../lightningcss.${parts.join('-')}.node`);\n}\n\nmodule.exports.transform = wrap(native.transform);\nmodule.exports.transformStyleAttribute = wrap(native.transformStyleAttribute);\nmodule.exports.bundle = wrap(native.bundle);\nmodule.exports.bundleAsync = wrap(native.bundleAsync);\nmodule.exports.browserslistToTargets = require('./browserslistToTargets');\nmodule.exports.composeVisitors = require('./composeVisitors');\nmodule.exports.Features = require('./flags').Features;\n\nfunction wrap(call) {\n  return (options) => {\n    if (typeof options.visitor === 'function') {\n      let deps = [];\n      options.visitor = options.visitor({\n        addDependency(dep) {\n          deps.push(dep);\n        }\n      });\n\n      let result = call(options);\n      if (result instanceof Promise) {\n        result = result.then(res => {\n          if (deps.length) {\n            res.dependencies ??= [];\n            res.dependencies.push(...deps);\n          }\n          return res;\n        });\n      } else if (deps.length) {\n        result.dependencies ??= [];\n        result.dependencies.push(...deps);\n      }\n      return result;\n    } else {\n      return call(options);\n    }\n  };\n}\n",
    "#!/usr/bin/env bun\n/**\n * Postbuild CSS purge — standalone Bun script.\n *\n * Runs after rsbuild build, purges CSS files in dist/ using a database-first\n * component manifest and consumer JSX usage analysis.\n *\n * Conservative rules:\n *   - selectors owned only by unused known components can be removed\n *   - selectors owned by used components but unused known prop variants can be removed\n *   - selectors with unknown ownership are kept\n *   - data/aria runtime state is kept when the owning component selector is kept\n *   - vars/keyframes are removed only after selector purge proves them unreferenced\n */\n\nimport { Glob } from \"bun\";\nimport { transform } from \"lightningcss\";\nimport type { AtRule, Rule } from \"postcss\";\nimport postcss from \"postcss\";\nimport type {\n\tComponentPurgeRecord,\n\tLegacyComponentManifest,\n\tPurgeManifest,\n\tSafelists,\n} from \"./scan-consumer\";\nimport { buildSafelists, scanConsumerSource } from \"./scan-consumer\";\n\n// ── CLI args ──────────────────────────────────────────────────────────────────\n\nfunction parseArgs(argv: string[]): {\n\tdistDir: string;\n\tsrcDir: string;\n\tmanifestPath: string;\n} {\n\tconst args = argv.slice(2);\n\tlet distDir = \"./dist\";\n\tlet srcDir = \"./src\";\n\tlet manifestPath = \"\";\n\n\tfor (let i = 0; i < args.length; i++) {\n\t\tif (args[i] === \"--dist\" && args[i + 1]) distDir = args[++i];\n\t\telse if (args[i] === \"--src\" && args[i + 1]) srcDir = args[++i];\n\t\telse if (args[i] === \"--manifest\" && args[i + 1]) manifestPath = args[++i];\n\t}\n\n\tif (!manifestPath) {\n\t\tconsole.error(\n\t\t\t\"Usage: bunx @pathscale/rsbuild-plugin-ui-css-purge --manifest <path> [--dist <path>] [--src <path>]\",\n\t\t);\n\t\tprocess.exit(1);\n\t}\n\n\treturn { distDir, srcDir, manifestPath };\n}\n\n// ── Database normalization ────────────────────────────────────────────────────\n\ninterface NormalizedComponentRecord extends LegacyComponentManifest {\n\tkey: string;\n\tcomponent: string;\n\tpart?: string;\n\tselectors: string[];\n\tattributeSelectors: string[];\n\tcssVars: {\n\t\tdeclared: string[];\n\t\treferenced: string[];\n\t};\n\tkeyframes: {\n\t\tdeclared: string[];\n\t\treferenced: string[];\n\t};\n}\n\ninterface NormalizedPurgeDatabase {\n\tversion: 2;\n\tcomponents: Record<string, NormalizedComponentRecord>;\n}\n\nfunction normalizePurgeDatabase(\n\tmanifest: PurgeManifest,\n): NormalizedPurgeDatabase {\n\tconst rawComponents =\n\t\t\"version\" in manifest && manifest.version === 2\n\t\t\t? manifest.components\n\t\t\t: manifest;\n\tconst components: Record<string, NormalizedComponentRecord> = {};\n\n\tfor (const [key, record] of Object.entries(rawComponents)) {\n\t\tconst maybeV2 = record as ComponentPurgeRecord;\n\t\tconst [fallbackComponent, fallbackPart] = splitComponentKey(key);\n\t\tcomponents[key] = {\n\t\t\t...record,\n\t\t\tkey: maybeV2.key ?? key,\n\t\t\tcomponent: maybeV2.component ?? fallbackComponent,\n\t\t\tpart: maybeV2.part ?? fallbackPart,\n\t\t\tselectors: maybeV2.selectors ?? [],\n\t\t\tattributeSelectors: maybeV2.attributeSelectors ?? [],\n\t\t\tcssVars: {\n\t\t\t\tdeclared: maybeV2.cssVars?.declared ?? [],\n\t\t\t\treferenced: maybeV2.cssVars?.referenced ?? [],\n\t\t\t},\n\t\t\tkeyframes: {\n\t\t\t\tdeclared: maybeV2.keyframes?.declared ?? [],\n\t\t\t\treferenced: maybeV2.keyframes?.referenced ?? [],\n\t\t\t},\n\t\t};\n\t}\n\n\treturn { version: 2, components };\n}\n\nfunction splitComponentKey(key: string): [string, string | undefined] {\n\tconst [component, ...part] = key.split(\".\");\n\treturn [component, part.length > 0 ? part.join(\".\") : undefined];\n}\n\nfunction rootComponent(key: string): string {\n\treturn key.split(\".\")[0];\n}\n\nfunction collectClassesFromEntry(entry: LegacyComponentManifest): string[] {\n\tconst result = [...entry.classes.always];\n\tfor (const value of Object.values(entry.classes.byProp)) {\n\t\tif (Array.isArray(value)) {\n\t\t\tresult.push(...value);\n\t\t} else {\n\t\t\tfor (const classes of Object.values(value)) {\n\t\t\t\tresult.push(...classes);\n\t\t\t}\n\t\t}\n\t}\n\treturn [...new Set(result)];\n}\n\nfunction buildClassOwners(\n\tdatabase: NormalizedPurgeDatabase,\n): Map<string, Set<string>> {\n\tconst owners = new Map<string, Set<string>>();\n\tfor (const [key, entry] of Object.entries(database.components)) {\n\t\tfor (const cls of collectClassesFromEntry(entry)) {\n\t\t\tconst existing = owners.get(cls) ?? new Set<string>();\n\t\t\texisting.add(key);\n\t\t\towners.set(cls, existing);\n\t\t}\n\t}\n\treturn owners;\n}\n\nfunction isRecordUsed(recordKey: string, safelists: Safelists): boolean {\n\treturn (\n\t\tsafelists.usedComponents.has(recordKey) ||\n\t\tsafelists.usedComponents.has(rootComponent(recordKey))\n\t);\n}\n\nfunction isClassAllowed(\n\tcls: string,\n\towners: Map<string, Set<string>>,\n\tsafelists: Safelists,\n): boolean {\n\tconst classOwners = owners.get(cls);\n\tif (!classOwners) return true;\n\tfor (const owner of classOwners) {\n\t\tif (isRecordUsed(owner, safelists) && safelists.classSafelist.has(cls)) {\n\t\t\treturn true;\n\t\t}\n\t}\n\treturn false;\n}\n\n// ── Selector purge ─────────────────────────────────────────────────────────────\n\ninterface SelectorPurgeReport {\n\tselectorsKeptKnown: number;\n\tselectorsKeptUnknown: number;\n\tselectorsRemoved: number;\n\tselectorsRemovedUnusedComponent: number;\n\tselectorsRemovedUnusedVariant: number;\n\tattrSelectorsSeen: number;\n\tkeyframesRemoved: number;\n\tfontFacesRemoved: number;\n}\n\ninterface PurgeResult {\n\tcss: string;\n\treport: SelectorPurgeReport;\n}\n\nfunction emptySelectorReport(): SelectorPurgeReport {\n\treturn {\n\t\tselectorsKeptKnown: 0,\n\t\tselectorsKeptUnknown: 0,\n\t\tselectorsRemoved: 0,\n\t\tselectorsRemovedUnusedComponent: 0,\n\t\tselectorsRemovedUnusedVariant: 0,\n\t\tattrSelectorsSeen: 0,\n\t\tkeyframesRemoved: 0,\n\t\tfontFacesRemoved: 0,\n\t};\n}\n\n/** Unescape CSS identifiers: `icon-\\[mdi--cog\\]` -> `icon-[mdi--cog]` */\nfunction unescapeCss(s: string): string {\n\treturn s.replace(/\\\\(.)/g, \"$1\");\n}\n\nfunction extractClassesFromSelector(selector: string): string[] {\n\tconst matches = selector.matchAll(\n\t\t/\\.([a-zA-Z_-](?:[a-zA-Z0-9_-]|\\\\[^\\s.#:[>+~,)]*)*)/g,\n\t);\n\treturn [...matches].map((m) => unescapeCss(m[1]));\n}\n\nfunction extractAttrsFromSelector(selector: string): string[] {\n\tconst matches = selector.matchAll(\n\t\t/\\[(data-[a-zA-Z0-9_-]+|aria-[a-zA-Z0-9_-]+)(?:=(?:\"([^\"]*)\"|'([^']*)'|([^\\]]+)))?\\]/g,\n\t);\n\treturn [...matches].map((m) => {\n\t\tconst value = m[2] ?? m[3] ?? m[4];\n\t\treturn value === undefined ? `[${m[1]}]` : `[${m[1]}=\"${value.trim()}\"]`;\n\t});\n}\n\nfunction selectorDecision(\n\tselector: string,\n\towners: Map<string, Set<string>>,\n\tsafelists: Safelists,\n):\n\t| \"keep-known\"\n\t| \"keep-unknown\"\n\t| \"remove-unused-component\"\n\t| \"remove-unused-variant\" {\n\tconst attrs = extractAttrsFromSelector(selector);\n\tif (attrs.some((attr) => safelists.attrSafelist.has(attr))) {\n\t\treturn \"keep-known\";\n\t}\n\n\tconst classes = extractClassesFromSelector(selector);\n\tif (classes.length === 0) return \"keep-unknown\";\n\n\tconst hasUnknownClass = classes.some((cls) => !owners.has(cls));\n\tif (hasUnknownClass) return \"keep-unknown\";\n\n\tconst hasUsedOwner = classes.some((cls) => {\n\t\tconst classOwners = owners.get(cls);\n\t\treturn [...(classOwners ?? [])].some((owner) =>\n\t\t\tisRecordUsed(owner, safelists),\n\t\t);\n\t});\n\n\tif (!hasUsedOwner) return \"remove-unused-component\";\n\n\tif (classes.every((cls) => isClassAllowed(cls, owners, safelists))) {\n\t\treturn \"keep-known\";\n\t}\n\n\treturn \"remove-unused-variant\";\n}\n\nfunction purgeCssWithDatabase(\n\tcss: string,\n\tmanifest: PurgeManifest | NormalizedPurgeDatabase,\n\tsafelists: Safelists,\n): PurgeResult {\n\tconst database = normalizePurgeDatabase(manifest as PurgeManifest);\n\tconst classOwners = buildClassOwners(database);\n\tconst report = emptySelectorReport();\n\tconst root = postcss.parse(css);\n\n\troot.walkRules((rule) => {\n\t\tconst selectors = rule.selectors;\n\t\tconst kept: string[] = [];\n\n\t\tfor (const selector of selectors) {\n\t\t\treport.attrSelectorsSeen += extractAttrsFromSelector(selector).length;\n\t\t\tconst decision = selectorDecision(selector, classOwners, safelists);\n\t\t\tif (decision === \"keep-known\") {\n\t\t\t\treport.selectorsKeptKnown++;\n\t\t\t\tkept.push(selector);\n\t\t\t} else if (decision === \"keep-unknown\") {\n\t\t\t\treport.selectorsKeptUnknown++;\n\t\t\t\tkept.push(selector);\n\t\t\t} else {\n\t\t\t\treport.selectorsRemoved++;\n\t\t\t\tif (decision === \"remove-unused-component\") {\n\t\t\t\t\treport.selectorsRemovedUnusedComponent++;\n\t\t\t\t} else {\n\t\t\t\t\treport.selectorsRemovedUnusedVariant++;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (kept.length === 0) {\n\t\t\trule.remove();\n\t\t} else if (kept.length < selectors.length) {\n\t\t\trule.selectors = kept;\n\t\t}\n\t});\n\n\tremoveUnusedKeyframes(root, report);\n\tremoveUnusedFontFaces(root, report);\n\tremoveEmptyAtRules(root);\n\n\treturn { css: root.toString(), report };\n}\n\nfunction removeUnusedKeyframes(\n\troot: postcss.Root,\n\treport: SelectorPurgeReport,\n) {\n\tconst usedKeyframes = new Set<string>();\n\troot.walkDecls(/^animation(-name)?$/, (decl) => {\n\t\tfor (const part of decl.value.split(\",\")) {\n\t\t\tconst name = part.trim().split(/\\s+/)[0];\n\t\t\tif (name && ![\"none\", \"initial\", \"inherit\", \"unset\"].includes(name)) {\n\t\t\t\tusedKeyframes.add(name);\n\t\t\t}\n\t\t}\n\t});\n\n\troot.walkAtRules(\"keyframes\", (atRule) => {\n\t\tif (!usedKeyframes.has(atRule.params.trim())) {\n\t\t\tatRule.remove();\n\t\t\treport.keyframesRemoved++;\n\t\t}\n\t});\n}\n\nfunction removeUnusedFontFaces(\n\troot: postcss.Root,\n\treport: SelectorPurgeReport,\n) {\n\tconst usedFonts = new Set<string>();\n\troot.walkDecls(/^font(-family)?$/, (decl) => {\n\t\tfor (const part of decl.value.split(\",\")) {\n\t\t\tconst name = part.trim().replace(/^[\"']|[\"']$/g, \"\");\n\t\t\tif (name) usedFonts.add(name);\n\t\t}\n\t});\n\n\troot.walkAtRules(\"font-face\", (atRule) => {\n\t\tlet family = \"\";\n\t\tatRule.walkDecls(\"font-family\", (decl) => {\n\t\t\tfamily = decl.value.trim().replace(/^[\"']|[\"']$/g, \"\");\n\t\t});\n\t\tif (family && !usedFonts.has(family)) {\n\t\t\tatRule.remove();\n\t\t\treport.fontFacesRemoved++;\n\t\t}\n\t});\n}\n\nfunction removeEmptyAtRules(root: postcss.Root) {\n\tlet cleaned = true;\n\twhile (cleaned) {\n\t\tcleaned = false;\n\t\troot.walkAtRules((atRule) => {\n\t\t\tif (atRule.nodes && atRule.nodes.length === 0) {\n\t\t\t\tatRule.remove();\n\t\t\t\tcleaned = true;\n\t\t\t}\n\t\t});\n\t}\n}\n\n// ── Runtime CSS variable references ──────────────────────────────────────────\n\nasync function collectRuntimeCssVarRefs(distDir: string): Promise<Set<string>> {\n\tconst refs = new Set<string>();\n\tconst glob = new Glob(\"**/*.{js,mjs,cjs}\");\n\n\tfor await (const relPath of glob.scan({ cwd: distDir })) {\n\t\tconst fullPath = `${distDir}/${relPath}`;\n\t\tconst code = await Bun.file(fullPath).text();\n\t\tfor (const match of code.matchAll(/var\\(\\s*(--[a-zA-Z0-9_-]+)/g)) {\n\t\t\trefs.add(match[1]);\n\t\t}\n\t}\n\n\treturn refs;\n}\n\n// ── Unused CSS variable cleanup ───────────────────────────────────────────────\n\ninterface VarCleanupResult {\n\tcss: string;\n\tremoved: number;\n}\n\n// TODO: potentially reduce parsing amount\nfunction cleanUnusedVarsWithReport(\n\tcss: string,\n\texternallyReferencedVars: Set<string>,\n): VarCleanupResult {\n\tlet changed = true;\n\tlet result = css;\n\tlet removed = 0;\n\n\twhile (changed) {\n\t\tchanged = false;\n\t\tconst root = postcss.parse(result);\n\n\t\tconst declared = new Map<string, { rule: Rule | AtRule; prop: string }[]>();\n\t\troot.walkDecls(/^--/, (decl) => {\n\t\t\tconst entries = declared.get(decl.prop) ?? [];\n\t\t\tentries.push({ rule: decl.parent as Rule, prop: decl.prop });\n\t\t\tdeclared.set(decl.prop, entries);\n\t\t});\n\n\t\tconst referenced = new Set<string>(externallyReferencedVars);\n\t\troot.walkDecls((decl) => {\n\t\t\tfor (const ref of decl.value.matchAll(/var\\(\\s*(--[a-zA-Z0-9_-]+)/g)) {\n\t\t\t\treferenced.add(ref[1]);\n\t\t\t}\n\t\t});\n\n\t\tfor (const [varName, entries] of declared) {\n\t\t\tif (!referenced.has(varName)) {\n\t\t\t\tfor (const entry of entries) {\n\t\t\t\t\tentry.rule.walkDecls(entry.prop, (decl) => {\n\t\t\t\t\t\tdecl.remove();\n\t\t\t\t\t\tchanged = true;\n\t\t\t\t\t\tremoved++;\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\troot.walkRules((rule) => {\n\t\t\tif (rule.nodes && rule.nodes.length === 0) rule.remove();\n\t\t});\n\t\tremoveEmptyAtRules(root);\n\n\t\tresult = root.toString();\n\t}\n\n\treturn { css: result, removed };\n}\n\nfunction cleanUnusedVars(\n\tcss: string,\n\texternallyReferencedVars: Set<string>,\n): string {\n\treturn cleanUnusedVarsWithReport(css, externallyReferencedVars).css;\n}\n\n// ── Minification: Lightning CSS ──────────────────────────────────────────────\n\nfunction minify(css: string): string {\n\tconst { code } = transform({\n\t\tfilename: \"purged.css\",\n\t\tcode: Buffer.from(css),\n\t\tminify: true,\n\t\terrorRecovery: true,\n\t});\n\treturn code.toString();\n}\n\n// ── Main ──────────────────────────────────────────────────────────────────────\n\nasync function main() {\n\tconst { distDir, srcDir, manifestPath } = parseArgs(process.argv);\n\n\tconst manifest: PurgeManifest = JSON.parse(\n\t\tawait Bun.file(manifestPath).text(),\n\t);\n\tconst database = normalizePurgeDatabase(manifest);\n\tconst roots = new Set(Object.keys(database.components).map(rootComponent));\n\tconsole.log(\n\t\t`[css-purge] Database loaded: ${Object.keys(database.components).length} records (${roots.size} components)`,\n\t);\n\n\tconst usages = await scanConsumerSource(srcDir);\n\tconst safelists = buildSafelists(usages, manifest);\n\tconst usedRoots = new Set([...safelists.usedComponents].map(rootComponent));\n\tconst removedRoots = [...roots].filter((root) => !usedRoots.has(root));\n\n\tconsole.log(\n\t\t`[css-purge] Components detected: ${usedRoots.size} used, ${removedRoots.length} removable`,\n\t);\n\tif (usedRoots.size > 0) {\n\t\tconsole.log(`[css-purge]   used: ${[...usedRoots].sort().join(\", \")}`);\n\t}\n\tif (removedRoots.length > 0) {\n\t\tconsole.log(`[css-purge]   removable: ${removedRoots.sort().join(\", \")}`);\n\t}\n\tconsole.log(\n\t\t`[css-purge] Safelist facts: ${safelists.classSafelist.size} classes, ${safelists.attrSafelist.size} attr selectors`,\n\t);\n\n\tconst runtimeCssVarRefs = await collectRuntimeCssVarRefs(distDir);\n\tif (runtimeCssVarRefs.size > 0) {\n\t\tconsole.log(\n\t\t\t`[css-purge] Runtime CSS vars referenced from JS: ${runtimeCssVarRefs.size}`,\n\t\t);\n\t}\n\n\tconst glob = new Glob(\"**/*.css\");\n\tlet totalBefore = 0;\n\tlet totalAfter = 0;\n\n\tfor await (const relPath of glob.scan({ cwd: distDir })) {\n\t\tconst fullPath = `${distDir}/${relPath}`;\n\t\tconst originalCss = await Bun.file(fullPath).text();\n\t\tconst originalSize = Buffer.byteLength(originalCss, \"utf-8\");\n\t\ttotalBefore += originalSize;\n\n\t\tconsole.log(\n\t\t\t`[css-purge] Processing ${relPath} (${(originalSize / 1024).toFixed(1)} KB)`,\n\t\t);\n\n\t\tconst purged = purgeCssWithDatabase(originalCss, database, safelists);\n\t\tlet purgedCss = purged.css;\n\t\tconst afterSelectors = Buffer.byteLength(purgedCss, \"utf-8\");\n\t\tconsole.log(\n\t\t\t`[css-purge]   selectors: ${(originalSize / 1024).toFixed(1)} -> ${(afterSelectors / 1024).toFixed(1)} KB (${purged.report.selectorsRemoved} removed, ${purged.report.selectorsKeptUnknown} kept unknown)`,\n\t\t);\n\t\tconsole.log(\n\t\t\t`[css-purge]   attrs seen: ${purged.report.attrSelectorsSeen}; keyframes removed: ${purged.report.keyframesRemoved}`,\n\t\t);\n\n\t\tconst vars = cleanUnusedVarsWithReport(purgedCss, runtimeCssVarRefs);\n\t\tpurgedCss = vars.css;\n\t\tconst afterVars = Buffer.byteLength(purgedCss, \"utf-8\");\n\t\tconsole.log(\n\t\t\t`[css-purge]   vars: ${(afterSelectors / 1024).toFixed(1)} -> ${(afterVars / 1024).toFixed(1)} KB (${vars.removed} removed)`,\n\t\t);\n\n\t\tpurgedCss = minify(purgedCss);\n\t\tconst finalSize = Buffer.byteLength(purgedCss, \"utf-8\");\n\t\ttotalAfter += finalSize;\n\t\tconsole.log(`[css-purge]   minify: -> ${(finalSize / 1024).toFixed(1)} KB`);\n\t\tconsole.log(\n\t\t\t`[css-purge]   final: ${(originalSize / 1024).toFixed(1)} -> ${(finalSize / 1024).toFixed(1)} KB (${((1 - finalSize / originalSize) * 100).toFixed(1)}% reduction)`,\n\t\t);\n\n\t\tawait Bun.write(fullPath, purgedCss);\n\t}\n\n\tconsole.log(\n\t\t`\\n[css-purge] Total: ${(totalBefore / 1024).toFixed(1)} -> ${(totalAfter / 1024).toFixed(1)} KB (${((1 - totalAfter / totalBefore) * 100).toFixed(1)}% reduction)`,\n\t);\n}\n\nif (import.meta.main) {\n\tmain();\n}\n\nexport {\n\tcleanUnusedVars,\n\tcleanUnusedVarsWithReport,\n\tnormalizePurgeDatabase,\n\tpurgeCssWithDatabase,\n};\nexport type {\n\tNormalizedPurgeDatabase,\n\tPurgeResult,\n\tSelectorPurgeReport,\n\tVarCleanupResult,\n};\n",
    "import index from './index.js';\n\nconst { transform, transformStyleAttribute, bundle, bundleAsync, browserslistToTargets, composeVisitors, Features } = index;\nexport { transform, transformStyleAttribute, bundle, bundleAsync, browserslistToTargets, composeVisitors, Features };\n",
    "/**\n * Consumer-side JSX scanner.\n *\n * Walks a consumer source tree, resolves @pathscale/ui imports with SWC, and\n * records canonical component/part usage plus prop facts for database-first CSS\n * purge decisions.\n *\n * Usage:  bun run src/scan-consumer.ts <consumer-src-dir> <purge-manifest.json>\n */\n\nimport swc from \"@swc/core\";\nimport { Glob } from \"bun\";\n\n// ── Types ──────────────────────────────────────────────────────────────────────\n\ninterface LegacyComponentManifest {\n\tclasses: {\n\t\talways: string[];\n\t\tbyProp: Record<string, string[] | Record<string, string[]>>;\n\t};\n\tattrs?: Record<string, Record<string, string>>;\n\tdeps?: string[];\n}\n\ninterface ComponentPurgeRecord extends LegacyComponentManifest {\n\tkey?: string;\n\tcomponent?: string;\n\tpart?: string;\n\tselectors?: string[];\n\tattributeSelectors?: string[];\n\tcssVars?: {\n\t\tdeclared?: string[];\n\t\treferenced?: string[];\n\t};\n\tkeyframes?: {\n\t\tdeclared?: string[];\n\t\treferenced?: string[];\n\t};\n}\n\ninterface PurgeDatabaseV2 {\n\tversion: 2;\n\tcomponents: Record<string, ComponentPurgeRecord>;\n\tshared?: {\n\t\tselectors?: unknown[];\n\t\tcssVars?: Record<string, unknown>;\n\t\tkeyframes?: Record<string, unknown>;\n\t};\n}\n\ntype PurgeManifest = Record<string, LegacyComponentManifest> | PurgeDatabaseV2;\n\n/** What we collect per component usage from JSX */\ninterface PropUsage {\n\tcomponent: string;\n\tprops: Map<string, string | \"DYNAMIC\">;\n\tbooleanProps: Set<string>;\n\thasSpread: boolean;\n\tsource?: string;\n}\n\ninterface ImportBindings {\n\tcomponents: Map<string, string>;\n\tnamespaces: Map<string, string | null>;\n\tconservativeUsages: PropUsage[];\n}\n\ninterface Safelists {\n\tclassSafelist: Set<string>;\n\tattrSafelist: Set<string>;\n\tusedComponents: Set<string>;\n\tdynamicComponents: Set<string>;\n}\n\ntype AstNode = Record<string, unknown>;\n\n// ── AST walker ─────────────────────────────────────────────────────────────────\n\nfunction walkAST(node: unknown, visitor: (node: AstNode) => void) {\n\tif (!isRecord(node)) return;\n\tvisitor(node);\n\tfor (const key of Object.keys(node)) {\n\t\tif (key === \"span\") continue;\n\t\tconst val = node[key];\n\t\tif (Array.isArray(val)) {\n\t\t\tfor (const item of val) walkAST(item, visitor);\n\t\t} else if (val && typeof val === \"object\") {\n\t\t\twalkAST(val, visitor);\n\t\t}\n\t}\n}\n\nfunction kebabToPascal(s: string): string {\n\treturn s\n\t\t.split(\"-\")\n\t\t.filter(Boolean)\n\t\t.map((p) => p.charAt(0).toUpperCase() + p.slice(1))\n\t\t.join(\"\");\n}\n\nfunction componentFromDeepImport(source: string): string | null {\n\tconst match = source.match(/^@pathscale\\/ui\\/components\\/([^/]+)/);\n\tif (!match) return null;\n\treturn kebabToPascal(match[1]);\n}\n\nfunction isUiImport(source: string | undefined): source is string {\n\treturn Boolean(source?.startsWith(\"@pathscale/ui\"));\n}\n\nfunction isRecord(v: unknown): v is Record<string, unknown> {\n\treturn v !== null && typeof v === \"object\" && !Array.isArray(v);\n}\n\nfunction getString(value: unknown, key: string): string | undefined {\n\tif (!isRecord(value)) return undefined;\n\tconst prop = value[key];\n\treturn typeof prop === \"string\" ? prop : undefined;\n}\n\nfunction getBoolean(value: unknown, key: string): boolean {\n\tif (!isRecord(value)) return false;\n\treturn value[key] === true;\n}\n\nfunction getPathString(value: unknown, ...keys: string[]): string | undefined {\n\tlet current = value;\n\tfor (const key of keys) {\n\t\tif (!isRecord(current)) return undefined;\n\t\tcurrent = current[key];\n\t}\n\treturn typeof current === \"string\" ? current : undefined;\n}\n\nfunction getArray(value: unknown, key: string): unknown[] {\n\tif (!isRecord(value)) return [];\n\tconst prop = value[key];\n\treturn Array.isArray(prop) ? prop : [];\n}\n\nfunction joinPath(base: string, rel: string): string {\n\treturn `${base.replace(/\\/+$/, \"\")}/${rel.replace(/^\\/+/, \"\")}`;\n}\n\nfunction canonicalImportedName(spec: unknown, source: string): string | null {\n\tconst importedName =\n\t\tgetPathString(spec, \"imported\", \"value\") ??\n\t\tgetPathString(spec, \"local\", \"value\") ??\n\t\tnull;\n\n\tconst deep = (c: string, t?: string): string | null => {\n\t\tif (t !== \"ImportSpecifier\") return c;\n\t\tif (!importedName) return null;\n\t\tif (importedName === c) return c;\n\t\treturn `${c}.${importedName}`;\n\t};\n\n\tconst type = getString(spec, \"type\");\n\tif (getBoolean(spec, \"isTypeOnly\")) return null;\n\tconst deepComponent = componentFromDeepImport(source);\n\tif (deepComponent) return deep(deepComponent, type);\n\n\tif (source === \"@pathscale/ui\" && type === \"ImportSpecifier\")\n\t\treturn importedName;\n\n\treturn null;\n}\n\nfunction conservativeUsage(component: string, source: string): PropUsage {\n\treturn {\n\t\tcomponent,\n\t\tprops: new Map(),\n\t\tbooleanProps: new Set(),\n\t\thasSpread: true,\n\t\tsource,\n\t};\n}\n\n/** Extract @pathscale/ui bindings from a parsed module. */\nfunction extractUIBindings(ast: unknown): ImportBindings {\n\tconst bindings: ImportBindings = {\n\t\tcomponents: new Map(),\n\t\tnamespaces: new Map(),\n\t\tconservativeUsages: [],\n\t};\n\n\tfor (const node of getArray(ast, \"body\")) {\n\t\tconst nodeType = getString(node, \"type\");\n\t\tif (nodeType === \"ImportDeclaration\") {\n\t\t\tconst source = getPathString(node, \"source\", \"value\");\n\t\t\tif (!isUiImport(source)) continue;\n\n\t\t\tfor (const spec of getArray(node, \"specifiers\")) {\n\t\t\t\tconst specType = getString(spec, \"type\");\n\t\t\t\tif (specType === \"ImportSpecifier\") {\n\t\t\t\t\tconst local = getPathString(spec, \"local\", \"value\");\n\t\t\t\t\tconst canonical = canonicalImportedName(spec, source);\n\t\t\t\t\tif (local && canonical) bindings.components.set(local, canonical);\n\t\t\t\t} else if (specType === \"ImportDefaultSpecifier\") {\n\t\t\t\t\tconst local = getPathString(spec, \"local\", \"value\");\n\t\t\t\t\tconst canonical = componentFromDeepImport(source) ?? local;\n\t\t\t\t\tif (local && canonical) bindings.components.set(local, canonical);\n\t\t\t\t} else if (specType === \"ImportNamespaceSpecifier\") {\n\t\t\t\t\tconst local = getPathString(spec, \"local\", \"value\");\n\t\t\t\t\tif (local)\n\t\t\t\t\t\tbindings.namespaces.set(local, componentFromDeepImport(source));\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (\n\t\t\tnodeType === \"ExportNamedDeclaration\" &&\n\t\t\tisUiImport(getPathString(node, \"source\", \"value\"))\n\t\t) {\n\t\t\tconst source = getPathString(node, \"source\", \"value\");\n\t\t\tif (!source) continue;\n\t\t\tconst deepComponent = componentFromDeepImport(source);\n\t\t\tfor (const spec of getArray(node, \"specifiers\")) {\n\t\t\t\tconst exported =\n\t\t\t\t\tgetPathString(spec, \"orig\", \"value\") ??\n\t\t\t\t\tgetPathString(spec, \"local\", \"value\") ??\n\t\t\t\t\tgetPathString(spec, \"exported\", \"value\") ??\n\t\t\t\t\tdeepComponent;\n\t\t\t\tconst canonical = deepComponent ?? exported;\n\t\t\t\tif (canonical)\n\t\t\t\t\tbindings.conservativeUsages.push(\n\t\t\t\t\t\tconservativeUsage(canonical, source),\n\t\t\t\t\t);\n\t\t\t}\n\t\t}\n\n\t\tif (\n\t\t\tnodeType === \"ExportAllDeclaration\" &&\n\t\t\tisUiImport(getPathString(node, \"source\", \"value\"))\n\t\t) {\n\t\t\tconst source = getPathString(node, \"source\", \"value\");\n\t\t\tif (!source) continue;\n\t\t\tconst deepComponent = componentFromDeepImport(source);\n\t\t\tif (deepComponent) {\n\t\t\t\tbindings.conservativeUsages.push(\n\t\t\t\t\tconservativeUsage(deepComponent, source),\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn bindings;\n}\n\n/** Back-compatible import extraction API: local binding -> canonical component. */\nfunction extractUIImports(ast: unknown): Map<string, string> {\n\treturn extractUIBindings(ast).components;\n}\n\nfunction jsxNameParts(name: unknown): string[] {\n\tif (!name) return [];\n\tconst type = getString(name, \"type\");\n\tconst value = getString(name, \"value\");\n\tif ((type === \"Identifier\" || type === \"JSXIdentifier\") && value)\n\t\treturn [value];\n\tif (type === \"JSXMemberExpression\") {\n\t\treturn [\n\t\t\t...jsxNameParts(isRecord(name) ? name.object : undefined),\n\t\t\t...jsxNameParts(isRecord(name) ? name.property : undefined),\n\t\t];\n\t}\n\treturn [];\n}\n\nfunction canonicalComponentFromJsx(\n\tparts: string[],\n\tbindings: ImportBindings,\n): string | null {\n\tif (parts.length === 0) return null;\n\tconst [root, ...members] = parts;\n\n\tconst namespaceComponent = bindings.namespaces.get(root);\n\tif (bindings.namespaces.has(root)) {\n\t\tif (namespaceComponent) {\n\t\t\tconst lower = members.map((m) => m.toLowerCase());\n\t\t\treturn [namespaceComponent, ...lower].join(\".\");\n\t\t}\n\t\treturn members.join(\".\") || null;\n\t}\n\n\tconst rootComponent = bindings.components.get(root);\n\tif (!rootComponent) return null;\n\n\tconst lower = members.map((m) => m.toLowerCase());\n\treturn [rootComponent, ...lower].join(\".\");\n}\n\n/** Extract JSX usages of UI components. */\nfunction extractJSXUsages(\n\tast: unknown,\n\tuiComponents: Map<string, string>,\n): PropUsage[] {\n\tconst bindings: ImportBindings = {\n\t\tcomponents: uiComponents,\n\t\tnamespaces: extractUIBindings(ast).namespaces,\n\t\tconservativeUsages: [],\n\t};\n\tconst usages: PropUsage[] = [];\n\n\twalkAST(ast, (node) => {\n\t\tif (getString(node, \"type\") !== \"JSXOpeningElement\") return;\n\n\t\tconst component = canonicalComponentFromJsx(\n\t\t\tjsxNameParts(node.name),\n\t\t\tbindings,\n\t\t);\n\t\tif (!component) return;\n\n\t\tconst usage: PropUsage = {\n\t\t\tcomponent,\n\t\t\tprops: new Map(),\n\t\t\tbooleanProps: new Set(),\n\t\t\thasSpread: false,\n\t\t};\n\n\t\tfor (const attr of getArray(node, \"attributes\")) {\n\t\t\tconst attrType = getString(attr, \"type\");\n\t\t\tif (attrType === \"SpreadElement\" || attrType === \"JSXSpreadAttribute\") {\n\t\t\t\tusage.hasSpread = true;\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (attrType !== \"JSXAttribute\") continue;\n\n\t\t\tconst propName = getPathString(attr, \"name\", \"value\");\n\t\t\tif (!propName) continue;\n\n\t\t\tconst attrValue = isRecord(attr) ? attr.value : undefined;\n\t\t\tconst attrValueType = getString(attrValue, \"type\");\n\t\t\tif (!attrValue) {\n\t\t\t\tusage.booleanProps.add(propName);\n\t\t\t} else if (attrValueType === \"StringLiteral\") {\n\t\t\t\tusage.props.set(propName, getString(attrValue, \"value\") ?? \"\");\n\t\t\t} else {\n\t\t\t\tusage.props.set(propName, \"DYNAMIC\");\n\t\t\t}\n\t\t}\n\n\t\tusages.push(usage);\n\t});\n\n\treturn usages;\n}\n\n// ── Manifest compatibility ────────────────────────────────────────────────────\n\nfunction manifestComponents(\n\tmanifest: PurgeManifest,\n): Record<string, LegacyComponentManifest> {\n\tif (isPurgeDatabaseV2(manifest)) {\n\t\treturn manifest.components;\n\t}\n\treturn manifest as Record<string, LegacyComponentManifest>;\n}\n\nfunction isPurgeDatabaseV2(\n\tmanifest: PurgeManifest,\n): manifest is PurgeDatabaseV2 {\n\treturn (\n\t\t(manifest as PurgeDatabaseV2).version === 2 &&\n\t\tisRecord((manifest as PurgeDatabaseV2).components)\n\t);\n}\n\n// ── Safelist builder ───────────────────────────────────────────────────────────\n\nfunction buildSafelists(\n\tallUsages: PropUsage[],\n\tmanifest: PurgeManifest,\n): Safelists {\n\tconst classSafelist = new Set<string>();\n\tconst attrSafelist = new Set<string>();\n\tconst usedComponents = new Set<string>();\n\tconst dynamicComponents = new Set<string>();\n\tconst componentUsages = new Map<string, PropUsage[]>();\n\tconst components = manifestComponents(manifest);\n\n\tfor (const usage of expandDependencyUsages(allUsages, components)) {\n\t\tconst existing = componentUsages.get(usage.component) ?? [];\n\t\texisting.push(usage);\n\t\tcomponentUsages.set(usage.component, existing);\n\t\tusedComponents.add(usage.component);\n\t\tif (usage.hasSpread || [...usage.props.values()].includes(\"DYNAMIC\")) {\n\t\t\tdynamicComponents.add(usage.component);\n\t\t}\n\t}\n\n\tfor (const [entryName, entry] of Object.entries(components)) {\n\t\tconst matchingUsages = findMatchingUsages(entryName, componentUsages);\n\t\tif (matchingUsages.length === 0) continue;\n\n\t\tusedComponents.add(entryName);\n\n\t\tfor (const cls of entry.classes.always) {\n\t\t\tclassSafelist.add(cls);\n\t\t}\n\n\t\tfor (const [propOrSlot, value] of Object.entries(entry.classes.byProp)) {\n\t\t\tif (Array.isArray(value)) {\n\t\t\t\tif (isPropUsed(propOrSlot, matchingUsages)) {\n\t\t\t\t\tfor (const cls of value) classSafelist.add(cls);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tconst usedValues = getUsedEnumValues(propOrSlot, matchingUsages);\n\t\t\t\tif (usedValues === \"ALL\") {\n\t\t\t\t\tfor (const classes of Object.values(value)) {\n\t\t\t\t\t\tfor (const cls of classes) classSafelist.add(cls);\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tfor (const val of usedValues) {\n\t\t\t\t\t\tif (value[val]) {\n\t\t\t\t\t\t\tfor (const cls of value[val]) classSafelist.add(cls);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (entry.attrs) {\n\t\t\tfor (const [propName, attrMap] of Object.entries(entry.attrs)) {\n\t\t\t\tif (isPropUsed(propName, matchingUsages)) {\n\t\t\t\t\tfor (const [attr, val] of Object.entries(attrMap)) {\n\t\t\t\t\t\tattrSafelist.add(`[${attr}=\"${val}\"]`);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn { classSafelist, attrSafelist, usedComponents, dynamicComponents };\n}\n\nfunction expandDependencyUsages(\n\tallUsages: PropUsage[],\n\tmanifest: Record<string, LegacyComponentManifest>,\n): PropUsage[] {\n\tconst result = [...allUsages];\n\tconst queue = [...allUsages.map((usage) => rootComponent(usage.component))];\n\tconst seen = new Set(queue);\n\n\twhile (queue.length > 0) {\n\t\tconst root = queue.pop();\n\t\tif (!root) continue;\n\t\tconst deps = depsForRoot(root, manifest);\n\t\tfor (const dep of deps) {\n\t\t\tif (seen.has(dep)) continue;\n\t\t\tseen.add(dep);\n\t\t\tqueue.push(dep);\n\t\t\tresult.push(conservativeUsage(dep, \"manifest-dependency\"));\n\t\t}\n\t}\n\n\treturn result;\n}\n\nfunction depsForRoot(\n\troot: string,\n\tmanifest: Record<string, LegacyComponentManifest>,\n): string[] {\n\tconst deps = new Set<string>();\n\tfor (const [key, entry] of Object.entries(manifest)) {\n\t\tif (rootComponent(key) !== root) continue;\n\t\tfor (const dep of entry.deps ?? []) deps.add(dep);\n\t}\n\treturn [...deps];\n}\n\nfunction rootComponent(component: string): string {\n\treturn component.split(\".\")[0];\n}\n\nfunction findMatchingUsages(\n\tentryName: string,\n\tusageMap: Map<string, PropUsage[]>,\n): PropUsage[] {\n\tconst direct = usageMap.get(entryName) ?? [];\n\tconst results = [...direct];\n\tconst entryRoot = rootComponent(entryName);\n\n\tfor (const [usageName, usages] of usageMap) {\n\t\tif (usageName === entryName) continue;\n\t\tif (entryName.includes(\".\") && usageName === entryRoot) {\n\t\t\tresults.push(...usages);\n\t\t}\n\t}\n\n\treturn results;\n}\n\nfunction isPropUsed(propName: string, usages: PropUsage[]): boolean {\n\tfor (const usage of usages) {\n\t\tif (usage.hasSpread) return true;\n\t\tif (usage.booleanProps.has(propName)) return true;\n\t\tif (usage.props.has(propName)) return true;\n\t}\n\treturn false;\n}\n\nfunction getUsedEnumValues(\n\tslotName: string,\n\tusages: PropUsage[],\n): Set<string> | \"ALL\" {\n\tconst values = new Set<string>();\n\tfor (const usage of usages) {\n\t\tif (usage.hasSpread) return \"ALL\";\n\t\tconst val = usage.props.get(slotName);\n\t\tif (val === \"DYNAMIC\") return \"ALL\";\n\t\tif (val !== undefined) values.add(val);\n\t\tif (usage.booleanProps.has(slotName)) return \"ALL\";\n\t}\n\treturn values;\n}\n\n// ── Consumer source scanning ───────────────────────────────────────────────────\n\nasync function scanConsumerSource(srcDir: string): Promise<PropUsage[]> {\n\tconst allUsages: PropUsage[] = [];\n\tconst glob = new Glob(\"**/*.{tsx,ts,jsx,js}\");\n\n\tfor await (const relPath of glob.scan({ cwd: srcDir })) {\n\t\tif (relPath.includes(\"node_modules\")) continue;\n\t\tconst fullPath = joinPath(srcDir, relPath);\n\t\tconst code = await Bun.file(fullPath).text();\n\t\tif (!code.includes(\"@pathscale/ui\")) continue;\n\n\t\tconst isTsx = /\\.[tj]sx$/.test(relPath);\n\t\tconst ast = await swc.parse(code, { syntax: \"typescript\", tsx: isTsx });\n\t\tconst bindings = extractUIBindings(ast);\n\t\tif (\n\t\t\tbindings.components.size === 0 &&\n\t\t\tbindings.namespaces.size === 0 &&\n\t\t\tbindings.conservativeUsages.length === 0\n\t\t) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tallUsages.push(...bindings.conservativeUsages);\n\t\tconst jsxUsages = extractJSXUsages(ast, bindings.components);\n\t\tallUsages.push(...jsxUsages);\n\t\tfor (const component of bindings.components.values()) {\n\t\t\tif (\n\t\t\t\tjsxUsages.some(\n\t\t\t\t\t(usage) =>\n\t\t\t\t\t\tusage.component === component ||\n\t\t\t\t\t\tusage.component.startsWith(`${component}.`),\n\t\t\t\t)\n\t\t\t) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tallUsages.push(conservativeUsage(component, \"import-without-direct-jsx\"));\n\t\t}\n\t}\n\n\treturn allUsages;\n}\n\n// ── Main (standalone CLI) ─────────────────────────────────────────────────────\n\nasync function main() {\n\tconst [srcDir, manifestPath] = process.argv.slice(2);\n\tif (!srcDir || !manifestPath) {\n\t\tconsole.error(\n\t\t\t\"Usage: bun run src/scan-consumer.ts <consumer-src-dir> <purge-manifest.json>\",\n\t\t);\n\t\tprocess.exit(1);\n\t}\n\n\tconst manifest: PurgeManifest = JSON.parse(\n\t\tawait Bun.file(manifestPath).text(),\n\t);\n\tconst resolvedSrc = srcDir;\n\tconst manifestSize = Object.keys(manifestComponents(manifest)).length;\n\tconsole.log(`Scanning ${resolvedSrc} for @pathscale/ui component usage...`);\n\tconsole.log(`Manifest: ${manifestSize} entries\\n`);\n\n\tconst usages = await scanConsumerSource(resolvedSrc);\n\tconst { classSafelist, attrSafelist, usedComponents } = buildSafelists(\n\t\tusages,\n\t\tmanifest,\n\t);\n\n\tconsole.log(\"=== Components Detected ===\");\n\tfor (const component of [...usedComponents].sort()) {\n\t\tconsole.log(`  ${component}`);\n\t}\n\n\tconsole.log(\"\\n=== Class Safelist ===\");\n\tfor (const cls of [...classSafelist].sort()) {\n\t\tconsole.log(`  ${cls}`);\n\t}\n\n\tconsole.log(\"\\n=== Attribute Safelist ===\");\n\tfor (const attr of [...attrSafelist].sort()) {\n\t\tconsole.log(`  ${attr}`);\n\t}\n\n\tconsole.log(\n\t\t`\\nTotal: ${usedComponents.size} components, ${classSafelist.size} classes, ${attrSafelist.size} attribute selectors`,\n\t);\n}\n\nif (import.meta.main) {\n\tmain();\n}\n\nexport {\n\tbuildSafelists,\n\textractJSXUsages,\n\textractUIImports,\n\tscanConsumerSource,\n};\nexport type {\n\tLegacyComponentManifest as ComponentManifest,\n\tComponentPurgeRecord,\n\tLegacyComponentManifest,\n\tPropUsage,\n\tPurgeDatabaseV2,\n\tPurgeManifest,\n\tSafelists,\n};\n"
  ],
  "mappings": "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",
  "debugId": "577D5EB7CD27ECD164756E2164756E21",
  "names": []
}