salmon-loop 0.2.3

package/dist/cli/ui/hooks/useCommandSuggestions.js

@@ -0,0 +1,87 @@
+import { useState, useEffect, useCallback } from 'react';
+import { UI_CONFIG } from '../config.js';
+export function useCommandSuggestions(value, getSuggestions, isConfirming, findCommand) {
+    const [suggestions, setSuggestions] = useState([]);
+    const [selectedIndex, setSelectedIndex] = useState(-1);
+    const [startIndex, setStartIndex] = useState(0);
+    const [isListClosed, setIsListClosed] = useState(false);
+    const [activeCommand, setActiveCommand] = useState(undefined);
+    // Determine active command for context
+    useEffect(() => {
+        if (value.trim().startsWith('/')) {
+            const parts = value.trim().split(/\s+/);
+            // If we have at least one space, we might be in a subcommand
+            // e.g. "/snapshot " -> parts=["/snapshot", ""] (length 2)
+            if (parts.length > 1 || (parts.length === 1 && value.endsWith(' '))) {
+                const cmdName = parts[0];
+                setActiveCommand(findCommand ? findCommand(cmdName) : undefined);
+                return;
+            }
+        }
+        setActiveCommand(undefined);
+    }, [findCommand, value]);
+    useEffect(() => {
+        if (isConfirming || isListClosed)
+            return;
+        let isMounted = true;
+        const updateSuggestions = async () => {
+            const trimmedStart = value.trimStart();
+            if (trimmedStart.startsWith('/')) {
+                const matches = await getSuggestions(trimmedStart);
+                if (isMounted) {
+                    setSuggestions(matches);
+                    const parts = trimmedStart.split(/\s+/);
+                    const currentToken = trimmedStart.endsWith(' ') ? '' : parts[parts.length - 1];
+                    const exactMatchIndex = trimmedStart.length > 1 && currentToken.length > 0
+                        ? matches.findIndex((m) => m.name.toLowerCase().startsWith(currentToken.toLowerCase()))
+                        : -1;
+                    setSelectedIndex(exactMatchIndex !== -1 ? exactMatchIndex : matches.length > 0 ? 0 : -1);
+                    setStartIndex(0);
+                }
+            }
+            else {
+                if (isMounted) {
+                    setSuggestions([]);
+                    setSelectedIndex(-1);
+                }
+            }
+        };
+        updateSuggestions();
+        return () => {
+            isMounted = false;
+        };
+    }, [value, getSuggestions, isListClosed, isConfirming]);
+    const navigateSuggestions = useCallback((direction) => {
+        if (suggestions.length === 0 || isListClosed)
+            return false;
+        const maxVisible = UI_CONFIG.MAX_SUGGESTIONS;
+        let newIndex = selectedIndex;
+        if (direction === 'up') {
+            newIndex = selectedIndex <= 0 ? suggestions.length - 1 : selectedIndex - 1;
+        }
+        else {
+            newIndex = selectedIndex === suggestions.length - 1 ? 0 : selectedIndex + 1;
+        }
+        setSelectedIndex(newIndex);
+        if (newIndex < startIndex) {
+            setStartIndex(newIndex);
+        }
+        else if (newIndex >= startIndex + maxVisible) {
+            setStartIndex(newIndex - maxVisible + 1);
+        }
+        return true;
+    }, [suggestions, isListClosed, selectedIndex, startIndex]);
+    return {
+        suggestions,
+        selectedIndex,
+        startIndex,
+        isListClosed,
+        setIsListClosed,
+        setSuggestions,
+        setSelectedIndex,
+        setStartIndex,
+        navigateSuggestions,
+        activeCommand,
+    };
+}
+//# sourceMappingURL=useCommandSuggestions.js.map

package/dist/cli/ui/hooks/useInputHistory.js

