@mdxui/terminal 2.0.0

package/dist/index.d.ts

@@ -0,0 +1,579 @@
+import React__default, { ReactNode } from 'react';
+export { ActionConfig, ActionProp, ActionsProps, App, AppHeader, AppHeaderProps, AppHeaderUser, AppProps, Badge, BadgeProps, Box, BoxProps, Breadcrumb, BreadcrumbItem, BreadcrumbProps, Button, ButtonProps, COMPONENT_TYPES, Card, CardProps, Dashboard, DashboardMetric, DashboardProps, Dialog, DialogProps, FAQ, FAQItem, FAQProps, FeatureItem, Features, FeaturesProps, Footer, FooterLinkGroup, FooterProps, Header, HeaderProps, Hero, HeroProps, Input, InputProps, LandingPage, LandingPageProps, List, ListProps, NavItem, Page, PageProps, Panel, PanelProps, Pricing, PricingProps, PricingTier, RenderContext, Select, SelectOption, SelectProps, Settings, SettingsProps, SettingsSection, Shell, ShellProps, Sidebar, SidebarItem, SidebarItemProps, SidebarLayout, SidebarProps, Site, SiteProps, SocialLink, Spinner, SpinnerProps, Table, TableColumn, TableProps, TerminalComponentType, TerminalSidebarLayoutProps, Text, TextProps, bgColorMap, colorMap, extractChildren, getBgColorCode, getColorCode, isBadgeProps, isBoxProps, isBreadcrumbProps, isButtonProps, isCardProps, isDialogProps, isInputProps, isListProps, isPanelProps, isPropsObject, isSelectProps, isSidebarItemProps, isSidebarProps, isSpinnerProps, isTableProps, isTerminalComponentType, isTextProps, renderBadge, renderBox, renderBreadcrumb, renderButton, renderCard, renderComponent, renderDialog, renderElement, renderInput, renderList, renderPanel, renderSelect, renderSidebar, renderSidebarItem, renderSpinner, renderTable, spinnerFrames } from './components/index.js';
+export { ANSI, Ansi256Code, Ansi256CodeSchema, AnsiEscapeSchema, BoxStyle, ColorSupport, ColorSupportSchema, CreateTerminalThemeOptions, CreateTerminalThemeOptionsInput, CreateTerminalThemeOptionsSchema, CreateThemeInput, CreateThemeInputSchema, HexColor, HexColorSchema, LegacyTerminalTheme, LegacyTerminalThemeSchema, LegacyTerminalThemeWithExtras, LegacyTerminalThemeWithExtrasSchema, RgbColor, RgbColorSchema, RgbComponentSchema, RgbToAnsiOptions, RgbToAnsiOptionsSchema, TAILWIND_COLORS, TerminalTheme, TerminalThemeColors, TerminalThemeColorsSchema, ThemeMode, ThemeModeSchema, adaptColor, ansi256, ansi256Bg, applyThemeStyles, bg, bold, boxChars, colors, composeThemes, createTerminalTheme, createTheme, createThemeVariant, cssVarToAnsi, darkTheme, defaultTheme, degradeColor, detectColorScheme, detectColorSupport, dim, drawBox, extendTheme, fg, getThemeColor, hex, hexBg, hexToAnsi, hexToRgb, highContrastTheme, italic, lightTheme, rgb, rgbBg, rgbToAnsi, strikethrough, stripAnsi, style, styled, tailwindToAnsi, tailwindToTerminal, themePresets, themeTokens, underline, visibleLength } from './theme/index.js';
+export { h as ARROW_BINDINGS, A as ActionContext, c as ActionHandler, y as AttachKeyboardOptions, C as COMMON_BINDINGS, D as DetachKeyboard, E as EMACS_BINDINGS, r as FocusContext, J as FocusId, k as FocusManagerState, x as FocusProvider, q as FocusProviderProps, F as FocusableElement, f as KEY, b as KeyBindings, K as KeyModifiers, a as KeyboardAction, e as KeyboardManager, d as KeyboardManagerOptions, N as NormalizedKey, O as OpenTUIKeyEvent, R as ReadlineKey, j as UseFocusOptions, U as UseKeyboardOptions, i as UseKeyboardResult, o as UseNavigableGridOptions, p as UseNavigableGridResult, l as UseNavigableListOptions, n as UseNavigableListResult, V as VIM_BINDINGS, _ as __resetFocusIdCounter, G as attachKeyboardManager, L as createFocusId, g as createKeyboardManager, I as createOpenTUIKeyHandler, M as isFocusId, B as keyToBindingString, m as matchKey, H as normalizeOpenTUIKey, z as normalizeReadlineKey, s as useFocus, t as useFocusManager, u as useKeyboard, w as useNavigableGrid, v as useNavigableList } from './index-CQRFZntR.js';
+export { APIKey, APIKeySchema, APIKeysCollection, Collection, ComparisonOperators, ConflictResolution, DB, DBConfig, DBProvider, DBProviderProps, DOSyncAdapter, DOSyncConfig, FieldFilter, FindManyOptions, MetricValue, MutationOperation, MutationOptions, MutationResult, OrderByClause, OrderDirection, PaginationState, QueryOptions, QueryResult, ReactiveCardOptions, ReactiveCardResult, ReactiveDataOptions, ReactiveDataResult, ReactiveListOptions, ReactiveMetricsOptions, ReactiveMetricsResult, ReactiveTableOptions, ReconnectOptions, SelectionState, SortState, SyncAdapter, Team, TeamSchema, TeamsCollection, Usage, UsageCollection, UsageSchema, User, UserRole, UserRoleSchema, UserSchema, UsersCollection, Webhook, WebhookSchema, WebhooksCollection, WhereClause, createCollection, createDB, createDOSync, useDBContext, useMutation, useQuery, useReactiveCard, useReactiveData, useReactiveList, useReactiveMetrics, useReactiveTable } from './data/index.js';
+import { U as UINode } from './types-Bxu5PAgA.js';
+export { a as CoreRenderContext, e as RenderContextSchema, R as RenderTier, c as RenderTierSchema, T as ThemeTokens, d as ThemeTokensSchema, b as UINodeSchema } from './types-Bxu5PAgA.js';
+export { A as ANSIToCSSResult, C as CSSStyleProperties, S as StyledSpan, T as TextRenderOptions, a as ansiToCSS, b as ansiToHTML, p as parseAnsiToSpans, r as renderText, s as spanToInlineStyle } from './ansi-css-_3eSEU9d.js';
+import 'zod';
+
+/**
+ * @mdxui/terminal JSX to UINode Compiler
+ *
+ * Compiles React element trees into UINode trees for terminal rendering.
+ *
+ * @remarks
+ * This module provides a TDD-implemented JSX compiler that converts React's
+ * dynamic component tree model into a serializable UINode tree optimized for
+ * terminal rendering. The compiler handles all React element types including
+ * fragments, nested trees, and edge cases like null/undefined filtering.
+ *
+ * **Performance Characteristics:**
+ * - Single-pass traversal: O(n) where n = total nodes
+ * - No backtracking or re-traversal of elements
+ * - Memory-efficient: Reuses object literals where safe
+ * - Deep tree optimization: Tail-call patterns for stack efficiency
+ * - Allocation minimization: Early returns avoid intermediate arrays
+ *
+ * **Key Design Principles:**
+ * 1. **Type Safety**: All child types validated at process time
+ * 2. **Fragment Flattening**: React Fragments unwrapped during traversal
+ * 3. **Null Filtering**: React's null/undefined/boolean children filtered out
+ * 4. **Key Preservation**: React keys converted to string keys for reconciliation
+ * 5. **Props Isolation**: Children field excluded from props object
+ *
+ * **Usage Example:**
+ * ```typescript
+ * import { compileJSX } from '@mdxui/terminal'
+ *
+ * const jsx = <Box padding={2}>
+ *   <Text bold>Hello</Text>
+ *   <Text>World</Text>
+ * </Box>
+ *
+ * const uiTree = compileJSX(jsx)
+ * // Result:
+ * // {
+ * //   type: 'Box',
+ * //   props: { padding: 2 },
+ * //   children: [
+ * //     { type: 'Text', props: { bold: true }, children: [{ type: 'Text', props: {}, children: ['Hello'] }] },
+ * //     { type: 'Text', props: {}, children: ['World'] }
+ * //   ]
+ * // }
+ * ```
+ *
+ * @category Compiler
+ * @module compiler
+ */
+
+/**
+ * Compiles a React JSX element into a UINode tree for terminal rendering.
+ *
+ * Converts React's dynamic element tree into a serializable form suitable for
+ * cross-tier terminal rendering (text, markdown, ascii, unicode, ansi, interactive).
+ *
+ * @param element - A React element created via React.createElement or JSX
+ * @returns A UINode tree representing the compiled element with all descendants
+ *
+ * @remarks
+ * **Input Handling:**
+ * - Accepts React elements from `React.createElement()` or JSX syntax
+ * - Component types (functions, classes, strings) are normalized to strings
+ * - Props are extracted and children are processed separately
+ * - React keys are preserved for list reconciliation
+ *
+ * **Output Structure:**
+ * - Always returns an object with `type` (string) and `props` (object)
+ * - Includes `children` array only if children exist or were explicitly provided
+ * - Includes `key` field only if key was present in source element
+ * - All props except `children` are preserved as-is
+ *
+ * **Fragment Handling:**
+ * Fragments are automatically unwrapped:
+ * ```typescript
+ * // Input
+ * <Box>
+ *   <>
+ *     <Text>A</Text>
+ *     <Text>B</Text>
+ *   </>
+ * </Box>
+ *
+ * // Output - Fragment is transparent
+ * {
+ *   type: 'Box',
+ *   props: {},
+ *   children: [
+ *     { type: 'Text', props: {}, children: ['A'] },
+ *     { type: 'Text', props: {}, children: ['B'] }
+ *   ]
+ * }
+ * ```
+ *
+ * **Key Preservation:**
+ * React keys are converted to strings and preserved for reconciliation:
+ * ```typescript
+ * // Input
+ * <List>
+ *   {items.map((item, i) => <Item key={item.id}>{item.name}</Item>)}
+ * </List>
+ *
+ * // Output - Keys preserved for stable reconciliation
+ * {
+ *   type: 'List',
+ *   props: {},
+ *   children: [
+ *     { type: 'Item', props: {}, key: 'item-1', children: ['Alice'] },
+ *     { type: 'Item', props: {}, key: 'item-2', children: ['Bob'] }
+ *   ]
+ * }
+ * ```
+ *
+ * **Null/Undefined Filtering:**
+ * React's falsy child filtering is applied:
+ * ```typescript
+ * // Input - null, undefined, and boolean children filtered
+ * <Box>
+ *   {text}
+ *   {condition && <Element />}
+ *   {false}
+ *   {null}
+ *   {undefined}
+ * </Box>
+ *
+ * // Output - Only truthy content remains
+ * {
+ *   type: 'Box',
+ *   props: {},
+ *   children: [
+ *     { type: 'string', props: {}, children: ['some text'] },
+ *     { type: 'Element', props: {} }  // Only if condition was true
+ *   ]
+ * }
+ * ```
+ *
+ * **Performance Notes:**
+ * - Single-pass tree traversal with O(n) complexity
+ * - Tail-call optimized for deep component trees
+ * - Minimal intermediate allocations
+ * - Type checks ordered by frequency (strings before rare types)
+ *
+ * @example
+ * Simple component:
+ * ```typescript
+ * const element = <Box padding={2} />
+ * const result = compileJSX(element)
+ * // { type: 'Box', props: { padding: 2 } }
+ * ```
+ *
+ * @example
+ * With children:
+ * ```typescript
+ * const element = <Text bold>Hello World</Text>
+ * const result = compileJSX(element)
+ * // { type: 'Text', props: { bold: true }, children: ['Hello World'] }
+ * ```
+ *
+ * @example
+ * With nested elements and fragment:
+ * ```typescript
+ * const element = (
+ *   <Layout>
+ *     <Header title="App" />
+ *     <>
+ *       <Content />
+ *       <Sidebar />
+ *     </>
+ *     <Footer />
+ *   </Layout>
+ * )
+ * const result = compileJSX(element)
+ * // { type: 'Layout', props: {}, children: [
+ * //   { type: 'Header', props: { title: 'App' } },
+ * //   { type: 'Content', props: {} },
+ * //   { type: 'Sidebar', props: {} },
+ * //   { type: 'Footer', props: {} }
+ * // ]}
+ * ```
+ *
+ * @see {@link UINode} for the output structure
+ * @see {@link processChildren} for child processing logic
+ * @see {@link processChild} for single child handling
+ *
+ * @throws {Error} Will not throw - gracefully handles all React element types
+ */
+declare function compileJSX(element: React__default.ReactElement): UINode;
+/**
+ * Compiles a React JSX element into a UINode tree using iteration.
+ *
+ * This is an alternative to {@link compileJSX} optimized for deeply nested
+ * trees that might cause stack overflow with recursive compilation. Use this
+ * when you expect trees with nesting depth > 1000 levels.
+ *
+ * @param element - A React element created via React.createElement or JSX
+ * @returns A UINode tree representing the compiled element with all descendants
+ *
+ * @remarks
+ * **Algorithm:**
+ * Uses an explicit work stack to process elements iteratively:
+ * 1. Start with root element on the stack
+ * 2. Pop element, create UINode with props
+ * 3. Process children:
+ *    - Primitives (string/number): add directly to children array
+ *    - Fragments: extract children, add to pending work
+ *    - Elements: add placeholder, push to work stack
+ * 4. Continue until stack is empty
+ *
+ * **Performance:**
+ * - O(n) time complexity where n = total nodes
+ * - O(d) space complexity where d = maximum tree depth
+ * - No recursion limit - can handle 10,000+ nesting levels
+ * - Slightly more overhead than recursive version for shallow trees
+ *
+ * **When to Use:**
+ * - Trees with > 1000 nesting levels
+ * - Dynamic tree generation where depth is unbounded
+ * - Processing user-generated content with arbitrary nesting
+ *
+ * For most use cases with reasonable tree depths (< 500 levels),
+ * use the standard {@link compileJSX} function instead.
+ *
+ * @example
+ * Deep tree compilation:
+ * ```typescript
+ * // Build a very deep tree
+ * let deepElement = <Text>Leaf</Text>
+ * for (let i = 0; i < 5000; i++) {
+ *   deepElement = <Box>{deepElement}</Box>
+ * }
+ *
+ * // This would cause stack overflow with compileJSX
+ * // But works fine with compileJSXDeep
+ * const uiTree = compileJSXDeep(deepElement)
+ * ```
+ *
+ * @see {@link compileJSX} for the standard recursive implementation
+ */
+declare function compileJSXDeep(element: React__default.ReactElement): UINode;
+
+/**
+ * @mdxui/terminal JSON Parser
+ *
+ * Converts JSON strings and objects into validated UINode structures.
+ * Supports both JSON string parsing and pre-parsed object validation.
+ */
+
+/**
+ * Custom error class for parsing errors.
+ * Provides helpful error messages for JSON parsing and UINode validation failures.
+ */
+declare class ParseError extends Error {
+    constructor(message: string);
+}
+/**
+ * Parse a JSON string or JavaScript object into a validated UINode.
+ *
+ * @param input - JSON string or pre-parsed JavaScript object
+ * @returns Validated UINode
+ * @throws ParseError if the input is invalid JSON or doesn't match UINode structure
+ *
+ * @example
+ * ```tsx
+ * // Parse JSON string
+ * const node = parseUINode('{"type":"text","props":{"content":"Hello"}}')
+ *
+ * // Parse pre-parsed object
+ * const node = parseUINode({ type: 'text', props: { content: 'Hello' } })
+ * ```
+ */
+declare function parseUINode(input: string | unknown): UINode;
+/**
+ * Parse a JSON string into a validated UINode.
+ *
+ * This is a convenience function that only accepts JSON strings.
+ * For parsing pre-parsed objects, use parseUINode directly.
+ *
+ * @param json - JSON string representation of a UINode
+ * @returns Validated UINode
+ * @throws ParseError if the JSON is invalid or doesn't match UINode structure
+ *
+ * @example
+ * ```tsx
+ * const node = parseUINodeFromJSON('{"type":"text","props":{"content":"Hello"}}')
+ * ```
+ */
+declare function parseUINodeFromJSON(json: string): UINode;
+
+/**
+ * @mdxui/terminal
+ *
+ * OpenTUI renderer for MDXUI primitives.
+ * Build CLI dashboards with the same component contracts as web.
+ *
+ * @example
+ * ```tsx
+ * import { CLI, Box, Text } from '@mdxui/terminal'
+ *
+ * async function main() {
+ *   const cli = await CLI()
+ *   cli.render(
+ *     <Box border="single">
+ *       <Text color="cyan">Hello Terminal!</Text>
+ *     </Box>
+ *   )
+ * }
+ *
+ * main()
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // For more control, use the lower-level API
+ * import { createCliRenderer, createRoot } from '@mdxui/terminal'
+ *
+ * async function main() {
+ *   const renderer = await createCliRenderer()
+ *   const root = createRoot(renderer)
+ *   root.render(<App />)
+ * }
+ * ```
+ */
+
+/**
+ * CLI renderer configuration options
+ */
+interface CliRendererConfig {
+    /** Input stream (defaults to process.stdin) */
+    stdin?: NodeJS.ReadStream;
+    /** Output stream (defaults to process.stdout) */
+    stdout?: NodeJS.WriteStream;
+    /** Exit on Ctrl+C (defaults to true) */
+    exitOnCtrlC?: boolean;
+    /** Target frames per second */
+    targetFps?: number;
+    /** Use alternate screen buffer */
+    useAlternateScreen?: boolean;
+    /** Enable mouse support */
+    useMouse?: boolean;
+    /** Background color */
+    backgroundColor?: string;
+}
+/**
+ * CLI renderer instance
+ */
+interface CliRenderer {
+    /** Terminal width in columns */
+    width: number;
+    /** Terminal height in rows */
+    height: number;
+    /** Start the render loop */
+    start(): void;
+    /** Stop the render loop */
+    stop(): void;
+    /** Destroy the renderer and clean up */
+    destroy(): void;
+    /** Request a render update */
+    requestRender(): void;
+}
+/**
+ * Root interface for React rendering
+ */
+interface Root {
+    /** Render a React element */
+    render(element: ReactNode): void;
+    /** Unmount and clean up */
+    unmount(): void;
+}
+/**
+ * Create an OpenTUI CLI renderer for terminal rendering.
+ *
+ * @param config - Optional configuration options
+ * @returns Promise resolving to a CLI renderer instance
+ *
+ * @example
+ * ```tsx
+ * import { createCliRenderer, createRoot } from '@mdxui/terminal'
+ *
+ * async function main() {
+ *   const renderer = await createCliRenderer()
+ *   const root = createRoot(renderer)
+ *   root.render(<App />)
+ * }
+ * ```
+ */
+declare function createCliRenderer(config?: CliRendererConfig): Promise<CliRenderer>;
+/**
+ * Create a root for rendering a React tree with the given CLI renderer.
+ *
+ * @param renderer - The CLI renderer to use (from createCliRenderer)
+ * @returns A root object with render and unmount methods
+ *
+ * @example
+ * ```tsx
+ * const renderer = await createCliRenderer()
+ * const root = createRoot(renderer)
+ * root.render(<App />)
+ *
+ * // Later, to clean up:
+ * root.unmount()
+ * renderer.destroy()
+ * ```
+ */
+declare function createRoot(renderer: CliRenderer): Root;
+/**
+ * Options for the CLI() function
+ */
+interface CLIOptions {
+    /** Color support level. Auto-detected if not specified. */
+    colorSupport?: 'none' | '16' | '256' | 'truecolor';
+    /** Input stream (defaults to process.stdin) */
+    stdin?: NodeJS.ReadStream;
+    /** Output stream (defaults to process.stdout) */
+    stdout?: NodeJS.WriteStream;
+    /** Exit on Ctrl+C (defaults to true) */
+    exitOnCtrlC?: boolean;
+    /** Target frames per second */
+    targetFps?: number;
+    /** Use alternate screen buffer */
+    useAlternateScreen?: boolean;
+    /** Enable mouse support */
+    useMouse?: boolean;
+    /** Background color */
+    backgroundColor?: string;
+}
+/**
+ * CLI instance returned by CLI()
+ */
+interface CLIInstance {
+    /** Terminal width in columns */
+    readonly width: number;
+    /** Terminal height in rows */
+    readonly height: number;
+    /** Render a React element to the terminal */
+    render: (element: ReactNode) => void;
+    /** Clear the terminal */
+    clear: () => void;
+    /** Destroy the CLI instance and clean up resources */
+    destroy: () => void;
+    /** Request a render update */
+    requestRender: () => void;
+    /** The underlying renderer instance */
+    readonly renderer: CliRenderer;
+    /** The underlying root instance */
+    readonly root: Root;
+}
+/**
+ * Create a high-level CLI instance for terminal rendering.
+ *
+ * This is the recommended entry point for building terminal UIs with @mdxui/terminal.
+ * It combines `createCliRenderer` and `createRoot` into a single, easy-to-use API.
+ *
+ * @param options - Optional configuration options
+ * @returns Promise resolving to a CLI instance with render, clear, and destroy methods
+ *
+ * @example
+ * ```tsx
+ * import { CLI, Box, Text } from '@mdxui/terminal'
+ *
+ * async function main() {
+ *   const cli = await CLI()
+ *   cli.render(
+ *     <Box border="single">
+ *       <Text color="cyan">Hello Terminal!</Text>
+ *     </Box>
+ *   )
+ * }
+ *
+ * main()
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With custom options
+ * const cli = await CLI({
+ *   useAlternateScreen: true,
+ *   useMouse: true,
+ *   exitOnCtrlC: true,
+ * })
+ * ```
+ */
+declare function CLI(options?: CLIOptions): Promise<CLIInstance>;
+/**
+ * Get the current terminal dimensions, with automatic updates on resize.
+ *
+ * Returns `{ width, height }` representing the terminal's column and row count.
+ *
+ * **Behavior by environment:**
+ * - **Node.js TTY**: Uses `process.stdout.columns/rows` and subscribes to resize events
+ * - **Browser/Non-TTY**: Falls back to 80x24 defaults
+ *
+ * @returns Current terminal width and height in columns/rows
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { width, height } = useTerminalSize()
+ *   return <Text>Terminal: {width}x{height}</Text>
+ * }
+ * ```
+ */
+declare function useTerminalSize(): {
+    width: number;
+    height: number;
+};
+/**
+ * Access terminal context and capabilities.
+ *
+ * Provides terminal dimensions plus color support detection and raw mode status.
+ * Uses @opentui/react for dimensions and our color-support module for capabilities.
+ *
+ * @returns Terminal state including dimensions, color support level, and raw mode
+ *
+ * @example
+ * ```tsx
+ * function StatusBar() {
+ *   const { width, height, colorSupport } = useTerminal()
+ *   return (
+ *     <Box>
+ *       <Text>Size: {width}x{height}</Text>
+ *       <Text>Colors: {colorSupport}</Text>
+ *     </Box>
+ *   )
+ * }
+ * ```
+ */
+declare function useTerminal(): {
+    width: number;
+    height: number;
+    colorSupport: 'none' | 'basic' | '256' | 'truecolor';
+    isRaw: boolean;
+};
+interface ThemeContextValue {
+    theme: 'light' | 'dark';
+    setTheme: (theme: 'light' | 'dark') => void;
+    colors: Record<string, string>;
+}
+/**
+ * Access current theme and colors
+ */
+declare function useTheme(): ThemeContextValue;
+interface TerminalProviderProps {
+    children?: ReactNode;
+}
+/**
+ * Terminal context provider - wraps app with terminal capabilities
+ */
+declare function TerminalProvider(props: TerminalProviderProps): React__default.ReactElement;
+interface ThemeProviderProps {
+    children?: ReactNode;
+    theme?: 'light' | 'dark';
+}
+/**
+ * Theme provider - provides color scheme to components
+ */
+declare function ThemeProvider(props: ThemeProviderProps): React__default.ReactElement;
+interface TerminalAppProps {
+    children: React__default.ReactNode;
+    /** Show status bar at bottom */
+    statusBar?: React__default.ReactNode;
+    /** Handle quit (Ctrl+C, q) */
+    onQuit?: () => void;
+}
+/**
+ * Terminal app shell with standard layout
+ */
+declare function TerminalApp(props: TerminalAppProps): React__default.ReactElement;
+
+export { CLI, type CLIInstance, type CLIOptions, type CliRenderer, type CliRendererConfig, ParseError, type Root, TerminalApp, type TerminalAppProps, TerminalProvider, type TerminalProviderProps, ThemeProvider, type ThemeProviderProps, UINode, compileJSX, compileJSXDeep, createCliRenderer, createRoot, parseUINode, parseUINodeFromJSON, useTerminal, useTerminalSize, useTheme };