@alchemy.run/sigil 0.0.0-alpha.4 → 0.0.0-alpha.6

package/dist/screen-CiPytswf.js

@@ -0,0 +1,342 @@
+import { d as tokenize, l as styledCharsFromTokens } from "./tokenize-AjqbvtiT.js";
+import { t as stringWidth } from "./string-width-CijQwpIk.js";
+import { i as emptyCell, r as createCell, t as cellAttributes } from "./cell-_ZVhbfl0.js";
+import { t as blend } from "./sample-Cqw1bjUL.js";
+import "./color-profile-DHhQHY55.js";
+import "./serialize-BTkAZgw1.js";
+//#region src/screen/ansi.ts
+const ESC = "\x1B";
+const BEL = "\x07";
+const C1_ST = "œ";
+const LINK_PREFIX = `${ESC}]8;`;
+/** Converts the renderer's canonical ANSI state into backend-neutral cells. */
+function cellsFromAnsi(text) {
+	return styledCharsFromTokens(tokenize(text)).map((character) => cellFromStyledChar(character));
+}
+function cellFromStyledChar(character, width = stringWidth(character.value)) {
+	const parsed = parseStyles(character.styles);
+	const style = {
+		...parsed.foreground ? { foreground: parsed.foreground } : {},
+		...parsed.background ? { background: parsed.background } : {},
+		...parsed.underlineColor ? { underlineColor: parsed.underlineColor } : {},
+		underline: parsed.underline,
+		attributes: parsed.attributes
+	};
+	return createCell(character.value, Math.max(1, width), style, parsed.hyperlink);
+}
+function parseStyles(codes) {
+	let foreground;
+	let background;
+	let underlineColor;
+	let underline = "none";
+	let attributes = cellAttributes.none;
+	let hyperlink;
+	for (const { code } of codes) {
+		if (code.startsWith(LINK_PREFIX)) {
+			hyperlink = parseHyperlink(code);
+			continue;
+		}
+		if (!code.startsWith(`${ESC}[`) || !code.endsWith("m")) continue;
+		const parameters = code.slice(2, -1);
+		const primary = Number.parseInt(parameters, 10);
+		if (primary >= 30 && primary <= 37) foreground = {
+			model: "indexed",
+			index: primary - 30,
+			encoding: "ansi16"
+		};
+		else if (primary >= 90 && primary <= 97) foreground = {
+			model: "indexed",
+			index: primary - 90 + 8,
+			encoding: "ansi16"
+		};
+		else if (primary >= 40 && primary <= 47) background = {
+			model: "indexed",
+			index: primary - 40,
+			encoding: "ansi16"
+		};
+		else if (primary >= 100 && primary <= 107) background = {
+			model: "indexed",
+			index: primary - 100 + 8,
+			encoding: "ansi16"
+		};
+		else if (primary === 38) foreground = parseExtendedColor(parameters);
+		else if (primary === 48) background = parseExtendedColor(parameters);
+		else if (primary === 58) underlineColor = parseExtendedColor(parameters);
+		else if (primary === 1) attributes += cellAttributes.bold;
+		else if (primary === 2) attributes += cellAttributes.faint;
+		else if (primary === 3) attributes += cellAttributes.italic;
+		else if (primary === 5) attributes += cellAttributes.blink;
+		else if (primary === 6) attributes += cellAttributes.rapidBlink;
+		else if (primary === 7) attributes += cellAttributes.inverse;
+		else if (primary === 8) attributes += cellAttributes.hidden;
+		else if (primary === 9) attributes += cellAttributes.strikethrough;
+		else if (primary === 4) underline = parseUnderline(parameters);
+	}
+	return {
+		...foreground ? { foreground } : {},
+		...background ? { background } : {},
+		...underlineColor ? { underlineColor } : {},
+		underline,
+		attributes,
+		...hyperlink ? { hyperlink } : {}
+	};
+}
+function parseExtendedColor(parameters) {
+	const parts = parameters.split(parameters.includes(":") ? ":" : ";");
+	const model = parts[1];
+	if (model === "5") {
+		const index = Number(parts[2]);
+		return Number.isInteger(index) && index >= 0 && index <= 255 ? {
+			model: "indexed",
+			index,
+			encoding: "ansi256"
+		} : void 0;
+	}
+	if (model !== "2") return;
+	const channels = parts.slice(-3).map(Number);
+	if (channels.length !== 3 || channels.some((channel) => !isByte(channel))) return;
+	return {
+		model: "rgb",
+		red: channels[0],
+		green: channels[1],
+		blue: channels[2],
+		alpha: 255
+	};
+}
+function parseUnderline(parameters) {
+	return {
+		0: "none",
+		1: "single",
+		2: "double",
+		3: "curly",
+		4: "dotted",
+		5: "dashed"
+	}[parameters.includes(":") ? Number(parameters.split(":").at(-1)) : 1] ?? "single";
+}
+function parseHyperlink(code) {
+	let body = code.slice(LINK_PREFIX.length);
+	if (body.endsWith(`${ESC}\\`)) body = body.slice(0, -2);
+	else if (body.endsWith(BEL) || body.endsWith(C1_ST)) body = body.slice(0, -1);
+	const separator = body.indexOf(";");
+	if (separator < 0) return;
+	const parameters = body.slice(0, separator);
+	const url = body.slice(separator + 1);
+	return parameters ? {
+		url,
+		parameters
+	} : { url };
+}
+function isByte(value) {
+	return Number.isInteger(value) && value >= 0 && value <= 255;
+}
+//#endregion
+//#region src/screen/screen.ts
+/**
+A mutable two-dimensional terminal cell buffer. Cells themselves are immutable,
+so current and next screens can compare them by value or safely share constants.
+*/
+var Screen = class {
+	#width;
+	#height;
+	#rows;
+	#painted;
+	#dirty;
+	constructor(width, height) {
+		validateDimensions(width, height);
+		this.#width = width;
+		this.#height = height;
+		this.#rows = Array.from({ length: height }, () => Array(width).fill(emptyCell));
+		this.#painted = Array.from({ length: height }, () => Array(width).fill(false));
+		this.#dirty = Array.from({ length: height }, () => width > 0 ? {
+			start: 0,
+			end: width
+		} : void 0);
+	}
+	get width() {
+		return this.#width;
+	}
+	/**
+	The populated length of one row: the nominal width, or more when overflow
+	writes (`textWrap: "none"` content) extended it past the screen's width.
+	*/
+	rowLength(y) {
+		return Math.max(this.#width, this.#rows[y]?.length ?? 0);
+	}
+	get height() {
+		return this.#height;
+	}
+	bounds() {
+		return {
+			x: 0,
+			y: 0,
+			width: this.width,
+			height: this.height
+		};
+	}
+	cellAt(x, y) {
+		return this.#rows[y]?.[x];
+	}
+	/** Whether a drawable explicitly touched this position. */
+	isPainted(x, y) {
+		return this.#painted[y]?.[x] ?? false;
+	}
+	setCell(x, y, cell, options) {
+		const row = this.#rows[y];
+		const overflow = options?.overflow === true;
+		if (!row || x < 0 || !overflow && x >= this.width) return;
+		if (!Number.isInteger(cell.width) || cell.width < 1) throw new Error("Only leading cells with a positive width may be written");
+		const finalColumn = x + cell.width;
+		if (overflow && finalColumn > row.length) this.#growRow(row, y, finalColumn);
+		const capacity = overflow ? row.length : this.width;
+		const clipped = finalColumn > capacity;
+		const overwriteEnd = Math.min(finalColumn, capacity);
+		for (let column = x; column < overwriteEnd; column++) this.#clearGraphemeAt(row, y, column);
+		if (clipped) {
+			for (let column = x; column < capacity; column++) row[column] = emptyCell;
+			this.#markDirty(y, x, capacity);
+			return;
+		}
+		row[x] = cell;
+		this.#painted[y][x] = true;
+		for (let column = x + 1; column < finalColumn; column++) {
+			row[column] = {
+				grapheme: "",
+				width: 0,
+				style: cell.style,
+				...cell.hyperlink ? { hyperlink: cell.hyperlink } : {}
+			};
+			this.#painted[y][column] = true;
+		}
+		this.#markDirty(y, x, finalColumn);
+	}
+	/**
+	Composes independent cell channels over the existing cell. An undefined
+	patch is transparent; an explicit space in `content` paints a blank.
+	*/
+	composeCell(x, y, patch, options) {
+		if (!patch) return;
+		const row = this.#rows[y];
+		if (!row || x < 0 || options?.overflow !== true && x >= this.width) return;
+		let leadingColumn = x;
+		while (leadingColumn > 0 && row[leadingColumn]?.width === 0) leadingColumn--;
+		const destination = row[leadingColumn] ?? emptyCell;
+		const writeColumn = patch.content ? x : leadingColumn;
+		const style = {
+			...this.#composeColor(destination.style, patch, "foreground"),
+			...this.#composeColor(destination.style, patch, "background"),
+			...this.#composeColor(destination.style, patch, "underlineColor"),
+			underline: patch.underline ?? destination.style.underline,
+			attributes: patch.attributes ?? destination.style.attributes
+		};
+		const content = patch.content ?? destination;
+		const hyperlink = patch.hyperlink === void 0 ? destination.hyperlink : patch.hyperlink ?? void 0;
+		this.setCell(writeColumn, y, createCell(content.grapheme, content.width, style, hyperlink), options);
+	}
+	/** Composes a patch throughout a rectangle, clipped to this screen. */
+	fill(bounds, patch) {
+		if (!patch) return;
+		const startX = Math.max(0, bounds.x);
+		const startY = Math.max(0, bounds.y);
+		const endX = Math.min(this.width, bounds.x + bounds.width);
+		const endY = Math.min(this.height, bounds.y + bounds.height);
+		const step = Math.max(1, patch.content?.width ?? 1);
+		for (let y = startY; y < endY; y++) for (let x = startX; x < endX; x += step) this.composeCell(x, y, patch);
+	}
+	/** Resizes while preserving complete graphemes in the shared top-left area. */
+	resize(width, height) {
+		validateDimensions(width, height);
+		const rows = Array.from({ length: height }, () => Array(width).fill(emptyCell));
+		const painted = Array.from({ length: height }, () => Array(width).fill(false));
+		const sharedHeight = Math.min(height, this.height);
+		for (let y = 0; y < sharedHeight; y++) {
+			const source = this.#rows[y];
+			const destination = rows[y];
+			for (let x = 0; x < Math.min(width, this.width); x++) {
+				const cell = source[x];
+				if (cell.width === 0 || x + cell.width > width) continue;
+				destination[x] = cell;
+				painted[y][x] = this.#painted[y][x];
+				for (let column = x + 1; column < x + cell.width; column++) {
+					destination[column] = source[column];
+					painted[y][column] = this.#painted[y][column];
+				}
+			}
+		}
+		this.#width = width;
+		this.#height = height;
+		this.#rows = rows;
+		this.#painted = painted;
+		this.#dirty = Array.from({ length: height }, () => width > 0 ? {
+			start: 0,
+			end: width
+		} : void 0);
+	}
+	clear() {
+		for (const [y, row] of this.#rows.entries()) {
+			row.fill(emptyCell);
+			this.#painted[y].fill(true);
+			this.#markDirty(y, 0, this.rowLength(y));
+		}
+	}
+	toRows() {
+		return this.#rows;
+	}
+	dirtySpans() {
+		return this.#dirty.flatMap((span, y) => span ? [{
+			y,
+			...span
+		}] : []);
+	}
+	takeDirtySpans() {
+		const spans = this.dirtySpans();
+		this.#dirty.fill(void 0);
+		return spans;
+	}
+	/** Extends a row (and its paint mask) so overflow writes land past `width`. */
+	#growRow(row, y, length) {
+		const painted = this.#painted[y];
+		while (row.length < length) {
+			row.push(emptyCell);
+			painted.push(false);
+		}
+	}
+	#clearGraphemeAt(row, y, x) {
+		const existing = row[x];
+		if (!existing || existing === emptyCell) return;
+		let leadingColumn = x;
+		while (leadingColumn > 0 && row[leadingColumn]?.width === 0) leadingColumn--;
+		const leadingCell = row[leadingColumn];
+		const width = Math.max(1, leadingCell?.width ?? 1);
+		for (let column = leadingColumn; column < Math.min(leadingColumn + width, row.length); column++) {
+			row[column] = emptyCell;
+			this.#painted[y][column] = true;
+		}
+		this.#markDirty(y, leadingColumn, leadingColumn + width);
+	}
+	#composeColor(destination, patch, channel) {
+		const value = patch[channel];
+		if (value === void 0) return destination[channel] ? { [channel]: destination[channel] } : {};
+		if (value === null) return {};
+		const destinationColor = destination[channel];
+		if (value.model === "rgb" && value.alpha < 255 && destinationColor) return { [channel]: blend(value, destinationColor) };
+		return { [channel]: value };
+	}
+	#markDirty(y, start, end) {
+		if (y < 0 || y >= this.height || start >= end) return;
+		const clippedStart = Math.max(0, start);
+		const clippedEnd = Math.min(this.rowLength(y), end);
+		const current = this.#dirty[y];
+		this.#dirty[y] = current ? {
+			start: Math.min(current.start, clippedStart),
+			end: Math.max(current.end, clippedEnd)
+		} : {
+			start: clippedStart,
+			end: clippedEnd
+		};
+	}
+};
+function validateDimensions(width, height) {
+	if (!Number.isInteger(width) || width < 0 || !Number.isInteger(height) || height < 0) throw new Error("Screen dimensions must be non-negative integers");
+}
+//#endregion
+export { cellFromStyledChar as n, cellsFromAnsi as r, Screen as t };