@@ -0,0 +1,57 @@
+import { useState, useCallback, useRef, useEffect } from 'react';
+import { useUIStore } from '../store/context.js';
+export function useInputHistory(currentValue, onChange) {
+    const { state } = useUIStore();
+    // Use ref to track index synchronously to avoid closure staleness during rapid key presses
+    const historyIndexRef = useRef(-1);
+    const [historyIndex, setHistoryIndex] = useState(-1);
+    const [originalInput, setOriginalInput] = useState('');
+    // Sync ref with state (for external updates like reset)
+    useEffect(() => {
+        historyIndexRef.current = historyIndex;
+    }, [historyIndex]);
+    // When the store replaces history (e.g. switching sessions), reset navigation state.
+    useEffect(() => {
+        historyIndexRef.current = -1;
+        setHistoryIndex(-1);
+        setOriginalInput('');
+    }, [state.inputHistory]);
+    const navigateHistory = useCallback((direction) => {
+        const history = [...state.inputHistory].reverse();
+        const currentIndex = historyIndexRef.current;
+        if (direction === 'up') {
+            if (currentIndex === -1) {
+                setOriginalInput(currentValue);
+            }
+            const nextIndex = currentIndex + 1;
+            if (nextIndex < history.length) {
+                historyIndexRef.current = nextIndex;
+                setHistoryIndex(nextIndex);
+                onChange(history[nextIndex]);
+                return true;
+            }
+        }
+        else {
+            if (currentIndex > 0) {
+                const nextIndex = currentIndex - 1;
+                historyIndexRef.current = nextIndex;
+                setHistoryIndex(nextIndex);
+                onChange(history[nextIndex]);
+                return true;
+            }
+            else if (currentIndex === 0) {
+                historyIndexRef.current = -1;
+                setHistoryIndex(-1);
+                onChange(originalInput);
+                return true;
+            }
+        }
+        return false;
+    }, [state.inputHistory, currentValue, originalInput, onChange]);
+    const resetHistory = useCallback(() => {
+        historyIndexRef.current = -1;
+        setHistoryIndex(-1);
+    }, []);
+    return { navigateHistory, resetHistory };
+}
+//# sourceMappingURL=useInputHistory.js.map

package/dist/cli/ui/hooks/useLoopEvents.js

