npm - termcut - Versions diffs - 0.7.1 → 0.7.3 - Mend

termcut 0.7.1 → 0.7.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

package/README.md CHANGED Viewed

@@ -10,7 +10,7 @@ Turn a terminal session into a video. Record it live or script it in TypeScript;
 bun add -g termcut     # Bun ≥ 1.4 · installs the `tcut` command
 ```
-Standalone binaries for macOS, Linux and Windows: [Releases](https://github.com/AmanVarshney01/tcut/releases). MP4/GIF need `ffmpeg`; SVG/HTML don't. Linux renders pixels through Chrome/Chromium on the PATH.
+Standalone binaries for macOS, Linux and Windows (all tested in CI): [Releases](https://github.com/AmanVarshney01/tcut/releases). MP4/GIF need `ffmpeg`; SVG/HTML don't. Linux and Windows render pixels through Chrome/Chromium.
 ## Use

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "termcut",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "description": "Script terminal sessions in TypeScript, render them to reproducible MP4/GIF/WebM/SVG/HTML with Bun.",
   "license": "MIT",
   "author": "Aman Varshney",

package/scripts/probe-webview.ts ADDED Viewed

@@ -0,0 +1,39 @@
+// Diagnostic: how does Bun.WebView behave on this machine? Prints backend, navigation, evaluate and screenshot
+// timings for a local page. `bun scripts/probe-webview.ts` (TCUT_DEBUG_CHROME=1 shows Chrome's stderr).
+import { createWebView, webViewBackend } from "../src/renderer/view";
+const t0 = performance.now();
+const at = () => `${((performance.now() - t0) / 1000).toFixed(3)}s`;
+const log = (m: string) => console.log(`${at()} ${m}`);
+const timed = async <T>(label: string, p: Promise<T>, ms = 8000): Promise<T | undefined> => {
+  try {
+    const v = await Promise.race([p, Bun.sleep(ms).then(() => Promise.reject(new Error(`timeout ${ms}ms`)))]);
+    log(`${label}: ok ${JSON.stringify(v)?.slice(0, 80) ?? ""}`);
+    return v;
+  } catch (cause) {
+    log(`${label}: FAILED ${cause instanceof Error ? cause.message : String(cause)}`);
+    return undefined;
+  }
+};
+const server = Bun.serve({ port: 0, hostname: "127.0.0.1", fetch: () => new Response("<html><body><h1 id=t>first</h1><button onclick=\"t.textContent='clicked'\">go</button></body></html>", { headers: { "content-type": "text/html" } }) });
+const url = `http://127.0.0.1:${server.port}/`;
+log(`platform ${process.platform} backend ${JSON.stringify(webViewBackend())}`);
+const view = createWebView({ width: 320, height: 240 });
+log(`view created; url=${JSON.stringify(view.url)} loading=${view.loading}`);
+const nav = view.navigate(url).then(() => "ok", (cause: unknown) => `rejected: ${cause instanceof Error ? cause.message : String(cause)}`);
+for (let i = 0; i < 6; i++) {
+  await Bun.sleep(250);
+  log(`tick ${i}: url=${JSON.stringify(view.url)} loading=${view.loading}`);
+}
+await timed("navigate", nav, 5000);
+await timed("evaluate readyState", view.evaluate("document.readyState"));
+await timed("evaluate innerText", view.evaluate("document.body ? document.body.innerText : ''"));
+const shot = await timed("screenshot", view.screenshot({ encoding: "buffer" }));
+log(`screenshot bytes: ${shot ? (shot as Uint8Array).length : "none"}`);
+await timed("click", view.click("button"), 5000);
+await timed("evaluate after click", view.evaluate("document.body.innerText"));
+await timed("screenshot 2", view.screenshot({ encoding: "buffer" }));
+log(`final url=${JSON.stringify(view.url)} loading=${view.loading}`);
+view.close();
+server.stop(true);

package/src/browser.ts CHANGED Viewed

