@orz/ui-hex 0.0.0-stage → 0.0.0

package/dist/decode.js

@@ -0,0 +1,63 @@
+// DataView.getFloat16 is too new to rely on in every consumer's target.
+export function float16(bits) {
+    const sign = bits & 0x8000 ? -1 : 1;
+    const exponent = (bits >> 10) & 0x1f;
+    const mantissa = bits & 0x3ff;
+    if (exponent === 0)
+        return sign * mantissa * 2 ** -24;
+    if (exponent === 0x1f)
+        return mantissa ? Number.NaN : sign * Infinity;
+    return sign * (1 + mantissa / 1024) * 2 ** (exponent - 15);
+}
+function formatFloat(value) {
+    return Object.is(value, -0) ? "-0" : String(value);
+}
+const ROWS = [
+    {
+        label: "Binary",
+        width: 1,
+        read: (v) => v.getUint8(0).toString(2).padStart(8, "0"),
+    },
+    { label: "Int8", width: 1, read: (v) => String(v.getInt8(0)) },
+    { label: "Uint8", width: 1, read: (v) => String(v.getUint8(0)) },
+    { label: "Int16", width: 2, read: (v, le) => String(v.getInt16(0, le)) },
+    { label: "Uint16", width: 2, read: (v, le) => String(v.getUint16(0, le)) },
+    { label: "Int32", width: 4, read: (v, le) => String(v.getInt32(0, le)) },
+    { label: "Uint32", width: 4, read: (v, le) => String(v.getUint32(0, le)) },
+    {
+        label: "Int64",
+        width: 8,
+        read: (v, le) => v.getBigInt64(0, le).toString(),
+    },
+    {
+        label: "Uint64",
+        width: 8,
+        read: (v, le) => v.getBigUint64(0, le).toString(),
+    },
+    {
+        label: "Float16",
+        width: 2,
+        read: (v, le) => formatFloat(float16(v.getUint16(0, le))),
+    },
+    {
+        label: "Float32",
+        width: 4,
+        read: (v, le) => formatFloat(v.getFloat32(0, le)),
+    },
+    {
+        label: "Float64",
+        width: 8,
+        read: (v, le) => formatFloat(v.getFloat64(0, le)),
+    },
+];
+/** One entry per inspector row, read from the first `available` bytes of `bytes`. */
+export function decodeAll(bytes, available, littleEndian) {
+    const n = Math.min(available, bytes.length);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, n);
+    return ROWS.map(({ label, width, read }) => ({
+        label,
+        width,
+        value: n >= width ? read(view, littleEndian) : null,
+    }));
+}
+//# sourceMappingURL=decode.js.map

package/dist/decode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode.js","sourceRoot":"","sources":["../src/decode.ts"],"names":[],"mappings":"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"}

package/dist/document.d.ts

@@ -0,0 +1,75 @@
+import type { ByteSource } from "./source.ts";
+import type { HexSelection } from "./types.ts";
+export interface HexDocumentOptions {
+    /** false locks the size: no insert mode, no delete or cut, no typing or pasting past the end. Default true. */
+    resizable?: boolean;
+}
+export type HexPiece = 
+/** A range of the original source. */
+{
+    kind: "source";
+    offset: number;
+    length: number;
+}
+/** Bytes that came from editing; a view onto the document's own buffer. */
+ | {
+    kind: "bytes";
+    bytes: Uint8Array;
+};
+export interface HexDocument extends ByteSource {
+    readonly source: ByteSource;
+    readonly resizable: boolean;
+    /** The undo position differs from the one `markSaved()` recorded. */
+    readonly dirty: boolean;
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+    peek(offset: number, length: number): Uint8Array | undefined;
+    subscribe(onChange: () => void): () => void;
+    /** Replace `length` bytes at `offset` with `bytes`; insert is length 0, delete is empty bytes. */
+    replace(offset: number, length: number, bytes: Uint8Array): void;
+    insert(offset: number, bytes: Uint8Array): void;
+    /** Writes over the bytes from `offset`; past the end it extends the document, or stops there when the size is locked. */
+    overwrite(offset: number, bytes: Uint8Array): void;
+    delete(offset: number, length: number): void;
+    undo(): void;
+    redo(): void;
+    markSaved(): void;
+    /** Ranges in [offset, offset + length) whose bytes came from editing, as [start, end) pairs. */
+    modifiedRanges(offset: number, length: number): Array<[number, number]>;
+    pieces(): HexPiece[];
+    toBlob(type?: string): Promise<Blob>;
+    stream(): ReadableStream<Uint8Array>;
+}
+type EditKey = "type-hex" | "type-text";
+export type HexDocumentChange = {
+    kind: "edit";
+}
+/** Saved, or the source changed underneath: nothing to restore. */
+ | {
+    kind: "other";
+} | {
+    kind: "undo" | "redo";
+    selection: HexSelection | null | undefined;
+};
+export interface DocumentEdit {
+    offset: number;
+    length: number;
+    bytes: Uint8Array;
+    key?: EditKey;
+    before?: HexSelection | null;
+    after?: HexSelection | null;
+}
+export declare function createHexDocument(source: ByteSource, { resizable }?: HexDocumentOptions): HexDocument;
+export declare function isHexDocument(value: unknown): value is HexDocument;
+/** An edit carrying the editor's selections and a coalescing key; `replace` without them. */
+export declare function editDocument(doc: HexDocument, edit: DocumentEdit): void;
+/** Runs several edits as one undo step, with one notification. */
+export declare function editGroup(doc: HexDocument, fn: () => void): void;
+/** The next edit starts a new undo step even when it would continue the run. */
+export declare function breakRun(doc: HexDocument): void;
+/** What the most recent notification was for; undo and redo carry the selection to restore. */
+export declare function lastChange(doc: HexDocument): HexDocumentChange;
+/** Bumped by every change the document notifies. */
+export declare function documentVersion(doc: HexDocument): number;
+export {};
+//# sourceMappingURL=document.d.ts.map

