coneko-term 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mm1995tk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/animation.d.ts

@@ -0,0 +1,18 @@
+/** 画素の並び（RGBA、1 画素 4 バイト、まっすぐなアルファ）とその大きさ。 */
+export interface Pixels {
+    rgba: Uint8ClampedArray;
+    width: number;
+    height: number;
+}
+/** 1 色（0xRRGGBBAA）で塗った画素の並び。 */
+export declare function solid(width: number, height: number, color: number): Pixels;
+/**
+ * `src` の四角（`sx`, `sy` から幅 `w`・高さ `h`）を、`dst` の `dx`, `dy` へ重ねる。
+ * `overwrite` なら置き換え、そうでなければアルファ合成（`src` が上）。どちらかの画素の外に
+ * はみ出す分は切る。
+ */
+export declare function compose(dst: Pixels, src: Pixels, sx: number, sy: number, dx: number, dy: number, w: number, h: number, overwrite: boolean): void;
+/** 画素の並びの写し。 */
+export declare function clone(p: Pixels): Pixels;
+/** 生の RGB（1 画素 3 バイト）か RGBA（4 バイト）から、RGBA の画素の並びを作る。長さが合わなければ `undefined`。 */
+export declare function fromRaw(bytes: Uint8Array, bpp: 3 | 4, width: number, height: number): Pixels | undefined;

package/dist/animation.js

@@ -0,0 +1,72 @@
+/** 1 色（0xRRGGBBAA）で塗った画素の並び。 */
+export function solid(width, height, color) {
+    const rgba = new Uint8ClampedArray(width * height * 4);
+    const r = (color >>> 24) & 0xff;
+    const g = (color >>> 16) & 0xff;
+    const b = (color >>> 8) & 0xff;
+    const a = color & 0xff;
+    if (r || g || b || a) {
+        for (let i = 0; i < rgba.length; i += 4) {
+            rgba[i] = r;
+            rgba[i + 1] = g;
+            rgba[i + 2] = b;
+            rgba[i + 3] = a;
+        }
+    }
+    return { rgba, width, height };
+}
+/**
+ * `src` の四角（`sx`, `sy` から幅 `w`・高さ `h`）を、`dst` の `dx`, `dy` へ重ねる。
+ * `overwrite` なら置き換え、そうでなければアルファ合成（`src` が上）。どちらかの画素の外に
+ * はみ出す分は切る。
+ */
+export function compose(dst, src, sx, sy, dx, dy, w, h, overwrite) {
+    // はみ出す分を切る
+    const w2 = Math.min(w, src.width - sx, dst.width - dx);
+    const h2 = Math.min(h, src.height - sy, dst.height - dy);
+    for (let y = 0; y < h2; y++) {
+        let s = ((sy + y) * src.width + sx) * 4;
+        let d = ((dy + y) * dst.width + dx) * 4;
+        for (let x = 0; x < w2; x++, s += 4, d += 4) {
+            const sa = src.rgba[s + 3];
+            if (overwrite || sa === 255) {
+                dst.rgba[d] = src.rgba[s];
+                dst.rgba[d + 1] = src.rgba[s + 1];
+                dst.rgba[d + 2] = src.rgba[s + 2];
+                dst.rgba[d + 3] = sa;
+                continue;
+            }
+            if (sa === 0)
+                continue;
+            const da = dst.rgba[d + 3];
+            // 上に重ねる（over）: 出力のアルファ = sa + da * (1 - sa)
+            const wd = (da * (255 - sa)) / 255;
+            const oa = sa + wd;
+            for (let c = 0; c < 3; c++) {
+                dst.rgba[d + c] = (src.rgba[s + c] * sa + dst.rgba[d + c] * wd) / oa;
+            }
+            dst.rgba[d + 3] = oa;
+        }
+    }
+}
+/** 画素の並びの写し。 */
+export function clone(p) {
+    return { rgba: p.rgba.slice(), width: p.width, height: p.height };
+}
+/** 生の RGB（1 画素 3 バイト）か RGBA（4 バイト）から、RGBA の画素の並びを作る。長さが合わなければ `undefined`。 */
+export function fromRaw(bytes, bpp, width, height) {
+    if (!(width > 0) || !(height > 0) || bytes.length !== width * height * bpp) {
+        return undefined;
+    }
+    if (bpp === 4) {
+        return { rgba: new Uint8ClampedArray(bytes), width, height };
+    }
+    const rgba = new Uint8ClampedArray(width * height * 4);
+    for (let i = 0, j = 0; i < bytes.length; i += 3, j += 4) {
+        rgba[j] = bytes[i];
+        rgba[j + 1] = bytes[i + 1];
+        rgba[j + 2] = bytes[i + 2];
+        rgba[j + 3] = 255;
+    }
+    return { rgba, width, height };
+}

