@vibefield/rosetta-room 0.0.0-stage → 0.1.0

package/dist/components/file-viewer/minimap/CodeMinimap.d.ts

@@ -0,0 +1,10 @@
+import type { RefObject } from "react";
+import type { TokenLine } from "../syntax/index.js";
+export interface CodeMinimapProps {
+    readonly lines: readonly TokenLine[];
+    readonly lineHeight: number;
+    readonly tabColumns: number;
+    readonly scrollerRef: RefObject<HTMLDivElement | null>;
+    readonly scrollToLine: (lineIndex: number) => void;
+}
+export declare function CodeMinimap({ lines, lineHeight, tabColumns, scrollerRef, scrollToLine, }: CodeMinimapProps): import("react").JSX.Element | null;

package/dist/components/file-viewer/minimap/CodeMinimap.js

@@ -0,0 +1,296 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// A read-only source map inside CodeView's native scrollbar gutters.
+//
+// Text is painted only on file/theme/size changes. Scroll moves one DOM
+// thumb, derived from the native scroller's real geometry. Sampling changes
+// which lines become pixels; it never changes navigation.
+import { useLayoutEffect, useRef, useState } from "react";
+import { computeScrollbarInsets, computeThumbGeometry, createRasterLayout, lineIndexForMapOffset, needsMinimap, scrollTopForThumbDelta, wheelDeltaPixels, } from "./layout.js";
+import { resolveMinimapPalette } from "./palette.js";
+import { rasterizeMinimap } from "./raster.js";
+const MAX_RENDER_SCALE = 2;
+function renderScale() {
+    const ratio = Number.isFinite(window.devicePixelRatio) ? window.devicePixelRatio : 1;
+    return Math.min(MAX_RENDER_SCALE, Math.max(1, ratio));
+}
+export function CodeMinimap({ lines, lineHeight, tabColumns, scrollerRef, scrollToLine, }) {
+    const hostRef = useRef(null);
+    const stageRef = useRef(null);
+    const canvasRef = useRef(null);
+    const thumbRef = useRef(null);
+    const [visible, setVisible] = useState(false);
+    const [supported, setSupported] = useState(true);
+    // This effect remains alive when the minimap returns null. That is what
+    // lets a newly overflowing scroller bring the host into existence without
+    // requiring an already measurable canvas.
+    useLayoutEffect(() => {
+        const scroller = scrollerRef.current;
+        if (scroller === null || lines.length === 0 || !supported) {
+            setVisible(false);
+            return;
+        }
+        let frame = 0;
+        const measure = () => {
+            frame = 0;
+            const next = needsMinimap(scroller.scrollHeight, scroller.clientHeight);
+            setVisible((current) => (current === next ? current : next));
+        };
+        const schedule = () => {
+            if (frame === 0)
+                frame = requestAnimationFrame(measure);
+        };
+        measure();
+        const observer = typeof ResizeObserver === "undefined" ? null : new ResizeObserver(schedule);
+        observer?.observe(scroller);
+        if (scroller.firstElementChild instanceof HTMLElement) {
+            observer?.observe(scroller.firstElementChild);
+        }
+        window.addEventListener("resize", schedule);
+        return () => {
+            observer?.disconnect();
+            window.removeEventListener("resize", schedule);
+            if (frame !== 0)
+                cancelAnimationFrame(frame);
+        };
+    }, [lines.length, scrollerRef, supported]);
+    useLayoutEffect(() => {
+        if (!visible || !supported)
+            return;
+        const scroller = scrollerRef.current;
+        const host = hostRef.current;
+        const stage = stageRef.current;
+        const canvas = canvasRef.current;
+        const thumb = thumbRef.current;
+        if (scroller === null ||
+            host === null ||
+            stage === null ||
+            canvas === null ||
+            thumb === null) {
+            return;
+        }
+        const context = canvas.getContext("2d", { alpha: false });
+        const initialPalette = resolveMinimapPalette(host);
+        if (context === null || initialPalette === null) {
+            setSupported(false);
+            return;
+        }
+        let palette = initialPalette;
+        let trackHeight = 0;
+        let geometry = null;
+        let drag = null;
+        let frame = 0;
+        let paintPending = false;
+        let palettePending = false;
+        const alignToScrollport = () => {
+            const insets = computeScrollbarInsets({
+                offsetWidth: scroller.offsetWidth,
+                clientWidth: scroller.clientWidth,
+                offsetHeight: scroller.offsetHeight,
+                clientHeight: scroller.clientHeight,
+            });
+            host.style.right = `${insets.right}px`;
+            host.style.bottom = `${insets.bottom}px`;
+        };
+        const syncThumb = () => {
+            geometry = computeThumbGeometry({
+                scrollTop: scroller.scrollTop,
+                scrollHeight: scroller.scrollHeight,
+                clientHeight: scroller.clientHeight,
+                trackHeight,
+            });
+            thumb.style.height = `${geometry.height.toFixed(3)}px`;
+            thumb.style.transform = `translate3d(0, ${geometry.top.toFixed(3)}px, 0)`;
+        };
+        const paint = () => {
+            alignToScrollport();
+            const scale = renderScale();
+            const cssWidth = host.clientWidth;
+            const availableHeight = host.clientHeight;
+            const layout = createRasterLayout(lines.length, availableHeight, scale);
+            if (cssWidth <= 0 || layout === null) {
+                trackHeight = 0;
+                stage.style.height = "0px";
+                syncThumb();
+                return;
+            }
+            const backingWidth = Math.max(1, Math.round(cssWidth * scale));
+            if (canvas.width !== backingWidth)
+                canvas.width = backingWidth;
+            if (canvas.height !== layout.backingHeight)
+                canvas.height = layout.backingHeight;
+            trackHeight = layout.cssHeight;
+            stage.style.height = `${trackHeight}px`;
+            const image = context.createImageData(backingWidth, layout.backingHeight);
+            rasterizeMinimap({
+                pixels: new Uint32Array(image.data.buffer),
+                width: backingWidth,
+                height: layout.backingHeight,
+                lines,
+                lineIndexes: layout.lineIndexes,
+                tabColumns,
+                palette,
+            });
+            context.putImageData(image, 0, 0);
+            syncThumb();
+        };
+        const flush = () => {
+            frame = 0;
+            if (palettePending) {
+                palettePending = false;
+                const resolved = resolveMinimapPalette(host);
+                if (resolved === null) {
+                    setSupported(false);
+                    return;
+                }
+                palette = resolved;
+            }
+            if (paintPending) {
+                paintPending = false;
+                paint();
+            }
+            else {
+                syncThumb();
+            }
+        };
+        const schedule = () => {
+            if (frame === 0)
+                frame = requestAnimationFrame(flush);
+        };
+        const schedulePaint = () => {
+            paintPending = true;
+            schedule();
+        };
+        const schedulePalette = () => {
+            palettePending = true;
+            paintPending = true;
+            schedule();
+        };
+        const onScroll = () => schedule();
+        const onWheel = (event) => {
+            const delta = wheelDeltaPixels(event.deltaY, event.deltaMode, lineHeight, scroller.clientHeight);
+            if (delta === 0)
+                return;
+            event.preventDefault();
+            scroller.scrollTop += delta;
+            schedule();
+        };
+        const onStagePointerDown = (event) => {
+            if (event.button !== 0 || event.target === thumb)
+                return;
+            event.preventDefault();
+            const bounds = stage.getBoundingClientRect();
+            if (bounds.height <= 0 || trackHeight <= 0)
+                return;
+            const offset = (event.clientY - bounds.top) * (trackHeight / bounds.height);
+            scrollToLine(lineIndexForMapOffset({
+                offset,
+                trackHeight,
+                lineCount: lines.length,
+            }));
+            schedule();
+        };
+        const onThumbPointerDown = (event) => {
+            if (event.button !== 0)
+                return;
+            event.preventDefault();
+            event.stopPropagation();
+            syncThumb();
+            if (geometry === null)
+                return;
+            const bounds = stage.getBoundingClientRect();
+            drag = {
+                pointerId: event.pointerId,
+                startY: event.clientY,
+                startScrollTop: scroller.scrollTop,
+                coordinateScale: bounds.height > 0 ? trackHeight / bounds.height : 1,
+                geometry,
+            };
+            thumb.classList.add("is-dragging");
+            thumb.setPointerCapture(event.pointerId);
+        };
+        const onThumbPointerMove = (event) => {
+            if (drag === null || drag.pointerId !== event.pointerId)
+                return;
+            const delta = (event.clientY - drag.startY) * drag.coordinateScale;
+            scroller.scrollTop = scrollTopForThumbDelta(drag.startScrollTop, delta, drag.geometry);
+            schedule();
+        };
+        const finishDrag = (event, release) => {
+            if (drag === null || drag.pointerId !== event.pointerId)
+                return;
+            const pointerId = drag.pointerId;
+            drag = null;
+            thumb.classList.remove("is-dragging");
+            if (release && thumb.hasPointerCapture(pointerId)) {
+                thumb.releasePointerCapture(pointerId);
+            }
+            schedule();
+        };
+        const onThumbPointerUp = (event) => finishDrag(event, true);
+        const onThumbLostCapture = (event) => finishDrag(event, false);
+        scroller.addEventListener("scroll", onScroll, { passive: true });
+        host.addEventListener("wheel", onWheel, { passive: false });
+        stage.addEventListener("pointerdown", onStagePointerDown);
+        thumb.addEventListener("pointerdown", onThumbPointerDown);
+        thumb.addEventListener("pointermove", onThumbPointerMove);
+        thumb.addEventListener("pointerup", onThumbPointerUp);
+        thumb.addEventListener("pointercancel", onThumbPointerUp);
+        thumb.addEventListener("lostpointercapture", onThumbLostCapture);
+        const resizeObserver = typeof ResizeObserver === "undefined"
+            ? null
+            : new ResizeObserver((entries) => {
+                if (entries.some((entry) => entry.target === host || entry.target === scroller)) {
+                    schedulePaint();
+                }
+                else {
+                    // Dynamically measured wrapped rows change scrollHeight, but not
+                    // the immutable source raster. Only the viewport thumb moves.
+                    schedule();
+                }
+            });
+        resizeObserver?.observe(host);
+        resizeObserver?.observe(scroller);
+        if (scroller.firstElementChild instanceof HTMLElement) {
+            resizeObserver?.observe(scroller.firstElementChild);
+        }
+        const themeObserver = typeof MutationObserver === "undefined"
+            ? null
+            : new MutationObserver(schedulePalette);
+        themeObserver?.observe(document.documentElement, {
+            attributes: true,
+            attributeFilter: ["class", "data-theme"],
+        });
+        let densityQuery = null;
+        const onDensityChange = () => {
+            armDensityObserver();
+            schedulePaint();
+        };
+        const armDensityObserver = () => {
+            densityQuery?.removeEventListener("change", onDensityChange);
+            densityQuery = window.matchMedia(`(resolution: ${window.devicePixelRatio}dppx)`);
+            densityQuery.addEventListener("change", onDensityChange);
+        };
+        armDensityObserver();
+        window.addEventListener("resize", schedulePaint);
+        paint();
+        return () => {
+            scroller.removeEventListener("scroll", onScroll);
+            host.removeEventListener("wheel", onWheel);
+            stage.removeEventListener("pointerdown", onStagePointerDown);
+            thumb.removeEventListener("pointerdown", onThumbPointerDown);
+            thumb.removeEventListener("pointermove", onThumbPointerMove);
+            thumb.removeEventListener("pointerup", onThumbPointerUp);
+            thumb.removeEventListener("pointercancel", onThumbPointerUp);
+            thumb.removeEventListener("lostpointercapture", onThumbLostCapture);
+            resizeObserver?.disconnect();
+            themeObserver?.disconnect();
+            densityQuery?.removeEventListener("change", onDensityChange);
+            window.removeEventListener("resize", schedulePaint);
+            if (frame !== 0)
+                cancelAnimationFrame(frame);
+        };
+    }, [lineHeight, lines, scrollerRef, scrollToLine, supported, tabColumns, visible]);
+    if (!visible || !supported)
+        return null;
+    return (_jsx("div", { className: "ah-code-minimap", ref: hostRef, "aria-hidden": "true", role: "presentation", children: _jsxs("div", { className: "ah-code-minimap__stage", ref: stageRef, children: [_jsx("canvas", { className: "ah-code-minimap__text", ref: canvasRef }), _jsx("div", { className: "ah-code-minimap__slider", ref: thumbRef })] }) }));
+}