package/dist/document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document.d.ts","sourceRoot":"","sources":["../src/document.ts"],"names":[],"mappings":"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"}

package/dist/document.js

@@ -0,0 +1,523 @@
+import { createPageCache } from "./page-cache.js";
+// Also the brand: a document is whatever createHexDocument registered here.
+const internals = new WeakMap();
+const ADD_CHUNK = 64 * 1024;
+const EXPORT_CHUNK = 1 << 20;
+function abortError(signal) {
+    return signal.reason ?? new DOMException("Aborted", "AbortError");
+}
+/** The buffer edits append to. Bytes once written are never rewritten, so pieces, undo steps and exports share it. */
+function createAddBuffer() {
+    const chunks = [];
+    const starts = [];
+    let fill = 0;
+    let end = 0;
+    const chunkAt = (at) => {
+        let lo = 0;
+        let hi = starts.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            if (starts[mid] <= at)
+                lo = mid;
+            else
+                hi = mid - 1;
+        }
+        return lo;
+    };
+    return {
+        /** Where `bytes` now live; always inside one chunk. */
+        append(bytes) {
+            let chunk = chunks.at(-1);
+            if (!chunk || chunk.length - fill < bytes.length) {
+                const start = chunk ? starts.at(-1) + chunk.length : 0;
+                chunk = new Uint8Array(Math.max(ADD_CHUNK, bytes.length));
+                chunks.push(chunk);
+                starts.push(start);
+                fill = 0;
+            }
+            chunk.set(bytes, fill);
+            const at = starts.at(-1) + fill;
+            fill += bytes.length;
+            end = at + bytes.length;
+            return at;
+        },
+        /** A view when the range sits in one chunk, else a copy. */
+        read(start, length) {
+            const i = chunkAt(start);
+            const chunk = chunks[i];
+            const at = start - starts[i];
+            if (at + length <= chunk.length)
+                return chunk.subarray(at, at + length);
+            const out = new Uint8Array(length);
+            let done = 0;
+            for (let c = i; done < length; c++) {
+                const from = c === i ? at : 0;
+                const part = chunks[c].subarray(from, from + length - done);
+                out.set(part, done);
+                done += part.length;
+            }
+            return out;
+        },
+        get end() {
+            return end;
+        },
+    };
+}
+function prefixEnds(pieces) {
+    const ends = new Array(pieces.length);
+    let at = 0;
+    for (let i = 0; i < pieces.length; i++) {
+        at += pieces[i].length;
+        ends[i] = at;
+    }
+    return ends;
+}
+/** The index of the piece holding byte `offset`; `pieces.length` at the end. */
+function pieceAt(ends, offset) {
+    let lo = 0;
+    let hi = ends.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (ends[mid] > offset)
+            hi = mid;
+        else
+            lo = mid + 1;
+    }
+    return lo;
+}
+function applySplice(pieces, index, remove, insert) {
+    return [
+        ...pieces.slice(0, index),
+        ...insert,
+        ...pieces.slice(index + remove),
+    ];
+}
+/** The record replacing [offset, offset + length) with `piece`, or nothing. */
+function spliceRecord(pieces, ends, offset, length, piece) {
+    let index = pieceAt(ends, offset);
+    const pieceStart = (i) => (i === 0 ? 0 : ends[i - 1]);
+    const end = offset + length;
+    const startsInside = index < pieces.length && pieceStart(index) < offset;
+    const last = length > 0 ? pieceAt(ends, end - 1) + 1 : startsInside ? index + 1 : index;
+    const removed = pieces.slice(index, last);
+    const inserted = [];
+    if (startsInside) {
+        const first = pieces[index];
+        inserted.push({ ...first, length: offset - pieceStart(index) });
+    }
+    if (piece) {
+        const prev = inserted.at(-1) ?? (index > 0 ? pieces[index - 1] : undefined);
+        if (prev &&
+            prev.buffer === "add" &&
+            piece.buffer === "add" &&
+            prev.start + prev.length === piece.start) {
+            const merged = { ...prev, length: prev.length + piece.length };
+            if (inserted.length)
+                inserted[inserted.length - 1] = merged;
+            else {
+                // The piece before the edit grows, so it moves into the record.
+                index--;
+                removed.unshift(prev);
+                inserted.push(merged);
+            }
+        }
+        else {
+            inserted.push(piece);
+        }
+    }
+    if (last > 0 && last - 1 >= index && removed.length) {
+        const tail = pieces[last - 1];
+        const tailEnd = ends[last - 1];
+        if (tailEnd > end) {
+            inserted.push({
+                ...tail,
+                start: tail.start + tail.length - (tailEnd - end),
+                length: tailEnd - end,
+            });
+        }
+    }
+    return { index, removed, inserted };
+}
+export function createHexDocument(source, { resizable = true } = {}) {
+    const add = createAddBuffer();
+    let pieces = source.size > 0
+        ? [{ buffer: "source", start: 0, length: source.size }]
+        : [];
+    let ends = prefixEnds(pieces);
+    const undoStack = [];
+    const redoStack = [];
+    let nextId = 1;
+    let savedId = 0;
+    let group;
+    let changedInGroup = false;
+    // Source reads go through a cache keyed by source offsets, which no edit
+    // moves, so it stays valid across edits. It reads a sync source in place,
+    // and learns which kind it has from the first real read: probing at
+    // creation would be a request of its own, and a zero-length one at that.
+    const cache = createPageCache(source);
+    const listeners = new Set();
+    let unsubscribeSource;
+    const state = {
+        edit: (edit) => editDocument(edit),
+        group(fn) {
+            if (group) {
+                fn();
+                return;
+            }
+            group = { step: undefined };
+            changedInGroup = false;
+            try {
+                fn();
+            }
+            finally {
+                group = undefined;
+                if (changedInGroup)
+                    notify();
+            }
+        },
+        breakRun() {
+            const top = undoStack.at(-1);
+            if (top)
+                top.key = undefined;
+        },
+        lastChange: { kind: "edit" },
+        version: 0,
+    };
+    const notify = () => {
+        state.version++;
+        if (group) {
+            changedInGroup = true;
+            return;
+        }
+        for (const listener of [...listeners])
+            listener();
+    };
+    const size = () => ends.at(-1) ?? 0;
+    /** The pieces' parts covering [offset, end), in order. */
+    const segments = (offset, end) => {
+        const out = [];
+        let i = pieceAt(ends, offset);
+        let at = offset;
+        while (at < end && i < pieces.length) {
+            const piece = pieces[i];
+            const pieceStart = ends[i] - piece.length;
+            const from = at - pieceStart;
+            const length = Math.min(piece.length - from, end - at);
+            out.push({ piece, from: piece.start + from, length });
+            at += length;
+            i++;
+        }
+        return out;
+    };
+    const join = (parts, length) => {
+        if (parts.length === 1)
+            return parts[0];
+        const out = new Uint8Array(length);
+        let at = 0;
+        for (const part of parts) {
+            out.set(part, at);
+            at += part.length;
+        }
+        return out;
+    };
+    const clamp = (offset, length) => {
+        const start = Math.min(Math.max(0, offset), size());
+        return [start, Math.min(size(), start + Math.max(0, length))];
+    };
+    function read(offset, length, signal) {
+        const [start, end] = clamp(offset, length);
+        const parts = segments(start, end);
+        if (cache.sync() === false && signal?.aborted) {
+            return Promise.reject(abortError(signal));
+        }
+        const read = parts.map(({ piece, from, length }) => piece.buffer === "add"
+            ? add.read(from, length)
+            : cache.read(from, length, signal));
+        // A document answers in place only once its source has: a view that saw
+        // edited bytes come back at once would take an async document for a
+        // sync one. With no source byte in this read to learn from, the source's
+        // first page decides; it is cached, and undo may well need it. An empty
+        // source has no bytes to read, so it never decides.
+        if (cache.sync() === undefined &&
+            source.size > 0 &&
+            parts.length > 0 &&
+            parts.every(({ piece }) => piece.buffer === "add")) {
+            const first = cache.read(0, 1);
+            if (first instanceof Promise)
+                first.catch(() => { });
+        }
+        const sync = cache.sync() ?? source.size === 0;
+        if (sync && read.every((r) => r instanceof Uint8Array)) {
+            return join(read, end - start);
+        }
+        return Promise.all(read).then((bytes) => join(bytes, end - start));
+    }
+    const readInPlace = (offset, length) => {
+        const bytes = source.read(offset, length);
+        if (bytes instanceof Uint8Array)
+            return bytes;
+        bytes.catch(() => { });
+        return undefined;
+    };
+    function peek(offset, length) {
+        const [start, end] = clamp(offset, length);
+        const parts = [];
+        for (const { piece, from, length } of segments(start, end)) {
+            let bytes;
+            if (piece.buffer === "add")
+                bytes = add.read(from, length);
+            else if (cache.sync() === false)
+                bytes = cache.get(from, length);
+            else if (cache.sync())
+                bytes = readInPlace(from, length);
+            // Unknown until the first read, and finding out would be one.
+            else
+                bytes = source.peek?.(from, length);
+            if (!bytes)
+                return undefined;
+            parts.push(bytes);
+        }
+        return parts.length ? join(parts, end - start) : new Uint8Array(0);
+    }
+    const apply = (record, forward) => {
+        const [remove, insert] = forward
+            ? [record.removed, record.inserted]
+            : [record.inserted, record.removed];
+        pieces = applySplice(pieces, record.index, remove.length, insert);
+        ends = prefixEnds(pieces);
+    };
+    function editDocument({ offset, length, bytes, key, before, after, }) {
+        const [start, end] = clamp(offset, length);
+        if (end === start && bytes.length === 0)
+            return;
+        if (!resizable && bytes.length !== end - start) {
+            throw new RangeError("This document's size is locked");
+        }
+        const piece = bytes.length
+            ? { buffer: "add", start: add.append(bytes), length: bytes.length }
+            : undefined;
+        const record = spliceRecord(pieces, ends, start, end - start, piece);
+        apply(record, true);
+        const top = undoStack.at(-1);
+        const joinsGroup = group?.step !== undefined && group.step === top;
+        const continuesRun = key !== undefined &&
+            top?.key === key &&
+            redoStack.length === 0 &&
+            (start === top.end || (end > start && end === top.end));
+        if (top && (joinsGroup || continuesRun)) {
+            top.records.push(record);
+            top.end = start + bytes.length;
+            if (after !== undefined)
+                top.after = after;
+            top.key = key;
+        }
+        else {
+            const step = {
+                id: nextId++,
+                records: [record],
+                before,
+                after,
+                key,
+                end: start + bytes.length,
+            };
+            undoStack.push(step);
+            redoStack.length = 0;
+            if (group)
+                group.step = step;
+        }
+        state.lastChange = { kind: "edit" };
+        notify();
+    }
+    const currentId = () => undoStack.at(-1)?.id ?? 0;
+    const doc = {
+        source,
+        resizable,
+        get size() {
+            return size();
+        },
+        get dirty() {
+            return currentId() !== savedId;
+        },
+        get canUndo() {
+            return undoStack.length > 0;
+        },
+        get canRedo() {
+            return redoStack.length > 0;
+        },
+        read,
+        peek,
+        subscribe(listener) {
+            listeners.add(listener);
+            if (listeners.size === 1) {
+                unsubscribeSource = source.subscribe?.(() => {
+                    cache.invalidate();
+                    state.lastChange = { kind: "other" };
+                    notify();
+                });
+            }
+            return () => {
+                if (!listeners.delete(listener) || listeners.size > 0)
+                    return;
+                unsubscribeSource?.();
+                unsubscribeSource = undefined;
+            };
+        },
+        replace(offset, length, bytes) {
+            editDocument({ offset, length, bytes });
+        },
+        insert(offset, bytes) {
+            editDocument({ offset, length: 0, bytes });
+        },
+        overwrite(offset, bytes) {
+            const [start] = clamp(offset, 0);
+            const room = size() - start;
+            const written = resizable ? bytes : bytes.subarray(0, room);
+            editDocument({
+                offset: start,
+                length: Math.min(written.length, room),
+                bytes: written,
+            });
+        },
+        delete(offset, length) {
+            editDocument({ offset, length, bytes: new Uint8Array(0) });
+        },
+        undo() {
+            const step = undoStack.pop();
+            if (!step)
+                return;
+            for (let i = step.records.length - 1; i >= 0; i--) {
+                apply(step.records[i], false);
+            }
+            step.key = undefined;
+            redoStack.push(step);
+            state.lastChange = { kind: "undo", selection: step.before };
+            notify();
+        },
+        redo() {
+            const step = redoStack.pop();
+            if (!step)
+                return;
+            for (const record of step.records)
+                apply(record, true);
+            undoStack.push(step);
+            state.lastChange = { kind: "redo", selection: step.after };
+            notify();
+        },
+        markSaved() {
+            state.breakRun();
+            if (savedId === currentId())
+                return;
+            savedId = currentId();
+            state.lastChange = { kind: "other" };
+            notify();
+        },
+        modifiedRanges(offset, length) {
+            const [start, end] = clamp(offset, length);
+            const out = [];
+            let at = start;
+            for (const { piece, length } of segments(start, end)) {
+                if (piece.buffer === "add") {
+                    const last = out.at(-1);
+                    if (last && last[1] === at)
+                        last[1] = at + length;
+                    else
+                        out.push([at, at + length]);
+                }
+                at += length;
+            }
+            return out;
+        },
+        pieces() {
+            return pieces.map((piece) => piece.buffer === "add"
+                ? { kind: "bytes", bytes: add.read(piece.start, piece.length) }
+                : { kind: "source", offset: piece.start, length: piece.length });
+        },
+        async toBlob(type) {
+            const snapshot = doc.pieces();
+            const wrapped = source;
+            const parts = [];
+            for (const piece of snapshot) {
+                if (piece.kind === "bytes") {
+                    parts.push(piece.bytes);
+                }
+                else if (wrapped.blob instanceof Blob) {
+                    parts.push(wrapped.blob.slice(piece.offset, piece.offset + piece.length));
+                }
+                else if (wrapped.bytes instanceof Uint8Array) {
+                    parts.push(wrapped.bytes.subarray(piece.offset, piece.offset + piece.length));
+                }
+                else {
+                    for (let at = 0; at < piece.length; at += EXPORT_CHUNK) {
+                        const bytes = await source.read(piece.offset + at, Math.min(EXPORT_CHUNK, piece.length - at));
+                        // A sync source may hand out a view it later changes.
+                        parts.push(bytes.slice());
+                    }
+                }
+            }
+            return new Blob(parts, { type });
+        },
+        stream() {
+            const snapshot = doc.pieces();
+            const controller = new AbortController();
+            let index = 0;
+            let at = 0;
+            return new ReadableStream({
+                async pull(stream) {
+                    const piece = snapshot[index];
+                    if (!piece) {
+                        stream.close();
+                        return;
+                    }
+                    if (piece.kind === "bytes") {
+                        index++;
+                        stream.enqueue(piece.bytes.slice());
+                        return;
+                    }
+                    const length = Math.min(EXPORT_CHUNK, piece.length - at);
+                    const bytes = await source.read(piece.offset + at, length, controller.signal);
+                    at += length;
+                    if (at >= piece.length) {
+                        index++;
+                        at = 0;
+                    }
+                    stream.enqueue(bytes.slice());
+                },
+                cancel(reason) {
+                    controller.abort(reason);
+                },
+            }, { highWaterMark: 1 });
+        },
+    };
+    internals.set(doc, state);
+    return doc;
+}
+function internalsOf(doc) {
+    const state = internals.get(doc);
+    if (!state)
+        throw new TypeError("Not a HexDocument from createHexDocument");
+    return state;
+}
+export function isHexDocument(value) {
+    return typeof value === "object" && value !== null && internals.has(value);
+}
+/** An edit carrying the editor's selections and a coalescing key; `replace` without them. */
+export function editDocument(doc, edit) {
+    internalsOf(doc).edit(edit);
+}
+/** Runs several edits as one undo step, with one notification. */
+export function editGroup(doc, fn) {
+    internalsOf(doc).group(fn);
+}
+/** The next edit starts a new undo step even when it would continue the run. */
+export function breakRun(doc) {
+    internalsOf(doc).breakRun();
+}
+/** What the most recent notification was for; undo and redo carry the selection to restore. */
+export function lastChange(doc) {
+    return internalsOf(doc).lastChange;
+}
+/** Bumped by every change the document notifies. */
+export function documentVersion(doc) {
+    return internalsOf(doc).version;
+}
+//# sourceMappingURL=document.js.map