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

package/dist/sgr-BhwaWAJB.js

@@ -0,0 +1,246 @@
+//#region src/ansi/escapes.ts
+const ESC = "\x1B";
+const BEL = "\x07";
+const DEL = "";
+/** Control Sequence Introducer. */
+const CSI = `[`;
+/** Operating System Command. */
+const OSC = `]`;
+/** String Terminator. */
+const ST = `\\`;
+/** Single-byte C1 forms of CSI and ST. */
+const C1_CSI = "›";
+const C1_ST = "œ";
+const sep = ";";
+const cursorTo = (x, y) => {
+	if (typeof y !== "number") return CSI + (x + 1) + "G";
+	return CSI + (y + 1) + sep + (x + 1) + "H";
+};
+const cursorUp = (count = 1) => CSI + count + "A";
+const cursorDown = (count = 1) => CSI + count + "B";
+const cursorLeft = CSI + "G";
+const cursorNextLine = CSI + "E";
+const eraseEndLine = CSI + "K";
+const eraseLine = CSI + "2K";
+const eraseScreen = CSI + "2J";
+const eraseLines = (count) => {
+	let clear = "";
+	for (let i = 0; i < count; i++) clear += eraseLine + (i < count - 1 ? cursorUp() : "");
+	if (count) clear += cursorLeft;
+	return clear;
+};
+const clearTerminal = `${eraseScreen}${CSI}3J${CSI}H`;
+const enterAlternativeScreen = CSI + "?1049h";
+const exitAlternativeScreen = CSI + "?1049l";
+const cursorShow = CSI + "?25h";
+const cursorHide = CSI + "?25l";
+const cursorShape = (shape, blinking = true) => {
+	const value = {
+		block: blinking ? 1 : 2,
+		underline: blinking ? 3 : 4,
+		bar: blinking ? 5 : 6
+	}[shape];
+	return `${CSI}${value} q`;
+};
+const cursorColor = (color) => `${OSC}12;${color}`;
+const resetCursorColor = `${OSC}112`;
+const enableBracketedPaste = CSI + "?2004h";
+const disableBracketedPaste = CSI + "?2004l";
+const pasteStart = CSI + "200~";
+const pasteEnd = CSI + "201~";
+const bsu = CSI + "?2026h";
+const esu = CSI + "?2026l";
+const kittyQuery = CSI + "?u";
+const pushKittyKeyboard = (flags) => `${CSI}>${flags}u`;
+const popKittyKeyboard = CSI + "<u";
+const link = (text, url) => [
+	OSC,
+	"8",
+	sep,
+	sep,
+	url,
+	"\x07",
+	text,
+	OSC,
+	"8",
+	sep,
+	sep,
+	"\x07"
+].join("");
+const ansiEscapes = {
+	cursorTo,
+	cursorUp,
+	cursorDown,
+	cursorLeft,
+	cursorNextLine,
+	eraseEndLine,
+	eraseLine,
+	eraseScreen,
+	eraseLines,
+	clearTerminal,
+	enterAlternativeScreen,
+	exitAlternativeScreen,
+	cursorShow,
+	cursorHide,
+	cursorShape,
+	cursorColor,
+	resetCursorColor,
+	enableBracketedPaste,
+	disableBracketedPaste,
+	pasteStart,
+	pasteEnd,
+	bsu,
+	esu,
+	kittyQuery,
+	pushKittyKeyboard,
+	popKittyKeyboard,
+	link
+};
+//#endregion
+//#region src/ansi/sgr.ts
+const ANSI_BACKGROUND_OFFSET = 10;
+const wrapAnsi16 = (offset = 0) => (code) => `${CSI}${code + offset}m`;
+const wrapAnsi256 = (offset = 0) => (code) => `${CSI}${38 + offset};5;${code}m`;
+const wrapAnsi16m = (offset = 0) => (red, green, blue) => `${CSI}${38 + offset};2;${red};${green};${blue}m`;
+const modifierCodes = {
+	reset: [0, 0],
+	bold: [1, 22],
+	dim: [2, 22],
+	italic: [3, 23],
+	underline: [4, 24],
+	overline: [53, 55],
+	inverse: [7, 27],
+	hidden: [8, 28],
+	strikethrough: [9, 29]
+};
+const colorCodes = {
+	black: [30, 39],
+	red: [31, 39],
+	green: [32, 39],
+	yellow: [33, 39],
+	blue: [34, 39],
+	magenta: [35, 39],
+	cyan: [36, 39],
+	white: [37, 39],
+	blackBright: [90, 39],
+	gray: [90, 39],
+	grey: [90, 39],
+	redBright: [91, 39],
+	greenBright: [92, 39],
+	yellowBright: [93, 39],
+	blueBright: [94, 39],
+	magentaBright: [95, 39],
+	cyanBright: [96, 39],
+	whiteBright: [97, 39]
+};
+const bgColorCodes = {
+	bgBlack: [40, 49],
+	bgRed: [41, 49],
+	bgGreen: [42, 49],
+	bgYellow: [43, 49],
+	bgBlue: [44, 49],
+	bgMagenta: [45, 49],
+	bgCyan: [46, 49],
+	bgWhite: [47, 49],
+	bgBlackBright: [100, 49],
+	bgGray: [100, 49],
+	bgGrey: [100, 49],
+	bgRedBright: [101, 49],
+	bgGreenBright: [102, 49],
+	bgYellowBright: [103, 49],
+	bgBlueBright: [104, 49],
+	bgMagentaBright: [105, 49],
+	bgCyanBright: [106, 49],
+	bgWhiteBright: [107, 49]
+};
+const modifierNames = Object.keys(modifierCodes);
+const foregroundColorNames = Object.keys(colorCodes);
+const backgroundColorNames = Object.keys(bgColorCodes);
+const toPairs = (codes) => {
+	const result = {};
+	for (const [name, [open, close]] of Object.entries(codes)) result[name] = {
+		open: `${CSI}${open}m`,
+		close: `${CSI}${close}m`
+	};
+	return result;
+};
+/**
+Named SGR styles as `{open, close}` escape sequence pairs.
+*/
+const styles = {
+	...toPairs(modifierCodes),
+	...toPairs(colorCodes),
+	...toPairs(bgColorCodes)
+};
+/**
+Raw SGR code numbers: open code → close code.
+*/
+const codes = new Map([
+	...Object.values(modifierCodes),
+	...Object.values(colorCodes),
+	...Object.values(bgColorCodes)
+].map(([open, close]) => [open, close]));
+const foreground = {
+	close: `${CSI}39m`,
+	ansi: wrapAnsi16(),
+	ansi256: wrapAnsi256(),
+	ansi16m: wrapAnsi16m()
+};
+const background = {
+	close: `${CSI}49m`,
+	ansi: wrapAnsi16(ANSI_BACKGROUND_OFFSET),
+	ansi256: wrapAnsi256(ANSI_BACKGROUND_OFFSET),
+	ansi16m: wrapAnsi16m(ANSI_BACKGROUND_OFFSET)
+};
+const rgbToAnsi256 = (red, green, blue) => {
+	if (red === green && green === blue) {
+		if (red < 8) return 16;
+		if (red > 248) return 231;
+		return Math.round((red - 8) / 247 * 24) + 232;
+	}
+	return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+};
+const hexToRgb = (hex) => {
+	const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex);
+	if (!matches) return [
+		0,
+		0,
+		0
+	];
+	let [colorString] = matches;
+	if (colorString.length === 3) colorString = colorString.replaceAll(/./g, "$&$&");
+	const integer = Number.parseInt(colorString, 16);
+	return [
+		integer >> 16 & 255,
+		integer >> 8 & 255,
+		integer & 255
+	];
+};
+const hexToAnsi256 = (hex) => rgbToAnsi256(...hexToRgb(hex));
+const ansi256ToAnsi = (code) => {
+	if (code < 8) return 30 + code;
+	if (code < 16) return 90 + (code - 8);
+	let red;
+	let green;
+	let blue;
+	if (code >= 232) {
+		red = ((code - 232) * 10 + 8) / 255;
+		green = red;
+		blue = red;
+	} else {
+		code -= 16;
+		const remainder = code % 36;
+		red = Math.floor(code / 36) / 5;
+		green = Math.floor(remainder / 6) / 5;
+		blue = remainder % 6 / 5;
+	}
+	const value = Math.max(red, green, blue) * 2;
+	if (value === 0) return 30;
+	let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+	if (value === 2) result += 60;
+	return result;
+};
+const rgbToAnsi = (red, green, blue) => ansi256ToAnsi(rgbToAnsi256(red, green, blue));
+const hexToAnsi = (hex) => ansi256ToAnsi(hexToAnsi256(hex));
+//#endregion
+export { cursorShape as A, eraseScreen as B, bsu as C, cursorHide as D, cursorDown as E, enableBracketedPaste as F, pasteEnd as G, exitAlternativeScreen as H, enterAlternativeScreen as I, pushKittyKeyboard as J, pasteStart as K, eraseEndLine as L, cursorTo as M, cursorUp as N, cursorLeft as O, disableBracketedPaste as P, eraseLine as R, ansiEscapes as S, cursorColor as T, kittyQuery as U, esu as V, link as W, resetCursorColor as Y, CSI as _, foreground as a, OSC as b, hexToAnsi256 as c, rgbToAnsi as d, rgbToAnsi256 as f, C1_ST as g, C1_CSI as h, codes as i, cursorShow as j, cursorNextLine as k, hexToRgb as l, BEL as m, background as n, foregroundColorNames as o, styles as p, popKittyKeyboard as q, backgroundColorNames as r, hexToAnsi as s, ansi256ToAnsi as t, modifierNames as u, DEL as v, clearTerminal as w, ST as x, ESC as y, eraseLines as z };

