about-system 0.10.15 → 0.10.17

package/dist/system-info-api-fNqdECMN.js

@@ -0,0 +1,2475 @@
+import u from "os";
+import a from "fs";
+import bg from "http";
+import eg from "https";
+import M from "path";
+import { execSync as uI } from "child_process";
+M.join(u.tmpdir(), "systeminfo-cache.json");
+const Zg = {
+  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
+}, xI = "da2d6cc4baa5d1", SI = 3e3;
+function EI(I, g, i) {
+  return new Promise((C) => {
+    if (i?.aborted) return C(null);
+    let c = !1, l;
+    const s = (t) => {
+      c || (c = !0, clearTimeout(b), i?.removeEventListener("abort", o), C(t));
+    }, o = () => {
+      l?.destroy(), s(null);
+    }, b = setTimeout(o, g);
+    i?.addEventListener("abort", o);
+    try {
+      l = (I.startsWith("https:") ? eg.get : bg.get)(I, (Z) => {
+        let e = "";
+        Z.on("data", (A) => e += A), Z.on("end", () => {
+          try {
+            s(JSON.parse(e));
+          } catch {
+            s(null);
+          }
+        }), Z.on("error", () => s(null));
+      }), l.on("error", () => s(null));
+    } catch {
+      s(null);
+    }
+  });
+}
+async function tg(I = xI, g = SI, i) {
+  const C = await EI(
+    `https://api.ipinfo.io/lite/me?token=${I}`,
+    g,
+    i
+  );
+  if (!C || typeof C != "object") return {};
+  const c = C.org ?? (C.asn && C.as_name ? `${C.asn} ${C.as_name}` : void 0);
+  return {
+    ip: C.ip,
+    city: C.city,
+    hostname: C.hostname,
+    org: c
+  };
+}
+async function Ag(I = SI, g) {
+  const i = await EI(
+    "http://ip-api.com/json/?fields=status,message,query,city,isp,org,as",
+    I,
+    g
+  );
+  return !i || i.status !== "success" ? {} : {
+    ip: i.query,
+    city: i.city,
+    hostname: void 0,
+    org: i.org || i.isp || i.as
+  };
+}
+async function dg(I = xI, g = SI, i) {
+  const [C, c] = await Promise.all([
+    tg(I, g, i),
+    Ag(g, i)
+  ]), l = {};
+  for (const s of [c, C])
+    for (const [o, b] of Object.entries(s))
+      b && (l[o] = b);
+  return l.ip?.includes(":") && c.ip && !c.ip.includes(":") && (l.ip = c.ip), l;
+}
+function PI(I, g) {
+  if (!I || !I.timestamp) return !1;
+  const i = Date.now() - I.timestamp, C = Zg[g] || 6e4;
+  return i < C;
+}
+function K(I, g) {
+  if (!I[g]) return null;
+  const i = I[g];
+  return PI(i, g) ? i.value : (delete I[g], null);
+}
+function d(I, g, i) {
+  I[g] = {
+    value: i,
+    timestamp: Date.now()
+  };
+}
+const _I = {}, O = M.join(
+  u.homedir(),
+  ".config",
+  "systeminfo-settings.json"
+), x = M.join(u.tmpdir(), "systeminfo-cache.json"), EC = {
+  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"
+}, PC = {
+  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"
+}, zI = {
+  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: _I?.stdout?.columns || 100
+  },
+  network: {
+    show_offline_message: !0
+  },
+  advanced: {
+    debug: !1
+  }
+};
+function _C() {
+  try {
+    if (a.existsSync(O)) {
+      const I = JSON.parse(a.readFileSync(O, "utf8"));
+      return { ...zI, ...I };
+    }
+  } catch {
+  }
+  return zI;
+}
+function qC(I) {
+  try {
+    const g = M.dirname(O);
+    return a.existsSync(g) || a.mkdirSync(g, { recursive: !0 }), a.writeFileSync(O, JSON.stringify(I, null, 2)), !0;
+  } catch {
+    return !1;
+  }
+}
+const J = u.platform() === "win32", V = u.platform() === "darwin", p = u.platform() === "linux";
+function B(I, g = {}) {
+  try {
+    const i = J ? `cmd /c ${I}` : I;
+    return uI(i, {
+      encoding: "utf8",
+      timeout: 1e4,
+      stdio: ["pipe", "pipe", "ignore"],
+      ...g
+    }).toString().trim();
+  } catch {
+    return "";
+  }
+}
+function j(I) {
+  try {
+    return J ? uI(`where ${I}`, { stdio: "ignore" }) : uI(`which ${I}`, { stdio: "ignore" }), !0;
+  } catch {
+    return !1;
+  }
+}
+function mg() {
+  return u.userInfo().username;
+}
+function ng() {
+  return u.hostname();
+}
+function Gg(I) {
+  const g = K(I.cache, "os");
+  if (g) return g;
+  const i = u.platform(), C = u.release();
+  let c = "";
+  if (J)
+    try {
+      const s = B("ver").match(/Microsoft Windows \[Version ([^\]]+)\]/);
+      c = s ? `Windows ${s[1]}` : `Windows ${C}`;
+    } catch {
+      c = `Windows ${C}`;
+    }
+  else if (V) {
+    const l = B("sw_vers -productName"), s = B("sw_vers -productVersion");
+    c = l && s ? `${l} ${s}` : `macOS ${C}`;
+  } else if (p)
+    try {
+      const l = a.readFileSync("/etc/os-release", "utf8"), s = l.match(/^NAME="([^"]+)"/m), o = l.match(/^VERSION_ID="([^"]+)"/m);
+      c = s ? s[1] : "Linux", o && (c += ` ${o[1]}`);
+    } catch {
+      c = `Linux ${C}`;
+    }
+  else
+    c = `${i} ${C}`;
+  return d(I.cache, "os", c), c;
+}
+function ag(I) {
+  const g = K(I.cache, "kernel");
+  if (g) return g;
+  const i = u.release();
+  return d(I.cache, "kernel", i), i;
+}
+function hg(I) {
+  const g = K(I.cache, "device");
+  if (g !== null) return g;
+  if (J) {
+    try {
+      const C = B("wmic csproduct get name /format:list").match(/Name=(.+)/);
+      if (C) {
+        const c = C[1].trim();
+        if (c && c !== "")
+          return d(I.cache, "device", c), c;
+      }
+    } catch {
+    }
+    try {
+      const i = B(
+        'powershell.exe -Command "Get-WmiObject -Class Win32_ComputerSystem | Select-Object -ExpandProperty Model"'
+      );
+      if (i.trim()) {
+        const C = i.trim();
+        return d(I.cache, "device", C), C;
+      }
+    } catch {
+    }
+  } else if (V) {
+    const C = B("system_profiler SPHardwareDataType").match(/Model Name:\s*(.+)/);
+    if (C) {
+      const c = C[1].trim();
+      return d(I.cache, "device", c), c;
+    }
+  } else if (p)
+    try {
+      if (j("getprop")) {
+        const C = B("getprop ro.product.model");
+        if (C)
+          return d(I.cache, "device", C), C;
+      }
+      const i = "/sys/devices/virtual/dmi/id/product_name";
+      if (a.existsSync(i)) {
+        const C = a.readFileSync(i, "utf8").trim();
+        if (C)
+          return d(I.cache, "device", C), C;
+      }
+    } catch {
+    }
+  return d(I.cache, "device", ""), "";
+}
+const _ = "data:video/mp2t;base64,/**
 * @fileoverview The four Geekbench lookups share a table format
 * (`[name, score, rank][]`) and a fuzzy matcher, so they're driven here with a
 * small fixture rather than the multi-megabyte real tables.
 */
import { beforeEach, describe, expect, it, vi } from "vitest";

vi.mock("../utils/platform", () => ({ IS_LINUX: true, IS_MAC: false, IS_WINDOWS: false }));

const execCommand = vi.hoisted(() => vi.fn());
vi.mock("../utils/command", () => ({ execCommand, commandExists: vi.fn() }));

const files = vi.hoisted(() => ({
  existing: new Set<string>(),
  data: {} as Record<string, string>,
}));
const fsMock = vi.hoisted(() => ({
  existsSync: vi.fn((p: string) => files.existing.has(p)),
  readFileSync: vi.fn((p: string) => {
    if (!(p in files.data)) throw new Error("ENOENT");
    return files.data[p];
  }),
  writeFileSync: vi.fn(),
}));
vi.mock("fs", () => ({ ...fsMock, default: fsMock }));

vi.mock("os", () => {
  const api = { tmpdir: () => "/tmp", cpus: () => [], platform: () => "linux" };
  return { ...api, default: api };
});

const h = await import("./hardware");
import type { InfoContext } from "../types/internal-types";

const CPU_TABLE = {
  scores: [
    ["AMD Ryzen 9 7950X", 3000, 1],
    ["Intel Core i9-13900K", 2900, 2],
    ["Apple M2 Pro", 2700, 3],
    ["Qualcomm Snapdragon X Elite", 2500, 4],
    ["AMD EPYC 7763", 2400, 5],
    ["Mystery Chip 9000", 1000, 6],
  ],
};
const GPU_TABLE = {
  scores: [
    ["NVIDIA GeForce RTX 4090", 300000, 1],
    ["AMD Radeon RX 7900 XTX", 200000, 2],
    ["Intel Arc A770", 100000, 3],
    ["Obscure Accelerator", 50000, 4],
  ],
};

const ctx = (cache: InfoContext["cache"] = {}): InfoContext => ({ cache });

/** Make `cpu()`/`gpu()` resolve to a name via the (mocked) shell tools. */
const resolveCpu = (name: string) =>
  execCommand.mockImplementation((c: string) => (c === "lscpu" ? `Model name: ${name}` : ""));
const resolveGpu = (name: string) =>
  execCommand.mockImplementation((c: string) =>
    c === "lspci" ? `01:00.0 VGA compatible controller: NVIDIA [${name}]` : "",
  );

beforeEach(() => {
  files.existing = new Set(["cpu-geekbench.json", "gpu-geekbench.json"]);
  files.data = {
    "cpu-geekbench.json": JSON.stringify(CPU_TABLE),
    "gpu-geekbench.json": JSON.stringify(GPU_TABLE),
  };
  execCommand.mockReset().mockReturnValue("");
});

describe("bench (CPU)", () => {
  it("formats score, rank and percentile for the fuzzy-matched CPU", () => {
    resolveCpu("AMD Ryzen 9 7950X");
    expect(h.bench(ctx())).toBe("3k #1 Top 1%");
  });

  it("is empty with no CPU name or no fuzzy match", () => {
    expect(h.bench(ctx())).toBe("");
    resolveCpu("zzzzzzzzzzzz qqqqqqqq");
    expect(h.bench(ctx())).toBe("");
  });

  it("is empty when the benchmark file is unreadable or malformed", () => {
    resolveCpu("AMD Ryzen 9 7950X");
    files.data["cpu-geekbench.json"] = "{not json";
    expect(h.bench(ctx())).toBe("");
  });

  it("finds the table under src/bench or ./bench when not in the cwd", () => {
    resolveCpu("AMD Ryzen 9 7950X");
    files.existing = new Set(["src/bench/cpu-geekbench.json"]);
    files.data = { "src/bench/cpu-geekbench.json": JSON.stringify(CPU_TABLE) };
    expect(h.bench(ctx())).toBe("3k #1 Top 1%");

    files.existing = new Set(["./bench/cpu-geekbench.json"]);
    files.data = { "./bench/cpu-geekbench.json": JSON.stringify(CPU_TABLE) };
    expect(h.bench(ctx())).toBe("3k #1 Top 1%");
  });

  it("falls back to the module-relative path when no known location exists", () => {
    resolveCpu("AMD Ryzen 9 7950X");
    files.existing = new Set();
    files.data = {};
    // Nothing readable anywhere → swallowed, cached as empty.
    expect(h.bench(ctx())).toBe("");
  });

  it("serves from the cache", () => {
    const c = ctx({ bench: { value: "cached", timestamp: Date.now() } });
    expect(h.bench(c)).toBe("cached");
  });
});

describe("cpu_bench_info", () => {
  it.each([
    ["AMD Ryzen 9 7950X", "Geekbench 6: 3k (Rank #1, Top 1%) - AMD"],
    ["Intel Core i9-13900K", "Geekbench 6: 3k (Rank #2, Top 17%) - Intel"],
    ["Apple M2 Pro", "Geekbench 6: 3k (Rank #3, Top 34%) - ARM"],
    ["Qualcomm Snapdragon X Elite", "Geekbench 6: 3k (Rank #4, Top 50%) - ARM"],
    ["AMD EPYC 7763", "Geekbench 6: 2k (Rank #5, Top 67%) - AMD"],
    ["Mystery Chip 9000", "Geekbench 6: 1k (Rank #6, Top 84%) - Unknown"],
  ])("labels %s with its architecture", (name, expected) => {
    resolveCpu(name);
    expect(h.cpu_bench_info(ctx())).toBe(expected);
  });

  it("is empty with no CPU, no match, or a bad table; and serves cache", () => {
    expect(h.cpu_bench_info(ctx())).toBe("");
    resolveCpu("zzzzzzzzzzzz qqqqqqqq");
    expect(h.cpu_bench_info(ctx())).toBe("");
    resolveCpu("AMD Ryzen 9 7950X");
    files.data["cpu-geekbench.json"] = "oops";
    expect(h.cpu_bench_info(ctx())).toBe("");
    expect(
      h.cpu_bench_info(ctx({ cpu_bench_info: { value: "cached", timestamp: Date.now() } })),
    ).toBe("cached");
  });

  it("locates the table at the alternate paths", () => {
    resolveCpu("AMD Ryzen 9 7950X");
    files.existing = new Set(["src/bench/cpu-geekbench.json"]);
    files.data = { "src/bench/cpu-geekbench.json": JSON.stringify(CPU_TABLE) };
    expect(h.cpu_bench_info(ctx())).toContain("AMD");
    files.existing = new Set(["./bench/cpu-geekbench.json"]);
    files.data = { "./bench/cpu-geekbench.json": JSON.stringify(CPU_TABLE) };
    expect(h.cpu_bench_info(ctx())).toContain("AMD");
    files.existing = new Set();
    files.data = {};
    expect(h.cpu_bench_info(ctx())).toBe("");
  });
});

describe("gpu_bench", () => {
  it("formats the fuzzy-matched GPU", () => {
    resolveGpu("GeForce RTX 4090");
    expect(h.gpu_bench(ctx())).toBe("300k #1 Top 1%");
  });

  it("is empty with no GPU, no match, or a bad table; serves cache", () => {
    expect(h.gpu_bench(ctx())).toBe("");
    resolveGpu("zzzzzzzzzzzz qqqqqqqq");
    expect(h.gpu_bench(ctx())).toBe("");
    resolveGpu("GeForce RTX 4090");
    files.data["gpu-geekbench.json"] = "oops";
    expect(h.gpu_bench(ctx())).toBe("");
    expect(h.gpu_bench(ctx({ gpu_bench: { value: "c", timestamp: Date.now() } }))).toBe("c");
  });

  it("locates the table at the alternate paths", () => {
    resolveGpu("GeForce RTX 4090");
    files.existing = new Set(["src/bench/gpu-geekbench.json"]);
    files.data = { "src/bench/gpu-geekbench.json": JSON.stringify(GPU_TABLE) };
    expect(h.gpu_bench(ctx())).toBe("300k #1 Top 1%");
    files.existing = new Set(["./bench/gpu-geekbench.json"]);
    files.data = { "./bench/gpu-geekbench.json": JSON.stringify(GPU_TABLE) };
    expect(h.gpu_bench(ctx())).toBe("300k #1 Top 1%");
    files.existing = new Set();
    files.data = {};
    expect(h.gpu_bench(ctx())).toBe("");
  });
});

describe("gpu_bench_info", () => {
  it.each([
    ["GeForce RTX 4090", "Geekbench 6: 300k (Rank #1, Top 1%) - NVIDIA"],
    ["Radeon RX 7900 XTX", "Geekbench 6: 200k (Rank #2, Top 25%) - AMD"],
    ["Intel Arc A770", "Geekbench 6: 100k (Rank #3, Top 50%) - Intel"],
    ["Obscure Accelerator", "Geekbench 6: 50k (Rank #4, Top 75%) - Unknown"],
  ])("labels %s with its vendor", (name, expected) => {
    resolveGpu(name);
    expect(h.gpu_bench_info(ctx())).toBe(expected);
  });

  it("is empty with no GPU, no match, or a bad table; serves cache", () => {
    expect(h.gpu_bench_info(ctx())).toBe("");
    resolveGpu("zzzzzzzzzzzz qqqqqqqq");
    expect(h.gpu_bench_info(ctx())).toBe("");
    resolveGpu("GeForce RTX 4090");
    files.data["gpu-geekbench.json"] = "oops";
    expect(h.gpu_bench_info(ctx())).toBe("");
    expect(
      h.gpu_bench_info(ctx({ gpu_bench_info: { value: "c", timestamp: Date.now() } })),
    ).toBe("c");
  });

  it("locates the table at the alternate paths", () => {
    resolveGpu("GeForce RTX 4090");
    files.existing = new Set(["src/bench/gpu-geekbench.json"]);
    files.data = { "src/bench/gpu-geekbench.json": JSON.stringify(GPU_TABLE) };
    expect(h.gpu_bench_info(ctx())).toContain("NVIDIA");
    files.existing = new Set(["./bench/gpu-geekbench.json"]);
    files.data = { "./bench/gpu-geekbench.json": JSON.stringify(GPU_TABLE) };
    expect(h.gpu_bench_info(ctx())).toContain("NVIDIA");
    files.existing = new Set();
    files.data = {};
    expect(h.gpu_bench_info(ctx())).toBe("");
  });
});
", q = "data:video/mp2t;base64,import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";

