uigraph 1.0.0 → 1.0.1

package/dist/easter-egg-3d-C9_btlWn.mjs

@@ -1,1225 +0,0 @@
-import { Ct as colorToRgb, M as theme, Mt as visibleWidth, Ot as rgbColor, St as backgroundAnsi, Tt as indexedColor, ct as getKeybindings, t as formatKeyText, wt as foregroundAnsi } from "./keybinding-hints-D0nLU3ZH.mjs";
-import { n as isArminPixel } from "./dist-EKhnHWHG.mjs";
-//#region node_modules/.pnpm/@earendil-works+pi-coding-agent@1.2.0_@aws-sdk+credential-provider-node@3.972.86_@model_cb83c1bd7a7ff5cede8c43e329c5cf76/node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/components/easter-egg-3d.js
-const DEPTH = .7;
-const FLY_START = .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 = .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.35),
-		widthShare: options.widthShare,
-		puzzleMoves: (random) => options.puzzleMoves(random, blocks.length),
-		origin: options.origin
-	};
-}
-const CORAL = [
-	228,
-	138,
-	122
-];
-const BLUE = [
-	79,
-	142,
-	179
-];
-const YELLOW = [
-	234,
-	182,
-	93
-];
-const PI_LOGO_PIXELS = [
-	"ccc.",
-	"b.c.",
-	"bb.y",
-	"b..y"
-];
-const PI_LOGO_COLORS = {
-	c: CORAL,
-	b: BLUE,
-	y: YELLOW
-};
-function piLogoModel(origin) {
-	return createModel(4, 4, (column, row) => PI_LOGO_COLORS[PI_LOGO_PIXELS[row][column]], {
-		cameraDistance: 10,
-		widthShare: .35,
-		puzzleMoves: (random) => random < .4 ? 2 : 1,
-		origin
-	});
-}
-function arminModel(color) {
-	return createModel(31, 36, (column, row) => isArminPixel(column, row) ? color : void 0, {
-		cameraDistance: 80,
-		widthShare: .45,
-		puzzleMoves: (random, blockCount) => Math.round(blockCount * (.03 + random * .04)),
-		origin: void 0
-	});
-}
-const PUZZLE_START = 4.4;
-const PUZZLE_STEP = .3;
-const PUZZLE_STEPS = 12;
-const PUZZLE_RETURN = 1;
-const PUZZLE_CYCLE = 5.199999999999999;
-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 = /* @__PURE__ */ new Set();
-	let random = cycle * 7919 + 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 = /* @__PURE__ */ 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
-					});
-				}
-			}
-			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 = 1e3 / 30;
-const DUST_DURATION = .35;
-const WAVE_SPREAD = .55;
-const WAVE_JITTER = .12;
-const DISSOLVE_END = 1.12;
-const BACKGROUND_FADE = .5;
-const EXIT_DURATION = 1.1;
-const STARS_START = 2.5;
-const STARS_FADE = 2;
-const STAR_DENSITY = .018;
-const STAR_TINTS = [
-	[
-		255,
-		255,
-		255
-	],
-	[
-		170,
-		195,
-		255
-	],
-	[
-		255,
-		225,
-		170
-	],
-	[
-		255,
-		190,
-		205
-	]
-];
-const LOGO_COLOR_STEP = 5;
-const LIGHT_HALO_STRENGTH = .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 = .5;
-const DOT_BITS = [
-	1,
-	8,
-	2,
-	16,
-	4,
-	32,
-	64,
-	128
-];
-const BRAILLE = Array.from({ length: 256 }, (_, bits) => String.fromCharCode(10240 + bits));
-const LIGHT = normalize([
-	-.45,
-	-.6,
-	.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 ^ 2654435769, 2246822507);
-	x ^= x >>> 13;
-	x = Math.imul(x, 3266489909);
-	x ^= x >>> 16;
-	return (x >>> 0) / 4294967296;
-}
-/** Whether a background is light, by relative luminance. */
-function isLight([r, g, b]) {
-	return .2126 * r + .7152 * g + .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) {
-					let args;
-					if (parts.length > 1) args = parts.slice(1).filter((part) => !Number.isNaN(part));
-					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] !== void 0) 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 = void 0;
-					bg = void 0;
-					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 = void 0;
-				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 = void 0;
-			}
-		};
-		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, .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) < 64 || line.charCodeAt(end) > 126)) end++;
-				if (line[end] === "m") applySgr(line.slice(sequenceStart + 2, end));
-				i = end + 1;
-			} else if (kind === "]" || kind === "_" || kind === "P" || kind === "^") {
-				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)
-	];
-	const ry = [
-		cy,
-		0,
-		sy,
-		0,
-		1,
-		0,
-		-sy,
-		0,
-		cy
-	];
-	const rx = [
-		1,
-		0,
-		0,
-		0,
-		cx,
-		-sx,
-		0,
-		sx,
-		cx
-	];
-	return multiply([
-		cz,
-		-sz,
-		0,
-		sz,
-		cz,
-		0,
-		0,
-		0,
-		1
-	], 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;
-}
-const SPIN_RAMP = 1.4;
-const SPIN_SPEED = Math.PI * 2 / PUZZLE_CYCLE;
-const SPIN_LINGER = .6;
-const FIRST_FRONT_VIEW = 9.3;
-/** 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;
-	if (u < 1) return SPIN_SPEED * SPIN_RAMP * (u ** 6 - 3 * u ** 5 + 2.5 * u ** 4);
-	return SPIN_SPEED * (SPIN_RAMP * .5 + elapsed - SPIN_RAMP);
-}
-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.
-*/
-var BlockRaster = class {
-	/** Braille dot bits per cell. */
-	bits = /* @__PURE__ */ new Uint8Array(0);
-	/** Lit dots per cell. */
-	counts = /* @__PURE__ */ new Uint8Array(0);
-	/** Summed RGB of the lit dots per cell. */
-	rgb = /* @__PURE__ */ new Float32Array(0);
-	/** Halo tint strength per cell, from 0 to 1. Only set when a halo was requested. */
-	haloAmount = /* @__PURE__ */ new Float32Array(0);
-	/** Halo color per cell. */
-	haloRgb = /* @__PURE__ */ new Float32Array(0);
-	width = 0;
-	height = 0;
-	/** Ray parameter of the nearest hit per dot; smaller is nearer. */
-	depth = /* @__PURE__ */ new Float32Array(0);
-	/** Face index + 1 of the nearest hit per dot, 0 for none. */
-	faceIds = /* @__PURE__ */ 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 = void 0;
-			this.depth = new Float32Array(dotWidth * dotHeight).fill(Infinity);
-			this.faceIds = new Uint16Array(dotWidth * dotHeight);
-			this.dirty = void 0;
-		} 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 = void 0;
-		}
-		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 = void 0;
-		}
-		const m = rotation(pose.yaw, pose.pitch, pose.roll);
-		const { centerX, centerY, scale } = pose;
-		const cameraDistance = this.cameraDistance;
-		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];
-			const stepA = m[a] / scale;
-			const stepU = m[u] / scale;
-			const stepV = m[v] / scale;
-			const sx = (face.minX + .5 - centerX) / scale;
-			for (let dotY = face.minY; dotY <= face.maxY; dotY++) {
-				const sy = (dotY + .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;
-				}
-			}
-		}
-		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];
-				const fog = clamp01(.15 - cameraDistance * (1 - depth[index]) * .12) * (light ? .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);
-		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 = -6; 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;
-		}
-		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 = -3; 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;
-			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;
-			const amount = Math.round(strength * Math.min(1, coverage) ** .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];
-				if ((origin[a] - plane) * side <= 0) continue;
-				if (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])) 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;
-				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 * .8 - nz * .3);
-				const specular = lightBackground ? 0 : Math.max(0, nx * HALF_VECTOR[0] + ny * HALF_VECTOR[1] + nz * HALF_VECTOR[2]) ** 24 * .6 * 255;
-				const light = lightBackground ? Math.min(1, .55 + diffuse * .45 + rim * .1) : .45 + diffuse * .78 + rim * .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.
-*/
-async function playEasterEgg3d(tui, screen, egg) {
-	if (playing) return;
-	playing = true;
-	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 animation = new EasterEgg3dAnimation(tui, screen, egg.kind === "armin" ? arminModel(toRgb(theme.colors.accent)) : piLogoModel({
-		column: egg.column,
-		row: egg.row
-	}), colors, () => {
-		playing = false;
-		overlay.hide();
-	});
-	const overlay = tui.showOverlay(animation, {
-		anchor: "top-left",
-		width: "100%",
-		maxHeight: "100%"
-	});
-}
-var EasterEgg3dAnimation = class {
-	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 = /* @__PURE__ */ 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(() => {
-			if (this.exit && this.exitProgress() >= 1 || performance.now() - this.lastRender > 1e3) 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);
-		}
-		let dissolveTime;
-		let pose;
-		let hintAlpha;
-		let starAlpha;
-		let offsets;
-		if (this.exit) {
-			const progress = this.exitProgress();
-			const landing = clamp01(progress / .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 / .2));
-			starAlpha = this.starAlpha(this.exit.time) * (1 - smooth(progress / .3));
-			const gather = 1 - smooth(progress / .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 / .6) * .3;
-		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();
-		const starLevel = Math.round(starAlpha * STAR_ALPHA_LEVELS) / STAR_ALPHA_LEVELS;
-		const starfield = (index) => {
-			if (starLevel <= 0) return void 0;
-			const star = this.stars[index];
-			if (!star) return void 0;
-			const flicker = Math.round((.5 + .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, .5), star.strength * (.7 + .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] : void 0;
-				const cellBg = halo(index, cell?.bg && backgroundFade < 1 ? mix(cell.bg, background, backgroundFade) : void 0);
-				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) {
-					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;
-				}
-				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) ** .8;
-				emit(BRAILLE[bits], mix(cell.fg, background, fade), cellBg);
-			}
-			lines.push(`${line}\x1b[0m`);
-		}
-		return lines;
-	}
-	elapsed() {
-		return (performance.now() - this.startTime) / 1e3;
-	}
-	exitProgress() {
-		return this.exit ? clamp01((performance.now() - this.exit.start) / 1e3 / EXIT_DURATION) : 0;
-	}
-	finish() {
-		if (!this.timer) return;
-		clearInterval(this.timer);
-		this.timer = void 0;
-		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 < 4.6) {
-			const u = (local - shuffleEnd) / PUZZLE_RETURN;
-			const remaining = 1 - smooth(u);
-			const arc = Math.sin(Math.PI * clamp01(u)) * .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));
-		const startScale = origin ? 2 * (cameraDistance - DEPTH / 2) / cameraDistance : START_SCALE;
-		const endScale = Math.max(startScale, Math.min(width * 2 * widthShare, (height * 4 - 8) * .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,
-			scale: startScale * (endScale / startScale) ** progress,
-			yaw: spinAngle(time),
-			pitch: .3 * Math.sin(spinPhase(time)) * progress,
-			roll: .06 * Math.sin(2 * spinPhase(time)) * progress
-		};
-	}
-	hint(width, height, alpha, background) {
-		if (alpha <= 0) return void 0;
-		const key = formatKeyText(getKeybindings().getKeys("tui.select.cancel")[0] ?? "escape");
-		const text = `${key} to return`;
-		if (text.length > width) return void 0;
-		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 + 20973) >= STAR_DENSITY) continue;
-			const random = (salt) => hash(index * 7 + salt * 40503);
-			stars[index] = {
-				glyph: BRAILLE[DOT_BITS[Math.floor(random(1) * 8)]],
-				tint: STAR_TINTS[Math.floor(random(2) * STAR_TINTS.length)],
-				strength: .1 + random(3) * .12,
-				phase: random(4) * Math.PI * 2,
-				speed: .4 + random(5) * .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;
-		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];
-				const owner = cell.width === 0 ? line[column - 1] : cell;
-				const seed = hash(row * 65537 + 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 * 65537 + column;
-				cell.ink = glyphInk(owner.text, seed);
-			}
-		}
-		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 = void 0;
-				}
-			}
-		}
-		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 === void 0) {
-			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;
-	}
-};
-//#endregion
-export { playEasterEgg3d };