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

package/dist/osc-CCH7xDoS.js

@@ -0,0 +1,71 @@
+import { D as cursorHide, b as OSC, j as cursorShow, x as ST } from "./sgr-BhwaWAJB.js";
+import { c as signalExit } from "./detect-BuTXtY6e.js";
+import { pathToFileURL } from "node:url";
+//#region src/ansi/cursor.ts
+let restoreRegistered = false;
+const registerRestore = () => {
+	if (restoreRegistered) return;
+	restoreRegistered = true;
+	signalExit(() => {
+		process.stderr.write(cursorShow);
+	}, { alwaysLast: true });
+};
+const cliCursor = {
+	show(writableStream = process.stderr) {
+		if (!writableStream.isTTY) return;
+		writableStream.write(cursorShow);
+	},
+	hide(writableStream = process.stderr) {
+		if (!writableStream.isTTY) return;
+		registerRestore();
+		writableStream.write(cursorHide);
+	}
+};
+//#endregion
+//#region src/ansi/osc.ts
+const clipboardCode = {
+	clipboard: "c",
+	primary: "p",
+	selection: "s"
+};
+const progressCode = {
+	inactive: 0,
+	normal: 1,
+	error: 2,
+	indeterminate: 3,
+	paused: 4
+};
+const field = (value) => value.replace(/[\u0000-\u001F\u007F-\u009F]/g, "");
+const command = (code, payload) => `${OSC}${code};${payload}${ST}`;
+/** Change the terminal window title (OSC 2). */
+const setWindowTitle = (title) => command(2, field(title));
+/** Announce the current directory as a file URI (OSC 7). */
+const setWorkingDirectory = (directory) => {
+	const uri = directory instanceof URL ? directory : directory.startsWith("file:") ? new URL(directory) : pathToFileURL(directory);
+	if (uri.protocol !== "file:") throw new Error("Terminal working directory must be a file URI");
+	return command(7, uri.href);
+};
+/** Show a desktop notification (OSC 9). */
+const notify = (title) => {
+	const safe = field(title);
+	return command(9, /^\d+;/.test(safe) ? ` ${safe}` : safe);
+};
+/** Change the terminal pointer shape (OSC 22; terminal support varies). */
+const setPointerShape = (shape) => command(22, field(shape));
+/** Write UTF-8 text to a terminal clipboard using OSC 52. */
+const setClipboard = (text, selection = "clipboard") => command(52, `${clipboardCode[selection]};${Buffer.from(text).toString("base64")}`);
+/** Request clipboard contents. The response is another OSC 52 sequence. */
+const queryClipboard = (selection = "clipboard") => command(52, `${clipboardCode[selection]};?`);
+/** Clear a terminal clipboard. */
+const clearClipboard = (selection = "clipboard") => command(52, `${clipboardCode[selection]};`);
+/** Report terminal-native progress using OSC 9;4. */
+const setTerminalProgress = (state, value) => {
+	const code = progressCode[state];
+	if (state === "inactive" || state === "indeterminate") return command(9, `4;${code}`);
+	if (value === void 0 && (state === "error" || state === "paused")) return command(9, `4;${code}`);
+	return command(9, `4;${code};${Math.max(0, Math.min(100, Math.round(value ?? 0)))}`);
+};
+/** Wrap a sequence for transport through tmux's DCS passthrough. */
+const tmuxPassthrough = (sequence) => `Ptmux;${sequence.replaceAll("\x1B", ``)}${ST}`;
+//#endregion
+export { setPointerShape as a, setWorkingDirectory as c, setClipboard as i, tmuxPassthrough as l, notify as n, setTerminalProgress as o, queryClipboard as r, setWindowTitle as s, clearClipboard as t, cliCursor as u };

package/dist/osc-Cn0fw77g.d.ts

@@ -0,0 +1,23 @@
+//#region src/ansi/osc.d.ts
+type ClipboardSelection = "clipboard" | "primary" | "selection";
+type TerminalProgressState = "inactive" | "normal" | "error" | "indeterminate" | "paused";
+/** Change the terminal window title (OSC 2). */
+declare const setWindowTitle: (title: string) => string;
+/** Announce the current directory as a file URI (OSC 7). */
+declare const setWorkingDirectory: (directory: URL | string) => string;
+/** Show a desktop notification (OSC 9). */
+declare const notify: (title: string) => string;
+/** Change the terminal pointer shape (OSC 22; terminal support varies). */
+declare const setPointerShape: (shape: string) => string;
+/** Write UTF-8 text to a terminal clipboard using OSC 52. */
+declare const setClipboard: (text: string, selection?: ClipboardSelection) => string;
+/** Request clipboard contents. The response is another OSC 52 sequence. */
+declare const queryClipboard: (selection?: ClipboardSelection) => string;
+/** Clear a terminal clipboard. */
+declare const clearClipboard: (selection?: ClipboardSelection) => string;
+/** Report terminal-native progress using OSC 9;4. */
+declare const setTerminalProgress: (state: TerminalProgressState, value?: number) => string;
+/** Wrap a sequence for transport through tmux's DCS passthrough. */
+declare const tmuxPassthrough: (sequence: string) => string;
+//#endregion
+export { queryClipboard as a, setTerminalProgress as c, tmuxPassthrough as d, notify as i, setWindowTitle as l, TerminalProgressState as n, setClipboard as o, clearClipboard as r, setPointerShape as s, ClipboardSelection as t, setWorkingDirectory as u };