const flags = vi.hoisted(() => ({ linux: true, mac: false, windows: false }));
vi.mock("../utils/platform", () => ({
  get IS_LINUX() {
    return flags.linux;
  },
  get IS_MAC() {
    return flags.mac;
  },
  get IS_WINDOWS() {
    return flags.windows;
  },
}));

const execCommand = vi.hoisted(() => vi.fn());
vi.mock("../utils/command", () => ({ execCommand, commandExists: vi.fn() }));

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

const osMock = vi.hoisted(() => ({
  cpus: vi.fn(() => [] as { model: string }[]),
  tmpdir: vi.fn(() => "/tmp"),
  platform: vi.fn(() => "linux"),
}));
vi.mock("os", () => ({ ...osMock, default: osMock }));

const h = await import("./hardware");
import type { InfoContext } from "../types/internal-types";

const ctx = (): InfoContext => ({ cache: {} });
const platform = (k: "linux" | "mac" | "windows" | "other") => {
  flags.linux = k === "linux";
  flags.mac = k === "mac";
  flags.windows = k === "windows";
};

beforeEach(() => {
  platform("linux");
  execCommand.mockReset().mockReturnValue("");
  fsMock.readFileSync.mockReset().mockReturnValue("");
  osMock.cpus.mockReset().mockReturnValue([]);
});

afterEach(() => {
  delete process.env.DISPLAY;
});

describe("cpu", () => {
  it("reads the model from lscpu on Linux and trims `with ...` suffixes", () => {
    execCommand.mockReturnValue("Architecture: x86_64\nModel name:  AMD Ryzen 7 5800X with Radeon\nFlags: a");
    expect(h.cpu(ctx())).toBe("AMD Ryzen 7 5800X");
  });

  it("stops the lscpu model at a comma", () => {
    execCommand.mockReturnValue("Model name: Intel(R) Core(TM) i7, 8 cores");
    expect(h.cpu(ctx())).toBe("Intel(R) Core(TM) i7");
  });

  it("falls back to /proc/cpuinfo model name, then Hardware", () => {
    fsMock.readFileSync.mockReturnValue("processor : 0\nmodel name : Fancy CPU\n");
    expect(h.cpu(ctx())).toBe("Fancy CPU");
    fsMock.readFileSync.mockReturnValue("Hardware : BCM2711\n");
    expect(h.cpu(ctx())).toBe("BCM2711");
  });

  it("is empty when Linux offers no CPU name", () => {
    fsMock.readFileSync.mockImplementation(() => {
      throw new Error("x");
    });
    expect(h.cpu(ctx())).toBe("");
    fsMock.readFileSync.mockReturnValue("nothing useful");
    expect(h.cpu(ctx())).toBe("");
  });

  it("uses wmic on Windows, then PowerShell", () => {
    platform("windows");
    execCommand.mockReturnValue("Name=Intel(R) Core(TM) i9-9900K CPU @ 3.60GHz\r\n");
    expect(h.cpu(ctx())).toBe("Intel(R) Core(TM) i9-9900K CPU @ 3.60GHz");
    execCommand.mockImplementation((c: string) => (c.startsWith("wmic") ? "" : "Ryzen 5 3600\r\n"));
    expect(h.cpu(ctx())).toBe("Ryzen 5 3600");
    execCommand.mockReturnValue("");
    expect(h.cpu(ctx())).toBe("");
  });

  it("uses os.cpus elsewhere (macOS)", () => {
    platform("mac");
    osMock.cpus.mockReturnValue([{ model: "Apple M2\r\nPro " }]);
    expect(h.cpu(ctx())).toBe("Apple M2 Pro");
    osMock.cpus.mockReturnValue([]);
    expect(h.cpu(ctx())).toBe("");
  });

  it("serves from the cache", () => {
    const c = ctx();
    execCommand.mockReturnValue("Model name: Cached CPU");
    h.cpu(c);
    execCommand.mockReturnValue("Model name: Other");
    expect(h.cpu(c)).toBe("Cached CPU");
  });
});

describe("gpu", () => {
  it("lists display-class lspci devices using the bracketed marketing name", () => {
    execCommand.mockReturnValue(
      [
        "00:02.0 VGA compatible controller: Intel Corporation UHD Graphics 630 [UHD Graphics 630]",
        "01:00.0 VGA compatible controller: NVIDIA Corporation GA104 [GeForce RTX 3070] (rev a1)",
        "01:00.1 Audio device: NVIDIA Corporation GA104 High Definition Audio",
        "02:00.0 Ethernet controller: Realtek",
        "03:00.0 3D controller: NVIDIA Corporation GA104 [GeForce RTX 3070]",
      ].join("\n"),
    );
    expect(h.gpu(ctx())).toBe("UHD Graphics 630, GeForce RTX 3070");
  });

  it("strips the class prefix and revision when there are no brackets", () => {
    execCommand.mockReturnValue("00:02.0 VGA compatible controller: Intel Corporation HD Graphics (rev 09)");
    expect(h.gpu(ctx())).toBe("Intel Corporation HD Graphics");
  });

  it("is empty when no GPU is found, or lspci fails", () => {
    execCommand.mockReturnValue("00:1f.0 ISA bridge: Intel");
    expect(h.gpu(ctx())).toBe("");
    execCommand.mockImplementation(() => {
      throw new Error("x");
    });
    expect(h.gpu(ctx())).toBe("");
  });

  it("lists wmic adapters on Windows, ignoring Microsoft Basic", () => {
    platform("windows");
    execCommand.mockReturnValue("Name=NVIDIA GeForce RTX 4090\r\nName=Microsoft Basic Display Adapter\r\nName=Intel UHD\r\n");
    expect(h.gpu(ctx())).toBe("NVIDIA GeForce RTX 4090, Intel UHD");
  });

  it("falls back to PowerShell on Windows", () => {
    platform("windows");
    execCommand.mockImplementation((c: string) =>
      c.startsWith("wmic") ? "" : "AMD Radeon RX 7900\r\nMicrosoft Basic Render\r\n\r\n",
    );
    expect(h.gpu(ctx())).toBe("AMD Radeon RX 7900");
    execCommand.mockReturnValue("");
    expect(h.gpu(ctx())).toBe("");
  });

  it("lists chipset models on macOS", () => {
    platform("mac");
    execCommand.mockReturnValue("Graphics:\n  Chipset Model: Apple M2 Pro\n  Chipset Model: AMD Radeon Pro");
    expect(h.gpu(ctx())).toBe("Apple M2 Pro, AMD Radeon Pro");
    execCommand.mockReturnValue("none");
    expect(h.gpu(ctx())).toBe("");
    execCommand.mockImplementation(() => {
      throw new Error("x");
    });
    expect(h.gpu(ctx())).toBe("");
  });

  it("is empty on unknown platforms and serves from the cache", () => {
    platform("other");
    const c = ctx();
    expect(h.gpu(c)).toBe("");
    platform("linux");
    execCommand.mockReturnValue("00:02.0 VGA compatible controller: Intel UHD Graphics [UHD]");
    expect(h.gpu(c)).toBe("");
  });
});

describe("screen_resolution", () => {
  it("parses the xrandr geometry on Linux when DISPLAY is set", () => {
    process.env.DISPLAY = ":0";
    execCommand.mockReturnValue("Screen 0: minimum 8 x 8\nHDMI-1 connected primary 2560x1440+0+0");
    expect(h.screen_resolution()).toBe("2560x1440");
  });

  it("is empty without DISPLAY, without a match, or when xrandr throws", () => {
    expect(h.screen_resolution()).toBe("");
    process.env.DISPLAY = ":0";
    execCommand.mockReturnValue("nothing");
    expect(h.screen_resolution()).toBe("");
    execCommand.mockImplementation(() => {
      throw new Error("x");
    });
    expect(h.screen_resolution()).toBe("");
  });

  it("parses the system_profiler resolution on macOS", () => {
    platform("mac");
    execCommand.mockReturnValue("Resolution: 3024 x 1964 Retina");
    expect(h.screen_resolution()).toBe("3024x1964");
    execCommand.mockReturnValue("nope");
    expect(h.screen_resolution()).toBe("");
    execCommand.mockImplementation(() => {
      throw new Error("x");
    });
    expect(h.screen_resolution()).toBe("");
  });

  it("is empty on other platforms", () => {
    platform("windows");
    expect(h.screen_resolution()).toBe("");
  });
});
", $ = "data:video/mp2t;base64,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", II = "data:video/mp2t;base64,/**
 * @fileoverview Memory and disk probes. Every function branches on the host
 * platform, so `utils/platform` is mocked with live getters and each test
 * picks the OS it wants to impersonate.
 */
import { beforeEach, describe, expect, it, vi } from "vitest";

const flags = vi.hoisted(() => ({ linux: true, mac: false, windows: false }));
vi.mock("../utils/platform", () => ({
  get IS_LINUX() {
    return flags.linux;
  },
  get IS_MAC() {
    return flags.mac;
  },
  get IS_WINDOWS() {
    return flags.windows;
  },
}));

const execCommand = vi.hoisted(() => vi.fn());
vi.mock("../utils/command", () => ({ execCommand, commandExists: vi.fn() }));

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

const osMock = vi.hoisted(() => ({
  totalmem: vi.fn(() => 16 * 1024 ** 3),
  freemem: vi.fn(() => 4 * 1024 ** 3),
  tmpdir: vi.fn(() => "/tmp"),
  platform: vi.fn(() => "linux"),
}));
vi.mock("os", () => ({ ...osMock, default: osMock }));

const m = await import("./memory");
import type { InfoContext } from "../types/internal-types";

const ctx = (cache: InfoContext["cache"] = {}): InfoContext => ({ cache });
const platform = (p: "linux" | "mac" | "windows") => {
  flags.linux = p === "linux";
  flags.mac = p === "mac";
  flags.windows = p === "windows";
};

const MEMINFO = [
  "MemTotal:       16777216 kB",
  "MemFree:         4194304 kB",
  "MemAvailable:    8388608 kB",
  "SwapTotal:       2097152 kB",
  "SwapFree:        1572864 kB",
].join("\n");

beforeEach(() => {
  platform("linux");
  execCommand.mockReset().mockReturnValue("");
  fsMock.readFileSync.mockReset().mockReturnValue(MEMINFO);
  osMock.totalmem.mockReturnValue(16 * 1024 ** 3);
  osMock.freemem.mockReturnValue(4 * 1024 ** 3);
});

describe("ram_used", () => {
  it("reads /proc/meminfo on Linux", () => {
    expect(m.ram_used(ctx())).toBe("12/16GB");
  });

  it("falls back to os.totalmem when /proc/meminfo is unreadable", () => {
    fsMock.readFileSync.mockImplementation(() => {
      throw new Error("nope");
    });
    expect(m.ram_used(ctx())).toBe("12/16GB");
  });

  it("falls back to os.totalmem when meminfo lacks the keys", () => {
    fsMock.readFileSync.mockReturnValue("garbage");
    expect(m.ram_used(ctx())).toBe("12/16GB");
  });

  it("uses os memory on non-Linux hosts", () => {
    platform("mac");
    osMock.totalmem.mockReturnValue(8 * 1024 ** 3);
    osMock.freemem.mockReturnValue(2 * 1024 ** 3);
    expect(m.ram_used(ctx())).toBe("6/8GB");
    expect(fsMock.readFileSync).not.toHaveBeenCalled();
  });

  it("serves a cached value and stores a fresh one", () => {
    const cache = {};
    expect(m.ram_used(ctx(cache))).toBe("12/16GB");
    fsMock.readFileSync.mockReturnValue("MemTotal: 1 kB\nMemFree: 1 kB");
    expect(m.ram_used(ctx(cache))).toBe("12/16GB");
  });
});

describe("memory_available", () => {
  it("reads MemAvailable on Linux", () => {
    expect(m.memory_available()).toBe("8GB available");
  });

  it("returns empty when MemAvailable is missing or unreadable on Linux", () => {
    fsMock.readFileSync.mockReturnValue("MemTotal: 1 kB");
    expect(m.memory_available()).toBe("");
    fsMock.readFileSync.mockImplementation(() => {
      throw new Error("x");
    });
    expect(m.memory_available()).toBe("");
  });

  it("derives free+inactive pages from vm_stat on macOS", () => {
    platform("mac");
    execCommand.mockReturnValue(
      [
        "Mach Virtual Memory Statistics: (page size of 16384 bytes)",
        "Pages free:                               262144.",
        "Pages inactive:                           262144.",
      ].join("\n"),
    );
    // (262144 + 262144) * 16384 bytes = 8 GiB
    expect(m.memory_available()).toBe("8GB available");
    expect(execCommand).toHaveBeenCalledWith("vm_stat");
  });

  it("returns empty on macOS when vm_stat output is unparseable", () => {
    platform("mac");
    execCommand.mockReturnValue("nonsense");
    expect(m.memory_available()).toBe("");
    execCommand.mockImplementation(() => {
      throw new Error("x");
    });
    expect(m.memory_available()).toBe("");
  });

  it("returns empty on Windows", () => {
    platform("windows");
    expect(m.memory_available()).toBe("");
  });
});

describe("swap_used", () => {
  it("computes percent and MB on Linux", () => {
    // 2 GiB total, 0.5 GiB used
    expect(m.swap_used()).toBe("25% (512MB) swap");
  });

  it("returns empty when there is no swap or meminfo is bad", () => {
    fsMock.readFileSync.mockReturnValue("SwapTotal: 0 kB\nSwapFree: 0 kB");
    expect(m.swap_used()).toBe("");
    fsMock.readFileSync.mockReturnValue("nothing");
    expect(m.swap_used()).toBe("");
    fsMock.readFileSync.mockImplementation(() => {
      throw new Error("x");
    });
    expect(m.swap_used()).toBe("");
  });

  it("parses sysctl vm.swapusage on macOS", () => {
    platform("mac");
    execCommand.mockReturnValue("total = 2048.00M  used = 512.00M  free = 1536.00M  (encrypted)");
    expect(m.swap_used()).toBe("25% (512MB) swap");
  });

  it("reports zero swap on macOS when total is 0", () => {
    platform("mac");
    execCommand.mockReturnValue("total = 0.00M  used = 0.00M  free = 0.00M");
    expect(m.swap_used()).toBe("0% (0MB) swap");
  });

  it("returns empty on macOS with unparseable output, and on Windows", () => {
    platform("mac");
    execCommand.mockReturnValue("?");
    expect(m.swap_used()).toBe("");
    platform("windows");
    expect(m.swap_used()).toBe("");
  });
});

const DF_H = [
  "Filesystem      Size  Used Avail Use% Mounted on",
  "/dev/sda1       100G   45G   50G  47% /",
  "tmpfs           1.0G     0  1.0G   0% /dev/shm",
  "/dev/sdb1       500G  390G   80G  78% /mnt/data",
].join("\n");

describe("disk_used", () => {
  it("finds the root filesystem percentage", () => {
    execCommand.mockReturnValue(DF_H);
    expect(m.disk_used(ctx())).toBe("47%");
  });

  it("falls back to a regex when no line ends in ' /' with a % column", () => {
    execCommand.mockReturnValue("Filesystem Use% Mounted\nrootfs 33% /");
    expect(m.disk_used(ctx())).toBe("33%");
  });

  it("returns empty when nothing matches", () => {
    execCommand.mockReturnValue("Filesystem Size\nnone");
    expect(m.disk_used(ctx())).toBe("");
  });

  it("reads the emulated storage line on Android", () => {
    execCommand.mockReturnValue("/dev/fuse 100G 40G 60G 40% /storage/emulated");
    expect(m.disk_used(ctx())).toBe("40%");
    execCommand.mockReturnValue("/storage/emulated only");
    expect(m.disk_used(ctx())).toBe("");
  });

  it("is empty on Windows, and caches the result", () => {
    platform("windows");
    const cache = {};
    expect(m.disk_used(ctx(cache))).toBe("");
    platform("linux");
    execCommand.mockReturnValue(DF_H);
    expect(m.disk_used(ctx(cache))).toBe("");
  });

  it("returns empty when df throws inside the probe", () => {
    execCommand.mockImplementation(() => {
      throw new Error("x");
    });
    expect(m.disk_used(ctx())).toBe("");
  });
});

const GB = 1024 * 1024;
const dfK = (rows: string[]) =>
  ["Filesystem 1K-blocks Used Available Use% Mounted on", ...rows].join("\n");

