@simon_he/vue-tui 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,684 @@
+import ansiStyles from "ansi-styles";
+import * as vue1 from "vue";
+import * as vue2 from "vue";
+import { App, Component as Component$1, ComputedRef, Ref, VNode } from "vue";
+
+//#region src/events/recording.d.ts
+type TerminalEventRecord = Readonly<{
+  type: 'keydown' | 'keyup';
+  key: string;
+  code?: string;
+  ctrlKey?: boolean;
+  shiftKey?: boolean;
+  altKey?: boolean;
+  metaKey?: boolean;
+  repeat?: boolean;
+  time?: number;
+}> | Readonly<{
+  type: 'pointerdown' | 'pointerup' | 'pointermove' | 'click' | 'dblclick' | 'contextmenu';
+  cellX: number;
+  cellY: number;
+  clientX?: number;
+  clientY?: number;
+  button?: number;
+  buttons?: number;
+  ctrlKey?: boolean;
+  shiftKey?: boolean;
+  altKey?: boolean;
+  metaKey?: boolean;
+  time?: number;
+}> | Readonly<{
+  type: 'wheel';
+  cellX: number;
+  cellY: number;
+  clientX?: number;
+  clientY?: number;
+  deltaY: number;
+  ctrlKey?: boolean;
+  shiftKey?: boolean;
+  altKey?: boolean;
+  metaKey?: boolean;
+  time?: number;
+}> | Readonly<{
+  type: 'beforeinput' | 'input' | 'compositionstart' | 'compositionupdate' | 'compositionend' | 'paste';
+  data?: string;
+  inputType?: string;
+  isComposing?: boolean;
+  text?: string;
+  time?: number;
+}>; //#endregion
+//#region src/cli/input.d.ts
+type Stdin = NodeJS.ReadStream;
+type StdinDriver = Readonly<{
+  dispose: () => void;
+}>;
+declare function createStdinDriver(options: Readonly<{
+  dispatch: (event: TerminalEventRecord) => void;
+  stdin?: Stdin;
+  stdout?: NodeJS.WriteStream;
+  enableMouse?: boolean;
+  onExit?: () => void;
+}>): StdinDriver;
+
+//#endregion
+//#region src/cli/path-provider.d.ts
+type FsEntryKind = 'file' | 'directory' | 'other';
+type FsDirEntry = Readonly<{
+  name: string;
+  kind: FsEntryKind;
+}>;
+type FsStat = Readonly<{
+  exists: boolean;
+  kind: FsEntryKind;
+}>;
+type PathPickerProvider = Readonly<{
+  listDir: (absDir: string) => Promise<FsDirEntry[]>;
+  stat: (absPath: string) => Promise<FsStat>;
+}>;
+declare function createNodePathPickerProvider(): PathPickerProvider;
+
+//#endregion
+//#region src/cli/recording.d.ts
+declare function writeEventLog(path: string, events: readonly TerminalEventRecord[]): Promise<void>;
+declare function writeSnapshot(path: string, lines: readonly string[]): Promise<void>;
+declare function readEventLog(path: string): Promise<TerminalEventRecord[]>;
+
+//#endregion
+//#region src/cli/path-suggest.d.ts
+declare function resolveUserPath(workspaceAbs: string, input: string): string;
+
+//#endregion
+//#region src/core/buffer/width.d.ts
+declare function charCellWidth(text: string): 1 | 2;
+
+//#endregion
+//#region src/core/types.d.ts
+type AnsiColorName = 'black' | 'red' | 'green' | 'yellow' | 'blue' | 'magenta' | 'cyan' | 'white' | 'blackBright' | 'redBright' | 'greenBright' | 'yellowBright' | 'blueBright' | 'magentaBright' | 'cyanBright' | 'whiteBright';
+type Style = Readonly<{
+  fg?: AnsiColorName;
+  bg?: AnsiColorName;
+  bold?: boolean;
+  dim?: boolean;
+  italic?: boolean;
+  underline?: boolean;
+  inverse?: boolean;
+}>;
+type Cell = Readonly<{
+  ch: string;
+  width: 1 | 2;
+  continuation?: true;
+  style: Style;
+}>;
+type BufferSnapshot = Readonly<{
+  cols: number;
+  rows: number;
+  lines: readonly string[];
+}>;
+type TerminalCommitEvent = Readonly<{
+  dirtyRows: readonly number[];
+}>;
+type TerminalResizeEvent = Readonly<{
+  cols: number;
+  rows: number;
+}>;
+interface TerminalEventMap {
+  commit: TerminalCommitEvent;
+  resize: TerminalResizeEvent;
+}
+interface Terminal {
+  resize: (cols: number, rows: number) => void;
+  clear: (x?: number, y?: number, w?: number, h?: number) => void;
+  write: (text: string, opts?: {
+    x?: number;
+    y?: number;
+    style?: Style;
+  }) => void;
+  writeAnsi: (text: string, opts?: {
+    x?: number;
+    y?: number;
+  }) => void;
+  put: (x: number, y: number, ch: string, style?: Style) => void;
+  fill: (x: number, y: number, w: number, h: number, ch?: string, style?: Style) => void;
+  scroll: (lines: number) => void;
+  setCursor: (x: number, y: number, visible?: boolean) => void;
+  batch: <T>(fn: () => T) => T;
+  commit: () => readonly number[];
+  on: <K extends keyof TerminalEventMap>(event: K, cb: (payload: TerminalEventMap[K]) => void) => () => void;
+  dispose: () => void;
+  snapshot: () => BufferSnapshot;
+  getCell: (x: number, y: number) => Cell;
+  getRow: (y: number) => readonly Cell[];
+  setScrollbackLimit: (limit: number) => void;
+  getScrollbackLines: (count?: number) => readonly string[];
+}
+
+//#endregion
+//#region src/core/ansi/sgr.d.ts
+interface AnsiSegment {
+  text: string;
+  style: Style;
+}
+declare function parseAnsiSgr(input: string, baseStyle?: Style): AnsiSegment[];
+
+//#endregion
+//#region src/core/terminal/create-terminal.d.ts
+declare function createTerminal(opts: {
+  cols: number;
+  rows: number;
+}): Terminal;
+
+//#endregion
+//#region src/renderer/dom/dom-renderer.d.ts
+type CellMetrics = Readonly<{
+  cellWidth: number;
+  cellHeight: number;
+}>;
+interface DomRenderer {
+  readonly container: HTMLElement;
+  readonly metrics: CellMetrics;
+  dispose: () => void;
+  refresh: () => void;
+}
+declare function createDomRenderer(terminal: Terminal, container: HTMLElement): DomRenderer;
+
+//#endregion
+//#region src/events/manager/types.d.ts
+type Rect = Readonly<{
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+}>;
+type TerminalEventType = 'click' | 'dblclick' | 'contextmenu' | 'pointerdown' | 'pointerup' | 'pointermove' | 'wheel' | 'keydown' | 'keyup' | 'beforeinput' | 'input' | 'compositionstart' | 'compositionupdate' | 'compositionend' | 'paste' | 'focus' | 'blur';
+interface TerminalBaseEvent {
+  type: TerminalEventType;
+  target: TerminalNode | null;
+  currentTarget: TerminalNode | null;
+  eventPhase: 1 | 2 | 3;
+  bubbles: boolean;
+  cancelable: boolean;
+  defaultPrevented: boolean;
+  timeStamp: number;
+  stopPropagation: () => void;
+  preventDefault: () => void;
+  composedPath: () => TerminalNode[];
+  nativeEvent?: Event;
+}
+type TerminalPointerEvent = TerminalBaseEvent & {
+  clientX: number;
+  clientY: number;
+  cellX: number;
+  cellY: number;
+  button?: number;
+  buttons?: number;
+  ctrlKey?: boolean;
+  shiftKey?: boolean;
+  altKey?: boolean;
+  metaKey?: boolean;
+  deltaY?: number;
+};
+type TerminalKeyboardEvent = TerminalBaseEvent & {
+  key: string;
+  code: string;
+  combo: string;
+  ctrlKey?: boolean;
+  shiftKey?: boolean;
+  altKey?: boolean;
+  metaKey?: boolean;
+  repeat?: boolean;
+};
+type TerminalInputEvent = TerminalBaseEvent & {
+  inputType?: string;
+  data?: string;
+  isComposing?: boolean;
+  text?: string;
+};
+type TerminalEventHandlerMap = Partial<{
+  clickCapture: (e: TerminalPointerEvent) => void;
+  click: (e: TerminalPointerEvent) => void;
+  dblclickCapture: (e: TerminalPointerEvent) => void;
+  dblclick: (e: TerminalPointerEvent) => void;
+  contextmenuCapture: (e: TerminalPointerEvent) => void;
+  contextmenu: (e: TerminalPointerEvent) => void;
+  pointerdownCapture: (e: TerminalPointerEvent) => void;
+  pointerdown: (e: TerminalPointerEvent) => void;
+  pointerupCapture: (e: TerminalPointerEvent) => void;
+  pointerup: (e: TerminalPointerEvent) => void;
+  pointermoveCapture: (e: TerminalPointerEvent) => void;
+  pointermove: (e: TerminalPointerEvent) => void;
+  wheelCapture: (e: TerminalPointerEvent) => void;
+  wheel: (e: TerminalPointerEvent) => void;
+  keydownCapture: (e: TerminalKeyboardEvent) => void;
+  keydown: (e: TerminalKeyboardEvent) => void;
+  keyupCapture: (e: TerminalKeyboardEvent) => void;
+  keyup: (e: TerminalKeyboardEvent) => void;
+  beforeinputCapture: (e: TerminalInputEvent) => void;
+  beforeinput: (e: TerminalInputEvent) => void;
+  inputCapture: (e: TerminalInputEvent) => void;
+  input: (e: TerminalInputEvent) => void;
+  compositionstartCapture: (e: TerminalInputEvent) => void;
+  compositionstart: (e: TerminalInputEvent) => void;
+  compositionupdateCapture: (e: TerminalInputEvent) => void;
+  compositionupdate: (e: TerminalInputEvent) => void;
+  compositionendCapture: (e: TerminalInputEvent) => void;
+  compositionend: (e: TerminalInputEvent) => void;
+  pasteCapture: (e: TerminalInputEvent) => void;
+  paste: (e: TerminalInputEvent) => void;
+  focusCapture: (e: TerminalBaseEvent) => void;
+  focus: (e: TerminalBaseEvent) => void;
+  blurCapture: (e: TerminalBaseEvent) => void;
+  blur: (e: TerminalBaseEvent) => void;
+}>;
+interface TerminalNode {
+  id: string;
+  rect: Rect;
+  zIndex: number;
+  visible?: boolean;
+  focusable?: boolean;
+  selectable?: boolean;
+  handlers: TerminalEventHandlerMap;
+}
+type TerminalDebugNode = Readonly<{
+  id: string;
+  rect: Rect;
+  zIndex: number;
+  visible: boolean;
+  focusable: boolean;
+}>;
+
+//#endregion
+//#region src/events/manager/cli-event-manager.d.ts
+interface CliEventManager {
+  register: (node: Omit<TerminalNode, 'id'> & {
+    id?: string;
+  }) => TerminalNode;
+  update: (id: string, next: Partial<Omit<TerminalNode, 'id'>>) => void;
+  unregister: (id: string) => void;
+  setMetrics: (next: CellMetrics) => void;
+  focus: (id: string | null) => void;
+  getFocused: () => string | null;
+  dispatch: (event: TerminalEventRecord) => void;
+  debugNodes: () => TerminalDebugNode[];
+  dispose: () => void;
+}
+declare function createCliEventManager(options?: Readonly<{
+  record?: (event: TerminalEventRecord) => void;
+  onFocusChange?: (prev: string | null, next: string | null) => void;
+}>): CliEventManager;
+
+//#endregion
+//#region src/events/manager/event-manager.d.ts
+interface EventManager {
+  register: (node: Omit<TerminalNode, 'id'> & {
+    id?: string;
+  }) => TerminalNode;
+  update: (id: string, next: Partial<Omit<TerminalNode, 'id'>>) => void;
+  unregister: (id: string) => void;
+  setMetrics: (next: CellMetrics) => void;
+  focus: (id: string | null) => void;
+  getFocused: () => string | null;
+  debugNodes: () => TerminalDebugNode[];
+  dispose: () => void;
+}
+declare function createEventManager(container: HTMLElement, metrics: CellMetrics, options?: Readonly<{
+  record?: (event: TerminalEventRecord) => void;
+  textInputTarget?: HTMLElement | null;
+  debugIme?: boolean;
+  onFocusChange?: (prev: string | null, next: string | null) => void;
+}>): EventManager;
+
+//#endregion
+//#region src/observability/trace.d.ts
+type TraceRecord = Readonly<{
+  type: 'event';
+  at: number;
+  event: TerminalEventRecord;
+}> | Readonly<{
+  type: 'focus';
+  at: number;
+  prev: string | null;
+  next: string | null;
+}> | Readonly<{
+  type: 'commit';
+  at: number;
+  dirtyRows: readonly number[];
+  focusedId: string | null;
+}>;
+type TraceStore = Readonly<{
+  enabled: Ref<boolean>;
+  records: TraceRecord[];
+  push: (record: TraceRecord) => void;
+  clear: () => void;
+  snapshot: () => TraceRecord[];
+}>;
+declare function createTraceStore(opts?: Readonly<{
+  enabled?: boolean;
+  max?: number;
+}>): TraceStore;
+
+//#endregion
+//#region src/renderer/cli/stdout-renderer.d.ts
+type CliOutput = Readonly<{
+  write: (chunk: string) => unknown;
+  isTTY?: boolean;
+}>;
+type StdoutRenderer = Readonly<{
+  render: () => void;
+  dispose: () => void;
+  /** Move terminal cursor to specified cell position for IME input */
+  setCursor: (x: number, y: number) => void;
+  /** Show or hide the terminal cursor */
+  showCursor: (visible: boolean) => void;
+}>;
+type StdoutColorMode = 'auto' | 'truecolor' | 'ansi16' | 'ansi256';
+declare function createStdoutRenderer(terminal: Terminal, options?: Readonly<{
+  output?: CliOutput;
+  clear?: boolean;
+  hideCursor?: boolean;
+  altScreen?: boolean;
+  /** Fallback background color when a cell has no explicit bg. */
+  defaultBg?: AnsiColorName;
+  palette?: Partial<Record<AnsiColorName, string>>;
+  /** Track TTY resize events (process.stdout 'resize') and call terminal.resize(). */
+  trackResize?: boolean;
+  /** Color mode for ANSI output (auto detects truecolor via env). */
+  colorMode?: StdoutColorMode;
+}>): StdoutRenderer;
+
+//#endregion
+//#region src/vue/render/render-manager.d.ts
+type RenderRect = Readonly<{
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+}>;
+type RenderStack = Readonly<{
+  id: string;
+  parent: RenderStack | null;
+  zIndex: number;
+  order: number;
+}>;
+type RenderNode = Readonly<{
+  id: string;
+  stack: RenderStack;
+  zIndex: number;
+  order: number;
+  rect: RenderRect | null;
+  paint: (dirtyRows?: readonly number[]) => void;
+}>;
+type RenderManager = Readonly<{
+  rootStack: RenderStack;
+  createStack: (parent: RenderStack, zIndex: number) => RenderStack;
+  register: (node: {
+    stack: RenderStack;
+    zIndex?: number;
+    rect?: RenderRect | null;
+    paint: (dirtyRows?: readonly number[]) => void;
+  }) => RenderNode;
+  update: (id: string, next: Partial<{
+    stack: RenderStack;
+    zIndex: number;
+    rect: RenderRect | null;
+    paint: (dirtyRows?: readonly number[]) => void;
+  }>) => void;
+  unregister: (id: string) => void;
+  render: () => void;
+}>;
+
+//#endregion
+//#region src/vue/context.d.ts
+interface LayoutContext {
+  originX: number;
+  originY: number;
+  clipRect: Rect | null;
+}
+type TerminalScheduler = Readonly<{
+  invalidate: () => void;
+  flush: () => void;
+}>;
+type TerminalRuntimeHandle = Readonly<{
+  update: (props: Record<string, unknown>) => void;
+  move: (x: number, y: number) => void;
+  unmount: () => void;
+}>;
+type TerminalRuntime = Readonly<{
+  mount: (component: Component$1, props: Record<string, unknown>) => TerminalRuntimeHandle;
+}>;
+type ImeAnchor = Readonly<{
+  cellX: number;
+  cellY: number;
+}>;
+type TerminalContext = Readonly<{
+  terminal: Terminal;
+  renderer: Ref<DomRenderer | null>;
+  events: Ref<EventManager | null>;
+  scheduler: TerminalScheduler;
+  runtime: TerminalRuntime;
+  observability: Readonly<{
+    trace: TraceStore;
+  }>;
+  defaultStyle: Ref<Style>;
+  render: RenderManager;
+}>;
+
+//#endregion
+//#region src/create-terminal-app.d.ts
+type TerminalApp = Readonly<{
+  app: App;
+  terminal: Terminal;
+  events: CliEventManager;
+  scheduler: {
+    invalidate: () => void;
+    flush: () => void;
+  };
+  /** Returns the current IME anchor position (cursor position in cell coordinates), or null if no input is focused */
+  getImeAnchor: () => ImeAnchor | null;
+  mount: () => void;
+  dispose: () => void;
+}>;
+type CreateTerminalAppOptions = Readonly<{
+  cols: number;
+  rows: number;
+  component: Component$1;
+  props?: Record<string, unknown>;
+  defaultStyle?: Style;
+}>;
+declare function createTerminalApp(options: CreateTerminalAppOptions): TerminalApp;
+
+//#endregion
+//#region src/runtime/index.d.ts
+type RuntimeEnv = 'browser' | 'terminal' | 'unknown';
+type TimerApi = Readonly<{
+  setTimeout: typeof setTimeout;
+  clearTimeout: typeof clearTimeout;
+  setInterval: typeof setInterval;
+  clearInterval: typeof clearInterval;
+}>;
+type RafApi = Readonly<{
+  request: (cb: FrameRequestCallback) => number;
+  cancel: (id: number) => void;
+}>;
+type ClipboardApi = Readonly<{
+  supported: boolean;
+  readText: () => Promise<string>;
+  writeText: (text: string) => Promise<void>;
+}>;
+type Runtime = Readonly<{
+  env: Readonly<{
+    kind: RuntimeEnv;
+    isBrowser: boolean;
+    isTerminal: boolean;
+  }>;
+  now: () => number;
+  timer: TimerApi;
+  raf: RafApi;
+  clipboard: ClipboardApi;
+  getWindow: () => Window | null;
+  getDocument: () => Document | null;
+  measureText: (text: string, opts?: Readonly<{
+    font?: string;
+  }>) => number | null;
+}>;
+declare function createRuntime(kind?: RuntimeEnv): Runtime;
+
+//#endregion
+//#region src/utils/newlines.d.ts
+declare function normalizeNewlines(text: string): string;
+
+//#endregion
+//#region src/vue/components/TAnchor.d.ts
+declare const TAnchor: any;
+
+//#endregion
+//#region src/vue/components/TBox.d.ts
+declare const TBox: any;
+
+//#endregion
+//#region src/vue/components/TDebugOverlay.d.ts
+declare const TDebugOverlay: any;
+
+//#endregion
+//#region src/vue/components/TDialog.d.ts
+declare const TDialog: any;
+
+//#endregion
+//#region src/vue/components/TerminalProvider.d.ts
+declare const TerminalProvider: any;
+
+//#endregion
+//#region src/vue/components/TFlow.d.ts
+declare const TFlow: any;
+
+//#endregion
+//#region src/vue/components/TInput.d.ts
+declare const TInput: any;
+
+//#endregion
+//#region src/vue/components/TInputBox.d.ts
+declare const TInputBox: any;
+
+//#endregion
+//#region src/vue/components/TList.d.ts
+declare const TList: any;
+
+//#endregion
+//#region src/vue/components/TPathPicker.d.ts
+declare const TPathPicker: any;
+
+//#endregion
+//#region src/vue/components/TSelect.d.ts
+declare const TSelect: any;
+
+//#endregion
+//#region src/vue/components/TText.d.ts
+declare const TText: any;
+
+//#endregion
+//#region src/vue/components/TTransition.d.ts
+declare const TTransition: any;
+
+//#endregion
+//#region src/vue/components/TView.d.ts
+declare const TView: any;
+
+//#endregion
+//#region src/vue/composables/use-layout.d.ts
+declare function useLayout(): LayoutContext;
+
+//#endregion
+//#region src/vue/composables/use-runtime.d.ts
+declare function useTerminalRuntime(): Readonly<{
+  mount: (component: Component, props: Record<string, unknown>) => TerminalRuntimeHandle;
+}>;
+
+//#endregion
+//#region src/vue/composables/use-terminal-node.d.ts
+interface TerminalNodeOptions {
+  rect: Rect;
+  zIndex?: number;
+  visible?: boolean;
+  focusable?: boolean;
+  selectable?: boolean;
+  handlers?: TerminalEventHandlerMap;
+}
+declare function useTerminalNode(getOptions: () => TerminalNodeOptions): {
+  id: Ref<string | null>;
+};
+
+//#endregion
+//#region src/vue/composables/use-terminal.d.ts
+declare function useTerminal(): TerminalContext;
+
+//#endregion
+//#region src/vue/composables/use-visibility.d.ts
+type VisibilityRootProps = Readonly<{
+  style: Readonly<Record<string, string | number>>;
+  onVnodeBeforeMount: (vnode: VNode) => void;
+  onVnodeBeforeUnmount: (vnode: VNode) => void;
+}>;
+declare function useVisibility(options?: {
+  provide?: boolean;
+}): Readonly<{
+  visible: ComputedRef<boolean>;
+  rootProps: VisibilityRootProps;
+}>;
+
+//#endregion
+//#region src/vue/router/types.d.ts
+type TerminalRoute = Readonly<{
+  name: string;
+  params?: Readonly<Record<string, string>>;
+  meta?: unknown;
+}>;
+type TerminalRouteRecord = Readonly<{
+  name: string;
+  component: Component$1;
+  meta?: unknown;
+  onEnter?: (to: TerminalRoute, from: TerminalRoute | null) => void | Promise<void>;
+  onLeave?: (to: TerminalRoute, from: TerminalRoute | null) => void | Promise<void>;
+}>;
+type TerminalRouteLocationRaw = string | Readonly<{
+  name: string;
+  params?: Record<string, string>;
+}>;
+type NavigationGuardReturn = void | boolean | TerminalRouteLocationRaw;
+type NavigationGuard = (to: TerminalRoute, from: TerminalRoute | null) => NavigationGuardReturn | Promise<NavigationGuardReturn>;
+type TerminalRouter = Readonly<{
+  currentRoute: vue1.Ref<TerminalRoute>;
+  push: (to: TerminalRouteLocationRaw) => Promise<void>;
+  replace: (to: TerminalRouteLocationRaw) => Promise<void>;
+  back: () => Promise<void>;
+  beforeEach: (guard: NavigationGuard) => () => void;
+  beforeResolve: (guard: NavigationGuard) => () => void;
+  afterEach: (guard: (to: TerminalRoute, from: TerminalRoute | null) => void) => () => void;
+  install: (app: vue2.App) => void;
+}>;
+
+//#endregion
+//#region src/vue/router/composables.d.ts
+declare function useRouter(): TerminalRouter;
+declare function useRoute(): ComputedRef<TerminalRoute>;
+
+//#endregion
+//#region src/vue/router/router.d.ts
+declare function createTerminalRouter(options: Readonly<{
+  routes: readonly TerminalRouteRecord[];
+  initialRoute: TerminalRouteLocationRaw;
+}>): TerminalRouter;
+
+//#endregion
+//#region src/vue/router/RouterView.d.ts
+declare const TRouterView: any;
+
+//#endregion
+//#region src/vue/utils/text.d.ts
+declare function sanitizeInlineText(text: string): string;
+declare function sanitizeTextBlock(text: string): string;
+declare function textCellWidth(text: string): number;
+declare function sliceByCells(text: string, maxCells: number): string;
+declare function padEndByCells(text: string, width: number): string;
+declare function wrapByCells(text: string, width: number): string[];
+
+//#endregion
+export { AnsiColorName, BufferSnapshot, Cell, CellMetrics, CliEventManager, ClipboardApi, CreateTerminalAppOptions, DomRenderer, EventManager, FsDirEntry, FsEntryKind, FsStat, LayoutContext, PathPickerProvider, RafApi, Rect, Runtime, RuntimeEnv, StdinDriver, StdoutRenderer, Style, TAnchor, TBox, TDebugOverlay, TDialog, TFlow, TInput, TInputBox, TList, TPathPicker, TRouterView, TSelect, TText, TTransition, TView, Terminal, TerminalApp, TerminalBaseEvent, TerminalCommitEvent, TerminalContext, TerminalDebugNode, TerminalEventHandlerMap, TerminalEventMap, TerminalEventRecord, TerminalEventType, TerminalInputEvent, TerminalKeyboardEvent, TerminalNode, TerminalPointerEvent, TerminalProvider, TerminalResizeEvent, TerminalRoute, TerminalRouteLocationRaw, TerminalRouteRecord, TerminalRouter, TerminalRuntime, TerminalRuntimeHandle, TerminalScheduler, TimerApi, TraceRecord, TraceStore, ansiStyles, charCellWidth, createCliEventManager, createDomRenderer, createEventManager, createNodePathPickerProvider, createRuntime, createStdinDriver, createStdoutRenderer, createTerminal, createTerminalApp, createTerminalRouter, createTraceStore, normalizeNewlines, padEndByCells, parseAnsiSgr, readEventLog, resolveUserPath, sanitizeInlineText, sanitizeTextBlock, sliceByCells, textCellWidth, useLayout, useRoute, useRouter, useTerminal, useTerminalNode, useTerminalRuntime, useVisibility, wrapByCells, writeEventLog, writeSnapshot };