@@ -0,0 +1,382 @@
+import { useEffect, useCallback, useRef } from 'react';
+import { mapErrorForDisplay } from '../../../core/observability/error-mapping.js';
+import { KAOMOJI } from '../../../core/ui/kaomoji.js';
+import { text } from '../../locales/index.js';
+import { useUIStore } from '../store/context.js';
+import { prepareMessagePayload, sanitizeMessage } from '../utils/sanitizer.js';
+/**
+ * Hook to manage loop events and state synchronization.
+ */
+export function useLoopEvents(mode, onStart, signal, options) {
+    const store = useUIStore();
+    const dispatch = store.dispatch;
+    const runStartedRef = useRef(false);
+    const activeStreamIdRef = useRef(null);
+    const logModeRef = useRef('normal');
+    // Throttle state for streaming deltas to prevent render thrashing
+    const streamBufferRef = useRef(new Map());
+    const streamTimerRef = useRef(new Map());
+    const statusBannerTimerRef = useRef(null);
+    const logModeValue = store.state?.logMode ?? 'normal';
+    useEffect(() => {
+        logModeRef.current = logModeValue;
+    }, [logModeValue]);
+    const dispatchSanitizedMessage = useCallback((ev) => {
+        const payload = prepareMessagePayload(ev);
+        if (!payload.content || payload.content.trim() === '')
+            return;
+        dispatch({
+            type: 'ADD_MESSAGE',
+            payload,
+        });
+    }, [dispatch]);
+    // Throttled dispatch for streaming deltas (100ms batching)
+    const throttledStreamDispatch = useCallback((streamId, delta, timestamp) => {
+        const buffer = streamBufferRef.current.get(streamId);
+        if (buffer) {
+            // Accumulate delta into existing buffer
+            buffer.delta += delta;
+            buffer.timestamp = timestamp;
+        }
+        else {
+            // Create new buffer for this stream
+            streamBufferRef.current.set(streamId, { delta, timestamp });
+        }
+        const existingTimer = streamTimerRef.current.get(streamId);
+        if (existingTimer) {
+            return;
+        }
+        // Set new timer to flush after 100ms (true throttle: do not reset per-delta)
+        const timer = setTimeout(() => {
+            const bufferedData = streamBufferRef.current.get(streamId);
+            if (bufferedData) {
+                dispatch({
+                    type: 'APPEND_LLM_STREAM',
+                    payload: {
+                        id: streamId,
+                        delta: bufferedData.delta,
+                        timestamp: bufferedData.timestamp,
+                    },
+                });
+                streamBufferRef.current.delete(streamId);
+                streamTimerRef.current.delete(streamId);
+            }
+        }, 100); // 100ms throttle window
+        streamTimerRef.current.set(streamId, timer);
+    }, [dispatch]);
+    const flushStream = useCallback((streamId) => {
+        const timer = streamTimerRef.current.get(streamId);
+        if (timer)
+            clearTimeout(timer);
+        const bufferedData = streamBufferRef.current.get(streamId);
+        if (bufferedData) {
+            dispatch({
+                type: 'APPEND_LLM_STREAM',
+                payload: {
+                    id: streamId,
+                    delta: bufferedData.delta,
+                    timestamp: bufferedData.timestamp,
+                },
+            });
+        }
+        streamBufferRef.current.delete(streamId);
+        streamTimerRef.current.delete(streamId);
+    }, [dispatch]);
+    // Flush pending throttled buffers so stream output stays chronologically correct.
+    // Stream completion is handled by explicit `llm.stream.end` events.
+    const flushAllStreams = useCallback(() => {
+        const ids = new Set([...streamBufferRef.current.keys(), ...streamTimerRef.current.keys()]);
+        for (const streamId of ids)
+            flushStream(streamId);
+    }, [flushStream]);
+    const handleEvent = useCallback((event) => {
+        if (!event)
+            return;
+        options?.interceptEvent?.(event);
+        const logMode = logModeRef.current;
+        if (event.type === 'ui.status') {
+            if (event.action === 'clear') {
+                dispatch({ type: 'CLEAR_STATUS_BANNER' });
+                return;
+            }
+            if (typeof event.face === 'string' && event.face.trim()) {
+                dispatch({
+                    type: 'SET_STATUS_BANNER',
+                    payload: {
+                        face: event.face,
+                        label: typeof event.label === 'string' ? event.label : '',
+                        source: 'runtime',
+                    },
+                });
+            }
+            if (statusBannerTimerRef.current)
+                clearTimeout(statusBannerTimerRef.current);
+            if (typeof event.ttlMs === 'number' && Number.isFinite(event.ttlMs) && event.ttlMs > 0) {
+                statusBannerTimerRef.current = setTimeout(() => {
+                    dispatch({ type: 'CLEAR_STATUS_BANNER' });
+                }, event.ttlMs);
+            }
+            return;
+        }
+        if (event.type === 'checkpoint.cleaned') {
+            dispatch({
+                type: 'FINALIZE_INTERRUPT',
+                payload: { timestamp: event.timestamp || new Date() },
+            });
+            dispatch({
+                type: 'SET_STATUS_BANNER',
+                payload: { face: KAOMOJI.cleanupDone, label: '', source: 'runtime' },
+            });
+            if (statusBannerTimerRef.current)
+                clearTimeout(statusBannerTimerRef.current);
+            statusBannerTimerRef.current = setTimeout(() => {
+                dispatch({ type: 'CLEAR_STATUS_BANNER', payload: { source: 'runtime' } });
+            }, 2000);
+            return;
+        }
+        // Intercept cancellation errors and treat them as interrupts
+        // This ensures we show the "^C [SPLATTED]" style instead of a generic error
+        const cancellationToken = 'Operation cancelled by user';
+        const messageText = typeof event.message === 'string' ? event.message : '';
+        const isCancellation = (event.type === 'error' && event.error?.message === 'Operation cancelled by user') ||
+            messageText.includes(cancellationToken) ||
+            (typeof event.error === 'string' && event.error.includes('Operation cancelled by user'));
+        if (isCancellation) {
+            const trimmed = messageText.trim();
+            const interruptContent = trimmed === cancellationToken || trimmed === `Failed: ${cancellationToken}`
+                ? ''
+                : trimmed;
+            dispatch({
+                type: 'INTERRUPT_STREAM',
+                payload: {
+                    content: interruptContent,
+                    timestamp: event.timestamp || new Date(),
+                },
+            });
+            return;
+        }
+        if (event.type === 'llm.stream.delta') {
+            const delta = sanitizeMessage({ type: 'assistant', content: event.content });
+            if (!delta)
+                return;
+            if (activeStreamIdRef.current && activeStreamIdRef.current !== event.streamId) {
+                flushStream(activeStreamIdRef.current);
+                dispatch({ type: 'COMPLETE_STREAM', payload: { id: activeStreamIdRef.current } });
+            }
+            activeStreamIdRef.current = event.streamId;
+            // Use throttled dispatch instead of direct dispatch
+            throttledStreamDispatch(event.streamId, delta, event.timestamp || new Date());
+            return;
+        }
+        if (event.type === 'llm.stream.end') {
+            flushStream(event.streamId);
+            dispatch({ type: 'COMPLETE_STREAM', payload: { id: event.streamId } });
+            if (activeStreamIdRef.current === event.streamId)
+                activeStreamIdRef.current = null;
+            return;
+        }
+        // For all non-streaming events, flush pending streams first to maintain chronological order
+        // This prevents throttled stream messages from appearing AFTER events that occurred earlier
+        flushAllStreams();
+        if (event.type === 'retry') {
+            const fromAttempt = typeof event.fromAttempt === 'number' ? event.fromAttempt : 0;
+            const toAttempt = typeof event.toAttempt === 'number' ? event.toAttempt : fromAttempt + 1;
+            const reason = typeof event.reason === 'string' ? event.reason : '';
+            dispatchSanitizedMessage({
+                type: 'warning',
+                content: text.loop.retryingAttempt(fromAttempt, toAttempt, reason),
+                timestamp: event.timestamp,
+            });
+            return;
+        }
+        if (event.type === 'llm.output') {
+            // Full output message (non-streaming path).
+            dispatchSanitizedMessage({
+                type: 'assistant',
+                content: event.content,
+                timestamp: event.timestamp,
+            });
+            return;
+        }
+        if (event.type === 'log') {
+            const msg = event.message || '';
+            const level = String(event.level || 'info');
+            if (logMode === 'quiet' || logMode === 'normal') {
+                if (level !== 'warn' && level !== 'error') {
+                    return;
+                }
+            }
+            const type = event.level === 'error' ? 'error' : event.level === 'warn' ? 'warning' : 'system';
+            const content = mapErrorForDisplay({ message: msg, code: event.code }).message;
+            dispatchSanitizedMessage({ content, type, timestamp: event.timestamp });
+        }
+        else if (event.type === 'snapshot.created') {
+            // Handle structured snapshot event
+            if (logMode === 'quiet')
+                return;
+            dispatchSanitizedMessage({
+                type: 'checkpoint',
+                content: event.commitHash.slice(0, 8),
+                timestamp: event.timestamp,
+            });
+        }
+        else if (event.content || event.message) {
+            if (logMode === 'debug') {
+                dispatchSanitizedMessage(event);
+            }
+        }
+        switch (event.type) {
+            case 'phase.start': {
+                dispatch({ type: 'UPDATE_PHASE', payload: event.phase, status: 'running' });
+                // Explicit mapping: Add blue label messages to the UI list when key phases start
+                const phaseTypeMap = {
+                    PREFLIGHT: 'preflight_step',
+                    PREPARE_DEPS: 'preflight_step',
+                    CONTEXT: 'context_step',
+                    EXPLORE: 'explore_step',
+                    PLAN: 'plan_step',
+                    PATCH: 'patch_step',
+                    APPLY: 'apply_step',
+                    VALIDATE: 'validate_step',
+                    AST_VALIDATE: 'ast_validate_step',
+                    VERIFY: 'verify_step',
+                    ROLLBACK: 'rollback_step',
+                    SHRINK: 'shrink_step',
+                    REVIEW: 'review_step',
+                    REPORT: 'report_step',
+                    ANALYZE_ISSUES: 'analyze_issues_step',
+                };
+                const guiType = phaseTypeMap[event.phase.toUpperCase()];
+                if (guiType) {
+                    const phaseKey = event.phase.toLowerCase();
+                    const phaseName = text.progress[phaseKey] || event.phase;
+                    if (logMode !== 'quiet' && logMode !== 'normal' && logMode !== 'debug')
+                        break;
+                    dispatch({
+                        type: 'ADD_MESSAGE',
+                        payload: {
+                            id: `phase-${event.phase}-${Date.now()}`,
+                            type: guiType,
+                            content: phaseName,
+                            timestamp: event.timestamp || new Date(),
+                        },
+                    });
+                }
+                break;
+            }
+            case 'phase.end': {
+                dispatch({
+                    type: 'UPDATE_PHASE',
+                    payload: event.phase,
+                    status: event.success ? 'success' : 'failed',
+                });
+                break;
+            }
+            case 'workspace.ready':
+                dispatch({
+                    type: 'UPDATE_WORKSPACE',
+                    payload: { path: event.path, isShadow: event.strategy === 'worktree' },
+                });
+                break;
+            case 'diff.meta':
+                dispatch({
+                    type: 'SET_CHANGED_FILES',
+                    payload: event.changedFiles,
+                });
+                if (logMode !== 'quiet' && logMode !== 'normal' && logMode !== 'debug')
+                    break;
+                dispatchSanitizedMessage({
+                    type: 'report_step',
+                    content: text.cli.uiDiffMeta(event.fileCount, event.lineCount),
+                    timestamp: event.timestamp || new Date(),
+                });
+                break;
+            case 'verify.result':
+                if (event.ok) {
+                    if (logMode !== 'quiet') {
+                        dispatchSanitizedMessage({
+                            type: 'verify_step',
+                            content: text.cli.uiVerifyPassed,
+                            timestamp: event.timestamp || new Date(),
+                        });
+                    }
+                    break;
+                }
+                dispatchSanitizedMessage({
+                    type: 'verify_step',
+                    content: text.cli.uiVerifyFailed,
+                    timestamp: event.timestamp || new Date(),
+                });
+                if (typeof event.output === 'string' && event.output.trim()) {
+                    dispatchSanitizedMessage({
+                        type: 'error',
+                        content: event.output,
+                        timestamp: event.timestamp || new Date(),
+                    });
+                }
+                break;
+            case 'tool.call.start':
+                if (logMode !== 'debug')
+                    break;
+                dispatchSanitizedMessage({
+                    type: 'tool_call',
+                    content: `${event.toolName}`,
+                    timestamp: event.timestamp || new Date(),
+                    metadata: { toolName: event.toolName, phase: event.phase, callId: event.callId },
+                });
+                break;
+            case 'tool.call.end': {
+                const status = String(event.status || 'unknown');
+                const isFailure = status !== 'ok';
+                if (logMode !== 'debug') {
+                    if (isFailure) {
+                        dispatchSanitizedMessage({
+                            type: 'warning',
+                            content: text.cli.uiToolFailed(String(event.toolName || 'tool'), status),
+                            timestamp: event.timestamp || new Date(),
+                        });
+                    }
+                    break;
+                }
+                const durationText = typeof event.durationMs === 'number' ? ` (${Math.round(event.durationMs)}ms)` : '';
+                const errorText = event.errorCode ? ` code=${event.errorCode}` : '';
+                dispatchSanitizedMessage({
+                    type: 'tool_result',
+                    content: `${event.toolName}: ${status}${durationText}${errorText}`,
+                    timestamp: event.timestamp || new Date(),
+                    metadata: {
+                        toolName: event.toolName,
+                        phase: event.phase,
+                        callId: event.callId,
+                        status,
+                        errorCode: event.errorCode,
+                        durationMs: event.durationMs,
+                    },
+                });
+                break;
+            }
+        }
+    }, [dispatch, dispatchSanitizedMessage, throttledStreamDispatch, flushAllStreams]);
+    useEffect(() => {
+        if (mode === 'run') {
+            if (runStartedRef.current)
+                return;
+            runStartedRef.current = true;
+            onStart((event) => handleEvent(event), { signal });
+        }
+    }, [mode, onStart, signal, handleEvent]);
+    // Cleanup timers on unmount
+    useEffect(() => {
+        return () => {
+            if (statusBannerTimerRef.current) {
+                clearTimeout(statusBannerTimerRef.current);
+                statusBannerTimerRef.current = null;
+            }
+            streamTimerRef.current.forEach((timer) => clearTimeout(timer));
+            streamTimerRef.current.clear();
+            streamBufferRef.current.clear();
+        };
+    }, []);
+    return { sanitizeAndDispatch: handleEvent };
+}
+//# sourceMappingURL=useLoopEvents.js.map

