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

package/dist/color-profile-DHhQHY55.js

@@ -0,0 +1,36 @@
+import { d as rgbToAnsi, f as rgbToAnsi256, t as ansi256ToAnsi } from "./sgr-BhwaWAJB.js";
+//#region src/screen/color-profile.ts
+function colorProfileFromLevel(level) {
+	return [
+		"none",
+		"ansi16",
+		"ansi256",
+		"truecolor"
+	][level];
+}
+/**
+Quantizes a semantic color for an output profile. `undefined` means the
+terminal default and is also the result for the no-color profile.
+*/
+function quantizeColor(color, profile) {
+	if (!color || profile === "none") return;
+	if (profile === "truecolor") return color;
+	if (profile === "ansi256") {
+		if (color.model === "indexed") return color;
+		return {
+			model: "indexed",
+			index: rgbToAnsi256(color.red, color.green, color.blue),
+			encoding: "ansi256"
+		};
+	}
+	return {
+		model: "indexed",
+		index: ansiCodeToPaletteIndex(color.model === "indexed" ? ansi256ToAnsi(color.index) : rgbToAnsi(color.red, color.green, color.blue)),
+		encoding: "ansi16"
+	};
+}
+function ansiCodeToPaletteIndex(code) {
+	return code >= 90 ? code - 90 + 8 : code - 30;
+}
+//#endregion
+export { quantizeColor as n, colorProfileFromLevel as t };

package/dist/color.d.ts

@@ -0,0 +1,21 @@
+import { c as Color, d as RgbColor } from "./color-profile-CyeHnG1T.js";
+import { _ as perimeterGradient, a as LinearGradient, c as PaintContext, d as adaptive, f as ansi, g as perProfile, h as named, i as InterpolationSpace, l as PerimeterGradient, m as linearGradient, n as ColorInput, o as NamedColor, p as ansi256, r as GradientStop, s as Paint, t as AdaptiveColor, u as ProfileColor, v as rgb } from "./paint-Cx-zC_sX.js";
+import { n as Rect } from "./geometry-BxXOzJgo.js";
+//#region src/color/palette.d.ts
+declare const canonicalAnsiPalette: readonly RgbColor[];
+declare function colorToRgb(color: Color, palette?: readonly {
+  r: number;
+  g: number;
+  b: number;
+}[]): RgbColor;
+//#endregion
+//#region src/color/sample.d.ts
+declare function samplePaint(paint: Paint, x: number, y: number, bounds: Rect, context?: PaintContext): Color | undefined;
+declare function blend(source: Color, destination: Color, palette?: PaintContext["palette"]): Color;
+/** Progressively moves a color toward white in perceptual OKLab space. */
+declare function lighten(color: Color, amount: number, palette?: PaintContext["palette"]): RgbColor;
+/** Progressively moves a color toward black in perceptual OKLab space. */
+declare function darken(color: Color, amount: number, palette?: PaintContext["palette"]): RgbColor;
+declare function interpolateColor(from: Color, to: Color, amount: number, space?: InterpolationSpace, palette?: PaintContext["palette"]): RgbColor;
+//#endregion
+export { AdaptiveColor, ColorInput, GradientStop, InterpolationSpace, LinearGradient, NamedColor, Paint, PaintContext, PerimeterGradient, ProfileColor, adaptive, ansi, ansi256, blend, canonicalAnsiPalette, colorToRgb, darken, interpolateColor, lighten, linearGradient, named, perProfile, perimeterGradient, rgb, samplePaint };

package/dist/color.js

@@ -0,0 +1,3 @@
+import { a as samplePaint, c as adaptive, d as linearGradient, f as named, h as rgb, i as lighten, l as ansi, m as perimeterGradient, n as darken, o as canonicalAnsiPalette, p as perProfile, r as interpolateColor, s as colorToRgb, t as blend, u as ansi256 } from "./sample-Cqw1bjUL.js";
+import "./color-CkbalRqK.js";
+export { adaptive, ansi, ansi256, blend, canonicalAnsiPalette, colorToRgb, darken, interpolateColor, lighten, linearGradient, named, perProfile, perimeterGradient, rgb, samplePaint };

package/dist/cursor-position-D2LAkRG0.d.ts