package/dist/components/file-viewer/minimap/layout.d.ts

@@ -0,0 +1,60 @@
+export declare const MINIMAP_ROW_DEVICE_PIXELS = 2;
+export declare const MINIMAP_MIN_THUMB_CSS_PIXELS = 8;
+export interface MinimapRasterLayout {
+    readonly rowCount: number;
+    readonly backingHeight: number;
+    readonly cssHeight: number;
+    /** Zero-based source line for each painted row. `null` means identity. */
+    readonly lineIndexes: Uint32Array | null;
+}
+export interface MinimapThumbGeometry {
+    readonly top: number;
+    readonly height: number;
+    readonly maxTop: number;
+    readonly maxScroll: number;
+    readonly scrollPerTrackPixel: number;
+}
+export interface MinimapScrollbarInsets {
+    /** Width occupied by the native vertical scrollbar. */
+    readonly right: number;
+    /** Height occupied by the native horizontal scrollbar. */
+    readonly bottom: number;
+}
+/** The browser's scroll box is authoritative: it includes code padding and
+ * any horizontal scrollbar that reduced the vertical viewport. */
+export declare function needsMinimap(scrollHeight: number, clientHeight: number): boolean;
+/** Position an overlay inside the scrollport, leaving the browser-owned
+ * scrollbar gutters untouched. The code scroller has no borders, so its
+ * offset/client delta is exactly the classic scrollbar footprint; overlay
+ * scrollbars naturally report zero. */
+export declare function computeScrollbarInsets(args: {
+    readonly offsetWidth: number;
+    readonly clientWidth: number;
+    readonly offsetHeight: number;
+    readonly clientHeight: number;
+}): MinimapScrollbarInsets;
+/** One representative source line per equal source interval. Endpoints are
+ * navigation concerns, not raster concerns; midpoint sampling avoids biasing
+ * the picture toward the first and last line of every interval. */
+export declare function sampleLineIndexes(lineCount: number, rowCount: number): Uint32Array | null;
+export declare function createRasterLayout(lineCount: number, availableCssHeight: number, renderScale: number): MinimapRasterLayout | null;
+/** A scrollbar thumb over the part of the minimap that actually contains
+ * pixels. For an unsampled 100-line file that is a short track at the top;
+ * for a sampled file it is the full available pane height. */
+export declare function computeThumbGeometry(args: {
+    readonly scrollTop: number;
+    readonly scrollHeight: number;
+    readonly clientHeight: number;
+    readonly trackHeight: number;
+    readonly minimumHeight?: number;
+}): MinimapThumbGeometry;
+/** Source-line navigation stays independent of raster sampling. The
+ * virtualizer resolves this index against measured wrapped-row heights. */
+export declare function lineIndexForMapOffset(args: {
+    readonly offset: number;
+    readonly trackHeight: number;
+    readonly lineCount: number;
+}): number;
+export declare function scrollTopForThumbDelta(startScrollTop: number, delta: number, geometry: MinimapThumbGeometry): number;
+/** WheelEvent delta units: pixels, lines, or pages. */
+export declare function wheelDeltaPixels(delta: number, deltaMode: number, lineHeight: number, clientHeight: number): number;

