@bomb.sh/tty 0.0.0-register.0

package/esm/input.js

@@ -0,0 +1,228 @@
+/**
+ * Terminal input parser.
+ *
+ * Thin wrapper around WASM `input_*` functions that decode raw VT/ANSI
+ * escape sequences into structured events. All parsing logic, state
+ * management, and buffering lives in WASM.
+ */
+import { createInputNative, EVENT_CURSOR, EVENT_KEY, EVENT_MOUSE, EVENT_RESIZE, KEY_ALT_LEFT, KEY_ALT_RIGHT, KEY_ARROW_DOWN, KEY_ARROW_LEFT, KEY_ARROW_RIGHT, KEY_ARROW_UP, KEY_BACKSPACE, KEY_BACKTAB, KEY_CAPS_LOCK, KEY_CONTROL_LEFT, KEY_CONTROL_RIGHT, KEY_DELETE, KEY_END, KEY_ENTER, KEY_ESC, KEY_F1, KEY_F10, KEY_F11, KEY_F12, KEY_F2, KEY_F3, KEY_F4, KEY_F5, KEY_F6, KEY_F7, KEY_F8, KEY_F9, KEY_HOME, KEY_HYPER_LEFT, KEY_HYPER_RIGHT, KEY_INSERT, KEY_META_LEFT, KEY_META_RIGHT, KEY_MOUSE_LEFT, KEY_MOUSE_MIDDLE, KEY_MOUSE_RELEASE, KEY_MOUSE_RIGHT, KEY_MOUSE_WHEEL_DOWN, KEY_MOUSE_WHEEL_UP, KEY_NUM_LOCK, KEY_NUMPAD_0, KEY_NUMPAD_1, KEY_NUMPAD_2, KEY_NUMPAD_3, KEY_NUMPAD_4, KEY_NUMPAD_5, KEY_NUMPAD_6, KEY_NUMPAD_7, KEY_NUMPAD_8, KEY_NUMPAD_9, KEY_NUMPAD_ADD, KEY_NUMPAD_DECIMAL, KEY_NUMPAD_DIVIDE, KEY_NUMPAD_ENTER, KEY_NUMPAD_EQUAL, KEY_NUMPAD_MULTIPLY, KEY_NUMPAD_SUBTRACT, KEY_PGDN, KEY_PGUP, KEY_SCROLL_LOCK, KEY_SHIFT_LEFT, KEY_SHIFT_RIGHT, KEY_SUPER_LEFT, KEY_SUPER_RIGHT, KEY_TAB, MAX_TERMINFO, MOD_ALT, MOD_CTRL, MOD_MOTION, MOD_RELEASE, MOD_SHIFT, readEvent, SCAN_BUFFER_SIZE, } from "./input-native.js";
+export async function createInput(options = {}) {
+    let { escLatency = 25, terminfo } = options;
+    if (terminfo && terminfo.byteLength > MAX_TERMINFO) {
+        throw new RangeError(`terminfo exceeds ${MAX_TERMINFO} byte limit (got ${terminfo.byteLength})`);
+    }
+    let native = await createInputNative(escLatency);
+    return {
+        scan(bytes = new Uint8Array(0)) {
+            let now = Date.now();
+            let events = [];
+            let offset = 0;
+            while (offset < bytes.length || (offset === 0 && bytes.length === 0)) {
+                let chunk = bytes.subarray(offset, offset + SCAN_BUFFER_SIZE);
+                if (chunk.length > 0) {
+                    new Uint8Array(native.memory.buffer).set(chunk, native.buffer);
+                }
+                let accepted = native.scan(native.state, native.buffer, chunk.length, now);
+                let count = native.count(native.state);
+                let view = new DataView(native.memory.buffer);
+                for (let i = 0; i < count; i++) {
+                    let ptr = native.event(native.state, i);
+                    if (ptr !== 0) {
+                        events.push(mapEvent(readEvent(view, ptr)));
+                    }
+                }
+                offset += accepted;
+                if (accepted < chunk.length) {
+                    break;
+                }
+                if (bytes.length === 0) {
+                    break;
+                }
+            }
+            let delay = native.delay(native.state);
+            if (delay > 0) {
+                return { events, pending: { delay } };
+            }
+            return { events };
+        },
+    };
+}
+const KEY_NAMES = new Map([
+    [KEY_F1, "F1"],
+    [KEY_F2, "F2"],
+    [KEY_F3, "F3"],
+    [KEY_F4, "F4"],
+    [KEY_F5, "F5"],
+    [KEY_F6, "F6"],
+    [KEY_F7, "F7"],
+    [KEY_F8, "F8"],
+    [KEY_F9, "F9"],
+    [KEY_F10, "F10"],
+    [KEY_F11, "F11"],
+    [KEY_F12, "F12"],
+    [KEY_ARROW_UP, "ArrowUp"],
+    [KEY_ARROW_DOWN, "ArrowDown"],
+    [KEY_ARROW_LEFT, "ArrowLeft"],
+    [KEY_ARROW_RIGHT, "ArrowRight"],
+    [KEY_HOME, "Home"],
+    [KEY_END, "End"],
+    [KEY_INSERT, "Insert"],
+    [KEY_DELETE, "Delete"],
+    [KEY_PGUP, "PageUp"],
+    [KEY_PGDN, "PageDown"],
+    [KEY_BACKTAB, "Backtab"],
+    [KEY_BACKSPACE, "Backspace"],
+    [KEY_TAB, "Tab"],
+    [KEY_ENTER, "Enter"],
+    [KEY_ESC, "Escape"],
+    [KEY_NUMPAD_0, "Numpad0"],
+    [KEY_NUMPAD_1, "Numpad1"],
+    [KEY_NUMPAD_2, "Numpad2"],
+    [KEY_NUMPAD_3, "Numpad3"],
+    [KEY_NUMPAD_4, "Numpad4"],
+    [KEY_NUMPAD_5, "Numpad5"],
+    [KEY_NUMPAD_6, "Numpad6"],
+    [KEY_NUMPAD_7, "Numpad7"],
+    [KEY_NUMPAD_8, "Numpad8"],
+    [KEY_NUMPAD_9, "Numpad9"],
+    [KEY_NUMPAD_DECIMAL, "NumpadDecimal"],
+    [KEY_NUMPAD_DIVIDE, "NumpadDivide"],
+    [KEY_NUMPAD_MULTIPLY, "NumpadMultiply"],
+    [KEY_NUMPAD_SUBTRACT, "NumpadSubtract"],
+    [KEY_NUMPAD_ADD, "NumpadAdd"],
+    [KEY_NUMPAD_ENTER, "NumpadEnter"],
+    [KEY_NUMPAD_EQUAL, "NumpadEqual"],
+    [KEY_SHIFT_LEFT, "ShiftLeft"],
+    [KEY_SHIFT_RIGHT, "ShiftRight"],
+    [KEY_CONTROL_LEFT, "ControlLeft"],
+    [KEY_CONTROL_RIGHT, "ControlRight"],
+    [KEY_ALT_LEFT, "AltLeft"],
+    [KEY_ALT_RIGHT, "AltRight"],
+    [KEY_SUPER_LEFT, "SuperLeft"],
+    [KEY_SUPER_RIGHT, "SuperRight"],
+    [KEY_HYPER_LEFT, "HyperLeft"],
+    [KEY_HYPER_RIGHT, "HyperRight"],
+    [KEY_META_LEFT, "MetaLeft"],
+    [KEY_META_RIGHT, "MetaRight"],
+    [KEY_CAPS_LOCK, "CapsLock"],
+    [KEY_NUM_LOCK, "NumLock"],
+    [KEY_SCROLL_LOCK, "ScrollLock"],
+]);
+const BUTTON_NAMES = new Map([
+    [KEY_MOUSE_LEFT, "left"],
+    [KEY_MOUSE_RIGHT, "right"],
+    [KEY_MOUSE_MIDDLE, "middle"],
+    [KEY_MOUSE_RELEASE, "release"],
+]);
+function mods(native) {
+    let m = {};
+    if (native.mod & MOD_ALT)
+        m.alt = true;
+    if (native.mod & MOD_CTRL)
+        m.ctrl = true;
+    if (native.mod & MOD_SHIFT)
+        m.shift = true;
+    return m;
+}
+function keyName(native) {
+    let name = KEY_NAMES.get(native.key);
+    if (name) {
+        return name;
+    }
+    else if (native.key === 0 && native.ch > 0) {
+        return String.fromCodePoint(native.ch);
+    }
+    else if (native.key > 0 && native.key < 0x20) {
+        return String.fromCharCode(native.key + 0x60);
+    }
+    else {
+        return String.fromCodePoint(native.ch || native.key);
+    }
+}
+function textFromNative(native) {
+    if (native.text.length === 0) {
+        return undefined;
+    }
+    else {
+        return String.fromCodePoint(...native.text);
+    }
+}
+function mapKeyEvent(native) {
+    let key = keyName(native);
+    let code = (native.base > 0 ? String.fromCodePoint(native.base) : key);
+    let m = mods(native);
+    let isChar = !KEY_NAMES.has(native.key);
+    let text = textFromNative(native);
+    if (native.action === 3) {
+        return { type: "keyup", key, code, ...m };
+    }
+    let type = native.action === 2
+        ? "keyrepeat"
+        : "keydown";
+    let ev = { type, key, code, ...m };
+    if (native.shifted > 0)
+        ev.shifted = String.fromCodePoint(native.shifted);
+    if (text) {
+        ev.text = text;
+    }
+    else if (isChar && type === "keydown" && native.ch > 0) {
+        ev.text = String.fromCodePoint(native.ch);
+    }
+    return ev;
+}
+function mapEvent(native) {
+    switch (native.type) {
+        case EVENT_KEY: {
+            return mapKeyEvent(native);
+        }
+        case EVENT_MOUSE: {
+            if (native.key === KEY_MOUSE_WHEEL_UP || native.key === KEY_MOUSE_WHEEL_DOWN) {
+                return {
+                    type: "wheel",
+                    direction: native.key === KEY_MOUSE_WHEEL_UP ? "up" : "down",
+                    x: native.x,
+                    y: native.y,
+                    ...mods(native),
+                };
+            }
+            if (native.mod & MOD_MOTION) {
+                let button = BUTTON_NAMES.get(native.key) ?? "left";
+                return {
+                    type: "mousemove",
+                    button: button === "release" ? "left" : button,
+                    x: native.x,
+                    y: native.y,
+                    ...mods(native),
+                };
+            }
+            let button = BUTTON_NAMES.get(native.key) ?? "left";
+            if (native.mod & MOD_RELEASE) {
+                return {
+                    type: "mouseup",
+                    button,
+                    x: native.x,
+                    y: native.y,
+                    ...mods(native),
+                };
+            }
+            else {
+                return {
+                    type: "mousedown",
+                    button: button,
+                    x: native.x,
+                    y: native.y,
+                    ...mods(native),
+                };
+            }
+        }
+        case EVENT_RESIZE: {
+            return { type: "resize", width: native.w, height: native.h };
+        }
+        case EVENT_CURSOR: {
+            return { type: "cursor", row: native.y, column: native.x };
+        }
+        default: {
+            return mapKeyEvent(native);
+        }
+    }
+}