package/dist/store-CgrG9K4y.d.ts

@@ -0,0 +1,72 @@
+import { t as Capabilities } from "./detect-Bh4yGP6w.js";
+//#region src/stream.d.ts
+type OutputStream = NodeJS.WritableStream & {
+  isTTY?: boolean;
+  columns?: number;
+  rows?: number;
+  destroyed?: boolean;
+  writableEnded?: boolean;
+};
+//#endregion
+//#region src/capabilities/store.d.ts
+type StoreStdin = NodeJS.ReadableStream & {
+  isTTY?: boolean;
+  isRaw?: boolean;
+  setRawMode?: (mode: boolean) => void;
+};
+type StoreStdout = OutputStream;
+type CapabilitiesStore = {
+  /**
+      The current snapshot: environment-derived detection merged with every
+      query answer received so far. Size is always fresh; the object identity
+      only changes when something actually changed, so it's safe to compare.
+      */
+  readonly current: Capabilities;
+  /**
+      Asks the terminal. The first call runs the full query; subsequent calls
+      re-ask only the dynamic questions (theme colors, pixel geometry) and
+      merge over the cached answers. No-op outside a TTY. Resolves with the
+      updated snapshot.
+      */
+  query: () => Promise<Capabilities>;
+  /**
+      Subscribes to snapshot changes: query answers arriving, terminal resizes
+      (including in-band pixel geometry), color scheme switches, and window
+      focus changes. While subscribers exist (and a report feed is available),
+      the store enables the supported report modes on the terminal and disables
+      them again on the last unsubscribe. Returns an unsubscribe function.
+      */
+  subscribe: (listener: (capabilities: Capabilities) => void, options?: {
+    resizes?: boolean;
+  }) => () => void;
+  /**
+      Feeds one parsed escape sequence from an input pipeline into the store.
+      Returns `true` when the sequence was an unsolicited terminal report
+      (color scheme, focus, in-band resize) and was consumed. Ink calls this
+      for every escape sequence it reads; standalone apps that read stdin
+      themselves can forward unrecognized sequences here.
+      */
+  ingest: (sequence: string) => boolean;
+};
+/**
+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.
+*/
+declare const getCapabilities: (stdin?: StoreStdin, stdout?: StoreStdout) => CapabilitiesStore;
+/**
+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);
+});
+```
+*/
+declare const capabilities: CapabilitiesStore;
+//#endregion
+export { OutputStream as i, capabilities as n, getCapabilities as r, CapabilitiesStore as t };