@@ -0,0 +1,7 @@
+//#region src/cursor-position.d.ts
+type CursorPosition = {
+  x: number;
+  y: number;
+};
+//#endregion
+export { CursorPosition as t };

package/dist/detect-B3dL4Q11.js

@@ -0,0 +1,374 @@
+import { n as isMacos, o as isWindows, r as isScreenReader, t as isInCi } from "./env-YVw64yZS.js";
+import { constants, openSync } from "node:fs";
+import { WriteStream } from "node:tty";
+//#region src/signal-exit.ts
+const signals = isWindows ? [
+	"SIGHUP",
+	"SIGINT",
+	"SIGTERM",
+	"SIGBREAK"
+] : [
+	"SIGHUP",
+	"SIGINT",
+	"SIGTERM",
+	"SIGQUIT",
+	"SIGUSR2"
+];
+const registrations = /* @__PURE__ */ new Set();
+const signalListeners = /* @__PURE__ */ new Map();
+let loaded = false;
+let emitted = false;
+const emitExit = (code, signal) => {
+	if (emitted) return;
+	emitted = true;
+	const ordered = [...registrations].toSorted((a, b) => Number(a.alwaysLast) - Number(b.alwaysLast));
+	for (const registration of ordered) registration.handler(code, signal);
+};
+const onExitEvent = (code) => {
+	emitExit(code, null);
+};
+const unload = () => {
+	if (!loaded) return;
+	loaded = false;
+	process.off("exit", onExitEvent);
+	for (const [signal, listener] of signalListeners) process.off(signal, listener);
+	signalListeners.clear();
+};
+const load = () => {
+	if (loaded) return;
+	loaded = true;
+	process.on("exit", onExitEvent);
+	for (const signal of signals) {
+		const listener = () => {
+			if (process.listenerCount(signal) === 1) {
+				unload();
+				emitExit(null, signal);
+				process.kill(process.pid, signal);
+			}
+		};
+		try {
+			process.on(signal, listener);
+			signalListeners.set(signal, listener);
+		} catch {}
+	}
+};
+const signalExit = (handler, options = {}) => {
+	const registration = {
+		handler,
+		alwaysLast: options.alwaysLast ?? false
+	};
+	registrations.add(registration);
+	load();
+	return () => {
+		registrations.delete(registration);
+		if (registrations.size === 0) unload();
+	};
+};
+//#endregion
+//#region src/terminal-size.ts
+const create = (columns, rows) => ({
+	columns: Number.parseInt(String(columns), 10),
+	rows: Number.parseInt(String(rows), 10)
+});
+const devTty = () => {
+	try {
+		const { O_EVTONLY: evtOnly } = constants;
+		const flags = isMacos && evtOnly !== void 0 ? evtOnly | constants.O_NONBLOCK : constants.O_NONBLOCK;
+		const { columns, rows } = new WriteStream(openSync("/dev/tty", flags));
+		if (columns && rows) return {
+			columns,
+			rows
+		};
+	} catch {}
+};
+const terminalSize = () => {
+	const { env, stdout, stderr } = process;
+	if (stdout?.columns && stdout?.rows) return create(stdout.columns, stdout.rows);
+	if (stderr?.columns && stderr?.rows) return create(stderr.columns, stderr.rows);
+	if (env["COLUMNS"] && env["LINES"]) return create(env["COLUMNS"], env["LINES"]);
+	return devTty() ?? {
+		columns: 80,
+		rows: 24
+	};
+};
+//#endregion
+//#region src/capabilities/detect.ts
+const { env } = process;
+const terminalKnowledge = {
+	iterm: {
+		trueColor: true,
+		hyperlinks: { since: [3, 1] }
+	},
+	"apple-terminal": { colorLevel: 2 },
+	wezterm: {
+		trueColor: true,
+		hyperlinks: true
+	},
+	vscode: {
+		trueColor: true,
+		hyperlinks: { since: [1, 72] }
+	},
+	ghostty: {
+		trueColor: true,
+		hyperlinks: true
+	},
+	kitty: {
+		trueColor: true,
+		hyperlinks: true
+	},
+	alacritty: {
+		trueColor: true,
+		hyperlinks: true
+	},
+	foot: {
+		trueColor: true,
+		hyperlinks: true
+	},
+	contour: {
+		trueColor: true,
+		hyperlinks: true
+	},
+	"windows-terminal": {
+		trueColor: true,
+		hyperlinks: true
+	},
+	konsole: {
+		trueColor: true,
+		hyperlinks: true
+	},
+	vte: {
+		trueColor: true,
+		hyperlinks: { since: [0, 50] }
+	},
+	hyper: { trueColor: true },
+	tabby: {
+		trueColor: true,
+		hyperlinks: true
+	},
+	rio: {
+		trueColor: true,
+		hyperlinks: true
+	}
+};
+const termProgramNames = {
+	"iTerm.app": "iterm",
+	Apple_Terminal: "apple-terminal",
+	WezTerm: "wezterm",
+	vscode: "vscode",
+	ghostty: "ghostty",
+	Hyper: "hyper",
+	Tabby: "tabby",
+	rio: "rio"
+};
+const termNames = {
+	"xterm-kitty": "kitty",
+	"xterm-ghostty": "ghostty",
+	alacritty: "alacritty",
+	wezterm: "wezterm",
+	foot: "foot",
+	contour: "contour"
+};
+const parseVteVersion = (raw) => {
+	const numeric = Number.parseInt(raw, 10);
+	if (Number.isNaN(numeric)) return;
+	return `${Math.floor(numeric / 1e4)}.${Math.floor(numeric / 100) % 100}.${numeric % 100}`;
+};
+const versionAtLeast = (version, [major, minor]) => {
+	if (!version) return false;
+	const [haveMajor = 0, haveMinor = 0] = version.split(".").map((part) => Number.parseInt(part, 10) || 0);
+	return haveMajor > major || haveMajor === major && haveMinor >= minor;
+};
+function detectTerminal() {
+	const term = env["TERM"];
+	let multiplexer;
+	if ("TMUX" in env || env["TERM_PROGRAM"] === "tmux") multiplexer = "tmux";
+	else if ("ZELLIJ" in env) multiplexer = "zellij";
+	else if (term?.startsWith("screen")) multiplexer = "screen";
+	let name;
+	let version;
+	const termProgram = env["TERM_PROGRAM"];
+	if (termProgram && termProgram !== "tmux" && termProgram in termProgramNames) {
+		name = termProgramNames[termProgram];
+		version = env["TERM_PROGRAM_VERSION"];
+	} else if (term && term in termNames) name = termNames[term];
+	else if ("WT_SESSION" in env) name = "windows-terminal";
+	else if ("KONSOLE_VERSION" in env) {
+		name = "konsole";
+		version = env["KONSOLE_VERSION"];
+	} else if ("VTE_VERSION" in env) {
+		name = "vte";
+		version = parseVteVersion(env["VTE_VERSION"]);
+	}
+	return {
+		name,
+		version,
+		term,
+		multiplexer
+	};
+}
+const knowledgeOf = (identity) => identity.name === void 0 ? void 0 : terminalKnowledge[identity.name];
+const forcedColorLevel = () => {
+	const forced = env["FORCE_COLOR"];
+	if (forced === void 0) return;
+	if (forced === "true" || forced.length === 0) return 1;
+	if (forced === "false") return 0;
+	return Math.min(Math.max(Number.parseInt(forced, 10) || 0, 0), 3);
+};
+/**
+Detects the color support level for a stream from the environment. Purely
+env-derived — the terminal query can upgrade this to truecolor when the
+terminal confirms it via XTGETTCAP.
+*/
+function detectColorLevel(stream) {
+	const forced = forcedColorLevel();
+	if (forced === 0) return 0;
+	if (env["TF_BUILD"] && env["AGENT_NAME"]) return 1;
+	if (stream && !stream.isTTY && forced === void 0) return 0;
+	const minimum = forced ?? 0;
+	if (env["TERM"] === "dumb") return minimum;
+	if (isWindows) return 3;
+	if (env["CI"]) {
+		if ([
+			"GITHUB_ACTIONS",
+			"GITEA_ACTIONS",
+			"CIRCLECI"
+		].some((key) => key in env)) return 3;
+		if ([
+			"TRAVIS",
+			"APPVEYOR",
+			"GITLAB_CI",
+			"BUILDKITE",
+			"DRONE"
+		].some((key) => key in env) || env["CI_NAME"] === "codeship") return 1;
+		return minimum;
+	}
+	if (env["TEAMCITY_VERSION"]) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env["TEAMCITY_VERSION"]) ? 1 : 0;
+	if (env["COLORTERM"] === "truecolor") return 3;
+	const knowledge = knowledgeOf(detectTerminal());
+	if (knowledge) {
+		if (knowledge.trueColor) return 3;
+		if (knowledge.colorLevel !== void 0) return knowledge.colorLevel;
+	}
+	if (/-256(color)?$/i.test(env["TERM"] ?? "")) return 2;
+	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env["TERM"] ?? "")) return 1;
+	if ("COLORTERM" in env) return 1;
+	return minimum;
+}
+/**
+The color level in chalk's `ColorInfo` shape.
+*/
+function createSupportsColor(stream) {
+	const level = detectColorLevel(stream);
+	if (level === 0) return false;
+	return {
+		level,
+		hasBasic: true,
+		has256: level >= 2,
+		has16m: level >= 3
+	};
+}
+/**
+Detects OSC 8 hyperlink support for a stream from the environment.
+*/
+function detectHyperlinkSupport(stream) {
+	if ("FORCE_HYPERLINK" in env) return !(env["FORCE_HYPERLINK"].length > 0 && Number.parseInt(env["FORCE_HYPERLINK"], 10) === 0);
+	if (detectColorLevel(stream) === 0) return false;
+	if (stream && !stream.isTTY) return false;
+	if (env["CI"] || env["TEAMCITY_VERSION"]) return false;
+	const identity = detectTerminal();
+	const hyperlinks = knowledgeOf(identity)?.hyperlinks;
+	if (hyperlinks === true) return true;
+	if (hyperlinks) return versionAtLeast(identity.version, hyperlinks.since);
+	return false;
+}
+/**
+Detects whether the terminal renders unicode reliably.
+*/
+function detectUnicodeSupport() {
+	if (process.platform !== "win32") return env["TERM"] !== "linux";
+	const { name } = detectTerminal();
+	return name === "windows-terminal" || name === "vscode" || name === "alacritty" || Boolean(env["TERMINUS_SUBLIME"]) || env["ConEmuTask"] === "{cmd::Cmder}" || env["TERM_PROGRAM"] === "Terminus-Sublime" || env["TERM"] === "xterm-256color" || env["TERMINAL_EMULATOR"] === "JetBrains-JediTerm";
+}
+const appearanceFromColorFgBg = () => {
+	const background = (env["COLORFGBG"]?.split(";"))?.at(-1);
+	if (!background || Number.isNaN(Number.parseInt(background, 10))) return;
+	return background === "7" || background === "15" ? "light" : "dark";
+};
+const colorDepths = {
+	0: 1,
+	1: 4,
+	2: 8,
+	3: 24
+};
+const staticCache = /* @__PURE__ */ new WeakMap();
+const computeStatic = (stdout) => {
+	const level = detectColorLevel(stdout);
+	const interactive = !isInCi && Boolean(stdout.isTTY);
+	return {
+		platform: process.platform,
+		ci: isInCi,
+		ssh: "SSH_CONNECTION" in env || "SSH_CLIENT" in env || "SSH_TTY" in env,
+		screenReader: isScreenReader,
+		interactive,
+		terminal: detectTerminal(),
+		color: {
+			level,
+			depth: colorDepths[level],
+			trueColor: level === 3
+		},
+		supports: {
+			color: level > 0,
+			hyperlinks: detectHyperlinkSupport(stdout),
+			unicode: detectUnicodeSupport(),
+			alternateScreen: interactive && env["TERM"] !== "dumb",
+			kittyKeyboard: void 0,
+			kittyGraphics: void 0,
+			sixel: void 0,
+			focusEvents: void 0,
+			sgrMouse: void 0,
+			sgrPixelMouse: void 0,
+			bracketedPaste: void 0,
+			synchronizedOutput: void 0,
+			graphemeClustering: void 0,
+			colorSchemeUpdates: void 0,
+			inBandResize: void 0
+		}
+	};
+};
+/**
+Takes a snapshot of everything knowable about the terminal from streams and
+environment variables. The environment-derived parts are computed once per
+stream and cached; size and theme are read fresh on every call. Fields that
+require asking the terminal itself start as `undefined` — run `queryTerminal`
+and merge with `applyTerminalQuery` to fill them in, or use the
+`useCapabilities` hook which does both.
+*/
+function detectCapabilities({ stdout = process.stdout } = {}) {
+	let staticParts = staticCache.get(stdout);
+	if (!staticParts) {
+		staticParts = computeStatic(stdout);
+		staticCache.set(stdout, staticParts);
+	}
+	return {
+		...staticParts,
+		size: {
+			...stdout.columns && stdout.rows ? {
+				columns: stdout.columns,
+				rows: stdout.rows
+			} : terminalSize(),
+			pixels: void 0,
+			source: "pty"
+		},
+		focused: void 0,
+		theme: {
+			appearance: appearanceFromColorFgBg(),
+			systemAppearance: void 0,
+			foreground: void 0,
+			background: void 0,
+			cursor: void 0,
+			palette: void 0
+		}
+	};
+}
+//#endregion
+export { detectTerminal as a, detectHyperlinkSupport as i, detectCapabilities as n, detectUnicodeSupport as o, detectColorLevel as r, signalExit as s, createSupportsColor as t };

