erosolar-cli 1.7.439 → 1.7.441

package/dist/ui/display.js

@@ -0,0 +1,756 @@
+/**
+ * Display - Simplified UI facade that routes all output through UnifiedUIRenderer
+ *
+ * This class now serves as a compatibility layer, providing the same API
+ * but delegating all actual rendering to UnifiedUIRenderer.
+ */
+import { theme, icons } from './theme.js';
+import { renderMessagePanel, renderMessageBody } from './richText.js';
+import { getTerminalColumns } from './layout.js';
+import { highlightError } from './textHighlighter.js';
+import { renderSectionHeading } from './designSystem.js';
+import { isPlainOutputMode } from './outputMode.js';
+// Display configuration constants
+const DISPLAY_CONSTANTS = {
+    MIN_BANNER_WIDTH: 32,
+    MAX_BANNER_WIDTH: 120,
+    BANNER_PADDING: 4,
+    MIN_MESSAGE_WIDTH: 42,
+    MAX_MESSAGE_WIDTH: 110,
+    MESSAGE_PADDING: 4,
+    MIN_ACTION_WIDTH: 40,
+    MAX_ACTION_WIDTH: 90,
+    MIN_THOUGHT_WIDTH: 48,
+    MAX_THOUGHT_WIDTH: 96,
+    MIN_CONTENT_WIDTH: 10,
+    MIN_WRAP_WIDTH: 12,
+};
+/**
+ * Display class - now a thin wrapper around UnifiedUIRenderer
+ *
+ * Provides backward-compatible API while routing all output through the renderer.
+ */
+export class Display {
+    outputStream;
+    errorStream;
+    renderer = null;
+    outputInterceptors = new Set();
+    // Legacy spinner support for compatibility with existing tests/callers
+    activeSpinner = null;
+    thinkingStartTime = null;
+    constructor(stream = process.stdout, errorStream) {
+        this.outputStream = stream;
+        this.errorStream = errorStream ?? stream;
+    }
+    setRenderer(renderer) {
+        this.renderer = renderer;
+    }
+    enqueueEvent(type, content) {
+        if (!this.renderer || !content) {
+            return false;
+        }
+        this.renderer.addEvent(type, content);
+        return true;
+    }
+    registerOutputInterceptor(interceptor) {
+        if (!interceptor) {
+            return () => { };
+        }
+        this.outputInterceptors.add(interceptor);
+        return () => {
+            this.outputInterceptors.delete(interceptor);
+        };
+    }
+    notifyBeforeOutput() {
+        for (const interceptor of this.outputInterceptors) {
+            interceptor.beforeWrite?.();
+        }
+    }
+    notifyAfterOutput(content) {
+        const interceptors = Array.from(this.outputInterceptors);
+        for (let index = interceptors.length - 1; index >= 0; index -= 1) {
+            interceptors[index]?.afterWrite?.(content);
+        }
+    }
+    /**
+     * Clear any active spinner for backward compatibility with legacy rendering.
+     * Optionally emits a newline to separate subsequent output.
+     */
+    clearActiveSpinner(addNewLine) {
+        if (!this.activeSpinner) {
+            return;
+        }
+        const spinner = this.activeSpinner;
+        this.activeSpinner = null;
+        if (typeof spinner.clear === 'function') {
+            spinner.clear();
+        }
+        else if (typeof spinner.stop === 'function') {
+            spinner.stop();
+        }
+        if (addNewLine) {
+            if (!this.enqueueEvent('raw', '\n')) {
+                this.outputStream.write('\n');
+            }
+        }
+    }
+    /**
+     * Write raw content directly
+     */
+    writeRaw(content) {
+        if (!content)
+            return;
+        this.notifyBeforeOutput();
+        if (this.enqueueEvent('raw', content)) {
+            this.notifyAfterOutput(content);
+            return;
+        }
+        // Fallback if no renderer
+        this.outputStream.write(content);
+        this.notifyAfterOutput(content);
+    }
+    /**
+     * Stream chunk (for streaming responses)
+     */
+    stream(chunk) {
+        if (!chunk)
+            return;
+        this.notifyBeforeOutput();
+        if (this.enqueueEvent('streaming', chunk)) {
+            this.notifyAfterOutput(chunk);
+            return;
+        }
+        // Fallback
+        this.outputStream.write(chunk);
+        this.notifyAfterOutput(chunk);
+    }
+    /**
+     * Backward-compatible alias
+     */
+    writeStreamChunk(chunk) {
+        this.stream(chunk);
+    }
+    /**
+     * Get the output stream for direct access
+     */
+    getOutputStream() {
+        return this.outputStream;
+    }
+    /**
+     * Show thinking indicator
+     */
+    showThinking(message = 'Thinking…') {
+        this.thinkingStartTime = Date.now();
+        this.enqueueEvent('response', message);
+    }
+    /**
+     * Update thinking message
+     */
+    updateThinking(message) {
+        this.enqueueEvent('response', message);
+    }
+    /**
+     * Stop thinking
+     */
+    stopThinking(_addNewLine = true) {
+        this.clearActiveSpinner(_addNewLine);
+        this.thinkingStartTime = null;
+    }
+    /**
+     * Get thinking elapsed time
+     */
+    getThinkingElapsedMs() {
+        if (!this.thinkingStartTime) {
+            return null;
+        }
+        return Date.now() - this.thinkingStartTime;
+    }
+    /**
+     * Check if spinner is active (always false with new renderer)
+     */
+    isSpinnerActive() {
+        return false;
+    }
+    /**
+     * Check if output is locked (always false with event queue)
+     */
+    isOutputLocked() {
+        return false;
+    }
+    /**
+     * Safe write (just calls callback immediately with event queue)
+     */
+    safeWrite(callback) {
+        callback();
+    }
+    /**
+     * Show assistant message
+     */
+    showAssistantMessage(content, metadata) {
+        this.clearActiveSpinner(false);
+        if (!content.trim())
+            return;
+        const isThought = metadata?.isFinal === false;
+        const body = isThought ? this.buildClaudeStyleThought(content) : this.buildChatBox(content, metadata);
+        if (!body.trim())
+            return;
+        const wrapped = isThought ? this.applySingleBulletBlock(body) : body;
+        const output = `\n${wrapped}\n\n`;
+        this.notifyBeforeOutput();
+        if (!this.enqueueEvent('raw', output)) {
+            // Fallback if no renderer
+            this.outputStream.write(output);
+        }
+        this.notifyAfterOutput(output);
+    }
+    /**
+     * Show narrative (thought)
+     */
+    showNarrative(content) {
+        if (!content.trim())
+            return;
+        this.showAssistantMessage(content, { isFinal: false });
+    }
+    /**
+     * Show action
+     */
+    showAction(text, status = 'info') {
+        if (!text.trim())
+            return;
+        const icon = this.formatActionIcon(status);
+        const rendered = this.wrapWithPrefix(text, `${icon} `);
+        this.enqueueEvent('raw', `${rendered}\n`);
+    }
+    /**
+     * Show sub-action
+     */
+    showSubAction(text, status = 'info') {
+        if (!text.trim())
+            return;
+        const lines = this.buildWrappedSubActionLines(text, status);
+        if (!lines.length)
+            return;
+        this.enqueueEvent('raw', `${lines.join('\n')}\n\n`);
+    }
+    /**
+     * Show message
+     */
+    showMessage(content, role = 'assistant') {
+        if (role === 'system') {
+            this.showSystemMessage(content);
+        }
+        else {
+            this.showAssistantMessage(content);
+        }
+    }
+    /**
+     * Show system message
+     */
+    showSystemMessage(content) {
+        const normalized = content.trim();
+        if (!normalized)
+            return;
+        this.stream(`${normalized}\n\n`);
+    }
+    /**
+     * Show error
+     */
+    showError(message, error) {
+        const details = this.formatErrorDetails(error);
+        const parts = [`${theme.error('✗')} ${message}`];
+        if (details) {
+            parts.push(`  ${details}`);
+        }
+        this.stream(`${parts.join('\n')}\n`);
+    }
+    /**
+     * Show warning
+     */
+    showWarning(message) {
+        this.stream(`${theme.warning('!')} ${message}\n`);
+    }
+    /**
+     * Show info
+     */
+    showInfo(message) {
+        this.stream(`${theme.info('ℹ')} ${message}\n`);
+    }
+    /**
+     * Show success
+     */
+    showSuccess(message) {
+        this.stream(`${theme.success('✓')} ${message}\n`);
+    }
+    /**
+     * Show progress badge
+     */
+    showProgressBadge(label, current, total) {
+        const percentage = Math.round((current / total) * 100);
+        const barWidth = 20;
+        const filled = Math.round((current / total) * barWidth);
+        const empty = barWidth - filled;
+        const progressBar = `${'█'.repeat(filled)}${'░'.repeat(empty)}`;
+        const badge = `[${label}] ${progressBar} ${percentage}%`;
+        this.stream(`\r${theme.info(badge)}`);
+        if (current >= total) {
+            this.stream('\n');
+        }
+    }
+    /**
+     * Show status line
+     */
+    showStatusLine(status, elapsedMs, _context) {
+        const normalized = status?.trim();
+        if (!normalized)
+            return;
+        const elapsed = this.formatElapsed(elapsedMs);
+        const parts = [];
+        parts.push(`${theme.success('✓')} ${normalized}`);
+        if (elapsed) {
+            parts.push(`(${elapsed})`);
+        }
+        this.stream(`${parts.join(' ')}\n`);
+    }
+    /**
+     * Show available tools (no-op)
+     */
+    showAvailableTools(_tools) {
+        // Hidden by default
+    }
+    /**
+     * Show command palette
+     */
+    showCommandPalette(commands, options) {
+        if (!commands || commands.length === 0)
+            return;
+        const panel = this.buildCommandPalette(commands, options);
+        if (!panel.trim())
+            return;
+        this.enqueueEvent('raw', `\n${panel}\n\n`);
+    }
+    /**
+     * Show ready with hints (no-op)
+     */
+    showReadyWithHints() {
+        // Commands hint is now in the renderer
+    }
+    /**
+     * Show planning step
+     */
+    showPlanningStep(step, index, total) {
+        if (!step?.trim() || index < 1 || total < 1 || index > total)
+            return;
+        const width = Math.max(DISPLAY_CONSTANTS.MIN_THOUGHT_WIDTH, Math.min(this.getColumnWidth(), DISPLAY_CONSTANTS.MAX_MESSAGE_WIDTH));
+        const heading = renderSectionHeading(`Plan ${index}/${total}`, {
+            subtitle: step,
+            icon: icons.arrow,
+            tone: 'info',
+            width,
+        });
+        this.enqueueEvent('raw', `${heading}\n`);
+    }
+    /**
+     * Show thinking block
+     */
+    showThinkingBlock(content, durationMs) {
+        const block = this.buildClaudeStyleThought(content, durationMs);
+        this.enqueueEvent('raw', `\n${block}\n\n`);
+    }
+    /**
+     * Clear screen
+     */
+    clear() {
+        // Renderer handles this
+    }
+    /**
+     * Update streaming status (routes to renderer)
+     */
+    updateStreamingStatus(status) {
+        this.renderer?.updateStatus(status);
+    }
+    /**
+     * Clear streaming status
+     */
+    clearStreamingStatus() {
+        this.renderer?.updateStatus(null);
+    }
+    /**
+     * Check if streaming status is visible
+     */
+    isStreamingStatusVisible() {
+        return false; // Renderer manages this
+    }
+    /**
+     * Legacy compatibility methods (no-ops)
+     */
+    getTotalWrittenLines() {
+        return 0;
+    }
+    getPinnedHeaderLines() {
+        return 0;
+    }
+    setupScrollRegion() {
+        // No-op - renderer handles layout
+    }
+    teardownScrollRegion() {
+        // No-op
+    }
+    isScrollRegionActive() {
+        return false;
+    }
+    parallelAgentStatus(content) {
+        if (!content)
+            return;
+        this.enqueueEvent('streaming', `${content}\n`);
+    }
+    // ==================== Private Helper Methods ====================
+    getColumnWidth() {
+        if (typeof this.outputStream.columns === 'number' &&
+            Number.isFinite(this.outputStream.columns) &&
+            this.outputStream.columns > 0) {
+            return this.outputStream.columns;
+        }
+        return getTerminalColumns();
+    }
+    formatErrorDetails(error) {
+        if (!error)
+            return null;
+        if (error instanceof Error) {
+            if (error.stack)
+                return highlightError(error.stack);
+            return highlightError(error.message);
+        }
+        if (typeof error === 'string') {
+            return highlightError(error);
+        }
+        try {
+            return highlightError(JSON.stringify(error, null, 2));
+        }
+        catch {
+            return null;
+        }
+    }
+    formatElapsed(elapsedMs) {
+        if (typeof elapsedMs !== 'number' || !Number.isFinite(elapsedMs) || elapsedMs < 0) {
+            return null;
+        }
+        const totalSeconds = Math.max(0, Math.round(elapsedMs / 1000));
+        const minutes = Math.floor(totalSeconds / 60);
+        const seconds = totalSeconds % 60;
+        if (minutes > 0) {
+            return `${minutes}m ${seconds.toString().padStart(2, '0')}s`;
+        }
+        return `${seconds}s`;
+    }
+    buildChatBox(content, metadata) {
+        const normalized = content.trim();
+        if (!normalized)
+            return '';
+        if (isPlainOutputMode()) {
+            const body = renderMessageBody(normalized, this.resolveMessageWidth());
+            const telemetry = this.formatTelemetryLine(metadata);
+            return telemetry ? `${body}\n${telemetry}` : body;
+        }
+        const width = this.resolveMessageWidth();
+        const panel = renderMessagePanel(normalized, {
+            width,
+            title: 'Assistant',
+            icon: icons.assistant,
+            accentColor: theme.assistant ?? theme.primary,
+            borderColor: theme.ui.border,
+        });
+        const telemetry = this.formatTelemetryLine(metadata);
+        return telemetry ? `${panel}\n${telemetry}` : panel;
+    }
+    resolveMessageWidth() {
+        const columns = this.getColumnWidth();
+        return Math.max(DISPLAY_CONSTANTS.MIN_MESSAGE_WIDTH, Math.min(columns - DISPLAY_CONSTANTS.MESSAGE_PADDING, DISPLAY_CONSTANTS.MAX_MESSAGE_WIDTH));
+    }
+    formatTelemetryLine(metadata) {
+        if (!metadata)
+            return '';
+        const parts = [];
+        const elapsed = this.formatElapsed(metadata.elapsedMs);
+        if (elapsed) {
+            const elapsedLabel = theme.metrics?.elapsedLabel ?? theme.accent;
+            const elapsedValue = theme.metrics?.elapsedValue ?? theme.secondary;
+            parts.push(`${elapsedLabel('elapsed')} ${elapsedValue(elapsed)}`);
+        }
+        if (!parts.length)
+            return '';
+        const separator = theme.ui.muted(' • ');
+        return `  ${parts.join(separator)}`;
+    }
+    buildClaudeStyleThought(content, durationMs) {
+        const thinkingStyle = theme.thinking || {
+            icon: theme.info,
+            text: theme.ui.muted,
+            border: theme.ui.border,
+            label: theme.info,
+        };
+        const width = Math.min(this.getColumnWidth() - 4, 70);
+        const lines = [];
+        // Header
+        if (durationMs !== undefined) {
+            const elapsed = this.formatElapsedTime(Math.floor(durationMs / 1000));
+            lines.push(`${theme.info('∴')} Thought for ${elapsed}`);
+        }
+        else {
+            lines.push(`${theme.info('✻')} ${thinkingStyle.label('Thinking…')}`);
+        }
+        // Content
+        const contentLines = content.split('\n');
+        const hasContent = contentLines.some(line => line.trim().length > 0);
+        if (hasContent) {
+            lines.push('');
+        }
+        for (const line of contentLines) {
+            const trimmed = line.replace(/\s+$/, '');
+            if (!trimmed.trim()) {
+                lines.push('');
+                continue;
+            }
+            const wrapped = this.wrapLine(trimmed, width - 4);
+            for (const wrappedLine of wrapped) {
+                lines.push(`  ${thinkingStyle.text(wrappedLine)}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    formatElapsedTime(seconds) {
+        if (seconds < 60) {
+            return `${seconds}s`;
+        }
+        const mins = Math.floor(seconds / 60);
+        const secs = seconds % 60;
+        return secs > 0 ? `${mins}m ${secs}s` : `${mins}m`;
+    }
+    applySingleBulletBlock(text) {
+        const lines = text.split('\n');
+        const bullet = `${icons.action} `;
+        const prefix = theme.info(bullet);
+        const indent = ' '.repeat(this.visibleLength(this.stripAnsi(bullet)));
+        return lines
+            .map((line, index) => (index === 0 ? `${prefix}${line}` : `${indent}${line}`))
+            .join('\n');
+    }
+    buildCommandPalette(commands, options) {
+        if (!commands.length)
+            return '';
+        const width = Math.max(DISPLAY_CONSTANTS.MIN_MESSAGE_WIDTH, Math.min(this.getColumnWidth() - 2, DISPLAY_CONSTANTS.MAX_MESSAGE_WIDTH));
+        const indent = '  ';
+        const grouped = this.groupPaletteCommands(commands);
+        const commandWidth = this.computeCommandColumnWidth(commands, width, indent.length);
+        const descWidth = Math.max(DISPLAY_CONSTANTS.MIN_WRAP_WIDTH, width - indent.length - commandWidth - 1);
+        const title = options?.title ?? 'Slash commands';
+        const intro = options?.intro ?? 'Describe a task or pick a command below:';
+        const lines = [];
+        lines.push(theme.gradient.primary(title));
+        const introLines = this.wrapLine(intro, width);
+        for (const line of introLines) {
+            lines.push(theme.ui.muted(line));
+        }
+        lines.push('');
+        grouped.forEach(({ category, items }, index) => {
+            const label = this.formatPaletteCategory(category);
+            if (label) {
+                lines.push(theme.bold(label));
+            }
+            for (const item of items) {
+                const wrappedDesc = this.wrapLine(item.description, descWidth);
+                const paddedCommand = item.command.padEnd(commandWidth);
+                const commandLabel = theme.primary(paddedCommand);
+                const firstLine = wrappedDesc[0] ?? '';
+                lines.push(`${indent}${commandLabel} ${this.colorizePaletteText(firstLine, item.tone)}`);
+                for (const extra of wrappedDesc.slice(1)) {
+                    lines.push(`${indent}${' '.repeat(commandWidth)} ${this.colorizePaletteText(extra, item.tone)}`);
+                }
+            }
+            if (index < grouped.length - 1) {
+                lines.push('');
+            }
+        });
+        return lines.join('\n').trimEnd();
+    }
+    groupPaletteCommands(commands) {
+        const FALLBACK = 'other';
+        const groups = new Map();
+        for (const item of commands) {
+            const key = (item.category ?? FALLBACK).toLowerCase();
+            const bucket = groups.get(key) ?? [];
+            bucket.push(item);
+            groups.set(key, bucket);
+        }
+        const order = ['configuration', 'workspace', 'diagnostics', 'other'];
+        const orderedKeys = [
+            ...order.filter((key) => groups.has(key)),
+            ...Array.from(groups.keys()).filter((key) => !order.includes(key)),
+        ];
+        return orderedKeys.map((category) => ({ category, items: groups.get(category) ?? [] }));
+    }
+    computeCommandColumnWidth(commands, totalWidth, indentWidth) {
+        const longest = commands.reduce((max, item) => Math.max(max, this.visibleLength(item.command)), 0);
+        const maxAllowed = Math.max(12, Math.min(longest + 2, Math.floor(totalWidth * 0.35)));
+        const budget = Math.max(10, totalWidth - indentWidth - DISPLAY_CONSTANTS.MIN_WRAP_WIDTH);
+        return Math.min(maxAllowed, budget);
+    }
+    formatPaletteCategory(category) {
+        if (!category)
+            return 'Other';
+        switch (category.toLowerCase()) {
+            case 'configuration': return 'Configuration';
+            case 'workspace': return 'Workspace';
+            case 'diagnostics': return 'Diagnostics';
+            case 'other': return 'Other';
+            default: return category[0]?.toUpperCase() + category.slice(1);
+        }
+    }
+    colorizePaletteText(text, tone) {
+        switch (tone) {
+            case 'warn': return theme.warning(text);
+            case 'success': return theme.success(text);
+            case 'info': return theme.info(text);
+            case 'muted':
+            default: return theme.ui.muted(text);
+        }
+    }
+    wrapWithPrefix(text, prefix, options) {
+        if (!text) {
+            return prefix.trimEnd();
+        }
+        const width = Math.max(DISPLAY_CONSTANTS.MIN_ACTION_WIDTH, Math.min(this.getColumnWidth(), DISPLAY_CONSTANTS.MAX_ACTION_WIDTH));
+        const prefixWidth = this.visibleLength(prefix);
+        const available = Math.max(DISPLAY_CONSTANTS.MIN_CONTENT_WIDTH, width - prefixWidth);
+        const indent = typeof options?.continuationPrefix === 'string'
+            ? options.continuationPrefix
+            : ' '.repeat(Math.max(0, prefixWidth));
+        const segments = text.split('\n');
+        const lines = [];
+        let usedPrefix = false;
+        for (const segment of segments) {
+            if (!segment.trim()) {
+                if (usedPrefix) {
+                    lines.push(indent);
+                }
+                else {
+                    lines.push(prefix.trimEnd());
+                    usedPrefix = true;
+                }
+                continue;
+            }
+            const wrapped = this.wrapLine(segment.trim(), available);
+            for (const line of wrapped) {
+                lines.push(!usedPrefix ? `${prefix}${line}` : `${indent}${line}`);
+                usedPrefix = true;
+            }
+        }
+        return lines.join('\n');
+    }
+    buildWrappedSubActionLines(text, status) {
+        const lines = text.split('\n').map((line) => line.trimEnd());
+        while (lines.length && !lines[lines.length - 1]?.trim()) {
+            lines.pop();
+        }
+        if (!lines.length)
+            return [];
+        const rendered = [];
+        for (let index = 0; index < lines.length; index += 1) {
+            const segment = lines[index] ?? '';
+            const isLast = index === lines.length - 1;
+            const { prefix, continuation } = this.buildSubActionPrefixes(status, isLast);
+            rendered.push(this.wrapWithPrefix(segment, prefix, { continuationPrefix: continuation }));
+        }
+        return rendered;
+    }
+    buildSubActionPrefixes(status, isLast) {
+        if (isLast) {
+            const colorize = this.resolveStatusColor(status);
+            return {
+                prefix: `  ${colorize(icons.subaction)} `,
+                continuation: '    ',
+            };
+        }
+        const branch = theme.ui.muted('│');
+        return {
+            prefix: `  ${branch} `,
+            continuation: `  ${branch} `,
+        };
+    }
+    resolveStatusColor(status) {
+        switch (status) {
+            case 'success': return theme.success;
+            case 'error': return theme.error;
+            case 'warning': return theme.warning;
+            case 'pending': return theme.info;
+            default: return theme.secondary;
+        }
+    }
+    formatActionIcon(status) {
+        const colorize = this.resolveStatusColor(status);
+        return colorize(`${icons.action}`);
+    }
+    wrapLine(text, width) {
+        if (width <= 0)
+            return [text];
+        if (!text)
+            return [''];
+        if (text.length <= width)
+            return [text];
+        const words = text.split(/\s+/).filter(Boolean);
+        if (!words.length)
+            return this.chunkWord(text, width);
+        const lines = [];
+        let current = '';
+        for (const word of words) {
+            if (!current) {
+                if (word.length <= width) {
+                    current = word;
+                }
+                else {
+                    const chunks = this.chunkWord(word, width);
+                    lines.push(...chunks.slice(0, -1));
+                    current = chunks[chunks.length - 1] ?? '';
+                }
+            }
+            else if (current.length + 1 + word.length <= width) {
+                current = `${current} ${word}`;
+            }
+            else {
+                lines.push(current);
+                if (word.length <= width) {
+                    current = word;
+                }
+                else {
+                    const chunks = this.chunkWord(word, width);
+                    lines.push(...chunks.slice(0, -1));
+                    current = chunks[chunks.length - 1] ?? '';
+                }
+            }
+        }
+        if (current) {
+            lines.push(current);
+        }
+        return lines.length ? lines : [''];
+    }
+    chunkWord(word, width) {
+        if (width <= 0 || !word)
+            return word ? [word] : [''];
+        const chunks = [];
+        for (let i = 0; i < word.length; i += width) {
+            chunks.push(word.slice(i, i + width));
+        }
+        return chunks.length > 0 ? chunks : [''];
+    }
+    visibleLength(value) {
+        if (!value)
+            return 0;
+        return this.stripAnsi(value).length;
+    }
+    stripAnsi(value) {
+        if (!value)
+            return '';
+        return value.replace(/\u001B\[[0-?]*[ -/]*[@-~]/g, '');
+    }
+}
+export const display = new Display();
+//# sourceMappingURL=display.js.map