package/dist/string-width-CijQwpIk.js

@@ -0,0 +1,69 @@
+import { N as isWideNotCJKTNotEmoji, k as isFullWidth } from "./tokenize-AjqbvtiT.js";
+//#region src/ansi/string-width.ts
+const getCodePointsLength = (input) => {
+	let length = 0;
+	for (const _ of input) length += 1;
+	return length;
+};
+const ANSI_RE = /[\u001b\u009b][[()#;?]*[0-9;:]*[0-9A-ORZcf-nqry=><]|\u001b\]8;[^;]*;.*?(?:\u0007|\u001b\u005c)/y;
+const CONTROL_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y;
+const CJKT_WIDE_RE = /(?:(?![\uFF61-\uFF9F\uFF00-\uFFEF])[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Tangut}]){1,1000}/uy;
+const TAB_RE = /\t{1,1000}/y;
+const EMOJI_RE = /[\u{1F1E6}-\u{1F1FF}]{2}|\u{1F3F4}[\u{E0061}-\u{E007A}]{2}[\u{E0030}-\u{E0039}\u{E0061}-\u{E007A}]{1,3}\u{E007F}|(?:\p{Emoji}\uFE0F\u20E3?|\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation})(?:\u200D(?:\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation}|\p{Emoji}\uFE0F\u20E3?))*/uy;
+const LATIN_RE = /(?:[\x20-\x7E\xA0-\xFF](?!\uFE0F)){1,1000}/y;
+const MODIFIER_RE = /\p{M}+/gu;
+const ANSI_WIDTH = 0;
+const CONTROL_WIDTH = 0;
+const TAB_WIDTH = 8;
+const EMOJI_WIDTH = 2;
+const FULL_WIDTH_WIDTH = 2;
+const REGULAR_WIDTH = 1;
+const WIDE_WIDTH = 2;
+const PARSE_BLOCKS = [
+	[LATIN_RE, REGULAR_WIDTH],
+	[ANSI_RE, ANSI_WIDTH],
+	[CONTROL_RE, CONTROL_WIDTH],
+	[TAB_RE, TAB_WIDTH],
+	[EMOJI_RE, EMOJI_WIDTH],
+	[CJKT_WIDE_RE, WIDE_WIDTH]
+];
+const stringWidth = (input) => {
+	let indexPrev = 0;
+	let index = 0;
+	const length = input.length;
+	let unmatchedStart = 0;
+	let unmatchedEnd = 0;
+	let width = 0;
+	outer: while (true) {
+		if (unmatchedEnd > unmatchedStart || index >= length && index > indexPrev) {
+			const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index);
+			for (const char of unmatched.replaceAll(MODIFIER_RE, "")) {
+				const codePoint = char.codePointAt(0) || 0;
+				width += isFullWidth(codePoint) ? FULL_WIDTH_WIDTH : isWideNotCJKTNotEmoji(codePoint) ? WIDE_WIDTH : REGULAR_WIDTH;
+			}
+			unmatchedStart = unmatchedEnd = 0;
+		}
+		if (index >= length) break;
+		for (let i = 0, l = PARSE_BLOCKS.length; i < l; i++) {
+			const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i];
+			BLOCK_RE.lastIndex = index;
+			if (BLOCK_RE.test(input)) {
+				const lengthExtra = BLOCK_RE === CJKT_WIDE_RE ? getCodePointsLength(input.slice(index, BLOCK_RE.lastIndex)) : BLOCK_RE === EMOJI_RE ? 1 : BLOCK_RE.lastIndex - index;
+				width += lengthExtra * BLOCK_WIDTH;
+				unmatchedStart = indexPrev;
+				unmatchedEnd = index;
+				index = indexPrev = BLOCK_RE.lastIndex;
+				continue outer;
+			}
+		}
+		index += 1;
+	}
+	return width;
+};
+const widestLine = (text) => {
+	let lineWidth = 0;
+	for (const line of text.split("\n")) lineWidth = Math.max(lineWidth, stringWidth(line));
+	return lineWidth;
+};
+//#endregion
+export { widestLine as n, stringWidth as t };