package/dist/detect-Db6GbKOm.d.ts

@@ -0,0 +1,195 @@
+//#region src/capabilities/detect.d.ts
+/**
+An RGB color with 8-bit channels, as reported by the terminal.
+*/
+type RgbColor = {
+  r: number;
+  g: number;
+  b: number;
+};
+type TerminalAppearance = "dark" | "light";
+type Multiplexer = "tmux" | "screen" | "zellij";
+/**
+Color support level: 0 = none, 1 = 16 colors, 2 = 256 colors, 3 = truecolor.
+*/
+type ColorSupportLevel = 0 | 1 | 2 | 3;
+/**
+The chalk-compatible color support shape.
+*/
+type ColorSupport = {
+  readonly level: ColorSupportLevel;
+  readonly hasBasic: boolean;
+  readonly has256: boolean;
+  readonly has16m: boolean;
+};
+type ColorInfo = ColorSupport | false;
+type TerminalIdentity = {
+  /**
+      Normalized terminal name (`"kitty"`, `"iterm"`, `"wezterm"`, …), or
+      `undefined` when unknown. `queryTerminal` can refine this with the
+      terminal's own XTVERSION answer.
+      */
+  name: string | undefined;
+  /**
+      The terminal's version, when the environment reports one.
+      */
+  version: string | undefined;
+  /**
+      The raw `TERM` environment variable.
+      */
+  term: string | undefined;
+  /**
+      The multiplexer the app is running under, if any. Note that inside a
+      multiplexer, capabilities reflect the multiplexer — not the outer terminal.
+      */
+  multiplexer: Multiplexer | undefined;
+};
+type PixelGeometry = {
+  /**
+      Text area size in pixels (XTWINOPS 14).
+      */
+  textArea: {
+    width: number;
+    height: number;
+  } | undefined;
+  /**
+      Size of a single character cell in pixels (XTWINOPS 16).
+      */
+  cell: {
+    width: number;
+    height: number;
+  } | undefined;
+};
+type Capabilities = {
+  /**
+      Current terminal dimensions in cells, plus pixel geometry once the
+      terminal has answered the query.
+  
+      `source` tells where the cell dimensions come from. `"pty"` is the
+      stream's own `columns`/`rows`, updated by the OS on SIGWINCH — which says
+      nothing about whether the emulator has finished rewrapping its screen.
+      `"terminal"` is the emulator's in-band size report (mode 2048), which
+      arrives in the input stream after the rewrap and so describes the screen
+      exactly as later output will find it. While the terminal reports, its
+      size wins over the stream's.
+      */
+  size: {
+    columns: number;
+    rows: number;
+    pixels: PixelGeometry | undefined;
+    source: "pty" | "terminal";
+  };
+  platform: NodeJS.Platform;
+  /**
+      Running under a CI provider.
+      */
+  ci: boolean;
+  /**
+      Running over an SSH connection.
+      */
+  ssh: boolean;
+  screenReader: boolean;
+  /**
+      Same detection `render()` uses: stdout is a TTY and not CI.
+      */
+  interactive: boolean;
+  /**
+      Whether the terminal window has focus. Requires focus events (mode 1004),
+      which the capabilities store enables automatically while it has
+      subscribers; `undefined` until the first focus report arrives.
+      */
+  focused: boolean | undefined;
+  terminal: TerminalIdentity;
+  color: {
+    level: ColorSupportLevel;
+    /**
+            The same fact as bits per color: 1, 4, 8, or 24.
+            */
+    depth: 1 | 4 | 8 | 24;
+    trueColor: boolean;
+  };
+  theme: {
+    /**
+            The terminal's own appearance. After `queryTerminal` this is derived
+            from the actual background color's luminance (a dark terminal theme on
+            a light OS stays `"dark"`); before that it's a `COLORFGBG` guess.
+            */
+    appearance: TerminalAppearance | undefined;
+    /**
+            The operating system's color preference, from the color scheme report.
+            Independent of the terminal's own theme — only available after
+            `queryTerminal` on terminals that support the report.
+            */
+    systemAppearance: TerminalAppearance | undefined;
+    /**
+            The user's configured foreground/background/cursor colors and 16-color
+            palette. Only available after `queryTerminal`.
+            */
+    foreground: RgbColor | undefined;
+    background: RgbColor | undefined;
+    cursor: RgbColor | undefined;
+    palette: RgbColor[] | undefined;
+  };
+  /**
+      Feature support. Fields typed `boolean | undefined` are only knowable by
+      asking the terminal — they stay `undefined` until `queryTerminal` has
+      answered (see `TerminalQueryResult` for what each means).
+      */
+  supports: {
+    color: boolean;
+    hyperlinks: boolean;
+    unicode: boolean;
+    alternateScreen: boolean;
+    kittyKeyboard: boolean | undefined;
+    kittyGraphics: boolean | undefined;
+    sixel: boolean | undefined;
+    focusEvents: boolean | undefined;
+    sgrMouse: boolean | undefined;
+    sgrPixelMouse: boolean | undefined;
+    bracketedPaste: boolean | undefined;
+    synchronizedOutput: boolean | undefined;
+    graphemeClustering: boolean | undefined;
+    colorSchemeUpdates: boolean | undefined;
+    inBandResize: boolean | undefined;
+  };
+};
+declare function detectTerminal(): TerminalIdentity;
+type DetectStream = {
+  isTTY?: boolean;
+};
+/**
+Detects the color support level for a stream from the environment. Purely
+env-derived — the terminal query can upgrade this to truecolor when the
+terminal confirms it via XTGETTCAP.
+*/
+declare function detectColorLevel(stream?: DetectStream): ColorSupportLevel;
+/**
+The color level in chalk's `ColorInfo` shape.
+*/
+declare function createSupportsColor(stream?: DetectStream): ColorInfo;
+/**
+Detects OSC 8 hyperlink support for a stream from the environment.
+*/
+declare function detectHyperlinkSupport(stream?: DetectStream): boolean;
+/**
+Detects whether the terminal renders unicode reliably.
+*/
+declare function detectUnicodeSupport(): boolean;
+type CapabilityStdout = DetectStream & {
+  columns?: number;
+  rows?: number;
+};
+type DetectOptions = {
+  stdout?: CapabilityStdout;
+};
+/**
+Takes a snapshot of everything knowable about the terminal from streams and
+environment variables. The environment-derived parts are computed once per
+stream and cached; size and theme are read fresh on every call. Fields that
+require asking the terminal itself start as `undefined` — run `queryTerminal`
+and merge with `applyTerminalQuery` to fill them in, or use the
+`useCapabilities` hook which does both.
+*/
+declare function detectCapabilities({ stdout }?: DetectOptions): Capabilities;
+//#endregion
+export { Multiplexer as a, TerminalAppearance as c, detectCapabilities as d, detectColorLevel as f, detectUnicodeSupport as h, ColorSupportLevel as i, TerminalIdentity as l, detectTerminal as m, ColorInfo as n, PixelGeometry as o, detectHyperlinkSupport as p, ColorSupport as r, RgbColor as s, Capabilities as t, createSupportsColor as u };