@milkio/vite-plugin-milkio 1.3.35 → 1.3.36

package/chunk-ywkaz8jz.js

@@ -0,0 +1,834 @@
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./chunk-d85ypywj.js";
+
+// 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);
+      }
+    };
+  }
+});
+
+// node_modules/lightningcss/node/index.mjs
+var import__ = __toESM(require_node(), 1);
+var { transform, transformStyleAttribute, bundle, bundleAsync, browserslistToTargets, composeVisitors, Features } = import__.default;
+export {
+  transformStyleAttribute,
+  transform,
+  composeVisitors,
+  bundleAsync,
+  bundle,
+  browserslistToTargets,
+  Features
+};
+
+//# debugId=4967FE6BA0390F2964756E2164756E21
+//# 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", "../../../node_modules/lightningcss/node/index.mjs"],
  "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",
    "import index from './index.js';\n\nconst { transform, transformStyleAttribute, bundle, bundleAsync, browserslistToTargets, composeVisitors, Features } = index;\nexport { transform, transformStyleAttribute, bundle, bundleAsync, browserslistToTargets, composeVisitors, Features };\n"
  ],
  "mappings": "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",
  "debugId": "4967FE6BA0390F2964756E2164756E21",
  "names": []
}