@ai-projector/ide 0.0.0-stage → 0.11.0

package/packages/core/modules/os/modules/linux/shortcut.js

@@ -0,0 +1,124 @@
+import { call, watchName } from "./bus.js";
+const keys = {
+    "Ctrl+Alt+Space": 0x0c000020,
+    "Super+Space": 0x10000020,
+    "Alt+Space": 0x08000020,
+};
+const action = ["projector", "toggle", "Projector", "Открыть поиск"];
+const service = "org.kde.kglobalaccel";
+const iface = "org.kde.KGlobalAccel";
+const componentIface = "org.kde.kglobalaccel.Component";
+const kdeCall = (bus, method, signature = "", values = [], path = "/kglobalaccel", interfaceName = iface) => call(bus, service, path, interfaceName, method, signature, values).then((reply) => reply.body);
+export async function available(bus, shortcut) {
+    try {
+        if (!shortcut)
+            return { supported: true, available: true };
+        if (!(shortcut in keys))
+            throw new Error("Неизвестное сочетание клавиш");
+        const [current] = await kdeCall(bus, "shortcut", "as", [action]);
+        if (current.includes(keys[shortcut]))
+            return { supported: true, available: true };
+        const [free] = await kdeCall(bus, "isGlobalShortcutAvailable", "is", [
+            keys[shortcut],
+            "projector",
+        ]);
+        return { supported: true, available: Boolean(free) };
+    }
+    catch {
+        return { supported: false, available: false };
+    }
+}
+export async function shortcutStatus(bus) {
+    try {
+        const [current] = await kdeCall(bus, "shortcut", "as", [action]);
+        const [path] = await kdeCall(bus, "getComponent", "s", ["projector"]);
+        const [active] = await kdeCall(bus, "isActive", "", [], path, componentIface);
+        const shortcut = Object.keys(keys).find((name) => current.includes(keys[name])) || "";
+        return { supported: true, active: Boolean(active && current.length), shortcut };
+    }
+    catch {
+        return {
+            supported: (await available(bus, "Ctrl+Alt+Space")).supported,
+            active: false,
+            shortcut: "",
+        };
+    }
+}
+export class Shortcut {
+    unsubscribe;
+    unwatch;
+    pending = Promise.resolve();
+    stopped = false;
+    bus;
+    configured;
+    activate;
+    constructor(bus, configured, activate) {
+        this.bus = bus;
+        this.configured = configured;
+        this.activate = activate;
+    }
+    async start() {
+        this.unwatch = await watchName(this.bus, service, () => this.configure());
+    }
+    configure() {
+        const task = this.pending.then(() => this.update());
+        this.pending = task.catch((error) => console.error("Хоткей:", error.message));
+        return task;
+    }
+    async update() {
+        if (this.stopped)
+            return;
+        this.unsubscribe?.();
+        this.unsubscribe = undefined;
+        const shortcut = await this.configured();
+        try {
+            if (!shortcut) {
+                await kdeCall(this.bus, "unregister", "ss", ["projector", "toggle"]);
+                return;
+            }
+            const check = await available(this.bus, shortcut);
+            if (!check.supported)
+                return;
+            if (!check.available) {
+                await this.deactivate();
+                console.error(`Горячая клавиша занята: ${shortcut}`);
+                return;
+            }
+            await kdeCall(this.bus, "doRegister", "as", [action]);
+            // SetPresent | NoAutoloading: explicit preference overrides KDE's old assignment.
+            const [registered] = await kdeCall(this.bus, "setShortcut", "asaiu", [
+                action,
+                [keys[shortcut]],
+                6,
+            ]);
+            if (registered.length !== 1 || registered[0] !== keys[shortcut]) {
+                await this.deactivate();
+                throw new Error("Не удалось назначить горячую клавишу");
+            }
+            const [path] = await kdeCall(this.bus, "getComponent", "s", ["projector"]);
+            const proxy = await this.bus.getProxyObject(service, path);
+            const component = proxy.getInterface(componentIface);
+            const pressed = (name, id) => {
+                if (!this.stopped && name === "projector" && id === "toggle")
+                    this.activate();
+            };
+            component.on("globalShortcutPressed", pressed);
+            this.unsubscribe = () => {
+                component.off("globalShortcutPressed", pressed);
+            };
+        }
+        catch (error) {
+            console.error("Хоткей:", error instanceof Error ? error.message : error);
+        }
+    }
+    async deactivate() {
+        await kdeCall(this.bus, "setInactive", "as", [action]).catch(() => undefined);
+    }
+    async stop() {
+        this.stopped = true;
+        this.unwatch?.();
+        await this.pending;
+        this.unsubscribe?.();
+        await this.deactivate();
+    }
+}

