about-system 0.10.10 → 0.10.12

package/dist/system-info-api-7iy1ZV2o.js

@@ -0,0 +1,2475 @@
+import B from "os";
+import u from "fs";
+import qI from "http";
+import Ig from "https";
+import M from "path";
+import { execSync as aI } from "child_process";
+M.join(B.tmpdir(), "systeminfo-cache.json");
+const gg = {
+  ipInfo: 600 * 1e3,
+  cpu: 1440 * 60 * 1e3,
+  gpu: 1440 * 60 * 1e3,
+  os: 1440 * 60 * 1e3,
+  device: 1440 * 60 * 1e3,
+  kernel: 3600 * 1e3,
+  pacman: 600 * 1e3,
+  ports: 300 * 1e3,
+  containers: 300 * 1e3,
+  top_process: 5 * 1e3,
+  disk_used: 60 * 1e3,
+  ram_used: 10 * 1e3,
+  services_running: 300 * 1e3,
+  temperature: 30 * 1e3,
+  battery: 60 * 1e3,
+  network_interfaces: 300 * 1e3,
+  mount_points: 600 * 1e3
+}, zI = "da2d6cc4baa5d1", BI = 3e3;
+function jI(I, g, c) {
+  return new Promise((i) => {
+    if (c?.aborted) return i(null);
+    let e = !1, s;
+    const t = (d) => {
+      e || (e = !0, clearTimeout(n), c?.removeEventListener("abort", C), i(d));
+    }, C = () => {
+      s?.destroy(), t(null);
+    }, n = setTimeout(C, g);
+    c?.addEventListener("abort", C);
+    try {
+      s = (I.startsWith("https:") ? Ig.get : qI.get)(I, (l) => {
+        let o = "";
+        l.on("data", (a) => o += a), l.on("end", () => {
+          try {
+            t(JSON.parse(o));
+          } catch {
+            t(null);
+          }
+        }), l.on("error", () => t(null));
+      }), s.on("error", () => t(null));
+    } catch {
+      t(null);
+    }
+  });
+}
+async function ig(I = zI, g = BI, c) {
+  const i = await jI(
+    `https://api.ipinfo.io/lite/me?token=${I}`,
+    g,
+    c
+  );
+  if (!i || typeof i != "object") return {};
+  const e = i.org ?? (i.asn && i.as_name ? `${i.asn} ${i.as_name}` : void 0);
+  return {
+    ip: i.ip,
+    city: i.city,
+    hostname: i.hostname,
+    org: e
+  };
+}
+async function cg(I = BI, g) {
+  const c = await jI(
+    "http://ip-api.com/json/?fields=status,message,query,city,isp,org,as",
+    I,
+    g
+  );
+  return !c || c.status !== "success" ? {} : {
+    ip: c.query,
+    city: c.city,
+    hostname: void 0,
+    org: c.org || c.isp || c.as
+  };
+}
+async function eg(I = zI, g = BI, c) {
+  const [i, e] = await Promise.all([
+    ig(I, g, c),
+    cg(g, c)
+  ]), s = {};
+  for (const t of [e, i])
+    for (const [C, n] of Object.entries(t))
+      n && (s[C] = n);
+  return s.ip?.includes(":") && e.ip && !e.ip.includes(":") && (s.ip = e.ip), s;
+}
+function MI(I, g) {
+  if (!I || !I.timestamp) return !1;
+  const c = Date.now() - I.timestamp, i = gg[g] || 6e4;
+  return c < i;
+}
+function W(I, g) {
+  if (!I[g]) return null;
+  const c = I[g];
+  return MI(c, g) ? c.value : (delete I[g], null);
+}
+function b(I, g, c) {
+  I[g] = {
+    value: c,
+    timestamp: Date.now()
+  };
+}
+const LI = {}, x = M.join(
+  B.homedir(),
+  ".config",
+  "systeminfo-settings.json"
+), O = M.join(B.tmpdir(), "systeminfo-cache.json"), ji = {
+  reset: "\x1B[0m",
+  red: "\x1B[38;5;160m",
+  orange: "\x1B[38;5;130m",
+  yellow: "\x1B[38;5;58m",
+  green: "\x1B[38;5;22m",
+  blue: "\x1B[38;5;25m",
+  cyan: "\x1B[38;5;23m",
+  purple: "\x1B[38;5;91m",
+  magenta: "\x1B[38;5;125m",
+  gray: "\x1B[38;5;238m",
+  lightblue: "\x1B[38;5;24m"
+}, Mi = {
+  red: "\x1B[48;5;88m\x1B[38;5;255m",
+  orange: "\x1B[48;5;166m\x1B[38;5;232m",
+  yellow: "\x1B[48;5;178m\x1B[38;5;232m",
+  green: "\x1B[48;5;22m\x1B[38;5;255m",
+  blue: "\x1B[48;5;18m\x1B[38;5;255m",
+  cyan: "\x1B[48;5;23m\x1B[38;5;255m",
+  purple: "\x1B[48;5;54m\x1B[38;5;255m",
+  magenta: "\x1B[48;5;53m\x1B[38;5;255m",
+  gray: "\x1B[48;5;236m\x1B[38;5;255m",
+  lightblue: "\x1B[48;5;26m\x1B[38;5;255m"
+}, XI = {
+  display_order: [
+    [
+      "user",
+      "hostname",
+      "os",
+      "device",
+      "kernel",
+      "cpu",
+      "bench",
+      "gpu",
+      "gpu_bench"
+    ],
+    [
+      "disk_used",
+      "disk_size",
+      "ram_used",
+      "top_process",
+      "uptime",
+      "temperature",
+      "battery",
+      "load_average"
+    ],
+    ["ip", "iplocal", "city"],
+    ["shell", "services_running", "pacman", "containers"]
+  ],
+  colors: {
+    user: "red",
+    hostname: "orange",
+    disk_used: "purple",
+    disk_size: "purple",
+    ram_used: "yellow",
+    top_process: "magenta",
+    uptime: "cyan",
+    ip: "green",
+    iplocal: "yellow",
+    city: "green",
+    domain: "gray",
+    isp: "lightblue",
+    os: "gray",
+    cpu: "orange",
+    gpu: "yellow",
+    bench: "red",
+    gpu_bench: "red",
+    device: "yellow",
+    kernel: "green",
+    shell: "orange",
+    pacman: "multicolor",
+    ports: "multicolor",
+    containers: "green",
+    memory_available: "blue",
+    swap_used: "purple",
+    load_average: "red",
+    users_logged_in: "cyan",
+    network_interfaces: "yellow",
+    mount_points: "gray",
+    services_running: "green",
+    temperature: "red",
+    battery: "green",
+    screen_resolution: "blue"
+  },
+  emojis: {
+    user: "👤 ",
+    hostname: "🏠 ",
+    ip: "🌎 ",
+    iplocal: "🌐 ",
+    city: "📍 ",
+    domain: "🔗 ",
+    isp: "👮 ",
+    os: "⚡ ",
+    cpu: "📈 ",
+    gpu: "🎮 ",
+    bench: "💪 ",
+    gpu_bench: "🏎️ ",
+    device: "💻 ",
+    kernel: "🔧 ",
+    shell: "🐚 ",
+    pacman: "🚀 ",
+    disk_used: "📁 ",
+    disk_size: "💽 ",
+    ram_used: "💾 ",
+    top_process: "🔝 ",
+    uptime: "⏱️ ",
+    ports: "🔌 ",
+    containers: "📦 ",
+    memory_available: "🧠 ",
+    swap_used: "🔄 ",
+    load_average: "⚖️ ",
+    users_logged_in: "👥 ",
+    network_interfaces: "🌐 ",
+    mount_points: "📂 ",
+    services_running: "⚙️ ",
+    temperature: "🌡️ ",
+    battery_charging: "🔌 ",
+    battery: "🔋 ",
+    screen_resolution: "🖥️ "
+  },
+  labels: {
+    user: "User",
+    hostname: "Host",
+    ip: "IP",
+    iplocal: "Local IP",
+    city: "City",
+    domain: "Domain",
+    isp: "ISP",
+    os: "OS",
+    cpu: "CPU",
+    gpu: "GPU",
+    bench: "Bench",
+    gpu_bench: "GPU Bench",
+    device: "Device",
+    kernel: "Kernel",
+    shell: "Shell",
+    pacman: "Packages",
+    disk_used: "Disk",
+    disk_size: "Disk Size",
+    ram_used: "RAM",
+    top_process: "Top",
+    uptime: "Uptime",
+    ports: "Ports",
+    containers: "Containers",
+    memory_available: "Memory",
+    swap_used: "Swap",
+    load_average: "Load",
+    users_logged_in: "Users",
+    network_interfaces: "Network",
+    mount_points: "Mounts",
+    services_running: "Services",
+    temperature: "Temp",
+    battery_charging: "Battery",
+    battery: "Battery",
+    screen_resolution: "Resolution"
+  },
+  display: {
+    show_emojis: !0,
+    show_backgrounds: !0,
+    single_line: !0,
+    line_wrap_length: LI?.stdout?.columns || 100
+  },
+  network: {
+    show_offline_message: !0
+  },
+  advanced: {
+    debug: !1
+  }
+};
+function Li() {
+  try {
+    if (u.existsSync(x)) {
+      const I = JSON.parse(u.readFileSync(x, "utf8"));
+      return { ...XI, ...I };
+    }
+  } catch {
+  }
+  return XI;
+}
+function Qi(I) {
+  try {
+    const g = M.dirname(x);
+    return u.existsSync(g) || u.mkdirSync(g, { recursive: !0 }), u.writeFileSync(x, JSON.stringify(I, null, 2)), !0;
+  } catch {
+    return !1;
+  }
+}
+const F = B.platform() === "win32", Y = B.platform() === "darwin", p = B.platform() === "linux";
+function G(I, g = {}) {
+  try {
+    const c = F ? `cmd /c ${I}` : I;
+    return aI(c, {
+      encoding: "utf8",
+      timeout: 1e4,
+      stdio: ["pipe", "pipe", "ignore"],
+      ...g
+    }).toString().trim();
+  } catch {
+    return "";
+  }
+}
+function k(I) {
+  try {
+    return F ? aI(`where ${I}`, { stdio: "ignore" }) : aI(`which ${I}`, { stdio: "ignore" }), !0;
+  } catch {
+    return !1;
+  }
+}
+function sg() {
+  return B.userInfo().username;
+}
+function tg() {
+  return B.hostname();
+}
+function Cg(I) {
+  const g = W(I.cache, "os");
+  if (g) return g;
+  const c = B.platform(), i = B.release();
+  let e = "";
+  if (F)
+    try {
+      const t = G("ver").match(/Microsoft Windows \[Version ([^\]]+)\]/);
+      e = t ? `Windows ${t[1]}` : `Windows ${i}`;
+    } catch {
+      e = `Windows ${i}`;
+    }
+  else if (Y) {
+    const s = G("sw_vers -productName"), t = G("sw_vers -productVersion");
+    e = s && t ? `${s} ${t}` : `macOS ${i}`;
+  } else if (p)
+    try {
+      const s = u.readFileSync("/etc/os-release", "utf8"), t = s.match(/^NAME="([^"]+)"/m), C = s.match(/^VERSION_ID="([^"]+)"/m);
+      e = t ? t[1] : "Linux", C && (e += ` ${C[1]}`);
+    } catch {
+      e = `Linux ${i}`;
+    }
+  else
+    e = `${c} ${i}`;
+  return b(I.cache, "os", e), e;
+}
+function ng(I) {
+  const g = W(I.cache, "kernel");
+  if (g) return g;
+  const c = B.release();
+  return b(I.cache, "kernel", c), c;
+}
+function og(I) {
+  const g = W(I.cache, "device");
+  if (g !== null) return g;
+  if (F) {
+    try {
+      const i = G("wmic csproduct get name /format:list").match(/Name=(.+)/);
+      if (i) {
+        const e = i[1].trim();
+        if (e && e !== "")
+          return b(I.cache, "device", e), e;
+      }
+    } catch {
+    }
+    try {
+      const c = G(
+        'powershell.exe -Command "Get-WmiObject -Class Win32_ComputerSystem | Select-Object -ExpandProperty Model"'
+      );
+      if (c.trim()) {
+        const i = c.trim();
+        return b(I.cache, "device", i), i;
+      }
+    } catch {
+    }
+  } else if (Y) {
+    const i = G("system_profiler SPHardwareDataType").match(/Model Name:\s*(.+)/);
+    if (i) {
+      const e = i[1].trim();
+      return b(I.cache, "device", e), e;
+    }
+  } else if (p)
+    try {
+      if (k("getprop")) {
+        const i = G("getprop ro.product.model");
+        if (i)
+          return b(I.cache, "device", i), i;
+      }
+      const c = "/sys/devices/virtual/dmi/id/product_name";
+      if (u.existsSync(c)) {
+        const i = u.readFileSync(c, "utf8").trim();
+        if (i)
+          return b(I.cache, "device", i), i;
+      }
+    } catch {
+    }
+  return b(I.cache, "device", ""), "";
+}
+const P = "data:video/mp2t;base64,aW1wb3J0IHsgZGVzY3JpYmUsIGV4cGVjdCwgaXQgfSBmcm9tICJ2aXRlc3QiOwppbXBvcnQgeyBmb3JtYXRCZW5jaCwgdG9wUGVyY2VudCB9IGZyb20gIi4vaGFyZHdhcmUiOwoKLyoqIEJ1aWxkcyBhIHRhYmxlIG9mIGBjb3VudGAgZW50cmllcyBhdCBlYWNoIHNjb3JlLCBoaWdoZXN0IGZpcnN0LiAqLwpmdW5jdGlvbiB0YWJsZShncm91cHM6IFtzY29yZTogbnVtYmVyLCBjb3VudDogbnVtYmVyXVtdKTogbnVtYmVyW10gewogIHJldHVybiBncm91cHMuZmxhdE1hcCgoW3Njb3JlLCBjb3VudF0pID0+IEFycmF5PG51bWJlcj4oY291bnQpLmZpbGwoc2NvcmUpKTsKfQoKZGVzY3JpYmUoInRvcFBlcmNlbnQiLCAoKSA9PiB7CiAgLy8gMSwwMDAgZW50cmllczogNCBhdCAxMDAsIDE4IGF0IDk5LCAzNSBhdCA5OCwgODAgYXQgOTcsIHJlc3QgYXQgNTAKICBjb25zdCBzY29yZXMgPSB0YWJsZShbWzEwMCwgNF0sIFs5OSwgMThdLCBbOTgsIDM1XSwgWzk3LCA4MF0sIFs1MCwgODYzXV0pOwoKICBpdCgiZ3JhZGVzIGJ5IGhvdyBtYW55IHNjb3JlIHN0cmljdGx5IGhpZ2hlciwgc28gdGllcyBzaGFyZSBhIGJ1Y2tldCIsICgpID0+IHsKICAgIGV4cGVjdCh0b3BQZXJjZW50KDEwMCwgc2NvcmVzKSkudG9CZSgxKTsKICAgIGV4cGVjdCh0b3BQZXJjZW50KDk5LCBzY29yZXMpKS50b0JlKDEpOwogICAgZXhwZWN0KHRvcFBlcmNlbnQoOTgsIHNjb3JlcykpLnRvQmUoMyk7CiAgICBleHBlY3QodG9wUGVyY2VudCg5Nywgc2NvcmVzKSkudG9CZSg2KTsKICB9KTsKCiAgaXQoImtlZXBzIGEgbGFyZ2UgdGllIHRvZ2V0aGVyIGluc3RlYWQgb2Ygc3BsaXR0aW5nIGl0IGJ5IHJhbmsiLCAoKSA9PiB7CiAgICBjb25zdCB0aWVkID0gdGFibGUoW1sxMDAsIDUwXSwgWzkwLCA5NTBdXSk7CiAgICBleHBlY3QodG9wUGVyY2VudCgxMDAsIHRpZWQpKS50b0JlKDEpOwogICAgZXhwZWN0KHRvcFBlcmNlbnQoOTAsIHRpZWQpKS50b0JlKDUpOwogIH0pOwoKICBpdCgic3RheXMgd2l0aGluIDEuLjEwMCIsICgpID0+IHsKICAgIGV4cGVjdCh0b3BQZXJjZW50KDEsIHRhYmxlKFtbMTAsIDk5OV0sIFsxLCAxXV0pKSkudG9CZSgxMDApOwogICAgZXhwZWN0KHRvcFBlcmNlbnQoNSwgW10pKS50b0JlKDEwMCk7CiAgfSk7Cn0pOwoKZGVzY3JpYmUoImZvcm1hdEJlbmNoIiwgKCkgPT4gewogIGNvbnN0IHNjb3JlcyA9IHRhYmxlKFtbMzc5NjcsIDFdLCBbMzAwMDAsIDY2XSwgWzIwNTEyLCAxXSwgWzEwMDAwLCA5MzJdXSk7CgogIGl0KCJyb3VuZHMgdGhlIHNjb3JlIHRvIHdob2xlIHRob3VzYW5kcyBhbmQgYXBwZW5kcyB0aGUgVG9wIHBlcmNlbnRpbGUiLCAoKSA9PiB7CiAgICBleHBlY3QoZm9ybWF0QmVuY2goMzc5NjcsIDEsIHNjb3JlcykpLnRvQmUoIjM4ayAjMSBUb3AgMSUiKTsKICAgIGV4cGVjdChmb3JtYXRCZW5jaCgyMDUxMiwgNjgsIHNjb3JlcykpLnRvQmUoIjIxayAjNjggVG9wIDclIik7CiAgfSk7CgogIGl0KCJuZXZlciBwcmludHMgYSBkZWNpbWFsIGluIHRoZSBzY29yZSIsICgpID0+IHsKICAgIGV4cGVjdChmb3JtYXRCZW5jaCgxOTI0OSwgOTEsIHNjb3JlcykpLm5vdC50b01hdGNoKC9cZFwuXGQvKTsKICB9KTsKfSk7Cg==", $ = "data:video/mp2t;base64,/**
 * Memory and disk-related system information functions
 * @module info/memory
 */

