@subimpact/e 0.100.0 → 0.100.1

package/dist/modes/interactive/components/easter-egg-3d.js

@@ -1,1138 +0,0 @@
-import { backgroundAnsi, colorToRgb, foregroundAnsi, getKeybindings, indexedColor, rgbColor, visibleWidth, } from "@earendil-works/pi-tui";
-import { theme } from "../theme/theme.js";
-import { ARMIN_HEIGHT, ARMIN_WIDTH, isArminPixel } from "./armin.js";
-import { formatKeyText } from "./keybinding-hints.js";
-const DEPTH = 0.7;
-const FLY_START = 0.1;
-const FLY_DURATION = 1.3;
-/** Braille dots per pixel when a model without an origin appears, growing from a speck at the center. */
-const START_SCALE = 0.1;
-function createModel(columns, rows, pixel, options) {
-    const blocks = [];
-    for (let row = 0; row < rows; row++) {
-        for (let column = 0; column < columns; column++) {
-            const color = pixel(column, row);
-            if (color)
-                blocks.push({ home: [column, row, 0], color });
-        }
-    }
-    return {
-        columns,
-        rows,
-        blocks,
-        cameraDistance: options.cameraDistance,
-        radius: Math.hypot(columns / 2, rows / 2, 1 + DEPTH / 2),
-        widthShare: options.widthShare,
-        puzzleMoves: (random) => options.puzzleMoves(random, blocks.length),
-        origin: options.origin,
-    };
-}
-const CORAL = [228, 138, 122];
-const BLUE = [79, 142, 179];
-const E_LOGO_PIXELS = ["c..c", "cccc", "bbbc", "b..b"];
-const E_LOGO_COLORS = { c: CORAL, b: BLUE };
-function eLogoModel(origin) {
-    return createModel(4, 4, (column, row) => E_LOGO_COLORS[E_LOGO_PIXELS[row][column]], {
-        cameraDistance: 10,
-        widthShare: 0.35,
-        puzzleMoves: (random) => (random < 0.4 ? 2 : 1),
-        origin,
-    });
-}
-function arminModel(color) {
-    return createModel(ARMIN_WIDTH, ARMIN_HEIGHT, (column, row) => (isArminPixel(column, row) ? color : undefined), {
-        // Far enough that the perspective stays mild for a figure about 36 blocks tall.
-        cameraDistance: 80,
-        widthShare: 0.45,
-        puzzleMoves: (random, blockCount) => Math.round(blockCount * (0.03 + random * 0.04)),
-        origin: undefined,
-    });
-}
-// The sliding puzzle: after the model spun for a while, blocks slide into free neighboring cells, a few at a time.
-// Each cycle shuffles, flies every block back home, and holds the model briefly.
-const PUZZLE_START = FLY_START + FLY_DURATION + 3;
-const PUZZLE_STEP = 0.3;
-const PUZZLE_STEPS = 12;
-const PUZZLE_RETURN = 1;
-const PUZZLE_HOLD = 0.6;
-const PUZZLE_CYCLE = PUZZLE_STEP * PUZZLE_STEPS + PUZZLE_RETURN + PUZZLE_HOLD;
-const PUZZLE_MOVES = [
-    [1, 0, 0],
-    [-1, 0, 0],
-    [0, 1, 0],
-    [0, -1, 0],
-    [1, 0, 0],
-    [-1, 0, 0],
-    [0, 1, 0],
-    [0, -1, 0],
-    [0, 0, 1],
-    [0, 0, -1],
-];
-/** Block positions after each step of one shuffle cycle, starting at home. Deterministic per cycle. */
-function shuffleSteps(model, cycle) {
-    const { columns, rows } = model;
-    let positions = model.blocks.map((block) => block.home);
-    const steps = [positions];
-    const lastMoved = new Set();
-    let random = cycle * 7_919 + 1;
-    const next = () => hash(random++);
-    const key = ([x, y, z]) => ((z + 1) * rows + y) * columns + x;
-    for (let step = 0; step < PUZZLE_STEPS; step++) {
-        const occupied = new Set(positions.map(key));
-        const nextPositions = [...positions];
-        const moved = new Set();
-        const moveCount = model.puzzleMoves(next());
-        for (let move = 0; move < moveCount; move++) {
-            const candidates = [];
-            for (let block = 0; block < positions.length; block++) {
-                if (moved.has(block))
-                    continue;
-                const [x, y, z] = positions[block];
-                for (const [dx, dy, dz] of PUZZLE_MOVES) {
-                    const target = [x + dx, y + dy, z + dz];
-                    if (target[0] < 0 || target[0] >= columns || target[1] < 0 || target[1] >= rows)
-                        continue;
-                    if (target[2] < -1 || target[2] > 1 || occupied.has(key(target)))
-                        continue;
-                    candidates.push({ block, target });
-                }
-            }
-            // Prefer blocks that did not just move, so the puzzle does not look like one block jittering.
-            const fresh = candidates.filter((candidate) => !lastMoved.has(candidate.block));
-            const pool = fresh.length > 0 ? fresh : candidates;
-            const choice = pool[Math.floor(next() * pool.length)];
-            if (!choice)
-                break;
-            occupied.add(key(choice.target));
-            nextPositions[choice.block] = choice.target;
-            moved.add(choice.block);
-        }
-        lastMoved.clear();
-        for (const block of moved)
-            lastMoved.add(block);
-        positions = nextPositions;
-        steps.push(positions);
-    }
-    return steps;
-}
-const FRAME_MS = 1000 / 30;
-const DUST_DURATION = 0.35;
-const WAVE_SPREAD = 0.55;
-const WAVE_JITTER = 0.12;
-const DISSOLVE_END = FLY_START + WAVE_SPREAD + WAVE_JITTER + DUST_DURATION;
-const BACKGROUND_FADE = 0.5;
-const EXIT_DURATION = 1.1;
-// A faint starfield fades in behind the logo once the screen has dissolved.
-const STARS_START = 2.5;
-const STARS_FADE = 2;
-const STAR_DENSITY = 0.018;
-// Star tints: neutral, pale blue, pale gold, and pale rose, each mixed half with the terminal's foreground.
-const STAR_TINTS = [
-    [255, 255, 255],
-    [170, 195, 255],
-    [255, 225, 170],
-    [255, 190, 205],
-];
-const LOGO_COLOR_STEP = 5;
-// On light backgrounds most of each braille cell shows the bright background, which washes the logo out. There,
-// the logo gets a halo: its colors and coverage blurred into the cell backgrounds, strongest under the logo and
-// fading out over HALO_RADIUS_X columns and HALO_RADIUS_Y rows (cells are about twice as tall as wide).
-const LIGHT_HALO_STRENGTH = 0.3;
-const HALO_RADIUS_X = 6;
-const HALO_RADIUS_Y = 3;
-const HALO_LEVELS = 32;
-const STAR_ALPHA_LEVELS = 8;
-const STAR_FLICKER_LEVELS = 3;
-const HINT_FADE = 0.5;
-// Braille dot bits, indexed by row * 2 + column within the 2x4 cell.
-const DOT_BITS = [0x01, 0x08, 0x02, 0x10, 0x04, 0x20, 0x40, 0x80];
-const BRAILLE = Array.from({ length: 256 }, (_, bits) => String.fromCharCode(0x2800 + bits));
-const LIGHT = normalize([-0.45, -0.6, 0.75]);
-const HALF_VECTOR = normalize([LIGHT[0], LIGHT[1], LIGHT[2] + 1]);
-function normalize(v) {
-    const length = Math.hypot(v[0], v[1], v[2]);
-    return [v[0] / length, v[1] / length, v[2] / length];
-}
-function clamp01(value) {
-    return value < 0 ? 0 : value > 1 ? 1 : value;
-}
-/** Quintic smoothstep. */
-function smooth(value) {
-    const t = clamp01(value);
-    return t * t * t * (t * (t * 6 - 15) + 10);
-}
-function easeOut(value) {
-    const t = 1 - clamp01(value);
-    return 1 - t * t * t;
-}
-function mix(a, b, amount) {
-    return [a[0] + (b[0] - a[0]) * amount, a[1] + (b[1] - a[1]) * amount, a[2] + (b[2] - a[2]) * amount];
-}
-function hash(value) {
-    let x = Math.imul(value ^ 0x9e3779b9, 0x85ebca6b);
-    x ^= x >>> 13;
-    x = Math.imul(x, 0xc2b2ae35);
-    x ^= x >>> 16;
-    return (x >>> 0) / 0x100000000;
-}
-/** Whether a background is light, by relative luminance. */
-function isLight([r, g, b]) {
-    return 0.2126 * r + 0.7152 * g + 0.0722 * b > 128;
-}
-function toRgb(color) {
-    const { r, g, b } = colorToRgb(color);
-    return [r, g, b];
-}
-/** Braille dots a glyph turns into, a rough measure of how much ink it has. */
-function glyphInk(text, seed) {
-    if (text.trim() === "")
-        return 0;
-    if (/^[.,:;'`\-_·]$/.test(text))
-        return 2;
-    if (/^[\u2500-\u257f]$/.test(text))
-        return 3;
-    return 4 + Math.floor(seed * 3);
-}
-const segmenter = new Intl.Segmenter();
-/** Parse rendered lines into cells with resolved colors. Other escape sequences (OSC, APC, cursor) are skipped. */
-function parseScreen(lines, width, foreground, background) {
-    const palette = (index) => toRgb(indexedColor(index));
-    return lines.map((line) => {
-        const cells = [];
-        let fg;
-        let bg;
-        let dim = false;
-        let inverse = false;
-        const applySgr = (params) => {
-            const codes = params === "" ? ["0"] : params.split(";");
-            for (let i = 0; i < codes.length; i++) {
-                const parts = codes[i].split(":").map((part) => Number.parseInt(part, 10));
-                const code = parts[0] ?? 0;
-                if (code === 38 || code === 48) {
-                    // Extended color, either as `38;5;n` / `38;2;r;g;b` or colon sub-parameters.
-                    let args;
-                    if (parts.length > 1) {
-                        args = parts.slice(1).filter((part) => !Number.isNaN(part));
-                        // `38:2::r:g:b` has an empty color space id, dropped above.
-                    }
-                    else {
-                        const kind = Number.parseInt(codes[i + 1] ?? "", 10);
-                        const count = kind === 5 ? 2 : kind === 2 ? 4 : 1;
-                        args = codes.slice(i + 1, i + 1 + count).map((part) => Number.parseInt(part, 10));
-                        i += count;
-                    }
-                    let color;
-                    if (args[0] === 5 && args[1] !== undefined)
-                        color = palette(args[1]);
-                    else if (args[0] === 2 && args.length >= 4)
-                        color = [args[1], args[2], args[3]];
-                    if (color) {
-                        if (code === 38)
-                            fg = color;
-                        else
-                            bg = color;
-                    }
-                }
-                else if (code === 0) {
-                    fg = undefined;
-                    bg = undefined;
-                    dim = false;
-                    inverse = false;
-                }
-                else if (code === 2)
-                    dim = true;
-                else if (code === 22)
-                    dim = false;
-                else if (code === 7)
-                    inverse = true;
-                else if (code === 27)
-                    inverse = false;
-                else if (code >= 30 && code <= 37)
-                    fg = palette(code - 30);
-                else if (code >= 90 && code <= 97)
-                    fg = palette(code - 90 + 8);
-                else if (code === 39)
-                    fg = undefined;
-                else if (code >= 40 && code <= 47)
-                    bg = palette(code - 40);
-                else if (code >= 100 && code <= 107)
-                    bg = palette(code - 100 + 8);
-                else if (code === 49)
-                    bg = undefined;
-            }
-        };
-        const pushText = (text) => {
-            for (const { segment } of segmenter.segment(text)) {
-                const glyphWidth = visibleWidth(segment);
-                if (glyphWidth === 0 || cells.length + glyphWidth > width)
-                    continue;
-                let cellFg = fg ?? foreground;
-                let cellBg = bg;
-                if (inverse) {
-                    cellFg = bg ?? background;
-                    cellBg = fg ?? foreground;
-                }
-                if (dim)
-                    cellFg = mix(cellFg, cellBg ?? background, 0.4);
-                const cell = { text: segment, width: glyphWidth, fg: cellFg, bg: cellBg, delay: 0, ink: 0, seed: 0 };
-                cells.push(cell);
-                if (glyphWidth === 2)
-                    cells.push({ ...cell, text: "", width: 0 });
-            }
-        };
-        let i = 0;
-        while (i < line.length) {
-            const sequenceStart = line.indexOf("\x1b", i);
-            if (sequenceStart === -1) {
-                pushText(line.slice(i));
-                break;
-            }
-            if (sequenceStart > i)
-                pushText(line.slice(i, sequenceStart));
-            const kind = line[sequenceStart + 1];
-            if (kind === "[") {
-                let end = sequenceStart + 2;
-                while (end < line.length && (line.charCodeAt(end) < 0x40 || line.charCodeAt(end) > 0x7e))
-                    end++;
-                if (line[end] === "m")
-                    applySgr(line.slice(sequenceStart + 2, end));
-                i = end + 1;
-            }
-            else if (kind === "]" || kind === "_" || kind === "P" || kind === "^") {
-                // String sequences end at BEL or ST (ESC \).
-                const bell = line.indexOf("\x07", sequenceStart + 2);
-                const st = line.indexOf("\x1b\\", sequenceStart + 2);
-                if (bell === -1 && st === -1)
-                    break;
-                i = bell !== -1 && (st === -1 || bell < st) ? bell + 1 : st + 2;
-            }
-            else {
-                i = sequenceStart + 2;
-            }
-        }
-        return cells;
-    });
-}
-/** Row-major 3x3 rotation matrix for yaw (y), then pitch (x), then roll (z). */
-function rotation(yaw, pitch, roll) {
-    const [sy, cy, sx, cx, sz, cz] = [
-        Math.sin(yaw),
-        Math.cos(yaw),
-        Math.sin(pitch),
-        Math.cos(pitch),
-        Math.sin(roll),
-        Math.cos(roll),
-    ];
-    // Rz * Rx * Ry
-    const ry = [cy, 0, sy, 0, 1, 0, -sy, 0, cy];
-    const rx = [1, 0, 0, 0, cx, -sx, 0, sx, cx];
-    const rz = [cz, -sz, 0, sz, cz, 0, 0, 0, 1];
-    return multiply(rz, multiply(rx, ry));
-}
-function multiply(a, b) {
-    const result = new Array(9);
-    for (let row = 0; row < 3; row++) {
-        for (let column = 0; column < 3; column++) {
-            result[row * 3 + column] =
-                a[row * 3] * b[column] + a[row * 3 + 1] * b[3 + column] + a[row * 3 + 2] * b[6 + column];
-        }
-    }
-    return result;
-}
-// The spin is locked to the puzzle: one turn per cycle, facing the camera in the middle of each hold.
-const SPIN_RAMP = 1.4;
-const SPIN_SPEED = (Math.PI * 2) / PUZZLE_CYCLE;
-// How much the spin slows down while facing the camera (and speeds up while facing away), from 0 to 1.
-const SPIN_LINGER = 0.6;
-const FIRST_FRONT_VIEW = PUZZLE_START + PUZZLE_STEP * PUZZLE_STEPS + PUZZLE_RETURN + PUZZLE_HOLD / 2;
-/** Uniform spin that accelerates from rest over SPIN_RAMP, then turns at SPIN_SPEED. */
-function baseSpinPhase(time) {
-    const elapsed = time - FLY_START;
-    if (elapsed <= 0)
-        return 0;
-    const u = elapsed / SPIN_RAMP;
-    // Integral of the quintic smoothstep ramp.
-    if (u < 1)
-        return SPIN_SPEED * SPIN_RAMP * (u ** 6 - 3 * u ** 5 + 2.5 * u ** 4);
-    return SPIN_SPEED * (SPIN_RAMP * 0.5 + elapsed - SPIN_RAMP);
-}
-// Extra rotation added during the flight, so the phase is a whole number of turns at every assembled front view.
-const SPIN_ALIGNMENT = Math.PI * 2 - (baseSpinPhase(FIRST_FRONT_VIEW) % (Math.PI * 2));
-/** Spin phase: whole turns exactly when the reassembled logo faces the camera. */
-function spinPhase(time) {
-    return baseSpinPhase(time) + SPIN_ALIGNMENT * smooth((time - FLY_START) / FLY_DURATION);
-}
-/** Yaw of the logo. It matches the phase at whole turns but lingers there, so the logo reads from the front. */
-function spinAngle(time) {
-    const phase = spinPhase(time);
-    return phase - SPIN_LINGER * Math.sin(phase);
-}
-/**
- * Renders the model's blocks into braille cells. Only faces that point at the camera and are not covered by a
- * touching block are drawn. Each face is rasterized over its projected bounds by intersecting each dot's ray
- * with the face's plane, with a depth buffer resolving overlaps. Buffers are reused between frames.
- */
-class BlockRaster {
-    /** Braille dot bits per cell. */
-    bits = new Uint8Array(0);
-    /** Lit dots per cell. */
-    counts = new Uint8Array(0);
-    /** Summed RGB of the lit dots per cell. */
-    rgb = new Float32Array(0);
-    /** Halo tint strength per cell, from 0 to 1. Only set when a halo was requested. */
-    haloAmount = new Float32Array(0);
-    /** Halo color per cell. */
-    haloRgb = new Float32Array(0);
-    width = 0;
-    height = 0;
-    /** Ray parameter of the nearest hit per dot; smaller is nearer. */
-    depth = new Float32Array(0);
-    /** Face index + 1 of the nearest hit per dot, 0 for none. */
-    faceIds = new Uint16Array(0);
-    /** Cells written by the previous frame, cleared before the next one. */
-    dirty;
-    /** Cells with a halo from the previous frame, cleared before the next one. */
-    haloDirty;
-    cameraDistance;
-    constructor(cameraDistance) {
-        this.cameraDistance = cameraDistance;
-    }
-    render(width, height, pose, boxes, background, haloStrength) {
-        const dotWidth = width * 2;
-        const dotHeight = height * 4;
-        if (width !== this.width || height !== this.height) {
-            this.width = width;
-            this.height = height;
-            this.bits = new Uint8Array(width * height);
-            this.counts = new Uint8Array(width * height);
-            this.rgb = new Float32Array(width * height * 3);
-            this.haloAmount = new Float32Array(width * height);
-            this.haloRgb = new Float32Array(width * height * 3);
-            this.haloDirty = undefined;
-            this.depth = new Float32Array(dotWidth * dotHeight).fill(Infinity);
-            this.faceIds = new Uint16Array(dotWidth * dotHeight);
-            this.dirty = undefined;
-        }
-        else if (this.dirty) {
-            const { minX, minY, maxX, maxY } = this.dirty;
-            for (let row = minY; row <= maxY; row++) {
-                this.bits.fill(0, row * width + minX, row * width + maxX + 1);
-                this.counts.fill(0, row * width + minX, row * width + maxX + 1);
-                this.rgb.fill(0, (row * width + minX) * 3, (row * width + maxX + 1) * 3);
-            }
-            this.dirty = undefined;
-        }
-        if (this.haloDirty) {
-            const { minX, minY, maxX, maxY } = this.haloDirty;
-            for (let row = minY; row <= maxY; row++) {
-                this.haloAmount.fill(0, row * width + minX, row * width + maxX + 1);
-                this.haloRgb.fill(0, (row * width + minX) * 3, (row * width + maxX + 1) * 3);
-            }
-            this.haloDirty = undefined;
-        }
-        const m = rotation(pose.yaw, pose.pitch, pose.roll);
-        const { centerX, centerY, scale } = pose;
-        const cameraDistance = this.cameraDistance;
-        // The camera sits at (0, 0, cameraDistance) in camera space; object space is the transpose rotation.
-        const origin = [m[6] * cameraDistance, m[7] * cameraDistance, m[8] * cameraDistance];
-        const light = isLight(background);
-        const faces = this.visibleFaces(m, origin, pose, boxes, dotWidth, dotHeight, light);
-        if (faces.length === 0)
-            return;
-        let minX = dotWidth;
-        let minY = dotHeight;
-        let maxX = -1;
-        let maxY = -1;
-        for (const face of faces) {
-            minX = Math.min(minX, face.minX);
-            minY = Math.min(minY, face.minY);
-            maxX = Math.max(maxX, face.maxX);
-            maxY = Math.max(maxY, face.maxY);
-        }
-        if (maxX < minX || maxY < minY)
-            return;
-        const depth = this.depth;
-        const faceIds = this.faceIds;
-        for (let faceIndex = 0; faceIndex < faces.length; faceIndex++) {
-            const face = faces[faceIndex];
-            const a = face.axis;
-            const u = (a + 1) % 3;
-            const v = (a + 2) % 3;
-            const originA = origin[a];
-            const originU = origin[u];
-            const originV = origin[v];
-            // The ray direction in object space is linear in the dot position, so it is stepped per dot.
-            const stepA = m[a] / scale;
-            const stepU = m[u] / scale;
-            const stepV = m[v] / scale;
-            const sx = (face.minX + 0.5 - centerX) / scale;
-            for (let dotY = face.minY; dotY <= face.maxY; dotY++) {
-                const sy = (dotY + 0.5 - centerY) / scale;
-                let directionA = m[a] * sx + m[3 + a] * sy - m[6 + a] * cameraDistance;
-                let directionU = m[u] * sx + m[3 + u] * sy - m[6 + u] * cameraDistance;
-                let directionV = m[v] * sx + m[3 + v] * sy - m[6 + v] * cameraDistance;
-                let index = dotY * dotWidth + face.minX;
-                for (let dotX = face.minX; dotX <= face.maxX; dotX++, index++) {
-                    const t = (face.plane - originA) / directionA;
-                    if (t > 0 && t < depth[index]) {
-                        const hitU = originU + t * directionU;
-                        const hitV = originV + t * directionV;
-                        if (hitU >= face.uMin && hitU <= face.uMax && hitV >= face.vMin && hitV <= face.vMax) {
-                            depth[index] = t;
-                            faceIds[index] = faceIndex + 1;
-                        }
-                    }
-                    directionA += stepA;
-                    directionU += stepU;
-                    directionV += stepV;
-                }
-            }
-        }
-        // Shade the hit dots, pack them into braille cells, and reset the dot buffers for the next frame.
-        const bits = this.bits;
-        const counts = this.counts;
-        const rgb = this.rgb;
-        let cellMinX = width;
-        let cellMinY = height;
-        let cellMaxX = -1;
-        let cellMaxY = -1;
-        for (let dotY = minY; dotY <= maxY; dotY++) {
-            let index = dotY * dotWidth + minX;
-            for (let dotX = minX; dotX <= maxX; dotX++, index++) {
-                const id = faceIds[index];
-                if (id === 0)
-                    continue;
-                const face = faces[id - 1];
-                // Points farther from the camera fade slightly toward the background for depth.
-                const fog = clamp01(0.15 - cameraDistance * (1 - depth[index]) * 0.12) * (light ? 0.5 : 1);
-                faceIds[index] = 0;
-                depth[index] = Infinity;
-                const cellX = dotX >> 1;
-                const cellY = dotY >> 2;
-                const cell = cellY * width + cellX;
-                bits[cell] |= DOT_BITS[(dotY & 3) * 2 + (dotX & 1)];
-                counts[cell]++;
-                rgb[cell * 3] += face.red + (background[0] - face.red) * fog;
-                rgb[cell * 3 + 1] += face.green + (background[1] - face.green) * fog;
-                rgb[cell * 3 + 2] += face.blue + (background[2] - face.blue) * fog;
-                if (cellX < cellMinX)
-                    cellMinX = cellX;
-                if (cellX > cellMaxX)
-                    cellMaxX = cellX;
-                if (cellY < cellMinY)
-                    cellMinY = cellY;
-                if (cellY > cellMaxY)
-                    cellMaxY = cellY;
-            }
-        }
-        if (cellMaxX >= 0)
-            this.dirty = { minX: cellMinX, minY: cellMinY, maxX: cellMaxX, maxY: cellMaxY };
-        if (haloStrength > 0)
-            this.renderHalo(haloStrength);
-    }
-    /**
-     * Blur the logo's coverage and color over neighboring cells with a separable tent filter, so the tint falls
-     * off smoothly past the logo's edges.
-     */
-    renderHalo(strength) {
-        const cells = this.dirty;
-        if (!cells)
-            return;
-        const { width, height, counts, rgb } = this;
-        const minX = Math.max(0, cells.minX - HALO_RADIUS_X);
-        const maxX = Math.min(width - 1, cells.maxX + HALO_RADIUS_X);
-        const minY = Math.max(0, cells.minY - HALO_RADIUS_Y);
-        const maxY = Math.min(height - 1, cells.maxY + HALO_RADIUS_Y);
-        const regionWidth = maxX - minX + 1;
-        const tent = (radius) => {
-            const weights = Array.from({ length: radius * 2 + 1 }, (_, i) => radius + 1 - Math.abs(i - radius));
-            const total = weights.reduce((sum, weight) => sum + weight, 0);
-            return weights.map((weight) => weight / total);
-        };
-        const weightsX = tent(HALO_RADIUS_X);
-        const weightsY = tent(HALO_RADIUS_Y);
-        // Horizontal pass over the rows that contain the logo: coverage and premultiplied color per cell.
-        const rows = cells.maxY - cells.minY + 1;
-        const horizontal = new Float32Array(rows * regionWidth * 4);
-        for (let y = cells.minY; y <= cells.maxY; y++) {
-            for (let x = minX; x <= maxX; x++) {
-                let coverage = 0;
-                let red = 0;
-                let green = 0;
-                let blue = 0;
-                for (let dx = -HALO_RADIUS_X; dx <= HALO_RADIUS_X; dx++) {
-                    const sourceX = x + dx;
-                    if (sourceX < cells.minX || sourceX > cells.maxX)
-                        continue;
-                    const source = y * width + sourceX;
-                    const count = counts[source];
-                    if (count === 0)
-                        continue;
-                    const weight = weightsX[dx + HALO_RADIUS_X] / 8;
-                    coverage += count * weight;
-                    red += rgb[source * 3] * weight;
-                    green += rgb[source * 3 + 1] * weight;
-                    blue += rgb[source * 3 + 2] * weight;
-                }
-                const target = ((y - cells.minY) * regionWidth + (x - minX)) * 4;
-                horizontal[target] = coverage;
-                horizontal[target + 1] = red;
-                horizontal[target + 2] = green;
-                horizontal[target + 3] = blue;
-            }
-        }
-        // Vertical pass into the halo buffers.
-        for (let y = minY; y <= maxY; y++) {
-            for (let x = minX; x <= maxX; x++) {
-                let coverage = 0;
-                let red = 0;
-                let green = 0;
-                let blue = 0;
-                for (let dy = -HALO_RADIUS_Y; dy <= HALO_RADIUS_Y; dy++) {
-                    const sourceY = y + dy;
-                    if (sourceY < cells.minY || sourceY > cells.maxY)
-                        continue;
-                    const weight = weightsY[dy + HALO_RADIUS_Y];
-                    const source = ((sourceY - cells.minY) * regionWidth + (x - minX)) * 4;
-                    coverage += horizontal[source] * weight;
-                    red += horizontal[source + 1] * weight;
-                    green += horizontal[source + 2] * weight;
-                    blue += horizontal[source + 3] * weight;
-                }
-                const target = y * width + x;
-                // Cells under the logo keep at least their own coverage, so faces stay solidly tinted.
-                const count = counts[target];
-                if (count > 0 && count / 8 > coverage) {
-                    coverage = count / 8;
-                    red = (rgb[target * 3] / count) * coverage;
-                    green = (rgb[target * 3 + 1] / count) * coverage;
-                    blue = (rgb[target * 3 + 2] / count) * coverage;
-                }
-                if (coverage <= 0)
-                    continue;
-                // Quantized so neighboring cells usually share a background and its escape sequence.
-                const amount = Math.round(strength * Math.min(1, coverage) ** 0.7 * HALO_LEVELS) / HALO_LEVELS;
-                if (amount <= 0)
-                    continue;
-                this.haloAmount[target] = amount;
-                this.haloRgb[target * 3] = Math.round(red / coverage / LOGO_COLOR_STEP) * LOGO_COLOR_STEP;
-                this.haloRgb[target * 3 + 1] = Math.round(green / coverage / LOGO_COLOR_STEP) * LOGO_COLOR_STEP;
-                this.haloRgb[target * 3 + 2] = Math.round(blue / coverage / LOGO_COLOR_STEP) * LOGO_COLOR_STEP;
-            }
-        }
-        this.haloDirty = { minX, minY, maxX, maxY };
-    }
-    visibleFaces(m, origin, pose, boxes, dotWidth, dotHeight, lightBackground) {
-        const faces = [];
-        const cameraDistance = this.cameraDistance;
-        for (const box of boxes) {
-            for (let a = 0; a < 3; a++) {
-                const u = (a + 1) % 3;
-                const v = (a + 2) % 3;
-                for (const side of [-1, 1]) {
-                    const plane = side > 0 ? box.max[a] : box.min[a];
-                    // Back faces point away from the camera.
-                    if ((origin[a] - plane) * side <= 0)
-                        continue;
-                    // Faces pressed against a neighboring block are hidden. Positions are exact while blocks rest.
-                    const covered = boxes.some((other) => other !== box &&
-                        (side > 0 ? other.min[a] : other.max[a]) === plane &&
-                        other.min[u] <= box.min[u] &&
-                        other.max[u] >= box.max[u] &&
-                        other.min[v] <= box.min[v] &&
-                        other.max[v] >= box.max[v]);
-                    if (covered)
-                        continue;
-                    let minX = Infinity;
-                    let minY = Infinity;
-                    let maxX = -Infinity;
-                    let maxY = -Infinity;
-                    const corner = [0, 0, 0];
-                    for (const cornerU of [box.min[u], box.max[u]]) {
-                        for (const cornerV of [box.min[v], box.max[v]]) {
-                            corner[a] = plane;
-                            corner[u] = cornerU;
-                            corner[v] = cornerV;
-                            const x = m[0] * corner[0] + m[1] * corner[1] + m[2] * corner[2];
-                            const y = m[3] * corner[0] + m[4] * corner[1] + m[5] * corner[2];
-                            const z = m[6] * corner[0] + m[7] * corner[1] + m[8] * corner[2];
-                            const perspective = (pose.scale * cameraDistance) / (cameraDistance - z);
-                            const screenX = pose.centerX + x * perspective;
-                            const screenY = pose.centerY + y * perspective;
-                            minX = Math.min(minX, screenX);
-                            minY = Math.min(minY, screenY);
-                            maxX = Math.max(maxX, screenX);
-                            maxY = Math.max(maxY, screenY);
-                        }
-                    }
-                    const face = {
-                        minX: Math.max(0, Math.floor(minX)),
-                        minY: Math.max(0, Math.floor(minY)),
-                        maxX: Math.min(dotWidth - 1, Math.ceil(maxX)),
-                        maxY: Math.min(dotHeight - 1, Math.ceil(maxY)),
-                    };
-                    if (face.maxX < face.minX || face.maxY < face.minY)
-                        continue;
-                    // Faces are flat, so lighting is computed once per face. The normal in camera space is a
-                    // column of the rotation matrix.
-                    const nx = m[a] * side;
-                    const ny = m[3 + a] * side;
-                    const nz = m[6 + a] * side;
-                    const diffuse = Math.max(0, nx * LIGHT[0] + ny * LIGHT[1] + nz * LIGHT[2]);
-                    const rim = Math.max(0, nx * 0.8 - nz * 0.3);
-                    // On light backgrounds, highlights toward white would vanish, so faces only get darker than
-                    // the brand colors there.
-                    const specular = lightBackground
-                        ? 0
-                        : Math.max(0, nx * HALF_VECTOR[0] + ny * HALF_VECTOR[1] + nz * HALF_VECTOR[2]) ** 24 * 0.6 * 255;
-                    const light = lightBackground
-                        ? Math.min(1, 0.55 + diffuse * 0.45 + rim * 0.1)
-                        : 0.45 + diffuse * 0.78 + rim * 0.25;
-                    faces.push({
-                        axis: a,
-                        plane,
-                        uMin: box.min[u],
-                        uMax: box.max[u],
-                        vMin: box.min[v],
-                        vMax: box.max[v],
-                        ...face,
-                        red: Math.min(255, box.color[0] * light + specular),
-                        green: Math.min(255, box.color[1] * light + specular),
-                        blue: Math.min(255, box.color[2] * light + specular),
-                    });
-                }
-            }
-        }
-        return faces;
-    }
-}
-let playing = false;
-/**
- * Show the animation as a fullscreen overlay until it is dismissed. The overlay takes focus and mouse input and
- * returns focus when hidden, so the rest of the UI keeps running underneath untouched.
- */
-export async function playEasterEgg3d(tui, screen, egg) {
-    if (playing)
-        return;
-    playing = true;
-    // Fading needs the terminal's actual default colors; the theme only knows its own.
-    const reported = await tui.queryTerminalColors({ timeoutMs: 100 });
-    const dark = theme.appearance === "dark";
-    const toRgbTuple = (rgb, fallback) => rgb ? [rgb.r, rgb.g, rgb.b] : fallback;
-    const colors = {
-        foreground: toRgbTuple(reported.foreground, toRgb(theme.colors.text)),
-        background: toRgbTuple(reported.background, dark ? [0, 0, 0] : [255, 255, 255]),
-    };
-    if (tui.hasOverlay()) {
-        playing = false;
-        return;
-    }
-    const model = egg.kind === "armin" ? arminModel(toRgb(theme.colors.accent)) : eLogoModel({ column: egg.column, row: egg.row });
-    const animation = new EasterEgg3dAnimation(tui, screen, model, colors, () => {
-        playing = false;
-        overlay.hide();
-    });
-    const overlay = tui.showOverlay(animation, { anchor: "top-left", width: "100%", maxHeight: "100%" });
-}
-export class EasterEgg3dAnimation {
-    tui;
-    /** The screen to dissolve, as rendered lines. */
-    screen;
-    model;
-    foreground;
-    background;
-    onDone;
-    startTime = performance.now();
-    lastRender = performance.now();
-    timer;
-    exit;
-    shuffle;
-    screenWidth = -1;
-    screenHeight = -1;
-    /** Star per cell index, or undefined. */
-    stars = [];
-    cells = [];
-    ansiCache = new Map();
-    raster;
-    constructor(tui, screen, model, colors, onDone) {
-        this.tui = tui;
-        this.screen = screen;
-        this.model = model;
-        this.raster = new BlockRaster(model.cameraDistance);
-        this.foreground = colors.foreground;
-        this.background = colors.background;
-        this.onDone = onDone;
-        this.timer = setInterval(() => {
-            // Also stop when no longer rendered, e.g. when pi hides all overlays on exit.
-            if ((this.exit && this.exitProgress() >= 1) || performance.now() - this.lastRender > 1000)
-                this.finish();
-            else
-                this.tui.requestRender();
-        }, FRAME_MS);
-        this.timer.unref?.();
-    }
-    /** Play the exit animation. A second call skips it. */
-    close() {
-        if (this.exit) {
-            this.finish();
-            return;
-        }
-        const time = this.elapsed();
-        const yaw = spinAngle(time);
-        const turn = Math.PI * 2;
-        this.exit = {
-            start: performance.now(),
-            time,
-            yaw,
-            targetYaw: Math.ceil(yaw / turn) * turn,
-            offsets: this.blockOffsets(time),
-        };
-    }
-    handleInput(data) {
-        const keybindings = getKeybindings();
-        if (keybindings.matches(data, "tui.select.cancel") || keybindings.matches(data, "app.clear"))
-            this.close();
-    }
-    handleMouse(event) {
-        if (event.type === "click")
-            this.close();
-        return { handled: true, render: false };
-    }
-    invalidate() {
-        this.screenWidth = -1;
-        this.screenHeight = -1;
-        this.ansiCache.clear();
-    }
-    render(width) {
-        const height = Math.max(1, this.tui.terminal.rows);
-        const foreground = this.foreground;
-        const background = this.background;
-        this.lastRender = performance.now();
-        if (width !== this.screenWidth || height !== this.screenHeight) {
-            this.screenWidth = width;
-            this.screenHeight = height;
-            this.cells = this.prepareCells(width, foreground);
-            this.stars = this.prepareStars(width, height);
-        }
-        // Dissolve time runs forward on entry and backward on exit, so the screen reassembles in reverse order.
-        let dissolveTime;
-        let pose;
-        let hintAlpha;
-        let starAlpha;
-        let offsets;
-        if (this.exit) {
-            const progress = this.exitProgress();
-            const landing = clamp01(progress / 0.8);
-            const settle = 1 - smooth(landing);
-            dissolveTime = Math.min(this.exit.time, DISSOLVE_END) * (1 - progress);
-            pose = this.pose(width, height, this.flyProgress(this.exit.time) * settle, this.exit.time);
-            pose.yaw = this.exit.yaw + (this.exit.targetYaw - this.exit.yaw) * easeOut(landing);
-            pose.pitch *= settle;
-            pose.roll *= settle;
-            hintAlpha = this.hintAlpha(this.exit.time) * (1 - smooth(progress / 0.2));
-            starAlpha = this.starAlpha(this.exit.time) * (1 - smooth(progress / 0.3));
-            // Blocks are home well before the logo lands.
-            const gather = 1 - smooth(progress / 0.5);
-            offsets = this.exit.offsets.map(([x, y, z]) => [x * gather, y * gather, z * gather]);
-        }
-        else {
-            const time = this.elapsed();
-            dissolveTime = time;
-            pose = this.pose(width, height, this.flyProgress(time), time);
-            hintAlpha = this.hintAlpha(time);
-            starAlpha = this.starAlpha(time);
-            offsets = this.blockOffsets(time);
-        }
-        const { columns, rows } = this.model;
-        const boxes = this.model.blocks.map((block, index) => {
-            const [dx, dy, dz] = offsets[index];
-            const x = block.home[0] - columns / 2 + dx;
-            const y = block.home[1] - rows / 2 + dy;
-            return { min: [x, y, dz - DEPTH / 2], max: [x + 1, y + 1, dz + DEPTH / 2], color: block.color };
-        });
-        const raster = this.raster;
-        raster.render(width, height, pose, boxes, background, isLight(background) ? LIGHT_HALO_STRENGTH : 0);
-        const halo = (index, base) => {
-            const amount = raster.haloAmount[index];
-            if (amount <= 0)
-                return base;
-            const color = raster.haloRgb;
-            return mix(base ?? background, [color[index * 3], color[index * 3 + 1], color[index * 3 + 2]], amount);
-        };
-        const backgroundFade = smooth(dissolveTime / BACKGROUND_FADE);
-        const textFade = smooth(dissolveTime / 0.6) * 0.3;
-        // Once the screen has fully dissolved, the text layer is empty and can be skipped.
-        const textActive = dissolveTime < DISSOLVE_END || backgroundFade < 1;
-        const hint = this.hint(width, height, hintAlpha, background);
-        const frame = Math.floor(dissolveTime * 14);
-        const now = this.elapsed();
-        // Star brightness is quantized, so a row only changes when one of its stars steps to another level
-        // instead of on every frame.
-        const starLevel = Math.round(starAlpha * STAR_ALPHA_LEVELS) / STAR_ALPHA_LEVELS;
-        const starfield = (index) => {
-            if (starLevel <= 0)
-                return undefined;
-            const star = this.stars[index];
-            if (!star)
-                return undefined;
-            const flicker = Math.round((0.5 + 0.5 * Math.sin(now * star.speed + star.phase)) * STAR_FLICKER_LEVELS) /
-                STAR_FLICKER_LEVELS;
-            return {
-                text: star.glyph,
-                fg: mix(background, mix(foreground, star.tint, 0.5), star.strength * (0.7 + 0.3 * flicker) * starLevel),
-            };
-        };
-        const lines = [];
-        for (let row = 0; row < height; row++) {
-            const cells = this.cells[row] ?? [];
-            let line = "";
-            let currentFg = -1;
-            let currentBg = -1;
-            const emit = (text, fg, bg) => {
-                const fgKey = fg ? this.pack(fg) : -1;
-                const bgKey = bg ? this.pack(bg) : -1;
-                if (fgKey !== currentFg && text !== " ") {
-                    line += fg ? this.ansi(fgKey, false) : "\x1b[39m";
-                    currentFg = fgKey;
-                }
-                if (bgKey !== currentBg) {
-                    line += bg ? this.ansi(bgKey, true) : "\x1b[49m";
-                    currentBg = bgKey;
-                }
-                line += text;
-            };
-            for (let column = 0; column < width; column++) {
-                const index = row * width + column;
-                const cell = textActive ? cells[column] : undefined;
-                const cellBg = halo(index, cell?.bg && backgroundFade < 1 ? mix(cell.bg, background, backgroundFade) : undefined);
-                if (hint && row === hint.row && column >= hint.start && column < hint.start + hint.text.length) {
-                    const offset = column - hint.start;
-                    emit(hint.text[offset], offset < hint.keyLength ? hint.keyColor : hint.color, cellBg);
-                    continue;
-                }
-                const dots = raster.bits[index];
-                if (dots) {
-                    // Quantized so neighboring cells on one face usually share a color and its escape sequence.
-                    const step = LOGO_COLOR_STEP * raster.counts[index];
-                    const rgb = raster.rgb;
-                    const color = [
-                        Math.round(rgb[index * 3] / step) * LOGO_COLOR_STEP,
-                        Math.round(rgb[index * 3 + 1] / step) * LOGO_COLOR_STEP,
-                        Math.round(rgb[index * 3 + 2] / step) * LOGO_COLOR_STEP,
-                    ];
-                    emit(BRAILLE[dots], color, cellBg);
-                    continue;
-                }
-                if (!cell) {
-                    const star = starfield(index);
-                    emit(star?.text ?? " ", star?.fg, cellBg);
-                    continue;
-                }
-                const dust = (dissolveTime - cell.delay) / DUST_DURATION;
-                if (dust < 0 && cell.width === 2 && !raster.bits[index + 1]) {
-                    emit(cell.text, mix(cell.fg, background, textFade), cellBg);
-                    column++;
-                    continue;
-                }
-                if (dust < 0 && cell.width === 1) {
-                    emit(cell.text, mix(cell.fg, background, textFade), cellBg);
-                    continue;
-                }
-                const dotCount = dust < 0 ? cell.ink : Math.round(cell.ink * (1 - clamp01(dust)));
-                if (dotCount <= 0) {
-                    const star = starfield(index);
-                    emit(star?.text ?? " ", star?.fg, cellBg);
-                    continue;
-                }
-                // Pick `dotCount` distinct dots; the choice changes a few times per second so the dust shimmers.
-                let bits = 0;
-                let placed = 0;
-                for (let attempt = 0; placed < dotCount && attempt < 32; attempt++) {
-                    const bit = DOT_BITS[Math.floor(hash(cell.seed * 7919 + frame * 131 + attempt) * 8)];
-                    if (bits & bit)
-                        continue;
-                    bits |= bit;
-                    placed++;
-                }
-                const fade = textFade + (1 - textFade) * clamp01(dust) ** 0.8;
-                emit(BRAILLE[bits], mix(cell.fg, background, fade), cellBg);
-            }
-            lines.push(`${line}\x1b[0m`);
-        }
-        return lines;
-    }
-    elapsed() {
-        return (performance.now() - this.startTime) / 1000;
-    }
-    exitProgress() {
-        return this.exit ? clamp01((performance.now() - this.exit.start) / 1000 / EXIT_DURATION) : 0;
-    }
-    finish() {
-        if (!this.timer)
-            return;
-        clearInterval(this.timer);
-        this.timer = undefined;
-        this.onDone();
-    }
-    /** Each block's displacement from its place in the model at `time`, in grid units. */
-    blockOffsets(time) {
-        const blocks = this.model.blocks;
-        const home = () => blocks.map(() => [0, 0, 0]);
-        if (time < PUZZLE_START)
-            return home();
-        const cycle = Math.floor((time - PUZZLE_START) / PUZZLE_CYCLE);
-        const local = time - PUZZLE_START - cycle * PUZZLE_CYCLE;
-        if (this.shuffle?.cycle !== cycle)
-            this.shuffle = { cycle, steps: shuffleSteps(this.model, cycle) };
-        const steps = this.shuffle.steps;
-        const offset = (position, index) => {
-            const block = blocks[index].home;
-            return [position[0] - block[0], position[1] - block[1], position[2] - block[2]];
-        };
-        const shuffleEnd = PUZZLE_STEP * PUZZLE_STEPS;
-        if (local < shuffleEnd) {
-            const step = Math.floor(local / PUZZLE_STEP);
-            const progress = smooth((local - step * PUZZLE_STEP) / PUZZLE_STEP);
-            return steps[step].map((from, index) => {
-                const a = offset(from, index);
-                const b = offset(steps[step + 1][index], index);
-                return [a[0] + (b[0] - a[0]) * progress, a[1] + (b[1] - a[1]) * progress, a[2] + (b[2] - a[2]) * progress];
-            });
-        }
-        if (local < shuffleEnd + PUZZLE_RETURN) {
-            // All blocks fly home at once. Alternating arcs in depth keep them from passing through each other.
-            const u = (local - shuffleEnd) / PUZZLE_RETURN;
-            const remaining = 1 - smooth(u);
-            const arc = Math.sin(Math.PI * clamp01(u)) * 0.8;
-            return steps[PUZZLE_STEPS].map((position, index) => {
-                const [x, y, z] = offset(position, index);
-                return [x * remaining, y * remaining, z * remaining + (index % 2 === 0 ? arc : -arc)];
-            });
-        }
-        return home();
-    }
-    flyProgress(time) {
-        return smooth((time - FLY_START) / FLY_DURATION);
-    }
-    starAlpha(time) {
-        return smooth((time - STARS_START) / STARS_FADE);
-    }
-    hintAlpha(time) {
-        return smooth((time - FLY_START - FLY_DURATION) / HINT_FADE);
-    }
-    pose(width, height, progress, time) {
-        const { columns, rows, cameraDistance, radius, widthShare, origin } = this.model;
-        const reach = radius * (cameraDistance / (cameraDistance - radius));
-        // Lifting off, the front face must cover exactly the half-block cells (2x2 dots per pixel) despite the
-        // perspective.
-        const startScale = origin ? (2 * (cameraDistance - DEPTH / 2)) / cameraDistance : START_SCALE;
-        const endScale = Math.max(startScale, Math.min(width * 2 * widthShare, (height * 4 - 8) * 0.48) / reach);
-        const endX = width;
-        const endY = height * 2 - 2;
-        const startX = origin ? origin.column * 2 + columns : endX;
-        const startY = origin ? origin.row * 4 + rows : endY;
-        return {
-            centerX: startX + (endX - startX) * progress,
-            centerY: startY + (endY - startY) * progress,
-            // Interpolate the zoom geometrically so it feels uniform.
-            scale: startScale * (endScale / startScale) ** progress,
-            yaw: spinAngle(time),
-            // Tilts are zero at whole turns, so the camera looks straight at the front of the reassembled logo.
-            pitch: 0.3 * Math.sin(spinPhase(time)) * progress,
-            roll: 0.06 * Math.sin(2 * spinPhase(time)) * progress,
-        };
-    }
-    hint(width, height, alpha, background) {
-        if (alpha <= 0)
-            return undefined;
-        const key = formatKeyText(getKeybindings().getKeys("tui.select.cancel")[0] ?? "escape");
-        const text = `${key} to return`;
-        if (text.length > width)
-            return undefined;
-        return {
-            row: height - 2,
-            start: Math.floor((width - text.length) / 2),
-            text,
-            keyLength: key.length,
-            keyColor: mix(background, toRgb(theme.colors.muted), alpha),
-            color: mix(background, toRgb(theme.colors.dim), alpha),
-        };
-    }
-    /** A sparse, deterministic starfield: one braille dot in about STAR_DENSITY of all cells. */
-    prepareStars(width, height) {
-        const stars = new Array(width * height);
-        for (let index = 0; index < width * height; index++) {
-            if (hash(index * 3 + 0x51ed) >= STAR_DENSITY)
-                continue;
-            const random = (salt) => hash(index * 7 + salt * 0x9e37);
-            stars[index] = {
-                glyph: BRAILLE[DOT_BITS[Math.floor(random(1) * 8)]],
-                tint: STAR_TINTS[Math.floor(random(2) * STAR_TINTS.length)],
-                strength: 0.1 + random(3) * 0.12,
-                phase: random(4) * Math.PI * 2,
-                speed: 0.4 + random(5) * 0.8,
-            };
-        }
-        return stars;
-    }
-    prepareCells(width, foreground) {
-        const cells = parseScreen(this.screen, width, foreground, this.background);
-        const height = Math.max(1, this.tui.terminal.rows);
-        const { columns, rows, origin } = this.model;
-        // The dust spreads out from where the model starts.
-        const centerX = origin ? origin.column + columns / 2 : width / 2;
-        const centerY = origin ? origin.row + rows / 4 : height / 2;
-        const farthest = Math.hypot(Math.max(centerX, width - centerX), Math.max(centerY, height - centerY) * 2);
-        for (let row = 0; row < cells.length; row++) {
-            const line = cells[row];
-            for (let column = 0; column < line.length; column++) {
-                const cell = line[column];
-                // Wide graphemes share their first column's timing so both halves change together.
-                const owner = cell.width === 0 ? line[column - 1] : cell;
-                const seed = hash(row * 65_537 + column);
-                if (cell.width !== 0) {
-                    const distance = Math.hypot(column - centerX, (row - centerY) * 2) / farthest;
-                    cell.delay = FLY_START + distance * WAVE_SPREAD + seed * WAVE_JITTER;
-                }
-                else {
-                    cell.delay = owner.delay;
-                }
-                cell.seed = row * 65_537 + column;
-                cell.ink = glyphInk(owner.text, seed);
-            }
-        }
-        // The 3D model replaces its half-block rendering on screen.
-        if (origin) {
-            for (let row = origin.row; row < origin.row + Math.ceil(rows / 2); row++) {
-                const line = cells[row];
-                if (!line)
-                    continue;
-                for (let column = origin.column; column < origin.column + columns; column++) {
-                    const cell = line[column];
-                    if (cell) {
-                        cell.text = " ";
-                        cell.width = 1;
-                        cell.ink = 0;
-                        cell.bg = undefined;
-                    }
-                }
-            }
-        }
-        return cells;
-    }
-    pack(color) {
-        return (Math.round(color[0]) << 16) | (Math.round(color[1]) << 8) | Math.round(color[2]);
-    }
-    ansi(key, isBackground) {
-        const cacheKey = key * 2 + (isBackground ? 1 : 0);
-        let value = this.ansiCache.get(cacheKey);
-        if (value === undefined) {
-            const color = rgbColor((key >> 16) & 255, (key >> 8) & 255, key & 255);
-            const mode = theme.getColorMode();
-            value = isBackground ? backgroundAnsi(color, mode) : foregroundAnsi(color, mode);
-            this.ansiCache.set(cacheKey, value);
-        }
-        return value;
-    }
-}
-//# sourceMappingURL=easter-egg-3d.js.map