package/packages/core/modules/os/modules/linux/tools.js

@@ -0,0 +1,14 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execute = promisify(execFile);
+export * from "../../../os-posix/index.js";
+export function moveNoReplace(source, target) {
+    return execute("mv", [
+        "--update=none",
+        "--no-target-directory",
+        "--no-copy",
+        "--",
+        source,
+        target,
+    ]);
+}

package/packages/core/modules/os/modules/linux/tray.js

@@ -0,0 +1,190 @@
+import dbus from "dbus-next";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { call, watchName } from "./bus.js";
+const { Interface, ACCESS_READ } = dbus.interface;
+const item = (label) => ({
+    label: new dbus.Variant("s", label),
+    enabled: new dbus.Variant("b", true),
+    visible: new dbus.Variant("b", true),
+});
+/** Exported interfaces use configureMembers, without decorators or a transpiler. */
+class StatusNotifier extends Interface {
+    Category = "ApplicationStatus";
+    Id = "projector";
+    Title = "Projector";
+    Status = "Active";
+    WindowId = 0;
+    IconName = fileURLToPath(new URL("../../../../../../resources/icons/64.png", import.meta.url));
+    IconThemePath = dirname(this.IconName);
+    IconPixmap = [];
+    OverlayIconName = "";
+    OverlayIconPixmap = [];
+    AttentionIconName = "";
+    AttentionIconPixmap = [];
+    AttentionMovieName = "";
+    ToolTip = [this.IconName, [], "Projector", "Поиск и запуск приложений"];
+    ItemIsMenu = false;
+    Menu = "/Menu";
+    activate;
+    constructor(activate) {
+        super("org.kde.StatusNotifierItem");
+        this.activate = activate;
+    }
+    Activate(_x, _y) {
+        this.activate();
+    }
+    SecondaryActivate(_x, _y) {
+        this.activate();
+    }
+    ContextMenu(_x, _y) { }
+    Scroll(_delta, _orientation) { }
+    NewIcon() { }
+    NewToolTip() { }
+    NewStatus(status) {
+        return status;
+    }
+}
+const propertyTypes = {
+    Category: "s",
+    Id: "s",
+    Title: "s",
+    Status: "s",
+    WindowId: "u",
+    IconName: "s",
+    IconThemePath: "s",
+    IconPixmap: "a(iiay)",
+    OverlayIconName: "s",
+    OverlayIconPixmap: "a(iiay)",
+    AttentionIconName: "s",
+    AttentionIconPixmap: "a(iiay)",
+    AttentionMovieName: "s",
+    ToolTip: "(sa(iiay)ss)",
+    ItemIsMenu: "b",
+    Menu: "o",
+};
+StatusNotifier.configureMembers({
+    properties: Object.fromEntries(Object.entries(propertyTypes).map(([name, signature]) => [
+        name,
+        { signature, access: ACCESS_READ },
+    ])),
+    methods: {
+        Activate: { inSignature: "ii" },
+        SecondaryActivate: { inSignature: "ii" },
+        ContextMenu: { inSignature: "ii" },
+        Scroll: { inSignature: "is" },
+    },
+    signals: {
+        NewIcon: { signature: "" },
+        NewToolTip: { signature: "" },
+        NewStatus: { signature: "s" },
+    },
+});
+class TrayMenu extends Interface {
+    Version = 3;
+    TextDirection = "ltr";
+    Status = "normal";
+    actions;
+    items = new Map([
+        [0, { "children-display": new dbus.Variant("s", "submenu") }],
+        [1, item("Открыть поиск")],
+        [3, item("Настройки")],
+        [4, { type: new dbus.Variant("s", "separator") }],
+        [6, item("Перезапустить")],
+        [5, item("Выйти из Projector")],
+    ]);
+    constructor(actions) {
+        super("com.canonical.dbusmenu");
+        this.actions = actions;
+    }
+    properties(id, names) {
+        const props = this.items.get(id);
+        if (!props)
+            throw new dbus.DBusError("com.canonical.dbusmenu.Error", "Unknown item");
+        return Object.fromEntries(Object.entries(props).filter(([name]) => !names.length || names.includes(name)));
+    }
+    layout(id, depth, names) {
+        return [
+            id,
+            this.properties(id, names),
+            id === 0 && depth !== 0
+                ? [1, 2, 3, 4, 6, 5].map((child) => new dbus.Variant("(ia{sv}av)", this.layout(child, depth - 1, names)))
+                : [],
+        ];
+    }
+    GetLayout(id, depth, names) {
+        return [1, this.layout(id, depth, names)];
+    }
+    GetGroupProperties(ids, names) {
+        return ids.filter((id) => this.items.has(id)).map((id) => [id, this.properties(id, names)]);
+    }
+    GetProperty(id, name) {
+        const prop = this.items.get(id)?.[name];
+        if (!prop)
+            throw new dbus.DBusError("com.canonical.dbusmenu.Error", "Unknown property");
+        return prop;
+    }
+    Event(id, event, _data, _timestamp) {
+        if (event === "clicked")
+            this.actions.get(id)?.();
+    }
+    EventGroup(events) {
+        for (const event of events)
+            this.Event(...event);
+        return [];
+    }
+    AboutToShow(_id) {
+        return false;
+    }
+    AboutToShowGroup(_ids) {
+        return [[], []];
+    }
+    LayoutUpdated(revision, parent) {
+        return [revision, parent];
+    }
+    ItemsPropertiesUpdated(updated, removed) {
+        return [updated, removed];
+    }
+}
+TrayMenu.configureMembers({
+    properties: {
+        Version: { signature: "u", access: ACCESS_READ },
+        TextDirection: { signature: "s", access: ACCESS_READ },
+        Status: { signature: "s", access: ACCESS_READ },
+    },
+    methods: {
+        GetLayout: { inSignature: "iias", outSignature: "u(ia{sv}av)" },
+        GetGroupProperties: { inSignature: "aias", outSignature: "a(ia{sv})" },
+        GetProperty: { inSignature: "is", outSignature: "v" },
+        Event: { inSignature: "isvu" },
+        EventGroup: { inSignature: "a(isvu)", outSignature: "ai" },
+        AboutToShow: { inSignature: "i", outSignature: "b" },
+        AboutToShowGroup: { inSignature: "ai", outSignature: "aiai" },
+    },
+    signals: {
+        LayoutUpdated: { signature: "ui" },
+        ItemsPropertiesUpdated: { signature: "a(ia{sv})a(ias)" },
+    },
+});
+export async function startTray(bus, activate, openPage, quit, restart) {
+    const sni = new StatusNotifier(activate);
+    const menu = new TrayMenu(new Map([
+        [1, activate],
+        [3, () => openPage("/settings")],
+        [5, quit],
+        [6, restart],
+    ]));
+    bus.export("/StatusNotifierItem", sni);
+    bus.export("/Menu", menu);
+    const unwatch = await watchName(bus, "org.kde.StatusNotifierWatcher", async () => {
+        await call(bus, "org.kde.StatusNotifierWatcher", "/StatusNotifierWatcher", "org.kde.StatusNotifierWatcher", "RegisterStatusNotifierItem", "s", ["/StatusNotifierItem"]);
+    }).catch((error) => {
+        console.error("Трей:", error.message);
+        return () => { };
+    });
+    return () => {
+        unwatch();
+        bus.unexport("/StatusNotifierItem", sni);
+        bus.unexport("/Menu", menu);
+    };
+}