import os from "os";
import fs from "fs";
import type { InfoContext } from "../types/internal-types";
import { IS_LINUX, IS_MAC } from "../utils/platform";
import { execCommand } from "../utils/command";
import { getCachedValue, setCachedValue } from "../cache/cache";

/**
 * Gets memory usage in gigabytes
 * Reads from /proc/meminfo on Linux, falls back to os.totalmem()
 * @param context - Info context with cache
 * @returns Memory usage as "used/total GB"
 * @example "12/32GB", "6/16GB"
 */
export function ram_used(context: InfoContext): string {
  const cached = getCachedValue(context.cache, "ram_used");
  if (cached) return cached;

  if (IS_LINUX) {
    try {
      const meminfo = fs.readFileSync("/proc/meminfo", "utf8");
      const totalMatch = meminfo.match(/MemTotal:\s+(\d+) kB/);
      const freeMatch = meminfo.match(/MemFree:\s+(\d+) kB/);

      if (totalMatch && freeMatch) {
        const totalMB = Math.round(parseInt(totalMatch[1]) / 1024);
        const freeMB = Math.round(parseInt(freeMatch[1]) / 1024);
        const usedMB = totalMB - freeMB;

        const totalGB = Math.round(totalMB / 1024);
        const usedGB = Math.round(usedMB / 1024);

        const result = `${usedGB}/${totalGB}GB`;
        setCachedValue(context.cache, "ram_used", result);
        return result;
      }
    } catch {}
  }

  const totalMem = os.totalmem();
  const freeMem = os.freemem();
  const usedMem = totalMem - freeMem;

  const totalGB = Math.round(totalMem / (1024 * 1024 * 1024));
  const usedGB = Math.round(usedMem / (1024 * 1024 * 1024));

  const result = `${usedGB}/${totalGB}GB`;
  setCachedValue(context.cache, "ram_used", result);
  return result;
}

/**
 * Gets available memory in gigabytes
 * Reads MemAvailable from /proc/meminfo (Linux) or derives it from
 * vm_stat's free+inactive pages (macOS)
 * @returns Available memory with "GB available" suffix or empty string
 * @example "12GB available", "4GB available"
 */
export function memory_available(): string {
  if (IS_LINUX) {
    try {
      const meminfo = fs.readFileSync("/proc/meminfo", "utf8");
      const availableMatch = meminfo.match(/MemAvailable:\s+(\d+) kB/);
      if (availableMatch) {
        const availableGB = Math.round(parseInt(availableMatch[1]) / 1024 / 1024);
        return `${availableGB}GB available`;
      }
    } catch {}
    return "";
  }

  if (IS_MAC) {
    try {
      const vmStat = execCommand("vm_stat");
      const pageSizeMatch = vmStat.match(/page size of (\d+) bytes/);
      const freeMatch = vmStat.match(/Pages free:\s+(\d+)\./);
      const inactiveMatch = vmStat.match(/Pages inactive:\s+(\d+)\./);

      if (pageSizeMatch && freeMatch && inactiveMatch) {
        const pageSize = parseInt(pageSizeMatch[1]);
        const availablePages = parseInt(freeMatch[1]) + parseInt(inactiveMatch[1]);
        const availableGB = Math.round((availablePages * pageSize) / (1024 * 1024 * 1024));
        return `${availableGB}GB available`;
      }
    } catch {}
    return "";
  }

  return "";
}

/**
 * Gets swap memory usage
 * Calculates swap usage from /proc/meminfo (Linux) or `sysctl vm.swapusage`
 * (macOS)
 * @returns Swap usage as "percentage (size MB) swap" or empty string
 * @example "15% (512MB) swap", "0% (0MB) swap"
 */
export function swap_used(): string {
  if (IS_LINUX) {
    try {
      const meminfo = fs.readFileSync("/proc/meminfo", "utf8");
      const swapTotalMatch = meminfo.match(/SwapTotal:\s+(\d+) kB/);
      const swapFreeMatch = meminfo.match(/SwapFree:\s+(\d+) kB/);

      if (swapTotalMatch && swapFreeMatch) {
        const swapTotal = parseInt(swapTotalMatch[1]);
        const swapFree = parseInt(swapFreeMatch[1]);
        const swapUsed = swapTotal - swapFree;

        if (swapTotal > 0) {
          const swapUsedPercent = Math.round((swapUsed / swapTotal) * 100);
          const swapUsedMB = Math.round(swapUsed / 1024);
          return `${swapUsedPercent}% (${swapUsedMB}MB) swap`;
        }
      }
    } catch {}
    return "";
  }

  if (IS_MAC) {
    try {
      const swapusage = execCommand("sysctl -n vm.swapusage");
      const match = swapusage.match(
        /total\s*=\s*([\d.]+)M\s+used\s*=\s*([\d.]+)M\s+free\s*=\s*([\d.]+)M/
      );

      if (match) {
        const swapTotal = parseFloat(match[1]);
        const swapUsedMB = parseFloat(match[2]);

        if (swapTotal > 0) {
          const swapUsedPercent = Math.round((swapUsedMB / swapTotal) * 100);
          return `${swapUsedPercent}% (${Math.round(swapUsedMB)}MB) swap`;
        }

        return "0% (0MB) swap";
      }
    } catch {}
    return "";
  }

  return "";
}

/**
 * Gets root filesystem disk usage percentage
 * Uses df command on Linux/Android/macOS
 * @param context - Info context with cache
 * @returns Percentage string or empty string
 * @example "45%", "78%"
 */
export function disk_used(context: InfoContext): string {
  const cached = getCachedValue(context.cache, "disk_used");
  if (cached !== null) return cached;

  if (IS_LINUX || IS_MAC) {
    try {
      const df = execCommand("df -h");
      let diskUsage = "";

      if (df.includes("/storage/emulated")) {
        const match = df.match(/\s+(\d+%)\s+\/storage\/emulated/);
        diskUsage = match ? match[1] : "";
      } else {
        const lines = df.split("\n");
        for (const line of lines) {
          if (line.trim().endsWith(" /")) {
            const parts = line.trim().split(/\s+/);
            const percentIndex = parts.findIndex((part) => part.includes("%"));
            if (percentIndex !== -1) {
              diskUsage = parts[percentIndex];
              break;
            }
          }
        }

        if (!diskUsage) {
          const rootMatch = df.match(/(\d+%)\s+\/\s*$/m);
          diskUsage = rootMatch ? rootMatch[1] : "";
        }
      }

      setCachedValue(context.cache, "disk_used", diskUsage);
      return diskUsage;
    } catch {}
  }

  setCachedValue(context.cache, "disk_used", "");
  return "";
}

/**
 * Minimum total size (in KB) for a partition to be considered a real disk
 * rather than a small system/boot partition
 */
const MIN_REAL_DISK_KB = 10 * 1024 * 1024; // 10GB

/**
 * Gets disk size (used/total) for each real disk
 * Uses `df -k` on Linux/macOS, filtering out pseudo filesystems, system/boot
 * partitions (e.g. /boot, /System/Volumes/*), and anything under 10GB, since
 * those aren't disks a user would care about. When exactly one real disk is
 * found (the common case) the result omits the mount point; when multiple
 * real disks are found (e.g. a data drive or external volume), each is
 * labeled by its mount point.
 * @param context - Info context with cache
 * @returns Disk size as "used/total GB" or "mount(used/total GB) ..." or empty string
 * @example "256/512GB", "/(100/500GB) /Volumes/Backup(900/2000GB)"
 */
export function disk_size(context: InfoContext): string {
  const cached = getCachedValue(context.cache, "disk_size");
  if (cached !== null) return cached;

  if (!IS_LINUX && !IS_MAC) {
    setCachedValue(context.cache, "disk_size", "");
    return "";
  }

  try {
    const df = execCommand("df -k");
    const lines = df.trim().split("\n").slice(1);
    const disks: { mount: string; usedGB: number; totalGB: number }[] = [];

    for (const line of lines) {
      const parts = line.trim().split(/\s+/);
      if (parts.length < 6) continue;

      const filesystem = parts[0];
      const totalKB = parseInt(parts[1]);
      const usedKB = parseInt(parts[2]);
      const mount = parts[parts.length - 1];

      if (isNaN(totalKB) || isNaN(usedKB) || totalKB < MIN_REAL_DISK_KB) continue;

      if (IS_MAC) {
        // Only the boot disk ("/") and externally mounted real disks count.
        // APFS internal system volumes (Data, VM, Preboot, Update, ...) all
        // live under /System/Volumes and aren't separate physical disks.
        if (mount !== "/" && !mount.startsWith("/Volumes/")) continue;
      } else {
        if (
          filesystem.startsWith("devtmpfs") ||
          filesystem.startsWith("tmpfs") ||
          filesystem === "overlay" ||
          mount.startsWith("/boot") ||
          mount.startsWith("/dev") ||
          mount.startsWith("/proc") ||
          mount.startsWith("/sys") ||
          mount.startsWith("/run")
        ) {
          continue;
        }
      }

      disks.push({
        mount,
        usedGB: Math.round(usedKB / (1024 * 1024)),
        totalGB: Math.round(totalKB / (1024 * 1024)),
      });
    }

    let result = "";
    if (disks.length === 1) {
      result = `${disks[0].usedGB}/${disks[0].totalGB}GB`;
    } else if (disks.length > 1) {
      result = disks
        .map((d) => `${d.mount}(${d.usedGB}/${d.totalGB}GB)`)
        .join(" ");
    }

    setCachedValue(context.cache, "disk_size", result);
    return result;
  } catch {}

  setCachedValue(context.cache, "disk_size", "");
  return "";
}

/**
 * Gets mounted filesystem information
 * Lists non-system mount points with usage from df (Linux/macOS)
 * On Linux, excludes /, /dev, /proc, /sys and internal /System/Volumes mounts.
 * On macOS, APFS internal volumes (Data, VM, Preboot, Update, ...) all live
 * under /System/Volumes and are not user-relevant, so only /Volumes (external
 * disks, network shares, disk images) are reported.
 * @param context - Info context with cache
 * @returns Space-separated mount points with usage or empty string
 * @example "/home(45%) /mnt/data(78%)", "/Volumes/Backup(78%)"
 */
export function mount_points(context: InfoContext): string {
  const cached = getCachedValue(context.cache, "mount_points");
  if (cached !== null) return cached;

  if (!IS_LINUX && !IS_MAC) {
    setCachedValue(context.cache, "mount_points", "");
    return "";
  }

  try {
    const df = execCommand("df -h");
    const lines = df.split("\n").slice(1);
    const mountPoints: string[] = [];

    lines.forEach((line) => {
      const parts = line.trim().split(/\s+/);
      if (parts.length < 2) return;

      const mountPoint = parts[parts.length - 1];
      const usage = parts.find((part) => /^\d+%$/.test(part)) || "";

      if (!usage) return;

      if (IS_MAC) {
        // Skip the "Macintosh HD" self-symlink and any other symlink back to /
        if (mountPoint.startsWith("/Volumes/") && mountPoint !== "/") {
          mountPoints.push(`${mountPoint}(${usage})`);
        }
        return;
      }

      if (
        !mountPoint.startsWith("/dev") &&
        !mountPoint.startsWith("/proc") &&
        !mountPoint.startsWith("/sys") &&
        !mountPoint.startsWith("/System/Volumes") &&
        mountPoint !== "/"
      ) {
        mountPoints.push(`${mountPoint}(${usage})`);
      }
    });

    const result = mountPoints.slice(0, 3).join(" ");
    setCachedValue(context.cache, "mount_points", result);
    return result;
  } catch {}

  setCachedValue(context.cache, "mount_points", "");
  return "";
}
", q = "data:video/mp2t;base64,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", II = "data:video/mp2t;base64,/**
 * @fileoverview Covers the platform facts `about-system` opens its readout
 * with: user, hostname, OS name, kernel and device model.
 *
 * Each of these shells out to a different tool per platform and parses its
 * output, so the tests drive the Linux path (the one CI runs on) end to end and
 * pin the two behaviours that hold everywhere: the cache is consulted before
 * any command runs, and a missing tool degrades to a fallback rather than
 * throwing.
 */

import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";

// These modules bind their imports by name, so the dependencies have to be
// mocked outright rather than spied on through a namespace object.
const execCommand = vi.hoisted(() => vi.fn());
const commandExists = vi.hoisted(() => vi.fn());
vi.mock("../utils/command", () => ({ execCommand, commandExists }));

const osMock = vi.hoisted(() => ({
  platform: vi.fn(() => "linux"),
  release: vi.fn(() => "6.1.0-generic"),
  hostname: vi.fn(() => "workstation"),
  userInfo: vi.fn(() => ({ username: "ada" })),
  // cache-config resolves the cache file under the temp directory at import time.
  tmpdir: vi.fn(() => "/tmp"),
}));
vi.mock("os", () => ({ ...osMock, default: osMock }));

const fsMock = vi.hoisted(() => ({
  existsSync: vi.fn(() => false),
  readFileSync: vi.fn(() => ""),
}));
vi.mock("fs", () => ({ ...fsMock, default: fsMock }));

const { device, hostname, kernel, os_info, user } = await import("./platform");
const { IS_LINUX } = await import("../utils/platform");
import type { InfoContext } from "../types/internal-types";

const context = (): InfoContext => ({ cache: {} });

beforeEach(() => {
  execCommand.mockReturnValue("");
  commandExists.mockReturnValue(false);
  fsMock.existsSync.mockReturnValue(false);
  fsMock.readFileSync.mockReturnValue("");
});

afterEach(() => {
  vi.clearAllMocks();
});

describe("user and hostname", () => {
  it("reads the current username", () => {
    expect(user()).toBe("ada");
  });

  it("reads the machine's network name", () => {
    expect(hostname()).toBe("workstation");
  });
});

describe("kernel", () => {
  it("reports the kernel release", () => {
    expect(kernel(context())).toBe("6.1.0-generic");
  });

  it("caches the result", () => {
    const ctx = context();
    kernel(ctx);
    expect(ctx.cache.kernel?.value).toBe("6.1.0-generic");
  });

  it("serves a cached kernel without asking the OS again", () => {
    const ctx = context();
    ctx.cache.kernel = { value: "cached-kernel", timestamp: Date.now() };

    expect(kernel(ctx)).toBe("cached-kernel");
    expect(osMock.release).not.toHaveBeenCalled();
  });
});

