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

package/src/input-parser.ts

@@ -1,4 +1,4 @@
-import { ESC, pasteStart, pasteEnd } from "./ansi/escapes.ts";
+import { ESC, pasteStart, pasteEnd } from "#/ansi/escapes.ts";
 
 const escape = ESC;
 

package/src/instances.ts

@@ -4,6 +4,6 @@
 // This map has to be stored in a separate file, because render.js creates instances,
 // but instance.js should delete itself from the map on unmount
 
-import type { Ink } from "./ink.tsx";
+import type { Ink } from "#/ink.tsx";
 
 export const instances = new WeakMap<NodeJS.WritableStream, Ink>();

package/src/kitty-keyboard.ts

@@ -1,3 +1,5 @@
+import { kittyQuery } from "#/ansi/escapes.ts";
+
 // Kitty keyboard protocol flags.
 // @see https://sw.kovidgoyal.net/kitty/keyboard-protocol/
 export const kittyFlags = {
@@ -55,3 +57,129 @@ export type KittyKeyboardOptions = {
   // - 'reportAssociatedText' - Report associated text with key events
   flags?: KittyFlagName[];
 };
+
+const textEncoder = new TextEncoder();
+
+const kittyQueryEscapeByte = 0x1b;
+const kittyQueryOpenBracketByte = 0x5b;
+const kittyQueryQuestionMarkByte = 0x3f;
+const kittyQueryLetterByte = 0x75;
+const zeroByte = 0x30;
+const nineByte = 0x39;
+
+type KittyQueryResponseMatch = { state: "complete"; endIndex: number } | { state: "partial" };
+
+const isDigitByte = (byte: number): boolean => byte >= zeroByte && byte <= nineByte;
+
+const matchKittyQueryResponse = (
+  buffer: number[],
+  startIndex: number,
+): KittyQueryResponseMatch | undefined => {
+  if (
+    buffer[startIndex] !== kittyQueryEscapeByte ||
+    buffer[startIndex + 1] !== kittyQueryOpenBracketByte ||
+    buffer[startIndex + 2] !== kittyQueryQuestionMarkByte
+  ) {
+    return;
+  }
+
+  let index = startIndex + 3;
+  const digitsStartIndex = index;
+  while (index < buffer.length && isDigitByte(buffer[index]!)) {
+    index++;
+  }
+
+  if (index === digitsStartIndex) {
+    return;
+  }
+
+  if (index === buffer.length) {
+    return { state: "partial" };
+  }
+
+  if (buffer[index] === kittyQueryLetterByte) {
+    return { state: "complete", endIndex: index };
+  }
+
+  return;
+};
+
+const hasCompleteKittyQueryResponse = (buffer: number[]): boolean => {
+  for (let index = 0; index < buffer.length; index++) {
+    const match = matchKittyQueryResponse(buffer, index);
+    if (match?.state === "complete") {
+      return true;
+    }
+  }
+
+  return false;
+};
+
+const stripKittyQueryResponsesAndTrailingPartial = (buffer: number[]): number[] => {
+  const keptBytes: number[] = [];
+  let index = 0;
+  while (index < buffer.length) {
+    const match = matchKittyQueryResponse(buffer, index);
+    if (match?.state === "complete") {
+      index = match.endIndex + 1;
+      continue;
+    }
+
+    if (match?.state === "partial") {
+      break;
+    }
+
+    keptBytes.push(buffer[index]!);
+    index++;
+  }
+
+  return keptBytes;
+};
+
+// Query the terminal for kitty keyboard protocol support. The CSI ? u query is
+// safe to send to any terminal — unsupporting terminals simply won't respond,
+// and the 200ms timeout handles that. Stdin bytes that aren't part of the
+// protocol response are re-emitted so they aren't lost from the caller's input
+// pipeline. Returns a cancel function; cancelling (or the timeout firing)
+// means `onSupported` never runs.
+export const detectKittySupport = (
+  stdin: NodeJS.ReadableStream,
+  stdout: { write: (data: string) => unknown },
+  onSupported: () => void,
+): (() => void) => {
+  let responseBuffer: number[] = [];
+
+  const cleanup = (): void => {
+    clearTimeout(timer);
+    stdin.removeListener("data", onData);
+
+    // Re-emit any buffered data that wasn't the protocol response.
+    // Clear responseBuffer afterwards to make cleanup idempotent.
+    const remaining = stripKittyQueryResponsesAndTrailingPartial(responseBuffer);
+    responseBuffer = [];
+    if (remaining.length > 0) {
+      stdin.unshift(Uint8Array.from(remaining));
+    }
+  };
+
+  const onData = (data: Uint8Array | string): void => {
+    const chunk = typeof data === "string" ? textEncoder.encode(data) : data;
+    for (const byte of chunk) {
+      responseBuffer.push(byte);
+    }
+
+    if (hasCompleteKittyQueryResponse(responseBuffer)) {
+      cleanup();
+      onSupported();
+    }
+  };
+
+  // Attach listener before writing the query so that synchronous
+  // or immediate responses are not missed.
+  stdin.on("data", onData);
+  const timer = setTimeout(cleanup, 200);
+
+  stdout.write(kittyQuery);
+
+  return cleanup;
+};

package/src/log-update.ts

@@ -1,5 +1,5 @@
-import { cliCursor } from "./ansi/cursor.ts";
-import { ansiEscapes } from "./ansi/escapes.ts";
+import { cliCursor } from "#/ansi/cursor.ts";
+import { ansiEscapes } from "#/ansi/escapes.ts";
 import {
   type CursorPosition,
   cursorPositionChanged,
@@ -7,9 +7,9 @@ import {
   buildCursorOnlySequence,
   buildReturnToBottomPrefix,
   hideCursorEscape,
-} from "./cursor-position.ts";
+} from "#/cursor-position.ts";
 
-export type { CursorPosition } from "./cursor-position.ts";
+export type { CursorPosition } from "#/cursor-position.ts";
 
 export type LogUpdate = {
   clear: () => void;

package/src/measure-element.ts

@@ -1,4 +1,4 @@
-import { type DOMElement } from "./dom.ts";
+import { type DOMElement } from "#/dom.ts";
 
 type Output = {
   /**

package/src/measure-text.ts

@@ -1,5 +1,5 @@
-import { widestLine } from "./ansi/widest-line.ts";
-import { QuickLru as QuickLRU } from "./quick-lru.ts";
+import { widestLine } from "#/ansi/string-width.ts";
+import { QuickLru as QuickLRU } from "#/quick-lru.ts";
 
 const cache = new QuickLRU<string, Output>({ maxSize: 4096 });
 

package/src/output.ts

@@ -1,12 +1,12 @@
-import { sliceAnsi } from "./ansi/slice.ts";
-import { stringWidth } from "./ansi/string-width.ts";
+import { sliceAnsi } from "#/ansi/slice.ts";
+import { stringWidth } from "#/ansi/string-width.ts";
 import {
   type StyledChar,
   styledCharsFromTokens,
   styledCharsToString,
   tokenize,
-} from "./ansi/tokenize.ts";
-import { type OutputTransformer } from "./render-node-to-output.ts";
+} from "#/ansi/tokenize.ts";
+import { type OutputTransformer } from "#/render-node-to-output.ts";
 
 /**
 "Virtual" output class

package/src/parse-keypress.ts

@@ -1,6 +1,6 @@
 // Copied from https://github.com/enquirer/enquirer/blob/36785f3399a41cd61e9d28d1eb9c2fcd73d69b4c/lib/keypress.js
-import { DEL, ESC } from "./ansi/escapes.ts";
-import { kittyModifiers } from "./kitty-keyboard.ts";
+import { DEL, ESC } from "#/ansi/escapes.ts";
+import { kittyModifiers } from "#/kitty-keyboard.ts";
 
 const textDecoder = new TextDecoder();
 
@@ -396,8 +396,7 @@ export const parseKeypress = (s: Uint8Array | string = ""): ParsedKey => {
 
   if (s instanceof Uint8Array) {
     if (s[0]! > 127 && s[1] === undefined) {
-      (s[0] as unknown as number) -= 128;
-      s = ESC + textDecoder.decode(s);
+      s = ESC + textDecoder.decode(Uint8Array.of(s[0]! - 128));
     } else {
       s = textDecoder.decode(s);
     }
@@ -499,7 +498,7 @@ export const parseKeypress = (s: Uint8Array | string = ""): ParsedKey => {
     // the modifier key bitflag and any meaningless "1;" sequence
     const code = [parts[1], parts[2], parts[4], parts[6]].filter(Boolean).join("");
 
-    const modifier = ((parts[3] || parts[5] || 1) as number) - 1;
+    const modifier = Number(parts[3] || parts[5] || 1) - 1;
 
     // Parse the key modifier
     key.ctrl = !!(modifier & 4);

package/src/parse-stack-line.ts

@@ -1,6 +1,5 @@
 // Derived from `stack-utils` (MIT, Isaac Z. Schlueter, James Talmage),
 // reduced to the `parseLine()` surface Ink's error overview uses.
-import process from "node:process";
 
 export type ParsedStackLine = {
   line?: number;

package/src/patch-console.ts

@@ -60,3 +60,47 @@ export const patchConsole = (callback: Callback): Restore => {
     originalMethods.clear();
   };
 };
+
+// Intercept direct `write` calls on a stream. The write is swallowed and the
+// decoded chunk is handed to `onData`; write callbacks still fire so callers
+// awaiting flushes don't hang.
+export const patchStreamWrite = (
+  stream: NodeJS.WritableStream,
+  onData: (data: string) => void,
+): Restore => {
+  // Keep the unbound reference: restore below must reassign the exact
+  // original function object, not a bound copy.
+  // oxlint-disable-next-line typescript/unbound-method
+  const originalWrite = stream.write;
+
+  const patchedWrite = (
+    chunk: unknown,
+    encodingOrCallback?: unknown,
+    callback?: unknown,
+  ): boolean => {
+    const data =
+      typeof chunk === "string"
+        ? chunk
+        : chunk instanceof Uint8Array
+          ? Buffer.from(chunk).toString()
+          : String(chunk);
+
+    onData(data);
+
+    const done =
+      typeof encodingOrCallback === "function"
+        ? encodingOrCallback
+        : typeof callback === "function"
+          ? callback
+          : undefined;
+    done?.();
+
+    return true;
+  };
+
+  stream.write = patchedWrite;
+
+  return () => {
+    stream.write = originalWrite;
+  };
+};

package/src/reconciler.ts

@@ -1,6 +1,4 @@
-import process from "node:process";
-
-import { createContext, version as reactVersion } from "react";
+import { createContext } from "react";
 import createReconciler, { type ReactContext } from "react-reconciler";
 import { DefaultEventPriority, NoEventPriority } from "react-reconciler/constants.js";
 import * as Scheduler from "scheduler";
@@ -20,27 +18,22 @@ import {
   type TextNode,
   type ElementNames,
   type DOMElement,
-} from "./dom.ts";
-import { type OutputTransformer } from "./render-node-to-output.ts";
-import { styles as applyStyles, type Styles } from "./styles.ts";
-import { Yoga } from "./yoga/index.ts";
+} from "#/dom.ts";
+import { isSigilDev } from "#/env.ts";
+import { type OutputTransformer } from "#/render-node-to-output.ts";
+import { styles as applyStyles, type Styles } from "#/styles.ts";
+import { Yoga } from "#/yoga/index.ts";
+
+import pkg from "../package.json" with { type: "json" };
 
 // We need to conditionally perform devtools connection to avoid
 // accidentally breaking other third-party code.
 // See https://github.com/vadimdemedes/ink/issues/384
 // See https://github.com/vadimdemedes/ink/issues/648
-if (process.env["SIGIL_DEV"] === "true") {
+if (isSigilDev) {
   // Intentionally no warning when the package is missing.
   // SIGIL_DEV may be set for other reasons; devtools is opt-in via installing the package.
-  let isDevtoolsInstalled = false;
-  try {
-    import.meta.resolve("react-devtools-core");
-    isDevtoolsInstalled = true;
-  } catch {}
-
-  if (isDevtoolsInstalled) {
-    await import("./devtools.ts");
-  }
+  await import("#/devtools.ts").catch(() => {});
 }
 
 type AnyObject = Record<string, unknown>;
@@ -138,46 +131,6 @@ type HostContext = {
 
 let currentUpdatePriority = NoEventPriority;
 
-async function loadPackageJson() {
-  const fs = await import("node:fs");
-  const content = fs.readFileSync(new URL("../package.json", import.meta.url), "utf8");
-
-  // oxlint-disable-next-line typescript/no-unsafe-type-assertion
-  const parsedContent = JSON.parse(content) as
-    | {
-        name?: string;
-        version?: string;
-      }
-    | undefined;
-
-  return {
-    name: parsedContent?.name,
-    version: parsedContent?.version,
-  };
-}
-
-let packageInfo = {
-  name: "ink",
-  version: reactVersion,
-};
-
-if (process.env["DEV"] === "true") {
-  try {
-    const loaded = await loadPackageJson();
-    packageInfo = {
-      // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
-      name: loaded.name || packageInfo.name,
-      // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
-      version: loaded.version || packageInfo.version,
-    };
-  } catch (error) {
-    console.warn(
-      "Failed to load package.json in development mode. Falling back to default renderer metadata.",
-      error,
-    );
-  }
-}
-
 export const reconciler = createReconciler<
   ElementNames,
   Props,
@@ -246,7 +199,7 @@ export const reconciler = createReconciler<
   shouldSetTextContent: () => false,
   createInstance(originalType, newProps, rootNode, hostContext) {
     if (hostContext.isInsideText && originalType === "ink-box") {
-      throw new Error(`<Box> can’t be nested inside <Text> component`);
+      throw new Error(`<Box> can't be nested inside <Text> component`);
     }
 
     const type =
@@ -446,6 +399,6 @@ export const reconciler = createReconciler<
   waitForCommitToBeReady() {
     return null;
   },
-  rendererPackageName: packageInfo.name,
-  rendererVersion: packageInfo.version,
+  rendererPackageName: pkg.name,
+  rendererVersion: pkg.version,
 });

package/src/render-background.ts

@@ -1,6 +1,6 @@
-import { colorize } from "./colorize.ts";
-import { type DOMNode } from "./dom.ts";
-import type { Output } from "./output.ts";
+import { colorize } from "#/colorize.ts";
+import { type DOMNode } from "#/dom.ts";
+import type { Output } from "#/output.ts";
 
 export const renderBackground = (x: number, y: number, node: DOMNode, output: Output): void => {
   if (!node.style.backgroundColor) {

package/src/render-border.ts

@@ -1,8 +1,8 @@
-import { chalk } from "./ansi/chalk.ts";
-import { boxes as cliBoxes } from "./boxes.ts";
-import { colorize } from "./colorize.ts";
-import { type DOMNode } from "./dom.ts";
-import type { Output } from "./output.ts";
+import { chalk } from "#/ansi/chalk.ts";
+import { colorize } from "#/colorize.ts";
+import { type DOMNode } from "#/dom.ts";
+import { BOXES } from "#/glyphs.ts";
+import type { Output } from "#/output.ts";
 
 const stylePiece = (segment: string, fg?: string, bg?: string, dim?: boolean): string => {
   let styled = colorize(segment, fg, "foreground");
@@ -20,7 +20,7 @@ export const renderBorder = (x: number, y: number, node: DOMNode, output: Output
     const height = node.yogaNode!.getComputedHeight();
     const box =
       typeof node.style.borderStyle === "string"
-        ? cliBoxes[node.style.borderStyle]
+        ? BOXES[node.style.borderStyle]
         : node.style.borderStyle;
 
     const topBorderColor = node.style.borderTopColor ?? node.style.borderColor;

package/src/render-node-to-output.ts

@@ -1,13 +1,12 @@
-import { widestLine } from "./ansi/widest-line.ts";
-import { type DOMElement } from "./dom.ts";
-import { getMaxWidth } from "./get-max-width.ts";
-import { indentString } from "./indent-string.ts";
-import type { Output } from "./output.ts";
-import { renderBackground } from "./render-background.ts";
-import { renderBorder } from "./render-border.ts";
-import { squashTextNodes } from "./squash-text-nodes.ts";
-import { wrapText } from "./wrap-text.ts";
-import { Yoga } from "./yoga/index.ts";
+import { widestLine } from "#/ansi/string-width.ts";
+import { type DOMElement } from "#/dom.ts";
+import { getMaxWidth } from "#/get-max-width.ts";
+import type { Output } from "#/output.ts";
+import { renderBackground } from "#/render-background.ts";
+import { renderBorder } from "#/render-border.ts";
+import { squashTextNodes } from "#/squash-text-nodes.ts";
+import { wrapText } from "#/wrap-text.ts";
+import { Yoga } from "#/yoga/index.ts";
 
 // If parent container is `<Box>`, text nodes will be treated as separate nodes in
 // the tree and will have their own coordinates in the layout.
@@ -21,7 +20,10 @@ const applyPaddingToText = (node: DOMElement, text: string): string => {
   if (yogaNode) {
     const offsetX = yogaNode.getComputedLeft();
     const offsetY = yogaNode.getComputedTop();
-    text = "\n".repeat(offsetY) + indentString(text, offsetX);
+
+    text =
+      "\n".repeat(offsetY) +
+      (offsetX > 0 ? text.replace(/^(?!\s*$)/gm, " ".repeat(offsetX)) : text);
   }
 
   return text;

package/src/render-to-string.ts

@@ -1,10 +1,10 @@
 import type { ReactNode } from "react";
 import { LegacyRoot } from "react-reconciler/constants.js";
 
-import { createNode, type DOMElement } from "./dom.ts";
-import { reconciler } from "./reconciler.ts";
-import { renderer } from "./renderer.ts";
-import { Yoga } from "./yoga/index.ts";
+import { createNode, type DOMElement } from "#/dom.ts";
+import { reconciler } from "#/reconciler.ts";
+import { renderer } from "#/renderer.ts";
+import { Yoga } from "#/yoga/index.ts";
 
 export type RenderToStringOptions = {
   /**

package/src/render.ts

@@ -1,11 +1,10 @@
-import process from "node:process";
 import { Stream, type Writable } from "node:stream";
 
 import type { ReactNode } from "react";
 
-import { Ink, type Options as InkOptions, type RenderMetrics } from "./ink.tsx";
-import { instances } from "./instances.ts";
-import { type KittyKeyboardOptions } from "./kitty-keyboard.ts";
+import { createInk, type Ink, type Options as InkOptions, type RenderMetrics } from "#/ink.tsx";
+import { instances } from "#/instances.ts";
+import { type KittyKeyboardOptions } from "#/kitty-keyboard.ts";
 
 export type RenderOptions = {
   /**
@@ -122,7 +121,7 @@ export type RenderOptions = {
   /**
 	Override automatic interactive mode detection.
 
-	By default, Ink detects whether the environment is interactive based on CI detection (via [`is-in-ci`](https://github.com/sindresorhus/is-in-ci)) and `stdout.isTTY`. Most users should not need to set this.
+	By default, Ink detects whether the environment is interactive based on CI detection (the `CI` environment variable) and `stdout.isTTY`. Most users should not need to set this.
 
 	When non-interactive, Ink disables ANSI erase sequences, cursor manipulation, synchronized output, resize handling, and kitty keyboard auto-detection, writing only the final frame at unmount.
 
@@ -226,20 +225,20 @@ export const render = (node: ReactNode, options?: Writable | RenderOptions): Ins
     ...getOptions(options),
   };
 
-  const instance: Ink = getInstance(inkOptions.stdout, () => new Ink(inkOptions));
+  const instance: Ink = getInstance(inkOptions.stdout, () => createInk(inkOptions));
   instance.render(node);
 
   return {
-    rerender: instance.render.bind(instance),
+    rerender: instance.render,
     unmount() {
       instance.unmount();
     },
-    waitUntilExit: instance.waitUntilExit.bind(instance),
-    waitUntilRenderFlush: instance.waitUntilRenderFlush.bind(instance),
+    waitUntilExit: instance.waitUntilExit,
+    waitUntilRenderFlush: instance.waitUntilRenderFlush,
     cleanup() {
       instance.unmount();
     },
-    clear: instance.clear.bind(instance),
+    clear: instance.clear,
   };
 };
 

package/src/renderer.ts

@@ -1,6 +1,6 @@
-import { type DOMElement } from "./dom.ts";
-import { Output } from "./output.ts";
-import { renderNodeToOutput, renderNodeToScreenReaderOutput } from "./render-node-to-output.ts";
+import { type DOMElement } from "#/dom.ts";
+import { Output } from "#/output.ts";
+import { renderNodeToOutput, renderNodeToScreenReaderOutput } from "#/render-node-to-output.ts";
 
 type Result = {
   output: string;

package/src/sanitize-ansi.ts

@@ -1,4 +1,4 @@
-import { hasAnsiControlCharacters, tokenizeAnsi } from "./ansi-tokenizer.ts";
+import { hasAnsiControlCharacters, tokenizeAnsi } from "#/ansi-tokenizer.ts";
 
 const sgrParametersRegex = /^[\d:;]*$/;
 

package/src/signal-exit.ts

@@ -4,7 +4,7 @@
 // Handlers receive `null` (not `undefined`) like the original package did —
 // Ink's unmount() relies on that to detect process shutdown.
 /* eslint-disable @typescript-eslint/no-restricted-types */
-import process from "node:process";
+import { isWindows } from "#/env.ts";
 
 type ExitHandler = (code: number | null, signal: NodeJS.Signals | null) => void;
 
@@ -13,10 +13,9 @@ type Registration = {
   alwaysLast: boolean;
 };
 
-const signals: NodeJS.Signals[] =
-  process.platform === "win32"
-    ? ["SIGHUP", "SIGINT", "SIGTERM", "SIGBREAK"]
-    : ["SIGHUP", "SIGINT", "SIGTERM", "SIGQUIT", "SIGUSR2"];
+const signals: NodeJS.Signals[] = isWindows
+  ? ["SIGHUP", "SIGINT", "SIGTERM", "SIGBREAK"]
+  : ["SIGHUP", "SIGINT", "SIGTERM", "SIGQUIT", "SIGUSR2"];
 
 const registrations = new Set<Registration>();
 const signalListeners = new Map<NodeJS.Signals, () => void>();

package/src/squash-text-nodes.ts

@@ -1,5 +1,5 @@
-import { type DOMElement } from "./dom.ts";
-import { sanitizeAnsi } from "./sanitize-ansi.ts";
+import { type DOMElement } from "#/dom.ts";
+import { sanitizeAnsi } from "#/sanitize-ansi.ts";
 
 // Squashing text nodes allows to combine multiple text nodes into one and write
 // to `Output` instance only once. For example, <Text>hello{' '}world</Text>

package/src/stream.ts

@@ -1,3 +1,5 @@
+import { isTty } from "#/env.ts";
+
 export type OutputStream = NodeJS.WritableStream & {
   isTTY?: boolean;
   columns?: number;
@@ -13,10 +15,6 @@ type RawModeStream = NodeJS.ReadableStream & {
   unref?: () => void;
 };
 
-export const isTty = (stream: NodeJS.ReadableStream): boolean => {
-  return "isTTY" in stream && stream.isTTY === true;
-};
-
 const isRawModeStream = (stdin: NodeJS.ReadableStream): stdin is RawModeStream => {
   return isTty(stdin) && "setRawMode" in stdin && typeof stdin.setRawMode === "function";
 };

package/src/styles.ts

@@ -1,7 +1,7 @@
-import { type ForegroundColorName } from "./ansi/sgr.ts"; // Note: We import directly from `ansi-styles` to avoid a bug in TypeScript.
-import { type Boxes, type BoxStyle } from "./boxes.ts";
-import { type LiteralUnion } from "./types.ts";
-import { Yoga, type Node as YogaNode, type PositionType } from "./yoga/index.ts";
+import { type ForegroundColorName } from "#/ansi/sgr.ts";
+import { type BoxGlyphs, type BoxStyle } from "#/glyphs.ts";
+import { type LiteralUnion } from "#/types.ts";
+import { Yoga, type Node as YogaNode, type PositionType } from "#/yoga/index.ts";
 
 export type Styles = {
   /*
@@ -134,7 +134,7 @@ export type Styles = {
   readonly flexGrow?: number;
 
   /**
-	It specifies the “flex shrink factor”, which determines how much the flex item will shrink relative to the rest of the flex items in the flex container when there isn’t enough space on the row.
+	It specifies the “flex shrink factor”, which determines how much the flex item will shrink relative to the rest of the flex items in the flex container when there isn't enough space on the row.
 	See [flex-shrink](https://css-tricks.com/almanac/properties/f/flex-shrink/).
 	*/
   readonly flexShrink?: number;
@@ -241,7 +241,7 @@ export type Styles = {
   /**
 	Add a border with a specified style. If `borderStyle` is `undefined` (the default), no border will be added.
 	*/
-  readonly borderStyle?: keyof Boxes | BoxStyle;
+  readonly borderStyle?: BoxStyle | BoxGlyphs;
 
   /**
 	Determines whether the top border is visible.