package/dist/images.d.ts

@@ -0,0 +1,116 @@
+import { type Pixels } from "./animation.js";
+/** `WasmTerminal.placements` の 1 つの配置が使う数。並びは `ImagePlacement` の順。 */
+export declare const PLACEMENT_STRIDE = 16;
+/** `z` がこれより小さい画像は、背景色の下に描く（kitty の仕様）。 */
+export declare const Z_UNDER_BACKGROUND = -1073741824;
+/** 画面に置いてある画像の配置 1 つ。 */
+export interface ImagePlacement {
+    /** 左上のセルの行。見えている画面の一番上を 0 とする。スクロールバックの中は負。 */
+    row: number;
+    /** 画像の ID。 */
+    imageId: number;
+    /** 配置の番号（0 は無い）。 */
+    placementId: number;
+    /** 左上のセルの列。 */
+    col: number;
+    /** 元の画像の使う部分の左端・上端・幅・高さ（画素）。幅と高さが 0 なら端まで。 */
+    srcX: number;
+    srcY: number;
+    srcW: number;
+    srcH: number;
+    /** 左上のセルの中でのずれ（画素）。 */
+    offsetX: number;
+    offsetY: number;
+    /** 使うセルの列数・行数。 */
+    cols: number;
+    rows: number;
+    /** 重ねる順。負なら字の下、0 以上なら字の上。 */
+    z: number;
+    /** 画素のまま置くか（そうでなければ `cols` x `rows` のセルいっぱいに引き伸ばす）。 */
+    native: boolean;
+    /** 画素で決めた描く大きさ（幅・高さ）。0 なら `native` と `cols` x `rows` で決める。 */
+    destW: number;
+    destH: number;
+}
+/** `WasmTerminal.placements` の並びを読む。 */
+export declare function parsePlacements(flat: ArrayLike<number>): ImagePlacement[];
+/** 描ける画像（`ImageBitmap` など）。 */
+export interface DrawableImage {
+    readonly width: number;
+    readonly height: number;
+    close?(): void;
+}
+/** 画像を読み解く道具。既定はブラウザーの機能で、テストでは入れ替える。 */
+export interface ImageDecoder {
+    /** zlib（`o=z`）を戻す。 */
+    inflate(bytes: Uint8Array): Promise<Uint8Array>;
+    /** PNG を読み解く。 */
+    fromPng(bytes: Uint8Array): Promise<DrawableImage>;
+    /** RGBA（1 画素 4 バイト）の画素から作る。 */
+    fromRgba(rgba: Uint8ClampedArray, width: number, height: number): Promise<DrawableImage>;
+    /** PNG を RGBA の画素に読み解く。アニメーションのコマの合成に使う。無ければ、PNG の画像はアニメーションにせず、根だけを描く。 */
+    toRgba?(bytes: Uint8Array): Promise<Pixels>;
+}
+/** `DecompressionStream`、`createImageBitmap`、`ImageData` を使う、既定の `ImageDecoder`。 */
+export declare const browserImageDecoder: ImageDecoder;
+/** `ImageCache` が `Terminal` から読むもの。 */
+export interface ImageSource {
+    /** 持っている画像の `[ID, 通し番号]` の並び。 */
+    imageSerials(): ArrayLike<number>;
+    /** 画像の `[通し番号, 形式（0 RGB、1 RGBA、2 PNG）, 圧縮, 幅, 高さ]`。無ければ空。 */
+    imageInfo(id: number): ArrayLike<number>;
+    /** 画像のバイト列（圧縮も PNG もそのまま）。 */
+    imageData(id: number): Uint8Array;
+    /** アニメーションの状態 `[コマの数, いまのコマ, 再生の状態（1 止まる、2・3 回す）, いまのコマの表示時間（ミリ秒）, 操作の数]`。無ければ空。 */
+    animationInfo?(id: number): ArrayLike<number>;
+    /** いまのコマの表示時間が過ぎたと知らせる。次のコマへ進んだら `true`。 */
+    animationStep?(id: number): boolean;
+    /** コマを作る `index` 番目の操作（`WasmTerminal.frame_op` の並び）。 */
+    frameOp?(id: number, index: number): ArrayLike<number>;
+    /** 操作のバイト列。 */
+    frameOpData?(id: number, index: number): Uint8Array;
+}
+/**
+ * 読み解いた画像を ID ごとに覚えておく。画像が消えたり、同じ ID で別の画像に変わったら捨てる
+ * （`sync`）。読み解けない画像は描かない（エラーにしない）。読み解きは非同期なので、
+ * 終わったら `onReady` を呼ぶ。
+ *
+ * コマを足した画像（アニメーション）は、コマを作る操作を順に当てて画素を作り、いまのコマの
+ * 絵を返す（`get`）。コマを進める時刻は `tick` で決める。時計はこちらが持つ。
+ */
+export declare class ImageCache {
+    private source;
+    private decoder;
+    private onReady;
+    private entries;
+    private timers;
+    constructor(source: ImageSource, decoder: ImageDecoder, onReady: () => void);
+    /** 持っている画像に合わせて、いらなくなったものを捨てる。 */
+    sync(): void;
+    /** 画像 `id` の、コマを足してあれば、その状態。 */
+    private animation;
+    /**
+     * 時刻 `now`（ミリ秒）で、画像 `id` のコマを進める。表示時間が過ぎていたら次のコマへ。
+     * 回し続けている（また呼ぶ必要がある）なら `true`。
+     */
+    tick(id: number, now: number): boolean;
+    /** 画像 `id` の絵が変わるたびに増える数（アニメーションでなければ 0）。 */
+    version(id: number): number;
+    /** 読み解き終えた画像。まだ、または読み解けなかったら `undefined`（初めて頼まれたら読み解きを始める）。 */
+    get(id: number): DrawableImage | undefined;
+    /** 画像そのもの（根）を読み解き始める。 */
+    private startDecode;
+    private drop;
+    private decode;
+    /** 形式 `format`（0 RGB、1 RGBA、2 PNG）のデータを、画素の並びに読み解く。 */
+    private toPixels;
+    private getAnimated;
+    /** 覚えている絵が多すぎたら、見せていない古いものから閉じる。 */
+    private trim;
+    /** 届いている操作を、まだ当てていないぶん順に当てる。 */
+    private pump;
+    /** 操作 1 つを当てる。変わったコマの番号（1 始まり）を返す。 */
+    private apply;
+    /** 全部捨てる。 */
+    dispose(): void;
+}