describe("os_info", () => {
  it("serves a cached value without running any command", () => {
    const ctx = context();
    ctx.cache.os = { value: "Cached OS 1.0", timestamp: Date.now() };

    expect(os_info(ctx)).toBe("Cached OS 1.0");
    expect(execCommand).not.toHaveBeenCalled();
  });

  it("caches whatever it resolves", () => {
    const ctx = context();
    const resolved = os_info(ctx);
    expect(ctx.cache.os?.value).toBe(resolved);
  });

  it("never returns an empty string, whatever the platform", () => {
    expect(os_info(context())).toBeTruthy();
  });

  it.runIf(IS_LINUX)("reads the distribution from /etc/os-release", () => {
    fsMock.existsSync.mockReturnValue(true);
    fsMock.readFileSync.mockReturnValue(
      'NAME="Ubuntu"\nVERSION_ID="22.04"\nID=ubuntu\n',
    );

    expect(os_info(context())).toBe("Ubuntu 22.04");
  });

  it.runIf(IS_LINUX)("uses the name alone when there is no version id", () => {
    fsMock.readFileSync.mockReturnValue('NAME="Arch Linux"\n');
    expect(os_info(context())).toBe("Arch Linux");
  });

  it.runIf(IS_LINUX)("falls back to the kernel release with no os-release file", () => {
    fsMock.readFileSync.mockImplementation(() => {
      throw new Error("ENOENT");
    });

    expect(os_info(context())).toBe("Linux 6.1.0-generic");
  });

  it.runIf(IS_LINUX)("falls back to a bare Linux when the file has no NAME", () => {
    fsMock.readFileSync.mockReturnValue("ID=unknown\n");
    expect(os_info(context())).toBe("Linux");
  });
});

describe("device", () => {
  it("serves a cached model without probing", () => {
    const ctx = context();
    ctx.cache.device = { value: "Cached Box", timestamp: Date.now() };

    expect(device(ctx)).toBe("Cached Box");
    expect(execCommand).not.toHaveBeenCalled();
  });

  it("caches an empty result too, so the probe is not repeated", () => {
    const ctx = context();
    device(ctx);
    expect(ctx.cache.device).toBeDefined();
  });

  it("returns an empty string when nothing identifies the machine", () => {
    expect(device(context())).toBe("");
  });

  it.runIf(IS_LINUX)("reads the model from the DMI product name", () => {
    fsMock.existsSync.mockImplementation(
      (path: string) => path === "/sys/devices/virtual/dmi/id/product_name",
    );
    fsMock.readFileSync.mockReturnValue("OptiPlex 7090\n");

    expect(device(context())).toBe("OptiPlex 7090");
  });

  it.runIf(IS_LINUX)("prefers Android's getprop when it is available", () => {
    commandExists.mockImplementation((cmd: string) => cmd === "getprop");
    execCommand.mockReturnValue("Pixel 8");

    expect(device(context())).toBe("Pixel 8");
    expect(execCommand).toHaveBeenCalledWith("getprop ro.product.model");
  });

  it.runIf(IS_LINUX)("falls through to DMI when getprop answers nothing", () => {
    commandExists.mockImplementation((cmd: string) => cmd === "getprop");
    execCommand.mockReturnValue("");
    fsMock.existsSync.mockReturnValue(true);
    fsMock.readFileSync.mockReturnValue("Steam Deck\n");

    expect(device(context())).toBe("Steam Deck");
  });

  it.runIf(IS_LINUX)("ignores a blank DMI product name", () => {
    fsMock.existsSync.mockReturnValue(true);
    fsMock.readFileSync.mockReturnValue("   \n");

    expect(device(context())).toBe("");
  });

  it.runIf(IS_LINUX)("survives an unreadable DMI file", () => {
    fsMock.existsSync.mockReturnValue(true);
    fsMock.readFileSync.mockImplementation(() => {
      throw new Error("EACCES");
    });

    expect(device(context())).toBe("");
  });
});
", gI = "data:video/mp2t;base64,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", iI = "data:video/mp2t;base64,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", cI = "data:video/mp2t;base64,/**
 * Settings configuration and management
 * @module info/settings
 */

import path from "path";
import os from "os";
import fs from "fs";
import process from "process";

// Settings file paths
export const SETTINGS_FILE = path.join(
  os.homedir(),
  ".config",
  "systeminfo-settings.json",
);
export const CACHE_FILE = path.join(os.tmpdir(), "systeminfo-cache.json");

// Color codes
//
// These are deliberately darker/more saturated than a typical terminal
// palette. The original bright variants (e.g. yellow 226, cyan 51, gray 250)
// have very high luminance and are nearly unreadable on a light/white
// terminal background. `lightblue` was also mislabeled: it pointed at gold
// (220), not a blue at all. Every value below reads clearly on both light
// and dark backgrounds.
export const colors = {
  reset: "\x1b[0m",
  red: "\x1b[38;5;160m",
  orange: "\x1b[38;5;130m",
  yellow: "\x1b[38;5;58m",
  green: "\x1b[38;5;22m",
  blue: "\x1b[38;5;25m",
  cyan: "\x1b[38;5;23m",
  purple: "\x1b[38;5;91m",
  magenta: "\x1b[38;5;125m",
  gray: "\x1b[38;5;238m",
  lightblue: "\x1b[38;5;24m",
};

// Background variants, keyed the same as `colors`, used when
// `display.show_backgrounds` is enabled. Each entry sets its own background
// block plus a foreground text color chosen for contrast against it, so
// every item is legible on its own regardless of what the terminal's
// background actually is.
export const backgrounds = {
  red: "\x1b[48;5;88m\x1b[38;5;255m",
  orange: "\x1b[48;5;166m\x1b[38;5;232m",
  yellow: "\x1b[48;5;178m\x1b[38;5;232m",
  green: "\x1b[48;5;22m\x1b[38;5;255m",
  blue: "\x1b[48;5;18m\x1b[38;5;255m",
  cyan: "\x1b[48;5;23m\x1b[38;5;255m",
  purple: "\x1b[48;5;54m\x1b[38;5;255m",
  magenta: "\x1b[48;5;53m\x1b[38;5;255m",
  gray: "\x1b[48;5;236m\x1b[38;5;255m",
  lightblue: "\x1b[48;5;26m\x1b[38;5;255m",
};

// Default settings
export const DEFAULT_SETTINGS = {
  display_order: [
    [
      "user",
      "hostname",
      "os",
      "device",
      "kernel",
      "cpu",
      "bench",
      "gpu",
      "gpu_bench",
    ],
    [
      "disk_used",
      "disk_size",
      "ram_used",
      "top_process",
      "uptime",
      "temperature",
      "battery",
      "load_average",
    ],
    ["ip", "iplocal", "city"],
    ["shell", "services_running", "pacman", "containers"],
  ],
  colors: {
    user: "red",
    hostname: "orange",
    disk_used: "purple",
    disk_size: "purple",
    ram_used: "yellow",
    top_process: "magenta",
    uptime: "cyan",
    ip: "green",
    iplocal: "yellow",
    city: "green",
    domain: "gray",
    isp: "lightblue",
    os: "gray",
    cpu: "orange",
    gpu: "yellow",
    bench: "red",
    gpu_bench: "red",
    device: "yellow",
    kernel: "green",
    shell: "orange",
    pacman: "multicolor",
    ports: "multicolor",
    containers: "green",
    memory_available: "blue",
    swap_used: "purple",
    load_average: "red",
    users_logged_in: "cyan",
    network_interfaces: "yellow",
    mount_points: "gray",
    services_running: "green",
    temperature: "red",
    battery: "green",
    screen_resolution: "blue",
  },
  emojis: {
    user: "👤 ",
    hostname: "🏠 ",
    ip: "🌎 ",
    iplocal: "🌐 ",
    city: "📍 ",
    domain: "🔗 ",
    isp: "👮 ",
    os: "⚡ ",
    cpu: "📈 ",
    gpu: "🎮 ",
    bench: "💪 ",
    gpu_bench: "🏎️ ",
    device: "💻 ",
    kernel: "🔧 ",
    shell: "🐚 ",
    pacman: "🚀 ",
    disk_used: "📁 ",
    disk_size: "💽 ",
    ram_used: "💾 ",
    top_process: "🔝 ",
    uptime: "⏱️ ",
    ports: "🔌 ",
    containers: "📦 ",
    memory_available: "🧠 ",
    swap_used: "🔄 ",
    load_average: "⚖️ ",
    users_logged_in: "👥 ",
    network_interfaces: "🌐 ",
    mount_points: "📂 ",
    services_running: "⚙️ ",
    temperature: "🌡️ ",
    battery_charging: "🔌 ",
    battery: "🔋 ",
    screen_resolution: "🖥️ ",
  },
  labels: {
    user: "User",
    hostname: "Host",
    ip: "IP",
    iplocal: "Local IP",
    city: "City",
    domain: "Domain",
    isp: "ISP",
    os: "OS",
    cpu: "CPU",
    gpu: "GPU",
    bench: "Bench",
    gpu_bench: "GPU Bench",
    device: "Device",
    kernel: "Kernel",
    shell: "Shell",
    pacman: "Packages",
    disk_used: "Disk",
    disk_size: "Disk Size",
    ram_used: "RAM",
    top_process: "Top",
    uptime: "Uptime",
    ports: "Ports",
    containers: "Containers",
    memory_available: "Memory",
    swap_used: "Swap",
    load_average: "Load",
    users_logged_in: "Users",
    network_interfaces: "Network",
    mount_points: "Mounts",
    services_running: "Services",
    temperature: "Temp",
    battery_charging: "Battery",
    battery: "Battery",
    screen_resolution: "Resolution",
  },
  display: {
    show_emojis: true,
    show_backgrounds: true,
    single_line: true,
    line_wrap_length: process?.stdout?.columns || 100,
  },
  network: {
    show_offline_message: true,
  },
  advanced: {
    debug: false,
  },
};

export interface Settings {
  display_order: string[][];
  colors: Record<string, string>;
  emojis: Record<string, string>;
  labels: Record<string, string>;
  display: {
    show_emojis: boolean;
    /** true (default): give every item its own background color block, so it stays legible regardless of the terminal's background */
    show_backgrounds: boolean;
    /** true: print one continuous line and let the terminal soft-wrap it; false: hard-wrap at line_wrap_length */
    single_line: boolean;
    line_wrap_length: number;
  };
  network: {
    show_offline_message: boolean;
  };
  advanced: {
    debug: boolean;
  };
}

/**
 * Loads settings from the configuration file
 * @returns Settings object (defaults merged with user settings)
 */
export function loadSettings(): Settings {
  try {
    if (fs.existsSync(SETTINGS_FILE)) {
      const settings = JSON.parse(fs.readFileSync(SETTINGS_FILE, "utf8"));
      return { ...DEFAULT_SETTINGS, ...settings };
    }
  } catch {}
  return DEFAULT_SETTINGS;
}

/**
 * Saves settings to the configuration file
 * @param settings - The settings object to save
 * @returns True if successful, false otherwise
 */
export function saveSettings(settings: Settings): boolean {
  try {
    const configDir = path.dirname(SETTINGS_FILE);
    if (!fs.existsSync(configDir)) {
      fs.mkdirSync(configDir, { recursive: true });
    }
    fs.writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2));
    return true;
  } catch {
    return false;
  }
}
", eI = "data:video/mp2t;base64,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", sI = "data:video/mp2t;base64,/**
 * System status and health information functions
 * @module info/system-status
 */

import fs from "fs";
import os from "os";
import type { InfoContext } from "../types/internal-types";
import { IS_LINUX, IS_MAC } from "../utils/platform";
import { execCommand, commandExists } from "../utils/command";
import { getCachedValue, setCachedValue } from "../cache/cache";

/**
 * Gets system load averages
 * Reads 1, 5, and 15 minute load averages from /proc/loadavg (Linux) or
 * os.loadavg() (macOS)
 * @returns Space-separated load averages (1m 5m 15m) or empty string
 * @example "0.52 0.58 0.59", "2.10 1.95 1.88"
 */
export function load_average(context: InfoContext): string {
  if (IS_MAC) {
    return os
      .loadavg()
      .map((n) => n.toFixed(2))
      .join(" ");
  }

  if (!IS_LINUX) return "";

  try {
    const loadavg = fs.readFileSync("/proc/loadavg", "utf8");
    const loads = loadavg.split(" ").slice(0, 3);
    return loads.join(" ");
  } catch {}
  return "";
}

/**
 * Gets battery charge level and charging status
 * Reads from /sys/class/power_supply/BAT0 (Linux laptops only)
 * @param context - Info context with cache
 * @returns Battery percentage with optional + for charging, or empty string
 * @example "85%", "42%+", "100%"
 */
export function battery(context: InfoContext): string {
  const cached = getCachedValue(context.cache, "battery");
  if (cached !== null) return cached;

  if (IS_MAC) {
    try {
      const batt = execCommand("pmset -g batt");
      const percentMatch = batt.match(/(\d+)%/);
      if (percentMatch) {
        const isCharging = /;\s*(charging|charged);/i.test(batt);
        const result = `${percentMatch[1]}%${isCharging ? "+" : ""}`;
        setCachedValue(context.cache, "battery", result);
        return result;
      }
    } catch {}

    setCachedValue(context.cache, "battery", "");
    return "";
  }

  if (!IS_LINUX) {
    setCachedValue(context.cache, "battery", "");
    return "";
  }

  try {
    const batteryPath = "/sys/class/power_supply/BAT0";
    const capacityPath = `${batteryPath}/capacity`;
    const statusPath = `${batteryPath}/status`;

    if (fs.existsSync(capacityPath)) {
      const capacity = fs.readFileSync(capacityPath, "utf8").trim();
      const status = fs.existsSync(statusPath)
        ? fs.readFileSync(statusPath, "utf8").trim()
        : "Unknown";

      const batteryPercent = parseInt(capacity);
      const isCharging = status === "Charging";
      const result = `${batteryPercent}%${isCharging ? "+" : ""}`;
      setCachedValue(context.cache, "battery", result);
      return result;
    }
  } catch {}

  setCachedValue(context.cache, "battery", "");
  return "";
}

/**
 * Gets system temperature in Celsius
 * Reads from thermal zone or hwmon sensors (Linux), or from the
 * `osx-cpu-temp` CLI (macOS, if installed via `brew install osx-cpu-temp`) -
 * macOS has no unprivileged API for this, so nothing is reported without it
 * @param context - Info context with cache
 * @returns Temperature with °C suffix or empty string
 * @example "45°C", "62°C"
 */
export function temperature(context: InfoContext): string {
  const cached = getCachedValue(context.cache, "temperature");
  if (cached !== null) return cached;

  if (IS_MAC) {
    if (commandExists("osx-cpu-temp")) {
      try {
        const output = execCommand("osx-cpu-temp");
        const match = output.match(/([\d.]+)\s*°?C/);
        if (match) {
          const tempC = Math.round(parseFloat(match[1]));
          if (tempC > 0 && tempC < 150) {
            const result = `${tempC}°C`;
            setCachedValue(context.cache, "temperature", result);
            return result;
          }
        }
      } catch {}
    }

    setCachedValue(context.cache, "temperature", "");
    return "";
  }

  if (!IS_LINUX) {
    setCachedValue(context.cache, "temperature", "");
    return "";
  }

  try {
    const tempSources = [
      "/sys/class/thermal/thermal_zone0/temp",
      "/sys/class/hwmon/hwmon0/temp1_input",
      "/sys/class/hwmon/hwmon1/temp1_input",
    ];

    for (const source of tempSources) {
      if (fs.existsSync(source)) {
        const temp = fs.readFileSync(source, "utf8").trim();
        const tempC = Math.round(parseInt(temp) / 1000);

        if (tempC > 0 && tempC < 150) {
          const result = `${tempC}°C`;
          setCachedValue(context.cache, "temperature", result);
          return result;
        }
      }
    }
  } catch {}

  setCachedValue(context.cache, "temperature", "");
  return "";
}