package/dist/screen.d.ts

@@ -0,0 +1,5 @@
+import { _ as emptyCellStyle, a as CellContent, c as Color, d as RgbColor, f as UnderlineStyle, g as emptyCell, h as createCell, i as Cell, l as Hyperlink, m as cellsEqual, n as colorProfileFromLevel, o as CellPatch, p as cellAttributes, r as quantizeColor, s as CellStyle, t as ColorProfile, u as IndexedColor } from "./color-profile-u0Nhe9Nv.js";
+import { n as Rect, t as Point } from "./geometry-BxXOzJgo.js";
+import { a as cellFromStyledChar, i as styledCharFromCell, n as serializeLine, o as cellsFromAnsi, r as serializeScreen, t as SerializeOptions } from "./index-DZ88EXJv.js";
+import { n as Screen, t as Line } from "./screen-BOSLQ8fF.js";
+export { Cell, CellContent, CellPatch, CellStyle, Color, ColorProfile, Hyperlink, IndexedColor, type Line, Point, Rect, RgbColor, Screen, SerializeOptions, UnderlineStyle, cellAttributes, cellFromStyledChar, cellsEqual, cellsFromAnsi, colorProfileFromLevel, createCell, emptyCell, emptyCellStyle, quantizeColor, serializeLine, serializeScreen, styledCharFromCell };