package/esm/mod.d.ts

@@ -0,0 +1,5 @@
+export * from "./ops.js";
+export * from "./term.js";
+export * from "./input.js";
+export * from "./settings.js";
+export * from "./termcodes.js";

package/esm/mod.js

@@ -0,0 +1,5 @@
+export * from "./ops.js";
+export * from "./term.js";
+export * from "./input.js";
+export * from "./settings.js";
+export * from "./termcodes.js";

package/esm/ops.d.ts

@@ -0,0 +1,106 @@
+declare const OP_OPEN_ELEMENT = 2;
+declare const OP_TEXT = 3;
+declare const OP_CLOSE_ELEMENT = 4;
+declare const OP_SNAPSHOT = 5;
+export declare function pack(ops: Op[], mem: ArrayBufferLike, offset: number, limit?: number): number;
+export declare function rgba(r: number, g: number, b: number, a?: number): number;
+export type SizingAxis = {
+    type: "fit";
+    min?: number;
+    max?: number;
+} | {
+    type: "grow";
+    min?: number;
+    max?: number;
+} | {
+    type: "percent";
+    value: number;
+} | {
+    type: "fixed";
+    value: number;
+};
+export declare const fit: (min?: number, max?: number) => SizingAxis;
+export declare const grow: (min?: number, max?: number) => SizingAxis;
+export declare const percent: (value: number) => SizingAxis;
+export declare const fixed: (value: number) => SizingAxis;
+export interface CloseElement {
+    directive: typeof OP_CLOSE_ELEMENT;
+}
+export interface OpenElement {
+    directive: typeof OP_OPEN_ELEMENT;
+    id: string;
+    layout?: {
+        width?: SizingAxis;
+        height?: SizingAxis;
+        padding?: {
+            left?: number;
+            right?: number;
+            top?: number;
+            bottom?: number;
+        };
+        gap?: number;
+        direction?: "ltr" | "ttb";
+        alignX?: "left" | "center" | "right";
+        alignY?: "top" | "center" | "bottom";
+    };
+    bg?: number;
+    cornerRadius?: {
+        tl?: number;
+        tr?: number;
+        bl?: number;
+        br?: number;
+    };
+    border?: {
+        color: number;
+        bg?: number;
+        left?: number;
+        right?: number;
+        top?: number;
+        bottom?: number;
+    };
+    clip?: {
+        horizontal?: boolean;
+        vertical?: boolean;
+    };
+    floating?: {
+        x?: number;
+        y?: number;
+        expand?: {
+            width?: number;
+            height?: number;
+        };
+        parent?: number;
+        attachTo?: AttachTo;
+        attachPoints?: {
+            element?: AttachPoint;
+            parent?: AttachPoint;
+        };
+        pointerCaptureMode?: PointerCaptureMode;
+        clipTo?: ClipTo;
+        zIndex?: number;
+    };
+}
+export type AttachPoint = "left-top" | "left-center" | "left-bottom" | "center-top" | "center-center" | "center-bottom" | "right-top" | "right-center" | "right-bottom";
+export type AttachTo = "none" | "parent" | "element" | "root";
+export type PointerCaptureMode = "capture" | "passthrough";
+export type ClipTo = "none" | "attached-parent";
+export interface Text {
+    directive: typeof OP_TEXT;
+    content: string;
+    color?: number;
+    bg?: number;
+    fontSize?: number;
+    fontId?: number;
+    wrap?: number;
+    attrs?: number;
+}
+interface Snapshot {
+    directive: typeof OP_SNAPSHOT;
+    data: Uint8Array;
+}
+export type Op = OpenElement | Text | CloseElement | Snapshot;
+export declare function open(id: string, props?: Omit<OpenElement, "directive" | "id">): OpenElement;
+export declare function text(content: string, props?: Omit<Text, "directive" | "content">): Text;
+export declare function close(): CloseElement;
+export declare function snapshot(ops: Op[]): Op;
+export {};