package/packages/core/modules/os/modules/linux/windows.js

@@ -0,0 +1,187 @@
+import { execFile, execFileSync, spawn } from "node:child_process";
+import { mkdirSync } from "node:fs";
+import { stat } from "node:fs/promises";
+import { dirname } from "node:path";
+import { pathToFileURL } from "node:url";
+import { promisify } from "node:util";
+const execute = promisify(execFile);
+const BROWSERS = [
+    "google-chrome-stable",
+    "google-chrome",
+    "chromium",
+    "chromium-browser",
+    "brave-browser",
+    "microsoft-edge-stable",
+    "microsoft-edge",
+];
+function which(bin) {
+    try {
+        execFileSync("which", [bin], { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function findBrowser() {
+    for (const bin of BROWSERS) {
+        if (which(bin))
+            return bin;
+    }
+    return null;
+}
+function tryExec(bin, args) {
+    if (!which(bin))
+        return false;
+    try {
+        execFileSync(bin, args, { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function focusAppWindow(appClass) {
+    return (tryExec("wmctrl", ["-xa", appClass]) ||
+        tryExec("xdotool", ["search", "--onlyvisible", "--class", appClass, "windowactivate"]));
+}
+function spawnDetached(bin, args) {
+    const child = spawn(bin, args, { detached: true, stdio: "ignore" });
+    child.unref();
+}
+export function openWindow(url) {
+    const browser = findBrowser();
+    if (browser) {
+        spawnDetached(browser, [`--app=${url}`]);
+        return;
+    }
+    spawnDetached("xdg-open", [url]);
+}
+export function openBrowser(url) {
+    spawnDetached("xdg-open", [url]);
+}
+/**
+ * Selects the entry in the desktop file manager. The standard `org.freedesktop.FileManager1`
+ * interface handles every desktop that implements it; otherwise the parent folder is opened.
+ */
+export async function revealInFileManager(path) {
+    try {
+        await execute("dbus-send", [
+            "--session",
+            "--dest=org.freedesktop.FileManager1",
+            "--type=method_call",
+            "/org/freedesktop/FileManager1",
+            "org.freedesktop.FileManager1.ShowItems",
+            `array:string:${pathToFileURL(path).href}`,
+            "string:",
+        ], { timeout: 5000, env: process.env });
+        return;
+    }
+    catch {
+        /* No file manager on the session bus: open the containing folder instead. */
+    }
+    const info = await stat(path);
+    spawnDetached("xdg-open", [info.isDirectory() ? path : dirname(path)]);
+}
+export function openOrFocusApp(url, appClass, profile) {
+    if (focusAppWindow(appClass))
+        return;
+    mkdirSync(profile, { recursive: true });
+    const browser = findBrowser();
+    if (browser) {
+        spawnDetached(browser, [
+            `--app=${url}`,
+            `--user-data-dir=${profile}`,
+            `--class=${appClass}`,
+            `--name=${appClass}`,
+            "--no-first-run",
+            "--no-default-browser-check",
+        ]);
+        return;
+    }
+    spawnDetached("xdg-open", [url]);
+}
+function paletteWindow(paletteClass) {
+    try {
+        const ids = execFileSync("xdotool", ["search", "--class", `^${paletteClass}$`], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        })
+            .trim()
+            .split("\n");
+        // Chromium also tags invisible helper windows with the app class.
+        // WM_STATE identifies the actual managed window, including when hidden.
+        for (const id of ids) {
+            const state = execFileSync("xprop", ["-id", id, "WM_STATE"], {
+                encoding: "utf8",
+                stdio: ["ignore", "pipe", "ignore"],
+            });
+            if (state.startsWith("WM_STATE(WM_STATE)"))
+                return id;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function hidePalette(paletteClass) {
+    const id = paletteWindow(paletteClass);
+    if (id)
+        tryExec("xdotool", ["windowunmap", id]);
+}
+export function openWebPalette(url, toggle, paletteClass, profile) {
+    const id = paletteWindow(paletteClass);
+    if (id) {
+        const active = tryGetActiveWindow();
+        if (toggle && active === id)
+            hidePalette(paletteClass);
+        else {
+            tryExec("xdotool", ["windowmap", id]);
+            tryExec("xdotool", ["windowactivate", "--sync", id]);
+        }
+        return;
+    }
+    const browser = findBrowser();
+    if (!browser)
+        throw new Error("Не найден Chromium-совместимый браузер; выберите режим браузера");
+    mkdirSync(profile, { recursive: true });
+    spawnDetached(browser, [
+        `--app=${url}?surface=window`,
+        `--user-data-dir=${profile}`,
+        `--class=${paletteClass}`,
+        `--name=${paletteClass}`,
+        "--window-size=660,500",
+        "--no-first-run",
+        "--no-default-browser-check",
+        "--disable-features=Translate",
+    ]);
+}
+function tryGetActiveWindow() {
+    try {
+        return execFileSync("xdotool", ["getactivewindow"], { encoding: "utf8" }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+export function closePalette(paletteClass) {
+    const id = paletteWindow(paletteClass);
+    if (id)
+        tryExec("xdotool", ["windowclose", id]);
+}
+export function activateWindow(id) {
+    const child = spawn("xdotool", ["windowactivate", "--sync", String(id)], { stdio: "ignore" });
+    child.on("error", () => { });
+}
+/** X11 needs an explicit raise. Wayland activates the window through the compositor. */
+export async function activateSurface(surface) {
+    try {
+        const { default: GdkX11 } = await import("gi:GdkX11-4.0");
+        if (surface instanceof GdkX11.X11Surface)
+            activateWindow(surface.getXid());
+    }
+    catch {
+        /* The surface is not an X11 window. */
+    }
+}

package/packages/core/modules/os/modules/windows/agent-process.js

@@ -0,0 +1,60 @@
+import { spawn } from "node:child_process";
+import { basename } from "node:path";
+import { killTree } from "./kill-tree.js";
+/** `shell: true` joins argv with spaces, so anything with whitespace or quotes is quoted for cmd.exe. */
+export function quoteForCmd(value) {
+    if (value !== "" && !/[\s"&|<>^()%]/.test(value))
+        return value;
+    return `"${value.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/, "$1$1")}"`;
+}
+/** A separate stdio process per chat turn: Projector never touches the user's own sessions. */
+/** `.cmd` shims are not executable without a shell on Windows, and a shell joins argv unquoted. */
+export function agentLaunch(spec) {
+    if (spec.shell === false)
+        return { command: spec.command, args: spec.args, shell: false };
+    return { command: quoteForCmd(spec.command), args: spec.args.map(quoteForCmd), shell: true };
+}
+export function spawnAgentProcess(spec) {
+    const launch = agentLaunch(spec);
+    const child = spawn(launch.command, launch.args, {
+        cwd: spec.cwd,
+        env: spec.env,
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true,
+        shell: launch.shell,
+    });
+    child.terminate = () => terminateTree(child);
+    return child;
+}
+async function terminateTree(child) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return;
+    const closed = new Promise((resolve) => child.once("close", () => resolve()));
+    if (child.pid)
+        await killTree(child.pid);
+    else
+        child.kill();
+    await closed;
+}
+/** Windows services inherit the user's PATH, so the environment is used as is. */
+export async function agentEnv(base) {
+    return base;
+}
+export function agentHostAddress(dir) {
+    return `\\\\.\\pipe\\projector-agent-${basename(dir)}`;
+}
+/** Starts the script that holds an agent process outside the server's own life. */
+export function spawnAgentHost(spec) {
+    const child = spawn(process.execPath, [spec.script, spec.dir, spec.address], {
+        env: spec.env,
+        stdio: ["ignore", spec.log, spec.log],
+        detached: true,
+        windowsHide: true,
+    });
+    child.on("error", () => { });
+    child.unref();
+    return child.pid;
+}
+export function killAgentTree(pid) {
+    void killTree(pid);
+}

package/packages/core/modules/os/modules/windows/alert.js

@@ -0,0 +1,20 @@
+import { runPowerShellSync } from "./ps.js";
+/**
+ * Start Menu / wscript hide the console. A modal MessageBox is the only way a
+ * failed launch is visible; skip it when the user already has a TTY.
+ */
+export function alertHiddenFailure(message) {
+    const fromShortcut = process.env.PROJECTOR_FROM_SHORTCUT === "1";
+    if (process.stdout.isTTY && !fromShortcut)
+        return;
+    try {
+        runPowerShellSync("Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.MessageBox]::Show($env:PROJECTOR_ALERT, 'Projector', 'OK', [System.Windows.Forms.MessageBoxIcon]::Error, [System.Windows.Forms.MessageBoxDefaultButton]::Button1, [System.Windows.Forms.MessageBoxOptions]::SystemModal) | Out-Null", {
+            sta: true,
+            timeout: 120000,
+            env: { PROJECTOR_ALERT: String(message).slice(0, 1000) },
+        });
+    }
+    catch {
+        /* best-effort */
+    }
+}

package/packages/core/modules/os/modules/windows/catalog.js

@@ -0,0 +1,91 @@
+import { homedir } from "node:os";
+import { join, sep } from "node:path";
+import { runPowerShell } from "./ps.js";
+function roots() {
+    const roaming = process.env.APPDATA || join(homedir(), "AppData", "Roaming");
+    const common = process.env.ProgramData || join(process.env.SystemDrive || "C:", "ProgramData");
+    return [
+        join(roaming, "Microsoft", "Windows", "Start Menu"),
+        join(common, "Microsoft", "Windows", "Start Menu"),
+    ];
+}
+function allowed(id) {
+    const normalized = id.replace(/\//g, "\\").toLowerCase();
+    if (!normalized.endsWith(".lnk"))
+        return false;
+    return roots().some((root) => {
+        const prefix = root.replace(/\//g, "\\").toLowerCase();
+        return normalized.startsWith(prefix.endsWith("\\") ? prefix : prefix + sep);
+    });
+}
+/** Start Menu shortcuts have no Gio icon. The palette row falls back to a text glyph. */
+export function desktopApp(_id) {
+    return { getIcon: () => null };
+}
+export async function listApplications() {
+    const script = `
+$shell = New-Object -ComObject WScript.Shell
+$roots = $env:PROJECTOR_START_ROOTS -split '\\|'
+foreach ($root in $roots) {
+  if (-not (Test-Path -LiteralPath $root)) { continue }
+  Get-ChildItem -LiteralPath $root -Filter *.lnk -Recurse -ErrorAction SilentlyContinue | ForEach-Object {
+    $shortcut = $shell.CreateShortcut($_.FullName)
+    $name = $_.BaseName -replace '[\\r\\n\\t]', ' '
+    $target = [string]$shortcut.TargetPath -replace '[\\r\\n\\t]', ' '
+    Write-Output ($_.FullName + [char]9 + $name + [char]9 + $target)
+  }
+}
+`;
+    let stdout = "";
+    try {
+        ({ stdout } = await runPowerShell(script, {
+            timeout: 20000,
+            env: { PROJECTOR_START_ROOTS: roots().join("|") },
+        }));
+    }
+    catch {
+        return [];
+    }
+    return stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .flatMap((line) => {
+        const [file, name, target] = line.split("\t");
+        if (!file || !name || !allowed(file))
+            return [];
+        return [
+            {
+                id: `app:${file}`,
+                name,
+                description: "приложение",
+                keywords: target || "",
+                kind: "application",
+                icon: `/api/launcher/icon?id=${encodeURIComponent(file)}`,
+            },
+        ];
+    });
+}
+export async function launchApplication(id) {
+    if (!allowed(id))
+        throw new Error("Приложение больше не доступно");
+    await runPowerShell("Start-Process -FilePath $env:PROJECTOR_SHORTCUT", {
+        env: { PROJECTOR_SHORTCUT: id },
+    });
+}
+export async function applicationIcon(id) {
+    if (!allowed(id))
+        return "";
+    try {
+        const { stdout } = await runPowerShell(`
+$shell = New-Object -ComObject WScript.Shell
+$icon = [string]$shell.CreateShortcut($env:PROJECTOR_SHORTCUT).IconLocation
+$icon.Split(',')[0]
+`, { env: { PROJECTOR_SHORTCUT: id }, timeout: 8000 });
+        const file = stdout.trim();
+        return /\.(?:ico|png|svg|bmp)$/i.test(file) ? file : "";
+    }
+    catch {
+        return "";
+    }
+}