@alchemy.run/sigil 0.0.0-alpha.1 → 0.0.0-alpha.11

package/dist/color-policy-BAC9-TZX.js

@@ -0,0 +1,592 @@
+import { _ as CSI, b as OSC } from "./sgr-BhwaWAJB.js";
+import { a as isTty } from "./env-YVw64yZS.js";
+import { n as detectCapabilities, s as signalExit } from "./detect-B3dL4Q11.js";
+import { t as colorProfileFromLevel } from "./color-profile-DHhQHY55.js";
+//#region src/capabilities/query.ts
+/**
+The DEC private modes queried via DECRQM, by name.
+*/
+const queriedModes = {
+	focusEvents: 1004,
+	sgrMouse: 1006,
+	sgrPixelMouse: 1016,
+	bracketedPaste: 2004,
+	synchronizedOutput: 2026,
+	graphemeClustering: 2027,
+	colorSchemeUpdates: 2031,
+	inBandResize: 2048
+};
+const paletteSize = 16;
+const parseColorValue = (value) => {
+	if (value.startsWith("rgb:")) {
+		const parts = value.slice(4).split("/");
+		if (parts.length !== 3) return;
+		const channels = parts.map((part) => {
+			if (!/^[0-9a-fA-F]{1,4}$/.test(part)) return;
+			return Math.round(Number.parseInt(part, 16) / (16 ** part.length - 1) * 255);
+		});
+		if (channels.some((channel) => channel === void 0)) return;
+		return {
+			r: channels[0],
+			g: channels[1],
+			b: channels[2]
+		};
+	}
+	if (/^#[0-9a-fA-F]{6}$/.test(value)) return {
+		r: Number.parseInt(value.slice(1, 3), 16),
+		g: Number.parseInt(value.slice(3, 5), 16),
+		b: Number.parseInt(value.slice(5, 7), 16)
+	};
+};
+const appearanceOf = (background) => {
+	if (!background) return;
+	return .2126 * background.r + .7152 * background.g + .0722 * background.b > 127.5 ? "light" : "dark";
+};
+const parseXtversion = (raw) => {
+	const match = raw.match(/^(.+?)[(\s]v?(\d[\w.-]*)\)?$/);
+	if (!match) return {
+		raw,
+		name: raw.toLowerCase() || void 0,
+		version: void 0
+	};
+	return {
+		raw,
+		name: match[1].trim().toLowerCase(),
+		version: match[2]
+	};
+};
+const xtgettcapRgb = "524742";
+const kittyGraphicsProbe = `_Gi=31,s=1,v=1,a=q,t=d,f=24;AAAA\\`;
+const oscColorResponse = new RegExp(`\\](\\d+);(?:(\\d+);)?([^]*)(?:|\\\\)`);
+const kittyKeyboardResponse = new RegExp(`\\[\\?(\\d+)u`);
+const decrqmResponse = new RegExp(`\\[\\?(\\d+);(\\d+)\\$y`);
+const xtversionResponse = new RegExp(`P>\\|([^]*)\\\\`);
+const xtgettcapResponse = new RegExp(`P([01])\\+r([^]*)\\\\`);
+const kittyGraphicsResponse = new RegExp(`_G([^]*)\\\\`);
+const winopsResponse = new RegExp(`\\[(4|6);(\\d+);(\\d+)t`);
+const colorSchemeResponse = new RegExp(`\\[\\?997;(\\d+)n`);
+const da1Response = new RegExp(`\\[\\?([\\d;]*)c`);
+const terminalResponses = [
+	oscColorResponse,
+	kittyKeyboardResponse,
+	decrqmResponse,
+	xtversionResponse,
+	xtgettcapResponse,
+	kittyGraphicsResponse,
+	winopsResponse,
+	colorSchemeResponse,
+	da1Response
+].map((pattern) => new RegExp(`^(?:${pattern.source})$`));
+const isTerminalQueryResponse = (sequence) => terminalResponses.some((pattern) => pattern.test(sequence));
+const buildQuery = (palette, scope) => {
+	const queries = [
+		`${OSC}10;?`,
+		`${OSC}11;?`,
+		`${OSC}12;?`
+	];
+	if (palette) for (let index = 0; index < paletteSize; index++) queries.push(`${OSC}4;${index};?`);
+	if (scope === "full") {
+		for (const mode of Object.values(queriedModes)) queries.push(`${CSI}?${mode}$p`);
+		queries.push(`${CSI}?u`, `P+q${xtgettcapRgb}\\`, kittyGraphicsProbe, `${CSI}>0q`);
+	}
+	queries.push(`${CSI}14t`, `${CSI}16t`, `${CSI}?996n`, `${CSI}c`);
+	return queries.join("");
+};
+/**
+Sends a batch of terminal queries and collects the responses. Resolves when
+the terminal answers the DA1 sentinel, or after `timeout` with whatever was
+gathered. Stdin bytes that are not query responses are pushed back into the
+stream.
+
+The query is lazy: nothing is sent until something asks. Inside an Ink app,
+use `useCapabilities` — it triggers the query through Ink's input pipeline so
+responses can't collide with key handling. Call this directly only outside of
+Ink, before any other stdin consumer is attached.
+*/
+const queryTerminal = async (stdin, stdout, { timeout = 500, palette = true, scope = "full" } = {}) => new Promise((resolve) => {
+	const result = {
+		foreground: void 0,
+		background: void 0,
+		cursorColor: void 0,
+		palette: void 0,
+		appearance: void 0,
+		systemAppearance: void 0,
+		kittyKeyboard: false,
+		kittyGraphics: false,
+		sixel: false,
+		deviceAttributes: void 0,
+		trueColor: false,
+		focusEvents: false,
+		sgrMouse: false,
+		sgrPixelMouse: false,
+		bracketedPaste: false,
+		synchronizedOutput: false,
+		graphemeClustering: false,
+		colorSchemeUpdates: false,
+		inBandResize: false,
+		textAreaPixels: void 0,
+		cellPixels: void 0,
+		terminal: void 0
+	};
+	const paletteColors = /* @__PURE__ */ new Map();
+	let reportedAppearance;
+	let buffer = "";
+	let receivedStrings = false;
+	let done = false;
+	const finish = () => {
+		if (done) return;
+		done = true;
+		clearTimeout(timer);
+		stdin.pause();
+		stdin.removeListener("data", onData);
+		if (paletteColors.size === paletteSize) result.palette = Array.from({ length: paletteSize }, (_, index) => paletteColors.get(index));
+		result.systemAppearance = reportedAppearance;
+		result.appearance = appearanceOf(result.background) ?? reportedAppearance;
+		if (buffer.length > 0) {
+			stdin.unshift(receivedStrings ? buffer : Buffer.from(buffer, "latin1"));
+			buffer = "";
+		}
+		resolve(result);
+	};
+	const consumeMatch = (pattern) => {
+		const match = buffer.match(pattern);
+		if (match) buffer = buffer.replace(pattern, "");
+		return match ?? void 0;
+	};
+	const consumeResponse = () => {
+		const oscMatch = consumeMatch(oscColorResponse);
+		if (oscMatch) {
+			const [, code, index, value] = oscMatch;
+			const color = parseColorValue(value);
+			if (color) {
+				if (code === "10") result.foreground = color;
+				else if (code === "11") result.background = color;
+				else if (code === "12") result.cursorColor = color;
+				else if (code === "4" && index !== void 0) paletteColors.set(Number.parseInt(index, 10), color);
+			}
+			return true;
+		}
+		const xtversionMatch = consumeMatch(xtversionResponse);
+		if (xtversionMatch) {
+			const raw = xtversionMatch[1].trim();
+			if (raw.length > 0) result.terminal = parseXtversion(raw);
+			return true;
+		}
+		const xtgettcapMatch = consumeMatch(xtgettcapResponse);
+		if (xtgettcapMatch) {
+			if (xtgettcapMatch[1] === "1" && xtgettcapMatch[2].includes(xtgettcapRgb)) result.trueColor = true;
+			return true;
+		}
+		const graphicsMatch = consumeMatch(kittyGraphicsResponse);
+		if (graphicsMatch) {
+			if (graphicsMatch[1].includes("OK")) result.kittyGraphics = true;
+			return true;
+		}
+		const decrqmMatch = consumeMatch(decrqmResponse);
+		if (decrqmMatch) {
+			const mode = Number.parseInt(decrqmMatch[1], 10);
+			const recognized = decrqmMatch[2] !== "0";
+			for (const [name, number] of Object.entries(queriedModes)) if (number === mode) result[name] = recognized;
+			return true;
+		}
+		const winopsMatch = consumeMatch(winopsResponse);
+		if (winopsMatch) {
+			const size = {
+				height: Number.parseInt(winopsMatch[2], 10),
+				width: Number.parseInt(winopsMatch[3], 10)
+			};
+			if (winopsMatch[1] === "4") result.textAreaPixels = size;
+			else result.cellPixels = size;
+			return true;
+		}
+		const colorSchemeMatch = consumeMatch(colorSchemeResponse);
+		if (colorSchemeMatch) {
+			if (colorSchemeMatch[1] === "1") reportedAppearance = "dark";
+			else if (colorSchemeMatch[1] === "2") reportedAppearance = "light";
+			return true;
+		}
+		if (consumeMatch(kittyKeyboardResponse)) {
+			result.kittyKeyboard = true;
+			return true;
+		}
+		const da1Match = consumeMatch(da1Response);
+		if (da1Match) {
+			const attributes = da1Match[1].split(";").filter((part) => part.length > 0).map((part) => Number.parseInt(part, 10));
+			result.deviceAttributes = attributes;
+			result.sixel = attributes.slice(1).includes(4);
+			finish();
+			return false;
+		}
+		return false;
+	};
+	const onData = (data) => {
+		receivedStrings = typeof data === "string";
+		buffer += typeof data === "string" ? data : Buffer.from(data).toString("latin1");
+		while (consumeResponse());
+	};
+	stdin.on("data", onData);
+	const timer = setTimeout(finish, timeout);
+	stdin.resume();
+	stdout.write(buildQuery(palette, scope));
+});
+const queryPromises = /* @__PURE__ */ new WeakMap();
+const queryResults = /* @__PURE__ */ new WeakMap();
+/**
+Starts (or joins) the terminal query for a stdout stream. The result is
+cached per stream — the terminal is only ever asked once.
+*/
+const ensureTerminalQuery = (stdin, stdout, options) => {
+	let promise = queryPromises.get(stdout);
+	if (!promise) {
+		promise = queryTerminal(stdin, stdout, options);
+		promise.then((result) => queryResults.set(stdout, result));
+		queryPromises.set(stdout, promise);
+	}
+	return promise;
+};
+/**
+The completed query result for a stdout stream, if the query has finished.
+*/
+const getTerminalQuery = (stdout) => queryResults.get(stdout);
+const getTerminalQueryPromise = (stdout) => queryPromises.get(stdout);
+/**
+Merges a partial update (from an unsolicited terminal report) into the
+cached query result. Returns the merged result, or `undefined` when no query
+has completed yet.
+*/
+const patchTerminalQuery = (stdout, patch) => {
+	const previous = queryResults.get(stdout);
+	if (!previous) return;
+	const merged = {
+		...previous,
+		...patch
+	};
+	queryResults.set(stdout, merged);
+	queryPromises.set(stdout, Promise.resolve(merged));
+	return merged;
+};
+const refreshPromises = /* @__PURE__ */ new WeakMap();
+/**
+Re-asks the terminal only the dynamic questions — colors/theme and pixel
+geometry, which change when the user switches themes or resizes — and merges
+the answers into the cached result. Static facts (mode and protocol support,
+identity) are kept from the original query. Falls back to a full query when
+none has completed yet; concurrent refreshes share one round-trip.
+*/
+const refreshTerminalQuery = (stdin, stdout, options) => {
+	const previous = queryResults.get(stdout);
+	if (!previous) return ensureTerminalQuery(stdin, stdout, options);
+	const inFlight = refreshPromises.get(stdout);
+	if (inFlight) return inFlight;
+	const promise = queryTerminal(stdin, stdout, {
+		...options,
+		scope: "dynamic"
+	}).then((fresh) => {
+		const merged = {
+			...previous,
+			foreground: fresh.foreground ?? previous.foreground,
+			background: fresh.background ?? previous.background,
+			cursorColor: fresh.cursorColor ?? previous.cursorColor,
+			palette: fresh.palette ?? previous.palette,
+			appearance: fresh.appearance ?? previous.appearance,
+			systemAppearance: fresh.systemAppearance ?? previous.systemAppearance,
+			textAreaPixels: fresh.textAreaPixels ?? previous.textAreaPixels,
+			cellPixels: fresh.cellPixels ?? previous.cellPixels
+		};
+		queryResults.set(stdout, merged);
+		queryPromises.set(stdout, Promise.resolve(merged));
+		refreshPromises.delete(stdout);
+		return merged;
+	});
+	refreshPromises.set(stdout, promise);
+	return promise;
+};
+/**
+Merges an async query result into a synchronous capabilities snapshot,
+producing the complete picture. The query is authoritative where it answered:
+a terminal that confirms truecolor via XTGETTCAP upgrades the sniffed color
+level.
+*/
+const applyTerminalQuery = (capabilities, query) => ({
+	...capabilities,
+	size: {
+		...capabilities.size,
+		pixels: query.textAreaPixels || query.cellPixels ? {
+			textArea: query.textAreaPixels,
+			cell: query.cellPixels
+		} : void 0
+	},
+	terminal: {
+		...capabilities.terminal,
+		name: query.terminal?.name ?? capabilities.terminal.name,
+		version: query.terminal?.version ?? capabilities.terminal.version
+	},
+	color: query.trueColor ? {
+		level: 3,
+		depth: 24,
+		trueColor: true
+	} : capabilities.color,
+	theme: {
+		appearance: query.appearance ?? capabilities.theme.appearance,
+		systemAppearance: query.systemAppearance,
+		foreground: query.foreground,
+		background: query.background,
+		cursor: query.cursorColor,
+		palette: query.palette
+	},
+	supports: {
+		...capabilities.supports,
+		color: capabilities.supports.color || query.trueColor,
+		kittyKeyboard: query.kittyKeyboard,
+		kittyGraphics: query.kittyGraphics,
+		sixel: query.sixel,
+		focusEvents: query.focusEvents,
+		sgrMouse: query.sgrMouse,
+		sgrPixelMouse: query.sgrPixelMouse,
+		bracketedPaste: query.bracketedPaste,
+		synchronizedOutput: query.synchronizedOutput,
+		graphemeClustering: query.graphemeClustering,
+		colorSchemeUpdates: query.colorSchemeUpdates,
+		inBandResize: query.inBandResize
+	}
+});
+//#endregion
+//#region src/stream.ts
+const isRawModeStream = (stdin) => {
+	return isTty(stdin) && "setRawMode" in stdin && typeof stdin.setRawMode === "function";
+};
+const getRawModeStream = (stdin) => {
+	if (!isRawModeStream(stdin)) return;
+	return stdin;
+};
+//#endregion
+//#region src/capabilities/store.ts
+const integrations = /* @__PURE__ */ new WeakMap();
+const reportingUpdaters = /* @__PURE__ */ new WeakMap();
+const registerTerminalIntegration = (stdout, integration) => {
+	integrations.set(stdout, integration);
+	reportingUpdaters.get(stdout)?.();
+	return () => {
+		if (integrations.get(stdout) === integration) {
+			integrations.delete(stdout);
+			reportingUpdaters.get(stdout)?.();
+		}
+	};
+};
+const focusInReport = `${CSI}I`;
+const focusOutReport = `${CSI}O`;
+const colorSchemeReport = new RegExp(`^\\[\\?997;(\\d+)n$`);
+const inBandResizeReport = new RegExp(`^\\[48;(\\d+);(\\d+);(\\d+);(\\d+)t$`);
+const reportModes = [
+	[1004, (result) => result.focusEvents],
+	[2031, (result) => result.colorSchemeUpdates],
+	[2048, (result) => result.inBandResize]
+];
+const stores = /* @__PURE__ */ new WeakMap();
+const createStore = (stdin, stdout) => {
+	const listeners = /* @__PURE__ */ new Set();
+	let resizeSubscribers = 0;
+	let focused;
+	let reportedSize;
+	let snapshot;
+	let snapshotQuery;
+	let snapshotColumns;
+	let snapshotRows;
+	let snapshotFocused;
+	let snapshotReportedSize;
+	const current = () => {
+		const query = getTerminalQuery(stdout);
+		const { columns, rows } = stdout;
+		if (!snapshot || query !== snapshotQuery || columns !== snapshotColumns || rows !== snapshotRows || focused !== snapshotFocused || reportedSize !== snapshotReportedSize) {
+			const detected = detectCapabilities({ stdout });
+			const applied = query ? applyTerminalQuery(detected, query) : detected;
+			const sized = reportedSize ? {
+				...applied,
+				size: {
+					...applied.size,
+					...reportedSize,
+					source: "terminal"
+				}
+			} : applied;
+			snapshot = focused === void 0 ? sized : {
+				...sized,
+				focused
+			};
+			snapshotQuery = query;
+			snapshotColumns = columns;
+			snapshotRows = rows;
+			snapshotFocused = focused;
+			snapshotReportedSize = reportedSize;
+		}
+		return snapshot;
+	};
+	let lastNotified;
+	const notify = () => {
+		const capabilities = current();
+		if (capabilities === lastNotified) return;
+		lastNotified = capabilities;
+		for (const listener of listeners) listener(capabilities);
+	};
+	let reportingEnabled = false;
+	let removeExitHandler;
+	const enabledModes = () => {
+		const result = getTerminalQuery(stdout);
+		if (!result) return [];
+		return reportModes.filter(([, supported]) => supported(result)).map(([mode]) => mode);
+	};
+	const writeModes = (suffix) => {
+		const sequence = enabledModes().map((mode) => `${CSI}?${mode}${suffix}`).join("");
+		if (sequence.length > 0) try {
+			stdout.write(sequence);
+		} catch {}
+	};
+	const updateReporting = () => {
+		const integration = integrations.get(stdout);
+		const shouldEnable = listeners.size > 0 && integration !== void 0 && stdout.isTTY === true;
+		if (shouldEnable && !reportingEnabled && enabledModes().length > 0) {
+			reportingEnabled = true;
+			integration?.setReportFeed?.(true);
+			writeModes("h");
+			removeExitHandler = signalExit(() => {
+				writeModes("l");
+			});
+		} else if (!shouldEnable && reportingEnabled) {
+			reportingEnabled = false;
+			writeModes("l");
+			integration?.setReportFeed?.(false);
+			removeExitHandler?.();
+			removeExitHandler = void 0;
+			reportedSize = void 0;
+		}
+	};
+	reportingUpdaters.set(stdout, updateReporting);
+	const ingest = (sequence) => {
+		if (sequence === focusInReport || sequence === focusOutReport) {
+			focused = sequence === focusInReport;
+			notify();
+			return true;
+		}
+		const colorScheme = sequence.match(colorSchemeReport);
+		if (colorScheme) {
+			const reported = colorScheme[1] === "1" ? "dark" : colorScheme[1] === "2" ? "light" : void 0;
+			if (reported) {
+				const cached = getTerminalQuery(stdout);
+				patchTerminalQuery(stdout, {
+					systemAppearance: reported,
+					...cached?.background === void 0 ? { appearance: reported } : {}
+				});
+				notify();
+				if (integrations.has(stdout)) query().catch(() => {});
+			}
+			return true;
+		}
+		const resize = sequence.match(inBandResizeReport);
+		if (resize) {
+			const [, rows, columns, pixelHeight, pixelWidth] = resize.map(Number);
+			if (columns && rows) {
+				reportedSize = {
+					columns,
+					rows
+				};
+				patchTerminalQuery(stdout, {
+					textAreaPixels: pixelWidth && pixelHeight ? {
+						width: pixelWidth,
+						height: pixelHeight
+					} : void 0,
+					cellPixels: pixelWidth && pixelHeight ? {
+						width: Math.round(pixelWidth / columns),
+						height: Math.round(pixelHeight / rows)
+					} : void 0
+				});
+			}
+			notify();
+			return true;
+		}
+		return false;
+	};
+	const runStandaloneQuery = async () => {
+		if (!stdout.isTTY || !stdin.isTTY) return;
+		const wasRaw = stdin.isRaw ?? false;
+		if (!wasRaw) stdin.setRawMode?.(true);
+		try {
+			await (getTerminalQuery(stdout) !== void 0 ? refreshTerminalQuery(stdin, stdout) : ensureTerminalQuery(stdin, stdout));
+		} finally {
+			if (!wasRaw) stdin.setRawMode?.(false);
+		}
+	};
+	const query = async () => {
+		const integration = integrations.get(stdout);
+		if (integration) await integration.runQuery({ refresh: getTerminalQuery(stdout) !== void 0 });
+		else await runStandaloneQuery();
+		notify();
+		updateReporting();
+		return current();
+	};
+	const onResize = () => {
+		notify();
+	};
+	const subscribe = (listener, options = {}) => {
+		const resizes = options.resizes ?? true;
+		if (resizes && resizeSubscribers++ === 0) stdout.on("resize", onResize);
+		listeners.add(listener);
+		updateReporting();
+		let subscribed = true;
+		return () => {
+			if (!subscribed) return;
+			subscribed = false;
+			listeners.delete(listener);
+			if (resizes && --resizeSubscribers === 0) stdout.removeListener("resize", onResize);
+			updateReporting();
+		};
+	};
+	return {
+		get current() {
+			return current();
+		},
+		query,
+		subscribe,
+		ingest
+	};
+};
+/**
+The capabilities store for a stream pair. Stores are cached per stdout, so
+standalone code and Ink components observing the same terminal share one
+snapshot and one set of query answers.
+*/
+const getCapabilities = (stdin = process.stdin, stdout = process.stdout) => {
+	let store = stores.get(stdout);
+	if (!store) {
+		store = createStore(stdin, stdout);
+		stores.set(stdout, store);
+	}
+	return store;
+};
+/**
+The process's own terminal — the store for `process.stdin`/`process.stdout`.
+
+```ts
+import { capabilities } from "@alchemy.run/sigil/capabilities";
+
+capabilities.current.supports.hyperlinks;
+const fresh = await capabilities.query();
+const unsubscribe = capabilities.subscribe((caps) => {
+console.log(caps.size, caps.theme.appearance);
+});
+```
+*/
+const capabilities = getCapabilities();
+//#endregion
+//#region src/capabilities/color-policy.ts
+function resolveColorProfile(detectedLevel, policy = "auto") {
+	return policy === "auto" ? colorProfileFromLevel(detectedLevel) : policy;
+}
+function colorState(capabilities, policy = "auto") {
+	const detected = colorProfileFromLevel(capabilities.color.level);
+	return {
+		detected,
+		policy,
+		effective: policy === "auto" ? detected : policy
+	};
+}
+//#endregion
+export { registerTerminalIntegration as a, ensureTerminalQuery as c, isTerminalQueryResponse as d, queryTerminal as f, getCapabilities as i, getTerminalQuery as l, resolveColorProfile as n, getRawModeStream as o, refreshTerminalQuery as p, capabilities as r, applyTerminalQuery as s, colorState as t, getTerminalQueryPromise as u };