@@ -48,6 +48,18 @@ export function startBrowserCapture(config: ResolvedConfig, stamp: () => number,
   // Sampling starts once a page has loaded: headless Chrome never resolves a screenshot of the initial blank
   // view, and a hung screenshot blocks every later command on that view.
   let loaded = false;
+  /** Extra time allowed while the browser has never answered: a cold Chrome on a fresh Windows runner can take 20–40 s. */
+  const STARTUP_GRACE = 45_000;
+  const startedAt = performance.now();
+  let startupNoted = false;
+  const startupDeadline = (deadline: number): number => {
+    if (loaded) return deadline;
+    if (!startupNoted && performance.now() > startedAt + 5000) {
+      startupNoted = true;
+      log("waiting for the browser to start…");
+    }
+    return Math.max(deadline, startedAt + STARTUP_GRACE);
+  };
   // A view runs one evaluate() at a time; goto's probes, waitFor and the script's own evaluate calls take turns.
   let chain: Promise<unknown> = Promise.resolve();
   const serial = <T,>(fn: () => Promise<T>): Promise<T> => {
@@ -58,7 +70,13 @@ export function startBrowserCapture(config: ResolvedConfig, stamp: () => number,
     );
     return next;
   };
-  const evaluate = (js: string, ms: number, label: string): Promise<unknown> => serial(() => within(view.evaluate(js), ms, label));
+  // A page that answers an evaluate is a page worth sampling (view.loading is not reliable on every backend).
+  const evaluate = (js: string, ms: number, label: string): Promise<unknown> =>
+    serial(async () => {
+      const result = await within(view.evaluate(js), ms, label);
+      loaded = true;
+      return result;
+    });
   // One screenshot at a time: the periodic sampler and the event-driven samples (after waitFor, at stop) share it.
   let sampling: Promise<void> | null = null;
   const sampleOnce = (): Promise<void> => {
@@ -79,6 +97,11 @@ export function startBrowserCapture(config: ResolvedConfig, stamp: () => number,
     })();
     return sampling;
   };