package/dist/screen.js

@@ -0,0 +1,5 @@
+import { a as emptyCellStyle, i as emptyCell, n as cellsEqual, r as createCell, t as cellAttributes } from "./cell-_ZVhbfl0.js";
+import { n as cellFromStyledChar, r as cellsFromAnsi, t as Screen } from "./screen-CiPytswf.js";
+import { n as quantizeColor, t as colorProfileFromLevel } from "./color-profile-DHhQHY55.js";
+import { n as serializeScreen, r as styledCharFromCell, t as serializeLine } from "./serialize-BTkAZgw1.js";
+export { Screen, cellAttributes, cellFromStyledChar, cellsEqual, cellsFromAnsi, colorProfileFromLevel, createCell, emptyCell, emptyCellStyle, quantizeColor, serializeLine, serializeScreen, styledCharFromCell };

package/dist/semantic-text-style-DIMzC7xt.js

@@ -0,0 +1,91 @@
+import { l as hexToRgb } from "./sgr-BhwaWAJB.js";
+import { t as cellAttributes } from "./cell-_ZVhbfl0.js";
+//#region src/semantic-text-style.ts
+const emptySemanticTextStyle = { attributes: cellAttributes.none };
+const namedColors = {
+	black: 0,
+	red: 1,
+	green: 2,
+	yellow: 3,
+	blue: 4,
+	magenta: 5,
+	cyan: 6,
+	white: 7,
+	blackBright: 8,
+	gray: 8,
+	grey: 8,
+	redBright: 9,
+	greenBright: 10,
+	yellowBright: 11,
+	blueBright: 12,
+	magentaBright: 13,
+	cyanBright: 14,
+	whiteBright: 15
+};
+const rgbPattern = /^rgb\(\s?(\d+),\s?(\d+),\s?(\d+)\s?\)$/;
+const ansi256Pattern = /^ansi256\(\s?(\d+)\s?\)$/;
+function parseSemanticColor(value) {
+	if (!value) return;
+	if (typeof value !== "string") return value;
+	const named = namedColors[value];
+	if (named !== void 0) return {
+		model: "indexed",
+		index: named,
+		encoding: "ansi16"
+	};
+	if (value.startsWith("#")) {
+		const [red, green, blue] = hexToRgb(value);
+		return {
+			model: "rgb",
+			red,
+			green,
+			blue,
+			alpha: 255
+		};
+	}
+	const rgb = rgbPattern.exec(value);
+	if (rgb) return {
+		model: "rgb",
+		red: Number(rgb[1]),
+		green: Number(rgb[2]),
+		blue: Number(rgb[3]),
+		alpha: 255
+	};
+	const ansi256 = ansi256Pattern.exec(value);
+	if (ansi256) return {
+		model: "indexed",
+		index: Number(ansi256[1]),
+		encoding: "ansi256"
+	};
+}
+function mergeSemanticTextStyles(parent, child) {
+	if (!child) return parent;
+	const attributes = parent.attributes | child.attributes;
+	const foreground = child.resetForeground ? void 0 : child.foreground ?? parent.foreground;
+	const background = child.resetBackground ? void 0 : child.background ?? parent.background;
+	return {
+		...foreground ? { foreground } : {},
+		...background ? { background } : {},
+		...child.resetForeground ? { resetForeground: true } : {},
+		...child.resetBackground ? { resetBackground: true } : {},
+		...child.underline ?? parent.underline ? { underline: child.underline ?? parent.underline } : {},
+		attributes
+	};
+}
+function semanticTextStyleToCellStyle(style) {
+	const foreground = solidColor(style.foreground);
+	const background = solidColor(style.background);
+	return {
+		...foreground ? { foreground } : {},
+		...background ? { background } : {},
+		underline: style.underline ?? "none",
+		attributes: style.attributes
+	};
+}
+function solidColor(paint) {
+	if (!paint) return void 0;
+	if (typeof paint === "string") return parseSemanticColor(paint);
+	return "model" in paint ? paint : void 0;
+}
+//#endregion
+export { semanticTextStyleToCellStyle as i, mergeSemanticTextStyles as n, parseSemanticColor as r, emptySemanticTextStyle as t };