package/dist/color-policy-CCxuHIdD.d.ts

@@ -0,0 +1,22 @@
+import { i as ColorSupportLevel } from "./detect-Db6GbKOm.js";
+import { t as ColorProfile } from "./color-profile-CyeHnG1T.js";
+//#region src/capabilities/color-policy.d.ts
+/** A user-selected output policy. `auto` follows the target stream. */
+type ColorPolicy = "auto" | ColorProfile;
+/** The three distinct inputs and result of terminal color negotiation. */
+type ColorState = {
+  /** The stream/terminal fact after environment and query detection. */
+  readonly detected: ColorProfile;
+  /** The application's policy for this render instance. */
+  readonly policy: ColorPolicy;
+  /** The profile the serializer must actually emit. */
+  readonly effective: ColorProfile;
+};
+declare function resolveColorProfile(detectedLevel: ColorSupportLevel, policy?: ColorPolicy): ColorProfile;
+declare function colorState(capabilities: {
+  readonly color: {
+    readonly level: ColorSupportLevel;
+  };
+}, policy?: ColorPolicy): ColorState;
+//#endregion
+export { resolveColorProfile as i, ColorState as n, colorState as r, ColorPolicy as t };

package/dist/color-profile-CyeHnG1T.d.ts

@@ -0,0 +1,97 @@
+import { i as ColorSupportLevel } from "./detect-Db6GbKOm.js";
+//#region src/screen/cell.d.ts
+/**
+A terminal color before it is converted to an output profile.
+*/
+type Color = RgbColor | IndexedColor;
+type RgbColor = {
+  readonly model: "rgb";
+  readonly red: number;
+  readonly green: number;
+  readonly blue: number;
+  readonly alpha: number;
+};
+type IndexedColor = {
+  readonly model: "indexed";
+  readonly index: number;
+  /** Preserve an explicit palette encoding when compatibility requires it. */
+  readonly encoding?: "ansi16" | "ansi256";
+};
+/**
+Bit flags for terminal text attributes. Multiple attributes may be combined.
+*/
+declare const cellAttributes: {
+  readonly none: 0;
+  readonly bold: number;
+  readonly faint: number;
+  readonly italic: number;
+  readonly blink: number;
+  readonly rapidBlink: number;
+  readonly inverse: number;
+  readonly hidden: number;
+  readonly strikethrough: number;
+};
+type UnderlineStyle = "none" | "single" | "double" | "curly" | "dotted" | "dashed";
+type CellStyle = {
+  readonly foreground?: Color;
+  readonly background?: Color;
+  readonly underlineColor?: Color;
+  readonly underline: UnderlineStyle;
+  readonly attributes: number;
+};
+type Hyperlink = {
+  readonly url: string;
+  readonly parameters?: string;
+};
+type CellContent = {
+  readonly grapheme: string;
+  readonly width: number;
+};
+/**
+A compositing operation for one screen position.
+
+An absent field is transparent and preserves the destination channel. `null`
+explicitly resets a color or hyperlink to the terminal default. Supplying
+`content` paints a grapheme; `{grapheme: " ", width: 1}` is therefore an
+explicit blank, while an absent patch paints nothing at all.
+*/
+type CellPatch = {
+  readonly content?: CellContent;
+  readonly foreground?: Color | null;
+  readonly background?: Color | null;
+  readonly underlineColor?: Color | null;
+  readonly underline?: UnderlineStyle;
+  readonly attributes?: number;
+  readonly hyperlink?: Hyperlink | null;
+};
+/**
+One grapheme cluster in a terminal screen. A width of zero is reserved for the
+continuation columns of a wide grapheme and is created only by `Screen`.
+*/
+type Cell = {
+  readonly grapheme: string;
+  readonly width: number;
+  readonly style: CellStyle;
+  readonly hyperlink?: Hyperlink;
+  /** Composition intent consumed when this cell is drawn over another surface. */
+  readonly reset?: {
+    readonly foreground?: boolean;
+    readonly background?: boolean;
+  };
+};
+declare const emptyCellStyle: CellStyle;
+declare const emptyCell: Cell;
+declare const createCell: (grapheme: string, width: number, style?: CellStyle, hyperlink?: Hyperlink, reset?: Cell["reset"]) => Cell;
+declare const cellsEqual: (left: Cell | undefined, right: Cell | undefined) => boolean;
+//#endregion
+//#region src/screen/color-profile.d.ts
+/** The color model emitted by a terminal serializer. */
+type ColorProfile = "none" | "ansi16" | "ansi256" | "truecolor";
+declare function colorProfileFromLevel(level: ColorSupportLevel): ColorProfile;
+/**
+Quantizes a semantic color for an output profile. `undefined` means the
+terminal default and is also the result for the no-color profile.
+*/
+declare function quantizeColor(color: Color | undefined, profile: ColorProfile): Color | undefined;
+//#endregion
+export { emptyCellStyle as _, CellContent as a, Color as c, RgbColor as d, UnderlineStyle as f, emptyCell as g, createCell as h, Cell as i, Hyperlink as l, cellsEqual as m, colorProfileFromLevel as n, CellPatch as o, cellAttributes as p, quantizeColor as r, CellStyle as s, ColorProfile as t, IndexedColor as u };