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

package/dist/color.d.ts

@@ -0,0 +1,21 @@
+import { c as Color, d as RgbColor } from "./color-profile-u0Nhe9Nv.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-C19minOS.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-Bh4yGP6w.d.ts

@@ -0,0 +1,186 @@
+//#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.
+      */
+  size: {
+    columns: number;
+    rows: number;
+    pixels: PixelGeometry | undefined;
+  };
+  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 };

package/dist/detect-BuTXtY6e.js

@@ -0,0 +1,373 @@
+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
+		},
+		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, signalExit as c, detectHyperlinkSupport as i, detectCapabilities as n, detectUnicodeSupport as o, detectColorLevel as r, terminalSize as s, createSupportsColor as t };

package/dist/env-YVw64yZS.js

@@ -0,0 +1,9 @@
+//#region src/env.ts
+const isInCi = Boolean(process.env.CI);
+const isSigilDev = process.env.SIGIL_DEV === "true";
+const isScreenReader = process.env.SIGIL_SCREEN_READER === "true";
+const isWindows = process.platform === "win32";
+const isMacos = process.platform === "darwin";
+const isTty = (stream) => "isTTY" in stream && stream.isTTY === true;
+//#endregion
+export { isTty as a, isSigilDev as i, isMacos as n, isWindows as o, isScreenReader as r, isInCi as t };

package/dist/escapes-CB_6CWOE.d.ts

@@ -0,0 +1,72 @@
+//#region src/ansi/escapes.d.ts
+declare const ESC = "";
+declare const BEL = "";
+declare const DEL = "";
+/** Control Sequence Introducer. */
+declare const CSI = "[";
+/** Operating System Command. */
+declare const OSC = "]";
+/** String Terminator. */
+declare const ST = "\\";
+/** Single-byte C1 forms of CSI and ST. */
+declare const C1_CSI = "›";
+declare const C1_ST = "œ";
+declare const cursorTo: (x: number, y?: number) => string;
+declare const cursorUp: (count?: number) => string;
+declare const cursorDown: (count?: number) => string;
+declare const cursorLeft: string;
+declare const cursorNextLine: string;
+declare const eraseEndLine: string;
+declare const eraseLine: string;
+declare const eraseScreen: string;
+declare const eraseLines: (count: number) => string;
+declare const clearTerminal = "";
+declare const enterAlternativeScreen: string;
+declare const exitAlternativeScreen: string;
+declare const cursorShow: string;
+declare const cursorHide: string;
+type CursorShape = "block" | "underline" | "bar";
+declare const cursorShape: (shape: CursorShape, blinking?: boolean) => string;
+declare const cursorColor: (color: string) => string;
+declare const resetCursorColor = "]112";
+declare const enableBracketedPaste: string;
+declare const disableBracketedPaste: string;
+declare const pasteStart: string;
+declare const pasteEnd: string;
+declare const bsu: string;
+declare const esu: string;
+declare const kittyQuery: string;
+declare const pushKittyKeyboard: (flags: number) => string;
+declare const popKittyKeyboard: string;
+declare const link: (text: string, url: string) => string;
+declare const ansiEscapes: {
+  cursorTo: typeof cursorTo;
+  cursorUp: typeof cursorUp;
+  cursorDown: typeof cursorDown;
+  cursorLeft: string;
+  cursorNextLine: string;
+  eraseEndLine: string;
+  eraseLine: string;
+  eraseScreen: string;
+  eraseLines: typeof eraseLines;
+  clearTerminal: string;
+  enterAlternativeScreen: string;
+  exitAlternativeScreen: string;
+  cursorShow: string;
+  cursorHide: string;
+  cursorShape: typeof cursorShape;
+  cursorColor: typeof cursorColor;
+  resetCursorColor: string;
+  enableBracketedPaste: string;
+  disableBracketedPaste: string;
+  pasteStart: string;
+  pasteEnd: string;
+  bsu: string;
+  esu: string;
+  kittyQuery: string;
+  pushKittyKeyboard: typeof pushKittyKeyboard;
+  popKittyKeyboard: string;
+  link: typeof link;
+};
+//#endregion
+export { exitAlternativeScreen as A, enableBracketedPaste as C, eraseLines as D, eraseLine as E, popKittyKeyboard as F, pushKittyKeyboard as I, resetCursorColor as L, link as M, pasteEnd as N, eraseScreen as O, pasteStart as P, disableBracketedPaste as S, eraseEndLine as T, cursorNextLine as _, CursorShape as a, cursorTo as b, OSC as c, bsu as d, clearTerminal as f, cursorLeft as g, cursorHide as h, CSI as i, kittyQuery as j, esu as k, ST as l, cursorDown as m, C1_CSI as n, DEL as o, cursorColor as p, C1_ST as r, ESC as s, BEL as t, ansiEscapes as u, cursorShape as v, enterAlternativeScreen as w, cursorUp as x, cursorShow as y };

package/dist/geometry-BxXOzJgo.d.ts

@@ -0,0 +1,11 @@
+//#region src/screen/geometry.d.ts
+type Point = {
+  readonly x: number;
+  readonly y: number;
+};
+type Rect = Point & {
+  readonly width: number;
+  readonly height: number;
+};
+//#endregion
+export { Rect as n, Point as t };