describe("disk_size", () => {
  it("reports a single real disk without its mount point", () => {
    execCommand.mockReturnValue(
      dfK([
        `/dev/sda1 ${100 * GB} ${45 * GB} ${50 * GB} 47% /`,
        `tmpfs ${100 * GB} 0 ${100 * GB} 0% /run`,
        `/dev/sda2 ${100 * GB} ${1 * GB} ${99 * GB} 1% /boot`,
        `/dev/small 1000 10 990 1% /small`,
        "short row",
        `/dev/bad abc def 1 1% /bad`,
      ]),
    );
    expect(m.disk_size(ctx())).toBe("45/100GB");
  });

  it("labels each disk by mount point when several are found", () => {
    execCommand.mockReturnValue(
      dfK([
        `/dev/sda1 ${100 * GB} ${45 * GB} ${50 * GB} 47% /`,
        `/dev/sdb1 ${500 * GB} ${390 * GB} ${80 * GB} 78% /mnt/data`,
        `devtmpfs ${50 * GB} 0 ${50 * GB} 0% /dev`,
        `overlay ${50 * GB} 0 ${50 * GB} 0% /var/lib/docker`,
        `proc ${50 * GB} 0 ${50 * GB} 0% /proc`,
        `sysfs ${50 * GB} 0 ${50 * GB} 0% /sys`,
      ]),
    );
    expect(m.disk_size(ctx())).toBe("/(45/100GB) /mnt/data(390/500GB)");
  });

  it("returns empty when no disk qualifies", () => {
    execCommand.mockReturnValue(dfK([`tmpfs ${100 * GB} 0 ${100 * GB} 0% /run`]));
    expect(m.disk_size(ctx())).toBe("");
  });

  it("only counts / and /Volumes/* on macOS", () => {
    platform("mac");
    execCommand.mockReturnValue(
      dfK([
        `/dev/disk3s1 ${500 * GB} ${200 * GB} ${300 * GB} 40% /`,
        `/dev/disk3s5 ${500 * GB} ${200 * GB} ${300 * GB} 40% /System/Volumes/Data`,
        `/dev/disk4s1 ${1000 * GB} ${900 * GB} ${100 * GB} 90% /Volumes/Backup`,
      ]),
    );
    expect(m.disk_size(ctx())).toBe("/(200/500GB) /Volumes/Backup(900/1000GB)");
  });

  it("is empty on Windows and when df throws", () => {
    platform("windows");
    expect(m.disk_size(ctx())).toBe("");
    platform("linux");
    execCommand.mockImplementation(() => {
      throw new Error("x");
    });
    expect(m.disk_size(ctx())).toBe("");
  });

  it("serves the cached value", () => {
    const cache = {};
    execCommand.mockReturnValue(dfK([`/dev/sda1 ${100 * GB} ${45 * GB} 1 47% /`]));
    expect(m.disk_size(ctx(cache))).toBe("45/100GB");
    execCommand.mockReturnValue("");
    expect(m.disk_size(ctx(cache))).toBe("45/100GB");
  });
});

describe("mount_points", () => {
  it("lists non-system mounts with usage on Linux (max 3)", () => {
    execCommand.mockReturnValue(
      [
        "Filesystem Size Used Avail Use% Mounted on",
        "/dev/sda1 100G 45G 50G 47% /",
        "tmpfs 1G 0 1G 0% /dev/shm",
        "/dev/sdb1 500G 390G 80G 78% /mnt/data",
        "/dev/sdc1 500G 100G 80G 20% /home",
        "/dev/sdd1 500G 100G 80G 21% /srv",
        "/dev/sde1 500G 100G 80G 22% /opt",
        "weird 1G",
        "nopercent mount",
        "/dev/x 1G 1G 0 1% /System/Volumes/Data",
      ].join("\n"),
    );
    expect(m.mount_points(ctx())).toBe("/mnt/data(78%) /home(20%) /srv(21%)");
  });

  it("reports only /Volumes mounts on macOS", () => {
    platform("mac");
    execCommand.mockReturnValue(
      [
        "Filesystem Size Used Avail Capacity Mounted on",
        "/dev/disk3s1 500G 200G 300G 40% /",
        "/dev/disk4s1 1T 900G 100G 90% /Volumes/Backup",
        "/dev/disk3s5 500G 200G 300G 40% /System/Volumes/Data",
      ].join("\n"),
    );
    expect(m.mount_points(ctx())).toBe("/Volumes/Backup(90%)");
  });

  it("is empty on Windows and when df throws", () => {
    platform("windows");
    expect(m.mount_points(ctx())).toBe("");
    platform("linux");
    execCommand.mockImplementation(() => {
      throw new Error("x");
    });
    expect(m.mount_points(ctx())).toBe("");
  });

  it("serves the cached value", () => {
    const cache = {};
    execCommand.mockReturnValue(
      "h\n/dev/a 1G 1G 0 5% /mnt/a",
    );
    expect(m.mount_points(ctx(cache))).toBe("/mnt/a(5%)");
    execCommand.mockReturnValue("");
    expect(m.mount_points(ctx(cache))).toBe("/mnt/a(5%)");
  });
});
", gI = "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 "";
}
", CI = "data:video/mp2t;base64,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", iI = "data:video/mp2t;base64,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", cI = "data:video/mp2t;base64,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", lI = "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("");
  });
});
", sI = "data:video/mp2t;base64,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", oI = "data:video/mp2t;base64,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", bI = "data:video/mp2t;base64,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", eI = "data:video/mp2t;base64,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", ZI = "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;
  }
}
", tI = "data:video/mp2t;base64,aW1wb3J0IHsgYmVmb3JlRWFjaCwgZGVzY3JpYmUsIGV4cGVjdCwgaXQsIHZpIH0gZnJvbSAidml0ZXN0IjsKCmNvbnN0IGZsYWdzID0gdmkuaG9pc3RlZCgoKSA9PiAoeyB3aW5kb3dzOiBmYWxzZSB9KSk7CnZpLm1vY2soIi4uL3V0aWxzL3BsYXRmb3JtIiwgKCkgPT4gKHsKICBnZXQgSVNfV0lORE9XUygpIHsKICAgIHJldHVybiBmbGFncy53aW5kb3dzOwogIH0sCiAgSVNfTElOVVg6IHRydWUsCiAgSVNfTUFDOiBmYWxzZSwKfSkpOwoKY29uc3QgZXhlY0NvbW1hbmQgPSB2aS5ob2lzdGVkKCgpID0+IHZpLmZuKCkpOwpjb25zdCBjb21tYW5kRXhpc3RzID0gdmkuaG9pc3RlZCgoKSA9PiB2aS5mbigpKTsKdmkubW9jaygiLi4vdXRpbHMvY29tbWFuZCIsICgpID0+ICh7IGV4ZWNDb21tYW5kLCBjb21tYW5kRXhpc3RzIH0pKTsKCmNvbnN0IG9zTW9jayA9IHZpLmhvaXN0ZWQoKCkgPT4gKHsKICB1c2VySW5mbzogdmkuZm4oKCkgPT4gKHsgc2hlbGw6ICIvYmluL3pzaCIgfSkpLAogIHRtcGRpcjogdmkuZm4oKCkgPT4gIi90bXAiKSwKICBwbGF0Zm9ybTogdmkuZm4oKCkgPT4gImxpbnV4IiksCn0pKTsKdmkubW9jaygib3MiLCAoKSA9PiAoeyAuLi5vc01vY2ssIGRlZmF1bHQ6IG9zTW9jayB9KSk7CnZpLm1vY2soInByb2Nlc3MiLCAoKSA9PiAoeyBkZWZhdWx0OiB7IHBwaWQ6IDQyNDIgfSB9KSk7Cgpjb25zdCBzID0gYXdhaXQgaW1wb3J0KCIuL3NvZnR3YXJlIik7CmltcG9ydCB0eXBlIHsgSW5mb0NvbnRleHQgfSBmcm9tICIuLi90eXBlcy9pbnRlcm5hbC10eXBlcyI7Cgpjb25zdCBjdHggPSAoKTogSW5mb0NvbnRleHQgPT4gKHsgY2FjaGU6IHt9IH0pOwoKYmVmb3JlRWFjaCgoKSA9PiB7CiAgZmxhZ3Mud2luZG93cyA9IGZhbHNlOwogIGV4ZWNDb21tYW5kLm1vY2tSZXNldCgpLm1vY2tSZXR1cm5WYWx1ZSgiIik7CiAgY29tbWFuZEV4aXN0cy5tb2NrUmVzZXQoKS5tb2NrUmV0dXJuVmFsdWUoZmFsc2UpOwogIG9zTW9jay51c2VySW5mby5tb2NrUmVzZXQoKS5tb2NrUmV0dXJuVmFsdWUoeyBzaGVsbDogIi9iaW4venNoIiB9KTsKfSk7CgpkZXNjcmliZSgic2hlbGwiLCAoKSA9PiB7CiAgaXQoInJldHVybnMgdGhlIGxvZ2luIHNoZWxsJ3MgYmFzZW5hbWUiLCAoKSA9PiB7CiAgICBleHBlY3Qocy5zaGVsbChjdHgoKSkpLnRvQmUoInpzaCIpOwogIH0pOwoKICBpdCgiZmFsbHMgYmFjayB0byB0aGUgcGFyZW50IHByb2Nlc3MgbmFtZSB3aGVuIHRoZXJlIGlzIG5vIGxvZ2luIHNoZWxsIiwgKCkgPT4gewogICAgb3NNb2NrLnVzZXJJbmZvLm1vY2tSZXR1cm5WYWx1ZSh7IHNoZWxsOiAiIiB9KTsKICAgIGV4ZWNDb21tYW5kLm1vY2tSZXR1cm5WYWx1ZSgiL3Vzci9iaW4vZmlzaCIpOwogICAgZXhwZWN0KHMuc2hlbGwoY3R4KCkpKS50b0JlKCJmaXNoIik7CiAgICBleHBlY3QoZXhlY0NvbW1hbmQpLnRvSGF2ZUJlZW5DYWxsZWRXaXRoKCJwcyAtcCA0MjQyIC1vIGNvbW09Iik7CiAgfSk7CgogIGl0KCJmYWxscyBiYWNrIHRvIHBzIHdoZW4gdXNlckluZm8gdGhyb3dzIiwgKCkgPT4gewogICAgb3NNb2NrLnVzZXJJbmZvLm1vY2tJbXBsZW1lbnRhdGlvbigoKSA9PiB7CiAgICAgIHRocm93IG5ldyBFcnJvcigieCIpOwogICAgfSk7CiAgICBleGVjQ29tbWFuZC5tb2NrUmV0dXJuVmFsdWUoImJhc2giKTsKICAgIGV4cGVjdChzLnNoZWxsKGN0eCgpKSkudG9CZSgiYmFzaCIpOwogIH0pOwoKICBpdCgiaXMgZW1wdHkgd2hlbiBub3RoaW5nIGlkZW50aWZpZXMgdGhlIHNoZWxsIiwgKCkgPT4gewogICAgb3NNb2NrLnVzZXJJbmZvLm1vY2tSZXR1cm5WYWx1ZSh7IHNoZWxsOiAiIiB9KTsKICAgIGV4ZWNDb21tYW5kLm1vY2tSZXR1cm5WYWx1ZSgiIik7CiAgICBleHBlY3Qocy5zaGVsbChjdHgoKSkpLnRvQmUoIiIpOwogICAgZXhlY0NvbW1hbmQubW9ja0ltcGxlbWVudGF0aW9uKCgpID0+IHsKICAgICAgdGhyb3cgbmV3IEVycm9yKCJ4Iik7CiAgICB9KTsKICAgIGV4cGVjdChzLnNoZWxsKGN0eCgpKSkudG9CZSgiIik7CiAgfSk7CgogIGl0KCJpcyBlbXB0eSBvbiBXaW5kb3dzIGFuZCBzZXJ2ZXMgZnJvbSBjYWNoZSIsICgpID0+IHsKICAgIGZsYWdzLndpbmRvd3MgPSB0cnVlOwogICAgY29uc3QgYyA9IGN0eCgpOwogICAgZXhwZWN0KHMuc2hlbGwoYykpLnRvQmUoIiIpOwogICAgZmxhZ3Mud2luZG93cyA9IGZhbHNlOwogICAgZXhwZWN0KHMuc2hlbGwoYykpLnRvQmUoIiIpOwogIH0pOwp9KTsKCmRlc2NyaWJlKCJwYWNrYWdlcyIsICgpID0+IHsKICBpdCgibGlzdHMgdGhlIHBhY2thZ2UgbWFuYWdlcnMvdG9vbHMgdGhhdCBleGlzdCIsICgpID0+IHsKICAgIGNvbW1hbmRFeGlzdHMubW9ja0ltcGxlbWVudGF0aW9uKChjOiBzdHJpbmcpID0+IFsiYXB0IiwgIm5wbSIsICJidW4iXS5pbmNsdWRlcyhjKSk7CiAgICBjb25zdCBjID0gY3R4KCk7CiAgICBleHBlY3Qocy5wYWNrYWdlcyhjKSkudG9CZSgiYXB0IG5wbSBidW4iKTsKICAgIGNvbW1hbmRFeGlzdHMubW9ja1JldHVyblZhbHVlKGZhbHNlKTsKICAgIGV4cGVjdChzLnBhY2thZ2VzKGMpKS50b0JlKCJhcHQgbnBtIGJ1biIpOwogIH0pOwoKICBpdCgiaXMgZW1wdHkgd2hlbiBub3RoaW5nIGlzIGluc3RhbGxlZCIsICgpID0+IHsKICAgIGV4cGVjdChzLnBhY2thZ2VzKGN0eCgpKSkudG9CZSgiIik7CiAgfSk7Cn0pOwoKZGVzY3JpYmUoImNvbW1vbl92ZXJzaW9ucyIsICgpID0+IHsKICBjb25zdCBvdXRwdXRzOiBSZWNvcmQ8c3RyaW5nLCBzdHJpbmc+ID0gewogICAgIm5vZGUgLS12ZXJzaW9uIjogInYyMi4xLjAiLAogICAgImdpdCAtLXZlcnNpb24iOiAiZ2l0IHZlcnNpb24gMi40NC4wIiwKICAgICJkb2NrZXIgLS12ZXJzaW9uIjogIkRvY2tlciB2ZXJzaW9uIDI2LjEuMCwgYnVpbGQgYWJjIiwKICAgICJweXRob24zIC0tdmVyc2lvbiI6ICJQeXRob24gMy4xMi4zIiwKICAgICJnbyB2ZXJzaW9uIjogImdvIHZlcnNpb24gZ28xLjIyLjAgbGludXgvYW1kNjQiLAogICAgInJ1c3RjIC0tdmVyc2lvbiI6ICJydXN0YyAxLjc3LjAgKGFiYyAyMDI0LTAzLTE3KSIsCiAgfTsKCiAgaXQoImNsZWFucyBlYWNoIHRvb2wncyB2ZXJzaW9uIG91dHB1dCIsICgpID0+IHsKICAgIGNvbW1hbmRFeGlzdHMubW9ja1JldHVyblZhbHVlKHRydWUpOwogICAgZXhlY0NvbW1hbmQubW9ja0ltcGxlbWVudGF0aW9uKChjOiBzdHJpbmcpID0+IG91dHB1dHNbY10pOwogICAgZXhwZWN0KHMuY29tbW9uX3ZlcnNpb25zKGN0eCgpKSkudG9CZSgKICAgICAgIm5vZGU6MjIuMS4wIGdpdDoyLjQ0LjAgZG9ja2VyOjI2LjEuMCBweXRob24zOjMuMTIuMyBnbzoxLjIyLjAgcnVzdGM6MS43Ny4wIiwKICAgICk7CiAgfSk7CgogIGl0KCJza2lwcyBtaXNzaW5nIHRvb2xzLCBlbXB0eSB2ZXJzaW9ucyBhbmQgZmFpbGluZyBjb21tYW5kcyIsICgpID0+IHsKICAgIGNvbW1hbmRFeGlzdHMubW9ja0ltcGxlbWVudGF0aW9uKChjOiBzdHJpbmcpID0+IFsibm9kZSIsICJnaXQiLCAiZ28iXS5pbmNsdWRlcyhjKSk7CiAgICBleGVjQ29tbWFuZC5tb2NrSW1wbGVtZW50YXRpb24oKGM6IHN0cmluZykgPT4gewogICAgICBpZiAoYy5zdGFydHNXaXRoKCJnaXQiKSkgcmV0dXJuICIiOwogICAgICBpZiAoYy5zdGFydHNXaXRoKCJnbyIpKSB0aHJvdyBuZXcgRXJyb3IoIngiKTsKICAgICAgcmV0dXJuIG91dHB1dHNbY107CiAgICB9KTsKICAgIGNvbnN0IGMgPSBjdHgoKTsKICAgIGV4cGVjdChzLmNvbW1vbl92ZXJzaW9ucyhjKSkudG9CZSgibm9kZToyMi4xLjAiKTsKICAgIGV4ZWNDb21tYW5kLm1vY2tSZXR1cm5WYWx1ZSgidjEiKTsKICAgIGV4cGVjdChzLmNvbW1vbl92ZXJzaW9ucyhjKSkudG9CZSgibm9kZToyMi4xLjAiKTsKICB9KTsKfSk7CgpkZXNjcmliZSgiY29udGFpbmVycyIsICgpID0+IHsKICBpdCgiaXMgZW1wdHkgd2l0aG91dCBkb2NrZXIiLCAoKSA9PiB7CiAgICBleHBlY3Qocy5jb250YWluZXJzKGN0eCgpKSkudG9CZSgiIik7CiAgfSk7CgogIGl0KCJpcyBlbXB0eSB3aGVuIG5vIGNvbnRhaW5lcnMgYXJlIHJ1bm5pbmciLCAoKSA9PiB7CiAgICBjb21tYW5kRXhpc3RzLm1vY2tSZXR1cm5WYWx1ZSh0cnVlKTsKICAgIGV4ZWNDb21tYW5kLm1vY2tSZXR1cm5WYWx1ZSgiIik7CiAgICBleHBlY3Qocy5jb250YWluZXJzKGN0eCgpKSkudG9CZSgiIik7CiAgfSk7CgogIGl0KCJsaXN0cyBuYW1lcyB3aXRoIHRoZWlyIGRlLWR1cGxpY2F0ZWQgcHVibGlzaGVkIHBvcnRzIiwgKCkgPT4gewogICAgY29tbWFuZEV4aXN0cy5tb2NrUmV0dXJuVmFsdWUodHJ1ZSk7CiAgICBleGVjQ29tbWFuZC5tb2NrSW1wbGVtZW50YXRpb24oKGM6IHN0cmluZykgPT4KICAgICAgYyA9PT0gImRvY2tlciBwcyAtcSIKICAgICAgICA/ICJhYmNcbmRlZlxuZ2hpIgogICAgICAgIDogWwogICAgICAgICAgICAid2ViXHQwLjAuMC4wOjgwODAtPjgwL3RjcCwgOjo6ODA4MC0+ODAvdGNwLCAwLjAuMC4wOjkwMDAtOTAwMi0+OTAwMC05MDAyL3RjcCIsCiAgICAgICAgICAgICJkYlx0NTQzMi90Y3AiLAogICAgICAgICAgICAiYmFyZSIsCiAgICAgICAgICAgICJcdDAuMC4wLjA6MS0+MS90Y3AiLAogICAgICAgICAgXS5qb2luKCJcbiIpLAogICAgKTsKICAgIGNvbnN0IGMgPSBjdHgoKTsKICAgIGV4cGVjdChzLmNvbnRhaW5lcnMoYykpLnRvQmUoIndlYiA4MCA5MDAwLTkwMDIgZGIgYmFyZSIpOwogICAgZXhlY0NvbW1hbmQubW9ja1JldHVyblZhbHVlKCIiKTsKICAgIGV4cGVjdChzLmNvbnRhaW5lcnMoYykpLnRvQmUoIndlYiA4MCA5MDAwLTkwMDIgZGIgYmFyZSIpOwogIH0pOwoKICBpdCgiaXMgZW1wdHkgd2hlbiBkb2NrZXIgZXJyb3JzIiwgKCkgPT4gewogICAgY29tbWFuZEV4aXN0cy5tb2NrUmV0dXJuVmFsdWUodHJ1ZSk7CiAgICBleGVjQ29tbWFuZC5tb2NrSW1wbGVtZW50YXRpb24oKCkgPT4gewogICAgICB0aHJvdyBuZXcgRXJyb3IoIngiKTsKICAgIH0pOwogICAgZXhwZWN0KHMuY29udGFpbmVycyhjdHgoKSkpLnRvQmUoIiIpOwogIH0pOwp9KTsK", AI = "data:video/mp2t;base64,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", dI = "data:video/mp2t;base64,import { beforeEach, describe, expect, it, vi } from "vitest";

