@code-yeongyu/senpi 2026.9.12-3 → 2026.9.12

package/node_modules/@earendil-works/pi-tui/native/linux/src/linux-platform-x11.c

@@ -1,274 +0,0 @@
-#include <xcb/xcb.h>
-#include <string.h>
-#include <xcb/xcbext.h>
-#include <errno.h>
-#include <poll.h>
-#include <time.h>
-#include "clipboard-worker.h"
-
-#define MAX_CLIPBOARD_BYTES (50u * 1024u * 1024u)
-#define CLIPBOARD_TIMEOUT_MS 2000
-
-static const char* const text_types[] = {
-    "text/plain;charset=utf-8", "text/plain;charset=UTF-8", "UTF8_STRING", "text/plain", "STRING",
-};
-static const char* const image_types[] = {
-    "image/png", "image/jpeg", "image/webp", "image/gif", "image/bmp", "image/tiff",
-};
-
-static int64_t monotonic_ms(void) {
-    struct timespec now;
-    clock_gettime(CLOCK_MONOTONIC, &now);
-    return (int64_t)now.tv_sec * 1000 + now.tv_nsec / 1000000;
-}
-
-typedef struct {
-    unsigned char* data;
-    size_t length;
-    uint32_t items;
-    uint8_t format;
-    xcb_atom_t type;
-} property_data;
-
-typedef struct {
-    xcb_connection_t* connection;
-    xcb_window_t window;
-    xcb_atom_t clipboard;
-    xcb_atom_t property;
-    xcb_atom_t targets;
-    xcb_atom_t incr;
-    int64_t deadline;
-} x11_clipboard;
-
-static bool append_bytes(property_data* result, const unsigned char* bytes, size_t length) {
-    if (length > MAX_CLIPBOARD_BYTES - result->length) return false;
-    unsigned char* data = realloc(result->data, result->length + length + 1);
-    if (!data) return false;
-    memcpy(data + result->length, bytes, length);
-    result->length += length;
-    data[result->length] = 0;
-    result->data = data;
-    return true;
-}
-
-// Share one deadline across discovery, replies, and incremental chunks.
-// Connection setup and flushing are libxcb calls on the private thread.
-static bool wait_for_input(x11_clipboard* clipboard) {
-    for (;;) {
-        int64_t remaining = clipboard->deadline - monotonic_ms();
-        if (remaining <= 0 || xcb_connection_has_error(clipboard->connection)) return false;
-        struct pollfd descriptor = {xcb_get_file_descriptor(clipboard->connection), POLLIN, 0};
-        int ready = poll(&descriptor, 1, (int)remaining);
-        if (ready >= 0) return ready && (descriptor.revents & POLLIN);
-        if (errno != EINTR) return false;
-    }
-}
-
-static void* wait_for_reply(x11_clipboard* clipboard, unsigned sequence) {
-    if (xcb_flush(clipboard->connection) <= 0) return 0;
-    while (monotonic_ms() < clipboard->deadline) {
-        void* reply = 0;
-        xcb_generic_error_t* error = 0;
-        if (xcb_poll_for_reply(clipboard->connection, sequence, &reply, &error)) {
-            free(error);
-            return reply;
-        }
-        if (!wait_for_input(clipboard)) break;
-    }
-    xcb_discard_reply(clipboard->connection, sequence);
-    return 0;
-}
-
-static xcb_generic_event_t* wait_for_event(x11_clipboard* clipboard, uint8_t type) {
-    if (xcb_flush(clipboard->connection) <= 0) return 0;
-    while (monotonic_ms() < clipboard->deadline) {
-        xcb_generic_event_t* event = xcb_poll_for_event(clipboard->connection);
-        if (event) {
-            if ((event->response_type & 0x7f) == type) return event;
-            free(event);
-        } else if (!wait_for_input(clipboard)) {
-            break;
-        }
-    }
-    return 0;
-}
-
-static bool read_property(x11_clipboard* clipboard, bool remove, property_data* result) {
-    xcb_get_property_cookie_t cookie = xcb_get_property(
-        clipboard->connection, remove, clipboard->window, clipboard->property,
-        XCB_GET_PROPERTY_TYPE_ANY, 0, MAX_CLIPBOARD_BYTES / 4
-    );
-    xcb_get_property_reply_t* reply = wait_for_reply(clipboard, cookie.sequence);
-    if (!reply) return false;
-    bool copied = false;
-    bool valid_format = reply->format == 8 || reply->format == 16 || reply->format == 32;
-    uint64_t length = (uint64_t)reply->value_len * (reply->format / 8);
-    if (reply->bytes_after == 0 && reply->type != XCB_NONE && valid_format &&
-        length <= MAX_CLIPBOARD_BYTES && length <= (uint64_t)reply->length * 4) {
-        result->type = reply->type;
-        result->format = reply->format;
-        result->items = reply->value_len;
-        copied = append_bytes(result, xcb_get_property_value(reply), (size_t)length);
-    }
-    free(reply);
-    return copied;
-}
-
-static bool append_property(property_data* result, const property_data* chunk) {
-    if ((chunk->format != 8 && chunk->format != 16 && chunk->format != 32) ||
-        chunk->type == XCB_NONE ||
-        (uint64_t)chunk->items * (chunk->format / 8) != chunk->length ||
-        (result->type != XCB_NONE && (result->type != chunk->type || result->format != chunk->format)) ||
-        chunk->items > UINT32_MAX - result->items) return false;
-    if (!append_bytes(result, chunk->data, chunk->length)) return false;
-    result->type = chunk->type;
-    result->format = chunk->format;
-    result->items += chunk->items;
-    return true;
-}
-
-static bool request_selection(x11_clipboard* clipboard, xcb_atom_t target, property_data* result) {
-    memset(result, 0, sizeof(*result));
-    xcb_delete_property(clipboard->connection, clipboard->window, clipboard->property);
-    xcb_convert_selection(
-        clipboard->connection, clipboard->window, clipboard->clipboard,
-        target, clipboard->property, XCB_CURRENT_TIME
-    );
-
-    while (true) {
-        xcb_selection_notify_event_t* event = (xcb_selection_notify_event_t*)wait_for_event(clipboard, XCB_SELECTION_NOTIFY);
-        if (!event) return false;
-        bool matches = event->selection == clipboard->clipboard && event->target == target;
-        bool received = event->property != XCB_NONE;
-        free(event);
-        if (!matches) continue;
-        if (!received) return true; // No owner, or the owner does not offer this target.
-        if (!read_property(clipboard, false, result)) return false;
-        break;
-    }
-    if (result->type != clipboard->incr) return true;
-
-    free(result->data);
-    memset(result, 0, sizeof(*result));
-    xcb_delete_property(clipboard->connection, clipboard->window, clipboard->property);
-
-    while (true) {
-        xcb_property_notify_event_t* event = (xcb_property_notify_event_t*)wait_for_event(clipboard, XCB_PROPERTY_NOTIFY);
-        if (!event) return false;
-        bool matches = event->atom == clipboard->property && event->state == XCB_PROPERTY_NEW_VALUE;
-        free(event);
-        if (!matches) continue;
-
-        property_data chunk = {0};
-        if (!read_property(clipboard, true, &chunk)) return false;
-        bool appended = append_property(result, &chunk);
-        bool finished = chunk.items == 0;
-        free(chunk.data);
-        if (!appended) return false;
-        if (finished) return true;
-    }
-}
-
-static xcb_atom_t intern_atom(x11_clipboard* clipboard, const char* name) {
-    xcb_intern_atom_cookie_t cookie = xcb_intern_atom(clipboard->connection, false, strlen(name), name);
-    xcb_intern_atom_reply_t* reply = wait_for_reply(clipboard, cookie.sequence);
-    if (!reply) return XCB_NONE;
-    xcb_atom_t atom = reply->atom;
-    free(reply);
-    return atom;
-}
-
-static bool open_clipboard(x11_clipboard* clipboard) {
-    memset(clipboard, 0, sizeof(*clipboard));
-    clipboard->deadline = monotonic_ms() + CLIPBOARD_TIMEOUT_MS;
-    int screen_number = 0;
-    clipboard->connection = xcb_connect(0, &screen_number);
-    if (xcb_connection_has_error(clipboard->connection)) return false;
-    xcb_screen_iterator_t screens = xcb_setup_roots_iterator(xcb_get_setup(clipboard->connection));
-    while (screen_number-- > 0 && screens.rem) xcb_screen_next(&screens);
-    if (!screens.rem) return false;
-
-    clipboard->window = xcb_generate_id(clipboard->connection);
-    uint32_t mask = XCB_EVENT_MASK_PROPERTY_CHANGE;
-    xcb_create_window(
-        clipboard->connection, XCB_COPY_FROM_PARENT, clipboard->window,
-        screens.data->root, 0, 0, 1, 1, 0, XCB_WINDOW_CLASS_INPUT_OUTPUT,
-        XCB_COPY_FROM_PARENT, XCB_CW_EVENT_MASK, &mask
-    );
-    clipboard->clipboard = intern_atom(clipboard, "CLIPBOARD");
-    clipboard->property = intern_atom(clipboard, "PI_CLIPBOARD");
-    clipboard->targets = intern_atom(clipboard, "TARGETS");
-    clipboard->incr = intern_atom(clipboard, "INCR");
-    return clipboard->clipboard && clipboard->property && clipboard->targets && clipboard->incr;
-}
-
-static void close_clipboard(x11_clipboard* clipboard) {
-    if (clipboard->connection) xcb_disconnect(clipboard->connection);
-}
-
-static bool preferred_target(x11_clipboard* clipboard, bool image, xcb_atom_t* target) {
-    const char* const* types = image ? image_types : text_types;
-    size_t type_count = image ? 6 : 5;
-    xcb_atom_t wanted[6];
-    for (size_t index = 0; index < type_count; index++) {
-        wanted[index] = intern_atom(clipboard, types[index]);
-        if (wanted[index] == XCB_NONE) return false;
-    }
-
-    property_data targets = {0};
-    bool received = request_selection(clipboard, clipboard->targets, &targets);
-    bool valid = targets.type == XCB_ATOM_ATOM && targets.format == 32 &&
-        targets.items == targets.length / sizeof(xcb_atom_t) && targets.length % sizeof(xcb_atom_t) == 0;
-    if (received && valid) {
-        xcb_atom_t* offered = (xcb_atom_t*)targets.data;
-        for (size_t wanted_index = 0; wanted_index < type_count; wanted_index++) {
-            for (uint32_t offered_index = 0; offered_index < targets.items; offered_index++) {
-                if (offered[offered_index] == wanted[wanted_index]) {
-                    free(targets.data);
-                    *target = wanted[wanted_index];
-                    return true;
-                }
-            }
-        }
-    }
-    free(targets.data);
-    // Some owners refuse TARGETS but still serve text directly.
-    if (received && !image && targets.type == XCB_NONE) {
-        *target = intern_atom(clipboard, "UTF8_STRING");
-        return *target != XCB_NONE;
-    }
-    return received && (valid || targets.type == XCB_NONE);
-}
-
-static bool read_selection(x11_clipboard* clipboard, bool image, property_data* result) {
-    xcb_atom_t target = XCB_NONE;
-    bool received = preferred_target(clipboard, image, &target) &&
-        (target == XCB_NONE || request_selection(clipboard, target, result));
-    if (!received) {
-        free(result->data);
-        memset(result, 0, sizeof(*result));
-    }
-    return received;
-}
-
-static void read_clipboard(clipboard_job* job) {
-    x11_clipboard clipboard;
-    if (open_clipboard(&clipboard)) {
-        property_data contents = {0};
-        if (!read_selection(&clipboard, job->operation == CLIPBOARD_IMAGE, &contents)) {
-            job->error = "Could not read X11 clipboard";
-        } else {
-            job->data = contents.data;
-            job->length = contents.length;
-            job->format = !contents.data ? CLIPBOARD_EMPTY : job->operation == CLIPBOARD_IMAGE
-                ? CLIPBOARD_BUFFER : contents.type == XCB_ATOM_STRING ? CLIPBOARD_LATIN1 : CLIPBOARD_UTF8;
-        }
-    }
-    close_clipboard(&clipboard);
-}
-
-PI_NAPI_EXPORT napi_value napi_register_module_v1(napi_env env, napi_value exports) {
-    set_function_export(env, exports, "getText", get_clipboard_text);
-    set_function_export(env, exports, "getImage", get_clipboard_image);
-    return exports;
-}

