@zenbu-labs/pixel 0.0.0 → 0.0.13

package/dist/terminal/terminals/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TERMINALS = void 0;
+const cmux_1 = require("./cmux");
+const ghostty_1 = require("./ghostty");
+const herdr_1 = require("./herdr");
+const kitty_1 = require("./kitty");
+const supacode_1 = require("./supacode");
+const tmux_1 = require("./tmux");
+const tty7_1 = require("./tty7");
+const vscode_1 = require("./vscode");
+const wezterm_1 = require("./wezterm");
+/**
+ * not fantastic, but ordering does matter
+ */
+exports.TERMINALS = [
+    herdr_1.herdr,
+    tmux_1.tmux,
+    tty7_1.tty7,
+    wezterm_1.wezterm,
+    kitty_1.kitty,
+    cmux_1.cmux,
+    supacode_1.supacode,
+    ghostty_1.ghostty,
+    vscode_1.vscode,
+];

package/dist/terminal/terminals/kitty.d.ts

@@ -0,0 +1,2 @@
+import type { Detect } from "../terminal";
+export declare const kitty: Detect;

package/dist/terminal/terminals/kitty.js

@@ -0,0 +1,209 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kitty = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const shared_1 = require("../shared");
+// todo: do this automatically
+const SETUP_HINT = [
+    "kitty has remote control switched off, which is required for this feature",
+    "Add these two lines to kitty.conf (usually ~/.config/kitty/kitty.conf), then fully quit and reopen kitty:",
+    "  allow_remote_control socket-only",
+    "  listen_on unix:/tmp/kitty",
+].join("\n");
+const GRID = 10000;
+function pairRects(tab) {
+    const pairs = tab.layout_state?.pairs;
+    if (tab.layout !== "splits" || !pairs)
+        return [];
+    const groups = new Map((tab.groups ?? []).map((group) => [group.id, group.windows[0]]));
+    const windowIds = new Set(tab.windows.map((window) => window.id));
+    const rects = [];
+    const walk = (node, left, top, width, height) => {
+        if (node === undefined)
+            return;
+        if (typeof node === "number") {
+            const id = windowIds.has(node) ? node : groups.get(node);
+            if (id !== undefined)
+                rects.push({ id: String(id), left, top, right: left + width - 1, bottom: top + height - 1 });
+            return;
+        }
+        const bias = node.bias ?? 0.5;
+        if (node.one === undefined || node.two === undefined) {
+            walk(node.one ?? node.two, left, top, width, height);
+            return;
+        }
+        if (node.horizontal ?? true) {
+            const first = Math.round(width * bias);
+            walk(node.one, left, top, first, height);
+            walk(node.two, left + first, top, width - first, height);
+        }
+        else {
+            const first = Math.round(height * bias);
+            walk(node.one, left, top, width, first);
+            walk(node.two, left, top + first, width, height - first);
+        }
+    };
+    walk(pairs, 0, 0, GRID, GRID);
+    return rects;
+}
+function findKitten(env) {
+    const pathDirs = (env.PATH ?? "").split(node_path_1.default.delimiter).filter(Boolean);
+    const appBundles = process.platform === "darwin"
+        ? [
+            "/Applications/kitty.app/Contents/MacOS/kitten",
+            node_path_1.default.join(env.HOME ?? "/", "Applications/kitty.app/Contents/MacOS/kitten"),
+        ]
+        : [];
+    const candidates = [
+        ...pathDirs.map((dir) => node_path_1.default.join(dir, "kitten")),
+        ...appBundles,
+        ...pathDirs.map((dir) => node_path_1.default.join(dir, "kitty")),
+    ];
+    return (candidates.find((candidate) => {
+        try {
+            node_fs_1.default.accessSync(candidate, node_fs_1.default.constants.X_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }) ?? null);
+}
+const kitty = (env, run) => {
+    const looksLikeKitty = (env.TERM ?? "").includes("kitty") || env.KITTY_WINDOW_ID || env.KITTY_PID;
+    if (!looksLikeKitty)
+        return null;
+    let cachedBin;
+    async function kitten(args, input) {
+        if (cachedBin === undefined)
+            cachedBin = findKitten(env);
+        if (!cachedBin) {
+            throw new Error("kitty's `kitten` command was not found — install kitty, or add kitten to PATH");
+        }
+        const listenOn = env.KITTY_LISTEN_ON && !env.KITTY_LISTEN_ON.startsWith("fd:") ? env.KITTY_LISTEN_ON : null;
+        const to = listenOn ? ["--to", listenOn] : [];
+        try {
+            return await run(cachedBin, ["@", ...to, ...args], input);
+        }
+        catch (error) {
+            const stderr = String(error.stderr ?? "");
+            if (stderr.includes("Remote control is disabled"))
+                throw new Error(SETUP_HINT);
+            throw error;
+        }
+    }
+    const osWindows = async () => JSON.parse(await kitten(["ls"]));
+    async function panes() {
+        const panes = [];
+        for (const osWindow of await osWindows()) {
+            for (const tab of osWindow.tabs) {
+                for (const window of tab.windows) {
+                    panes.push({
+                        id: String(window.id),
+                        tab: `${osWindow.id}:${tab.id}`,
+                    });
+                }
+            }
+        }
+        return panes;
+    }
+    async function listPanes() {
+        const listed = [];
+        for (const osWindow of await osWindows()) {
+            for (const tab of osWindow.tabs) {
+                for (const window of tab.windows) {
+                    const pid = window.pid ?? window.foreground_processes?.[0]?.pid ?? null;
+                    listed.push({
+                        pid,
+                        pane: {
+                            id: String(window.id),
+                            tab: `${osWindow.id}:${tab.id}`,
+                            tty: null,
+                            command: (window.foreground_processes ?? [])
+                                .map((process) => (process.cmdline ?? []).join(" "))
+                                .join("\n") || null,
+                        },
+                    });
+                }
+            }
+        }
+        const pids = listed.map((entry) => entry.pid).filter((pid) => pid != null);
+        if (pids.length > 0) {
+            const byPid = new Map();
+            const out = await run("ps", ["-o", "pid=,tty=", "-p", pids.join(",")]).catch(() => "");
+            for (const line of out.split("\n")) {
+                const [pid, tty] = line.trim().split(/\s+/);
+                if (pid && tty && tty !== "??")
+                    byPid.set(Number(pid), `/dev/${tty}`);
+            }
+            for (const entry of listed) {
+                if (entry.pid != null)
+                    entry.pane.tty = byPid.get(entry.pid) ?? null;
+            }
+        }
+        return listed.map((entry) => entry.pane);
+    }
+    /** kitty can only place splits in a layout that has them. */
+    async function ensureSplitsLayout(paneId) {
+        const self = Number(paneId);
+        const tabs = (await osWindows()).flatMap((osWindow) => osWindow.tabs);
+        const tab = tabs.find((candidate) => candidate.windows.some((window) => window.id === self)) ??
+            tabs.find((candidate) => candidate.is_active);
+        if (!tab || tab.layout === "splits")
+            return;
+        const hasSplits = tab.enabled_layouts.some((layout) => layout === "splits" || layout.startsWith("splits:"));
+        if (!hasSplits)
+            return;
+        const match = self > 0 ? ["--match", `id:${self}`] : [];
+        await kitten(["goto-layout", ...match, "splits"]);
+    }
+    async function neighbor(from, direction) {
+        const self = Number(from.id);
+        const tab = (await osWindows())
+            .flatMap((osWindow) => osWindow.tabs)
+            .find((candidate) => candidate.windows.some((window) => window.id === self));
+        if (!tab)
+            return null;
+        const rects = pairRects(tab);
+        const own = rects.find((rect) => rect.id === from.id);
+        if (!own)
+            return null;
+        const found = (0, shared_1.adjacentPane)(own, rects, direction, 1);
+        return found ? { id: found.id, tab: from.tab } : null;
+    }
+    return {
+        name: "kitty",
+        getCurrentPane: () => (0, shared_1.paneById)(panes, env.KITTY_WINDOW_ID),
+        listPanes,
+        neighbor,
+        async sendText(pane, text) {
+            const target = ["send-text", "--match", `id:${pane}`, "--stdin"];
+            try {
+                await kitten([...target, "--bracketed-paste", "auto"], text);
+            }
+            catch (error) {
+                const stderr = String(error.stderr ?? "");
+                if (!/bracketed-paste/.test(stderr))
+                    throw error;
+                await kitten(target, text);
+            }
+        },
+        async focusPane(pane) {
+            await kitten(["focus-window", "--match", `id:${pane}`]);
+        },
+        async split({ from, direction, command, size }) {
+            await ensureSplitsLayout(from.id);
+            const location = direction === "right" || direction === "left" ? "vsplit" : "hsplit";
+            const bias = size ? [`--bias=${Math.round(size * 100)}`] : [];
+            await kitten(["launch", `--location=${location}`, ...bias, "--", ...command]);
+            if (direction === "left" || direction === "up") {
+                await kitten(["action", "move_window", direction]);
+            }
+        },
+    };
+};
+exports.kitty = kitty;

package/dist/terminal/terminals/supacode.d.ts

@@ -0,0 +1,2 @@
+import type { Detect } from "../terminal";
+export declare const supacode: Detect;

package/dist/terminal/terminals/supacode.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.supacode = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const shared_1 = require("../shared");
+const BUNDLED_CLI = "/Applications/supacode.app/Contents/Resources/bin/supacode";
+const supacode = (env, run) => {
+    if (!env.SUPACODE_SURFACE_ID && env.TERM_PROGRAM !== "supacode")
+        return null;
+    const binary = node_fs_1.default.existsSync(BUNDLED_CLI) && !env.SUPACODE_SURFACE_ID ? BUNDLED_CLI : "supacode";
+    const supacode = (args) => run(binary, args);
+    const lines = async (args) => (await supacode(args))
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line !== "");
+    async function panes() {
+        const found = [];
+        for (const tab of await lines(["tab", "list"])) {
+            for (const surface of await lines(["surface", "list", "--tab", tab])) {
+                found.push({ id: surface, tab });
+            }
+        }
+        return found;
+    }
+    const homes = new Map();
+    async function listPanes() {
+        const worktrees = env.SUPACODE_WORKTREE_ID ? [env.SUPACODE_WORKTREE_ID] : await lines(["worktree", "list"]);
+        const found = [];
+        for (const worktree of worktrees) {
+            for (const tab of await lines(["tab", "list", "-w", worktree])) {
+                for (const surface of await lines(["surface", "list", "-w", worktree, "-t", tab])) {
+                    homes.set(surface, { worktree, tab });
+                    found.push({ id: surface, tab, tty: null, command: null });
+                }
+            }
+        }
+        return found;
+    }
+    async function home(surface) {
+        if (!homes.has(surface))
+            await listPanes();
+        const found = homes.get(surface);
+        if (!found)
+            throw new Error(`supacode has no surface ${surface}`);
+        return found;
+    }
+    return {
+        name: "supacode",
+        getCurrentPane: () => (0, shared_1.paneById)(panes, env.SUPACODE_SURFACE_ID),
+        listPanes,
+        async sendText(pane, text) {
+            const { worktree, tab } = await home(pane);
+            await supacode(["surface", "focus", "-w", worktree, "-t", tab, "-s", pane, "--input", text, "--timeout", "5"]);
+        },
+        async focusPane(pane) {
+            const { worktree, tab } = await home(pane);
+            await supacode(["surface", "focus", "-w", worktree, "-t", tab, "-s", pane, "--timeout", "5"]);
+        },
+        async split({ from, direction, command }) {
+            if (direction !== "right" && direction !== "down") {
+                throw new Error("supacode only splits right and down");
+            }
+            await supacode([
+                "surface",
+                "split",
+                "--surface",
+                from.id,
+                "--direction",
+                direction === "right" ? "horizontal" : "vertical",
+                "--input",
+                (0, shared_1.shellQuote)(command),
+            ]);
+        },
+    };
+};
+exports.supacode = supacode;

package/dist/terminal/terminals/tmux.d.ts

@@ -0,0 +1,2 @@
+import type { Detect } from "../terminal";
+export declare const tmux: Detect;

package/dist/terminal/terminals/tmux.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tmux = void 0;
+const node_child_process_1 = require("node:child_process");
+const shared_1 = require("../shared");
+const SPLIT_FLAG = { right: "-h", left: "-h", down: "-v", up: "-v" };
+const tmux = (env, run) => {
+    if (!env.TMUX)
+        return null;
+    const tmux = (args) => run("tmux", args);
+    async function panes() {
+        const listing = await tmux([
+            "list-panes",
+            "-a",
+            "-F",
+            "#{session_name}\t#{window_id}\t#{pane_id}\t#{pane_title}",
+        ]);
+        const panes = [];
+        for (const line of listing.split("\n")) {
+            if (!line.trim())
+                continue;
+            const [session, window, pane, ...title] = line.split("\t");
+            panes.push({ id: pane, tab: `${session}:${window}` });
+        }
+        return panes;
+    }
+    async function listPanes() {
+        const listing = await tmux([
+            "list-panes",
+            "-a",
+            "-F",
+            "#{session_name}\t#{window_id}\t#{pane_id}\t#{pane_tty}",
+        ]);
+        const panes = [];
+        for (const line of listing.split("\n")) {
+            if (!line.trim())
+                continue;
+            const [session, window, pane, tty] = line.split("\t");
+            panes.push({ id: pane, tab: `${session}:${window}`, tty: tty || null, command: null });
+        }
+        return panes;
+    }
+    async function userClient() {
+        const listing = await tmux(["list-clients", "-F", "#{client_tty}\t#{client_flags}\t#{client_activity}"]);
+        let best = null;
+        for (const line of listing.split("\n")) {
+            if (!line.trim())
+                continue;
+            const [tty, flags, activity] = line.split("\t");
+            const client = { tty, focused: (flags ?? "").split(",").includes("focused"), activity: Number(activity) || 0 };
+            if (!best || (client.focused && !best.focused) || (client.focused === best.focused && client.activity > best.activity)) {
+                best = client;
+            }
+        }
+        return best?.tty ?? null;
+    }
+    async function neighbor(from, direction) {
+        const listing = await tmux([
+            "list-panes",
+            "-t",
+            from.id,
+            "-F",
+            "#{pane_id}\t#{pane_left}\t#{pane_top}\t#{pane_right}\t#{pane_bottom}",
+        ]);
+        const rects = [];
+        for (const line of listing.split("\n")) {
+            if (!line.trim())
+                continue;
+            const [id, left, top, right, bottom] = line.split("\t");
+            rects.push({ id, left: Number(left), top: Number(top), right: Number(right), bottom: Number(bottom) });
+        }
+        const self = rects.find((rect) => rect.id === from.id);
+        if (!self)
+            return null;
+        const found = (0, shared_1.adjacentPane)(self, rects, direction);
+        return found ? { id: found.id, tab: from.tab } : null;
+    }
+    return {
+        name: "tmux",
+        wrapper: "tmux",
+        prepare: () => prepareTmux(env),
+        getCurrentPane: () => (0, shared_1.paneById)(panes, env.TMUX_PANE),
+        listPanes,
+        neighbor,
+        async sendText(pane, text) {
+            if (text === "")
+                return;
+            await run("tmux", ["load-buffer", "-b", "pixel-send", "-"], text);
+            await tmux(["paste-buffer", "-p", "-d", "-b", "pixel-send", "-t", pane]);
+        },
+        async focusPane(pane) {
+            const client = await userClient();
+            if (client) {
+                await tmux(["switch-client", "-c", client, "-t", pane]);
+                return;
+            }
+            await tmux(["select-window", "-t", pane]);
+            await tmux(["select-pane", "-t", pane]);
+        },
+        async split({ from, direction, command, size }) {
+            const before = direction === "left" || direction === "up" ? ["-b"] : [];
+            const length = size ? ["-l", `${Math.round(size * 100)}%`] : [];
+            await tmux([
+                "split-window",
+                SPLIT_FLAG[direction],
+                ...before,
+                ...length,
+                "-t",
+                from.id,
+                (0, shared_1.shellQuote)(command),
+            ]);
+        },
+    };
+};
+exports.tmux = tmux;
+function prepareTmux(env) {
+    const tmux = (args) => {
+        try {
+            return (0, node_child_process_1.execFileSync)("tmux", args, { env, encoding: "utf8", timeout: 5000 }).trim();
+        }
+        catch {
+            return null;
+        }
+    };
+    tmux(["set", "-p", "allow-passthrough", "on"]);
+    tmux(["set", "-s", "focus-events", "on"]);
+    tmux(["set", "-s", "extended-keys", "on"]);
+    tmux(["set", "-s", "extended-keys-format", "csi-u"]);
+    const termname = tmux(["display", "-p", "#{client_termname}"]);
+    if (termname)
+        tmux(["set", "-as", "terminal-features", `${termname}:extkeys`]);
+}

package/dist/terminal/terminals/tty7.d.ts

@@ -0,0 +1,2 @@
+import type { Detect } from "../terminal";
+export declare const tty7: Detect;

package/dist/terminal/terminals/tty7.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tty7 = void 0;
+const shared_1 = require("../shared");
+const tty7 = (env, run) => {
+    if (!env.TTY7_PANE && env.TERM_PROGRAM !== "tty7")
+        return null;
+    const tty7 = (args) => run("tty7", args);
+    const list = async (args) => JSON.parse(await tty7(args)).panes;
+    const selfId = () => (env.TTY7_PANE ?? "").replace(/^%/, "") || null;
+    async function panes() {
+        const [placed, running] = await Promise.all([
+            list(["pane", "ls", "--json"]),
+            list(["pane", "ls", "--all", "--json"]),
+        ]);
+        const live = new Set(running.map((pane) => pane.pane));
+        return placed
+            .filter((pane) => live.has(pane.pane))
+            .map((pane) => ({
+            id: String(pane.pane),
+            tab: `${pane.workspace ?? ""}:${pane.tab ?? ""}`,
+        }));
+    }
+    async function listPanes() {
+        const [placed, running] = await Promise.all([
+            list(["pane", "ls", "--json"]),
+            list(["pane", "ls", "--all", "--json"]),
+        ]);
+        // tty7 reports the foreground process name as the pane title
+        const commands = new Map(running.filter((pane) => pane.live).map((pane) => [pane.pane, pane.title]));
+        return placed
+            .filter((pane) => commands.has(pane.pane))
+            .map((pane) => ({
+            id: String(pane.pane),
+            tab: `${pane.workspace ?? ""}:${pane.tab ?? ""}`,
+            tty: null,
+            command: commands.get(pane.pane) || null,
+        }));
+    }
+    return {
+        name: "tty7",
+        getCurrentPane: () => (0, shared_1.paneById)(panes, selfId()),
+        listPanes,
+        async sendText(pane, text) {
+            await tty7(["send", `%${pane}`, (0, shared_1.bracketedPaste)(text)]);
+        },
+        async split({ from, direction, command, size }) {
+            if (direction !== "right" && direction !== "down") {
+                throw new Error("tty7 only splits right and down");
+            }
+            const axis = direction === "right" ? "--horizontal" : "--vertical";
+            const ratio = size ? ["--ratio", String(1 - size)] : [];
+            const created = JSON.parse(await tty7(["split", `%${from.id}`, axis, ...ratio, "--json"]));
+            await tty7(["send", `%${created.pane}`, (0, shared_1.shellQuote)(command), "--enter"]);
+        },
+    };
+};
+exports.tty7 = tty7;

package/dist/terminal/terminals/vscode.d.ts

@@ -0,0 +1,2 @@
+import type { Detect } from "../terminal";
+export declare const vscode: Detect;

package/dist/terminal/terminals/vscode.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vscode = void 0;
+// we could implement the full api with a vscode extension
+const vscode = (env) => {
+    if (env.TERM_PROGRAM !== "vscode" && !env.VSCODE_INJECTION)
+        return null;
+    return {
+        name: "vscode",
+        reportsCssPixels: true,
+    };
+};
+exports.vscode = vscode;

package/dist/terminal/terminals/wezterm.d.ts

@@ -0,0 +1,2 @@
+import type { Detect } from "../terminal";
+export declare const wezterm: Detect;

package/dist/terminal/terminals/wezterm.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wezterm = void 0;
+const shared_1 = require("../shared");
+const SPLIT_FLAG = { right: "--right", left: "--left", down: "--bottom", up: "--top" };
+const wezterm = (env, run) => {
+    if (env.TERM_PROGRAM !== "WezTerm" && !env.WEZTERM_PANE)
+        return null;
+    const wezterm = (args, input) => run("wezterm", args, input);
+    async function panes() {
+        const list = JSON.parse(await wezterm(["cli", "list", "--format", "json"]));
+        return list.map((pane) => ({
+            id: String(pane.pane_id),
+            tab: `${pane.window_id}:${pane.tab_id}`,
+        }));
+    }
+    async function listPanes() {
+        const list = JSON.parse(await wezterm(["cli", "list", "--format", "json"]));
+        return list.map((pane) => ({
+            id: String(pane.pane_id),
+            tab: `${pane.window_id}:${pane.tab_id}`,
+            tty: pane.tty_name || null,
+            command: null,
+        }));
+    }
+    async function neighbor(from, direction) {
+        const list = JSON.parse(await wezterm(["cli", "list", "--format", "json"]));
+        const rects = list
+            .filter((pane) => `${pane.window_id}:${pane.tab_id}` === from.tab && pane.size && pane.left_col != null && pane.top_row != null)
+            .map((pane) => ({
+            id: String(pane.pane_id),
+            left: pane.left_col,
+            top: pane.top_row,
+            right: pane.left_col + pane.size.cols - 1,
+            bottom: pane.top_row + pane.size.rows - 1,
+        }));
+        const self = rects.find((rect) => rect.id === from.id);
+        if (!self)
+            return null;
+        const found = (0, shared_1.adjacentPane)(self, rects, direction);
+        return found ? { id: found.id, tab: from.tab } : null;
+    }
+    return {
+        name: "wezterm",
+        getCurrentPane: () => (0, shared_1.paneById)(panes, env.WEZTERM_PANE),
+        listPanes,
+        neighbor,
+        async sendText(pane, text) {
+            await wezterm(["cli", "send-text", "--pane-id", pane], text);
+        },
+        async focusPane(pane) {
+            await wezterm(["cli", "activate-pane", "--pane-id", pane]);
+        },
+        async split({ direction, command }) {
+            await wezterm(["cli", "split-pane", SPLIT_FLAG[direction], "--", ...command]);
+        },
+    };
+};
+exports.wezterm = wezterm;

package/dist/theme.d.ts

@@ -0,0 +1,22 @@
+import type { EngineInfo, Rgba } from "./react";
+export interface Theme {
+    bg: Rgba;
+    fg: Rgba;
+    muted: Rgba;
+    disabled: Rgba;
+    accent: Rgba;
+    field: Rgba;
+    fieldBorder: Rgba;
+    hover: Rgba;
+    hoverStrong: Rgba;
+    hairline: Rgba;
+    selection: Rgba;
+    red: Rgba;
+    green: Rgba;
+    yellow: Rgba;
+    magenta: Rgba;
+    cyan: Rgba;
+}
+export declare function withAlpha(color: Rgba, alpha: number): Rgba;
+export declare function mix(base: Rgba, toward: Rgba, t: number): Rgba;
+export declare function makeTheme(colors: EngineInfo["colors"]): Theme;

package/dist/theme.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withAlpha = withAlpha;
+exports.mix = mix;
+exports.makeTheme = makeTheme;
+function withAlpha(color, alpha) {
+    return [color[0], color[1], color[2], alpha];
+}
+function mix(base, toward, t) {
+    const channel = (b, w) => Math.round(b + (w - b) * t);
+    return [
+        channel(base[0], toward[0]),
+        channel(base[1], toward[1]),
+        channel(base[2], toward[2]),
+        255,
+    ];
+}
+function makeTheme(colors) {
+    const bg = colors.background ?? [30, 32, 38, 255];
+    const fg = colors.foreground ?? [235, 237, 242, 255];
+    const accent = colors.palette[12] ?? colors.palette[4] ?? [93, 156, 255, 255];
+    return {
+        bg,
+        fg,
+        accent,
+        muted: mix(fg, bg, 0.35),
+        disabled: mix(fg, bg, 0.7),
+        field: mix(bg, fg, 0.06),
+        fieldBorder: mix(bg, fg, 0.16),
+        hover: mix(bg, fg, 0.12),
+        hoverStrong: mix(bg, fg, 0.26),
+        hairline: mix(bg, fg, 0.12),
+        selection: mix(bg, accent, 0.35),
+        red: colors.palette[9] ?? colors.palette[1] ?? [229, 72, 77, 255],
+        green: colors.palette[10] ?? colors.palette[2] ?? [48, 164, 108, 255],
+        yellow: colors.palette[11] ?? colors.palette[3] ?? [245, 165, 36, 255],
+        magenta: colors.palette[13] ?? colors.palette[5] ?? [186, 148, 255, 255],
+        cyan: colors.palette[14] ?? colors.palette[6] ?? [94, 201, 227, 255],
+    };
+}