+  /** A sample taken after this moment: waits out any in-flight screenshot (seconds on a cold Chrome), then takes a fresh one. */
+  const sampleNow = async (): Promise<void> => {
+    if (sampling) await sampling;
+    await sampleOnce();
+  };
   const sampler = (async () => {
     while (running) {
       await sampleOnce();
@@ -114,16 +137,16 @@ export function startBrowserCapture(config: ResolvedConfig, stamp: () => number,
       }
       if (outcome === "failed") navigation = null;
       if (!running) return;
-      const state = await evaluate("document.readyState", 3000, "goto").catch(() => "");
-      // Some backends leave view.url empty; then a complete document is the best signal we have.
+      // No evaluate() here: the view's own loading flag and URL say whether the page arrived (some backends keep
+      // the navigate() promise pending long after the page is up, and may leave view.url empty).
       const href = (view.url ?? "").replace(/\/$/, "");
-      if (state === "complete" && (href === "" || href.startsWith(target))) {
+      if (outcome === "tick" && (href.startsWith(target) || (!view.loading && href === ""))) {
         currentUrl = url;
         loaded = true;
         return;
       }
-      if (performance.now() > deadline) {
-        throw new WaitTimeoutError(`browser.goto(${url})`, config.waitTimeout, `current url: ${view.url ?? "(none)"}, readyState: ${state || "unknown"}`);
+      if (performance.now() > startupDeadline(deadline)) {
+        throw new WaitTimeoutError(`browser.goto(${url})`, config.waitTimeout, `current url: ${view.url ?? "(none)"}, loading: ${view.loading}`);
       }
       await Bun.sleep(250);
     }
@@ -143,10 +166,10 @@ export function startBrowserCapture(config: ResolvedConfig, stamp: () => number,
         const text = String((await evaluate("document.body ? document.body.innerText : ''", 5000, "waitFor").catch(() => "")) ?? "");
         if (regex.test(text)) {
           loaded = true; // a page that answers is a page worth sampling, even if navigate() has not settled yet
-          await sampleOnce(); // the frame the script waited for, captured the moment it appeared
+          await sampleNow(); // the frame the script waited for, captured the moment it appeared
           return;
         }
-        if (performance.now() > deadline) throw new WaitTimeoutError(`${regex} in the browser page`, timeout, text.slice(0, 2000));
+        if (performance.now() > startupDeadline(deadline)) throw new WaitTimeoutError(`${regex} in the browser page`, timeout, text.slice(0, 2000));
         await Bun.sleep(150);
       }
     },
@@ -163,9 +186,12 @@ export function startBrowserCapture(config: ResolvedConfig, stamp: () => number,
     reload: () => within(view.reload(), 30000, "reload").catch((err) => (/pending/i.test(String(err)) ? undefined : Promise.reject(err))),
     evaluate: (js) => evaluate(js, 10000, "evaluate"),
     async stop() {
+      // A session shorter than the browser's start-up (cold Chrome on CI) should still show the page once.
+      if (frames.length === 0 && initialLoad) await Promise.race([initialLoad, Bun.sleep(Math.max(0, startupDeadline(0) - performance.now()))]);
+      if (!loaded && bcfg.url) await evaluate("document.readyState", 2000, "probe").catch(() => undefined); // marks loaded if the page answers
       running = false;
       await sampler;
-      await sampleOnce(); // final state of the page
+      await sampleNow(); // final state of the page
       try {
         view.close();
       } catch {
@@ -174,6 +200,6 @@ export function startBrowserCapture(config: ResolvedConfig, stamp: () => number,
     },
   };
-  if (bcfg.url) void goto(bcfg.url).catch((err) => log(String(err)));
+  const initialLoad = bcfg.url ? goto(bcfg.url).catch((err) => log(String(err))) : null;
   return capture;
 }

package/src/cli.ts CHANGED Viewed

@@ -15,7 +15,7 @@ import { renderOutputs } from "./render";
 import { generateScript } from "./scriptgen";
 import { runScriptTests, type TestSummary } from "./testing";
 import { findThemes, themeNames } from "./themes";
-import type { BrowserConfig, ClipSelection, CoreName, ThemeName, VideoConfig, WindowBar } from "./types";
+import type { BrowserConfig, ClipSelection, CoreName, Recording, ResolvedConfig, ThemeName, VideoConfig, WindowBar } from "./types";
 import { Video, attachBrowserFrames, castConfig, isVideo, renderCast } from "./video";
 // Let user scripts `import { defineVideo } from "tcut"` (or "termcut", the npm package name) regardless of
@@ -524,13 +524,13 @@ async function main(): Promise<void> {
       const castOut = values.cast ?? (joining ? path.join(path.dirname(rest[0]!), "concat.cast") : rest[0]!.replace(/\.cast$/, "") + "-cut.cast");
       const overrides = overridesFromFlags();
       delete overrides.cast;
-      const parts: Array<{ rec: Awaited<ReturnType<typeof readCast>>; config: ReturnType<typeof castConfig> }> = [];
+      const parts: Array<{ rec: Recording; config: ResolvedConfig }> = [];
       for (const [i, file] of rest.entries()) {
         const rec = await readCast(file);
         const config = applyOverrides(castConfig(rec, file, values.output), overrides);
         parts.push({ rec: await rebaseBrowserFrames(rec, file, castOut, joining ? `${i}-` : ""), config });
       }
-      let out: Awaited<ReturnType<typeof readCast>>;
+      let out: Recording;
       if (joining) {
         out = concatRecordings(parts, { gap: seconds("gap") ?? 0 });
       } else {

package/src/config.ts CHANGED Viewed

@@ -114,6 +114,7 @@ export function resolveConfig(input: VideoConfig): ResolvedConfig {
     quantize: config.quantize ?? false,
     core: config.core ?? "ghostty",
     cache: config.cache ?? true,
+    requires: config.requires ?? [],
     font,
     theme,
     cursor: {

package/src/errors.ts CHANGED Viewed

@@ -7,6 +7,16 @@ export class WaitTimeoutError extends Error {
   }
 }
+/** A program named in `requires` is not on the PATH — raised before the shell is even started. */
+export class MissingRequirementError extends Error {
+  constructor(readonly missing: string[]) {
+    super(
+      `${missing.length === 1 ? `\`${missing[0]}\` is` : `${missing.map((m) => `\`${m}\``).join(", ")} are`} not on the PATH. Install ${missing.length === 1 ? "it" : "them"}, or remove ${missing.length === 1 ? "it" : "them"} from \`requires\`.`,
+    );
+    this.name = "MissingRequirementError";
+  }
+}
 export class ExpectationError extends Error {
   constructor(what: string, screen: string) {
     super(`Expected ${what} to match.\n\n--- screen ---\n${screen}\n--------------`);

package/src/index.ts CHANGED Viewed

@@ -26,5 +26,5 @@ export type { DiffOptions, DiffResult } from "./diff";
 export { keyLabels, keyChips } from "./keylabels";
 export { startBrowserCapture } from "./browser";
 export { resolveConfig } from "./config";
-export { WaitTimeoutError, ExpectationError } from "./recorder";
+export { WaitTimeoutError, ExpectationError, MissingRequirementError } from "./recorder";
 export type * from "./types";

package/src/recorder.ts CHANGED Viewed

@@ -2,7 +2,7 @@ import { MarkdownRenderer } from "@wterm/markdown";
 import { startBrowserCapture, type BrowserCapture } from "./browser";
 import { MARKER } from "./cast";
 import { toMs } from "./duration";
-import { ExpectationError, WaitTimeoutError } from "./errors";
+import { ExpectationError, MissingRequirementError, WaitTimeoutError } from "./errors";
 import { altSequence, ctrlSequence, keySequence, shiftSequence, wheelSequence } from "./keys";
 import { Screen } from "./screen";
 import type {
@@ -20,7 +20,7 @@ import type {
   WaitOptions,
 } from "./types";
-export { WaitTimeoutError, ExpectationError } from "./errors";
+export { WaitTimeoutError, ExpectationError, MissingRequirementError } from "./errors";
 /** Deterministic PRNG (mulberry32) so typing jitter is reproducible. */
 function mulberry32(seed: number): () => number {
@@ -103,6 +103,8 @@ export function defaultLang(): string {
 /** Drives a Bun.Terminal PTY according to a script and produces an asciicast recording. */
 export async function record(config: ResolvedConfig, script: Script, opts: RecordOptions = {}): Promise<Recording> {
   const log = opts.log ?? (() => {});
+  const missing = config.requires.filter((name) => Bun.which(name) === null);
+  if (missing.length > 0) throw new MissingRequirementError(missing);
   const events: CastEvent[] = [];
   const screen = await Screen.create(config.cols, config.rows, { core: config.core });
   const fast = opts.fast === true;

package/src/renderer/bundle.ts CHANGED Viewed

@@ -43,8 +43,8 @@ async function embeddedAssets(): Promise<PageAssets | null> {
   }
 }
-/** True inside a `bun build --compile` binary, where sources live on the virtual /$bunfs filesystem. */
-const isCompiled = import.meta.dir.startsWith("/$bunfs");
+/** True inside a `bun build --compile` binary (sources then live on a virtual filesystem: /$bunfs, or B:\~BUN on Windows). */
+const isCompiled = Bun.isStandaloneExecutable;
 /**
  * Prebuilt assets in the compiled binary; otherwise built at runtime with Bun.build so edits to the page entries

package/src/renderer/png.ts CHANGED Viewed

@@ -1,7 +1,7 @@
 // A minimal PNG codec for the renderer. Bun.WebView screenshots come in as opaque PNGs and Bun.Image has no raw
 // pixel access, so transparent output needs its own decode → matte → encode step. 8-bit RGB/RGBA, non-interlaced.
-// node:zlib rather than Bun.inflateSync/deflateSync: PNG needs zlib-framed streams and Bun's defaults are raw deflate.
-import { deflateSync, inflateSync } from "node:zlib";
+// PNG streams are zlib-framed; Bun's inflateSync reads that with windowBits 15, and deflateSync's raw output gets the
+// two-byte header and Adler-32 trailer added here (Bun only — no node:zlib).
 /** Straight (non-premultiplied) RGBA pixels, row-major. */
 export interface RgbaImage {
@@ -16,8 +16,31 @@ const SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10];
 const readU32 = (b: Uint8Array, o: number): number => ((b[o]! << 24) | (b[o + 1]! << 16) | (b[o + 2]! << 8) | b[o + 3]!) >>> 0;
-function concat(parts: Uint8Array[]): Uint8Array {
-  const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+function adler32(bytes: Uint8Array): number {
+  let a = 1;
+  let b = 0;
+  for (let i = 0; i < bytes.length; i++) {
+    a = (a + bytes[i]!) % 65521;
+    b = (b + a) % 65521;
+  }
+  return ((b << 16) | a) >>> 0;
+}
+/** Raw DEFLATE from Bun.deflateSync wrapped as a zlib stream (RFC 1950): CMF/FLG header + data + Adler-32. */
+function zlibDeflate(raw: Uint8Array<ArrayBuffer>, level: 1 | 6 = 1): Uint8Array {
+  const body = Bun.deflateSync(raw, { level });
+  const out = new Uint8Array(2 + body.length + 4);
+  out[0] = 0x78;
+  out[1] = level === 1 ? 0x01 : 0x9c;
+  out.set(body, 2);
+  new DataView(out.buffer).setUint32(2 + body.length, adler32(raw));
+  return out;
+}
+const zlibInflate = (data: Uint8Array<ArrayBuffer>): Uint8Array => Bun.inflateSync(data, { windowBits: 15 });
+function concat(parts: Uint8Array[]): Uint8Array<ArrayBuffer> {
+  const out = new Uint8Array(new ArrayBuffer(parts.reduce((n, p) => n + p.length, 0)));
   let o = 0;
   for (const p of parts) {
     out.set(p, o);
@@ -83,7 +106,7 @@ export function decodePng(png: Uint8Array): RgbaImage {
   }
   const bpp = colorType === 6 ? 4 : 3;
   const stride = width * bpp;
-  const raw = inflateSync(concat(idat));
+  const raw = zlibInflate(concat(idat));
   const out = new Uint8Array(width * height * 4);
   let prev = new Uint8Array(stride);
   let row = new Uint8Array(stride);
@@ -133,7 +156,7 @@ function chunk(type: string, data: Uint8Array): Uint8Array {
 /** Encode straight RGBA as an 8-bit PNG (filter 0; speed matters more than size — ffmpeg re-encodes anyway). */
 export function encodePng(img: RgbaImage): Uint8Array {
   const stride = img.width * 4;
-  const raw = new Uint8Array((stride + 1) * img.height);
+  const raw = new Uint8Array(new ArrayBuffer((stride + 1) * img.height));
   for (let y = 0; y < img.height; y++) {
     raw[y * (stride + 1)] = 0;
     raw.set(img.data.subarray(y * stride, (y + 1) * stride), y * (stride + 1) + 1);
@@ -144,7 +167,7 @@ export function encodePng(img: RgbaImage): Uint8Array {
   v.setUint32(4, img.height);
   ihdr[8] = 8; // bit depth
   ihdr[9] = 6; // RGBA
-  return concat([new Uint8Array(SIGNATURE), chunk("IHDR", ihdr), chunk("IDAT", deflateSync(raw, { level: 1 })), chunk("IEND", new Uint8Array(0))]);
+  return concat([new Uint8Array(SIGNATURE), chunk("IHDR", ihdr), chunk("IDAT", zlibDeflate(raw)), chunk("IEND", new Uint8Array(0))]);
 }
 export function parseHex(color: string): Rgb {

package/src/scriptgen.ts CHANGED Viewed

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { keySequence } from "./keys";
 import type { Recording } from "./types";
 export interface ScriptGenOptions {
@@ -20,7 +21,9 @@ type Op =
   | { kind: "key"; name: string; times: number }
   | { kind: "ctrl"; letter: string; times: number }
   | { kind: "alt"; key: string; times: number }
-  | { kind: "raw"; data: string }
+  | { kind: "fkey"; name: string; times: number }
+  | { kind: "shift"; key: string; times: number }
+  | { kind: "raw"; data: string; comment?: string }
   | { kind: "sleep"; ms: number };
 const NAMED = new Map<string, string>([
@@ -46,6 +49,35 @@ const NAMED = new Map<string, string>([
   ["\x1b[6~", "pageDown"],
 ]);
+/** F-keys by the bytes a terminal sends (`ESC O P` … `ESC [24~`), so they replay as `t.key("f5")`: one write, never ESC + key. */
+const FKEYS = new Map(Array.from({ length: 12 }, (_, i) => [keySequence(`f${i + 1}` as `f${1}`), `f${i + 1}`] as const));
+const MODIFIER_NAMES = new Map([
+  ["2", "shift"],
+  ["3", "alt"],
+  ["5", "ctrl"],
+  ["6", "ctrl+shift"],
+  ["7", "ctrl+alt"],
+]);
+const MODIFIED_KEYS = new Map([
+  ["A", "up"],
+  ["B", "down"],
+  ["C", "right"],
+  ["D", "left"],
+  ["H", "home"],
+  ["F", "end"],
+]);
+/** `ESC [1;3D` → { modifier: "alt", key: "left" } (xterm modifier encoding), or null. */
+function modifiedKey(token: string): { modifier: string; key: string } | null {
+  if (!token.startsWith("\x1b[1;")) return null;
+  const m = /^(\d)([A-DHF])$/.exec(token.slice(4));
+  if (!m) return null;
+  const modifier = MODIFIER_NAMES.get(m[1]!);
+  const key = MODIFIED_KEYS.get(m[2]!);
+  return modifier && key ? { modifier, key } : null;
+}
 /** Split a raw input chunk into individual key tokens (escape sequences, control chars, printable runs). */
 export function tokenize(input: string): string[] {
   const tokens: string[] = [];
@@ -160,8 +192,12 @@ export function eventsToOps(rec: Recording, opts: ScriptGenOptions): Op[] {
         pushKey({ kind: "ctrl", letter, times: 1 });
       } else if (token.length === 2 && token[0] === "\x1b") {
         pushKey({ kind: "alt", key: token[1]!, times: 1 });
+      } else if (FKEYS.has(token)) {
+        pushKey({ kind: "fkey", name: FKEYS.get(token)!, times: 1 });
       } else {
-        ops.push({ kind: "raw", data: token });
+        const mod = modifiedKey(token);
+        if (mod?.modifier === "shift") pushKey({ kind: "shift", key: mod.key, times: 1 });
+        else ops.push({ kind: "raw", data: token, ...(mod && { comment: `${mod.modifier}+${mod.key}` }) });
       }
     }
   }
@@ -186,8 +222,12 @@ function opToLine(op: Op): string {
       return op.times > 1 ? `await t.ctrl(${q(op.letter)}, ${op.times});` : `await t.ctrl(${q(op.letter)});`;
     case "alt":
       return op.times > 1 ? `await t.alt(${q(op.key)}, ${op.times});` : `await t.alt(${q(op.key)});`;
+    case "fkey":
+      return op.times > 1 ? `await t.key(${q(op.name)}, ${op.times});` : `await t.key(${q(op.name)});`;
+    case "shift":
+      return op.times > 1 ? `await t.shift(${q(op.key)}, ${op.times});` : `await t.shift(${q(op.key)});`;
     case "raw":
-      return `await t.raw(${q(op.data)});`;
+      return `await t.raw(${q(op.data)});${op.comment ? ` // ${op.comment}` : ""}`;
     case "sleep":
       return `await t.sleep(${formatMs(op.ms)});`;
   }

package/src/testing.ts CHANGED Viewed

@@ -45,7 +45,7 @@ export async function runScriptTests(inputs: string[], log: (line: string) => vo
   const results: TestResult[] = [];
   log(`TAP version 14\n1..${files.length}`);
   for (const [index, file] of files.entries()) {
-    const rel = path.relative(process.cwd(), file);
+    const rel = path.relative(process.cwd(), file).split(path.sep).join("/"); // stable TAP output on every platform
     const started = performance.now();
     let error: string | undefined;
     try {

package/src/types.ts CHANGED Viewed

@@ -205,6 +205,8 @@ export interface VideoConfig {
   core?: CoreName;
   /** Reuse the existing cast when the script and record config are unchanged. Default true. */
   cache?: boolean;
+  /** Programs the script needs on the PATH (`["bun", "eza"]`). Checked before the shell starts; missing ones fail fast with a clear message. */
+  requires?: string[];
   font?: FontConfig;
   theme?: ThemeName | Theme;
@@ -257,6 +259,7 @@ export interface ResolvedConfig {
   quantize: boolean;
   core: CoreName;
   cache: boolean;
+  requires: string[];
   font: Required<FontConfig>;
   theme: Theme;
   cursor: Required<CursorConfig>;