package/dist/paint-C19minOS.d.ts

@@ -0,0 +1,81 @@
+import { c as TerminalAppearance } from "./detect-Bh4yGP6w.js";
+import { c as Color, d as RgbColor, t as ColorProfile } from "./color-profile-u0Nhe9Nv.js";
+//#region src/color/paint.d.ts
+type ColorInput = Color | string;
+type InterpolationSpace = "oklab" | "lab" | "rgb" | "hsv";
+type GradientStop = {
+  readonly offset?: number;
+  readonly color: ColorInput;
+};
+type LinearGradient = {
+  readonly type: "linear-gradient";
+  readonly stops: readonly GradientStop[];
+  /** Degrees clockwise: 0 points left-to-right, 90 top-to-bottom. */
+  readonly angle: number;
+  readonly space: InterpolationSpace;
+};
+/** A one-dimensional gradient wrapped clockwise around a rectangle's edge. */
+type PerimeterGradient = {
+  readonly type: "perimeter-gradient";
+  readonly stops: readonly GradientStop[];
+  /** Rotation in terminal cells, starting at the top-left corner. */
+  readonly offset: number;
+  readonly space: InterpolationSpace;
+};
+type AdaptiveColor = {
+  readonly type: "adaptive-color";
+  readonly light: ColorInput;
+  readonly dark: ColorInput;
+};
+type ProfileColor = {
+  readonly type: "profile-color";
+  readonly colors: Partial<Record<ColorProfile, ColorInput>>;
+  readonly fallback: ColorInput;
+};
+type Paint = ColorInput | LinearGradient | PerimeterGradient | AdaptiveColor | ProfileColor;
+type PaintContext = {
+  readonly appearance?: TerminalAppearance;
+  readonly profile?: ColorProfile;
+  readonly palette?: readonly {
+    r: number;
+    g: number;
+    b: number;
+  }[];
+};
+declare const rgb: (red: number, green: number, blue: number, alpha?: number) => RgbColor;
+declare const ansi: (index: number) => Color;
+declare const ansi256: (index: number) => Color;
+declare const namedIndexes: {
+  readonly black: 0;
+  readonly red: 1;
+  readonly green: 2;
+  readonly yellow: 3;
+  readonly blue: 4;
+  readonly magenta: 5;
+  readonly cyan: 6;
+  readonly white: 7;
+  readonly blackBright: 8;
+  readonly gray: 8;
+  readonly grey: 8;
+  readonly redBright: 9;
+  readonly greenBright: 10;
+  readonly yellowBright: 11;
+  readonly blueBright: 12;
+  readonly magentaBright: 13;
+  readonly cyanBright: 14;
+  readonly whiteBright: 15;
+};
+type NamedColor = keyof typeof namedIndexes;
+declare const named: (color: NamedColor) => Color;
+declare const adaptive: (light: ColorInput, dark: ColorInput) => AdaptiveColor;
+declare const perProfile: (colors: Partial<Record<ColorProfile, ColorInput>>, fallback: ColorInput) => ProfileColor;
+declare const linearGradient: (stops: readonly (GradientStop | ColorInput)[], options?: {
+  angle?: number;
+  space?: InterpolationSpace;
+}) => LinearGradient;
+declare const perimeterGradient: (stops: readonly ColorInput[], options?: {
+  offset?: number;
+  space?: InterpolationSpace;
+}) => PerimeterGradient;
+//#endregion
+export { perimeterGradient as _, LinearGradient as a, PaintContext as c, adaptive as d, ansi as f, perProfile as g, named as h, InterpolationSpace as i, PerimeterGradient as l, linearGradient as m, ColorInput as n, NamedColor as o, ansi256 as p, GradientStop as r, Paint as s, AdaptiveColor as t, ProfileColor as u, rgb as v };

package/dist/query-vaIeGOkH.d.ts