const flags = vi.hoisted(() => ({ linux: true, mac: false }));
vi.mock("../utils/platform", () => ({
  get IS_LINUX() {
    return flags.linux;
  },
  get IS_MAC() {
    return flags.mac;
  },
  IS_WINDOWS: false,
}));

const execCommand = vi.hoisted(() => vi.fn());
const commandExists = vi.hoisted(() => vi.fn());
vi.mock("../utils/command", () => ({ execCommand, commandExists }));

const files = vi.hoisted(() => ({ map: {} as Record<string, string> }));
const fsMock = vi.hoisted(() => ({
  existsSync: vi.fn((p: string) => p in files.map),
  readFileSync: vi.fn((p: string) => {
    if (!(p in files.map)) throw new Error("ENOENT");
    return files.map[p];
  }),
  writeFileSync: vi.fn(),
}));
vi.mock("fs", () => ({ ...fsMock, default: fsMock }));

const osMock = vi.hoisted(() => ({
  loadavg: vi.fn(() => [0.5, 1.25, 2]),
  tmpdir: vi.fn(() => "/tmp"),
  platform: vi.fn(() => "linux"),
}));
vi.mock("os", () => ({ ...osMock, default: osMock }));

const st = await import("./system-status");
import type { InfoContext } from "../types/internal-types";

const ctx = (): InfoContext => ({ cache: {} });
const platform = (v: "linux" | "mac" | "other") => {
  flags.linux = v === "linux";
  flags.mac = v === "mac";
};

beforeEach(() => {
  platform("linux");
  files.map = {};
  execCommand.mockReset().mockReturnValue("");
  commandExists.mockReset().mockReturnValue(false);
});

describe("load_average", () => {
  it("reads /proc/loadavg on Linux", () => {
    files.map["/proc/loadavg"] = "0.10 0.20 0.30 1/200 999";
    expect(st.load_average(ctx())).toBe("0.10 0.20 0.30");
  });

  it("is empty when /proc/loadavg is unreadable", () => {
    expect(st.load_average(ctx())).toBe("");
  });

  it("formats os.loadavg on macOS", () => {
    platform("mac");
    expect(st.load_average(ctx())).toBe("0.50 1.25 2.00");
  });

  it("is empty on other platforms", () => {
    platform("other");
    expect(st.load_average(ctx())).toBe("");
  });
});

describe("battery", () => {
  it("reads capacity/status from sysfs on Linux", () => {
    files.map["/sys/class/power_supply/BAT0/capacity"] = "87\n";
    files.map["/sys/class/power_supply/BAT0/status"] = "Charging\n";
    expect(st.battery(ctx())).toBe("87%+");
  });

  it("omits the + when discharging, or when status is unavailable", () => {
    files.map["/sys/class/power_supply/BAT0/capacity"] = "50";
    files.map["/sys/class/power_supply/BAT0/status"] = "Discharging";
    expect(st.battery(ctx())).toBe("50%");
    delete files.map["/sys/class/power_supply/BAT0/status"];
    expect(st.battery(ctx())).toBe("50%");
  });

  it("is empty with no battery", () => {
    expect(st.battery(ctx())).toBe("");
  });

  it("parses pmset on macOS", () => {
    platform("mac");
    execCommand.mockReturnValue("Now drawing from 'AC Power'\n -InternalBattery-0 (id=1)\t64%; charging; 1:00 remaining");
    expect(st.battery(ctx())).toBe("64%+");
    execCommand.mockReturnValue("-InternalBattery-0\t64%; discharging; 3:00 remaining");
    expect(st.battery(ctx())).toBe("64%");
    execCommand.mockReturnValue("No batteries");
    expect(st.battery(ctx())).toBe("");
    execCommand.mockImplementation(() => {
      throw new Error("x");
    });
    expect(st.battery(ctx())).toBe("");
  });

  it("is empty on other platforms, and cached", () => {
    platform("other");
    const c = ctx();
    expect(st.battery(c)).toBe("");
    platform("linux");
    files.map["/sys/class/power_supply/BAT0/capacity"] = "10";
    expect(st.battery(c)).toBe("");
  });
});

describe("temperature", () => {
  it("reads the first plausible sysfs thermal source", () => {
    files.map["/sys/class/thermal/thermal_zone0/temp"] = "0";
    files.map["/sys/class/hwmon/hwmon0/temp1_input"] = "54321";
    expect(st.temperature(ctx())).toBe("54°C");
  });

  it("rejects implausible readings", () => {
    files.map["/sys/class/thermal/thermal_zone0/temp"] = "200000";
    expect(st.temperature(ctx())).toBe("");
  });

  it("is empty when no sensors exist", () => {
    expect(st.temperature(ctx())).toBe("");
  });

  it("uses osx-cpu-temp on macOS when installed", () => {
    platform("mac");
    commandExists.mockReturnValue(true);
    execCommand.mockReturnValue("61.7°C");
    expect(st.temperature(ctx())).toBe("62°C");
    execCommand.mockReturnValue("999.0°C");
    expect(st.temperature(ctx())).toBe("");
    execCommand.mockReturnValue("no temp");
    expect(st.temperature(ctx())).toBe("");
    execCommand.mockImplementation(() => {
      throw new Error("x");
    });
    expect(st.temperature(ctx())).toBe("");
  });

  it("is empty on macOS without osx-cpu-temp and on other platforms", () => {
    platform("mac");
    expect(st.temperature(ctx())).toBe("");
    platform("other");
    expect(st.temperature(ctx())).toBe("");
  });

  it("serves from the cache", () => {
    const c = ctx();
    files.map["/sys/class/thermal/thermal_zone0/temp"] = "40000";
    expect(st.temperature(c)).toBe("40°C");
    files.map["/sys/class/thermal/thermal_zone0/temp"] = "90000";
    expect(st.temperature(c)).toBe("40°C");
  });
});