package/node_modules/@earendil-works/pi-tui/native/napi.h

@@ -1,89 +0,0 @@
-#ifndef PI_NAPI_H
-#define PI_NAPI_H
-
-// Resolve the small N-API surface we use from Node or Bun, without Node headers
-// or a link-time dependency on a particular runtime.
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-#ifdef _WIN32
-#include <windows.h>
-#define PI_NAPI_CALL __cdecl
-#define PI_NAPI_EXPORT __declspec(dllexport)
-#else
-#include <dlfcn.h>
-#define PI_NAPI_CALL
-#define PI_NAPI_EXPORT __attribute__((visibility("default")))
-#endif
-
-#define NAPI_AUTO_LENGTH ((size_t)-1)
-
-typedef void* napi_env;
-typedef void* napi_value;
-typedef void* napi_callback_info;
-typedef void* napi_async_work;
-typedef void* napi_deferred;
-typedef void (PI_NAPI_CALL *napi_async_execute_callback)(napi_env, void*);
-typedef void (PI_NAPI_CALL *napi_async_complete_callback)(napi_env, int, void*);
-typedef int (PI_NAPI_CALL *napi_create_async_work_fn)(napi_env, napi_value, napi_value, napi_async_execute_callback, napi_async_complete_callback, void*, napi_async_work*);
-typedef int (PI_NAPI_CALL *napi_async_work_fn)(napi_env, napi_async_work);
-typedef int (PI_NAPI_CALL *napi_create_promise_fn)(napi_env, napi_deferred*, napi_value*);
-typedef int (PI_NAPI_CALL *napi_settle_deferred_fn)(napi_env, napi_deferred, napi_value);
-typedef int (PI_NAPI_CALL *napi_create_error_fn)(napi_env, napi_value, napi_value, napi_value*);
-typedef napi_value (PI_NAPI_CALL *napi_callback)(napi_env, napi_callback_info);
-typedef int (PI_NAPI_CALL *napi_create_buffer_copy_fn)(napi_env, size_t, const void*, void**, napi_value*);
-typedef int (PI_NAPI_CALL *napi_create_function_fn)(napi_env, const char*, size_t, napi_callback, void*, napi_value*);
-typedef int (PI_NAPI_CALL *napi_create_string_utf8_fn)(napi_env, const char*, size_t, napi_value*);
-typedef int (PI_NAPI_CALL *napi_create_string_utf16_fn)(napi_env, const uint16_t*, size_t, napi_value*);
-typedef int (PI_NAPI_CALL *napi_get_boolean_fn)(napi_env, bool, napi_value*);
-typedef int (PI_NAPI_CALL *napi_get_cb_info_fn)(napi_env, napi_callback_info, size_t*, napi_value*, napi_value*, void**);
-typedef int (PI_NAPI_CALL *napi_get_value_fn)(napi_env, napi_value*);
-typedef int (PI_NAPI_CALL *napi_get_value_string_utf8_fn)(napi_env, napi_value, char*, size_t, size_t*);
-typedef int (PI_NAPI_CALL *napi_get_value_string_utf16_fn)(napi_env, napi_value, uint16_t*, size_t, size_t*);
-typedef int (PI_NAPI_CALL *napi_set_named_property_fn)(napi_env, napi_value, const char*, napi_value);
-typedef int (PI_NAPI_CALL *napi_throw_error_fn)(napi_env, const char*, const char*);
-
-static void* node_symbol(const char* name) {
-#ifdef _WIN32
-    HMODULE module = GetModuleHandleA(0);
-    void* proc = module ? (void*)GetProcAddress(module, name) : 0;
-    if (proc) return proc;
-    module = GetModuleHandleA("node.dll");
-    return module ? (void*)GetProcAddress(module, name) : 0;
-#else
-    return dlsym(RTLD_DEFAULT, name);
-#endif
-}
-
-static napi_value undefined_value(napi_env env) {
-    napi_get_value_fn get_value = (napi_get_value_fn)node_symbol("napi_get_undefined");
-    napi_value result = 0;
-    if (get_value) get_value(env, &result);
-    return result;
-}
-
-static napi_value null_value(napi_env env) {
-    napi_get_value_fn get_value = (napi_get_value_fn)node_symbol("napi_get_null");
-    napi_value result = 0;
-    if (get_value) get_value(env, &result);
-    return result;
-}
-
-static napi_value fail(napi_env env, const char* message) {
-    napi_throw_error_fn napi_throw_error = (napi_throw_error_fn)node_symbol("napi_throw_error");
-    if (napi_throw_error) napi_throw_error(env, 0, message);
-    return undefined_value(env);
-}
-
-static void set_function_export(napi_env env, napi_value exports, const char* name, napi_callback callback) {
-    napi_create_function_fn napi_create_function = (napi_create_function_fn)node_symbol("napi_create_function");
-    napi_set_named_property_fn napi_set_named_property =
-        (napi_set_named_property_fn)node_symbol("napi_set_named_property");
-    napi_value fn = 0;
-    if (napi_create_function && napi_set_named_property &&
-        napi_create_function(env, name, NAPI_AUTO_LENGTH, callback, 0, &fn) == 0) {
-        napi_set_named_property(env, exports, name, fn);
-    }
-}
-
-#endif