package/esm/ops.js

@@ -0,0 +1,307 @@
+/* Command buffer opcodes — mirrors ops.h */
+const OP_OPEN_ELEMENT = 0x02;
+const OP_TEXT = 0x03;
+const OP_CLOSE_ELEMENT = 0x04;
+const OP_SNAPSHOT = 0x05;
+/* Property group masks for OPEN_ELEMENT */
+const PROP_LAYOUT = 0x01;
+const PROP_BG_COLOR = 0x02;
+const PROP_CORNER_RADIUS = 0x04;
+const PROP_BORDER = 0x08;
+const PROP_CLIP = 0x10;
+const PROP_FLOATING = 0x20;
+const encoder = new TextEncoder();
+function packAxis(view, offset, axis) {
+    let o = offset;
+    switch (axis.type) {
+        case "fit":
+            view.setUint32(o, 0, true);
+            o += 4;
+            view.setFloat32(o, axis.min ?? 0, true);
+            o += 4;
+            view.setFloat32(o, axis.max ?? 0, true);
+            o += 4;
+            break;
+        case "grow":
+            view.setUint32(o, 1, true);
+            o += 4;
+            view.setFloat32(o, axis.min ?? 0, true);
+            o += 4;
+            view.setFloat32(o, axis.max ?? 0, true);
+            o += 4;
+            break;
+        case "percent":
+            view.setUint32(o, 2, true);
+            o += 4;
+            view.setFloat32(o, axis.value, true);
+            o += 4;
+            view.setFloat32(o, 0, true);
+            o += 4;
+            break;
+        case "fixed":
+            view.setUint32(o, 3, true);
+            o += 4;
+            view.setFloat32(o, axis.value, true);
+            o += 4;
+            view.setFloat32(o, 0, true);
+            o += 4;
+            break;
+    }
+    return o;
+}
+function packString(view, bytes, o, end, context) {
+    let paddedLength = Math.ceil(bytes.length / 4) * 4;
+    let next = o + 4 + paddedLength;
+    if (next > end) {
+        throw new RangeError(`transfer buffer capacity exceeded while packing ${context} ` +
+            `(${next} byte offset, ${end} byte limit). ` +
+            `Render a smaller visible slice or reduce frame content.`);
+    }
+    view.setUint32(o, bytes.length, true);
+    o += 4;
+    new Uint8Array(view.buffer).set(bytes, o);
+    o += paddedLength;
+    return o;
+}
+export function pack(ops, mem, offset, limit) {
+    let view = new DataView(mem);
+    let end = limit ?? mem.byteLength;
+    let o = offset;
+    for (let op of ops) {
+        switch (op.directive) {
+            case OP_CLOSE_ELEMENT:
+                view.setUint32(o, op.directive, true);
+                o += 4;
+                break;
+            case OP_OPEN_ELEMENT: {
+                view.setUint32(o, OP_OPEN_ELEMENT, true);
+                o += 4;
+                let bytes = encoder.encode(op.id);
+                o = packString(view, bytes, o, end, "element id");
+                let mask = 0;
+                if (op.layout)
+                    mask |= PROP_LAYOUT;
+                if (op.bg !== undefined)
+                    mask |= PROP_BG_COLOR;
+                if (op.cornerRadius)
+                    mask |= PROP_CORNER_RADIUS;
+                if (op.border)
+                    mask |= PROP_BORDER;
+                if (op.clip)
+                    mask |= PROP_CLIP;
+                if (op.floating)
+                    mask |= PROP_FLOATING;
+                view.setUint32(o, mask, true);
+                o += 4;
+                if (op.layout) {
+                    let l = op.layout;
+                    o = packAxis(view, o, l.width ?? { type: "fit" });
+                    o = packAxis(view, o, l.height ?? { type: "fit" });
+                    let p = l.padding ?? {};
+                    view.setUint32(o, (p.left ?? 0) | ((p.right ?? 0) << 8) | ((p.top ?? 0) << 16) |
+                        ((p.bottom ?? 0) << 24), true);
+                    o += 4;
+                    view.setUint32(o, (l.gap ?? 0) | ((l.direction === "ttb" ? 1 : 0) << 16), true);
+                    o += 4;
+                    let alignX = l.alignX === "right" ? 1 : l.alignX === "center" ? 2 : 0;
+                    let alignY = l.alignY === "bottom"
+                        ? 1
+                        : l.alignY === "center"
+                            ? 2
+                            : 0;
+                    view.setUint32(o, alignX | (alignY << 8), true);
+                    o += 4;
+                }
+                if (op.bg !== undefined) {
+                    view.setUint32(o, op.bg, true);
+                    o += 4;
+                }
+                if (op.cornerRadius) {
+                    let cr = op.cornerRadius;
+                    view.setUint32(o, (cr.tl ?? 0) | ((cr.tr ?? 0) << 8) | ((cr.bl ?? 0) << 16) |
+                        ((cr.br ?? 0) << 24), true);
+                    o += 4;
+                }
+                if (op.border) {
+                    let b = op.border;
+                    view.setUint32(o, b.color, true);
+                    o += 4;
+                    // ATTR_DEFAULT sentinel (bit 31 set) means "use terminal default bg"
+                    let bg = b.bg === undefined ? 0x80000000 : b.bg & 0x00FFFFFF;
+                    view.setUint32(o, bg, true);
+                    o += 4;
+                    view.setUint32(o, (b.left ?? 0) | ((b.right ?? 0) << 8) | ((b.top ?? 0) << 16) |
+                        ((b.bottom ?? 0) << 24), true);
+                    o += 4;
+                }
+                if (op.clip) {
+                    view.setUint32(o, (op.clip.horizontal ? 1 : 0) | ((op.clip.vertical ? 1 : 0) << 8), true);
+                    o += 4;
+                }
+                if (op.floating) {
+                    let f = op.floating;
+                    view.setFloat32(o, f.x ?? 0, true);
+                    o += 4;
+                    view.setFloat32(o, f.y ?? 0, true);
+                    o += 4;
+                    view.setFloat32(o, f.expand?.width ?? 0, true);
+                    o += 4;
+                    view.setFloat32(o, f.expand?.height ?? 0, true);
+                    o += 4;
+                    view.setUint32(o, f.parent ?? 0, true);
+                    o += 4;
+                    view.setUint32(o, encodeAttachTo(f.attachTo) |
+                        (encodeAttachPoint(f.attachPoints?.element) << 8) |
+                        (encodeAttachPoint(f.attachPoints?.parent) << 16) |
+                        (encodePointerCaptureMode(f.pointerCaptureMode) << 24), true);
+                    o += 4;
+                    view.setUint32(o, encodeClipTo(f.clipTo) | (((f.zIndex ?? 0) & 0xffff) << 8), true);
+                    o += 4;
+                }
+                break;
+            }
+            case OP_SNAPSHOT: {
+                new Uint8Array(mem).set(op.data, o);
+                o += op.data.length;
+                break;
+            }
+            case OP_TEXT: {
+                view.setUint32(o, OP_TEXT, true);
+                o += 4;
+                // No explicit color: leave the terminal default foreground by writing
+                // 0 and setting ATTR_DEFAULT (0x80 in the attrs byte). The C path ORs
+                // it into fg and emit_attr skips the foreground SGR (mirrors unset bg).
+                let textDefault = op.color === undefined;
+                view.setUint32(o, op.color ?? 0, true);
+                o += 4;
+                // No explicit bg: leave the terminal default bg by writing
+                // 0 and setting ATTR_DEFAULT (0x80 in the attrs byte). The C path ORs
+                // it into bg and emit_attr skips the background SGR
+                let bg = op.bg === undefined ? 0x80000000 : op.bg & 0x00FFFFFF;
+                view.setUint32(o, bg, true);
+                o += 4;
+                view.setUint32(o, (op.fontSize ?? 1) |
+                    ((op.fontId ?? 0) << 8) |
+                    ((op.wrap ?? 0) << 16) |
+                    (((op.attrs ?? 0) | (textDefault ? 0x80 : 0)) << 24), true);
+                o += 4;
+                let str = encoder.encode(op.content);
+                o = packString(view, str, o, end, "text content");
+                break;
+            }
+        }
+        if (o > end) {
+            throw new RangeError(`ops exceed buffer capacity (${o - offset} bytes packed, ${end - offset} available)`);
+        }
+    }
+    return (o - offset) / 4;
+}
+export function rgba(r, g, b, a = 255) {
+    return ((a & 0xFF) << 24) | ((r & 0xFF) << 16) | ((g & 0xFF) << 8) |
+        (b & 0xFF);
+}
+export const fit = (min = 0, max = 0) => ({
+    type: "fit",
+    min,
+    max,
+});
+export const grow = (min = 0, max = 0) => ({
+    type: "grow",
+    min,
+    max,
+});
+export const percent = (value) => ({
+    type: "percent",
+    value,
+});
+export const fixed = (value) => ({ type: "fixed", value });
+const ATTACH_POINT = {
+    "left-top": 0,
+    "left-center": 1,
+    "left-bottom": 2,
+    "center-top": 3,
+    "center-center": 4,
+    "center-bottom": 5,
+    "right-top": 6,
+    "right-center": 7,
+    "right-bottom": 8,
+};
+const ATTACH_TO = {
+    none: 0,
+    parent: 1,
+    element: 2,
+    root: 3,
+};
+const POINTER_CAPTURE_MODE = {
+    capture: 0,
+    passthrough: 1,
+};
+const CLIP_TO = {
+    none: 0,
+    "attached-parent": 1,
+};
+function encodeAttachPoint(value) {
+    return value === undefined ? 0 : ATTACH_POINT[value];
+}
+function encodeAttachTo(value) {
+    return value === undefined ? 0 : ATTACH_TO[value];
+}
+function encodePointerCaptureMode(value) {
+    return value === undefined ? 0 : POINTER_CAPTURE_MODE[value];
+}
+function encodeClipTo(value) {
+    return value === undefined ? 0 : CLIP_TO[value];
+}
+export function open(id, props = {}) {
+    return { directive: OP_OPEN_ELEMENT, id, ...props };
+}
+export function text(content, props = {}) {
+    return { directive: OP_TEXT, content, ...props };
+}
+export function close() {
+    return { directive: OP_CLOSE_ELEMENT };
+}
+function packSize(ops) {
+    let n = 0;
+    for (let op of ops) {
+        switch (op.directive) {
+            case OP_CLOSE_ELEMENT:
+                n += 4;
+                break;
+            case OP_SNAPSHOT:
+                n += op.data.length;
+                break;
+            case OP_OPEN_ELEMENT: {
+                n += 4; // opcode
+                n += 4 + Math.ceil(encoder.encode(op.id).length / 4) * 4; // id string
+                n += 4; // mask
+                if (op.layout)
+                    n += 6 * 4 + 4 + 4 + 4; // 2 axes (3 words each) + pad + gap + align
+                if (op.bg !== undefined)
+                    n += 4;
+                if (op.cornerRadius)
+                    n += 4;
+                if (op.border)
+                    n += 12;
+                if (op.clip)
+                    n += 4;
+                // x, y, expand width/height, parent, attach/pointer, clip/z
+                if (op.floating)
+                    n += 7 * 4;
+                break;
+            }
+            case OP_TEXT: {
+                n += 4 + 4 + 4 + 4; // opcode + color + bg + cfg
+                n += 4 + Math.ceil(encoder.encode(op.content).length / 4) * 4; // string
+                break;
+            }
+        }
+    }
+    return n;
+}
+export function snapshot(ops) {
+    let size = packSize(ops);
+    let buf = new ArrayBuffer(size);
+    let words = pack(ops, buf, 0, size);
+    return { directive: OP_SNAPSHOT, data: new Uint8Array(buf, 0, words * 4) };
+}

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/settings.d.ts

@@ -0,0 +1,18 @@
+export interface Setting {
+    apply: Uint8Array;
+    revert: Uint8Array;
+}
+export declare function settings(...sequence: Setting[]): Setting;
+export declare function alternateBuffer(options?: {
+    clear?: boolean;
+}): Setting;
+export declare function cursor(visible: boolean): Setting;
+/**
+ * Save and restore cursor position using DECSC (`ESC 7`) / DECRC (`ESC 8`).
+ *
+ * @see {@link https://vt100.net/docs/vt510-rm/DECSC.html | VT510 DECSC}
+ * @see {@link https://vt100.net/docs/vt510-rm/DECRC.html | VT510 DECRC}
+ */
+export declare function saveCursorPosition(): Setting;
+export declare function progressiveInput(level: number): Setting;
+export declare function mouseTracking(): Setting;