package/dist/cli/ui/hooks/useLoopState.js

@@ -0,0 +1,73 @@
+import { useState, useCallback } from 'react';
+export function useLoopState() {
+    const [state, setState] = useState({
+        phase: 'IDLE',
+        status: 'idle',
+        logs: [
+            {
+                id: 'welcome',
+                message: 'WELCOME_LOGO',
+                level: 'info',
+                timestamp: new Date(),
+            },
+        ],
+        progress: 0,
+        history: [],
+    });
+    const handleEvent = useCallback((event) => {
+        setState((prev) => {
+            switch (event.type) {
+                case 'phase.start':
+                    return {
+                        ...prev,
+                        phase: event.phase,
+                        status: 'running',
+                    };
+                case 'log':
+                    return {
+                        ...prev,
+                        logs: [
+                            ...prev.logs,
+                            {
+                                id: Math.random().toString(36).substring(7),
+                                message: event.message,
+                                level: event.level,
+                                timestamp: event.timestamp,
+                            },
+                        ].slice(-100),
+                    };
+                case 'phase.end':
+                    if (event.phase === 'VERIFY' && event.success) {
+                        return { ...prev, status: 'success', progress: 100 };
+                    }
+                    return prev;
+                case 'checkpoint.created':
+                    return {
+                        ...prev,
+                        logs: [
+                            ...prev.logs,
+                            {
+                                id: 'clear-' + Date.now(),
+                                message: '--- SCREEN CLEARED ---',
+                                level: 'info',
+                                timestamp: new Date(),
+                            },
+                        ],
+                    };
+                case 'workspace.ready':
+                    return {
+                        ...prev,
+                        workspaceInfo: {
+                            path: event.path,
+                            strategy: event.strategy,
+                            isShadow: event.strategy === 'worktree',
+                        },
+                    };
+                default:
+                    return prev;
+            }
+        });
+    }, []);
+    return { state, handleEvent };
+}
+//# sourceMappingURL=useLoopState.js.map

