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

package/dist/sample-Cqw1bjUL.js

@@ -0,0 +1,445 @@
+import { r as parseSemanticColor } from "./semantic-text-style-DIMzC7xt.js";
+//#region src/color/paint.ts
+const rgb = (red, green, blue, alpha = 255) => ({
+	model: "rgb",
+	red: channel(red),
+	green: channel(green),
+	blue: channel(blue),
+	alpha: channel(alpha)
+});
+const ansi = (index) => ({
+	model: "indexed",
+	index: Math.max(0, Math.min(15, Math.round(index))),
+	encoding: "ansi16"
+});
+const ansi256 = (index) => ({
+	model: "indexed",
+	index: Math.max(0, Math.min(255, Math.round(index))),
+	encoding: "ansi256"
+});
+const namedIndexes = {
+	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 named = (color) => ansi(namedIndexes[color]);
+const adaptive = (light, dark) => ({
+	type: "adaptive-color",
+	light,
+	dark
+});
+const perProfile = (colors, fallback) => ({
+	type: "profile-color",
+	colors,
+	fallback
+});
+const linearGradient = (stops, options = {}) => {
+	if (stops.length < 2) throw new Error("A linear gradient requires at least two color stops");
+	return {
+		type: "linear-gradient",
+		stops: normalizeStops(stops.map((stop) => isGradientStop(stop) ? stop : { color: stop })),
+		angle: options.angle ?? 0,
+		space: options.space ?? "oklab"
+	};
+};
+const perimeterGradient = (stops, options = {}) => {
+	if (stops.length < 2) throw new Error("A perimeter gradient requires at least two color stops");
+	return {
+		type: "perimeter-gradient",
+		stops: normalizeStops(stops.map((color) => ({ color }))),
+		offset: Math.round(options.offset ?? 0),
+		space: options.space ?? "lab"
+	};
+};
+function normalizeStops(stops) {
+	const output = stops.map((stop) => ({ ...stop }));
+	output[0] = {
+		...output[0],
+		offset: output[0].offset ?? 0
+	};
+	output[output.length - 1] = {
+		...output.at(-1),
+		offset: output.at(-1).offset ?? 1
+	};
+	let anchor = 0;
+	while (anchor < output.length - 1) {
+		let next = anchor + 1;
+		while (next < output.length && output[next].offset === void 0) next++;
+		const start = output[anchor].offset;
+		const end = output[next].offset;
+		for (let index = anchor + 1; index < next; index++) output[index] = {
+			...output[index],
+			offset: start + (end - start) * (index - anchor) / (next - anchor)
+		};
+		anchor = next;
+	}
+	return output.map((stop) => ({
+		...stop,
+		offset: Math.max(0, Math.min(1, stop.offset))
+	}));
+}
+function isGradientStop(value) {
+	return typeof value === "object" && value !== null && "color" in value;
+}
+function channel(value) {
+	return Math.max(0, Math.min(255, Math.round(value)));
+}
+const canonicalAnsiPalette = [
+	[
+		0,
+		0,
+		0
+	],
+	[
+		205,
+		0,
+		0
+	],
+	[
+		0,
+		205,
+		0
+	],
+	[
+		205,
+		205,
+		0
+	],
+	[
+		0,
+		0,
+		238
+	],
+	[
+		205,
+		0,
+		205
+	],
+	[
+		0,
+		205,
+		205
+	],
+	[
+		229,
+		229,
+		229
+	],
+	[
+		127,
+		127,
+		127
+	],
+	[
+		255,
+		0,
+		0
+	],
+	[
+		0,
+		255,
+		0
+	],
+	[
+		255,
+		255,
+		0
+	],
+	[
+		92,
+		92,
+		255
+	],
+	[
+		255,
+		0,
+		255
+	],
+	[
+		0,
+		255,
+		255
+	],
+	[
+		255,
+		255,
+		255
+	]
+].map(([red, green, blue]) => ({
+	model: "rgb",
+	red,
+	green,
+	blue,
+	alpha: 255
+}));
+function colorToRgb(color, palette) {
+	if (color.model === "rgb") return color;
+	const custom = color.index < 16 ? palette?.[color.index] : void 0;
+	if (custom) return {
+		model: "rgb",
+		red: custom.r,
+		green: custom.g,
+		blue: custom.b,
+		alpha: 255
+	};
+	if (color.index < 16) return canonicalAnsiPalette[color.index];
+	if (color.index >= 232) {
+		const value = 8 + (color.index - 232) * 10;
+		return {
+			model: "rgb",
+			red: value,
+			green: value,
+			blue: value,
+			alpha: 255
+		};
+	}
+	const index = color.index - 16;
+	const levels = [
+		0,
+		95,
+		135,
+		175,
+		215,
+		255
+	];
+	return {
+		model: "rgb",
+		red: levels[Math.floor(index / 36)],
+		green: levels[Math.floor(index % 36 / 6)],
+		blue: levels[index % 6],
+		alpha: 255
+	};
+}
+//#endregion
+//#region src/color/sample.ts
+function samplePaint(paint, x, y, bounds, context = {}) {
+	const resolved = resolveConditional(paint, context);
+	if (resolved && typeof resolved === "object" && "type" in resolved) {
+		if (resolved.type === "perimeter-gradient") return samplePerimeterGradient(resolved, x, y, bounds, context);
+	}
+	if (isLinearGradient(resolved)) return sampleGradient(resolved, x, y, bounds, context);
+	return resolveColor(resolved);
+}
+function blend(source, destination, palette) {
+	const foreground = colorToRgb(source, palette);
+	if (foreground.alpha >= 255) return foreground;
+	const background = colorToRgb(destination, palette);
+	const alpha = foreground.alpha / 255;
+	return rgb(foreground.red * alpha + background.red * (1 - alpha), foreground.green * alpha + background.green * (1 - alpha), foreground.blue * alpha + background.blue * (1 - alpha));
+}
+/** Progressively moves a color toward white in perceptual OKLab space. */
+function lighten(color, amount, palette) {
+	return interpolateColor(color, rgb(255, 255, 255), amount, "oklab", palette);
+}
+/** Progressively moves a color toward black in perceptual OKLab space. */
+function darken(color, amount, palette) {
+	return interpolateColor(color, rgb(0, 0, 0), amount, "oklab", palette);
+}
+function sampleGradient(gradient, x, y, bounds, context) {
+	const radians = gradient.angle * Math.PI / 180;
+	const dx = Math.cos(radians);
+	const dy = Math.sin(radians);
+	const width = Math.max(1, bounds.width - 1);
+	const height = Math.max(1, bounds.height - 1);
+	const projections = [
+		0,
+		width * dx,
+		height * dy,
+		width * dx + height * dy
+	];
+	const minimum = Math.min(...projections);
+	const maximum = Math.max(...projections);
+	const projection = (x - bounds.x) * dx + (y - bounds.y) * dy;
+	const position = maximum === minimum ? 0 : (projection - minimum) / (maximum - minimum);
+	return sampleStops(gradient.stops, position, gradient.space, x, y, bounds, context);
+}
+function samplePerimeterGradient(gradient, x, y, bounds, context) {
+	const width = Math.max(1, bounds.width);
+	const height = Math.max(1, bounds.height);
+	const steps = width === 1 || height === 1 ? Math.max(width, height) : 2 * width + 2 * height - 4;
+	if (steps <= 1) return samplePaint(gradient.stops[0].color, x, y, bounds, context);
+	const left = bounds.x;
+	const top = bounds.y;
+	const right = left + width - 1;
+	const bottom = top + height - 1;
+	let index;
+	if (height === 1) index = x - left;
+	else if (width === 1) index = y - top;
+	else if (y <= top) index = Math.max(0, Math.min(width - 1, x - left));
+	else if (x >= right) index = width + Math.max(0, Math.min(height - 2, y - top - 1));
+	else if (y >= bottom) index = width + height - 2 + Math.max(0, Math.min(width - 1, right - x));
+	else index = 2 * width + height - 2 + Math.max(0, Math.min(height - 2, bottom - y - 1));
+	index = modulo(index - gradient.offset, steps);
+	const position = blendPosition(index, steps, gradient.stops.length);
+	return sampleStops(gradient.stops, position, gradient.space, x, y, bounds, context);
+}
+/** Matches Lip Gloss Blend1D's even, discrete distribution of stops. */
+function blendPosition(index, steps, stopCount) {
+	if (steps <= stopCount) return index / Math.max(1, stopCount - 1);
+	const segments = stopCount - 1;
+	const baseSize = Math.floor(steps / segments);
+	const remainder = steps % segments;
+	let start = 0;
+	for (let segment = 0; segment < segments; segment++) {
+		const size = baseSize + (segment < remainder ? 1 : 0);
+		if (index < start + size) {
+			const local = size <= 1 ? 0 : (index - start) / (size - 1);
+			return (segment + local) / segments;
+		}
+		start += size;
+	}
+	return 1;
+}
+function sampleStops(stops, position, space, x, y, bounds, context) {
+	let right = 1;
+	while (right < stops.length - 1 && position > stops[right].offset) right++;
+	const start = stops[right - 1];
+	const end = stops[right];
+	const span = end.offset - start.offset;
+	const amount = span === 0 ? 0 : Math.max(0, Math.min(1, (position - start.offset) / span));
+	const startColor = samplePaint(start.color, x, y, bounds, context);
+	const endColor = samplePaint(end.color, x, y, bounds, context);
+	if (!startColor || !endColor) return startColor ?? endColor;
+	return interpolateColor(startColor, endColor, amount, space, context.palette);
+}
+function interpolateColor(from, to, amount, space = "oklab", palette) {
+	const a = colorToRgb(from, palette);
+	const b = colorToRgb(to, palette);
+	const t = Math.max(0, Math.min(1, amount));
+	if (space === "rgb") return rgb(mix(a.red, b.red, t), mix(a.green, b.green, t), mix(a.blue, b.blue, t), mix(a.alpha, b.alpha, t));
+	if (space === "hsv") {
+		const ah = toHsv(a), bh = toHsv(b);
+		let delta = bh[0] - ah[0];
+		if (delta > 180) delta -= 360;
+		if (delta < -180) delta += 360;
+		return fromHsv(ah[0] + delta * t, mix(ah[1], bh[1], t), mix(ah[2], bh[2], t), mix(a.alpha, b.alpha, t));
+	}
+	if (space === "lab") {
+		const al = toLab(a), bl = toLab(b);
+		return fromLab(mix(al[0], bl[0], t), mix(al[1], bl[1], t), mix(al[2], bl[2], t), mix(a.alpha, b.alpha, t));
+	}
+	const al = toOklab(a), bl = toOklab(b);
+	return fromOklab(mix(al[0], bl[0], t), mix(al[1], bl[1], t), mix(al[2], bl[2], t), mix(a.alpha, b.alpha, t));
+}
+const D65 = [
+	.95047,
+	1,
+	1.08883
+];
+function labCurve(value) {
+	return value > (6 / 29) ** 3 ? Math.cbrt(value) : value / 3 * (29 / 6) ** 2 + 4 / 29;
+}
+function inverseLabCurve(value) {
+	return value > 6 / 29 ? value ** 3 : 3 * (6 / 29) ** 2 * (value - 4 / 29);
+}
+function toLab(color) {
+	const r = linear(color.red), g = linear(color.green), b = linear(color.blue);
+	const x = .4123907992659595 * r + .357584339383878 * g + .1804807884018343 * b;
+	const y = .2126390058715104 * r + .7151686787677559 * g + .0721923153607337 * b;
+	const z = .0193308187155919 * r + .119194779794626 * g + .9505321522496606 * b;
+	const fy = labCurve(y / D65[1]);
+	return [
+		1.16 * fy - .16,
+		5 * (labCurve(x / D65[0]) - fy),
+		2 * (fy - labCurve(z / D65[2]))
+	];
+}
+function fromLab(l, a, b, alpha) {
+	const center = (l + .16) / 1.16;
+	const x = D65[0] * inverseLabCurve(center + a / 5);
+	const y = D65[1] * inverseLabCurve(center);
+	const z = D65[2] * inverseLabCurve(center - b / 2);
+	return rgb(colorfulChannel(3.240969941904521 * x - 1.5373831775700935 * y - .4986107602930033 * z), colorfulChannel(-.9692436362808798 * x + 1.8759675015077206 * y + .0415550574071756 * z), colorfulChannel(.0556300796969936 * x - .2039769588889766 * y + 1.0569715142428786 * z), alpha);
+}
+const mix = (a, b, t) => a + (b - a) * t;
+const linear = (value) => {
+	const x = value / 255;
+	return x <= .04045 ? x / 12.92 : ((x + .055) / 1.055) ** 2.4;
+};
+const gamma = (value) => 255 * (value <= .0031308 ? 12.92 * value : 1.055 * value ** (1 / 2.4) - .055);
+const colorfulChannel = (value) => {
+	const encoded = value <= .0031308 ? 12.92 * value : 1.055 * value ** (1 / 2.4) - .055;
+	return Math.floor(Math.round(Math.max(0, Math.min(1, encoded)) * 65535) / 256);
+};
+function toOklab(c) {
+	const r = linear(c.red), g = linear(c.green), b = linear(c.blue);
+	const l = Math.cbrt(.4122214708 * r + .5363325363 * g + .0514459929 * b), m = Math.cbrt(.2119034982 * r + .6806995451 * g + .1073969566 * b), s = Math.cbrt(.0883024619 * r + .2817188376 * g + .6299787005 * b);
+	return [
+		.2104542553 * l + .793617785 * m - .0040720468 * s,
+		1.9779984951 * l - 2.428592205 * m + .4505937099 * s,
+		.0259040371 * l + .7827717662 * m - .808675766 * s
+	];
+}
+function fromOklab(L, a, b, alpha) {
+	const l = (L + .3963377774 * a + .2158037573 * b) ** 3, m = (L - .1055613458 * a - .0638541728 * b) ** 3, s = (L - .0894841775 * a - 1.291485548 * b) ** 3;
+	return rgb(gamma(4.0767416621 * l - 3.3077115913 * m + .2309699292 * s), gamma(-1.2684380046 * l + 2.6097574011 * m - .3413193965 * s), gamma(-.0041960863 * l - .7034186147 * m + 1.707614701 * s), alpha);
+}
+function toHsv(c) {
+	const r = c.red / 255, g = c.green / 255, b = c.blue / 255, max = Math.max(r, g, b), d = max - Math.min(r, g, b);
+	let h = 0;
+	if (d) h = max === r ? 60 * ((g - b) / d % 6) : max === g ? 60 * ((b - r) / d + 2) : 60 * ((r - g) / d + 4);
+	return [
+		(h + 360) % 360,
+		max === 0 ? 0 : d / max,
+		max
+	];
+}
+function fromHsv(h, s, v, alpha) {
+	const c = v * s, x = c * (1 - Math.abs(h / 60 % 2 - 1)), m = v - c;
+	const [r, g, b] = h < 60 ? [
+		c,
+		x,
+		0
+	] : h < 120 ? [
+		x,
+		c,
+		0
+	] : h < 180 ? [
+		0,
+		c,
+		x
+	] : h < 240 ? [
+		0,
+		x,
+		c
+	] : h < 300 ? [
+		x,
+		0,
+		c
+	] : [
+		c,
+		0,
+		x
+	];
+	return rgb((r + m) * 255, (g + m) * 255, (b + m) * 255, alpha);
+}
+function resolveConditional(paint, context) {
+	if (typeof paint !== "object" || paint === null || "model" in paint) return paint;
+	if (paint.type === "adaptive-color") return resolveConditional(context.appearance === "light" ? paint.light : paint.dark, context);
+	if (paint.type === "profile-color") return resolveConditional((context.profile && paint.colors[context.profile]) ?? paint.fallback, context);
+	return paint;
+}
+function resolveColor(value) {
+	return typeof value === "string" ? parseSemanticColor(value) : typeof value === "object" && value !== null && "model" in value ? value : void 0;
+}
+function isLinearGradient(value) {
+	return typeof value === "object" && value !== null && "type" in value && value.type === "linear-gradient";
+}
+const modulo = (value, divisor) => (value % divisor + divisor) % divisor;
+//#endregion
+export { samplePaint as a, adaptive as c, linearGradient as d, named as f, rgb as h, lighten as i, ansi as l, perimeterGradient as m, darken as n, canonicalAnsiPalette as o, perProfile as p, interpolateColor as r, colorToRgb as s, blend as t, ansi256 as u };

package/dist/screen-BOSLQ8fF.d.ts

@@ -0,0 +1,49 @@
+import { i as Cell, o as CellPatch } from "./color-profile-u0Nhe9Nv.js";
+import { n as Rect } from "./geometry-BxXOzJgo.js";
+//#region src/screen/screen.d.ts
+type Line = readonly Cell[];
+/** A half-open range of changed columns in one row. */
+type DirtySpan = {
+  readonly y: number;
+  readonly start: number;
+  readonly end: number;
+};
+/**
+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.
+*/
+declare class Screen {
+  #private;
+  constructor(width: number, height: number);
+  get width(): number;
+  /**
+    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: number): number;
+  get height(): number;
+  bounds(): Rect;
+  cellAt(x: number, y: number): Cell | undefined;
+  /** Whether a drawable explicitly touched this position. */
+  isPainted(x: number, y: number): boolean;
+  setCell(x: number, y: number, cell: Cell, options?: {
+    overflow?: boolean;
+  }): void;
+  /**
+    Composes independent cell channels over the existing cell. An undefined
+    patch is transparent; an explicit space in `content` paints a blank.
+    */
+  composeCell(x: number, y: number, patch: CellPatch | undefined, options?: {
+    overflow?: boolean;
+  }): void;
+  /** Composes a patch throughout a rectangle, clipped to this screen. */
+  fill(bounds: Rect, patch: CellPatch | undefined): void;
+  /** Resizes while preserving complete graphemes in the shared top-left area. */
+  resize(width: number, height: number): void;
+  clear(): void;
+  toRows(): readonly Line[];
+  dirtySpans(): readonly DirtySpan[];
+  takeDirtySpans(): readonly DirtySpan[];
+}
+//#endregion
+export { Screen as n, Line as t };