package/node_modules/@earendil-works/pi-tui/native/win32/src/win32-platform.c

@@ -1,241 +0,0 @@
-#define PI_CLIPBOARD_WRITE
-#include "../../clipboard.h"
-
-#ifndef BI_ALPHABITFIELDS
-#define BI_ALPHABITFIELDS 6
-#endif
-
-#define KEY_PRESSED_MASK 0x8000
-#define OPEN_CLIPBOARD_ATTEMPTS 10
-#define OPEN_CLIPBOARD_RETRY_MS 5
-#define BITMAP_FILE_HEADER_SIZE 14
-
-static int string_equals(const char* left, const char* right) {
-    while (*left && *right && *left == *right) {
-        left++;
-        right++;
-    }
-    return *left == 0 && *right == 0;
-}
-
-static int is_key_pressed(int virtual_key) {
-    return ((unsigned short)GetAsyncKeyState(virtual_key) & KEY_PRESSED_MASK) != 0;
-}
-
-static int is_modifier_name_pressed(const char* name) {
-    if (string_equals(name, "shift")) return is_key_pressed(VK_SHIFT) || is_key_pressed(VK_LSHIFT) || is_key_pressed(VK_RSHIFT);
-    if (string_equals(name, "control")) return is_key_pressed(VK_CONTROL) || is_key_pressed(VK_LCONTROL) || is_key_pressed(VK_RCONTROL);
-    if (string_equals(name, "option") || string_equals(name, "alt")) return is_key_pressed(VK_MENU) || is_key_pressed(VK_LMENU) || is_key_pressed(VK_RMENU);
-    if (string_equals(name, "command") || string_equals(name, "super") || string_equals(name, "win")) return is_key_pressed(VK_LWIN) || is_key_pressed(VK_RWIN);
-    return 0;
-}
-
-static napi_value __cdecl enable_virtual_terminal_input(napi_env env, napi_callback_info info) {
-    (void)info;
-
-    HANDLE handle = GetStdHandle(STD_INPUT_HANDLE);
-    DWORD mode = 0;
-    bool enabled = handle != INVALID_HANDLE_VALUE &&
-        GetConsoleMode(handle, &mode) &&
-        SetConsoleMode(handle, mode | ENABLE_VIRTUAL_TERMINAL_INPUT);
-
-    napi_get_boolean_fn napi_get_boolean = (napi_get_boolean_fn)node_symbol("napi_get_boolean");
-    napi_value result = 0;
-    if (!napi_get_boolean || napi_get_boolean(env, enabled, &result) != 0) {
-        return fail(env, "Could not configure console input");
-    }
-    return result;
-}
-
-static napi_value __cdecl is_modifier_pressed(napi_env env, napi_callback_info info) {
-    napi_get_cb_info_fn napi_get_cb_info = (napi_get_cb_info_fn)node_symbol("napi_get_cb_info");
-    napi_get_value_string_utf8_fn napi_get_value_string_utf8 =
-        (napi_get_value_string_utf8_fn)node_symbol("napi_get_value_string_utf8");
-    napi_get_boolean_fn napi_get_boolean = (napi_get_boolean_fn)node_symbol("napi_get_boolean");
-
-    bool pressed = false;
-    if (napi_get_cb_info && napi_get_value_string_utf8) {
-        size_t argc = 1;
-        napi_value args[1] = {0};
-        if (napi_get_cb_info(env, info, &argc, args, 0, 0) == 0 && argc >= 1 && args[0]) {
-            char name[16] = {0};
-            size_t copied = 0;
-            if (napi_get_value_string_utf8(env, args[0], name, sizeof(name), &copied) == 0) {
-                pressed = is_modifier_name_pressed(name);
-            }
-        }
-    }
-
-    napi_value result = 0;
-    if (!napi_get_boolean || napi_get_boolean(env, pressed, &result) != 0) {
-        return fail(env, "Could not inspect modifier state");
-    }
-    return result;
-}
-
-static bool open_clipboard(HWND owner) {
-    for (int attempt = 0; attempt < OPEN_CLIPBOARD_ATTEMPTS; attempt++) {
-        if (OpenClipboard(owner)) return true;
-        Sleep(OPEN_CLIPBOARD_RETRY_MS);
-    }
-    return false;
-}
-
-static uint16_t read_u16(const uint8_t* data) {
-    return (uint16_t)data[0] | ((uint16_t)data[1] << 8);
-}
-
-static uint32_t read_u32(const uint8_t* data) {
-    return (uint32_t)data[0] |
-        ((uint32_t)data[1] << 8) |
-        ((uint32_t)data[2] << 16) |
-        ((uint32_t)data[3] << 24);
-}
-
-static void write_u32(uint8_t* data, uint32_t value) {
-    data[0] = (uint8_t)value;
-    data[1] = (uint8_t)(value >> 8);
-    data[2] = (uint8_t)(value >> 16);
-    data[3] = (uint8_t)(value >> 24);
-}
-
-static void copy_bytes(uint8_t* destination, const uint8_t* source, size_t length) {
-    volatile uint8_t* target = destination;
-    const volatile uint8_t* input = source;
-    for (size_t index = 0; index < length; index++) target[index] = input[index];
-}
-
-static size_t dib_pixel_offset(const uint8_t* dib, size_t size) {
-    if (size < 12) return 0;
-    uint32_t header_size = read_u32(dib);
-
-    if (header_size == 12) {
-        uint16_t bits_per_pixel = read_u16(dib + 10);
-        uint32_t color_count = bits_per_pixel <= 8 ? 1u << bits_per_pixel : 0;
-        size_t offset = header_size + (size_t)color_count * 3;
-        return offset <= size ? offset : 0;
-    }
-
-    if (header_size < 40 || header_size > size) return 0;
-    uint16_t bits_per_pixel = read_u16(dib + 14);
-    uint32_t compression = read_u32(dib + 16);
-    uint32_t color_count = read_u32(dib + 32);
-    if (!color_count && bits_per_pixel <= 8) color_count = 1u << bits_per_pixel;
-
-    size_t offset = header_size + (size_t)color_count * 4;
-    if (header_size == 40 && compression == BI_BITFIELDS) offset += 3 * sizeof(uint32_t);
-    if (header_size == 40 && compression == BI_ALPHABITFIELDS) offset += 4 * sizeof(uint32_t);
-    return offset <= size ? offset : 0;
-}
-
-static void read_clipboard_image(clipboard_job* job) {
-    UINT png_format = RegisterClipboardFormatW(L"PNG");
-    if (!(png_format && IsClipboardFormatAvailable(png_format)) &&
-        !IsClipboardFormatAvailable(CF_DIBV5) && !IsClipboardFormatAvailable(CF_DIB)) {
-        job->format = CLIPBOARD_EMPTY;
-        return;
-    }
-    HGLOBAL handle = png_format && IsClipboardFormatAvailable(png_format)
-        ? (HGLOBAL)GetClipboardData(png_format) : 0;
-    bool is_png = handle != 0;
-    if (!handle && IsClipboardFormatAvailable(CF_DIBV5)) handle = (HGLOBAL)GetClipboardData(CF_DIBV5);
-    if (!handle && IsClipboardFormatAvailable(CF_DIB)) handle = (HGLOBAL)GetClipboardData(CF_DIB);
-
-    const uint8_t* source = handle ? (const uint8_t*)GlobalLock(handle) : 0;
-    size_t size = handle ? GlobalSize(handle) : 0;
-    if (!source || !size) {
-        if (source) GlobalUnlock(handle);
-        job->error = "Clipboard does not contain an image";
-        return;
-    }
-    if (is_png) {
-        clipboard_copy(job, source, size, CLIPBOARD_BUFFER);
-    } else {
-        size_t offset = dib_pixel_offset(source, size);
-        uint8_t* bitmap = offset && size <= UINT32_MAX - BITMAP_FILE_HEADER_SIZE
-            ? clipboard_alloc(size + BITMAP_FILE_HEADER_SIZE) : 0;
-        if (bitmap) {
-            bitmap[0] = 'B';
-            bitmap[1] = 'M';
-            write_u32(bitmap + 2, (uint32_t)(size + BITMAP_FILE_HEADER_SIZE));
-            write_u32(bitmap + 10, (uint32_t)(BITMAP_FILE_HEADER_SIZE + offset));
-            copy_bytes(bitmap + BITMAP_FILE_HEADER_SIZE, source, size);
-            job->data = bitmap;
-            job->length = size + BITMAP_FILE_HEADER_SIZE;
-            job->format = CLIPBOARD_BUFFER;
-        } else {
-            job->error = "Could not create clipboard image buffer";
-        }
-    }
-    GlobalUnlock(handle);
-}
-
-static void clipboard_execute(clipboard_job* job) {
-    // A real clipboard owner is required for text writes, including under Node
-    // without a console. Create and destroy it on the same worker thread.
-    HWND owner = 0;
-    if (job->operation == CLIPBOARD_WRITE) {
-        owner = CreateWindowExW(0, L"STATIC", 0, 0, 0, 0, 0, 0,
-            HWND_MESSAGE, 0, GetModuleHandleA(0), 0);
-        if (!owner) {
-            job->error = "Could not create clipboard owner window";
-            return;
-        }
-    }
-    if (!open_clipboard(owner)) {
-        if (owner) DestroyWindow(owner);
-        job->error = "Could not open clipboard";
-        return;
-    }
-    if (job->operation == CLIPBOARD_WRITE) {
-        size_t size = (job->length + 1) * sizeof(uint16_t);
-        HGLOBAL handle = GlobalAlloc(GMEM_MOVEABLE, size);
-        void* text = handle ? GlobalLock(handle) : 0;
-        bool success = false;
-        if (text) {
-            copy_bytes(text, job->data, size);
-            GlobalUnlock(handle);
-            success = EmptyClipboard() && SetClipboardData(CF_UNICODETEXT, handle) != 0;
-        }
-        if (!success) {
-            if (handle) GlobalFree(handle);
-            job->error = "Could not set clipboard text";
-        }
-    } else if (job->operation == CLIPBOARD_TEXT) {
-        if (!IsClipboardFormatAvailable(CF_UNICODETEXT)) {
-            job->format = CLIPBOARD_EMPTY;
-        } else {
-            HGLOBAL handle = (HGLOBAL)GetClipboardData(CF_UNICODETEXT);
-            const uint16_t* text = handle ? GlobalLock(handle) : 0;
-            if (text) {
-                size_t capacity = GlobalSize(handle) / sizeof(uint16_t);
-                size_t length = 0;
-                while (length < capacity && text[length]) length++;
-                clipboard_copy(job, text, length * sizeof(uint16_t), CLIPBOARD_UTF16);
-                GlobalUnlock(handle);
-            } else {
-                job->error = "Clipboard does not contain text";
-            }
-        }
-    } else {
-        read_clipboard_image(job);
-    }
-    CloseClipboard();
-    if (owner) DestroyWindow(owner);
-}
-
-BOOL WINAPI _DllMainCRTStartup(HINSTANCE instance, DWORD reason, LPVOID reserved) {
-    (void)instance;
-    (void)reason;
-    (void)reserved;
-    return TRUE;
-}
-
-PI_NAPI_EXPORT napi_value PI_NAPI_CALL napi_register_module_v1(napi_env env, napi_value exports) {
-    set_function_export(env, exports, "enableVirtualTerminalInput", enable_virtual_terminal_input);
-    set_function_export(env, exports, "isModifierPressed", is_modifier_pressed);
-    set_function_export(env, exports, "getText", get_clipboard_text);
-    set_function_export(env, exports, "setText", set_clipboard_text);
-    set_function_export(env, exports, "getImage", get_clipboard_image);
-    return exports;
-}