package/dist/images.js

@@ -0,0 +1,359 @@
+import { clone, compose, fromRaw, solid } from "./animation.js";
+/** `WasmTerminal.placements` の 1 つの配置が使う数。並びは `ImagePlacement` の順。 */
+export const PLACEMENT_STRIDE = 16;
+/** `z` がこれより小さい画像は、背景色の下に描く（kitty の仕様）。 */
+export const Z_UNDER_BACKGROUND = -1_073_741_824;
+/** `WasmTerminal.placements` の並びを読む。 */
+export function parsePlacements(flat) {
+    const out = [];
+    for (let o = 0; o + PLACEMENT_STRIDE <= flat.length; o += PLACEMENT_STRIDE) {
+        out.push({
+            row: flat[o],
+            imageId: flat[o + 1],
+            placementId: flat[o + 2],
+            col: flat[o + 3],
+            srcX: flat[o + 4],
+            srcY: flat[o + 5],
+            srcW: flat[o + 6],
+            srcH: flat[o + 7],
+            offsetX: flat[o + 8],
+            offsetY: flat[o + 9],
+            cols: flat[o + 10],
+            rows: flat[o + 11],
+            z: flat[o + 12],
+            native: flat[o + 13] !== 0,
+            destW: flat[o + 14],
+            destH: flat[o + 15],
+        });
+    }
+    return out;
+}
+/** `DecompressionStream`、`createImageBitmap`、`ImageData` を使う、既定の `ImageDecoder`。 */
+export const browserImageDecoder = {
+    async inflate(bytes) {
+        const stream = new Blob([bytes])
+            .stream()
+            .pipeThrough(new DecompressionStream("deflate"));
+        return new Uint8Array(await new Response(stream).arrayBuffer());
+    },
+    fromPng(bytes) {
+        return createImageBitmap(new Blob([bytes], { type: "image/png" }));
+    },
+    fromRgba(rgba, width, height) {
+        return createImageBitmap(new ImageData(rgba, width, height));
+    },
+    async toRgba(bytes) {
+        const bitmap = await createImageBitmap(new Blob([bytes], { type: "image/png" }));
+        try {
+            const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
+            const ctx = canvas.getContext("2d");
+            if (!ctx)
+                throw new Error("coneko-term: canvas 2d context is unavailable");
+            ctx.drawImage(bitmap, 0, 0);
+            const data = ctx.getImageData(0, 0, bitmap.width, bitmap.height);
+            return { rgba: data.data, width: bitmap.width, height: bitmap.height };
+        }
+        finally {
+            bitmap.close();
+        }
+    },
+};
+/** 絵を覚えておくコマの数。これを超えたら古いものから閉じる。 */
+const BITMAP_LIMIT = 8;
+/**
+ * 読み解いた画像を ID ごとに覚えておく。画像が消えたり、同じ ID で別の画像に変わったら捨てる
+ * （`sync`）。読み解けない画像は描かない（エラーにしない）。読み解きは非同期なので、
+ * 終わったら `onReady` を呼ぶ。
+ *
+ * コマを足した画像（アニメーション）は、コマを作る操作を順に当てて画素を作り、いまのコマの
+ * 絵を返す（`get`）。コマを進める時刻は `tick` で決める。時計はこちらが持つ。
+ */
+export class ImageCache {
+    source;
+    decoder;
+    onReady;
+    entries = new Map();
+    timers = new Map();
+    constructor(source, decoder, onReady) {
+        this.source = source;
+        this.decoder = decoder;
+        this.onReady = onReady;
+    }
+    /** 持っている画像に合わせて、いらなくなったものを捨てる。 */
+    sync() {
+        if (this.entries.size === 0)
+            return;
+        const alive = new Map();
+        const flat = this.source.imageSerials();
+        for (let i = 0; i + 1 < flat.length; i += 2)
+            alive.set(flat[i], flat[i + 1]);
+        for (const [id, entry] of this.entries) {
+            if (alive.get(id) !== entry.serial)
+                this.drop(id, entry);
+        }
+        for (const id of this.timers.keys()) {
+            if (!alive.has(id))
+                this.timers.delete(id);
+        }
+    }
+    /** 画像 `id` の、コマを足してあれば、その状態。 */
+    animation(id) {
+        const info = this.source.animationInfo?.(id);
+        return info && info.length >= 5 && info[4] > 0 ? info : undefined;
+    }
+    /**
+     * 時刻 `now`（ミリ秒）で、画像 `id` のコマを進める。表示時間が過ぎていたら次のコマへ。
+     * 回し続けている（また呼ぶ必要がある）なら `true`。
+     */
+    tick(id, now) {
+        const info = this.animation(id);
+        if (!info)
+            return false;
+        const [frames, current, state, gap] = Array.from(info);
+        if (frames < 2)
+            return false;
+        const timer = this.timers.get(id);
+        if (!timer || timer.current !== current || state === 1) {
+            this.timers.set(id, { current, since: now });
+            return state !== 1;
+        }
+        if (now - timer.since >= Math.max(gap, 0)) {
+            if (this.source.animationStep?.(id)) {
+                const after = this.source.animationInfo?.(id);
+                this.timers.set(id, { current: after?.[1] ?? current, since: now });
+            }
+            else {
+                timer.since = now;
+            }
+        }
+        return true;
+    }
+    /** 画像 `id` の絵が変わるたびに増える数（アニメーションでなければ 0）。 */
+    version(id) {
+        return this.entries.get(id)?.anim?.version ?? 0;
+    }
+    /** 読み解き終えた画像。まだ、または読み解けなかったら `undefined`（初めて頼まれたら読み解きを始める）。 */
+    get(id) {
+        let entry = this.entries.get(id);
+        const anim = entry?.anim?.dead ? undefined : this.animation(id);
+        if (anim) {
+            if (!entry) {
+                const info = this.source.imageInfo(id);
+                if (info.length < 5)
+                    return undefined;
+                entry = { serial: info[0] };
+                this.entries.set(id, entry);
+            }
+            return this.getAnimated(id, entry, anim);
+        }
+        if (entry) {
+            // コマを使えない画像は、根だけを通常の画像として描く
+            if (entry.anim?.dead && !entry.started)
+                this.startDecode(id, entry);
+            return entry.image;
+        }
+        const info = this.source.imageInfo(id);
+        if (info.length < 5)
+            return undefined;
+        const fresh = { serial: info[0] };
+        this.entries.set(id, fresh);
+        this.startDecode(id, fresh);
+        return undefined;
+    }
+    /** 画像そのもの（根）を読み解き始める。 */
+    startDecode(id, fresh) {
+        const info = this.source.imageInfo(id);
+        if (info.length < 5)
+            return;
+        fresh.started = true;
+        const data = this.source.imageData(id);
+        void this.decode(info, data).then((image) => {
+            if (image && this.entries.get(id) === fresh) {
+                fresh.image = image;
+                this.onReady();
+            }
+            else {
+                image?.close?.();
+            }
+        }, () => { });
+    }
+    drop(id, entry) {
+        this.entries.delete(id);
+        entry.image?.close?.();
+        if (entry.anim) {
+            const all = new Set([...entry.anim.bitmaps.values(), entry.anim.shown]);
+            for (const b of all)
+                b?.close?.();
+            entry.anim.bitmaps.clear();
+            entry.anim.shown = undefined;
+        }
+    }
+    async decode(info, data) {
+        const [, format, compressed, width, height] = Array.from(info);
+        let bytes = data;
+        if (compressed)
+            bytes = await this.decoder.inflate(bytes);
+        if (format === 2)
+            return this.decoder.fromPng(bytes);
+        const pixels = fromRaw(bytes, format === 0 ? 3 : 4, width, height);
+        if (!pixels)
+            return undefined;
+        return this.decoder.fromRgba(pixels.rgba, width, height);
+    }
+    /** 形式 `format`（0 RGB、1 RGBA、2 PNG）のデータを、画素の並びに読み解く。 */
+    async toPixels(format, compressed, data, width, height) {
+        const bytes = compressed ? await this.decoder.inflate(data) : data;
+        if (format === 2)
+            return this.decoder.toRgba?.(bytes);
+        return fromRaw(bytes, format === 0 ? 3 : 4, width, height);
+    }
+    getAnimated(id, entry, info) {
+        const a = (entry.anim ??= {
+            frames: [],
+            applied: 0,
+            busy: false,
+            dead: false,
+            bitmaps: new Map(),
+            pending: new Set(),
+            version: 0,
+        });
+        if (a.applied < info[4] && !a.busy && !a.dead)
+            void this.pump(id, entry, a);
+        const frame = info[1];
+        const bitmap = a.bitmaps.get(frame);
+        if (bitmap) {
+            if (a.shown !== bitmap) {
+                a.shown = bitmap;
+                a.version++;
+            }
+            return bitmap;
+        }
+        const pixels = a.frames[frame - 1];
+        if (pixels && !a.pending.has(frame)) {
+            a.pending.add(frame);
+            void this.decoder.fromRgba(pixels.rgba.slice(), pixels.width, pixels.height).then((image) => {
+                a.pending.delete(frame);
+                if (this.entries.get(id) !== entry) {
+                    image.close?.();
+                    return;
+                }
+                // 操作でこのコマが変わっていたら、古い絵なので使わない
+                if (a.frames[frame - 1] !== pixels) {
+                    image.close?.();
+                }
+                else {
+                    a.bitmaps.set(frame, image);
+                    this.trim(a);
+                }
+                this.onReady();
+            }, () => a.pending.delete(frame));
+        }
+        return a.shown ?? entry.image;
+    }
+    /** 覚えている絵が多すぎたら、見せていない古いものから閉じる。 */
+    trim(a) {
+        for (const [frame, image] of a.bitmaps) {
+            if (a.bitmaps.size <= BITMAP_LIMIT)
+                break;
+            if (image === a.shown)
+                continue;
+            a.bitmaps.delete(frame);
+            image.close?.();
+        }
+    }
+    /** 届いている操作を、まだ当てていないぶん順に当てる。 */
+    async pump(id, entry, a) {
+        a.busy = true;
+        const alive = () => this.entries.get(id) === entry;
+        try {
+            if (a.frames.length === 0) {
+                const info = this.source.imageInfo(id);
+                if (info.length < 5)
+                    return;
+                const [, format, compressed, width, height] = Array.from(info);
+                const root = await this.toPixels(format, compressed !== 0, this.source.imageData(id), width, height);
+                if (!alive())
+                    return;
+                if (!root) {
+                    a.dead = true;
+                    return;
+                }
+                a.frames.push(root);
+            }
+            for (;;) {
+                const total = this.animation(id)?.[4] ?? 0;
+                if (a.applied >= total || !alive())
+                    break;
+                const op = this.source.frameOp?.(id, a.applied);
+                if (!op || op.length === 0)
+                    break;
+                const touched = await this.apply(id, a, op, a.applied);
+                if (!alive())
+                    return;
+                a.applied++;
+                // 変わったコマの絵は作り直す
+                const old = a.bitmaps.get(touched);
+                a.bitmaps.delete(touched);
+                if (old && old !== a.shown)
+                    old.close?.();
+            }
+        }
+        catch {
+            // 根が読めなければ、コマは使わない。操作が当てられないだけなら、飛ばして次へ
+            if (a.frames.length === 0)
+                a.dead = true;
+        }
+        finally {
+            a.busy = false;
+        }
+        if (alive())
+            this.onReady();
+    }
+    /** 操作 1 つを当てる。変わったコマの番号（1 始まり）を返す。 */
+    async apply(id, a, op, index) {
+        const root = a.frames[0];
+        if (op[0] === 1) {
+            const [, srcFrame, dstFrame, sx, sy, dx, dy, w, h, overwrite] = Array.from(op);
+            const src = a.frames[srcFrame - 1];
+            const dst = a.frames[dstFrame - 1];
+            if (src && dst) {
+                // 絵を作っている途中の写しと取り違えないよう、新しい画素に差し替える
+                const next = clone(dst);
+                compose(next, src, sx, sy, dx, dy, w, h, overwrite !== 0);
+                a.frames[dstFrame - 1] = next;
+            }
+            return dstFrame;
+        }
+        const [, target, baseKind, baseValue, x, y, width, height, overwrite, format, compressed] = Array.from(op);
+        const base = baseKind === 0
+            ? a.frames[target - 1]
+            : baseKind === 1
+                ? a.frames[baseValue - 1]
+                : undefined;
+        // 差し替えるので、元の画素は書き換えない
+        const canvas = base
+            ? clone(base)
+            : solid(root.width, root.height, baseKind === 2 ? baseValue : 0);
+        // 読み解けないデータでも、コマは作る（下地のまま）
+        const data = this.source.frameOpData?.(id, index) ?? new Uint8Array();
+        try {
+            const pixels = await this.toPixels(format, compressed !== 0, data, width, height);
+            if (pixels)
+                compose(canvas, pixels, 0, 0, x, y, pixels.width, pixels.height, overwrite !== 0);
+        }
+        catch {
+            // 下地のまま
+        }
+        if (target > a.frames.length)
+            a.frames.push(canvas);
+        else
+            a.frames[target - 1] = canvas;
+        return target;
+    }
+    /** 全部捨てる。 */
+    dispose() {
+        for (const [id, entry] of [...this.entries])
+            this.drop(id, entry);
+        this.timers.clear();
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `init()` に渡せる .wasm。
+ * .wasm のバイト列（`BufferSource`）か、コンパイル済みの `WebAssembly.Module`。
+ */
+export type WasmSource = BufferSource | WebAssembly.Module;
+/**
+ * WebAssembly を読み込む。ほかの関数や `Terminal` を使う前に呼ぶ。2 回目以降は何もしない。
+ * 引数を省くと、パッケージ内の .wasm を fetch で読む。
+ * Node.js などで fetch できないときは、.wasm のバイト列かモジュールを渡す。
+ */
+export declare function init(source?: WasmSource): Promise<void>;
+/** coneko-term の版。`init()` のあとに呼ぶ。 */
+export declare function version(): string;
+export { CELL_STRIDE, CLUSTER_FLAG, Terminal, type ClipboardItem, type ClipboardLocation, type ClipboardReadError, type ClipboardReadRequest, type ClipboardWriteRequest, type ClipboardWriteStatus, type DndErrorName, type DndEvent, type DndLocation, type DndOperation, type DndOperations, type DragImage, type DropDataForm, type DropRequest, type FileTransferErrorName, type FileTransferEvent, type FileTransferFileType, type FileTransferListing, type FileTransferStart, type CursorState, type ExtraCursorState, type MouseInput, type ProgramKind, type ProgramState, type ProgramStatus, type ProgramStatusChange, type NotificationSupport, type TerminalNotification, type WheelInput, type Disposable, type RowView, type SizedInfo, type TerminalOptions, type Theme, } from "./terminal.js";
+export { browserEnv, CanvasRenderer, Palette, SCROLLBAR_WIDTH, proposeDimensions, type CellSize, type FitInput, type RenderEnv, type RenderOptions, type RenderSource, } from "./renderer.js";
+export { PLACEMENT_STRIDE, Z_UNDER_BACKGROUND, ImageCache, browserImageDecoder, parsePlacements, type DrawableImage, type ImageDecoder, type ImagePlacement, type ImageSource, } from "./images.js";
+export { SelectionModel, type BufferPosition, type SelectionHost, type SelectionKind, type SelectionRange, } from "./selection.js";
+export { bracketTextForPaste, evaluateKeyboardEvent, KITTY_DISAMBIGUATE, KITTY_REPORT_ALL_KEYS, KITTY_REPORT_ALTERNATE_KEYS, KITTY_REPORT_EVENT_TYPES, KITTY_REPORT_TEXT, prepareTextForTerminal, type KeyEventLike, type KeyEventType, type KeyResult, type KeyResultType, } from "./keyboard.js";
+export { CompositionHelper, KeyHandler, type CompositionAnchor, type CompositionViewLike, type KeyHandlerHost, type TextareaLike, } from "./input.js";

package/dist/index.js

@@ -0,0 +1,21 @@
+import wasmInit, { version as wasmVersion } from "./wasm/coneko_term_wasm.js";
+import { setMemory } from "./memory.js";
+/**
+ * WebAssembly を読み込む。ほかの関数や `Terminal` を使う前に呼ぶ。2 回目以降は何もしない。
+ * 引数を省くと、パッケージ内の .wasm を fetch で読む。
+ * Node.js などで fetch できないときは、.wasm のバイト列かモジュールを渡す。
+ */
+export async function init(source) {
+    const out = await wasmInit(source === undefined ? undefined : { module_or_path: source });
+    setMemory(out.memory);
+}
+/** coneko-term の版。`init()` のあとに呼ぶ。 */
+export function version() {
+    return wasmVersion();
+}
+export { CELL_STRIDE, CLUSTER_FLAG, Terminal, } from "./terminal.js";
+export { browserEnv, CanvasRenderer, Palette, SCROLLBAR_WIDTH, proposeDimensions, } from "./renderer.js";
+export { PLACEMENT_STRIDE, Z_UNDER_BACKGROUND, ImageCache, browserImageDecoder, parsePlacements, } from "./images.js";
+export { SelectionModel, } from "./selection.js";
+export { bracketTextForPaste, evaluateKeyboardEvent, KITTY_DISAMBIGUATE, KITTY_REPORT_ALL_KEYS, KITTY_REPORT_ALTERNATE_KEYS, KITTY_REPORT_EVENT_TYPES, KITTY_REPORT_TEXT, prepareTextForTerminal, } from "./keyboard.js";
+export { CompositionHelper, KeyHandler, } from "./input.js";