package/dist/serialize-BTkAZgw1.js

@@ -0,0 +1,79 @@
+import { i as getEndCode, u as styledCharsToString } from "./tokenize-AjqbvtiT.js";
+import { t as cellAttributes } from "./cell-_ZVhbfl0.js";
+import { n as quantizeColor } from "./color-profile-DHhQHY55.js";
+//#region src/screen/serialize.ts
+const ESC = "\x1B";
+const BEL = "\x07";
+/** Serializes one structured cell run with minimal style transitions. */
+function serializeLine(line, options) {
+	const characters = line.map((cell) => styledCharFromCell(cell, options.colorProfile, options.styles ?? true));
+	const output = styledCharsToString(characters);
+	return options.trimEnd === false ? output : output.trimEnd();
+}
+function serializeScreen(screen, options) {
+	return screen.toRows().map((line) => serializeLine(line, options)).join("\n");
+}
+/** Converts a semantic cell to the canonical ANSI compatibility style state. */
+function styledCharFromCell(cell, profile, styles = true) {
+	return {
+		type: "char",
+		value: cell.grapheme,
+		fullWidth: cell.width > 1,
+		styles: styles ? ansiCodesFromCell(cell, profile) : []
+	};
+}
+function ansiCodesFromCell(cell, profile) {
+	const result = [];
+	const { style } = cell;
+	if (cell.hyperlink) result.push(codePair(hyperlinkStart(cell.hyperlink)));
+	addAttribute(result, style.attributes, cellAttributes.inverse, 7);
+	addAttribute(result, style.attributes, cellAttributes.hidden, 8);
+	addAttribute(result, style.attributes, cellAttributes.strikethrough, 9);
+	if (style.underline !== "none") {
+		const variant = {
+			single: "4",
+			double: "4:2",
+			curly: "4:3",
+			dotted: "4:4",
+			dashed: "4:5"
+		}[style.underline];
+		result.push(codePair(`${ESC}[${variant}m`));
+	}
+	addAttribute(result, style.attributes, cellAttributes.italic, 3);
+	addAttribute(result, style.attributes, cellAttributes.bold, 1);
+	addAttribute(result, style.attributes, cellAttributes.rapidBlink, 6);
+	addAttribute(result, style.attributes, cellAttributes.blink, 5);
+	const background = quantizeColor(style.background, profile);
+	if (background) result.push(codePair(colorCode(background, "background")));
+	const foreground = quantizeColor(style.foreground, profile);
+	if (foreground) result.push(codePair(colorCode(foreground, "foreground")));
+	addAttribute(result, style.attributes, cellAttributes.faint, 2);
+	const underlineColor = quantizeColor(style.underlineColor, profile);
+	if (underlineColor) result.push(codePair(colorCode(underlineColor, "underline")));
+	return result;
+}
+function addAttribute(result, attributes, attribute, sgr) {
+	if (Math.floor(attributes / attribute) % 2 === 1) result.push(codePair(`${ESC}[${sgr}m`));
+}
+function colorCode(color, channel) {
+	const prefix = {
+		foreground: 38,
+		background: 48,
+		underline: 58
+	}[channel];
+	if (color.model === "rgb") return `${ESC}[${prefix};2;${color.red};${color.green};${color.blue}m`;
+	if (channel === "underline" || color.index >= 16 || color.encoding === "ansi256") return `${ESC}[${prefix};5;${color.index}m`;
+	const basic = color.index < 8 ? color.index : color.index - 8 + 60;
+	return `${ESC}[${(channel === "background" ? 40 : 30) + basic}m`;
+}
+function hyperlinkStart(hyperlink) {
+	return `${ESC}]8;${hyperlink.parameters ?? ""};${hyperlink.url}${BEL}`;
+}
+function codePair(code) {
+	return {
+		code,
+		endCode: getEndCode(code)
+	};
+}
+//#endregion
+export { serializeScreen as n, styledCharFromCell as r, serializeLine as t };