describe("services_running", () => {
  it("counts running units via systemctl", () => {
    commandExists.mockImplementation((c: string) => c === "systemctl");
    execCommand.mockReturnValue("a.service loaded active running A\nb.service loaded active running B\nfooter");
    expect(st.services_running(ctx())).toBe("2 services");
  });

  it("falls back to `service --status-all`", () => {
    commandExists.mockImplementation((c: string) => c === "service");
    execCommand.mockReturnValue(" [ + ]  cron\n [ - ]  nginx\n [ + ]  ssh");
    expect(st.services_running(ctx())).toBe("2 services");
  });

  it("is empty with no service manager, zero services, or on error", () => {
    expect(st.services_running(ctx())).toBe("");
    commandExists.mockReturnValue(true);
    execCommand.mockReturnValue("");
    expect(st.services_running(ctx())).toBe("");
    execCommand.mockImplementation(() => {
      throw new Error("x");
    });
    expect(st.services_running(ctx())).toBe("");
  });

  it("counts launchctl entries on macOS", () => {
    platform("mac");
    execCommand.mockReturnValue("PID Status Label\n1 0 com.a\n- 0 com.b\n\n");
    expect(st.services_running(ctx())).toBe("2 services");
    execCommand.mockReturnValue("PID Status Label");
    expect(st.services_running(ctx())).toBe("");
    execCommand.mockImplementation(() => {
      throw new Error("x");
    });
    expect(st.services_running(ctx())).toBe("");
  });

  it("is empty on other platforms, and cached", () => {
    platform("other");
    const c = ctx();
    expect(st.services_running(c)).toBe("");
    platform("mac");
    execCommand.mockReturnValue("PID\n1 0 a");
    expect(st.services_running(c)).toBe("");
  });
});
", mI = "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 k(I) {
+  return Array.isArray ? Array.isArray(I) : $I(I) === "[object Array]";
+}
+function Wg(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 KI(I) {
+  return I == null ? "" : Wg(I);
+}
+function N(I) {
+  return typeof I == "string";
+}
+function U(I) {
+  return typeof I == "number";
+}
+function Bg(I) {
+  return I === !0 || I === !1 || ug(I) && $I(I) == "[object Boolean]";
+}
+function qI(I) {
+  return typeof I == "object";
+}
+function ug(I) {
+  return qI(I) && I !== null;
+}
+function X(I) {
+  return I != null;
+}
+function T(I) {
+  return !I.trim().length;
+}
+function $I(I) {
+  return I == null ? I === void 0 ? "[object Undefined]" : "[object Null]" : Object.prototype.toString.call(I);
+}
+const Kg = "Incorrect 'index' type", pI = "Invalid doc index: must be a non-negative integer within the bounds of the docs array", pg = (I) => `Invalid value for key ${I}`, Vg = (I) => `Pattern length exceeds max of ${I}.`, Yg = (I) => `Missing ${I} property in key`, Ng = (I) => `Property 'weight' in key '${I}' must be a positive integer`, rg = "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.", LI = Object.prototype.hasOwnProperty;
+var yg = class {
+  constructor(I) {
+    this._keys = [], this._keyMap = {};
+    let g = 0;
+    I.forEach((i) => {
+      const C = Ig(i);
+      this._keys.push(C), this._keyMap[C.id] = C, g += C.weight;
+    }), this._keys.forEach((i) => {
+      i.weight /= g;
+    });
+  }
+  get(I) {
+    return this._keyMap[I];
+  }
+  keys() {
+    return this._keys;
+  }
+  toJSON() {
+    return JSON.stringify(this._keys);
+  }
+};
+function Ig(I) {
+  let g = null, i = null, C = null, c = 1, l = null;
+  if (N(I) || k(I))
+    C = I, g = MI(I), i = D(I);
+  else {
+    if (!LI.call(I, "name")) throw new Error(Yg("name"));
+    const s = I.name;
+    if (C = s, LI.call(I, "weight") && I.weight !== void 0 && (c = I.weight, c <= 0))
+      throw new Error(Ng(D(s)));
+    g = MI(s), i = D(s), l = I.getFn ?? null;
+  }
+  return {
+    path: g,
+    id: i,
+    weight: c,
+    src: C,
+    getFn: l
+  };
+}
+function MI(I) {
+  return k(I) ? I : I.split(".");
+}
+function D(I) {
+  return k(I) ? I.join(".") : I;
+}
+function Xg(I, g) {
+  const i = [];
+  let C = !1;
+  const c = (l, s, o, b) => {
+    if (X(l))
+      if (!s[o]) i.push(b !== void 0 ? {
+        v: l,
+        i: b
+      } : l);
+      else {
+        const t = l[s[o]];
+        if (!X(t)) return;
+        if (o === s.length - 1 && (N(t) || U(t) || Bg(t) || typeof t == "bigint")) i.push(b !== void 0 ? {
+          v: KI(t),
+          i: b
+        } : KI(t));
+        else if (k(t)) {
+          C = !0;
+          for (let Z = 0, e = t.length; Z < e; Z += 1) c(t[Z], s, o + 1, Z);
+        } else s.length && c(t, s, o + 1, b);
+      }
+  };
+  return c(I, N(g) ? g.split(".") : g, 0), C ? i : i[0];
+}
+const Sg = {
+  includeMatches: !1,
+  findAllMatches: !1,
+  minMatchCharLength: 1
+}, Hg = {
+  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
+}, wg = {
+  location: 0,
+  threshold: 0.6,
+  distance: 100
+}, kg = {
+  useExtendedSearch: !1,
+  useTokenSearch: !1,
+  tokenize: void 0,
+  tokenMatch: "any",
+  getFn: Xg,
+  ignoreLocation: !1,
+  ignoreFieldNorm: !1,
+  fieldNormWeight: 1
+}, n = Object.freeze({
+  ...Hg,
+  ...Sg,
+  ...wg,
+  ...kg
+});
+function Rg(I) {
+  return I >= 9 && I <= 13 || I === 32 || I === 160;
+}
+function vg(I = 1, g = 3) {
+  const i = /* @__PURE__ */ new Map(), C = Math.pow(10, g);
+  return {
+    get(c) {
+      let l = 0, s = !1;
+      for (let b = 0; b < c.length; b++) Rg(c.charCodeAt(b)) ? s = !1 : s || (l++, s = !0);
+      if (l === 0 && (l = 1), i.has(l)) return i.get(l);
+      const o = Math.round(C / Math.pow(l, 0.5 * I)) / C;
+      return i.set(l, o), o;
+    },
+    clear() {
+      i.clear();
+    }
+  };
+}
+var HI = class {
+  constructor({ getFn: I = n.getFn, fieldNormWeight: g = n.fieldNormWeight } = {}) {
+    this.norm = vg(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, i) => {
+      this._keysMap[g.id] = i;
+    });
+  }
+  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 i = 0; i < I; i++) {
+      const C = this._createStringRecord(this.docs[i], i);
+      C && (this.records[g++] = C);
+    }
+    else for (let i = 0; i < I; i++) this.records[g++] = this._createObjectRecord(this.docs[i], i);
+    this.records.length = g, this.norm.clear();
+  }
+  add(I, g) {
+    if (!Number.isInteger(g) || g < 0) throw new Error(pI);
+    if (N(I)) {
+      const C = this._createStringRecord(I, g);
+      return C && this.records.push(C), C;
+    }
+    const i = this._createObjectRecord(I, g);
+    return this.records.push(i), i;
+  }
+  removeAt(I) {
+    if (!Number.isInteger(I) || I < 0) throw new Error(pI);
+    for (let g = 0, i = this.records.length; g < i; g += 1) if (this.records[g].i === I) {
+      this.records.splice(g, 1);
+      break;
+    }
+    for (let g = 0, i = this.records.length; g < i; g += 1) this.records[g].i > I && (this.records[g].i -= 1);
+  }
+  removeAll(I) {
+    const g = /* @__PURE__ */ new Set();
+    for (const C of I) Number.isInteger(C) && C >= 0 && g.add(C);
+    if (g.size === 0) return;
+    this.records = this.records.filter((C) => !g.has(C.i));
+    const i = Array.from(g).sort((C, c) => C - c);
+    for (const C of this.records) {
+      let c = 0, l = i.length;
+      for (; c < l; ) {
+        const s = c + l >>> 1;
+        i[s] < C.i ? c = s + 1 : l = s;
+      }
+      C.i -= c;
+    }
+  }
+  getValueForItemAtKeyId(I, g) {
+    return I[this._keysMap[g]];
+  }
+  size() {
+    return this.records.length;
+  }
+  _createStringRecord(I, g) {
+    return !X(I) || T(I) ? null : {
+      v: I,
+      i: g,
+      n: this.norm.get(I)
+    };
+  }
+  _createObjectRecord(I, g) {
+    const i = {
+      i: g,
+      $: {}
+    };
+    for (let C = 0, c = this.keys.length; C < c; C++) {
+      const l = this.keys[C], s = l.getFn ? l.getFn(I) : this.getFn(I, l.path);
+      if (X(s)) {
+        if (k(s)) {
+          const o = [];
+          for (let b = 0, t = s.length; b < t; b += 1) {
+            const Z = s[b];
+            if (X(Z)) {
+              if (N(Z)) {
+                if (!T(Z)) {
+                  const e = {
+                    v: Z,
+                    i: b,
+                    n: this.norm.get(Z)
+                  };
+                  o.push(e);
+                }
+              } else if (X(Z.v)) {
+                const e = N(Z.v) ? Z.v : KI(Z.v);
+                if (!T(e)) {
+                  const A = {
+                    v: e,
+                    i: Z.i,
+                    n: this.norm.get(e)
+                  };
+                  o.push(A);
+                }
+              }
+            }
+          }
+          i.$[C] = o;
+        } else if (N(s) && !T(s)) {
+          const o = {
+            v: s,
+            n: this.norm.get(s)
+          };
+          i.$[C] = o;
+        }
+      }
+    }
+    return i;
+  }
+  toJSON() {
+    return {
+      keys: this.keys.map(({ getFn: I, ...g }) => g),
+      records: this.records
+    };
+  }
+};
+function gg(I, g, { getFn: i = n.getFn, fieldNormWeight: C = n.fieldNormWeight } = {}) {
+  const c = new HI({
+    getFn: i,
+    fieldNormWeight: C
+  });
+  return c.setKeys(I.map(Ig)), c.setSources(g), c.create(), c;
+}
+function Jg(I, { getFn: g = n.getFn, fieldNormWeight: i = n.fieldNormWeight } = {}) {
+  const { keys: C, records: c } = I, l = new HI({
+    getFn: g,
+    fieldNormWeight: i
+  });
+  return l.setKeys(C), l.setIndexRecords(c), l;
+}
+function Fg(I = [], g = n.minMatchCharLength) {
+  const i = [];
+  let C = -1, c = -1, l = 0;
+  for (let s = I.length; l < s; l += 1) {
+    const o = I[l];
+    o && C === -1 ? C = l : !o && C !== -1 && (c = l - 1, c - C + 1 >= g && i.push([C, c]), C = -1);
+  }
+  return I[l - 1] && l - C >= g && i.push([C, l - 1]), i;
+}
+function jg(I, g, i, { location: C = n.location, distance: c = n.distance, threshold: l = n.threshold, findAllMatches: s = n.findAllMatches, minMatchCharLength: o = n.minMatchCharLength, includeMatches: b = n.includeMatches, ignoreLocation: t = n.ignoreLocation } = {}) {
+  if (g.length > 32) throw new Error(Vg(32));
+  const Z = g.length, e = I.length, A = Math.max(0, Math.min(C, e));
+  let m = l, h = A;
+  const W = (Y, y) => {
+    const S = Y / Z;
+    if (t) return S;
+    const z = Math.abs(A - y);
+    return c ? S + z / c : z ? 1 : S;
+  }, G = o > 1 || b, r = G ? Array(e) : [];
+  let w;
+  for (; (w = I.indexOf(g, h)) > -1; ) {
+    const Y = W(0, w);
+    if (m = Math.min(Y, m), h = w + Z, G) {
+      let y = 0;
+      for (; y < Z; )
+        r[w + y] = 1, y += 1;
+    }
+  }
+  h = -1;
+  let v = [], Q = 1, jI = 0, f = Z + e;
+  const sg = 1 << Z - 1;
+  for (let Y = 0; Y < Z; Y += 1) {
+    let y = 0, S = f;
+    for (; y < S; )
+      W(Y, A + S) <= m ? y = S : f = S, S = Math.floor((f - y) / 2 + y);
+    f = S;
+    let z = Math.max(1, A - S + 1);
+    const aI = s ? e : Math.min(A + S, e) + Z, F = Array(aI + 2);
+    F[aI + 1] = (1 << Y) - 1;
+    for (let H = aI; H >= z; H -= 1) {
+      const hI = H - 1, og = i[I[hI]];
+      if (F[H] = (F[H + 1] << 1 | 1) & og, Y && (F[H] |= (v[H + 1] | v[H]) << 1 | 1 | v[H + 1]), F[H] & sg && (Q = W(Y, hI), Q <= m)) {
+        if (m = Q, h = hI, jI = Y, h <= A) break;
+        z = Math.max(1, 2 * A - h);
+      }
+    }
+    if (W(Y + 1, A) > m) break;
+    v = F;
+  }
+  if (G && h >= 0) {
+    const Y = Math.min(e - 1, h + Z - 1 + jI);
+    for (let y = h; y <= Y; y += 1) i[I[y]] && (r[y] = 1);
+  }
+  const GI = {
+    isMatch: h >= 0,
+    score: Math.max(1e-3, Q)
+  };
+  if (G) {
+    const Y = Fg(r, o);
+    Y.length ? b && (GI.indices = Y) : GI.isMatch = !1;
+  }
+  return GI;
+}
+function zg(I) {
+  const g = {};
+  for (let i = 0, C = I.length; i < C; i += 1) {
+    const c = I.charAt(i);
+    g[c] = (g[c] || 0) | 1 << C - i - 1;
+  }
+  return g;
+}
+function wI(I) {
+  if (I.length <= 1) return I;
+  I.sort((i, C) => i[0] - C[0] || i[1] - C[1]);
+  const g = [I[0]];
+  for (let i = 1, C = I.length; i < C; i += 1) {
+    const c = g[g.length - 1], l = I[i];
+    l[0] <= c[1] + 1 ? c[1] = Math.max(c[1], l[1]) : g.push(l);
+  }
+  return g;
+}
+const Cg = {
+  ł: "l",
+  Ł: "L",
+  đ: "d",
+  Đ: "D",
+  ø: "o",
+  Ø: "O",
+  ħ: "h",
+  Ħ: "H",
+  ŧ: "t",
+  Ŧ: "T",
+  ı: "i",
+  ß: "ss"
+}, Lg = new RegExp("[" + Object.keys(Cg).join("") + "]", "g"), L = 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(Lg, (g) => Cg[g]) : (I) => I;
+var kI = class {
+  constructor(I, { location: g = n.location, threshold: i = n.threshold, distance: C = n.distance, includeMatches: c = n.includeMatches, findAllMatches: l = n.findAllMatches, minMatchCharLength: s = n.minMatchCharLength, isCaseSensitive: o = n.isCaseSensitive, ignoreDiacritics: b = n.ignoreDiacritics, ignoreLocation: t = n.ignoreLocation } = {}) {
+    if (this.options = {
+      location: g,
+      threshold: i,
+      distance: C,
+      includeMatches: c,
+      findAllMatches: l,
+      minMatchCharLength: s,
+      isCaseSensitive: o,
+      ignoreDiacritics: b,
+      ignoreLocation: t
+    }, I = o ? I : I.toLowerCase(), I = b ? L(I) : I, this.pattern = I, this.chunks = [], !this.pattern.length) return;
+    const Z = (A, m) => {
+      this.chunks.push({
+        pattern: A,
+        alphabet: zg(A),
+        startIndex: m
+      });
+    }, e = this.pattern.length;
+    if (e > 32) {
+      let A = 0;
+      const m = e % 32, h = e - m;
+      for (; A < h; )
+        Z(this.pattern.substr(A, 32), A), A += 32;
+      if (m) {
+        const W = e - 32;
+        Z(this.pattern.substr(W), W);
+      }
+    } else Z(this.pattern, 0);
+  }
+  searchIn(I) {
+    const { isCaseSensitive: g, ignoreDiacritics: i, includeMatches: C } = this.options;
+    if (I = g ? I : I.toLowerCase(), I = i ? L(I) : I, this.pattern === I) {
+      if (I.length < this.options.minMatchCharLength) return {
+        isMatch: !1,
+        score: 1
+      };
+      const h = {
+        isMatch: !0,
+        score: 0
+      };
+      return C && (h.indices = [[0, I.length - 1]]), h;
+    }
+    const { location: c, distance: l, threshold: s, findAllMatches: o, minMatchCharLength: b, ignoreLocation: t } = this.options, Z = [];
+    let e = 0, A = !1;
+    this.chunks.forEach(({ pattern: h, alphabet: W, startIndex: G }) => {
+      const { isMatch: r, score: w, indices: v } = jg(I, h, W, {
+        location: c + G,
+        distance: l,
+        threshold: s,
+        findAllMatches: o,
+        minMatchCharLength: b,
+        includeMatches: C,
+        ignoreLocation: t
+      });
+      r && (A = !0), e += w, r && v && Z.push(...v);
+    });
+    const m = {
+      isMatch: A,
+      score: A ? e / this.chunks.length : 1
+    };
+    return A && C && (m.indices = wI(Z)), m;
+  }
+};
+const Mg = /* @__PURE__ */ new Set(["fuzzy", "include"]);
+function Qg(I) {
+  return I.startsWith("inverse");
+}
+const VI = [
+  {
+    type: "exact",
+    multiRegex: /^="(.*)"$/,
+    singleRegex: /^=(.*)$/,
+    create: (I) => ({
+      type: "exact",
+      search(g) {
+        const i = g === I;
+        return {
+          isMatch: i,
+          score: i ? 0 : 1,
+          indices: [0, I.length - 1]
+        };
+      }
+    })
+  },
+  {
+    type: "include",
+    multiRegex: /^'"(.*)"$/,
+    singleRegex: /^'(.*)$/,
+    create: (I) => ({
+      type: "include",
+      search(g) {
+        let i = 0, C;
+        const c = [], l = I.length;
+        for (; (C = g.indexOf(I, i)) > -1; )
+          i = C + l, c.push([C, i - 1]);
+        const s = !!c.length;
+        return {
+          isMatch: s,
+          score: s ? 0 : 1,
+          indices: c
+        };
+      }
+    })
+  },
+  {
+    type: "prefix-exact",
+    multiRegex: /^\^"(.*)"$/,
+    singleRegex: /^\^(.*)$/,
+    create: (I) => ({
+      type: "prefix-exact",
+      search(g) {
+        const i = g.startsWith(I);
+        return {
+          isMatch: i,
+          score: i ? 0 : 1,
+          indices: [0, I.length - 1]
+        };
+      }
+    })
+  },
+  {
+    type: "inverse-prefix-exact",
+    multiRegex: /^!\^"(.*)"$/,
+    singleRegex: /^!\^(.*)$/,
+    create: (I) => ({
+      type: "inverse-prefix-exact",
+      search(g) {
+        const i = !g.startsWith(I);
+        return {
+          isMatch: i,
+          score: i ? 0 : 1,
+          indices: [0, g.length - 1]
+        };
+      }
+    })
+  },
+  {
+    type: "inverse-suffix-exact",
+    multiRegex: /^!"(.*)"\$$/,
+    singleRegex: /^!(.*)\$$/,
+    create: (I) => ({
+      type: "inverse-suffix-exact",
+      search(g) {
+        const i = !g.endsWith(I);
+        return {
+          isMatch: i,
+          score: i ? 0 : 1,
+          indices: [0, g.length - 1]
+        };
+      }
+    })
+  },
+  {
+    type: "suffix-exact",
+    multiRegex: /^"(.*)"\$$/,
+    singleRegex: /^(.*)\$$/,
+    create: (I) => ({
+      type: "suffix-exact",
+      search(g) {
+        const i = g.endsWith(I);
+        return {
+          isMatch: i,
+          score: i ? 0 : 1,
+          indices: [g.length - I.length, g.length - 1]
+        };
+      }
+    })
+  },
+  {
+    type: "inverse-exact",
+    multiRegex: /^!"(.*)"$/,
+    singleRegex: /^!(.*)$/,
+    create: (I) => ({
+      type: "inverse-exact",
+      search(g) {
+        const i = g.indexOf(I) === -1;
+        return {
+          isMatch: i,
+          score: i ? 0 : 1,
+          indices: [0, g.length - 1]
+        };
+      }
+    })
+  },
+  {
+    type: "fuzzy",
+    multiRegex: /^"(.*)"$/,
+    singleRegex: /^(.*)$/,
+    create: (I, g = {}) => {
+      const i = new kI(I, {
+        location: g.location ?? n.location,
+        threshold: g.threshold ?? n.threshold,
+        distance: g.distance ?? n.distance,
+        includeMatches: g.includeMatches ?? n.includeMatches,
+        findAllMatches: g.findAllMatches ?? n.findAllMatches,
+        minMatchCharLength: g.minMatchCharLength ?? n.minMatchCharLength,
+        isCaseSensitive: g.isCaseSensitive ?? n.isCaseSensitive,
+        ignoreDiacritics: g.ignoreDiacritics ?? n.ignoreDiacritics,
+        ignoreLocation: g.ignoreLocation ?? n.ignoreLocation
+      });
+      return {
+        type: "fuzzy",
+        search(C) {
+          return i.searchIn(C);
+        }
+      };
+    }
+  }
+], QI = VI.length, fg = "\0", Tg = "|";
+function Ug(I) {
+  const g = [], i = I.length;
+  let C = 0;
+  for (; C < i; ) {
+    for (; C < i && I[C] === " "; ) C++;
+    if (C >= i) break;
+    let c = C;
+    for (; c < i && I[c] !== " " && I[c] !== '"'; ) c++;
+    if (c < i && I[c] === '"') {
+      for (c++; c < i; ) {
+        if (I[c] === '"') {
+          const l = c + 1;
+          if (l >= i || I[l] === " ") {
+            c++;
+            break;
+          }
+          if (I[l] === "$" && (l + 1 >= i || I[l + 1] === " ")) {
+            c += 2;
+            break;
+          }
+        }
+        c++;
+      }
+      g.push(I.substring(C, c)), C = c;
+    } else {
+      for (; c < i && I[c] !== " "; ) c++;
+      g.push(I.substring(C, c)), C = c;
+    }
+  }
+  return g;
+}
+function fI(I, g) {
+  const i = I.match(g);
+  return i ? i[1] : null;
+}
+function Dg(I, g = {}) {
+  return I.replace(/\\\|/g, fg).split(Tg).map((i) => {
+    const C = Ug(i.replace(/\u0000/g, "|").trim()).filter((l) => l && !!l.trim()), c = [];
+    for (let l = 0, s = C.length; l < s; l += 1) {
+      const o = C[l];
+      let b = !1, t = -1;
+      for (; !b && ++t < QI; ) {
+        const Z = VI[t], e = fI(o, Z.multiRegex);
+        e && (c.push(Z.create(e, g)), b = !0);
+      }
+      if (!b)
+        for (t = -1; ++t < QI; ) {
+          const Z = VI[t], e = fI(o, Z.singleRegex);
+          if (e) {
+            c.push(Z.create(e, g));
+            break;
+          }
+        }
+    }
+    return c;
+  });
+}
+var Og = class {
+  constructor(I, { isCaseSensitive: g = n.isCaseSensitive, ignoreDiacritics: i = n.ignoreDiacritics, includeMatches: C = n.includeMatches, minMatchCharLength: c = n.minMatchCharLength, ignoreLocation: l = n.ignoreLocation, findAllMatches: s = n.findAllMatches, location: o = n.location, threshold: b = n.threshold, distance: t = n.distance } = {}) {
+    this.query = null, this.options = {
+      isCaseSensitive: g,
+      ignoreDiacritics: i,
+      includeMatches: C,
+      minMatchCharLength: c,
+      findAllMatches: s,
+      ignoreLocation: l,
+      location: o,
+      threshold: b,
+      distance: t
+    }, I = g ? I : I.toLowerCase(), I = i ? L(I) : I, this.pattern = I, this.query = Dg(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: i, isCaseSensitive: C, ignoreDiacritics: c } = this.options;
+    I = C ? I : I.toLowerCase(), I = c ? L(I) : I;
+    let l = 0;
+    const s = [];
+    let o = 0, b = !1;
+    for (let t = 0, Z = g.length; t < Z; t += 1) {
+      const e = g[t];
+      s.length = 0, l = 0, b = !1;
+      for (let A = 0, m = e.length; A < m; A += 1) {
+        const h = e[A], { isMatch: W, indices: G, score: r } = h.search(I);
+        if (W)
+          l += 1, o += r, Qg(h.type) && (b = !0), i && (Mg.has(h.type) ? s.push(...G) : s.push(G));
+        else {
+          o = 0, l = 0, s.length = 0, b = !1;
+          break;
+        }
+      }
+      if (l) {
+        const A = {
+          isMatch: !0,
+          score: o / l
+        };
+        return b && (A.hasInverse = !0), i && (A.indices = wI(s)), A;
+      }
+    }
+    return {
+      isMatch: !1,
+      score: 1
+    };
+  }
+};
+const YI = [];
+function RI(...I) {
+  YI.push(...I);
+}
+function E(I, g) {
+  for (let i = 0, C = YI.length; i < C; i += 1) {
+    const c = YI[i];
+    if (c.condition(I, g)) return new c(I, g);
+  }
+  return new kI(I, g);
+}
+const P = {
+  AND: "$and",
+  OR: "$or"
+}, NI = {
+  PATH: "$path",
+  PATTERN: "$val"
+}, rI = (I) => !!(I[P.AND] || I[P.OR]), xg = (I) => !!I[NI.PATH], Eg = (I) => !k(I) && qI(I) && !rI(I), TI = (I) => ({ [P.AND]: Object.keys(I).map((g) => ({ [g]: I[g] })) });
+function ig(I, g, { auto: i = !0 } = {}) {
+  const C = (c) => {
+    if (N(c)) {
+      const b = {
+        keyId: null,
+        pattern: c
+      };
+      return i && (b.searcher = E(c, g)), b;
+    }
+    const l = Object.keys(c), s = xg(c);
+    if (!s && l.length > 1 && !rI(c)) return C(TI(c));
+    if (Eg(c)) {
+      const b = s ? c[NI.PATH] : l[0], t = s ? c[NI.PATTERN] : c[b];
+      if (!N(t)) throw new Error(pg(b));
+      const Z = {
+        keyId: D(b),
+        pattern: t
+      };
+      return i && (Z.searcher = E(t, g)), Z;
+    }
+    const o = {
+      children: [],
+      operator: l[0]
+    };
+    return l.forEach((b) => {
+      const t = c[b];
+      k(t) && t.forEach((Z) => {
+        o.children.push(C(Z));
+      });
+    }), o;
+  };
+  return rI(I) || (I = TI(I)), C(I);
+}
+function yI(I, { ignoreFieldNorm: g = n.ignoreFieldNorm }) {
+  let i = 1;
+  return I.forEach(({ key: C, norm: c, score: l }) => {
+    const s = C ? C.weight : null;
+    i *= Math.pow(l === 0 && s ? Number.EPSILON : l, (s || 1) * (g ? 1 : c));
+  }), i;
+}
+function Pg(I, { ignoreFieldNorm: g = n.ignoreFieldNorm }) {
+  I.forEach((i) => {
+    i.score = yI(i.matches, { ignoreFieldNorm: g });
+  });
+}
+var _g = 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 i = I - 1 >> 1;
+      if (this.comparator(g[I], g[i]) <= 0) break;
+      const C = g[I];
+      g[I] = g[i], g[i] = C, I = i;
+    }
+  }
+  _sinkDown(I) {
+    const g = this.heap, i = g.length;
+    let C = I;
+    do {
+      I = C;
+      const c = 2 * I + 1, l = 2 * I + 2;
+      if (c < i && this.comparator(g[c], g[C]) > 0 && (C = c), l < i && this.comparator(g[l], g[C]) > 0 && (C = l), C !== I) {
+        const s = g[I];
+        g[I] = g[C], g[C] = s;
+      }
+    } while (C !== I);
+  }
+};
+function qg(I) {
+  const g = [];
+  return I.matches.forEach((i) => {
+    if (!X(i.indices) || !i.indices.length) return;
+    const C = {
+      indices: i.indices,
+      value: i.value
+    };
+    i.key && (C.key = i.key.id), i.idx > -1 && (C.refIndex = i.idx), g.push(C);
+  }), g;
+}
+function $g(I, g, { includeMatches: i = n.includeMatches, includeScore: C = n.includeScore } = {}) {
+  return I.map((c) => {
+    const { idx: l } = c, s = {
+      item: g[l],
+      refIndex: l
+    };
+    return i && (s.matches = qg(c)), C && (s.score = c.score), s;
+  });
+}
+const IC = /[\p{L}\p{M}\p{N}_]+/gu, UI = /* @__PURE__ */ new WeakSet();
+function gC(I) {
+  UI.has(I) || (UI.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 CC(I) {
+  if (typeof I == "function") {
+    let g = !1;
+    return (i) => {
+      const C = I(i);
+      if (!g && (g = !0, !Array.isArray(C) || C.some((c) => typeof c != "string")))
+        throw new Error(`[Fuse] tokenize function must return string[]; received ${Array.isArray(C) ? "array containing non-strings" : typeof C}.`);
+      return C;
+    };
+  }
+  return I instanceof RegExp ? (I.global || gC(I), (g) => g.match(I) || []) : (g) => g.match(IC) || [];
+}
+function XI({ isCaseSensitive: I = !1, ignoreDiacritics: g = !1, tokenize: i } = {}) {
+  const C = CC(i);
+  return { tokenize(c) {
+    return I || (c = c.toLowerCase()), g && (c = L(c)), C(c);
+  } };
+}
+var iC = class {
+  static condition(I, g) {
+    return g.useTokenSearch;
+  }
+  constructor(I, g) {
+    this.options = g, this.analyzer = XI({
+      isCaseSensitive: g.isCaseSensitive,
+      ignoreDiacritics: g.ignoreDiacritics,
+      tokenize: g.tokenize
+    });
+    const i = this.analyzer.tokenize(I), { df: C, fieldCount: c } = g._invertedIndex;
+    this.termSearchers = [], this.idfWeights = [];
+    for (const l of i) {
+      this.termSearchers.push(new kI(l, {
+        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 s = C.get(l) || 0, o = Math.log(1 + (c - s + 0.5) / (s + 0.5));
+      this.idfWeights.push(o);
+    }
+    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 i = 0, C = 0, c = 0, l = 0;
+    const s = this.combineAll && !this.useMask ? /* @__PURE__ */ new Set() : null;
+    for (let t = 0; t < this.termSearchers.length; t++) {
+      const Z = this.termSearchers[t].searchIn(I), e = this.idfWeights[t];
+      C += e, Z.isMatch && (c++, i += e * (1 - Z.score), Z.indices && g.push(...Z.indices), this.combineAll && (this.useMask ? l |= 1 << t : s.add(t)));
+    }
+    if (c === 0) return {
+      isMatch: !1,
+      score: 1
+    };
+    const o = C > 0 ? 1 - i / C : 0, b = {
+      isMatch: !0,
+      score: Math.max(1e-3, o)
+    };
+    return this.options.includeMatches && g.length && (b.indices = wI(g)), this.combineAll && (this.useMask ? b.matchedMask = l : b.matchedTerms = s, b.termCount = this.numTerms), b;
+  }
+};
+function WI(I, g, i, C) {
+  const c = C.tokenize(g);
+  if (!c.length) return;
+  I.fieldCount++, I.docFieldCount.set(i, (I.docFieldCount.get(i) || 0) + 1);
+  const l = new Set(c);
+  let s = I.docTermFieldHits.get(i);
+  s || (s = /* @__PURE__ */ new Map(), I.docTermFieldHits.set(i, s));
+  for (const o of l)
+    s.set(o, (s.get(o) || 0) + 1), I.df.set(o, (I.df.get(o) || 0) + 1);
+}
+function cg(I, g, i, C) {
+  const { i: c, v: l, $: s } = g;
+  if (l !== void 0) {
+    WI(I, l, c, C);
+    return;
+  }
+  if (s)
+    for (let o = 0; o < i; o++) {
+      const b = s[o];
+      if (b)
+        if (Array.isArray(b)) for (const t of b) WI(I, t.v, c, C);
+        else WI(I, b.v, c, C);
+    }
+}
+function cC(I, g, i) {
+  const C = {
+    fieldCount: 0,
+    df: /* @__PURE__ */ new Map(),
+    docFieldCount: /* @__PURE__ */ new Map(),
+    docTermFieldHits: /* @__PURE__ */ new Map()
+  };
+  for (const c of I) cg(C, c, g, i);
+  return C;
+}
+function lC(I, g, i, C) {
+  cg(I, g, i, C);
+}
+function sC(I, g) {
+  const i = I.docFieldCount.get(g);
+  if (i === void 0) return;
+  I.fieldCount -= i, I.docFieldCount.delete(g);
+  const C = I.docTermFieldHits.get(g);
+  if (C) {
+    for (const [c, l] of C) {
+      const s = (I.df.get(c) || 0) - l;
+      s <= 0 ? I.df.delete(c) : I.df.set(c, s);
+    }
+    I.docTermFieldHits.delete(g);
+  }
+}
+function DI(I, g) {
+  if (g.length === 0) return;
+  const i = Array.from(new Set(g)).sort((o, b) => o - b);
+  for (const o of i) sC(I, o);
+  const C = (o) => {
+    let b = 0, t = i.length;
+    for (; b < t; ) {
+      const Z = b + t >>> 1;
+      i[Z] < o ? b = Z + 1 : t = Z;
+    }
+    return o - b;
+  }, c = i[0], l = /* @__PURE__ */ new Map();
+  for (const [o, b] of I.docFieldCount) l.set(o > c ? C(o) : o, b);
+  I.docFieldCount = l;
+  const s = /* @__PURE__ */ new Map();
+  for (const [o, b] of I.docTermFieldHits) s.set(o > c ? C(o) : o, b);
+  I.docTermFieldHits = s;
+}
+var R = class {
+  constructor(I, g, i) {
+    this.options = {
+      ...n,
+      ...g
+    }, this.options.useExtendedSearch, this.options.useTokenSearch, this._keyStore = new yg(this.options.keys), this._docs = I, this._myIndex = null, this._invertedIndex = null, this.setCollection(I, i), 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 HI)) throw new Error(Kg);
+    if (this._myIndex = g || gg(this.options.keys, this._docs, {
+      getFn: this.options.getFn,
+      fieldNormWeight: this.options.fieldNormWeight
+    }), this.options.useTokenSearch) {
+      const i = XI({
+        isCaseSensitive: this.options.isCaseSensitive,
+        ignoreDiacritics: this.options.ignoreDiacritics,
+        tokenize: this.options.tokenize
+      });
+      this._invertedIndex = cC(this._myIndex.records, this._myIndex.keys.length, i);
+    }
+    this._invalidateSearcherCache();
+  }
+  add(I) {
+    if (!X(I)) return;
+    this._docs.push(I);
+    const g = this._myIndex.add(I, this._docs.length - 1);
+    if (this._invertedIndex && g) {
+      const i = XI({
+        isCaseSensitive: this.options.isCaseSensitive,
+        ignoreDiacritics: this.options.ignoreDiacritics,
+        tokenize: this.options.tokenize
+      });
+      lC(this._invertedIndex, g, this._myIndex.keys.length, i);
+    }
+    this._invalidateSearcherCache();
+  }
+  remove(I = () => !1) {
+    const g = [], i = [];
+    for (let C = 0, c = this._docs.length; C < c; C += 1) I(this._docs[C], C) && (g.push(this._docs[C]), i.push(C));
+    if (i.length) {
+      this._invertedIndex && DI(this._invertedIndex, i);
+      const C = new Set(i);
+      this._docs = this._docs.filter((c, l) => !C.has(l)), this._myIndex.removeAll(i), this._invalidateSearcherCache();
+    }
+    return g;
+  }
+  removeAt(I) {
+    if (!Number.isInteger(I) || I < 0 || I >= this._docs.length) throw new Error(pI);
+    this._invertedIndex && DI(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: i = -1 } = g || {}, { includeMatches: C, includeScore: c, shouldSort: l, sortFn: s, ignoreFieldNorm: o } = this.options;
+    if (N(I) && !I.trim()) {
+      let A = this._docs.map((m, h) => ({
+        item: m,
+        refIndex: h
+      }));
+      return U(i) && i > -1 && (A = A.slice(0, i)), A;
+    }
+    const b = l && U(i) && i > 0 && N(I), t = s, Z = (A, m) => t(A, m) || A.idx - m.idx;
+    let e;
+    if (b) {
+      const A = new _g(i, Z);
+      N(this._docs[0]) ? this._searchStringList(I, {
+        heap: A,
+        ignoreFieldNorm: o
+      }) : this._searchObjectList(I, {
+        heap: A,
+        ignoreFieldNorm: o
+      }), e = A.extractSorted();
+    } else
+      e = N(I) ? N(this._docs[0]) ? this._searchStringList(I) : this._searchObjectList(I) : this._searchLogical(I), Pg(e, { ignoreFieldNorm: o }), l && e.sort(N(I) ? Z : t), U(i) && i > -1 && (e = e.slice(0, i));
+    return $g(e, this._docs, {
+      includeMatches: C,
+      includeScore: c
+    });
+  }
+  _searchStringList(I, { heap: g, ignoreFieldNorm: i } = {}) {
+    const C = this._getSearcher(I), c = this.options.useTokenSearch && this.options.tokenMatch === "all", { records: l } = this._myIndex, s = g ? null : [];
+    return l.forEach(({ v: o, i: b, n: t }) => {
+      if (!X(o)) return;
+      const Z = C.searchIn(o);
+      if (Z.isMatch) {
+        const e = {
+          score: Z.score,
+          value: o,
+          norm: t,
+          indices: Z.indices
+        };
+        c && (e.matchedMask = Z.matchedMask, e.matchedTerms = Z.matchedTerms, e.termCount = Z.termCount);
+        const A = [e];
+        if (!c || this._coversAllTokens(A)) {
+          const m = {
+            item: o,
+            idx: b,
+            matches: A
+          };
+          g ? (m.score = yI(m.matches, { ignoreFieldNorm: i }), g.insert(m)) : s.push(m);
+        }
+      }
+    }), s;
+  }
+  _searchLogical(I) {
+    const g = ig(I, this.options), i = this._normalizedKeys(), C = (o, b, t) => {
+      if (!("children" in o)) {
+        const { keyId: m, searcher: h } = o;
+        let W;
+        return m === null ? (W = [], i.forEach((G, r) => {
+          W.push(...this._findMatches({
+            key: G,
+            value: b[r],
+            searcher: h
+          }));
+        })) : W = this._findMatches({
+          key: this._keyStore.get(m),
+          value: this._myIndex.getValueForItemAtKeyId(b, m),
+          searcher: h
+        }), W && W.length ? [{
+          idx: t,
+          item: b,
+          matches: W
+        }] : [];
+      }
+      const { children: Z, operator: e } = o, A = [];
+      for (let m = 0, h = Z.length; m < h; m += 1) {
+        const W = Z[m], G = C(W, b, t);
+        if (G.length) A.push(...G);
+        else if (e === P.AND) return [];
+      }
+      return A;
+    }, c = this._myIndex.records, l = /* @__PURE__ */ new Map(), s = [];
+    return c.forEach(({ $: o, i: b }) => {
+      if (X(o)) {
+        const t = C(g, o, b);
+        t.length && (l.has(b) || (l.set(b, {
+          idx: b,
+          item: o,
+          matches: []
+        }), s.push(l.get(b))), t.forEach(({ matches: Z }) => {
+          l.get(b).matches.push(...Z);
+        }));
+      }
+    }), s;
+  }
+  _searchObjectList(I, { heap: g, ignoreFieldNorm: i } = {}) {
+    const C = this._getSearcher(I), c = this.options.useTokenSearch && this.options.tokenMatch === "all", { records: l } = this._myIndex, s = this._normalizedKeys(), o = g ? null : [];
+    return l.forEach(({ $: b, i: t }) => {
+      if (!X(b)) return;
+      const Z = [];
+      let e = !1, A = !1;
+      if (s.forEach((m, h) => {
+        const W = this._findMatches({
+          key: m,
+          value: b[h],
+          searcher: C
+        });
+        W.length ? (Z.push(...W), W[0].hasInverse && (A = !0)) : e = !0;
+      }), !(A && e) && Z.length && (!c || this._coversAllTokens(Z))) {
+        const m = {
+          idx: t,
+          item: b,
+          matches: Z
+        };
+        g ? (m.score = yI(m.matches, { ignoreFieldNorm: i }), g.insert(m)) : o.push(m);
+      }
+    }), o;
+  }
+  _findMatches({ key: I, value: g, searcher: i }) {
+    if (!X(g)) return [];
+    const C = [];
+    if (k(g)) g.forEach(({ v: c, i: l, n: s }) => {
+      if (!X(c)) return;
+      const o = i.searchIn(c);
+      if (o.isMatch) {
+        const b = {
+          score: o.score,
+          key: I,
+          value: c,
+          idx: l,
+          norm: s,
+          indices: o.indices,
+          hasInverse: o.hasInverse
+        };
+        o.termCount !== void 0 && (b.matchedMask = o.matchedMask, b.matchedTerms = o.matchedTerms, b.termCount = o.termCount), C.push(b);
+      }
+    });
+    else {
+      const { v: c, n: l } = g, s = i.searchIn(c);
+      if (s.isMatch) {
+        const o = {
+          score: s.score,
+          key: I,
+          value: c,
+          norm: l,
+          indices: s.indices,
+          hasInverse: s.hasInverse
+        };
+        s.termCount !== void 0 && (o.matchedMask = s.matchedMask, o.matchedTerms = s.matchedTerms, o.termCount = s.termCount), C.push(o);
+      }
+    }
+    return C;
+  }
+  _coversAllTokens(I) {
+    const g = I.length ? I[0].termCount : void 0;
+    if (g === void 0) return !0;
+    if (g <= 31) {
+      let C = 0;
+      for (let c = 0; c < I.length; c++) C |= I[c].matchedMask || 0;
+      return C === 2 ** g - 1;
+    }
+    const i = /* @__PURE__ */ new Set();
+    for (let C = 0; C < I.length; C++) {
+      const c = I[C].matchedTerms;
+      if (c) for (const l of c) i.add(l);
+    }
+    return i.size === g;
+  }
+};
+R.version = "7.5.0";
+R.createIndex = gg;
+R.parseIndex = Jg;
+R.config = n;
+R.match = function(I, g, i) {
+  if (i && i.useTokenSearch) throw new Error(rg);
+  return E(I, {
+    ...n,
+    ...i
+  }).searchIn(g);
+};
+R.parseQuery = ig;
+RI(Og);
+RI(iC);
+R.use = function(...I) {
+  I.forEach((g) => RI(g));
+};
+var nI = R;
+function lg(I, g, i) {
+  return `${Math.round(I / 1e3)}k #${g} Top ${vI(I, i)}%`;
+}
+function vI(I, g) {
+  if (!g.length) return 100;
+  const i = g.filter((C) => C > I).length;
+  return Math.min(100, Math.max(1, Math.ceil(i / g.length * 100)));
+}
+function JI(I) {
+  const g = K(I.cache, "cpu");
+  if (g) return g;
+  let i = "";
+  if (J) {
+    try {
+      const c = B("wmic cpu get name /format:list").match(/Name=(.+)/);
+      c && (i = c[1].trim());
+    } catch {
+    }
+    if (!i)
+      try {
+        const C = B(
+          'powershell.exe -Command "Get-WmiObject -Class Win32_Processor | Select-Object -ExpandProperty Name"'
+        );
+        C.trim() && (i = C.trim());
+      } catch {
+      }
+  } else if (p) {
+    try {
+      const c = B("lscpu").match(/Model name:\s*([^\n,]+)/);
+      c && (i = c[1].trim());
+    } catch {
+    }
+    if (!i)
+      try {
+        const C = a.readFileSync("/proc/cpuinfo", "utf8"), c = C.match(/model name\s*:\s*([^\n]+)/), l = C.match(/Hardware\s*:\s*([^\n]+)/);
+        c ? i = c[1].trim() : l && (i = l[1].trim());
+      } catch {
+      }
+  } else {
+    const C = u.cpus();
+    C.length > 0 && (i = C[0].model.trim().replace(/[\r\n]+/g, " "));
+  }
+  return i ? (i = i.trim().replace(/with .*/, "").trim(), d(I.cache, "cpu", i), i) : (d(I.cache, "cpu", ""), "");
+}
+function FI(I) {
+  const g = K(I.cache, "gpu");
+  if (g !== null) return g;
+  if (J) {
+    const i = [];
+    try {
+      const c = B(
+        "wmic path win32_VideoController get name /format:list"
+      ).matchAll(/Name=(.+)/g);
+      for (const l of c) {
+        const s = l[1].trim();
+        s && !s.includes("Microsoft Basic") && i.push(s);
+      }
+    } catch {
+    }
+    if (i.length === 0)
+      try {
+        const C = B(
+          `powershell.exe -Command "Get-WmiObject -Class Win32_VideoController | Where-Object {$_.Name -notlike '*Microsoft Basic*'} | Select-Object -ExpandProperty Name"`
+        );
+        if (C.trim())
+          for (const c of C.trim().split(/\r?\n/)) {
+            const l = c.trim();
+            l && !l.includes("Microsoft Basic") && i.push(l);
+          }
+      } catch {
+      }
+    if (i.length > 0) {
+      const C = i.join(", ");
+      return d(I.cache, "gpu", C), C;
+    }
+  } else if (V)
+    try {
+      const i = B("system_profiler SPDisplaysDataType"), C = Array.from(i.matchAll(/Chipset Model:\s*(.+)/g)).map(
+        (c) => c[1].trim()
+      );
+      if (C.length > 0) {
+        const c = C.join(", ");
+        return d(I.cache, "gpu", c), c;
+      }
+    } catch {
+    }
+  else if (p)
+    try {
+      const i = B("lspci"), C = [], c = /(?:VGA compatible controller|3D controller|Display controller)/i, l = /(?:NVIDIA|GeForce|RTX|GTX|Quadro|Tesla|AMD|ATI|Radeon|Navi|Vega|RX|Intel.*(?:Arc|UHD|Iris|HD Graphics))/i;
+      for (const s of i.split(`
+`)) {
+        if (!c.test(s) || !l.test(s)) continue;
+        let o;
+        const b = s.match(/\[([^\]]+)\]/g);
+        b && b.length > 0 ? o = b[b.length - 1].replace(/^\[|\]$/g, "") : o = s.replace(/^.*(?:VGA compatible controller|3D controller|Display controller):\s*/i, "").replace(/\s*\(rev [a-f0-9]+\)\s*$/i, "").trim(), o && !C.includes(o) && C.push(o);
+      }
+      if (C.length > 0) {
+        const s = C.join(", ");
+        return d(I.cache, "gpu", s), s;
+      }
+    } catch {
+    }
+  return d(I.cache, "gpu", ""), "";
+}
+function oC() {
+  if (V) {
+    try {
+      const g = B("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 = B("xrandr").match(/(\d+x\d+)\+\d+\+\d+/);
+      if (g)
+        return g[1];
+    }
+  } catch {
+  }
+  return "";
+}
+function bC(I) {
+  const g = K(I.cache, "bench");
+  if (g) return g;
+  const i = JI(I);
+  if (!i)
+    return d(I.cache, "bench", ""), "";
+  try {
+    let C;
+    const c = "cpu-geekbench.json";
+    if (a.existsSync(c))
+      C = c;
+    else if (a.existsSync(`src/bench/${c}`))
+      C = `src/bench/${c}`;
+    else if (a.existsSync(`./bench/${c}`))
+      C = `./bench/${c}`;
+    else
+      try {
+        const e = new URL((/* @__PURE__ */ Object.assign({ "./hardware-bench.test.ts": _, "./hardware-probes.test.ts": q, "./hardware.test.ts": $, "./memory.test.ts": II, "./memory.ts": gI, "./network.test.ts": CI, "./network.ts": iI, "./platform-os.test.ts": cI, "./platform.test.ts": lI, "./platform.ts": sI, "./process.test.ts": oI, "./process.ts": bI, "./settings.test.ts": eI, "./settings.ts": ZI, "./software.test.ts": tI, "./software.ts": AI, "./system-status.test.ts": dI, "./system-status.ts": mI }))[`./${c}`], import.meta.url);
+        C = e.pathname, a.existsSync(C) || (C = e.pathname.substring(0, e.pathname.lastIndexOf("/")) + `/${c}`);
+      } catch {
+        C = c;
+      }
+    const l = a.readFileSync(C, "utf8"), o = JSON.parse(l).scores, b = o.map((e) => ({ name: e[0], score: e[1], rank: e[2] })), Z = new nI(b, {
+      keys: ["name"],
+      threshold: 0.6,
+      minMatchCharLength: 3
+    }).search(i);
+    if (Z.length > 0) {
+      const e = Z[0].item, A = lg(e.score, e.rank, o.map((m) => m[1]));
+      return d(I.cache, "bench", A), A;
+    }
+  } catch {
+  }
+  return d(I.cache, "bench", ""), "";
+}
+function eC(I) {
+  const g = K(I.cache, "cpu_bench_info");
+  if (g) return g;
+  const i = JI(I);
+  if (!i)
+    return d(I.cache, "cpu_bench_info", ""), "";
+  try {
+    let C;
+    const c = "cpu-geekbench.json";
+    if (a.existsSync(c))
+      C = c;
+    else if (a.existsSync(`src/bench/${c}`))
+      C = `src/bench/${c}`;
+    else if (a.existsSync(`./bench/${c}`))
+      C = `./bench/${c}`;
+    else
+      try {
+        const e = new URL((/* @__PURE__ */ Object.assign({ "./hardware-bench.test.ts": _, "./hardware-probes.test.ts": q, "./hardware.test.ts": $, "./memory.test.ts": II, "./memory.ts": gI, "./network.test.ts": CI, "./network.ts": iI, "./platform-os.test.ts": cI, "./platform.test.ts": lI, "./platform.ts": sI, "./process.test.ts": oI, "./process.ts": bI, "./settings.test.ts": eI, "./settings.ts": ZI, "./software.test.ts": tI, "./software.ts": AI, "./system-status.test.ts": dI, "./system-status.ts": mI }))[`./${c}`], import.meta.url);
+        C = e.pathname, a.existsSync(C) || (C = e.pathname.substring(0, e.pathname.lastIndexOf("/")) + `/${c}`);
+      } catch {
+        C = c;
+      }
+    const l = a.readFileSync(C, "utf8"), o = JSON.parse(l).scores, b = o.map((e) => ({
+      name: e[0],
+      score: e[1],
+      rank: e[2]
+    })), Z = new nI(b, {
+      keys: ["name"],
+      threshold: 0.6,
+      minMatchCharLength: 3
+    }).search(i);
+    if (Z.length > 0) {
+      const e = Z[0].item, A = Math.round(e.score / 1e3), m = e.rank, h = vI(e.score, o.map((r) => r[1]));
+      let W = "Unknown";
+      e.name.includes("Apple") || e.name.includes("ARM") ? W = "ARM" : e.name.includes("Intel") ? W = "Intel" : e.name.includes("AMD") || e.name.includes("Ryzen") || e.name.includes("EPYC") ? W = "AMD" : e.name.includes("Qualcomm") && (W = "ARM");
+      const G = `Geekbench 6: ${A}k (Rank #${m}, Top ${h}%) - ${W}`;
+      return d(I.cache, "cpu_bench_info", G), G;
+    }
+  } catch {
+  }
+  return d(I.cache, "cpu_bench_info", ""), "";
+}
+function ZC(I) {
+  const g = K(I.cache, "gpu_bench");
+  if (g) return g;
+  const i = FI(I);
+  if (!i)
+    return d(I.cache, "gpu_bench", ""), "";
+  try {
+    let C;
+    const c = "gpu-geekbench.json";
+    if (a.existsSync(c))
+      C = c;
+    else if (a.existsSync(`src/bench/${c}`))
+      C = `src/bench/${c}`;
+    else if (a.existsSync(`./bench/${c}`))
+      C = `./bench/${c}`;
+    else
+      try {
+        const e = new URL((/* @__PURE__ */ Object.assign({ "./hardware-bench.test.ts": _, "./hardware-probes.test.ts": q, "./hardware.test.ts": $, "./memory.test.ts": II, "./memory.ts": gI, "./network.test.ts": CI, "./network.ts": iI, "./platform-os.test.ts": cI, "./platform.test.ts": lI, "./platform.ts": sI, "./process.test.ts": oI, "./process.ts": bI, "./settings.test.ts": eI, "./settings.ts": ZI, "./software.test.ts": tI, "./software.ts": AI, "./system-status.test.ts": dI, "./system-status.ts": mI }))[`./${c}`], import.meta.url);
+        C = e.pathname, a.existsSync(C) || (C = e.pathname.substring(0, e.pathname.lastIndexOf("/")) + `/${c}`);
+      } catch {
+        C = c;
+      }
+    const l = a.readFileSync(C, "utf8"), o = JSON.parse(l).scores, b = o.map((e) => ({ name: e[0], score: e[1], rank: e[2] })), Z = new nI(b, {
+      keys: ["name"],
+      threshold: 0.6,
+      minMatchCharLength: 3
+    }).search(i);
+    if (Z.length > 0) {
+      const e = Z[0].item, A = lg(e.score, e.rank, o.map((m) => m[1]));
+      return d(I.cache, "gpu_bench", A), A;
+    }
+  } catch {
+  }
+  return d(I.cache, "gpu_bench", ""), "";
+}
+function tC(I) {
+  const g = K(I.cache, "gpu_bench_info");
+  if (g) return g;
+  const i = FI(I);
+  if (!i)
+    return d(I.cache, "gpu_bench_info", ""), "";
+  try {
+    let C;
+    const c = "gpu-geekbench.json";
+    if (a.existsSync(c))
+      C = c;
+    else if (a.existsSync(`src/bench/${c}`))
+      C = `src/bench/${c}`;
+    else if (a.existsSync(`./bench/${c}`))
+      C = `./bench/${c}`;
+    else
+      try {
+        const e = new URL((/* @__PURE__ */ Object.assign({ "./hardware-bench.test.ts": _, "./hardware-probes.test.ts": q, "./hardware.test.ts": $, "./memory.test.ts": II, "./memory.ts": gI, "./network.test.ts": CI, "./network.ts": iI, "./platform-os.test.ts": cI, "./platform.test.ts": lI, "./platform.ts": sI, "./process.test.ts": oI, "./process.ts": bI, "./settings.test.ts": eI, "./settings.ts": ZI, "./software.test.ts": tI, "./software.ts": AI, "./system-status.test.ts": dI, "./system-status.ts": mI }))[`./${c}`], import.meta.url);
+        C = e.pathname, a.existsSync(C) || (C = e.pathname.substring(0, e.pathname.lastIndexOf("/")) + `/${c}`);
+      } catch {
+        C = c;
+      }
+    const l = a.readFileSync(C, "utf8"), o = JSON.parse(l).scores, b = o.map((e) => ({
+      name: e[0],
+      score: e[1],
+      rank: e[2]
+    })), Z = new nI(b, {
+      keys: ["name"],
+      threshold: 0.6,
+      minMatchCharLength: 3
+    }).search(i);
+    if (Z.length > 0) {
+      const e = Z[0].item, A = Math.round(e.score / 1e3), m = e.rank, h = vI(e.score, o.map((w) => w[1]));
+      let W = "Unknown";
+      const G = e.name.toUpperCase();
+      G.includes("NVIDIA") || G.includes("GEFORCE") || G.includes("RTX") || G.includes("GTX") || G.includes("QUADRO") || G.includes("TESL") || G.includes("B200") || G.includes("H100") || G.includes("A100") || G.includes("A40") || G.includes("L40") || G.includes("L20") ? W = "NVIDIA" : G.includes("AMD") || G.includes("RADEON") || G.includes("RX ") || G.includes("HD") || G.includes("EPYC") || G.includes("INSTINCT") || G.includes("NAVI") || G.includes("VEGA") ? W = "AMD" : (G.includes("INTEL") || G.includes("ARC") || G.includes("UHD") || G.includes("IRIS") || G.includes("HD GRAPHICS")) && (W = "Intel");
+      const r = `Geekbench 6: ${A}k (Rank #${m}, Top ${h}%) - ${W}`;
+      return d(I.cache, "gpu_bench_info", r), r;
+    }
+  } catch {
+  }
+  return d(I.cache, "gpu_bench_info", ""), "";
+}
+function AC(I) {
+  const g = K(I.cache, "ram_used");
+  if (g) return g;
+  if (p)
+    try {
+      const b = a.readFileSync("/proc/meminfo", "utf8"), t = b.match(/MemTotal:\s+(\d+) kB/), Z = b.match(/MemFree:\s+(\d+) kB/);
+      if (t && Z) {
+        const e = Math.round(parseInt(t[1]) / 1024), A = Math.round(parseInt(Z[1]) / 1024), m = e - A, h = Math.round(e / 1024), G = `${Math.round(m / 1024)}/${h}GB`;
+        return d(I.cache, "ram_used", G), G;
+      }
+    } catch {
+    }
+  const i = u.totalmem(), C = u.freemem(), c = i - C, l = Math.round(i / (1024 * 1024 * 1024)), o = `${Math.round(c / (1024 * 1024 * 1024))}/${l}GB`;
+  return d(I.cache, "ram_used", o), o;
+}
+function dC() {
+  if (p) {
+    try {
+      const g = a.readFileSync("/proc/meminfo", "utf8").match(/MemAvailable:\s+(\d+) kB/);
+      if (g)
+        return `${Math.round(parseInt(g[1]) / 1024 / 1024)}GB available`;
+    } catch {
+    }
+    return "";
+  }
+  if (V) {
+    try {
+      const I = B("vm_stat"), g = I.match(/page size of (\d+) bytes/), i = I.match(/Pages free:\s+(\d+)\./), C = I.match(/Pages inactive:\s+(\d+)\./);
+      if (g && i && C) {
+        const c = parseInt(g[1]), l = parseInt(i[1]) + parseInt(C[1]);
+        return `${Math.round(l * c / (1024 * 1024 * 1024))}GB available`;
+      }
+    } catch {
+    }
+    return "";
+  }
+  return "";
+}
+function mC() {
+  if (p) {
+    try {
+      const I = a.readFileSync("/proc/meminfo", "utf8"), g = I.match(/SwapTotal:\s+(\d+) kB/), i = I.match(/SwapFree:\s+(\d+) kB/);
+      if (g && i) {
+        const C = parseInt(g[1]), c = parseInt(i[1]), l = C - c;
+        if (C > 0) {
+          const s = Math.round(l / C * 100), o = Math.round(l / 1024);
+          return `${s}% (${o}MB) swap`;
+        }
+      }
+    } catch {
+    }
+    return "";
+  }
+  if (V) {
+    try {
+      const g = B("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 i = parseFloat(g[1]), C = parseFloat(g[2]);
+        return i > 0 ? `${Math.round(C / i * 100)}% (${Math.round(C)}MB) swap` : "0% (0MB) swap";
+      }
+    } catch {
+    }
+    return "";
+  }
+  return "";
+}
+function nC(I) {
+  const g = K(I.cache, "disk_used");
+  if (g !== null) return g;
+  if (p || V)
+    try {
+      const i = B("df -h");
+      let C = "";
+      if (i.includes("/storage/emulated")) {
+        const c = i.match(/\s+(\d+%)\s+\/storage\/emulated/);
+        C = c ? c[1] : "";
+      } else {
+        const c = i.split(`
+`);
+        for (const l of c)
+          if (l.trim().endsWith(" /")) {
+            const s = l.trim().split(/\s+/), o = s.findIndex((b) => b.includes("%"));
+            if (o !== -1) {
+              C = s[o];
+              break;
+            }
+          }
+        if (!C) {
+          const l = i.match(/(\d+%)\s+\/\s*$/m);
+          C = l ? l[1] : "";
+        }
+      }
+      return d(I.cache, "disk_used", C), C;
+    } catch {
+    }
+  return d(I.cache, "disk_used", ""), "";
+}
+const GC = 10 * 1024 * 1024;
+function aC(I) {
+  const g = K(I.cache, "disk_size");
+  if (g !== null) return g;
+  if (!p && !V)
+    return d(I.cache, "disk_size", ""), "";
+  try {
+    const C = B("df -k").trim().split(`
+`).slice(1), c = [];
+    for (const s of C) {
+      const o = s.trim().split(/\s+/);
+      if (o.length < 6) continue;
+      const b = o[0], t = parseInt(o[1]), Z = parseInt(o[2]), e = o[o.length - 1];
+      if (!(isNaN(t) || isNaN(Z) || t < GC)) {
+        if (V) {
+          if (e !== "/" && !e.startsWith("/Volumes/")) continue;
+        } else if (b.startsWith("devtmpfs") || b.startsWith("tmpfs") || b === "overlay" || e.startsWith("/boot") || e.startsWith("/dev") || e.startsWith("/proc") || e.startsWith("/sys") || e.startsWith("/run"))
+          continue;
+        c.push({
+          mount: e,
+          usedGB: Math.round(Z / (1024 * 1024)),
+          totalGB: Math.round(t / (1024 * 1024))
+        });
+      }
+    }
+    let l = "";
+    return c.length === 1 ? l = `${c[0].usedGB}/${c[0].totalGB}GB` : c.length > 1 && (l = c.map((s) => `${s.mount}(${s.usedGB}/${s.totalGB}GB)`).join(" ")), d(I.cache, "disk_size", l), l;
+  } catch {
+  }
+  return d(I.cache, "disk_size", ""), "";
+}
+function hC(I) {
+  const g = K(I.cache, "mount_points");
+  if (g !== null) return g;
+  if (!p && !V)
+    return d(I.cache, "mount_points", ""), "";
+  try {
+    const C = B("df -h").split(`
+`).slice(1), c = [];
+    C.forEach((s) => {
+      const o = s.trim().split(/\s+/);
+      if (o.length < 2) return;
+      const b = o[o.length - 1], t = o.find((Z) => /^\d+%$/.test(Z)) || "";
+      if (t) {
+        if (V) {
+          b.startsWith("/Volumes/") && b !== "/" && c.push(`${b}(${t})`);
+          return;
+        }
+        !b.startsWith("/dev") && !b.startsWith("/proc") && !b.startsWith("/sys") && !b.startsWith("/System/Volumes") && b !== "/" && c.push(`${b}(${t})`);
+      }
+    });
+    const l = c.slice(0, 3).join(" ");
+    return d(I.cache, "mount_points", l), l;
+  } catch {
+  }
+  return d(I.cache, "mount_points", ""), "";
+}
+function WC(I) {
+  const g = K(I.cache, "top_process");
+  if (g !== null) return g;
+  if (p)
+    try {
+      const C = B("ps -eo pcpu,comm --sort=-%cpu --no-headers").split(`
+`);
+      if (C.length > 0) {
+        const c = C[0].trim().replace(/\s+/, " ").split(" "), l = c[0].replace(/\.\d+/, ""), s = c[1].split("/").pop(), o = `${l}% ${s}`;
+        return d(I.cache, "top_process", o), o;
+      }
+    } catch {
+    }
+  else if (V)
+    try {
+      const C = B("ps -Aceo pcpu,comm -r").split(`
+`).filter((c) => c.trim());
+      if (C.length > 1) {
+        const c = C[1].trim().split(/\s+/), l = Math.round(parseFloat(c[0])), s = c.slice(1).join(" ");
+        if (!isNaN(l) && s) {
+          const o = `${l}% ${s}`;
+          return d(I.cache, "top_process", o), o;
+        }
+      }
+    } catch {
+    }
+  return d(I.cache, "top_process", ""), "";
+}
+function BC() {
+  const I = u.uptime(), g = Math.floor(I / 86400), i = Math.floor(I % 86400 / 3600), C = Math.floor(I % 3600 / 60);
+  return `${g}d ${i}h ${C}m`;
+}
+function uC() {
+  if (!p && !V) return "";
+  try {
+    const g = B("who").split(`
+`).filter((i) => i.trim()).length;
+    if (g > 0)
+      return `${g} users`;
+  } catch {
+  }
+  return "";
+}
+function KC(I) {
+  return I.ipInfo?.ip || "";
+}
+function pC() {
+  if (p) {
+    try {
+      const C = B("ifconfig 2>/dev/null").match(
+        /wlan0[\s\S]*?inet (\d+\.\d+\.\d+\.\d+)/
+      );
+      if (C)
+        return C[1];
+    } catch {
+    }
+    try {
+      const i = B("ip addr show 2>/dev/null"), C = [], c = i.matchAll(/inet (\d+\.\d+\.\d+\.\d+)\/\d+/g);
+      for (const l of c)
+        l[1].startsWith("127.") || C.push(l[1]);
+      if (C.length > 0)
+        return C.join(" ");
+    } catch {
+    }
+  }
+  const I = u.networkInterfaces(), g = [];
+  for (const i of Object.keys(I))
+    for (const C of I[i] || [])
+      C.family === "IPv4" && !C.internal && g.push(C.address);
+  return g.join(" ");
+}
+function VC(I) {
+  return I.ipInfo?.city || "";
+}
+function YC(I) {
+  const g = I.ipInfo?.hostname;
+  return g ? `http://${g}` : "";
+}
+function NC(I) {
+  const g = I.ipInfo?.org;
+  return g ? g.split(" ").slice(1).join(" ") : "";
+}
+function rC(I) {
+  const g = K(I.cache, "network_interfaces");
+  if (g !== null) return g;
+  if (!p && !V)
+    return d(I.cache, "network_interfaces", ""), "";
+  try {
+    const i = u.networkInterfaces(), C = [];
+    for (const [l, s] of Object.entries(i))
+      l !== "lo" && s?.find(
+        (b) => b.family === "IPv4" && !b.internal
+      ) && C.push(l);
+    const c = C.join(" ");
+    return d(I.cache, "network_interfaces", c), c;
+  } catch {
+  }
+  return d(I.cache, "network_interfaces", ""), "";
+}
+function yC(I) {
+  const g = K(I.cache, "ports");
+  if (g !== null) return g;
+  if (p || V)
+    try {
+      const C = B("lsof -nP -iTCP -sTCP:LISTEN").split(`
+`).slice(1), c = /* @__PURE__ */ new Set();
+      C.forEach((s) => {
+        const o = s.split(/\s+/);
+        if (o.length >= 9) {
+          const t = o[8].match(/:(\d+)$/);
+          if (t) {
+            const Z = t[1], e = o[0].substring(0, 4);
+            c.add(`${Z}${e}`);
+          }
+        }
+      });
+      const l = Array.from(c).join(" ");
+      return d(I.cache, "ports", l), l;
+    } catch {
+    }
+  return d(I.cache, "ports", ""), "";
+}
+function XC(I) {
+  if (V)
+    return u.loadavg().map((g) => g.toFixed(2)).join(" ");
+  if (!p) return "";
+  try {
+    return a.readFileSync("/proc/loadavg", "utf8").split(" ").slice(0, 3).join(" ");
+  } catch {
+  }
+  return "";
+}
+function SC(I) {
+  const g = K(I.cache, "battery");
+  if (g !== null) return g;
+  if (V) {
+    try {
+      const i = B("pmset -g batt"), C = i.match(/(\d+)%/);
+      if (C) {
+        const c = /;\s*(charging|charged);/i.test(i), l = `${C[1]}%${c ? "+" : ""}`;
+        return d(I.cache, "battery", l), l;
+      }
+    } catch {
+    }
+    return d(I.cache, "battery", ""), "";
+  }
+  if (!p)
+    return d(I.cache, "battery", ""), "";
+  try {
+    const i = "/sys/class/power_supply/BAT0", C = `${i}/capacity`, c = `${i}/status`;
+    if (a.existsSync(C)) {
+      const l = a.readFileSync(C, "utf8").trim(), s = a.existsSync(c) ? a.readFileSync(c, "utf8").trim() : "Unknown", t = `${parseInt(l)}%${s === "Charging" ? "+" : ""}`;
+      return d(I.cache, "battery", t), t;
+    }
+  } catch {
+  }
+  return d(I.cache, "battery", ""), "";
+}
+function HC(I) {
+  const g = K(I.cache, "temperature");
+  if (g !== null) return g;
+  if (V) {
+    if (j("osx-cpu-temp"))
+      try {
+        const C = B("osx-cpu-temp").match(/([\d.]+)\s*°?C/);
+        if (C) {
+          const c = Math.round(parseFloat(C[1]));
+          if (c > 0 && c < 150) {
+            const l = `${c}°C`;
+            return d(I.cache, "temperature", l), l;
+          }
+        }
+      } catch {
+      }
+    return d(I.cache, "temperature", ""), "";
+  }
+  if (!p)
+    return d(I.cache, "temperature", ""), "";
+  try {
+    const i = [
+      "/sys/class/thermal/thermal_zone0/temp",
+      "/sys/class/hwmon/hwmon0/temp1_input",
+      "/sys/class/hwmon/hwmon1/temp1_input"
+    ];
+    for (const C of i)
+      if (a.existsSync(C)) {
+        const c = a.readFileSync(C, "utf8").trim(), l = Math.round(parseInt(c) / 1e3);
+        if (l > 0 && l < 150) {
+          const s = `${l}°C`;
+          return d(I.cache, "temperature", s), s;
+        }
+      }
+  } catch {
+  }
+  return d(I.cache, "temperature", ""), "";
+}
+function wC(I) {
+  const g = K(I.cache, "services_running");
+  if (g !== null) return g;
+  if (V) {
+    try {
+      const C = B("launchctl list").split(`
+`).filter((c) => c.trim() && !c.startsWith("PID")).length;
+      if (C > 0) {
+        const c = `${C} services`;
+        return d(I.cache, "services_running", c), c;
+      }
+    } catch {
+    }
+    return d(I.cache, "services_running", ""), "";
+  }
+  if (!p)
+    return d(I.cache, "services_running", ""), "";
+  try {
+    let i = 0;
+    if (j("systemctl") ? i = B(
+      "systemctl list-units --type=service --state=running --no-pager"
+    ).split(`
+`).filter((c) => c.includes(".service")).length : j("service") && (i = B("service --status-all").split(`
+`).filter((c) => c.includes("+")).length), i > 0) {
+      const C = `${i} services`;
+      return d(I.cache, "services_running", C), C;
+    }
+  } catch {
+  }
+  return d(I.cache, "services_running", ""), "";
+}
+function kC(I) {
+  const g = K(I.cache, "shell");
+  if (g !== null) return g;
+  if (!J) {
+    try {
+      const i = u.userInfo().shell;
+      if (i) {
+        const C = i.split("/").pop();
+        return d(I.cache, "shell", C), C;
+      }
+    } catch {
+    }
+    try {
+      const i = _I.ppid, C = B(`ps -p ${i} -o comm=`).split("/").pop();
+      if (C)
+        return d(I.cache, "shell", C), C;
+    } catch {
+    }
+  }
+  return d(I.cache, "shell", ""), "";
+}
+function RC(I) {
+  const g = K(I.cache, "packages");
+  if (g !== null) return g;
+  const c = [
+    "apt",
+    "brew",
+    "npm",
+    "uv",
+    "docker",
+    "hx",
+    "nvim",
+    "bun",
+    "yay",
+    "pacman",
+    "yum",
+    "dnf",
+    "zypper",
+    "emerge",
+    "apk",
+    "snap",
+    "flatpak"
+  ].filter((l) => j(l)).join(" ");
+  return d(I.cache, "packages", c), c;
+}
+function vC(I) {
+  const g = K(I.cache, "containers");
+  if (g !== null) return g;
+  if (!j("docker"))
+    return d(I.cache, "containers", ""), "";
+  try {
+    if (B("docker ps -q").split(`
+`).filter((o) => o.trim()).length === 0)
+      return d(I.cache, "containers", ""), "";
+    const c = B(
+      'docker ps --format "{{.Names}}	{{.Ports}}"'
+    ).split(`
+`).filter((o) => o.trim()), l = [];
+    c.forEach((o) => {
+      const [b, t] = o.split("	");
+      if (b && (l.push(b), t)) {
+        const Z = t.match(/->(\d+(-\d+)?)\//g);
+        if (Z) {
+          const e = [
+            ...new Set(
+              Z.map((A) => A.replace(/^->(\d+(-\d+)?)\/$/, "$1"))
+            )
+          ];
+          l.push(...e);
+        }
+      }
+    });
+    const s = l.join(" ");
+    return d(I.cache, "containers", s), s;
+  } catch {
+  }
+  return d(I.cache, "containers", ""), "";
+}
+const JC = u.platform() === "win32", FC = u.platform() === "darwin", jC = u.platform() === "linux";
+function zC() {
+  try {
+    if (a.existsSync(x))
+      return JSON.parse(a.readFileSync(x, "utf8"));
+  } catch {
+  }
+  return {};
+}
+function LC(I) {
+  try {
+    const g = M.dirname(x);
+    a.existsSync(g) || a.mkdirSync(g, { recursive: !0 }), a.writeFileSync(x, JSON.stringify(I, null, 2));
+  } catch {
+  }
+}
+const OI = {
+  user: mg,
+  hostname: ng,
+  ip: KC,
+  iplocal: pC,
+  city: VC,
+  domain: YC,
+  isp: NC,
+  os: Gg,
+  // Mapped from os_info
+  cpu: JI,
+  gpu: FI,
+  bench: bC,
+  cpu_bench_info: eC,
+  gpu_bench: ZC,
+  gpu_bench_info: tC,
+  disk_used: nC,
+  disk_size: aC,
+  ram_used: AC,
+  top_process: WC,
+  uptime: BC,
+  device: hg,
+  kernel: ag,
+  shell: kC,
+  pacman: RC,
+  // Mapped from packages
+  ports: yC,
+  containers: vC,
+  memory_available: dC,
+  swap_used: mC,
+  load_average: XC,
+  users_logged_in: uC,
+  network_interfaces: rC,
+  mount_points: hC,
+  services_running: wC,
+  temperature: HC,
+  battery: SC,
+  screen_resolution: oC
+}, BI = /* @__PURE__ */ new Set(["ip", "city", "domain", "isp"]), MC = () => new Promise((I) => setImmediate(I));
+async function QC(I, g) {
+  const i = I.ipInfo;
+  if (i && PI(i, "ipInfo")) return i.value || {};
+  const C = await dg(void 0, void 0, g), c = C.ip ? C : i?.value || {};
+  return g?.aborted || (I.ipInfo = { value: c, timestamp: Date.now() }), c;
+}
+async function $C(I = {}) {
+  const { keys: g, signal: i } = I, C = zC(), c = { cache: C }, l = Object.keys(OI).filter(
+    (Z) => !g || g.includes(Z)
+  ), s = l.some((Z) => BI.has(Z)) ? QC(C, i) : void 0, o = {}, b = async (Z) => {
+    try {
+      o[Z] = await OI[Z](c);
+    } catch {
+      o[Z] = "";
+    }
+  };
+  for (const Z of l)
+    if (!BI.has(Z)) {
+      if (await MC(), i?.aborted) break;
+      await b(Z);
+    }
+  if (s) {
+    c.ipInfo = await s;
+    for (const Z of l)
+      BI.has(Z) && await b(Z);
+  }
+  const t = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    platform: JC ? "windows" : FC ? "macos" : jC ? "linux" : "unknown"
+  };
+  for (const Z of l)
+    Z in o && (t[Z] = o[Z]);
+  return LC(C), t;
+}
+export {
+  x as C,
+  zI as D,
+  O as S,
+  _C as a,
+  qC as b,
+  EC as c,
+  PC as d,
+  $C as g,
+  OI as i,
+  zC as l,
+  LC as s
+};
+//# sourceMappingURL=system-info-api-fNqdECMN.js.map