package/dist/components/file-viewer/minimap/layout.js

@@ -0,0 +1,117 @@
+// Geometry for a full-file, pane-bounded minimap.
+//
+// Sampling belongs only to the raster. The thumb and drag are projections of
+// the real scroll element; a track click names a logical source line so the
+// virtualizer can account for measured wrapping.
+export const MINIMAP_ROW_DEVICE_PIXELS = 2;
+export const MINIMAP_MIN_THUMB_CSS_PIXELS = 8;
+const OVERFLOW_EPSILON = 1;
+function clamp(value, minimum, maximum) {
+    return Math.min(maximum, Math.max(minimum, value));
+}
+function positive(value) {
+    return Number.isFinite(value) ? Math.max(0, value) : 0;
+}
+/** The browser's scroll box is authoritative: it includes code padding and
+ * any horizontal scrollbar that reduced the vertical viewport. */
+export function needsMinimap(scrollHeight, clientHeight) {
+    const viewport = positive(clientHeight);
+    return viewport > 0 && positive(scrollHeight) - viewport > OVERFLOW_EPSILON;
+}
+/** Position an overlay inside the scrollport, leaving the browser-owned
+ * scrollbar gutters untouched. The code scroller has no borders, so its
+ * offset/client delta is exactly the classic scrollbar footprint; overlay
+ * scrollbars naturally report zero. */
+export function computeScrollbarInsets(args) {
+    return {
+        right: Math.max(0, positive(args.offsetWidth) - positive(args.clientWidth)),
+        bottom: Math.max(0, positive(args.offsetHeight) - positive(args.clientHeight)),
+    };
+}
+/** One representative source line per equal source interval. Endpoints are
+ * navigation concerns, not raster concerns; midpoint sampling avoids biasing
+ * the picture toward the first and last line of every interval. */
+export function sampleLineIndexes(lineCount, rowCount) {
+    const lines = Math.max(0, Math.floor(lineCount));
+    const rows = Math.max(0, Math.floor(rowCount));
+    if (lines === 0 || rows === 0 || lines <= rows)
+        return null;
+    const sampled = new Uint32Array(rows);
+    for (let row = 0; row < rows; row += 1) {
+        const from = Math.floor((row * lines) / rows);
+        const to = Math.max(from, Math.floor(((row + 1) * lines) / rows) - 1);
+        sampled[row] = Math.floor((from + to) / 2);
+    }
+    return sampled;
+}
+export function createRasterLayout(lineCount, availableCssHeight, renderScale) {
+    const lines = Math.max(0, Math.floor(lineCount));
+    const cssHeight = positive(availableCssHeight);
+    const scale = positive(renderScale);
+    if (lines === 0 || cssHeight === 0 || scale === 0)
+        return null;
+    const availableDeviceHeight = Math.floor(cssHeight * scale);
+    const capacity = Math.floor(availableDeviceHeight / MINIMAP_ROW_DEVICE_PIXELS);
+    if (capacity === 0)
+        return null;
+    const rowCount = Math.min(lines, capacity);
+    const backingHeight = rowCount * MINIMAP_ROW_DEVICE_PIXELS;
+    return {
+        rowCount,
+        backingHeight,
+        cssHeight: backingHeight / scale,
+        lineIndexes: sampleLineIndexes(lines, rowCount),
+    };
+}
+/** A scrollbar thumb over the part of the minimap that actually contains
+ * pixels. For an unsampled 100-line file that is a short track at the top;
+ * for a sampled file it is the full available pane height. */
+export function computeThumbGeometry(args) {
+    const trackHeight = positive(args.trackHeight);
+    const scrollHeight = positive(args.scrollHeight);
+    const clientHeight = positive(args.clientHeight);
+    const maxScroll = Math.max(0, scrollHeight - clientHeight);
+    if (trackHeight === 0 || scrollHeight === 0 || maxScroll === 0) {
+        return {
+            top: 0,
+            height: trackHeight,
+            maxTop: 0,
+            maxScroll,
+            scrollPerTrackPixel: 0,
+        };
+    }
+    const minimumHeight = positive(args.minimumHeight ?? MINIMAP_MIN_THUMB_CSS_PIXELS);
+    const height = clamp((clientHeight / scrollHeight) * trackHeight, minimumHeight, trackHeight);
+    const maxTop = Math.max(0, trackHeight - height);
+    const top = maxTop === 0 ? 0 : (clamp(positive(args.scrollTop), 0, maxScroll) / maxScroll) * maxTop;
+    return {
+        top,
+        height,
+        maxTop,
+        maxScroll,
+        scrollPerTrackPixel: maxTop === 0 ? 0 : maxScroll / maxTop,
+    };
+}
+/** Source-line navigation stays independent of raster sampling. The
+ * virtualizer resolves this index against measured wrapped-row heights. */
+export function lineIndexForMapOffset(args) {
+    const trackHeight = positive(args.trackHeight);
+    const lineCount = Math.max(0, Math.floor(args.lineCount));
+    if (trackHeight === 0 || lineCount === 0)
+        return 0;
+    const fraction = clamp(positive(args.offset) / trackHeight, 0, 1);
+    return Math.min(lineCount - 1, Math.floor(fraction * lineCount));
+}
+export function scrollTopForThumbDelta(startScrollTop, delta, geometry) {
+    return clamp(positive(startScrollTop) + delta * geometry.scrollPerTrackPixel, 0, geometry.maxScroll);
+}
+/** WheelEvent delta units: pixels, lines, or pages. */
+export function wheelDeltaPixels(delta, deltaMode, lineHeight, clientHeight) {
+    if (!Number.isFinite(delta))
+        return 0;
+    if (deltaMode === 1)
+        return delta * positive(lineHeight);
+    if (deltaMode === 2)
+        return delta * positive(clientHeight);
+    return delta;
+}