package/dist/strip-BvU4toXG.js

@@ -0,0 +1,6 @@
+import { stripVTControlCharacters } from "node:util";
+//#region src/ansi/strip.ts
+const colonSgrRegex = /(?:\u001B\[|\u009B)[\d;]*:[\d;:]*m/g;
+const stripAnsi = (input) => stripVTControlCharacters(input.replaceAll(colonSgrRegex, ""));
+//#endregion
+export { stripAnsi as t };

package/dist/terminal.d.ts

@@ -0,0 +1,118 @@
+import { a as CursorShape } from "./escapes-CB_6CWOE.js";
+import { n as TerminalProgressState, t as ClipboardSelection } from "./osc-Cn0fw77g.js";
+import { i as OutputStream, t as CapabilitiesStore } from "./store-CgrG9K4y.js";
+import { t as ColorProfile } from "./color-profile-u0Nhe9Nv.js";
+import { t as ColorPolicy } from "./color-policy-BMzMwV7Q.js";
+import { n as Screen } from "./screen-BOSLQ8fF.js";
+import { t as CursorPosition } from "./cursor-position-D2LAkRG0.js";
+//#region src/input-parser.d.ts
+type InputEvent = string | {
+  readonly paste: string;
+};
+//#endregion
+//#region src/terminal/input.d.ts
+type MouseButton = "left" | "middle" | "right" | "none" | "wheel-up" | "wheel-down";
+type TerminalMouseEvent = {
+  readonly type: "press" | "release" | "move" | "wheel";
+  readonly x: number;
+  readonly y: number;
+  readonly button: MouseButton;
+  readonly shift: boolean;
+  readonly alt: boolean;
+  readonly ctrl: boolean;
+};
+/** Stateful stdin decoder that separates terminal reports from application input. */
+declare class TerminalInput {
+  #private;
+  constructor(capabilities: CapabilitiesStore);
+  push(chunk: string): InputEvent[];
+  subscribeMouse(listener: (event: TerminalMouseEvent) => void): () => void;
+  hasPendingEscape(): boolean;
+  flushPendingEscape(): string | undefined;
+  reset(): void;
+}
+declare function parseMouseEvent(sequence: string): TerminalMouseEvent | undefined;
+//#endregion
+//#region src/terminal/session.d.ts
+type TerminalSessionOptions = {
+  readonly stdin: NodeJS.ReadableStream;
+  readonly stdout: OutputStream;
+  readonly stderr: OutputStream;
+  readonly colorPolicy?: ColorPolicy;
+  readonly onCapabilitiesChange?: () => void;
+};
+type TerminalMode = {
+  readonly id: string;
+  readonly enable: string;
+  readonly disable: string;
+};
+type TerminalCursor = {
+  readonly position?: CursorPosition;
+  readonly visible: boolean;
+  readonly shape: CursorShape;
+  readonly blinking: boolean;
+  readonly color?: string;
+};
+/** Instance-scoped terminal state and lifecycle ownership. */
+declare class TerminalSession {
+  #private;
+  readonly stdin: NodeJS.ReadableStream;
+  readonly stdout: OutputStream;
+  readonly stderr: OutputStream;
+  readonly capabilities: CapabilitiesStore;
+  readonly input: TerminalInput;
+  cursor: TerminalCursor;
+  suspended: boolean;
+  alternateScreen: boolean;
+  inlineScreen: boolean;
+  constructor(options: TerminalSessionOptions);
+  get colorProfile(): ColorProfile;
+  /** Encodes a structured frame at the terminal boundary. */
+  encode(screen: Screen): string;
+  present(screen: Screen, options?: {
+    readonly fullscreen?: boolean;
+    readonly forceRewrite?: boolean;
+  }): boolean;
+  willPresent(screen: Screen, options?: {
+    readonly fullscreen?: boolean;
+    readonly forceRewrite?: boolean;
+  }): boolean;
+  clearFrame(): void;
+  resetFrame(): void;
+  finishFrame(): void;
+  setColorPolicy(policy: ColorPolicy): void;
+  /** Writes through the session and tracks callback-based backpressure completion. */
+  write(data: string): boolean;
+  flush(): Promise<void>;
+  /** Copy text through OSC 52, including tmux passthrough when required. */
+  copyToClipboard(text: string, selection?: ClipboardSelection): boolean;
+  setTitle(title: string): boolean;
+  publishTitle(owner: symbol, title?: string): boolean;
+  setWorkingDirectory(directory: URL | string): boolean;
+  notify(title: string): boolean;
+  setPointerShape(shape: string): boolean;
+  publishProgress(owner: symbol, state: TerminalProgressState, value?: number): boolean;
+  /**
+   * Update terminal-native progress. Active progress is reset during cleanup
+   * so a completed or failed process cannot leave a stale terminal indicator.
+   */
+  setProgress(state: TerminalProgressState, value?: number): boolean;
+  enableMode(mode: TerminalMode): void;
+  enableMode(enable: string, disable: string): void;
+  disableMode(idOrDisable: string): void;
+  setCursor(position: CursorPosition | undefined): void;
+  setCursorAppearance(options: {
+    readonly visible?: boolean;
+    readonly shape?: CursorShape;
+    readonly blinking?: boolean;
+    readonly color?: string | null;
+  }): void;
+  setAlternateScreen(enabled: boolean, options?: {
+    hideCursor?: boolean;
+  }): void;
+  beginSuspension(): void;
+  resume(): void;
+  cleanup(): void;
+}
+//#endregion
+export { MouseButton, TerminalCursor, TerminalInput, TerminalMode, TerminalMouseEvent, TerminalSession, TerminalSessionOptions, parseMouseEvent };

package/dist/terminal.js

@@ -0,0 +1,2 @@
+import { n as TerminalInput, r as parseMouseEvent, t as TerminalSession } from "./session-aZr9O8h3.js";
+export { TerminalInput, TerminalSession, parseMouseEvent };