package/dist/cli/ui/hooks/useOnionExit.js

@@ -0,0 +1,31 @@
+import { useInput } from 'ink';
+import { useUIStore } from '../store/context.js';
+export const useOnionExit = () => {
+    const { state, dispatch } = useUIStore();
+    const { contextStack } = state;
+    useInput((input, key) => {
+        if (key.escape) {
+            if (contextStack.length > 1) {
+                // Pop the top context (Onion Model)
+                dispatch({ type: 'POP_CONTEXT' });
+            }
+            else {
+                // If only 'base' is left, push 'exit-confirm'
+                dispatch({ type: 'PUSH_CONTEXT', payload: 'exit-confirm' });
+            }
+        }
+        if (contextStack.includes('exit-confirm')) {
+            if (input.toLowerCase() === 'y') {
+                process.exit(0);
+            }
+            else if (input.toLowerCase() === 'n' || key.escape) {
+                dispatch({ type: 'POP_CONTEXT' });
+            }
+        }
+    });
+    return {
+        currentContext: contextStack[contextStack.length - 1],
+        isExitConfirming: contextStack.includes('exit-confirm'),
+    };
+};
+//# sourceMappingURL=useOnionExit.js.map

package/dist/cli/ui/hooks/useTerminalDimensions.js

@@ -0,0 +1,34 @@
+import { useStdout } from 'ink';
+import { useEffect, useRef } from 'react';
+import { UI_CONFIG } from '../config.js';
+import { useUIStore } from '../store/context.js';
+/**
+ * Hook to handle terminal resizing with throttling.
+ */
+export function useTerminalDimensions() {
+    const { stdout } = useStdout();
+    const { dispatch } = useUIStore();
+    const resizeTimer = useRef(null);
+    useEffect(() => {
+        const handleResize = () => {
+            if (resizeTimer.current)
+                clearTimeout(resizeTimer.current);
+            resizeTimer.current = setTimeout(() => {
+                dispatch({
+                    type: 'UPDATE_DIMENSIONS',
+                    payload: {
+                        width: stdout?.columns || UI_CONFIG.DEFAULT_WIDTH,
+                        height: stdout?.rows || UI_CONFIG.DEFAULT_HEIGHT,
+                    },
+                });
+            }, UI_CONFIG.RESIZE_THROTTLE_MS);
+        };
+        stdout?.on('resize', handleResize);
+        return () => {
+            stdout?.off('resize', handleResize);
+            if (resizeTimer.current)
+                clearTimeout(resizeTimer.current);
+        };
+    }, [stdout, dispatch]);
+}
+//# sourceMappingURL=useTerminalDimensions.js.map