@@ -0,0 +1,152 @@
+import { c as TerminalAppearance, s as RgbColor, t as Capabilities } from "./detect-Bh4yGP6w.js";
+//#region src/capabilities/query.d.ts
+type PixelSize = {
+  width: number;
+  height: number;
+};
+type TerminalQueryResult = {
+  foreground: RgbColor | undefined;
+  background: RgbColor | undefined;
+  cursorColor: RgbColor | undefined;
+  /**
+      The user's 16-color ANSI palette, when the terminal reports it.
+      */
+  palette: RgbColor[] | undefined;
+  /**
+      The terminal's own appearance, derived from the actual background color's
+      luminance — a dark terminal theme on a light OS stays "dark". Falls back
+      to the OS color scheme report when the background is unknown.
+      */
+  appearance: TerminalAppearance | undefined;
+  /**
+      The operating system's color preference, from the color scheme report
+      (`CSI ? 996 n`). Independent of the terminal's own theme.
+      */
+  systemAppearance: TerminalAppearance | undefined;
+  /**
+      The terminal answered the kitty keyboard protocol query.
+      */
+  kittyKeyboard: boolean;
+  /**
+      The terminal answered the kitty graphics protocol probe.
+      */
+  kittyGraphics: boolean;
+  /**
+      The terminal reports sixel graphics in its DA1 device attributes.
+      */
+  sixel: boolean;
+  /**
+      Raw DA1 device attribute parameters, for capabilities not modeled here.
+      */
+  deviceAttributes: number[] | undefined;
+  /**
+      The terminal confirmed truecolor via XTGETTCAP ("RGB").
+      */
+  trueColor: boolean;
+  /**
+      Focus in/out reporting (mode 1004).
+      */
+  focusEvents: boolean;
+  /**
+      SGR mouse reporting (mode 1006).
+      */
+  sgrMouse: boolean;
+  /**
+      SGR pixel-precision mouse reporting (mode 1016).
+      */
+  sgrPixelMouse: boolean;
+  /**
+      Bracketed paste (mode 2004).
+      */
+  bracketedPaste: boolean;
+  /**
+      Synchronized output (mode 2026).
+      */
+  synchronizedOutput: boolean;
+  /**
+      Grapheme cluster width handling (mode 2027).
+      */
+  graphemeClustering: boolean;
+  /**
+      Push notifications of light/dark scheme changes (mode 2031).
+      */
+  colorSchemeUpdates: boolean;
+  /**
+      In-band window resize notifications (mode 2048).
+      */
+  inBandResize: boolean;
+  /**
+      Text area size in pixels (XTWINOPS 14).
+      */
+  textAreaPixels: PixelSize | undefined;
+  /**
+      Size of a single character cell in pixels (XTWINOPS 16).
+      */
+  cellPixels: PixelSize | undefined;
+  /**
+      The terminal's self-reported name and version (XTVERSION).
+      */
+  terminal: {
+    raw: string;
+    name: string | undefined;
+    version: string | undefined;
+  } | undefined;
+};
+type TerminalQueryOptions = {
+  /**
+      How long to wait for the DA1 sentinel before giving up, in milliseconds.
+      */
+  timeout?: number;
+  /**
+      Also query the 16-color palette (16 extra OSC 4 queries).
+  
+      @default true
+      */
+  palette?: boolean;
+  /**
+      Which queries to send. `"full"` asks everything; `"dynamic"` asks only the
+      facts that change over a session — colors/theme and pixel geometry — and
+      is what `refreshTerminalQuery` uses. Mode support, protocol support, and
+      the terminal's identity are static and never need re-asking.
+  
+      @default "full"
+      */
+  scope?: "full" | "dynamic";
+};
+/**
+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.
+*/
+declare const queryTerminal: (stdin: NodeJS.ReadableStream, stdout: {
+  write: (data: string) => unknown;
+}, { timeout, palette, scope }?: TerminalQueryOptions) => Promise<TerminalQueryResult>;
+/**
+The completed query result for a stdout stream, if the query has finished.
+*/
+declare const getTerminalQuery: (stdout: object) => TerminalQueryResult | undefined;
+/**
+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.
+*/
+declare const refreshTerminalQuery: (stdin: NodeJS.ReadableStream, stdout: {
+  write: (data: string) => unknown;
+}, options?: TerminalQueryOptions) => Promise<TerminalQueryResult>;
+/**
+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.
+*/
+declare const applyTerminalQuery: (capabilities: Capabilities, query: TerminalQueryResult) => Capabilities;
+//#endregion
+export { getTerminalQuery as a, applyTerminalQuery as i, TerminalQueryOptions as n, queryTerminal as o, TerminalQueryResult as r, refreshTerminalQuery as s, PixelSize as t };