package/dist/components/file-viewer/minimap/palette.d.ts

@@ -0,0 +1,2 @@
+import type { MinimapPalette } from "./raster.js";
+export declare function resolveMinimapPalette(host: HTMLElement): MinimapPalette | null;

package/dist/components/file-viewer/minimap/palette.js

@@ -0,0 +1,73 @@
+// Canvas cannot inherit the file viewer's CSS palette. Resolve the same custom
+// properties through a live descendant, then let a one-pixel canvas normalize
+// CSS Color 4 values and alpha-composite them over the viewer ground.
+import { packRgba } from "./raster.js";
+const TOKEN_KINDS = [
+    "comment",
+    "string",
+    "number",
+    "keyword",
+    "type",
+    "function",
+    "constant",
+    "property",
+    "tag",
+    "operator",
+    "plain",
+];
+const TOKEN_VARIABLE = {
+    comment: "--vf-text-faint",
+    string: "--ah-syn-string",
+    number: "--ah-syn-value",
+    keyword: "--ah-syn-keyword",
+    type: "--ah-syn-type",
+    function: "--ah-syn-function",
+    constant: "--ah-syn-value",
+    property: "--ah-syn-property",
+    tag: "--ah-syn-keyword",
+    operator: "--vf-text-tertiary",
+    plain: "--vf-text-secondary",
+};
+const BACKGROUND_VARIABLE = "--vf-chrome-solid";
+const TOKEN_OPACITY = 0.58;
+function packedPixel(context, background, foreground, opacity) {
+    context.clearRect(0, 0, 1, 1);
+    context.globalAlpha = 1;
+    context.fillStyle = background;
+    context.fillRect(0, 0, 1, 1);
+    context.globalAlpha = opacity;
+    context.fillStyle = foreground;
+    context.fillRect(0, 0, 1, 1);
+    context.globalAlpha = 1;
+    const [red, green, blue, alpha] = context.getImageData(0, 0, 1, 1).data;
+    return packRgba(red, green, blue, alpha);
+}
+export function resolveMinimapPalette(host) {
+    const scratch = document.createElement("canvas");
+    scratch.width = 1;
+    scratch.height = 1;
+    const context = scratch.getContext("2d", { willReadFrequently: true });
+    if (context === null)
+        return null;
+    const probe = document.createElement("span");
+    probe.style.position = "absolute";
+    probe.style.visibility = "hidden";
+    probe.style.pointerEvents = "none";
+    host.appendChild(probe);
+    try {
+        const resolve = (variable) => {
+            probe.style.color = `var(${variable})`;
+            return getComputedStyle(probe).color;
+        };
+        const backgroundCss = resolve(BACKGROUND_VARIABLE);
+        const background = packedPixel(context, backgroundCss, backgroundCss, 1);
+        const token = {};
+        for (const kind of TOKEN_KINDS) {
+            token[kind] = packedPixel(context, backgroundCss, resolve(TOKEN_VARIABLE[kind]), TOKEN_OPACITY);
+        }
+        return { background, token };
+    }
+    finally {
+        probe.remove();
+    }
+}

package/dist/components/file-viewer/minimap/raster.d.ts

@@ -0,0 +1,19 @@
+import type { TokenKind, TokenLine } from "../syntax/index.js";
+export declare const MINIMAP_CHARACTER_DEVICE_PIXELS = 1;
+export declare const MINIMAP_CHARACTER_HEIGHT_DEVICE_PIXELS = 2;
+export declare const MINIMAP_LEFT_GUTTER_DEVICE_PIXELS = 2;
+export declare const MINIMAP_MAX_COLUMNS = 96;
+export interface MinimapPalette {
+    readonly background: number;
+    readonly token: Readonly<Record<TokenKind, number>>;
+}
+export declare function packRgba(red: number, green: number, blue: number, alpha?: number): number;
+export declare function rasterizeMinimap(args: {
+    readonly pixels: Uint32Array;
+    readonly width: number;
+    readonly height: number;
+    readonly lines: readonly TokenLine[];
+    readonly lineIndexes: Uint32Array | null;
+    readonly tabColumns: number;
+    readonly palette: MinimapPalette;
+}): void;