/**
 * Gets count of running system services
 * Uses systemctl or service command (Linux only)
 * @param context - Info context with cache
 * @returns Service count with "services" suffix or empty string
 * @example "125 services", "89 services"
 */
export function services_running(context: InfoContext): string {
  const cached = getCachedValue(context.cache, "services_running");
  if (cached !== null) return cached;

  if (IS_MAC) {
    try {
      const services = execCommand("launchctl list");
      const serviceCount = services
        .split("\n")
        .filter((line) => line.trim() && !line.startsWith("PID")).length;

      if (serviceCount > 0) {
        const result = `${serviceCount} services`;
        setCachedValue(context.cache, "services_running", result);
        return result;
      }
    } catch {}

    setCachedValue(context.cache, "services_running", "");
    return "";
  }

  if (!IS_LINUX) {
    setCachedValue(context.cache, "services_running", "");
    return "";
  }

  try {
    let serviceCount = 0;

    if (commandExists("systemctl")) {
      const services = execCommand(
        "systemctl list-units --type=service --state=running --no-pager"
      );
      serviceCount = services
        .split("\n")
        .filter((line) => line.includes(".service")).length;
    } else if (commandExists("service")) {
      const services = execCommand("service --status-all");
      serviceCount = services
        .split("\n")
        .filter((line) => line.includes("+")).length;
    }

    if (serviceCount > 0) {
      const result = `${serviceCount} services`;
      setCachedValue(context.cache, "services_running", result);
      return result;
    }
  } catch {}

  setCachedValue(context.cache, "services_running", "");
  return "";
}
";
+function v(I) {
+  return Array.isArray ? Array.isArray(I) : UI(I) === "[object Array]";
+}
+function lg(I) {
+  if (typeof I == "string") return I;
+  if (typeof I == "bigint") return I.toString();
+  const g = I + "";
+  return g == "0" && 1 / I == -1 / 0 ? "-0" : g;
+}
+function bI(I) {
+  return I == null ? "" : lg(I);
+}
+function N(I) {
+  return typeof I == "string";
+}
+function T(I) {
+  return typeof I == "number";
+}
+function dg(I) {
+  return I === !0 || I === !1 || ag(I) && UI(I) == "[object Boolean]";
+}
+function QI(I) {
+  return typeof I == "object";
+}
+function ag(I) {
+  return QI(I) && I !== null;
+}
+function H(I) {
+  return I != null;
+}
+function U(I) {
+  return !I.trim().length;
+}
+function UI(I) {
+  return I == null ? I === void 0 ? "[object Undefined]" : "[object Null]" : Object.prototype.toString.call(I);
+}
+const bg = "Incorrect 'index' type", AI = "Invalid doc index: must be a non-negative integer within the bounds of the docs array", Ag = (I) => `Invalid value for key ${I}`, hg = (I) => `Pattern length exceeds max of ${I}.`, rg = (I) => `Missing ${I} property in key`, ug = (I) => `Property 'weight' in key '${I}' must be a positive integer`, mg = "Fuse.match does not support useTokenSearch: token search requires corpus-level statistics (df, fieldCount) that a one-off string comparison does not have. Use new Fuse(...).search(...) instead.", wI = Object.prototype.hasOwnProperty;
+var Zg = class {
+  constructor(I) {
+    this._keys = [], this._keyMap = {};
+    let g = 0;
+    I.forEach((c) => {
+      const i = TI(c);
+      this._keys.push(i), this._keyMap[i.id] = i, g += i.weight;
+    }), this._keys.forEach((c) => {
+      c.weight /= g;
+    });
+  }
+  get(I) {
+    return this._keyMap[I];
+  }
+  keys() {
+    return this._keys;
+  }
+  toJSON() {
+    return JSON.stringify(this._keys);
+  }
+};
+function TI(I) {
+  let g = null, c = null, i = null, e = 1, s = null;
+  if (N(I) || v(I))
+    i = I, g = fI(I), c = D(I);
+  else {
+    if (!wI.call(I, "name")) throw new Error(rg("name"));
+    const t = I.name;
+    if (i = t, wI.call(I, "weight") && I.weight !== void 0 && (e = I.weight, e <= 0))
+      throw new Error(ug(D(t)));
+    g = fI(t), c = D(t), s = I.getFn ?? null;
+  }
+  return {
+    path: g,
+    id: c,
+    weight: e,
+    src: i,
+    getFn: s
+  };
+}
+function fI(I) {
+  return v(I) ? I : I.split(".");
+}
+function D(I) {
+  return v(I) ? I.join(".") : I;
+}
+function Gg(I, g) {
+  const c = [];
+  let i = !1;
+  const e = (s, t, C, n) => {
+    if (H(s))
+      if (!t[C]) c.push(n !== void 0 ? {
+        v: s,
+        i: n
+      } : s);
+      else {
+        const d = s[t[C]];
+        if (!H(d)) return;
+        if (C === t.length - 1 && (N(d) || T(d) || dg(d) || typeof d == "bigint")) c.push(n !== void 0 ? {
+          v: bI(d),
+          i: n
+        } : bI(d));
+        else if (v(d)) {
+          i = !0;
+          for (let l = 0, o = d.length; l < o; l += 1) e(d[l], t, C + 1, l);
+        } else t.length && e(d, t, C + 1, n);
+      }
+  };
+  return e(I, N(g) ? g.split(".") : g, 0), i ? c : c[0];
+}
+const Bg = {
+  includeMatches: !1,
+  findAllMatches: !1,
+  minMatchCharLength: 1
+}, Wg = {
+  isCaseSensitive: !1,
+  ignoreDiacritics: !1,
+  includeScore: !1,
+  keys: [],
+  shouldSort: !0,
+  sortFn: (I, g) => I.score === g.score ? I.idx < g.idx ? -1 : 1 : I.score < g.score ? -1 : 1
+}, pg = {
+  location: 0,
+  threshold: 0.6,
+  distance: 100
+}, Yg = {
+  useExtendedSearch: !1,
+  useTokenSearch: !1,
+  tokenize: void 0,
+  tokenMatch: "any",
+  getFn: Gg,
+  ignoreLocation: !1,
+  ignoreFieldNorm: !1,
+  fieldNormWeight: 1
+}, h = Object.freeze({
+  ...Wg,
+  ...Bg,
+  ...pg,
+  ...Yg
+});
+function yg(I) {
+  return I >= 9 && I <= 13 || I === 32 || I === 160;
+}
+function Ng(I = 1, g = 3) {
+  const c = /* @__PURE__ */ new Map(), i = Math.pow(10, g);
+  return {
+    get(e) {
+      let s = 0, t = !1;
+      for (let n = 0; n < e.length; n++) yg(e.charCodeAt(n)) ? t = !1 : t || (s++, t = !0);
+      if (s === 0 && (s = 1), c.has(s)) return c.get(s);
+      const C = Math.round(i / Math.pow(s, 0.5 * I)) / i;
+      return c.set(s, C), C;
+    },
+    clear() {
+      c.clear();
+    }
+  };
+}
+var WI = class {
+  constructor({ getFn: I = h.getFn, fieldNormWeight: g = h.fieldNormWeight } = {}) {
+    this.norm = Ng(g, 3), this.getFn = I, this.isCreated = !1, this.docs = [], this.keys = [], this._keysMap = {}, this.setIndexRecords();
+  }
+  setSources(I = []) {
+    this.docs = I;
+  }
+  setIndexRecords(I = []) {
+    this.records = I;
+  }
+  setKeys(I = []) {
+    this.keys = I, this._keysMap = {}, I.forEach((g, c) => {
+      this._keysMap[g.id] = c;
+    });
+  }
+  create() {
+    if (this.isCreated || !this.docs.length) return;
+    this.isCreated = !0;
+    const I = this.docs.length;
+    this.records = new Array(I);
+    let g = 0;
+    if (N(this.docs[0])) for (let c = 0; c < I; c++) {
+      const i = this._createStringRecord(this.docs[c], c);
+      i && (this.records[g++] = i);
+    }
+    else for (let c = 0; c < I; c++) this.records[g++] = this._createObjectRecord(this.docs[c], c);
+    this.records.length = g, this.norm.clear();
+  }
+  add(I, g) {
+    if (!Number.isInteger(g) || g < 0) throw new Error(AI);
+    if (N(I)) {
+      const i = this._createStringRecord(I, g);
+      return i && this.records.push(i), i;
+    }
+    const c = this._createObjectRecord(I, g);
+    return this.records.push(c), c;
+  }
+  removeAt(I) {
+    if (!Number.isInteger(I) || I < 0) throw new Error(AI);
+    for (let g = 0, c = this.records.length; g < c; g += 1) if (this.records[g].i === I) {
+      this.records.splice(g, 1);
+      break;
+    }
+    for (let g = 0, c = this.records.length; g < c; g += 1) this.records[g].i > I && (this.records[g].i -= 1);
+  }
+  removeAll(I) {
+    const g = /* @__PURE__ */ new Set();
+    for (const i of I) Number.isInteger(i) && i >= 0 && g.add(i);
+    if (g.size === 0) return;
+    this.records = this.records.filter((i) => !g.has(i.i));
+    const c = Array.from(g).sort((i, e) => i - e);
+    for (const i of this.records) {
+      let e = 0, s = c.length;
+      for (; e < s; ) {
+        const t = e + s >>> 1;
+        c[t] < i.i ? e = t + 1 : s = t;
+      }
+      i.i -= e;
+    }
+  }
+  getValueForItemAtKeyId(I, g) {
+    return I[this._keysMap[g]];
+  }
+  size() {
+    return this.records.length;
+  }
+  _createStringRecord(I, g) {
+    return !H(I) || U(I) ? null : {
+      v: I,
+      i: g,
+      n: this.norm.get(I)
+    };
+  }
+  _createObjectRecord(I, g) {
+    const c = {
+      i: g,
+      $: {}
+    };
+    for (let i = 0, e = this.keys.length; i < e; i++) {
+      const s = this.keys[i], t = s.getFn ? s.getFn(I) : this.getFn(I, s.path);
+      if (H(t)) {
+        if (v(t)) {
+          const C = [];
+          for (let n = 0, d = t.length; n < d; n += 1) {
+            const l = t[n];
+            if (H(l)) {
+              if (N(l)) {
+                if (!U(l)) {
+                  const o = {
+                    v: l,
+                    i: n,
+                    n: this.norm.get(l)
+                  };
+                  C.push(o);
+                }
+              } else if (H(l.v)) {
+                const o = N(l.v) ? l.v : bI(l.v);
+                if (!U(o)) {
+                  const a = {
+                    v: o,
+                    i: l.i,
+                    n: this.norm.get(o)
+                  };
+                  C.push(a);
+                }
+              }
+            }
+          }
+          c.$[i] = C;
+        } else if (N(t) && !U(t)) {
+          const C = {
+            v: t,
+            n: this.norm.get(t)
+          };
+          c.$[i] = C;
+        }
+      }
+    }
+    return c;
+  }
+  toJSON() {
+    return {
+      keys: this.keys.map(({ getFn: I, ...g }) => g),
+      records: this.records
+    };
+  }
+};
+function DI(I, g, { getFn: c = h.getFn, fieldNormWeight: i = h.fieldNormWeight } = {}) {
+  const e = new WI({
+    getFn: c,
+    fieldNormWeight: i
+  });
+  return e.setKeys(I.map(TI)), e.setSources(g), e.create(), e;
+}
+function Vg(I, { getFn: g = h.getFn, fieldNormWeight: c = h.fieldNormWeight } = {}) {
+  const { keys: i, records: e } = I, s = new WI({
+    getFn: g,
+    fieldNormWeight: c
+  });
+  return s.setKeys(i), s.setIndexRecords(e), s;
+}
+function Kg(I = [], g = h.minMatchCharLength) {
+  const c = [];
+  let i = -1, e = -1, s = 0;
+  for (let t = I.length; s < t; s += 1) {
+    const C = I[s];
+    C && i === -1 ? i = s : !C && i !== -1 && (e = s - 1, e - i + 1 >= g && c.push([i, e]), i = -1);
+  }
+  return I[s - 1] && s - i >= g && c.push([i, s - 1]), c;
+}
+function Hg(I, g, c, { location: i = h.location, distance: e = h.distance, threshold: s = h.threshold, findAllMatches: t = h.findAllMatches, minMatchCharLength: C = h.minMatchCharLength, includeMatches: n = h.includeMatches, ignoreLocation: d = h.ignoreLocation } = {}) {
+  if (g.length > 32) throw new Error(hg(32));
+  const l = g.length, o = I.length, a = Math.max(0, Math.min(i, o));
+  let A = s, m = a;
+  const Z = (y, K) => {
+    const X = y / l;
+    if (d) return X;
+    const z = Math.abs(a - K);
+    return e ? X + z / e : z ? 1 : X;
+  }, r = C > 1 || n, V = r ? Array(o) : [];
+  let f;
+  for (; (f = I.indexOf(g, m)) > -1; ) {
+    const y = Z(0, f);
+    if (A = Math.min(y, A), m = f + l, r) {
+      let K = 0;
+      for (; K < l; )
+        V[f + K] = 1, K += 1;
+    }
+  }
+  m = -1;
+  let R = [], L = 1, HI = 0, Q = l + o;
+  const PI = 1 << l - 1;
+  for (let y = 0; y < l; y += 1) {
+    let K = 0, X = Q;
+    for (; K < X; )
+      Z(y, a + X) <= A ? K = X : Q = X, X = Math.floor((Q - K) / 2 + K);
+    Q = X;
+    let z = Math.max(1, a - X + 1);
+    const nI = t ? o : Math.min(a + X, o) + l, J = Array(nI + 2);
+    J[nI + 1] = (1 << y) - 1;
+    for (let w = nI; w >= z; w -= 1) {
+      const oI = w - 1, $I = c[I[oI]];
+      if (J[w] = (J[w + 1] << 1 | 1) & $I, y && (J[w] |= (R[w + 1] | R[w]) << 1 | 1 | R[w + 1]), J[w] & PI && (L = Z(y, oI), L <= A)) {
+        if (A = L, m = oI, HI = y, m <= a) break;
+        z = Math.max(1, 2 * a - m);
+      }
+    }
+    if (Z(y + 1, a) > A) break;
+    R = J;
+  }
+  if (r && m >= 0) {
+    const y = Math.min(o - 1, m + l - 1 + HI);
+    for (let K = m; K <= y; K += 1) c[I[K]] && (V[K] = 1);
+  }
+  const CI = {
+    isMatch: m >= 0,
+    score: Math.max(1e-3, L)
+  };
+  if (r) {
+    const y = Kg(V, C);
+    y.length ? n && (CI.indices = y) : CI.isMatch = !1;
+  }
+  return CI;
+}
+function Xg(I) {
+  const g = {};
+  for (let c = 0, i = I.length; c < i; c += 1) {
+    const e = I.charAt(c);
+    g[e] = (g[e] || 0) | 1 << i - c - 1;
+  }
+  return g;
+}
+function pI(I) {
+  if (I.length <= 1) return I;
+  I.sort((c, i) => c[0] - i[0] || c[1] - i[1]);
+  const g = [I[0]];
+  for (let c = 1, i = I.length; c < i; c += 1) {
+    const e = g[g.length - 1], s = I[c];
+    s[0] <= e[1] + 1 ? e[1] = Math.max(e[1], s[1]) : g.push(s);
+  }
+  return g;
+}
+const xI = {
+  ł: "l",
+  Ł: "L",
+  đ: "d",
+  Đ: "D",
+  ø: "o",
+  Ø: "O",
+  ħ: "h",
+  Ħ: "H",
+  ŧ: "t",
+  Ŧ: "T",
+  ı: "i",
+  ß: "ss"
+}, wg = new RegExp("[" + Object.keys(xI).join("") + "]", "g"), j = typeof String.prototype.normalize == "function" ? (I) => I.normalize("NFD").replace(/[\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08D3-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B62\u0B63\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0C00-\u0C04\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D82\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EB9\u0EBB\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F\u109A-\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u180B-\u180D\u1885\u1886\u18A9\u1920-\u192B\u1930-\u193B\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F\u1AB0-\u1ABE\u1B00-\u1B04\u1B34-\u1B44\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BE6-\u1BF3\u1C24-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF2-\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DF9\u1DFB-\u1DFF\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA880\uA881\uA8B4-\uA8C5\uA8E0-\uA8F1\uA8FF\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9E5\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F]/g, "").replace(wg, (g) => xI[g]) : (I) => I;
+var YI = class {
+  constructor(I, { location: g = h.location, threshold: c = h.threshold, distance: i = h.distance, includeMatches: e = h.includeMatches, findAllMatches: s = h.findAllMatches, minMatchCharLength: t = h.minMatchCharLength, isCaseSensitive: C = h.isCaseSensitive, ignoreDiacritics: n = h.ignoreDiacritics, ignoreLocation: d = h.ignoreLocation } = {}) {
+    if (this.options = {
+      location: g,
+      threshold: c,
+      distance: i,
+      includeMatches: e,
+      findAllMatches: s,
+      minMatchCharLength: t,
+      isCaseSensitive: C,
+      ignoreDiacritics: n,
+      ignoreLocation: d
+    }, I = C ? I : I.toLowerCase(), I = n ? j(I) : I, this.pattern = I, this.chunks = [], !this.pattern.length) return;
+    const l = (a, A) => {
+      this.chunks.push({
+        pattern: a,
+        alphabet: Xg(a),
+        startIndex: A
+      });
+    }, o = this.pattern.length;
+    if (o > 32) {
+      let a = 0;
+      const A = o % 32, m = o - A;
+      for (; a < m; )
+        l(this.pattern.substr(a, 32), a), a += 32;
+      if (A) {
+        const Z = o - 32;
+        l(this.pattern.substr(Z), Z);
+      }
+    } else l(this.pattern, 0);
+  }
+  searchIn(I) {
+    const { isCaseSensitive: g, ignoreDiacritics: c, includeMatches: i } = this.options;
+    if (I = g ? I : I.toLowerCase(), I = c ? j(I) : I, this.pattern === I) {
+      if (I.length < this.options.minMatchCharLength) return {
+        isMatch: !1,
+        score: 1
+      };
+      const m = {
+        isMatch: !0,
+        score: 0
+      };
+      return i && (m.indices = [[0, I.length - 1]]), m;
+    }
+    const { location: e, distance: s, threshold: t, findAllMatches: C, minMatchCharLength: n, ignoreLocation: d } = this.options, l = [];
+    let o = 0, a = !1;
+    this.chunks.forEach(({ pattern: m, alphabet: Z, startIndex: r }) => {
+      const { isMatch: V, score: f, indices: R } = Hg(I, m, Z, {
+        location: e + r,
+        distance: s,
+        threshold: t,
+        findAllMatches: C,
+        minMatchCharLength: n,
+        includeMatches: i,
+        ignoreLocation: d
+      });
+      V && (a = !0), o += f, V && R && l.push(...R);
+    });
+    const A = {
+      isMatch: a,
+      score: a ? o / this.chunks.length : 1
+    };
+    return a && i && (A.indices = pI(l)), A;
+  }
+};
+const fg = /* @__PURE__ */ new Set(["fuzzy", "include"]);
+function vg(I) {
+  return I.startsWith("inverse");
+}
+const hI = [
+  {
+    type: "exact",
+    multiRegex: /^="(.*)"$/,
+    singleRegex: /^=(.*)$/,
+    create: (I) => ({
+      type: "exact",
+      search(g) {
+        const c = g === I;
+        return {
+          isMatch: c,
+          score: c ? 0 : 1,
+          indices: [0, I.length - 1]
+        };
+      }
+    })
+  },
+  {
+    type: "include",
+    multiRegex: /^'"(.*)"$/,
+    singleRegex: /^'(.*)$/,
+    create: (I) => ({
+      type: "include",
+      search(g) {
+        let c = 0, i;
+        const e = [], s = I.length;
+        for (; (i = g.indexOf(I, c)) > -1; )
+          c = i + s, e.push([i, c - 1]);
+        const t = !!e.length;
+        return {
+          isMatch: t,
+          score: t ? 0 : 1,
+          indices: e
+        };
+      }
+    })
+  },
+  {
+    type: "prefix-exact",
+    multiRegex: /^\^"(.*)"$/,
+    singleRegex: /^\^(.*)$/,
+    create: (I) => ({
+      type: "prefix-exact",
+      search(g) {
+        const c = g.startsWith(I);
+        return {
+          isMatch: c,
+          score: c ? 0 : 1,
+          indices: [0, I.length - 1]
+        };
+      }
+    })
+  },
+  {
+    type: "inverse-prefix-exact",
+    multiRegex: /^!\^"(.*)"$/,
+    singleRegex: /^!\^(.*)$/,
+    create: (I) => ({
+      type: "inverse-prefix-exact",
+      search(g) {
+        const c = !g.startsWith(I);
+        return {
+          isMatch: c,
+          score: c ? 0 : 1,
+          indices: [0, g.length - 1]
+        };
+      }
+    })
+  },
+  {
+    type: "inverse-suffix-exact",
+    multiRegex: /^!"(.*)"\$$/,
+    singleRegex: /^!(.*)\$$/,
+    create: (I) => ({
+      type: "inverse-suffix-exact",
+      search(g) {
+        const c = !g.endsWith(I);
+        return {
+          isMatch: c,
+          score: c ? 0 : 1,
+          indices: [0, g.length - 1]
+        };
+      }
+    })
+  },
+  {
+    type: "suffix-exact",
+    multiRegex: /^"(.*)"\$$/,
+    singleRegex: /^(.*)\$$/,
+    create: (I) => ({
+      type: "suffix-exact",
+      search(g) {
+        const c = g.endsWith(I);
+        return {
+          isMatch: c,
+          score: c ? 0 : 1,
+          indices: [g.length - I.length, g.length - 1]
+        };
+      }
+    })
+  },
+  {
+    type: "inverse-exact",
+    multiRegex: /^!"(.*)"$/,
+    singleRegex: /^!(.*)$/,
+    create: (I) => ({
+      type: "inverse-exact",
+      search(g) {
+        const c = g.indexOf(I) === -1;
+        return {
+          isMatch: c,
+          score: c ? 0 : 1,
+          indices: [0, g.length - 1]
+        };
+      }
+    })
+  },
+  {
+    type: "fuzzy",
+    multiRegex: /^"(.*)"$/,
+    singleRegex: /^(.*)$/,
+    create: (I, g = {}) => {
+      const c = new YI(I, {
+        location: g.location ?? h.location,
+        threshold: g.threshold ?? h.threshold,
+        distance: g.distance ?? h.distance,
+        includeMatches: g.includeMatches ?? h.includeMatches,
+        findAllMatches: g.findAllMatches ?? h.findAllMatches,
+        minMatchCharLength: g.minMatchCharLength ?? h.minMatchCharLength,
+        isCaseSensitive: g.isCaseSensitive ?? h.isCaseSensitive,
+        ignoreDiacritics: g.ignoreDiacritics ?? h.ignoreDiacritics,
+        ignoreLocation: g.ignoreLocation ?? h.ignoreLocation
+      });
+      return {
+        type: "fuzzy",
+        search(i) {
+          return c.searchIn(i);
+        }
+      };
+    }
+  }
+], vI = hI.length, Sg = "\0", Rg = "|";
+function Fg(I) {
+  const g = [], c = I.length;
+  let i = 0;
+  for (; i < c; ) {
+    for (; i < c && I[i] === " "; ) i++;
+    if (i >= c) break;
+    let e = i;
+    for (; e < c && I[e] !== " " && I[e] !== '"'; ) e++;
+    if (e < c && I[e] === '"') {
+      for (e++; e < c; ) {
+        if (I[e] === '"') {
+          const s = e + 1;
+          if (s >= c || I[s] === " ") {
+            e++;
+            break;
+          }
+          if (I[s] === "$" && (s + 1 >= c || I[s + 1] === " ")) {
+            e += 2;
+            break;
+          }
+        }
+        e++;
+      }
+      g.push(I.substring(i, e)), i = e;
+    } else {
+      for (; e < c && I[e] !== " "; ) e++;
+      g.push(I.substring(i, e)), i = e;
+    }
+  }
+  return g;
+}
+function SI(I, g) {
+  const c = I.match(g);
+  return c ? c[1] : null;
+}
+function Jg(I, g = {}) {
+  return I.replace(/\\\|/g, Sg).split(Rg).map((c) => {
+    const i = Fg(c.replace(/\u0000/g, "|").trim()).filter((s) => s && !!s.trim()), e = [];
+    for (let s = 0, t = i.length; s < t; s += 1) {
+      const C = i[s];
+      let n = !1, d = -1;
+      for (; !n && ++d < vI; ) {
+        const l = hI[d], o = SI(C, l.multiRegex);
+        o && (e.push(l.create(o, g)), n = !0);
+      }
+      if (!n)
+        for (d = -1; ++d < vI; ) {
+          const l = hI[d], o = SI(C, l.singleRegex);
+          if (o) {
+            e.push(l.create(o, g));
+            break;
+          }
+        }
+    }
+    return e;
+  });
+}
+var kg = class {
+  constructor(I, { isCaseSensitive: g = h.isCaseSensitive, ignoreDiacritics: c = h.ignoreDiacritics, includeMatches: i = h.includeMatches, minMatchCharLength: e = h.minMatchCharLength, ignoreLocation: s = h.ignoreLocation, findAllMatches: t = h.findAllMatches, location: C = h.location, threshold: n = h.threshold, distance: d = h.distance } = {}) {
+    this.query = null, this.options = {
+      isCaseSensitive: g,
+      ignoreDiacritics: c,
+      includeMatches: i,
+      minMatchCharLength: e,
+      findAllMatches: t,
+      ignoreLocation: s,
+      location: C,
+      threshold: n,
+      distance: d
+    }, I = g ? I : I.toLowerCase(), I = c ? j(I) : I, this.pattern = I, this.query = Jg(this.pattern, this.options);
+  }
+  static condition(I, g) {
+    return g.useExtendedSearch;
+  }
+  searchIn(I) {
+    const g = this.query;
+    if (!g) return {
+      isMatch: !1,
+      score: 1
+    };
+    const { includeMatches: c, isCaseSensitive: i, ignoreDiacritics: e } = this.options;
+    I = i ? I : I.toLowerCase(), I = e ? j(I) : I;
+    let s = 0;
+    const t = [];
+    let C = 0, n = !1;
+    for (let d = 0, l = g.length; d < l; d += 1) {
+      const o = g[d];
+      t.length = 0, s = 0, n = !1;
+      for (let a = 0, A = o.length; a < A; a += 1) {
+        const m = o[a], { isMatch: Z, indices: r, score: V } = m.search(I);
+        if (Z)
+          s += 1, C += V, vg(m.type) && (n = !0), c && (fg.has(m.type) ? t.push(...r) : t.push(r));
+        else {
+          C = 0, s = 0, t.length = 0, n = !1;
+          break;
+        }
+      }
+      if (s) {
+        const a = {
+          isMatch: !0,
+          score: C / s
+        };
+        return n && (a.hasInverse = !0), c && (a.indices = pI(t)), a;
+      }
+    }
+    return {
+      isMatch: !1,
+      score: 1
+    };
+  }
+};
+const rI = [];
+function yI(...I) {
+  rI.push(...I);
+}
+function E(I, g) {
+  for (let c = 0, i = rI.length; c < i; c += 1) {
+    const e = rI[c];
+    if (e.condition(I, g)) return new e(I, g);
+  }
+  return new YI(I, g);
+}
+const _ = {
+  AND: "$and",
+  OR: "$or"
+}, uI = {
+  PATH: "$path",
+  PATTERN: "$val"
+}, mI = (I) => !!(I[_.AND] || I[_.OR]), zg = (I) => !!I[uI.PATH], jg = (I) => !v(I) && QI(I) && !mI(I), RI = (I) => ({ [_.AND]: Object.keys(I).map((g) => ({ [g]: I[g] })) });
+function OI(I, g, { auto: c = !0 } = {}) {
+  const i = (e) => {
+    if (N(e)) {
+      const n = {
+        keyId: null,
+        pattern: e
+      };
+      return c && (n.searcher = E(e, g)), n;
+    }
+    const s = Object.keys(e), t = zg(e);
+    if (!t && s.length > 1 && !mI(e)) return i(RI(e));
+    if (jg(e)) {
+      const n = t ? e[uI.PATH] : s[0], d = t ? e[uI.PATTERN] : e[n];
+      if (!N(d)) throw new Error(Ag(n));
+      const l = {
+        keyId: D(n),
+        pattern: d
+      };
+      return c && (l.searcher = E(d, g)), l;
+    }
+    const C = {
+      children: [],
+      operator: s[0]
+    };
+    return s.forEach((n) => {
+      const d = e[n];
+      v(d) && d.forEach((l) => {
+        C.children.push(i(l));
+      });
+    }), C;
+  };
+  return mI(I) || (I = RI(I)), i(I);
+}
+function ZI(I, { ignoreFieldNorm: g = h.ignoreFieldNorm }) {
+  let c = 1;
+  return I.forEach(({ key: i, norm: e, score: s }) => {
+    const t = i ? i.weight : null;
+    c *= Math.pow(s === 0 && t ? Number.EPSILON : s, (t || 1) * (g ? 1 : e));
+  }), c;
+}
+function Mg(I, { ignoreFieldNorm: g = h.ignoreFieldNorm }) {
+  I.forEach((c) => {
+    c.score = ZI(c.matches, { ignoreFieldNorm: g });
+  });
+}
+var Lg = class {
+  constructor(I, g) {
+    this.limit = I, this.heap = [], this.comparator = g;
+  }
+  get size() {
+    return this.heap.length;
+  }
+  insert(I) {
+    this.size < this.limit ? (this.heap.push(I), this._bubbleUp(this.size - 1)) : this.comparator(I, this.heap[0]) < 0 && (this.heap[0] = I, this._sinkDown(0));
+  }
+  extractSorted() {
+    return this.heap.sort(this.comparator);
+  }
+  _bubbleUp(I) {
+    const g = this.heap;
+    for (; I > 0; ) {
+      const c = I - 1 >> 1;
+      if (this.comparator(g[I], g[c]) <= 0) break;
+      const i = g[I];
+      g[I] = g[c], g[c] = i, I = c;
+    }
+  }
+  _sinkDown(I) {
+    const g = this.heap, c = g.length;
+    let i = I;
+    do {
+      I = i;
+      const e = 2 * I + 1, s = 2 * I + 2;
+      if (e < c && this.comparator(g[e], g[i]) > 0 && (i = e), s < c && this.comparator(g[s], g[i]) > 0 && (i = s), i !== I) {
+        const t = g[I];
+        g[I] = g[i], g[i] = t;
+      }
+    } while (i !== I);
+  }
+};
+function Qg(I) {
+  const g = [];
+  return I.matches.forEach((c) => {
+    if (!H(c.indices) || !c.indices.length) return;
+    const i = {
+      indices: c.indices,
+      value: c.value
+    };
+    c.key && (i.key = c.key.id), c.idx > -1 && (i.refIndex = c.idx), g.push(i);
+  }), g;
+}
+function Ug(I, g, { includeMatches: c = h.includeMatches, includeScore: i = h.includeScore } = {}) {
+  return I.map((e) => {
+    const { idx: s } = e, t = {
+      item: g[s],
+      refIndex: s
+    };
+    return c && (t.matches = Qg(e)), i && (t.score = e.score), t;
+  });
+}
+const Tg = /[\p{L}\p{M}\p{N}_]+/gu, FI = /* @__PURE__ */ new WeakSet();
+function Dg(I) {
+  FI.has(I) || (FI.add(I), console.warn(`[Fuse] tokenize regex ${I} lacks the global flag; only the first match per text will be returned. Add the 'g' flag.`));
+}
+function xg(I) {
+  if (typeof I == "function") {
+    let g = !1;
+    return (c) => {
+      const i = I(c);
+      if (!g && (g = !0, !Array.isArray(i) || i.some((e) => typeof e != "string")))
+        throw new Error(`[Fuse] tokenize function must return string[]; received ${Array.isArray(i) ? "array containing non-strings" : typeof i}.`);
+      return i;
+    };
+  }
+  return I instanceof RegExp ? (I.global || Dg(I), (g) => g.match(I) || []) : (g) => g.match(Tg) || [];
+}
+function GI({ isCaseSensitive: I = !1, ignoreDiacritics: g = !1, tokenize: c } = {}) {
+  const i = xg(c);
+  return { tokenize(e) {
+    return I || (e = e.toLowerCase()), g && (e = j(e)), i(e);
+  } };
+}
+var Og = class {
+  static condition(I, g) {
+    return g.useTokenSearch;
+  }
+  constructor(I, g) {
+    this.options = g, this.analyzer = GI({
+      isCaseSensitive: g.isCaseSensitive,
+      ignoreDiacritics: g.ignoreDiacritics,
+      tokenize: g.tokenize
+    });
+    const c = this.analyzer.tokenize(I), { df: i, fieldCount: e } = g._invertedIndex;
+    this.termSearchers = [], this.idfWeights = [];
+    for (const s of c) {
+      this.termSearchers.push(new YI(s, {
+        location: g.location,
+        threshold: g.threshold,
+        distance: g.distance,
+        includeMatches: g.includeMatches,
+        findAllMatches: g.findAllMatches,
+        minMatchCharLength: g.minMatchCharLength,
+        isCaseSensitive: g.isCaseSensitive,
+        ignoreDiacritics: g.ignoreDiacritics,
+        ignoreLocation: !0
+      }));
+      const t = i.get(s) || 0, C = Math.log(1 + (e - t + 0.5) / (t + 0.5));
+      this.idfWeights.push(C);
+    }
+    this.combineAll = g.tokenMatch === "all", this.numTerms = this.termSearchers.length, this.useMask = this.numTerms <= 31;
+  }
+  searchIn(I) {
+    if (!this.termSearchers.length) return {
+      isMatch: !1,
+      score: 1
+    };
+    const g = [];
+    let c = 0, i = 0, e = 0, s = 0;
+    const t = this.combineAll && !this.useMask ? /* @__PURE__ */ new Set() : null;
+    for (let d = 0; d < this.termSearchers.length; d++) {
+      const l = this.termSearchers[d].searchIn(I), o = this.idfWeights[d];
+      i += o, l.isMatch && (e++, c += o * (1 - l.score), l.indices && g.push(...l.indices), this.combineAll && (this.useMask ? s |= 1 << d : t.add(d)));
+    }
+    if (e === 0) return {
+      isMatch: !1,
+      score: 1
+    };
+    const C = i > 0 ? 1 - c / i : 0, n = {
+      isMatch: !0,
+      score: Math.max(1e-3, C)
+    };
+    return this.options.includeMatches && g.length && (n.indices = pI(g)), this.combineAll && (this.useMask ? n.matchedMask = s : n.matchedTerms = t, n.termCount = this.numTerms), n;
+  }
+};
+function lI(I, g, c, i) {
+  const e = i.tokenize(g);
+  if (!e.length) return;
+  I.fieldCount++, I.docFieldCount.set(c, (I.docFieldCount.get(c) || 0) + 1);
+  const s = new Set(e);
+  let t = I.docTermFieldHits.get(c);
+  t || (t = /* @__PURE__ */ new Map(), I.docTermFieldHits.set(c, t));
+  for (const C of s)
+    t.set(C, (t.get(C) || 0) + 1), I.df.set(C, (I.df.get(C) || 0) + 1);
+}
+function EI(I, g, c, i) {
+  const { i: e, v: s, $: t } = g;
+  if (s !== void 0) {
+    lI(I, s, e, i);
+    return;
+  }
+  if (t)
+    for (let C = 0; C < c; C++) {
+      const n = t[C];
+      if (n)
+        if (Array.isArray(n)) for (const d of n) lI(I, d.v, e, i);
+        else lI(I, n.v, e, i);
+    }
+}
+function Eg(I, g, c) {
+  const i = {
+    fieldCount: 0,
+    df: /* @__PURE__ */ new Map(),
+    docFieldCount: /* @__PURE__ */ new Map(),
+    docTermFieldHits: /* @__PURE__ */ new Map()
+  };
+  for (const e of I) EI(i, e, g, c);
+  return i;
+}
+function _g(I, g, c, i) {
+  EI(I, g, c, i);
+}
+function Pg(I, g) {
+  const c = I.docFieldCount.get(g);
+  if (c === void 0) return;
+  I.fieldCount -= c, I.docFieldCount.delete(g);
+  const i = I.docTermFieldHits.get(g);
+  if (i) {
+    for (const [e, s] of i) {
+      const t = (I.df.get(e) || 0) - s;
+      t <= 0 ? I.df.delete(e) : I.df.set(e, t);
+    }
+    I.docTermFieldHits.delete(g);
+  }
+}
+function JI(I, g) {
+  if (g.length === 0) return;
+  const c = Array.from(new Set(g)).sort((C, n) => C - n);
+  for (const C of c) Pg(I, C);
+  const i = (C) => {
+    let n = 0, d = c.length;
+    for (; n < d; ) {
+      const l = n + d >>> 1;
+      c[l] < C ? n = l + 1 : d = l;
+    }
+    return C - n;
+  }, e = c[0], s = /* @__PURE__ */ new Map();
+  for (const [C, n] of I.docFieldCount) s.set(C > e ? i(C) : C, n);
+  I.docFieldCount = s;
+  const t = /* @__PURE__ */ new Map();
+  for (const [C, n] of I.docTermFieldHits) t.set(C > e ? i(C) : C, n);
+  I.docTermFieldHits = t;
+}
+var S = class {
+  constructor(I, g, c) {
+    this.options = {
+      ...h,
+      ...g
+    }, this.options.useExtendedSearch, this.options.useTokenSearch, this._keyStore = new Zg(this.options.keys), this._docs = I, this._myIndex = null, this._invertedIndex = null, this.setCollection(I, c), this._lastQuery = null, this._lastSearcher = null;
+  }
+  _getSearcher(I) {
+    if (this._lastQuery === I) return this._lastSearcher;
+    const g = E(I, this._invertedIndex ? {
+      ...this.options,
+      _invertedIndex: this._invertedIndex
+    } : this.options);
+    return this._lastQuery = I, this._lastSearcher = g, g;
+  }
+  setCollection(I, g) {
+    if (this._docs = I, g && !(g instanceof WI)) throw new Error(bg);
+    if (this._myIndex = g || DI(this.options.keys, this._docs, {
+      getFn: this.options.getFn,
+      fieldNormWeight: this.options.fieldNormWeight
+    }), this.options.useTokenSearch) {
+      const c = GI({
+        isCaseSensitive: this.options.isCaseSensitive,
+        ignoreDiacritics: this.options.ignoreDiacritics,
+        tokenize: this.options.tokenize
+      });
+      this._invertedIndex = Eg(this._myIndex.records, this._myIndex.keys.length, c);
+    }
+    this._invalidateSearcherCache();
+  }
+  add(I) {
+    if (!H(I)) return;
+    this._docs.push(I);
+    const g = this._myIndex.add(I, this._docs.length - 1);
+    if (this._invertedIndex && g) {
+      const c = GI({
+        isCaseSensitive: this.options.isCaseSensitive,
+        ignoreDiacritics: this.options.ignoreDiacritics,
+        tokenize: this.options.tokenize
+      });
+      _g(this._invertedIndex, g, this._myIndex.keys.length, c);
+    }
+    this._invalidateSearcherCache();
+  }
+  remove(I = () => !1) {
+    const g = [], c = [];
+    for (let i = 0, e = this._docs.length; i < e; i += 1) I(this._docs[i], i) && (g.push(this._docs[i]), c.push(i));
+    if (c.length) {
+      this._invertedIndex && JI(this._invertedIndex, c);
+      const i = new Set(c);
+      this._docs = this._docs.filter((e, s) => !i.has(s)), this._myIndex.removeAll(c), this._invalidateSearcherCache();
+    }
+    return g;
+  }
+  removeAt(I) {
+    if (!Number.isInteger(I) || I < 0 || I >= this._docs.length) throw new Error(AI);
+    this._invertedIndex && JI(this._invertedIndex, [I]);
+    const g = this._docs.splice(I, 1)[0];
+    return this._myIndex.removeAt(I), this._invalidateSearcherCache(), g;
+  }
+  _invalidateSearcherCache() {
+    this._lastQuery = null, this._lastSearcher = null;
+  }
+  getIndex() {
+    return this._myIndex;
+  }
+  _normalizedKeys() {
+    return this._myIndex.keys.map((I) => this._keyStore.get(I.id) || I);
+  }
+  search(I, g) {
+    const { limit: c = -1 } = g || {}, { includeMatches: i, includeScore: e, shouldSort: s, sortFn: t, ignoreFieldNorm: C } = this.options;
+    if (N(I) && !I.trim()) {
+      let a = this._docs.map((A, m) => ({
+        item: A,
+        refIndex: m
+      }));
+      return T(c) && c > -1 && (a = a.slice(0, c)), a;
+    }
+    const n = s && T(c) && c > 0 && N(I), d = t, l = (a, A) => d(a, A) || a.idx - A.idx;
+    let o;
+    if (n) {
+      const a = new Lg(c, l);
+      N(this._docs[0]) ? this._searchStringList(I, {
+        heap: a,
+        ignoreFieldNorm: C
+      }) : this._searchObjectList(I, {
+        heap: a,
+        ignoreFieldNorm: C
+      }), o = a.extractSorted();
+    } else
+      o = N(I) ? N(this._docs[0]) ? this._searchStringList(I) : this._searchObjectList(I) : this._searchLogical(I), Mg(o, { ignoreFieldNorm: C }), s && o.sort(N(I) ? l : d), T(c) && c > -1 && (o = o.slice(0, c));
+    return Ug(o, this._docs, {
+      includeMatches: i,
+      includeScore: e
+    });
+  }
+  _searchStringList(I, { heap: g, ignoreFieldNorm: c } = {}) {
+    const i = this._getSearcher(I), e = this.options.useTokenSearch && this.options.tokenMatch === "all", { records: s } = this._myIndex, t = g ? null : [];
+    return s.forEach(({ v: C, i: n, n: d }) => {
+      if (!H(C)) return;
+      const l = i.searchIn(C);
+      if (l.isMatch) {
+        const o = {
+          score: l.score,
+          value: C,
+          norm: d,
+          indices: l.indices
+        };
+        e && (o.matchedMask = l.matchedMask, o.matchedTerms = l.matchedTerms, o.termCount = l.termCount);
+        const a = [o];
+        if (!e || this._coversAllTokens(a)) {
+          const A = {
+            item: C,
+            idx: n,
+            matches: a
+          };
+          g ? (A.score = ZI(A.matches, { ignoreFieldNorm: c }), g.insert(A)) : t.push(A);
+        }
+      }
+    }), t;
+  }
+  _searchLogical(I) {
+    const g = OI(I, this.options), c = this._normalizedKeys(), i = (C, n, d) => {
+      if (!("children" in C)) {
+        const { keyId: A, searcher: m } = C;
+        let Z;
+        return A === null ? (Z = [], c.forEach((r, V) => {
+          Z.push(...this._findMatches({
+            key: r,
+            value: n[V],
+            searcher: m
+          }));
+        })) : Z = this._findMatches({
+          key: this._keyStore.get(A),
+          value: this._myIndex.getValueForItemAtKeyId(n, A),
+          searcher: m
+        }), Z && Z.length ? [{
+          idx: d,
+          item: n,
+          matches: Z
+        }] : [];
+      }
+      const { children: l, operator: o } = C, a = [];
+      for (let A = 0, m = l.length; A < m; A += 1) {
+        const Z = l[A], r = i(Z, n, d);
+        if (r.length) a.push(...r);
+        else if (o === _.AND) return [];
+      }
+      return a;
+    }, e = this._myIndex.records, s = /* @__PURE__ */ new Map(), t = [];
+    return e.forEach(({ $: C, i: n }) => {
+      if (H(C)) {
+        const d = i(g, C, n);
+        d.length && (s.has(n) || (s.set(n, {
+          idx: n,
+          item: C,
+          matches: []
+        }), t.push(s.get(n))), d.forEach(({ matches: l }) => {
+          s.get(n).matches.push(...l);
+        }));
+      }
+    }), t;
+  }
+  _searchObjectList(I, { heap: g, ignoreFieldNorm: c } = {}) {
+    const i = this._getSearcher(I), e = this.options.useTokenSearch && this.options.tokenMatch === "all", { records: s } = this._myIndex, t = this._normalizedKeys(), C = g ? null : [];
+    return s.forEach(({ $: n, i: d }) => {
+      if (!H(n)) return;
+      const l = [];
+      let o = !1, a = !1;
+      if (t.forEach((A, m) => {
+        const Z = this._findMatches({
+          key: A,
+          value: n[m],
+          searcher: i
+        });
+        Z.length ? (l.push(...Z), Z[0].hasInverse && (a = !0)) : o = !0;
+      }), !(a && o) && l.length && (!e || this._coversAllTokens(l))) {
+        const A = {
+          idx: d,
+          item: n,
+          matches: l
+        };
+        g ? (A.score = ZI(A.matches, { ignoreFieldNorm: c }), g.insert(A)) : C.push(A);
+      }
+    }), C;
+  }
+  _findMatches({ key: I, value: g, searcher: c }) {
+    if (!H(g)) return [];
+    const i = [];
+    if (v(g)) g.forEach(({ v: e, i: s, n: t }) => {
+      if (!H(e)) return;
+      const C = c.searchIn(e);
+      if (C.isMatch) {
+        const n = {
+          score: C.score,
+          key: I,
+          value: e,
+          idx: s,
+          norm: t,
+          indices: C.indices,
+          hasInverse: C.hasInverse
+        };
+        C.termCount !== void 0 && (n.matchedMask = C.matchedMask, n.matchedTerms = C.matchedTerms, n.termCount = C.termCount), i.push(n);
+      }
+    });
+    else {
+      const { v: e, n: s } = g, t = c.searchIn(e);
+      if (t.isMatch) {
+        const C = {
+          score: t.score,
+          key: I,
+          value: e,
+          norm: s,
+          indices: t.indices,
+          hasInverse: t.hasInverse
+        };
+        t.termCount !== void 0 && (C.matchedMask = t.matchedMask, C.matchedTerms = t.matchedTerms, C.termCount = t.termCount), i.push(C);
+      }
+    }
+    return i;
+  }
+  _coversAllTokens(I) {
+    const g = I.length ? I[0].termCount : void 0;
+    if (g === void 0) return !0;
+    if (g <= 31) {
+      let i = 0;
+      for (let e = 0; e < I.length; e++) i |= I[e].matchedMask || 0;
+      return i === 2 ** g - 1;
+    }
+    const c = /* @__PURE__ */ new Set();
+    for (let i = 0; i < I.length; i++) {
+      const e = I[i].matchedTerms;
+      if (e) for (const s of e) c.add(s);
+    }
+    return c.size === g;
+  }
+};
+S.version = "7.5.0";
+S.createIndex = DI;
+S.parseIndex = Vg;
+S.config = h;
+S.match = function(I, g, c) {
+  if (c && c.useTokenSearch) throw new Error(mg);
+  return E(I, {
+    ...h,
+    ...c
+  }).searchIn(g);
+};
+S.parseQuery = OI;
+yI(kg);
+yI(Og);
+S.use = function(...I) {
+  I.forEach((g) => yI(g));
+};
+var tI = S;
+function _I(I, g, c) {
+  return `${Math.round(I / 1e3)}k #${g} Top ${NI(I, c)}%`;
+}
+function NI(I, g) {
+  if (!g.length) return 100;
+  const c = g.filter((i) => i > I).length;
+  return Math.min(100, Math.max(1, Math.ceil(c / g.length * 100)));
+}
+function VI(I) {
+  const g = W(I.cache, "cpu");
+  if (g) return g;
+  let c = "";
+  if (F) {
+    try {
+      const e = G("wmic cpu get name /format:list").match(/Name=(.+)/);
+      e && (c = e[1].trim());
+    } catch {
+    }
+    if (!c)
+      try {
+        const i = G(
+          'powershell.exe -Command "Get-WmiObject -Class Win32_Processor | Select-Object -ExpandProperty Name"'
+        );
+        i.trim() && (c = i.trim());
+      } catch {
+      }
+  } else if (p) {
+    try {
+      const e = G("lscpu").match(/Model name:\s*([^\n,]+)/);
+      e && (c = e[1].trim());
+    } catch {
+    }
+    if (!c)
+      try {
+        const i = u.readFileSync("/proc/cpuinfo", "utf8"), e = i.match(/model name\s*:\s*([^\n]+)/), s = i.match(/Hardware\s*:\s*([^\n]+)/);
+        e ? c = e[1].trim() : s && (c = s[1].trim());
+      } catch {
+      }
+  } else {
+    const i = B.cpus();
+    i.length > 0 && (c = i[0].model.trim().replace(/[\r\n]+/g, " "));
+  }
+  return c ? (c = c.trim().replace(/with .*/, ""), b(I.cache, "cpu", c), c) : (b(I.cache, "cpu", ""), "");
+}
+function KI(I) {
+  const g = W(I.cache, "gpu");
+  if (g !== null) return g;
+  if (F) {
+    const c = [];
+    try {
+      const e = G(
+        "wmic path win32_VideoController get name /format:list"
+      ).matchAll(/Name=(.+)/g);
+      for (const s of e) {
+        const t = s[1].trim();
+        t && !t.includes("Microsoft Basic") && c.push(t);
+      }
+    } catch {
+    }
+    if (c.length === 0)
+      try {
+        const i = G(
+          `powershell.exe -Command "Get-WmiObject -Class Win32_VideoController | Where-Object {$_.Name -notlike '*Microsoft Basic*'} | Select-Object -ExpandProperty Name"`
+        );
+        if (i.trim())
+          for (const e of i.trim().split(/\r?\n/)) {
+            const s = e.trim();
+            s && !s.includes("Microsoft Basic") && c.push(s);
+          }
+      } catch {
+      }
+    if (c.length > 0) {
+      const i = c.join(", ");
+      return b(I.cache, "gpu", i), i;
+    }
+  } else if (Y)
+    try {
+      const c = G("system_profiler SPDisplaysDataType"), i = Array.from(c.matchAll(/Chipset Model:\s*(.+)/g)).map(
+        (e) => e[1].trim()
+      );
+      if (i.length > 0) {
+        const e = i.join(", ");
+        return b(I.cache, "gpu", e), e;
+      }
+    } catch {
+    }
+  else if (p)
+    try {
+      const c = G("lspci"), i = [], e = /(?:VGA compatible controller|3D controller|Display controller)/i, s = /(?:NVIDIA|GeForce|RTX|GTX|Quadro|Tesla|AMD|ATI|Radeon|Navi|Vega|RX|Intel.*(?:Arc|UHD|Iris|HD Graphics))/i;
+      for (const t of c.split(`
+`)) {
+        if (!e.test(t) || !s.test(t)) continue;
+        let C;
+        const n = t.match(/\[([^\]]+)\]/g);
+        n && n.length > 0 ? C = n[n.length - 1].replace(/^\[|\]$/g, "") : C = t.replace(/^.*(?:VGA compatible controller|3D controller|Display controller):\s*/i, "").replace(/\s*\(rev [a-f0-9]+\)\s*$/i, "").trim(), C && !i.includes(C) && i.push(C);
+      }
+      if (i.length > 0) {
+        const t = i.join(", ");
+        return b(I.cache, "gpu", t), t;
+      }
+    } catch {
+    }
+  return b(I.cache, "gpu", ""), "";
+}
+function $g() {
+  if (Y) {
+    try {
+      const g = G("system_profiler SPDisplaysDataType").match(/Resolution:\s*(\d+) x (\d+)/);
+      if (g)
+        return `${g[1]}x${g[2]}`;
+    } catch {
+    }
+    return "";
+  }
+  if (!p) return "";
+  try {
+    if (process.env.DISPLAY) {
+      const g = G("xrandr").match(/(\d+x\d+)\+\d+\+\d+/);
+      if (g)
+        return g[1];
+    }
+  } catch {
+  }
+  return "";
+}
+function qg(I) {
+  const g = W(I.cache, "bench");
+  if (g) return g;
+  const c = VI(I);
+  if (!c)
+    return b(I.cache, "bench", ""), "";
+  try {
+    let i;
+    const e = "cpu-geekbench.json";
+    if (u.existsSync(e))
+      i = e;
+    else if (u.existsSync(`src/bench/${e}`))
+      i = `src/bench/${e}`;
+    else if (u.existsSync(`./bench/${e}`))
+      i = `./bench/${e}`;
+    else
+      try {
+        const o = new URL((/* @__PURE__ */ Object.assign({ "./hardware.test.ts": P, "./memory.ts": $, "./network.ts": q, "./platform.test.ts": II, "./platform.ts": gI, "./process.ts": iI, "./settings.ts": cI, "./software.ts": eI, "./system-status.ts": sI }))[`./${e}`], import.meta.url);
+        i = o.pathname, u.existsSync(i) || (i = o.pathname.substring(0, o.pathname.lastIndexOf("/")) + `/${e}`);
+      } catch {
+        i = e;
+      }
+    const s = u.readFileSync(i, "utf8"), C = JSON.parse(s).scores, n = C.map((o) => ({ name: o[0], score: o[1], rank: o[2] })), l = new tI(n, {
+      keys: ["name"],
+      threshold: 0.6,
+      minMatchCharLength: 3
+    }).search(c);
+    if (l.length > 0) {
+      const o = l[0].item, a = _I(o.score, o.rank, C.map((A) => A[1]));
+      return b(I.cache, "bench", a), a;
+    }
+  } catch {
+  }
+  return b(I.cache, "bench", ""), "";
+}
+function Ii(I) {
+  const g = W(I.cache, "cpu_bench_info");
+  if (g) return g;
+  const c = VI(I);
+  if (!c)
+    return b(I.cache, "cpu_bench_info", ""), "";
+  try {
+    let i;
+    const e = "cpu-geekbench.json";
+    if (u.existsSync(e))
+      i = e;
+    else if (u.existsSync(`src/bench/${e}`))
+      i = `src/bench/${e}`;
+    else if (u.existsSync(`./bench/${e}`))
+      i = `./bench/${e}`;
+    else
+      try {
+        const o = new URL((/* @__PURE__ */ Object.assign({ "./hardware.test.ts": P, "./memory.ts": $, "./network.ts": q, "./platform.test.ts": II, "./platform.ts": gI, "./process.ts": iI, "./settings.ts": cI, "./software.ts": eI, "./system-status.ts": sI }))[`./${e}`], import.meta.url);
+        i = o.pathname, u.existsSync(i) || (i = o.pathname.substring(0, o.pathname.lastIndexOf("/")) + `/${e}`);
+      } catch {
+        i = e;
+      }
+    const s = u.readFileSync(i, "utf8"), C = JSON.parse(s).scores, n = C.map((o) => ({
+      name: o[0],
+      score: o[1],
+      rank: o[2]
+    })), l = new tI(n, {
+      keys: ["name"],
+      threshold: 0.6,
+      minMatchCharLength: 3
+    }).search(c);
+    if (l.length > 0) {
+      const o = l[0].item, a = Math.round(o.score / 1e3), A = o.rank, m = NI(o.score, C.map((V) => V[1]));
+      let Z = "Unknown";
+      o.name.includes("Apple") || o.name.includes("ARM") ? Z = "ARM" : o.name.includes("Intel") ? Z = "Intel" : o.name.includes("AMD") || o.name.includes("Ryzen") || o.name.includes("EPYC") ? Z = "AMD" : o.name.includes("Qualcomm") && (Z = "ARM");
+      const r = `Geekbench 6: ${a}k (Rank #${A}, Top ${m}%) - ${Z}`;
+      return b(I.cache, "cpu_bench_info", r), r;
+    }
+  } catch {
+  }
+  return b(I.cache, "cpu_bench_info", ""), "";
+}
+function gi(I) {
+  const g = W(I.cache, "gpu_bench");
+  if (g) return g;
+  const c = KI(I);
+  if (!c)
+    return b(I.cache, "gpu_bench", ""), "";
+  try {
+    let i;
+    const e = "gpu-geekbench.json";
+    if (u.existsSync(e))
+      i = e;
+    else if (u.existsSync(`src/bench/${e}`))
+      i = `src/bench/${e}`;
+    else if (u.existsSync(`./bench/${e}`))
+      i = `./bench/${e}`;
+    else
+      try {
+        const o = new URL((/* @__PURE__ */ Object.assign({ "./hardware.test.ts": P, "./memory.ts": $, "./network.ts": q, "./platform.test.ts": II, "./platform.ts": gI, "./process.ts": iI, "./settings.ts": cI, "./software.ts": eI, "./system-status.ts": sI }))[`./${e}`], import.meta.url);
+        i = o.pathname, u.existsSync(i) || (i = o.pathname.substring(0, o.pathname.lastIndexOf("/")) + `/${e}`);
+      } catch {
+        i = e;
+      }
+    const s = u.readFileSync(i, "utf8"), C = JSON.parse(s).scores, n = C.map((o) => ({ name: o[0], score: o[1], rank: o[2] })), l = new tI(n, {
+      keys: ["name"],
+      threshold: 0.6,
+      minMatchCharLength: 3
+    }).search(c);
+    if (l.length > 0) {
+      const o = l[0].item, a = _I(o.score, o.rank, C.map((A) => A[1]));
+      return b(I.cache, "gpu_bench", a), a;
+    }
+  } catch {
+  }
+  return b(I.cache, "gpu_bench", ""), "";
+}
+function ii(I) {
+  const g = W(I.cache, "gpu_bench_info");
+  if (g) return g;
+  const c = KI(I);
+  if (!c)
+    return b(I.cache, "gpu_bench_info", ""), "";
+  try {
+    let i;
+    const e = "gpu-geekbench.json";
+    if (u.existsSync(e))
+      i = e;
+    else if (u.existsSync(`src/bench/${e}`))
+      i = `src/bench/${e}`;
+    else if (u.existsSync(`./bench/${e}`))
+      i = `./bench/${e}`;
+    else
+      try {
+        const o = new URL((/* @__PURE__ */ Object.assign({ "./hardware.test.ts": P, "./memory.ts": $, "./network.ts": q, "./platform.test.ts": II, "./platform.ts": gI, "./process.ts": iI, "./settings.ts": cI, "./software.ts": eI, "./system-status.ts": sI }))[`./${e}`], import.meta.url);
+        i = o.pathname, u.existsSync(i) || (i = o.pathname.substring(0, o.pathname.lastIndexOf("/")) + `/${e}`);
+      } catch {
+        i = e;
+      }
+    const s = u.readFileSync(i, "utf8"), C = JSON.parse(s).scores, n = C.map((o) => ({
+      name: o[0],
+      score: o[1],
+      rank: o[2]
+    })), l = new tI(n, {
+      keys: ["name"],
+      threshold: 0.6,
+      minMatchCharLength: 3
+    }).search(c);
+    if (l.length > 0) {
+      const o = l[0].item, a = Math.round(o.score / 1e3), A = o.rank, m = NI(o.score, C.map((f) => f[1]));
+      let Z = "Unknown";
+      const r = o.name.toUpperCase();
+      r.includes("NVIDIA") || r.includes("GEFORCE") || r.includes("RTX") || r.includes("GTX") || r.includes("QUADRO") || r.includes("TESL") || r.includes("B200") || r.includes("H100") || r.includes("A100") || r.includes("A40") || r.includes("L40") || r.includes("L20") ? Z = "NVIDIA" : r.includes("AMD") || r.includes("RADEON") || r.includes("RX ") || r.includes("HD") || r.includes("EPYC") || r.includes("INSTINCT") || r.includes("NAVI") || r.includes("VEGA") ? Z = "AMD" : (r.includes("INTEL") || r.includes("ARC") || r.includes("UHD") || r.includes("IRIS") || r.includes("HD GRAPHICS")) && (Z = "Intel");
+      const V = `Geekbench 6: ${a}k (Rank #${A}, Top ${m}%) - ${Z}`;
+      return b(I.cache, "gpu_bench_info", V), V;
+    }
+  } catch {
+  }
+  return b(I.cache, "gpu_bench_info", ""), "";
+}
+function ci(I) {
+  const g = W(I.cache, "ram_used");
+  if (g) return g;
+  if (p)
+    try {
+      const n = u.readFileSync("/proc/meminfo", "utf8"), d = n.match(/MemTotal:\s+(\d+) kB/), l = n.match(/MemFree:\s+(\d+) kB/);
+      if (d && l) {
+        const o = Math.round(parseInt(d[1]) / 1024), a = Math.round(parseInt(l[1]) / 1024), A = o - a, m = Math.round(o / 1024), r = `${Math.round(A / 1024)}/${m}GB`;
+        return b(I.cache, "ram_used", r), r;
+      }
+    } catch {
+    }
+  const c = B.totalmem(), i = B.freemem(), e = c - i, s = Math.round(c / (1024 * 1024 * 1024)), C = `${Math.round(e / (1024 * 1024 * 1024))}/${s}GB`;
+  return b(I.cache, "ram_used", C), C;
+}
+function ei() {
+  if (p) {
+    try {
+      const g = u.readFileSync("/proc/meminfo", "utf8").match(/MemAvailable:\s+(\d+) kB/);
+      if (g)
+        return `${Math.round(parseInt(g[1]) / 1024 / 1024)}GB available`;
+    } catch {
+    }
+    return "";
+  }
+  if (Y) {
+    try {
+      const I = G("vm_stat"), g = I.match(/page size of (\d+) bytes/), c = I.match(/Pages free:\s+(\d+)\./), i = I.match(/Pages inactive:\s+(\d+)\./);
+      if (g && c && i) {
+        const e = parseInt(g[1]), s = parseInt(c[1]) + parseInt(i[1]);
+        return `${Math.round(s * e / (1024 * 1024 * 1024))}GB available`;
+      }
+    } catch {
+    }
+    return "";
+  }
+  return "";
+}
+function si() {
+  if (p) {
+    try {
+      const I = u.readFileSync("/proc/meminfo", "utf8"), g = I.match(/SwapTotal:\s+(\d+) kB/), c = I.match(/SwapFree:\s+(\d+) kB/);
+      if (g && c) {
+        const i = parseInt(g[1]), e = parseInt(c[1]), s = i - e;
+        if (i > 0) {
+          const t = Math.round(s / i * 100), C = Math.round(s / 1024);
+          return `${t}% (${C}MB) swap`;
+        }
+      }
+    } catch {
+    }
+    return "";
+  }
+  if (Y) {
+    try {
+      const g = G("sysctl -n vm.swapusage").match(
+        /total\s*=\s*([\d.]+)M\s+used\s*=\s*([\d.]+)M\s+free\s*=\s*([\d.]+)M/
+      );
+      if (g) {
+        const c = parseFloat(g[1]), i = parseFloat(g[2]);
+        return c > 0 ? `${Math.round(i / c * 100)}% (${Math.round(i)}MB) swap` : "0% (0MB) swap";
+      }
+    } catch {
+    }
+    return "";
+  }
+  return "";
+}
+function ti(I) {
+  const g = W(I.cache, "disk_used");
+  if (g !== null) return g;
+  if (p || Y)
+    try {
+      const c = G("df -h");
+      let i = "";
+      if (c.includes("/storage/emulated")) {
+        const e = c.match(/\s+(\d+%)\s+\/storage\/emulated/);
+        i = e ? e[1] : "";
+      } else {
+        const e = c.split(`
+`);
+        for (const s of e)
+          if (s.trim().endsWith(" /")) {
+            const t = s.trim().split(/\s+/), C = t.findIndex((n) => n.includes("%"));
+            if (C !== -1) {
+              i = t[C];
+              break;
+            }
+          }
+        if (!i) {
+          const s = c.match(/(\d+%)\s+\/\s*$/m);
+          i = s ? s[1] : "";
+        }
+      }
+      return b(I.cache, "disk_used", i), i;
+    } catch {
+    }
+  return b(I.cache, "disk_used", ""), "";
+}
+const Ci = 10 * 1024 * 1024;
+function ni(I) {
+  const g = W(I.cache, "disk_size");
+  if (g !== null) return g;
+  if (!p && !Y)
+    return b(I.cache, "disk_size", ""), "";
+  try {
+    const i = G("df -k").trim().split(`
+`).slice(1), e = [];
+    for (const t of i) {
+      const C = t.trim().split(/\s+/);
+      if (C.length < 6) continue;
+      const n = C[0], d = parseInt(C[1]), l = parseInt(C[2]), o = C[C.length - 1];
+      if (!(isNaN(d) || isNaN(l) || d < Ci)) {
+        if (Y) {
+          if (o !== "/" && !o.startsWith("/Volumes/")) continue;
+        } else if (n.startsWith("devtmpfs") || n.startsWith("tmpfs") || n === "overlay" || o.startsWith("/boot") || o.startsWith("/dev") || o.startsWith("/proc") || o.startsWith("/sys") || o.startsWith("/run"))
+          continue;
+        e.push({
+          mount: o,
+          usedGB: Math.round(l / (1024 * 1024)),
+          totalGB: Math.round(d / (1024 * 1024))
+        });
+      }
+    }
+    let s = "";
+    return e.length === 1 ? s = `${e[0].usedGB}/${e[0].totalGB}GB` : e.length > 1 && (s = e.map((t) => `${t.mount}(${t.usedGB}/${t.totalGB}GB)`).join(" ")), b(I.cache, "disk_size", s), s;
+  } catch {
+  }
+  return b(I.cache, "disk_size", ""), "";
+}
+function oi(I) {
+  const g = W(I.cache, "mount_points");
+  if (g !== null) return g;
+  if (!p && !Y)
+    return b(I.cache, "mount_points", ""), "";
+  try {
+    const i = G("df -h").split(`
+`).slice(1), e = [];
+    i.forEach((t) => {
+      const C = t.trim().split(/\s+/);
+      if (C.length < 2) return;
+      const n = C[C.length - 1], d = C.find((l) => /^\d+%$/.test(l)) || "";
+      if (d) {
+        if (Y) {
+          n.startsWith("/Volumes/") && n !== "/" && e.push(`${n}(${d})`);
+          return;
+        }
+        !n.startsWith("/dev") && !n.startsWith("/proc") && !n.startsWith("/sys") && !n.startsWith("/System/Volumes") && n !== "/" && e.push(`${n}(${d})`);
+      }
+    });
+    const s = e.slice(0, 3).join(" ");
+    return b(I.cache, "mount_points", s), s;
+  } catch {
+  }
+  return b(I.cache, "mount_points", ""), "";
+}
+function li(I) {
+  const g = W(I.cache, "top_process");
+  if (g !== null) return g;
+  if (p)
+    try {
+      const i = G("ps -eo pcpu,comm --sort=-%cpu --no-headers").split(`
+`);
+      if (i.length > 0) {
+        const e = i[0].trim().replace(/\s+/, " ").split(" "), s = e[0].replace(/\.\d+/, "%"), t = e[1].split("/").pop(), C = `${s}% ${t}`;
+        return b(I.cache, "top_process", C), C;
+      }
+    } catch {
+    }
+  else if (Y)
+    try {
+      const i = G("ps -Aceo pcpu,comm -r").split(`
+`).filter((e) => e.trim());
+      if (i.length > 1) {
+        const e = i[1].trim().split(/\s+/), s = Math.round(parseFloat(e[0])), t = e.slice(1).join(" ");
+        if (!isNaN(s) && t) {
+          const C = `${s}% ${t}`;
+          return b(I.cache, "top_process", C), C;
+        }
+      }
+    } catch {
+    }
+  return b(I.cache, "top_process", ""), "";
+}
+function di() {
+  const I = B.uptime(), g = Math.floor(I / 86400), c = Math.floor(I % 86400 / 3600), i = Math.floor(I % 3600 / 60);
+  return `${g}d ${c}h ${i}m`;
+}
+function ai() {
+  if (!p && !Y) return "";
+  try {
+    const g = G("who").split(`
+`).filter((c) => c.trim()).length;
+    if (g > 0)
+      return `${g} users`;
+  } catch {
+  }
+  return "";
+}
+function bi(I) {
+  return I.ipInfo?.ip || "";
+}
+function Ai() {
+  if (p) {
+    try {
+      const i = G("ifconfig 2>/dev/null").match(
+        /wlan0[\s\S]*?inet (\d+\.\d+\.\d+\.\d+)/
+      );
+      if (i)
+        return i[1];
+    } catch {
+    }
+    try {
+      const c = G("ip addr show 2>/dev/null"), i = [], e = c.matchAll(/inet (\d+\.\d+\.\d+\.\d+)\/\d+/g);
+      for (const s of e)
+        s[1].startsWith("127.") || i.push(s[1]);
+      if (i.length > 0)
+        return i.join(" ");
+    } catch {
+    }
+  }
+  const I = B.networkInterfaces(), g = [];
+  for (const c of Object.keys(I))
+    for (const i of I[c] || [])
+      i.family === "IPv4" && !i.internal && g.push(i.address);
+  return g.join(" ");
+}
+function hi(I) {
+  return I.ipInfo?.city || "";
+}
+function ri(I) {
+  const g = I.ipInfo?.hostname;
+  return g ? `http://${g}` : "";
+}
+function ui(I) {
+  const g = I.ipInfo?.org;
+  return g ? g.split(" ").slice(1).join(" ") : "";
+}
+function mi(I) {
+  const g = W(I.cache, "network_interfaces");
+  if (g !== null) return g;
+  if (!p && !Y)
+    return b(I.cache, "network_interfaces", ""), "";
+  try {
+    const c = B.networkInterfaces(), i = [];
+    for (const [s, t] of Object.entries(c))
+      s !== "lo" && t?.find(
+        (n) => n.family === "IPv4" && !n.internal
+      ) && i.push(s);
+    const e = i.join(" ");
+    return b(I.cache, "network_interfaces", e), e;
+  } catch {
+  }
+  return b(I.cache, "network_interfaces", ""), "";
+}
+function Zi(I) {
+  const g = W(I.cache, "ports");
+  if (g !== null) return g;
+  if (p || Y)
+    try {
+      const i = G("lsof -nP -iTCP -sTCP:LISTEN").split(`
+`).slice(1), e = /* @__PURE__ */ new Set();
+      i.forEach((t) => {
+        const C = t.split(/\s+/);
+        if (C.length >= 9) {
+          const d = C[8].match(/:(\d+)$/);
+          if (d) {
+            const l = d[1], o = C[0].substring(0, 4);
+            e.add(`${l}${o}`);
+          }
+        }
+      });
+      const s = Array.from(e).join(" ");
+      return b(I.cache, "ports", s), s;
+    } catch {
+    }
+  return b(I.cache, "ports", ""), "";
+}
+function Gi(I) {
+  if (Y)
+    return B.loadavg().map((g) => g.toFixed(2)).join(" ");
+  if (!p) return "";
+  try {
+    return u.readFileSync("/proc/loadavg", "utf8").split(" ").slice(0, 3).join(" ");
+  } catch {
+  }
+  return "";
+}
+function Bi(I) {
+  const g = W(I.cache, "battery");
+  if (g !== null) return g;
+  if (Y) {
+    try {
+      const c = G("pmset -g batt"), i = c.match(/(\d+)%/);
+      if (i) {
+        const e = /;\s*(charging|charged);/i.test(c), s = `${i[1]}%${e ? "+" : ""}`;
+        return b(I.cache, "battery", s), s;
+      }
+    } catch {
+    }
+    return b(I.cache, "battery", ""), "";
+  }
+  if (!p)
+    return b(I.cache, "battery", ""), "";
+  try {
+    const c = "/sys/class/power_supply/BAT0", i = `${c}/capacity`, e = `${c}/status`;
+    if (u.existsSync(i)) {
+      const s = u.readFileSync(i, "utf8").trim(), t = u.existsSync(e) ? u.readFileSync(e, "utf8").trim() : "Unknown", d = `${parseInt(s)}%${t === "Charging" ? "+" : ""}`;
+      return b(I.cache, "battery", d), d;
+    }
+  } catch {
+  }
+  return b(I.cache, "battery", ""), "";
+}
+function Wi(I) {
+  const g = W(I.cache, "temperature");
+  if (g !== null) return g;
+  if (Y) {
+    if (k("osx-cpu-temp"))
+      try {
+        const i = G("osx-cpu-temp").match(/([\d.]+)\s*°?C/);
+        if (i) {
+          const e = Math.round(parseFloat(i[1]));
+          if (e > 0 && e < 150) {
+            const s = `${e}°C`;
+            return b(I.cache, "temperature", s), s;
+          }
+        }
+      } catch {
+      }
+    return b(I.cache, "temperature", ""), "";
+  }
+  if (!p)
+    return b(I.cache, "temperature", ""), "";
+  try {
+    const c = [
+      "/sys/class/thermal/thermal_zone0/temp",
+      "/sys/class/hwmon/hwmon0/temp1_input",
+      "/sys/class/hwmon/hwmon1/temp1_input"
+    ];
+    for (const i of c)
+      if (u.existsSync(i)) {
+        const e = u.readFileSync(i, "utf8").trim(), s = Math.round(parseInt(e) / 1e3);
+        if (s > 0 && s < 150) {
+          const t = `${s}°C`;
+          return b(I.cache, "temperature", t), t;
+        }
+      }
+  } catch {
+  }
+  return b(I.cache, "temperature", ""), "";
+}
+function pi(I) {
+  const g = W(I.cache, "services_running");
+  if (g !== null) return g;
+  if (Y) {
+    try {
+      const i = G("launchctl list").split(`
+`).filter((e) => e.trim() && !e.startsWith("PID")).length;
+      if (i > 0) {
+        const e = `${i} services`;
+        return b(I.cache, "services_running", e), e;
+      }
+    } catch {
+    }
+    return b(I.cache, "services_running", ""), "";
+  }
+  if (!p)
+    return b(I.cache, "services_running", ""), "";
+  try {
+    let c = 0;
+    if (k("systemctl") ? c = G(
+      "systemctl list-units --type=service --state=running --no-pager"
+    ).split(`
+`).filter((e) => e.includes(".service")).length : k("service") && (c = G("service --status-all").split(`
+`).filter((e) => e.includes("+")).length), c > 0) {
+      const i = `${c} services`;
+      return b(I.cache, "services_running", i), i;
+    }
+  } catch {
+  }
+  return b(I.cache, "services_running", ""), "";
+}
+function Yi(I) {
+  const g = W(I.cache, "shell");
+  if (g !== null) return g;
+  if (!F) {
+    try {
+      const c = B.userInfo().shell;
+      if (c) {
+        const i = c.split("/").pop();
+        return b(I.cache, "shell", i), i;
+      }
+    } catch {
+    }
+    try {
+      const c = LI.ppid, i = G(`ps -p ${c} -o comm=`).split("/").pop();
+      if (i)
+        return b(I.cache, "shell", i), i;
+    } catch {
+    }
+  }
+  return b(I.cache, "shell", ""), "";
+}
+function yi(I) {
+  const g = W(I.cache, "packages");
+  if (g !== null) return g;
+  const e = [
+    "apt",
+    "brew",
+    "npm",
+    "uv",
+    "docker",
+    "hx",
+    "nvim",
+    "bun",
+    "yay",
+    "pacman",
+    "yum",
+    "dnf",
+    "zypper",
+    "emerge",
+    "apk",
+    "snap",
+    "flatpak"
+  ].filter((s) => k(s)).join(" ");
+  return b(I.cache, "packages", e), e;
+}
+function Ni(I) {
+  const g = W(I.cache, "containers");
+  if (g !== null) return g;
+  if (!k("docker"))
+    return b(I.cache, "containers", ""), "";
+  try {
+    if (G("docker ps -q").split(`
+`).filter((C) => C.trim()).length === 0)
+      return b(I.cache, "containers", ""), "";
+    const e = G(
+      'docker ps --format "{{.Names}}	{{.Ports}}"'
+    ).split(`
+`).filter((C) => C.trim()), s = [];
+    e.forEach((C) => {
+      const [n, d] = C.split("	");
+      if (n && (s.push(n), d)) {
+        const l = d.match(/->(\d+(-\d+)?)\//g);
+        if (l) {
+          const o = [
+            ...new Set(
+              l.map((a) => a.replace(/->\d+(-\d+)?\//, ""))
+            )
+          ];
+          s.push(...o);
+        }
+      }
+    });
+    const t = s.join(" ");
+    return b(I.cache, "containers", t), t;
+  } catch {
+  }
+  return b(I.cache, "containers", ""), "";
+}
+const Vi = B.platform() === "win32", Ki = B.platform() === "darwin", Hi = B.platform() === "linux";
+function Xi() {
+  try {
+    if (u.existsSync(O))
+      return JSON.parse(u.readFileSync(O, "utf8"));
+  } catch {
+  }
+  return {};
+}
+function wi(I) {
+  try {
+    const g = M.dirname(O);
+    u.existsSync(g) || u.mkdirSync(g, { recursive: !0 }), u.writeFileSync(O, JSON.stringify(I, null, 2));
+  } catch {
+  }
+}
+const kI = {
+  user: sg,
+  hostname: tg,
+  ip: bi,
+  iplocal: Ai,
+  city: hi,
+  domain: ri,
+  isp: ui,
+  os: Cg,
+  // Mapped from os_info
+  cpu: VI,
+  gpu: KI,
+  bench: qg,
+  cpu_bench_info: Ii,
+  gpu_bench: gi,
+  gpu_bench_info: ii,
+  disk_used: ti,
+  disk_size: ni,
+  ram_used: ci,
+  top_process: li,
+  uptime: di,
+  device: og,
+  kernel: ng,
+  shell: Yi,
+  pacman: yi,
+  // Mapped from packages
+  ports: Zi,
+  containers: Ni,
+  memory_available: ei,
+  swap_used: si,
+  load_average: Gi,
+  users_logged_in: ai,
+  network_interfaces: mi,
+  mount_points: oi,
+  services_running: pi,
+  temperature: Wi,
+  battery: Bi,
+  screen_resolution: $g
+}, dI = /* @__PURE__ */ new Set(["ip", "city", "domain", "isp"]), fi = () => new Promise((I) => setImmediate(I));
+async function vi(I, g) {
+  const c = I.ipInfo;
+  if (c && MI(c, "ipInfo")) return c.value || {};
+  const i = await eg(void 0, void 0, g), e = i.ip ? i : c?.value || {};
+  return g?.aborted || (I.ipInfo = { value: e, timestamp: Date.now() }), e;
+}
+async function Ui(I = {}) {
+  const { keys: g, signal: c } = I, i = Xi(), e = { cache: i }, s = Object.keys(kI).filter(
+    (l) => !g || g.includes(l)
+  ), t = s.some((l) => dI.has(l)) ? vi(i, c) : void 0, C = {}, n = async (l) => {
+    try {
+      C[l] = await kI[l](e);
+    } catch {
+      C[l] = "";
+    }
+  };
+  for (const l of s)
+    if (!dI.has(l)) {
+      if (await fi(), c?.aborted) break;
+      await n(l);
+    }
+  if (t) {
+    e.ipInfo = await t;
+    for (const l of s)
+      dI.has(l) && await n(l);
+  }
+  const d = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    platform: Vi ? "windows" : Ki ? "macos" : Hi ? "linux" : "unknown"
+  };
+  for (const l of s)
+    l in C && (d[l] = C[l]);
+  return wi(i), d;
+}
+export {
+  O as C,
+  XI as D,
+  x as S,
+  Li as a,
+  Qi as b,
+  ji as c,
+  Mi as d,
+  Ui as g,
+  kI as i,
+  Xi as l,
+  wi as s
+};
+//# sourceMappingURL=system-info-api-7iy1ZV2o.js.map