@pathscale/rsbuild-plugin-ui-css-purge 0.9.0

package/dist/postbuild-purge.js

@@ -0,0 +1,1448 @@
+#!/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;
+import path from "path";
+function walkAST(node, visitor) {
+  if (!node || typeof node !== "object")
+    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 extractUIImports(ast) {
+  const imports = new Map;
+  for (const node of ast.body) {
+    if (node.type !== "ImportDeclaration")
+      continue;
+    const src = node.source?.value;
+    if (!src || !src.startsWith("@pathscale/ui"))
+      continue;
+    for (const spec of node.specifiers) {
+      if (spec.type === "ImportSpecifier") {
+        const imported = spec.imported?.value ?? spec.local?.value;
+        const local = spec.local?.value;
+        if (local && imported)
+          imports.set(local, imported);
+      } else if (spec.type === "ImportDefaultSpecifier") {
+        const local = spec.local?.value;
+        if (local)
+          imports.set(local, local);
+      }
+    }
+  }
+  return imports;
+}
+function extractJSXUsages(ast, uiComponents) {
+  const usages = [];
+  walkAST(ast, (node) => {
+    if (node.type !== "JSXOpeningElement")
+      return;
+    let elementName = null;
+    let rootName = null;
+    if (node.name?.type === "Identifier") {
+      elementName = node.name.value;
+      rootName = elementName;
+    } else if (node.name?.type === "JSXMemberExpression") {
+      const parts = [];
+      let cursor = node.name;
+      while (cursor?.type === "JSXMemberExpression") {
+        parts.unshift(cursor.property?.value);
+        cursor = cursor.object;
+      }
+      if (cursor?.type === "Identifier") {
+        parts.unshift(cursor.value);
+        rootName = cursor.value;
+      }
+      elementName = parts.join(".");
+    }
+    if (!rootName || !uiComponents.has(rootName))
+      return;
+    const usage = {
+      component: elementName,
+      props: new Map,
+      booleanProps: new Set,
+      hasSpread: false
+    };
+    for (const attr of node.attributes || []) {
+      if (attr.type === "SpreadElement" || attr.type === "JSXSpreadAttribute") {
+        usage.hasSpread = true;
+        continue;
+      }
+      if (attr.type !== "JSXAttribute")
+        continue;
+      const propName = attr.name?.value;
+      if (!propName)
+        continue;
+      if (!attr.value) {
+        usage.booleanProps.add(propName);
+      } else if (attr.value.type === "StringLiteral") {
+        usage.props.set(propName, attr.value.value);
+      } else {
+        usage.props.set(propName, "DYNAMIC");
+      }
+    }
+    usages.push(usage);
+  });
+  return usages;
+}
+function buildSafelists(allUsages, manifest) {
+  const classSafelist = new Set;
+  const attrSafelist = new Set;
+  const componentUsages = new Map;
+  for (const usage of allUsages) {
+    const existing = componentUsages.get(usage.component) ?? [];
+    existing.push(usage);
+    componentUsages.set(usage.component, existing);
+  }
+  for (const [entryName, entry] of Object.entries(manifest)) {
+    const matchingUsages = findMatchingUsages(entryName, componentUsages);
+    if (matchingUsages.length === 0) {
+      continue;
+    }
+    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 };
+}
+function findMatchingUsages(entryName, usageMap) {
+  if (usageMap.has(entryName)) {
+    return usageMap.get(entryName);
+  }
+  const results = [];
+  for (const [usageName, usages] of usageMap) {
+    if (usageName === entryName) {
+      results.push(...usages);
+    }
+    if (entryName.includes(".")) {
+      const [family, part] = entryName.split(".");
+      if (part === family && usageName === family) {
+        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 = path.join(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 uiImports = extractUIImports(ast);
+    if (uiImports.size === 0)
+      continue;
+    allUsages.push(...extractJSXUsages(ast, uiImports));
+  }
+  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 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 result;
+}
+function buildKillList(manifest, importedComponents) {
+  const componentBemRoots = new Map;
+  for (const [key, entry] of Object.entries(manifest)) {
+    const root = key.split(".")[0];
+    const existing = componentBemRoots.get(root) ?? new Set;
+    for (const cls of entry.classes.always) {
+      existing.add(cls);
+    }
+    componentBemRoots.set(root, existing);
+  }
+  const componentClasses = new Map;
+  for (const [key, entry] of Object.entries(manifest)) {
+    const root = key.split(".")[0];
+    const existing = componentClasses.get(root) ?? [];
+    existing.push(...collectClassesFromEntry(entry));
+    componentClasses.set(root, existing);
+  }
+  function isBemClass(cls, bemRoots) {
+    for (const root of bemRoots) {
+      if (cls === root || cls.startsWith(`${root}--`) || cls.startsWith(`${root}__`)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  const killList = new Set;
+  const safeClasses = new Set;
+  for (const [component, classes] of componentClasses) {
+    const bemRoots = componentBemRoots.get(component) ?? new Set;
+    if (importedComponents.has(component)) {
+      for (const cls of classes)
+        safeClasses.add(cls);
+    } else {
+      for (const cls of classes) {
+        if (isBemClass(cls, bemRoots)) {
+          killList.add(cls);
+        }
+      }
+    }
+  }
+  for (const cls of safeClasses) {
+    killList.delete(cls);
+  }
+  return killList;
+}
+function kebabToPascal(s) {
+  return s.split("-").map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+}
+async function scanImportedComponents(srcDir) {
+  const imported = new Set;
+  const glob = new Glob2("**/*.{tsx,ts,jsx,js}");
+  for await (const relPath of glob.scan({ cwd: srcDir })) {
+    if (relPath.includes("node_modules"))
+      continue;
+    const fullPath = `${srcDir}/${relPath}`;
+    const code = await Bun.file(fullPath).text();
+    if (!code.includes("@pathscale/ui"))
+      continue;
+    const barrelRegex = /import\s*\{([^}]+)\}\s*from\s*['"]@pathscale\/ui['"]/g;
+    for (const match of code.matchAll(barrelRegex)) {
+      const specifiers = match[1].split(",");
+      for (const spec of specifiers) {
+        const trimmed = spec.trim();
+        if (trimmed.startsWith("type "))
+          continue;
+        const name = trimmed.split(/\s+as\s+/)[0].trim();
+        if (name && /^[A-Z]/.test(name)) {
+          imported.add(name);
+        }
+      }
+    }
+    const deepDefaultRegex = /import\s+([A-Z][a-zA-Z0-9]*)\s+from\s*['"]@pathscale\/ui\/components\/([^'"]+)['"]/g;
+    for (const match of code.matchAll(deepDefaultRegex)) {
+      imported.add(match[1]);
+    }
+    const deepNamedRegex = /import\s*\{([^}]+)\}\s*from\s*['"]@pathscale\/ui\/components\/([^'"]+)['"]/g;
+    for (const match of code.matchAll(deepNamedRegex)) {
+      const specifiers = match[1].split(",");
+      for (const spec of specifiers) {
+        const trimmed = spec.trim();
+        if (trimmed.startsWith("type "))
+          continue;
+        const name = trimmed.split(/\s+as\s+/)[0].trim();
+        if (name && /^[A-Z]/.test(name)) {
+          imported.add(name);
+        }
+      }
+      const dirName = match[2].split("/")[0];
+      imported.add(kebabToPascal(dirName));
+    }
+  }
+  return imported;
+}
+function buildDepGraphFromManifest(manifest) {
+  const graph = new Map;
+  for (const [key, entry] of Object.entries(manifest)) {
+    const root = key.split(".")[0];
+    if (entry.deps && entry.deps.length > 0 && !graph.has(root)) {
+      graph.set(root, new Set(entry.deps));
+    }
+  }
+  return graph;
+}
+function resolveTransitiveDeps(imported, depGraph) {
+  const resolved = new Set(imported);
+  const queue = [...imported];
+  while (queue.length > 0) {
+    const comp = queue.pop();
+    const deps = depGraph.get(comp);
+    if (!deps)
+      continue;
+    for (const dep of deps) {
+      if (!resolved.has(dep)) {
+        resolved.add(dep);
+        queue.push(dep);
+      }
+    }
+  }
+  return resolved;
+}
+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]));
+}
+var ALWAYS_KEEP_SELECTORS = new Set([
+  "*",
+  "html",
+  "body",
+  ":root",
+  "::before",
+  "::after",
+  ":before",
+  ":after",
+  "::backdrop"
+]);
+function isKeepableNonClassSelector(sel) {
+  const stripped = sel.trim();
+  for (const el of ALWAYS_KEEP_SELECTORS) {
+    if (stripped === el)
+      return true;
+    if (stripped.startsWith(el + ":") || stripped.startsWith(el + "[") || stripped.startsWith(el + " "))
+      return true;
+  }
+  if (/^:root/.test(stripped))
+    return true;
+  if (/^\[data-theme/.test(stripped))
+    return true;
+  if (/^\[hidden/.test(stripped))
+    return true;
+  return false;
+}
+function purgeClasses(css, killList) {
+  const root = postcss.parse(css);
+  root.walkRules((rule) => {
+    const selectors = rule.selectors;
+    const kept = [];
+    for (const sel of selectors) {
+      const classes = extractClassesFromSelector(sel);
+      if (classes.length === 0) {
+        if (isKeepableNonClassSelector(sel)) {
+          kept.push(sel);
+        }
+        continue;
+      }
+      if (classes.some((c) => !killList.has(c))) {
+        kept.push(sel);
+      }
+    }
+    if (kept.length === 0) {
+      rule.remove();
+    } else if (kept.length < selectors.length) {
+      rule.selectors = kept;
+    }
+  });
+  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 && name !== "none" && name !== "initial" && name !== "inherit") {
+        usedKeyframes.add(name);
+      }
+    }
+  });
+  root.walkAtRules("keyframes", (atRule) => {
+    if (!usedKeyframes.has(atRule.params.trim())) {
+      atRule.remove();
+    }
+  });
+  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();
+    }
+  });
+  let cleaned = true;
+  while (cleaned) {
+    cleaned = false;
+    root.walkAtRules((atRule) => {
+      if (atRule.nodes && atRule.nodes.length === 0) {
+        atRule.remove();
+        cleaned = true;
+      }
+    });
+  }
+  return root.toString();
+}
+function purgeAttributes(css, attrSafelist) {
+  const root = postcss.parse(css);
+  root.walkRules((rule) => {
+    const selectors = rule.selectors;
+    const kept = [];
+    for (const sel of selectors) {
+      const attrMatches = sel.matchAll(/\[(data-[a-z-]+|aria-[a-z-]+)="([^"]+)"\]/g);
+      let shouldKeep = true;
+      for (const match of attrMatches) {
+        if (match[1] === "data-slot")
+          continue;
+        const attrSelector = `[${match[1]}="${match[2]}"]`;
+        if (!attrSafelist.has(attrSelector)) {
+          shouldKeep = false;
+          break;
+        }
+      }
+      if (shouldKeep)
+        kept.push(sel);
+    }
+    if (kept.length === 0) {
+      rule.remove();
+    } else if (kept.length < selectors.length) {
+      rule.selectors = kept;
+    }
+  });
+  return root.toString();
+}
+function cleanUnusedVars(css) {
+  let changed = true;
+  let result = css;
+  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;
+    root.walkDecls((decl) => {
+      const refs = decl.value.matchAll(/var\(\s*(--[a-zA-Z0-9_-]+)/g);
+      for (const ref of refs)
+        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;
+          });
+        }
+      }
+    }
+    root.walkRules((rule) => {
+      if (rule.nodes && rule.nodes.length === 0)
+        rule.remove();
+    });
+    root.walkAtRules((atRule) => {
+      if (atRule.nodes && atRule.nodes.length === 0)
+        atRule.remove();
+    });
+    result = root.toString();
+  }
+  return result;
+}
+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 totalComponents = new Set(Object.keys(manifest).map((k) => k.split(".")[0])).size;
+  console.log(`[css-purge] Manifest loaded: ${Object.keys(manifest).length} entries (${totalComponents} components)`);
+  const directImports = await scanImportedComponents(srcDir);
+  console.log(`[css-purge] Direct imports from app: ${directImports.size} / ${totalComponents}`);
+  const depGraph = buildDepGraphFromManifest(manifest);
+  const importedComponents = resolveTransitiveDeps(directImports, depGraph);
+  const transitive = importedComponents.size - directImports.size;
+  console.log(`[css-purge] Transitive deps: +${transitive} \u2192 ${importedComponents.size} total used components`);
+  const killList = buildKillList(manifest, importedComponents);
+  console.log(`[css-purge] Kill-list: ${killList.size} classes from ${totalComponents - importedComponents.size} unused components`);
+  const usages = await scanConsumerSource(srcDir);
+  const { attrSafelist } = buildSafelists(usages, manifest);
+  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)`);
+    let purgedCss = purgeClasses(originalCss, killList);
+    const afterL1 = Buffer.byteLength(purgedCss, "utf-8");
+    console.log(`[css-purge]   L1 class purge: ${(originalSize / 1024).toFixed(1)} \u2192 ${(afterL1 / 1024).toFixed(1)} KB`);
+    purgedCss = purgeAttributes(purgedCss, attrSafelist);
+    const afterL2 = Buffer.byteLength(purgedCss, "utf-8");
+    console.log(`[css-purge]   L2 attr purge: ${(afterL1 / 1024).toFixed(1)} \u2192 ${(afterL2 / 1024).toFixed(1)} KB`);
+    purgedCss = cleanUnusedVars(purgedCss);
+    const afterL3 = Buffer.byteLength(purgedCss, "utf-8");
+    console.log(`[css-purge]   L3 var cleanup: \u2192 ${(afterL3 / 1024).toFixed(1)} KB`);
+    purgedCss = minify(purgedCss);
+    const finalSize = Buffer.byteLength(purgedCss, "utf-8");
+    totalAfter += finalSize;
+    console.log(`[css-purge]   Minify (lightningcss): \u2192 ${(finalSize / 1024).toFixed(1)} KB`);
+    console.log(`[css-purge]   Final: ${(originalSize / 1024).toFixed(1)} \u2192 ${(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)} \u2192 ${(totalAfter / 1024).toFixed(1)} KB (${((1 - totalAfter / totalBefore) * 100).toFixed(1)}% reduction)`);
+}
+main();
+
+//# debugId=044B62D65705AFE764756E2164756E21
+//# 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 the purge manifest\n * and consumer JSX analysis. Zero Node imports.\n *\n * Three-level purge:\n *   L1 — class-level: drop rules whose class selectors aren't in the safelist (postcss)\n *   L2 — attr-level: drop rules with data/aria attribute selectors for unused props (postcss)\n *   L3 — var cleanup: iteratively remove declared-but-unreferenced CSS custom properties (postcss)\n *   Final — minification via Lightning CSS\n *\n * Usage:\n *   bunx @pathscale/rsbuild-plugin-ui-css-purge \\\n *     --dist dist --src src --manifest node_modules/@pathscale/ui/dist/purge-manifest.json\n */\n\nimport { Glob } from \"bun\";\nimport { transform } from \"lightningcss\";\nimport postcss from \"postcss\";\nimport type { Rule, AtRule } from \"postcss\";\nimport { scanConsumerSource, buildSafelists } from \"./scan-consumer\";\nimport type { PurgeManifest } from \"./scan-consumer\";\n\n// ── CLI args ──────────────────────────────────────────────────────────────────\n\nfunction parseArgs(argv: string[]): { distDir: string; srcDir: string; manifestPath: string } {\n  const args = argv.slice(2);\n  let distDir = \"./dist\";\n  let srcDir = \"./src\";\n  let manifestPath = \"\";\n\n  for (let i = 0; i < args.length; i++) {\n    if (args[i] === \"--dist\" && args[i + 1]) distDir = args[++i];\n    else if (args[i] === \"--src\" && args[i + 1]) srcDir = args[++i];\n    else if (args[i] === \"--manifest\" && args[i + 1]) manifestPath = args[++i];\n  }\n\n  if (!manifestPath) {\n    console.error(\n      \"Usage: bunx @pathscale/rsbuild-plugin-ui-css-purge --manifest <path> [--dist <path>] [--src <path>]\",\n    );\n    process.exit(1);\n  }\n\n  return { distDir, srcDir, manifestPath };\n}\n\n// ── Build kill-list: classes from components that are never imported ──────────\n\nfunction collectClassesFromEntry(entry: { classes: { always: string[]; byProp: Record<string, string[] | Record<string, string[]>> } }): string[] {\n  const result = [...entry.classes.always];\n  for (const value of Object.values(entry.classes.byProp)) {\n    if (Array.isArray(value)) {\n      result.push(...value);\n    } else {\n      for (const classes of Object.values(value)) {\n        result.push(...classes);\n      }\n    }\n  }\n  return result;\n}\n\nfunction buildKillList(manifest: PurgeManifest, importedComponents: Set<string>): Set<string> {\n  // For each manifest entry, collect BEM root classes (from classes.always).\n  // A class is considered a BEM-owned class of a component if it matches\n  // one of its roots: exact match, root--, or root__.\n  // Everything else (Tailwind utilities like gap-1, flex-col) is never killed.\n  const componentBemRoots = new Map<string, Set<string>>();\n\n  for (const [key, entry] of Object.entries(manifest)) {\n    const root = key.split(\".\")[0];\n    const existing = componentBemRoots.get(root) ?? new Set();\n    for (const cls of entry.classes.always) {\n      existing.add(cls);\n    }\n    componentBemRoots.set(root, existing);\n  }\n\n  // Collect ALL classes per component\n  const componentClasses = new Map<string, string[]>();\n  for (const [key, entry] of Object.entries(manifest)) {\n    const root = key.split(\".\")[0];\n    const existing = componentClasses.get(root) ?? [];\n    existing.push(...collectClassesFromEntry(entry));\n    componentClasses.set(root, existing);\n  }\n\n  // Filter: only include classes that match a BEM root of their component\n  function isBemClass(cls: string, bemRoots: Set<string>): boolean {\n    for (const root of bemRoots) {\n      if (cls === root || cls.startsWith(`${root}--`) || cls.startsWith(`${root}__`)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  const killList = new Set<string>();\n  const safeClasses = new Set<string>();\n\n  for (const [component, classes] of componentClasses) {\n    const bemRoots = componentBemRoots.get(component) ?? new Set();\n    if (importedComponents.has(component)) {\n      for (const cls of classes) safeClasses.add(cls);\n    } else {\n      // Only kill BEM-owned classes, not Tailwind utilities\n      for (const cls of classes) {\n        if (isBemClass(cls, bemRoots)) {\n          killList.add(cls);\n        }\n      }\n    }\n  }\n\n  // If a class appears in BOTH used and unused components, keep it\n  for (const cls of safeClasses) {\n    killList.delete(cls);\n  }\n\n  return killList;\n}\n\n/** Convert kebab-case directory name to PascalCase component name */\nfunction kebabToPascal(s: string): string {\n  return s.split(\"-\").map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join(\"\");\n}\n\nasync function scanImportedComponents(srcDir: string): Promise<Set<string>> {\n  const imported = new Set<string>();\n  const glob = new Glob(\"**/*.{tsx,ts,jsx,js}\");\n\n  for await (const relPath of glob.scan({ cwd: srcDir })) {\n    if (relPath.includes(\"node_modules\")) continue;\n    const fullPath = `${srcDir}/${relPath}`;\n    const code = await Bun.file(fullPath).text();\n    if (!code.includes(\"@pathscale/ui\")) continue;\n\n    // Match barrel: import { Foo, Bar as Baz } from \"@pathscale/ui\"\n    const barrelRegex = /import\\s*\\{([^}]+)\\}\\s*from\\s*['\"]@pathscale\\/ui['\"]/g;\n    for (const match of code.matchAll(barrelRegex)) {\n      const specifiers = match[1].split(\",\");\n      for (const spec of specifiers) {\n        const trimmed = spec.trim();\n        if (trimmed.startsWith(\"type \")) continue;\n        const name = trimmed.split(/\\s+as\\s+/)[0].trim();\n        if (name && /^[A-Z]/.test(name)) {\n          imported.add(name);\n        }\n      }\n    }\n\n    // Match deep-path default: import Foo from \"@pathscale/ui/components/foo-bar\"\n    const deepDefaultRegex = /import\\s+([A-Z][a-zA-Z0-9]*)\\s+from\\s*['\"]@pathscale\\/ui\\/components\\/([^'\"]+)['\"]/g;\n    for (const match of code.matchAll(deepDefaultRegex)) {\n      imported.add(match[1]);\n    }\n\n    // Match deep-path named: import { Foo, Bar } from \"@pathscale/ui/components/foo-bar\"\n    const deepNamedRegex = /import\\s*\\{([^}]+)\\}\\s*from\\s*['\"]@pathscale\\/ui\\/components\\/([^'\"]+)['\"]/g;\n    for (const match of code.matchAll(deepNamedRegex)) {\n      const specifiers = match[1].split(\",\");\n      for (const spec of specifiers) {\n        const trimmed = spec.trim();\n        if (trimmed.startsWith(\"type \")) continue;\n        const name = trimmed.split(/\\s+as\\s+/)[0].trim();\n        if (name && /^[A-Z]/.test(name)) {\n          imported.add(name);\n        }\n      }\n      // Also add the PascalCase name from the path itself (covers sub-components)\n      const dirName = match[2].split(\"/\")[0];\n      imported.add(kebabToPascal(dirName));\n    }\n  }\n\n  return imported;\n}\n\n/**\n * Build dependency graph from manifest `deps` fields.\n */\nfunction buildDepGraphFromManifest(manifest: PurgeManifest): Map<string, Set<string>> {\n  const graph = new Map<string, Set<string>>();\n  for (const [key, entry] of Object.entries(manifest)) {\n    const root = key.split(\".\")[0];\n    if (entry.deps && entry.deps.length > 0 && !graph.has(root)) {\n      graph.set(root, new Set(entry.deps));\n    }\n  }\n  return graph;\n}\n\n/**\n * Given directly imported components and a dependency graph,\n * transitively resolve all components that are needed.\n */\nfunction resolveTransitiveDeps(\n  imported: Set<string>,\n  depGraph: Map<string, Set<string>>,\n): Set<string> {\n  const resolved = new Set(imported);\n  const queue = [...imported];\n\n  while (queue.length > 0) {\n    const comp = queue.pop()!;\n    const deps = depGraph.get(comp);\n    if (!deps) continue;\n    for (const dep of deps) {\n      if (!resolved.has(dep)) {\n        resolved.add(dep);\n        queue.push(dep);\n      }\n    }\n  }\n\n  return resolved;\n}\n\n// ── Level 1: class-level purge + keyframes + font-face + element selectors ───\n\n/** Unescape CSS identifiers: `icon-\\[mdi--cog\\]` → `icon-[mdi--cog]` */\nfunction unescapeCss(s: string): string {\n  return s.replace(/\\\\(.)/g, \"$1\");\n}\n\nfunction extractClassesFromSelector(selector: string): string[] {\n  // Match class selectors including CSS escape sequences (e.g. .icon-\\[mdi--cog\\])\n  const matches = selector.matchAll(/\\.([a-zA-Z_-](?:[a-zA-Z0-9_-]|\\\\[^\\s])*)/g);\n  return [...matches].map((m) => unescapeCss(m[1]));\n}\n\n// Elements that are always kept (fundamental reset targets).\n// Everything else (sub, sup, img, select, textarea, etc.) is stripped\n// unless it appears alongside a safelisted class.\nconst ALWAYS_KEEP_SELECTORS = new Set([\n  \"*\", \"html\", \"body\", \":root\", \"::before\", \"::after\",\n  \":before\", \":after\", \"::backdrop\",\n]);\n\nfunction isKeepableNonClassSelector(sel: string): boolean {\n  const stripped = sel.trim();\n\n  // Exact match on fundamental selectors\n  for (const el of ALWAYS_KEEP_SELECTORS) {\n    if (stripped === el) return true;\n    // Allow pseudo-elements/classes attached to fundamental selectors\n    // e.g. *::before, html:not([data-theme])\n    if (stripped.startsWith(el + \":\") || stripped.startsWith(el + \"[\") || stripped.startsWith(el + \" \")) return true;\n  }\n\n  // Keep :root with pseudo/attr (theme selectors like :root:not([data-theme]))\n  if (/^:root/.test(stripped)) return true;\n\n  // Keep attribute-only selectors like [data-theme=dark] — theme variable declarations\n  if (/^\\[data-theme/.test(stripped)) return true;\n\n  // Keep [hidden] reset rules\n  if (/^\\[hidden/.test(stripped)) return true;\n\n  // Drop everything else: :host, :where(select...), element selectors (sub, sup, img, etc.)\n  return false;\n}\n\nfunction purgeClasses(css: string, killList: Set<string>): string {\n  const root = postcss.parse(css);\n\n  // Pass 1: remove selectors where ALL classes are on the kill-list\n  // (i.e. they belong exclusively to unused UI components).\n  // Any selector with even one class NOT on the kill-list is kept.\n  root.walkRules((rule) => {\n    const selectors = rule.selectors;\n    const kept: string[] = [];\n\n    for (const sel of selectors) {\n      const classes = extractClassesFromSelector(sel);\n      if (classes.length === 0) {\n        if (isKeepableNonClassSelector(sel)) {\n          kept.push(sel);\n        }\n        continue;\n      }\n\n      // Keep if ANY class is not on the kill-list\n      if (classes.some((c) => !killList.has(c))) {\n        kept.push(sel);\n      }\n    }\n\n    if (kept.length === 0) {\n      rule.remove();\n    } else if (kept.length < selectors.length) {\n      rule.selectors = kept;\n    }\n  });\n\n  // Pass 2: collect animation names referenced by surviving rules\n  const usedKeyframes = new Set<string>();\n  root.walkDecls(/^animation(-name)?$/, (decl) => {\n    // animation-name can be comma-separated\n    for (const part of decl.value.split(\",\")) {\n      const name = part.trim().split(/\\s+/)[0];\n      if (name && name !== \"none\" && name !== \"initial\" && name !== \"inherit\") {\n        usedKeyframes.add(name);\n      }\n    }\n  });\n\n  // Pass 3: remove unused @keyframes\n  root.walkAtRules(\"keyframes\", (atRule) => {\n    if (!usedKeyframes.has(atRule.params.trim())) {\n      atRule.remove();\n    }\n  });\n\n  // Pass 4: collect font families referenced by surviving rules\n  const usedFonts = new Set<string>();\n  root.walkDecls(/^font(-family)?$/, (decl) => {\n    // Extract font family names (rough but catches common patterns)\n    for (const part of decl.value.split(\",\")) {\n      const name = part.trim().replace(/^[\"']|[\"']$/g, \"\");\n      if (name) usedFonts.add(name);\n    }\n  });\n\n  // Pass 5: remove unused @font-face\n  root.walkAtRules(\"font-face\", (atRule) => {\n    let family = \"\";\n    atRule.walkDecls(\"font-family\", (decl) => {\n      family = decl.value.trim().replace(/^[\"']|[\"']$/g, \"\");\n    });\n    if (family && !usedFonts.has(family)) {\n      atRule.remove();\n    }\n  });\n\n  // Pass 6: clean empty at-rules\n  let cleaned = true;\n  while (cleaned) {\n    cleaned = false;\n    root.walkAtRules((atRule) => {\n      if (atRule.nodes && atRule.nodes.length === 0) {\n        atRule.remove();\n        cleaned = true;\n      }\n    });\n  }\n\n  return root.toString();\n}\n\n// ── Level 2: attribute purge (postcss) ───────────────────────────────────────\n\nfunction purgeAttributes(css: string, attrSafelist: Set<string>): string {\n  const root = postcss.parse(css);\n\n  root.walkRules((rule) => {\n    const selectors = rule.selectors;\n    const kept: string[] = [];\n\n    for (const sel of selectors) {\n      const attrMatches = sel.matchAll(/\\[(data-[a-z-]+|aria-[a-z-]+)=\"([^\"]+)\"\\]/g);\n      let shouldKeep = true;\n\n      for (const match of attrMatches) {\n        if (match[1] === \"data-slot\") continue;\n        const attrSelector = `[${match[1]}=\"${match[2]}\"]`;\n        if (!attrSafelist.has(attrSelector)) {\n          shouldKeep = false;\n          break;\n        }\n      }\n\n      if (shouldKeep) kept.push(sel);\n    }\n\n    if (kept.length === 0) {\n      rule.remove();\n    } else if (kept.length < selectors.length) {\n      rule.selectors = kept;\n    }\n  });\n\n  return root.toString();\n}\n\n// ── Level 3: unused CSS variable cleanup (postcss) ───────────────────────────\n\nfunction cleanUnusedVars(css: string): string {\n  let changed = true;\n  let result = css;\n\n  while (changed) {\n    changed = false;\n    const root = postcss.parse(result);\n\n    const declared = new Map<string, { rule: Rule | AtRule; prop: string }[]>();\n    root.walkDecls(/^--/, (decl) => {\n      const entries = declared.get(decl.prop) ?? [];\n      entries.push({ rule: decl.parent as Rule, prop: decl.prop });\n      declared.set(decl.prop, entries);\n    });\n\n    const referenced = new Set<string>();\n    root.walkDecls((decl) => {\n      const refs = decl.value.matchAll(/var\\(\\s*(--[a-zA-Z0-9_-]+)/g);\n      for (const ref of refs) referenced.add(ref[1]);\n    });\n\n    for (const [varName, entries] of declared) {\n      if (!referenced.has(varName)) {\n        for (const entry of entries) {\n          entry.rule.walkDecls(entry.prop, (decl) => {\n            decl.remove();\n            changed = true;\n          });\n        }\n      }\n    }\n\n    root.walkRules((rule) => {\n      if (rule.nodes && rule.nodes.length === 0) rule.remove();\n    });\n    root.walkAtRules((atRule) => {\n      if (atRule.nodes && atRule.nodes.length === 0) atRule.remove();\n    });\n\n    result = root.toString();\n  }\n\n  return result;\n}\n\n// ── Minification: Lightning CSS ──────────────────────────────────────────────\n\nfunction minify(css: string): string {\n  const { code } = transform({\n    filename: \"purged.css\",\n    code: Buffer.from(css),\n    minify: true,\n    errorRecovery: true,\n  });\n  return code.toString();\n}\n\n// ── Main ──────────────────────────────────────────────────────────────────────\n\nasync function main() {\n  const { distDir, srcDir, manifestPath } = parseArgs(process.argv);\n\n  // 1. Load manifest\n  const manifest: PurgeManifest = JSON.parse(\n    await Bun.file(manifestPath).text(),\n  );\n  const totalComponents = new Set(Object.keys(manifest).map(k => k.split(\".\")[0])).size;\n  console.log(`[css-purge] Manifest loaded: ${Object.keys(manifest).length} entries (${totalComponents} components)`);\n\n  // 2. Scan consumer source for directly imported components\n  const directImports = await scanImportedComponents(srcDir);\n  console.log(`[css-purge] Direct imports from app: ${directImports.size} / ${totalComponents}`);\n\n  // 3. Resolve transitive dependencies from manifest deps\n  const depGraph = buildDepGraphFromManifest(manifest);\n  const importedComponents = resolveTransitiveDeps(directImports, depGraph);\n  const transitive = importedComponents.size - directImports.size;\n  console.log(`[css-purge] Transitive deps: +${transitive} → ${importedComponents.size} total used components`);\n\n  // 4. Build kill-list (classes from components never imported) + attr safelist\n  const killList = buildKillList(manifest, importedComponents);\n  console.log(`[css-purge] Kill-list: ${killList.size} classes from ${totalComponents - importedComponents.size} unused components`);\n\n  // Also scan for prop-level attr purging\n  const usages = await scanConsumerSource(srcDir);\n  const { attrSafelist } = buildSafelists(usages, manifest);\n\n  // 4. Glob CSS files in dist\n  const glob = new Glob(\"**/*.css\");\n  let totalBefore = 0;\n  let totalAfter = 0;\n\n  for await (const relPath of glob.scan({ cwd: distDir })) {\n    const fullPath = `${distDir}/${relPath}`;\n    const originalCss = await Bun.file(fullPath).text();\n    const originalSize = Buffer.byteLength(originalCss, \"utf-8\");\n    totalBefore += originalSize;\n\n    console.log(`[css-purge] Processing ${relPath} (${(originalSize / 1024).toFixed(1)} KB)`);\n\n    // Level 1: class-level purge (unused components only)\n    let purgedCss = purgeClasses(originalCss, killList);\n    const afterL1 = Buffer.byteLength(purgedCss, \"utf-8\");\n    console.log(`[css-purge]   L1 class purge: ${(originalSize / 1024).toFixed(1)} → ${(afterL1 / 1024).toFixed(1)} KB`);\n\n    // Level 2: attribute-level purge\n    purgedCss = purgeAttributes(purgedCss, attrSafelist);\n    const afterL2 = Buffer.byteLength(purgedCss, \"utf-8\");\n    console.log(`[css-purge]   L2 attr purge: ${(afterL1 / 1024).toFixed(1)} → ${(afterL2 / 1024).toFixed(1)} KB`);\n\n    // Level 3: unused CSS variable cleanup\n    purgedCss = cleanUnusedVars(purgedCss);\n    const afterL3 = Buffer.byteLength(purgedCss, \"utf-8\");\n    console.log(`[css-purge]   L3 var cleanup: → ${(afterL3 / 1024).toFixed(1)} KB`);\n\n    // Final: minification via Lightning CSS\n    purgedCss = minify(purgedCss);\n    const finalSize = Buffer.byteLength(purgedCss, \"utf-8\");\n    totalAfter += finalSize;\n    console.log(`[css-purge]   Minify (lightningcss): → ${(finalSize / 1024).toFixed(1)} KB`);\n    console.log(`[css-purge]   Final: ${(originalSize / 1024).toFixed(1)} → ${(finalSize / 1024).toFixed(1)} KB (${((1 - finalSize / originalSize) * 100).toFixed(1)}% reduction)`);\n\n    await Bun.write(fullPath, purgedCss);\n  }\n\n  console.log(`\\n[css-purge] Total: ${(totalBefore / 1024).toFixed(1)} → ${(totalAfter / 1024).toFixed(1)} KB (${((1 - totalAfter / totalBefore) * 100).toFixed(1)}% reduction)`);\n}\n\nmain();\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's source tree, finds component imports from @pathscale/ui,\n * collects prop values, and cross-references with the purge manifest to build\n * Level 1 (class) and Level 2 (attribute) safelists.\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\";\nimport path from \"path\";\n\n// ── Types ──────────────────────────────────────────────────────────────────────\n\ninterface ComponentManifest {\n  classes: {\n    always: string[];\n    byProp: Record<string, string[] | Record<string, string[]>>;\n  };\n  attrs?: Record<string, Record<string, string>>;\n  deps?: string[];\n}\n\ntype PurgeManifest = Record<string, ComponentManifest>;\n\n/** What we collect per component usage from JSX */\ninterface PropUsage {\n  component: string;\n  props: Map<string, string | \"DYNAMIC\">; // propName → literal value or DYNAMIC\n  booleanProps: Set<string>; // props present without a value (truthy)\n  hasSpread: boolean;\n}\n\n// ── AST walker ─────────────────────────────────────────────────────────────────\n\nfunction walkAST(node: any, visitor: (node: any) => void) {\n  if (!node || typeof node !== \"object\") return;\n  visitor(node);\n  for (const key of Object.keys(node)) {\n    if (key === \"span\") continue;\n    const val = node[key];\n    if (Array.isArray(val)) {\n      for (const item of val) walkAST(item, visitor);\n    } else if (val && typeof val === \"object\") {\n      walkAST(val, visitor);\n    }\n  }\n}\n\n/** Extract @pathscale/ui imports from a parsed module */\nfunction extractUIImports(ast: any): Map<string, string> {\n  const imports = new Map<string, string>();\n  for (const node of ast.body) {\n    if (node.type !== \"ImportDeclaration\") continue;\n    const src = node.source?.value as string;\n    if (!src || !src.startsWith(\"@pathscale/ui\")) continue;\n\n    for (const spec of node.specifiers) {\n      if (spec.type === \"ImportSpecifier\") {\n        const imported = spec.imported?.value ?? spec.local?.value;\n        const local = spec.local?.value;\n        if (local && imported) imports.set(local, imported);\n      } else if (spec.type === \"ImportDefaultSpecifier\") {\n        const local = spec.local?.value;\n        if (local) imports.set(local, local);\n      }\n    }\n  }\n  return imports;\n}\n\n/** Extract JSX usages of UI components */\nfunction extractJSXUsages(ast: any, uiComponents: Map<string, string>): PropUsage[] {\n  const usages: PropUsage[] = [];\n\n  walkAST(ast, (node) => {\n    if (node.type !== \"JSXOpeningElement\") return;\n\n    let elementName: string | null = null;\n    let rootName: string | null = null;\n\n    if (node.name?.type === \"Identifier\") {\n      elementName = node.name.value;\n      rootName = elementName;\n    } else if (node.name?.type === \"JSXMemberExpression\") {\n      const parts: string[] = [];\n      let cursor = node.name;\n      while (cursor?.type === \"JSXMemberExpression\") {\n        parts.unshift(cursor.property?.value);\n        cursor = cursor.object;\n      }\n      if (cursor?.type === \"Identifier\") {\n        parts.unshift(cursor.value);\n        rootName = cursor.value;\n      }\n      elementName = parts.join(\".\");\n    }\n\n    if (!rootName || !uiComponents.has(rootName)) return;\n\n    const usage: PropUsage = {\n      component: elementName!,\n      props: new Map(),\n      booleanProps: new Set(),\n      hasSpread: false,\n    };\n\n    for (const attr of node.attributes || []) {\n      if (attr.type === \"SpreadElement\" || attr.type === \"JSXSpreadAttribute\") {\n        usage.hasSpread = true;\n        continue;\n      }\n      if (attr.type !== \"JSXAttribute\") continue;\n\n      const propName = attr.name?.value;\n      if (!propName) continue;\n\n      if (!attr.value) {\n        usage.booleanProps.add(propName);\n      } else if (attr.value.type === \"StringLiteral\") {\n        usage.props.set(propName, attr.value.value);\n      } else {\n        usage.props.set(propName, \"DYNAMIC\");\n      }\n    }\n\n    usages.push(usage);\n  });\n\n  return usages;\n}\n\n// ── Safelist builder ───────────────────────────────────────────────────────────\n\ninterface Safelists {\n  classSafelist: Set<string>;\n  attrSafelist: Set<string>;\n}\n\nfunction buildSafelists(\n  allUsages: PropUsage[],\n  manifest: PurgeManifest,\n): Safelists {\n  const classSafelist = new Set<string>();\n  const attrSafelist = new Set<string>();\n\n  const componentUsages = new Map<string, PropUsage[]>();\n  for (const usage of allUsages) {\n    const existing = componentUsages.get(usage.component) ?? [];\n    existing.push(usage);\n    componentUsages.set(usage.component, existing);\n  }\n\n  for (const [entryName, entry] of Object.entries(manifest)) {\n    const matchingUsages = findMatchingUsages(entryName, componentUsages);\n\n    if (matchingUsages.length === 0) {\n      continue;\n    }\n\n    for (const cls of entry.classes.always) {\n      classSafelist.add(cls);\n    }\n\n    for (const [propOrSlot, value] of Object.entries(entry.classes.byProp)) {\n      if (Array.isArray(value)) {\n        if (isPropUsed(propOrSlot, matchingUsages)) {\n          for (const cls of value) classSafelist.add(cls);\n        }\n      } else {\n        const usedValues = getUsedEnumValues(propOrSlot, matchingUsages);\n        if (usedValues === \"ALL\") {\n          for (const classes of Object.values(value)) {\n            for (const cls of classes) classSafelist.add(cls);\n          }\n        } else {\n          for (const val of usedValues) {\n            if (value[val]) {\n              for (const cls of value[val]) classSafelist.add(cls);\n            }\n          }\n        }\n      }\n    }\n\n    if (entry.attrs) {\n      for (const [propName, attrMap] of Object.entries(entry.attrs)) {\n        if (isPropUsed(propName, matchingUsages)) {\n          for (const [attr, val] of Object.entries(attrMap)) {\n            attrSafelist.add(`${attr}=${val}`);\n          }\n        }\n      }\n    }\n  }\n\n  return { classSafelist, attrSafelist };\n}\n\nfunction findMatchingUsages(\n  entryName: string,\n  usageMap: Map<string, PropUsage[]>,\n): PropUsage[] {\n  if (usageMap.has(entryName)) {\n    return usageMap.get(entryName)!;\n  }\n\n  const results: PropUsage[] = [];\n  for (const [usageName, usages] of usageMap) {\n    if (usageName === entryName) {\n      results.push(...usages);\n    }\n    if (entryName.includes(\".\")) {\n      const [family, part] = entryName.split(\".\");\n      if (part === family && usageName === family) {\n        results.push(...usages);\n      }\n    }\n  }\n  return results;\n}\n\nfunction isPropUsed(propName: string, usages: PropUsage[]): boolean {\n  for (const usage of usages) {\n    if (usage.hasSpread) return true;\n    if (usage.booleanProps.has(propName)) return true;\n    if (usage.props.has(propName)) return true;\n  }\n  return false;\n}\n\nfunction getUsedEnumValues(slotName: string, usages: PropUsage[]): Set<string> | \"ALL\" {\n  const values = new Set<string>();\n  for (const usage of usages) {\n    if (usage.hasSpread) return \"ALL\";\n    const val = usage.props.get(slotName);\n    if (val === \"DYNAMIC\") return \"ALL\";\n    if (val !== undefined) values.add(val);\n    if (usage.booleanProps.has(slotName)) return \"ALL\";\n  }\n  return values;\n}\n\n// ── Consumer source scanning ───────────────────────────────────────────────────\n\nasync function scanConsumerSource(srcDir: string): Promise<PropUsage[]> {\n  const allUsages: PropUsage[] = [];\n  const glob = new Glob(\"**/*.{tsx,ts,jsx,js}\");\n\n  for await (const relPath of glob.scan({ cwd: srcDir })) {\n    if (relPath.includes(\"node_modules\")) continue;\n    const fullPath = path.join(srcDir, relPath);\n    const code = await Bun.file(fullPath).text();\n    if (!code.includes(\"@pathscale/ui\")) continue;\n\n    const isTsx = /\\.[tj]sx$/.test(relPath);\n    const ast = await swc.parse(code, { syntax: \"typescript\", tsx: isTsx });\n    const uiImports = extractUIImports(ast);\n    if (uiImports.size === 0) continue;\n\n    allUsages.push(...extractJSXUsages(ast, uiImports));\n  }\n\n  return allUsages;\n}\n\n// ── Main (standalone CLI) ─────────────────────────────────────────────────────\n\nasync function main() {\n  const [srcDir, manifestPath] = process.argv.slice(2);\n  if (!srcDir || !manifestPath) {\n    console.error(\"Usage: bun run src/scan-consumer.ts <consumer-src-dir> <purge-manifest.json>\");\n    process.exit(1);\n  }\n\n  const manifest: PurgeManifest = JSON.parse(\n    await Bun.file(manifestPath).text(),\n  );\n  const resolvedSrc = path.resolve(srcDir);\n  console.log(`Scanning ${resolvedSrc} for @pathscale/ui component usage…`);\n  console.log(`Manifest: ${Object.keys(manifest).length} entries\\n`);\n\n  const usages = await scanConsumerSource(resolvedSrc);\n  const { classSafelist, attrSafelist } = buildSafelists(usages, manifest);\n\n  console.log(\"=== Class Safelist ===\");\n  for (const cls of [...classSafelist].sort()) {\n    console.log(`  ${cls}`);\n  }\n\n  console.log(`\\n=== Attribute Safelist ===`);\n  for (const attr of [...attrSafelist].sort()) {\n    console.log(`  [${attr}]`);\n  }\n\n  console.log(`\\nTotal: ${classSafelist.size} classes, ${attrSafelist.size} attribute selectors`);\n}\n\n// Only run CLI when invoked directly (not when imported as a module)\nif (import.meta.main) {\n  main();\n}\n\nexport { extractUIImports, extractJSXUsages, buildSafelists, scanConsumerSource };\nexport type { PropUsage, PurgeManifest, ComponentManifest, Safelists };\n"
  ],
  "mappings": "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",
  "debugId": "044B62D65705AFE764756E2164756E21",
  "names": []
}