@mks2508/mks-ui 0.3.1 → 0.4.0

package/dist/react-ui/blocks/Terminal/parsing/LogParserService.js

@@ -0,0 +1,478 @@
+import { AnsiParser } from "./ansi/AnsiParser.js";
+import { LogLevelDetector } from "./levels/LogLevelDetector.js";
+import { BadgeFormatter } from "./BadgeFormatter.js";
+import { MultilineAggregator } from "./MultilineAggregator.js";
+
+//#region src/react-ui/blocks/Terminal/parsing/LogParserService.ts
+/**
+* Log parser service for terminal log processing.
+*
+* Main service that combines ANSI parsing, log level detection,
+* timestamp extraction, and structured log handling into a
+* unified API for processing log streams.
+*
+* @module components/devenv/terminal/parsing/service
+*/
+/**
+* Timestamp patterns for common log formats.
+*
+* IMPORTANT: Order matters! More specific patterns must come first.
+* The double timestamp pattern MUST be before single timestamp patterns.
+*/
+const TIMESTAMP_PATTERNS = [
+	{
+		regex: /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?)\s+(\d{2}:\d{2}:\d{2}(?:\.\d+)?)\s+/,
+		format: "double",
+		extractIndex: 2
+	},
+	{
+		regex: /^(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}),(\d+)\s+/,
+		format: "supervisord"
+	},
+	{
+		regex: /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?)\s/,
+		format: "iso"
+	},
+	{
+		regex: /^(\d{2}:\d{2}:\d{2}(?:\.\d+)?)\s/,
+		format: "time"
+	},
+	{
+		regex: /^\[(\d{13,})\]\s/,
+		format: "unix"
+	},
+	{
+		regex: /^\[(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2})\]\s/,
+		format: "datetime"
+	},
+	{
+		regex: /^([A-Z][a-z]{2}\s+\d{1,2}\s+\d{2}:\d{2}:\d{2})\s/,
+		format: "syslog"
+	}
+];
+/**
+* Tag extraction pattern.
+* Matches: ⦗COMPONENT⦘ ⦗ROUTES⦘ etc.
+*/
+const TAG_PATTERN = /⦗([^⦘]+)⦘/g;
+/**
+* Log parser service class.
+*
+* Provides unified API for parsing log text with ANSI colorization,
+* log level detection, timestamp extraction, and structured data handling.
+*
+* @example
+* ```ts
+* const parser = new LogParserService();
+* const entry = parser.parseLine('2026-02-05T21:35:28.944Z INFO ⦗API⦘ Message');
+* // entry.level = 'info'
+* // entry.timestamp = '2026-02-05T21:35:28.944Z'
+* // entry.tags = ['API']
+* ```
+*/
+var LogParserService = class {
+	/** ANSI parser instance */
+	ansiParser;
+	/** Log level detector instance */
+	levelDetector;
+	/** Badge formatter instance */
+	badgeFormatter;
+	/** Multiline aggregator instance */
+	multilineAggregator;
+	/** Parser options */
+	options;
+	/**
+	* Create a new log parser service.
+	*
+	* @param options - Parser configuration options
+	*/
+	constructor(options = {}) {
+		this.options = {
+			enable_ansi: true,
+			timestamp_format: "time",
+			enable_structured: true,
+			enable_tags: true,
+			max_line_length: 1e4,
+			level_patterns: {},
+			...options
+		};
+		this.ansiParser = new AnsiParser();
+		this.badgeFormatter = new BadgeFormatter();
+		this.multilineAggregator = new MultilineAggregator();
+		this.levelDetector = new LogLevelDetector({ custom_patterns: this.options.level_patterns ? Object.entries(this.options.level_patterns).map(([level, regex]) => ({
+			level,
+			regex,
+			confidence: .9
+		})) : void 0 });
+	}
+	/**
+	* Parse a single log line into structured entry.
+	*
+	* @param line - Raw log line
+	* @param lineNumber - Line number in stream
+	* @param isStderr - Whether this is from stderr
+	* @returns Parsed log entry
+	*/
+	parseLine(line, lineNumber, isStderr = false) {
+		let raw = line;
+		let wasTruncated = false;
+		if (line.length > this.options.max_line_length) {
+			raw = line.slice(0, this.options.max_line_length) + "... (truncated)";
+			wasTruncated = true;
+		}
+		const levelDetection = this.levelDetector.detect(raw);
+		const level = levelDetection.confidence >= .5 ? levelDetection.level : this.levelDetector.detectOrDefault(raw);
+		const timestamp = this.extractTimestamp(raw);
+		const timestampDisplay = this.formatTimestamp(timestamp);
+		const tags = this.options.enable_tags ? this.extractTags(raw) : void 0;
+		const message = this.extractMessage(raw, timestamp, levelDetection.matched);
+		let formatted = raw;
+		if (this.options.enable_ansi) formatted = this.ansiParser.parse(raw).text;
+		else formatted = AnsiParser.stripAnsi(raw);
+		let structured;
+		if (this.options.enable_structured) structured = this.parseStructured(raw);
+		return {
+			raw: wasTruncated ? raw : line,
+			formatted,
+			level,
+			timestamp,
+			timestamp_display: timestampDisplay,
+			line_number: lineNumber,
+			is_stderr: isStderr,
+			structured,
+			tags,
+			message
+		};
+	}
+	/**
+	* Parse multiple lines (batch processing).
+	*
+	* @param lines - Array of raw log lines
+	* @param startNumber - Starting line number (default: 1)
+	* @returns Array of parsed log entries
+	*/
+	parseLines(lines, startNumber = 1) {
+		return lines.map((line, index) => this.parseLine(line, startNumber + index));
+	}
+	/**
+	* Parse logs with incremental state (for streaming).
+	*
+	* Maintains state between chunks for proper multiline log
+	* aggregation and line numbering. Applies multiline aggregation
+	* to mark continuation lines.
+	*
+	* @param chunk - New log chunk
+	* @param prevState - Previous parser state
+	* @returns Parsed entries and new state
+	*/
+	parseIncremental(chunk, prevState) {
+		const lines = (prevState.buffer + chunk).split("\n");
+		const lastLine = lines.pop() ?? "";
+		let currentLineNumber = prevState.line_number;
+		const entries = [];
+		for (const line of lines) if (line.length > 0) {
+			currentLineNumber++;
+			entries.push(this.parseLine(line, currentLineNumber));
+		}
+		const initialMultilineState = prevState.multiline_state ? {
+			buffer: [],
+			isMultiline: prevState.multiline_state.isMultiline,
+			depth: prevState.multiline_state.depth,
+			expectedClose: prevState.multiline_state.expectedClose,
+			parentEntry: prevState.multiline_state.parentEntry
+		} : void 0;
+		const { entries: aggregated, state: newMultilineState } = this.multilineAggregator.aggregate(entries, initialMultilineState);
+		const lastEntry = aggregated.length > 0 ? aggregated[aggregated.length - 1] : void 0;
+		return {
+			entries: aggregated,
+			newState: {
+				buffer: lastLine,
+				line_number: currentLineNumber,
+				last_level: lastEntry?.level ?? prevState.last_level,
+				last_timestamp: lastEntry?.timestamp ?? prevState.last_timestamp,
+				multiline_state: newMultilineState.isMultiline || newMultilineState.depth > 0 ? {
+					isMultiline: newMultilineState.isMultiline,
+					depth: newMultilineState.depth,
+					expectedClose: newMultilineState.expectedClose,
+					parentEntry: newMultilineState.parentEntry
+				} : void 0
+			}
+		};
+	}
+	/**
+	* Format log entry for xterm.js display.
+	*
+	* Supports two modes:
+	*
+	* **'raw' mode (default for terminal):**
+	* - Returns the log AS-IS without modifications
+	* - Preserves original ANSI codes from the source (bun, supervisord, etc.)
+	* - No badges, no formatting, just the raw log line
+	* - Prevents ANSI mixing artifacts and visible escape codes
+	*
+	* **'parsed' mode (for React viewer):**
+	* - Strips ANSI codes first
+	* - Adds level badge, tag badges, timestamp badge
+	* - Formats message content for React display
+	* - Continuation lines get indented
+	*
+	* @param entry - Parsed log entry
+	* @param mode - Format mode: 'raw' (default) or 'parsed'
+	* @returns Formatted string for xterm.js or React viewer
+	*/
+	formatForTerminal(entry, mode = "raw") {
+		if (mode === "raw") return entry.raw;
+		if (entry.is_continuation) return "  " + AnsiParser.stripAnsi(entry.raw).trimEnd();
+		const parts = [];
+		const levelBadge = this.badgeFormatter.createLevelBadge(entry.level);
+		parts.push(levelBadge);
+		if (entry.tags && entry.tags.length > 0) {
+			const tagBadges = this.badgeFormatter.createTagBadges(entry.tags);
+			if (tagBadges) parts.push(tagBadges);
+		}
+		const messageContent = entry.message ?? AnsiParser.stripAnsi(entry.raw);
+		parts.push(messageContent);
+		let line = parts.join(" ");
+		if (entry.timestamp_display) {
+			const timestampBadge = this.badgeFormatter.createTimestampBadge(entry.timestamp_display);
+			line = line + timestampBadge;
+		}
+		return line;
+	}
+	/**
+	* Check if line contains structured data (JSON).
+	*
+	* @param line - Log line to check
+	* @returns true if line contains valid JSON
+	*/
+	isStructured(line) {
+		const trimmed = line.trim();
+		if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) try {
+			JSON.parse(trimmed);
+			return true;
+		} catch {
+			return false;
+		}
+		return false;
+	}
+	/**
+	* Filter log entries by criteria.
+	*
+	* @param entries - Array of parsed log entries
+	* @param filter - Filter options
+	* @returns Filtered array of entries
+	*/
+	filter(entries, filter) {
+		return entries.filter((entry) => {
+			if (filter.min_level !== void 0) {
+				if (LogLevelDetector.getSeverity(entry.level) < LogLevelDetector.getSeverity(filter.min_level)) return false;
+			}
+			if (filter.stderr_only !== void 0) {
+				if (filter.stderr_only && !entry.is_stderr) return false;
+				if (!filter.stderr_only && entry.is_stderr) return false;
+			}
+			if (filter.pattern) {
+				if (!filter.pattern.test(entry.raw)) return false;
+			}
+			if (filter.tags && filter.tags.length > 0) {
+				if (!entry.tags || !filter.tags.some((t) => entry.tags?.includes(t))) return false;
+			}
+			if (filter.after && entry.timestamp) {
+				if (entry.timestamp < filter.after) return false;
+			}
+			if (filter.before && entry.timestamp) {
+				if (entry.timestamp > filter.before) return false;
+			}
+			return true;
+		});
+	}
+	/**
+	* Calculate statistics for log entries.
+	*
+	* @param entries - Array of parsed log entries
+	* @returns Log statistics
+	*/
+	calculateStats(entries) {
+		const byLevel = {
+			trace: 0,
+			debug: 0,
+			info: 0,
+			warn: 0,
+			error: 0,
+			fatal: 0,
+			unknown: 0
+		};
+		let bytes = 0;
+		let earliest;
+		let latest;
+		for (const entry of entries) {
+			byLevel[entry.level] = (byLevel[entry.level] ?? 0) + 1;
+			bytes += entry.raw.length;
+			if (entry.timestamp) {
+				if (!earliest || entry.timestamp < earliest) earliest = entry.timestamp;
+				if (!latest || entry.timestamp > latest) latest = entry.timestamp;
+			}
+		}
+		return {
+			total: entries.length,
+			by_level: byLevel,
+			bytes,
+			earliest,
+			latest
+		};
+	}
+	/**
+	* Create initial parser state.
+	*
+	* @returns Fresh parser state for incremental parsing
+	*/
+	createInitialState() {
+		return {
+			buffer: "",
+			line_number: 0,
+			last_level: "info",
+			last_timestamp: void 0,
+			multiline_state: void 0
+		};
+	}
+	/**
+	* Extract timestamp from log line.
+	*
+	* Handles multiple timestamp formats including:
+	* - Double timestamp (ISO + time): 2026-02-05T22:41:05.372Z 22:41:05.372
+	* - Supervisord: 2026-02-05 22:22:38,372
+	* - Unix milliseconds: [1770328479225]
+	*
+	* @param line - Log line
+	* @returns ISO timestamp string or undefined
+	* @private
+	*/
+	extractTimestamp(line) {
+		for (const pattern of TIMESTAMP_PATTERNS) {
+			const match = line.match(pattern.regex);
+			if (match) {
+				const captured = match[pattern.extractIndex ?? 1];
+				if (pattern.format === "unix") return new Date(parseInt(captured, 10)).toISOString();
+				return captured;
+			}
+		}
+	}
+	/**
+	* Format timestamp for display.
+	*
+	* @param timestamp - ISO timestamp
+	* @returns Formatted timestamp string
+	* @private
+	*/
+	formatTimestamp(timestamp) {
+		if (!timestamp) return void 0;
+		switch (this.options.timestamp_format) {
+			case "none": return;
+			case "full": return timestamp;
+			case "time":
+				const timeMatch = timestamp.match(/(\d{2}:\d{2}:\d{2}(?:\.\d+)?)/);
+				return timeMatch ? timeMatch[1] : timestamp;
+			case "relative":
+				const date = new Date(timestamp);
+				const diff = (/* @__PURE__ */ new Date()).getTime() - date.getTime();
+				if (diff < 1e3) return "just now";
+				if (diff < 6e4) return `${Math.floor(diff / 1e3)}s ago`;
+				if (diff < 36e5) return `${Math.floor(diff / 6e4)}m ago`;
+				return `${Math.floor(diff / 36e5)}h ago`;
+			default: return timestamp;
+		}
+	}
+	/**
+	* Extract tags from log line.
+	*
+	* @param line - Log line
+	* @returns Array of extracted tags
+	* @private
+	*/
+	extractTags(line) {
+		const tags = [];
+		let match;
+		const bracketPattern = /\[([A-Z]+)\]/g;
+		bracketPattern.lastIndex = 0;
+		while ((match = bracketPattern.exec(line)) !== null) tags.push(match[1]);
+		const parenPattern = /\(([^)]+)\)/g;
+		parenPattern.lastIndex = 0;
+		while ((match = parenPattern.exec(line)) !== null) {
+			const tag = match[1].toUpperCase();
+			if (!tags.includes(tag)) tags.push(tag);
+		}
+		const anglePattern = /<([^>]+)>/g;
+		anglePattern.lastIndex = 0;
+		while ((match = anglePattern.exec(line)) !== null) {
+			const tag = match[1].toUpperCase();
+			if (!tags.includes(tag)) tags.push(tag);
+		}
+		TAG_PATTERN.lastIndex = 0;
+		while ((match = TAG_PATTERN.exec(line)) !== null) {
+			const tag = match[1];
+			if (!tags.includes(tag)) tags.push(tag);
+		}
+		return tags;
+	}
+	/**
+	* Extract message content from log line.
+	*
+	* Removes ALL metadata including timestamps, levels, tags, and source locations
+	* to return only the clean message content.
+	*
+	* @param line - Log line
+	* @param _timestamp - Extracted timestamp (unused, kept for API compatibility)
+	* @param _levelMatch - Level match string (unused, kept for API compatibility)
+	* @returns Message content
+	* @private
+	*/
+	extractMessage(line, _timestamp, _levelMatch) {
+		let message = line;
+		message = message.replace(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?\s+\d{2}:\d{2}:\d{2}(?:\.\d+)?\s+/, "").replace(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?\s*/, "").replace(/^\d{2}:\d{2}:\d{2}(?:\.\d+)?\s*/, "").replace(/^\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2},\d+\s+/, "").replace(/^\[\d{13,}\]\s*/, "").replace(/^\[\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}\]\s*/, "").replace(/^[A-Z][a-z]{2}\s+\d{1,2}\s+\d{2}:\d{2}:\d{2}\s+/, "");
+		message = message.replace(/^\s*[ℹ️🔵💙📖📝]+\s+(?:INFO(?:RMATION)?\s*)?/i, "").replace(/^\s*[⚠️🟡⚡🔶]+\s*(?:WARN(?:ING)?\s*)?/i, "").replace(/^\s*[❌🔴❗🚨⛔]+\s*(?:ERROR\s*)?/i, "").replace(/^\s*[🐛🔍🔬⚙️]+\s*(?:DEBUG\s*)?/i, "").replace(/^\s*[💀🔥☠️⚰️]+\s*(?:FATAL|CRITICAL\s*)?/i, "").replace(/^\s*[▲✓✗⚡]+\s*/, "");
+		message = message.replace(/^\s*\[(?:TRACE|DEBUG|INFO|WARN(?:ING)?|ERROR|FATAL|CRITICAL)\]\s*/i, "").replace(/^\s*(?:TRACE|DEBUG|INFO|WARN(?:ING)?|ERROR|FATAL|CRITICAL):\s*/i, "");
+		message = message.replace(/⦗[^⦘]+⦘\s*/g, "");
+		message = message.replace(/\([^)]+\d+:\d+\)\s*/, "");
+		message = message.replace(/^\[[\w\s]+\]\s*/, "");
+		message = message.replace(/^\s*[ℹ️⚠️❌🐛💀🚨🔥☠️⚰️🔵🟡🔴💙📖📝🔍🔬⚙️🔶▲✓✗⚡]+\s*/, "");
+		message = message.replace(/^\s+/, "").replace(/\s+$/, "").replace(/^[,\s]+/, "").trim();
+		return message;
+	}
+	/**
+	* Parse structured data (JSON) from log line.
+	*
+	* @param line - Log line
+	* @returns Parsed object or undefined
+	* @private
+	*/
+	parseStructured(line) {
+		const jsonMatch = line.match(/\{[^{}]*\}/);
+		if (!jsonMatch) return void 0;
+		try {
+			return JSON.parse(jsonMatch[0]);
+		} catch {
+			return;
+		}
+	}
+	/**
+	* Get ANSI color code for log level.
+	*
+	* @param level - Log level
+	* @returns ANSI SGR color code
+	* @private
+	*/
+	_getAnsiColorForLevel(level) {
+		return {
+			trace: 90,
+			debug: 36,
+			info: 34,
+			warn: 33,
+			error: 31,
+			fatal: 35,
+			unknown: 37
+		}[level] ?? 37;
+	}
+};
+
+//#endregion
+export { LogParserService };

package/dist/react-ui/blocks/Terminal/parsing/MultilineAggregator.d.ts

@@ -0,0 +1,173 @@
+/**
+ * Multiline log aggregator for JSON and structured data.
+ *
+ * Detects and aggregates multiline log entries such as JSON objects,
+ * tables, and structured data that span multiple lines. Prevents
+ * timestamp/level repetition on continuation lines.
+ *
+ * @module components/devenv/terminal/parsing/multiline
+ */
+import type { IParsedLogEntry, TLogLevel } from './LogParser.types';
+/**
+ * Multiline aggregation state.
+ *
+ * Tracks buffer and context while aggregating multiline logs.
+ */
+export interface IMultilineState {
+    /** Buffered lines for current multiline entry */
+    buffer: string[];
+    /** Parent entry for continuation lines (only line_number is used) */
+    parentEntry?: {
+        line_number: number;
+        level: TLogLevel;
+    };
+    /** Whether currently in multiline mode */
+    isMultiline: boolean;
+    /** Expected closing bracket/brace for current multiline */
+    expectedClose?: '}' | ']';
+    /** Current depth of nested braces/brackets */
+    depth: number;
+}
+/**
+ * Multiline log aggregator class.
+ *
+ * Detects and aggregates lines that are part of a multiline JSON
+ * or structured data entry. Marks continuation lines so they don't
+ * get timestamp/level prefixes.
+ *
+ * @example
+ * ```ts
+ * const aggregator = new MultilineAggregator();
+ * const aggregated = aggregator.aggregate(entries);
+ * // Lines like '{', '  filter: {},', '}' get marked as continuation
+ * ```
+ */
+export declare class MultilineAggregator {
+    /**
+     * Detect if a line is a continuation of multiline JSON/structured data.
+     *
+     * Continuation indicators:
+     * - Line starts with `{` or `[` alone → opens multiline
+     * - Line has indentation + `key: value,` → continuation
+     * - Line is just `}` or `]` → closes multiline
+     * - Line ends with `{` or `[` without match → opens multiline
+     * - When in multiline mode: lines ending with comma or containing key-value patterns
+     *
+     * @param line - Line to check
+     * @param state - Current multiline state
+     * @returns true if line is a continuation
+     */
+    detectContinuation(line: string, state: IMultilineState): boolean;
+    /**
+     * Aggregate entries, marking continuation lines.
+     *
+     * Processes entries and marks lines that are continuations
+     * of a previous multiline entry. Handles:
+     * - JSON/structured data blocks
+     * - Table borders (box-drawing characters)
+     * - Indented continuation lines
+     *
+     * @param entries - Parsed log entries to aggregate
+     * @param initialState - Optional initial multiline state (for persistence across chunks)
+     * @returns Entries with continuation marking and new multiline state
+     */
+    aggregate(entries: IParsedLogEntry[], initialState?: IMultilineState): {
+        entries: IParsedLogEntry[];
+        state: IMultilineState;
+    };
+    /**
+     * Check if a line opens a multiline block.
+     *
+     * @param trimmed - Trimmed line to check
+     * @returns true if line opens multiline
+     * @private
+     */
+    private opensMultiline;
+    /**
+     * Check if a line is an opening brace/bracket.
+     *
+     * @param trimmed - Trimmed line to check
+     * @returns true if line contains opening brace/bracket
+     * @private
+     */
+    private isOpeningBrace;
+    /**
+     * Check if a line is a closing brace/bracket for expected type.
+     *
+     * @param trimmed - Trimmed line to check
+     * @param expected - Expected close type
+     * @returns true if line closes the multiline block
+     * @private
+     */
+    private isClosingBrace;
+    /**
+     * Get the expected closing character for a line.
+     *
+     * @param trimmed - Trimmed line to check
+     * @returns Expected closing character or undefined
+     * @private
+     */
+    private getExpectedClose;
+    /**
+     * Count opening braces/brackets in a line.
+     *
+     * @param trimmed - Trimmed line to check
+     * @returns Count of opening braces/brackets
+     * @private
+     */
+    private countOpeningBraces;
+    /**
+     * Check if a line is a table line (contains box-drawing characters).
+     *
+     * @param trimmed - Trimmed line to check
+     * @returns true if line contains table borders
+     * @private
+     */
+    private isTableLine;
+    /**
+     * Check if a line looks like a new log entry (not a continuation).
+     *
+     * New entries typically start with:
+     * - Timestamp followed by log level
+     * - HTTP method followed by path
+     * - Component/module tag
+     *
+     * @param trimmed - Trimmed line to check
+     * @returns true if line looks like a new entry
+     * @private
+     */
+    private looksLikeNewEntry;
+    /**
+     * Check if a trimmed line is a JSON/structured data continuation.
+     *
+     * This handles lines that have their own timestamp/level metadata
+     * but are actually continuations of a multiline JSON block.
+     *
+     * Examples:
+     * - `container: "name",` - ends with comma
+     * - `tail: 100,` - ends with comma
+     * - `key: "value"` - key-value pattern
+     * - `}` - closing brace
+     * - Lines with pipe characters (table rows)
+     *
+     * @param trimmed - Trimmed line to check
+     * @returns true if line is a JSON continuation
+     * @private
+     */
+    private isJsonContinuation;
+    /**
+     * Check if a line looks like a continuation line (indented content).
+     *
+     * @param line - Line to check (not trimmed, to check indentation)
+     * @returns true if line appears to be a continuation
+     * @private
+     */
+    private isContinuationLine;
+    /**
+     * Create initial multiline state.
+     *
+     * @returns Fresh multiline state
+     */
+    createInitialState(): IMultilineState;
+}
+//# sourceMappingURL=MultilineAggregator.d.ts.map

package/dist/react-ui/blocks/Terminal/parsing/MultilineAggregator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MultilineAggregator.d.ts","sourceRoot":"","sources":["../../../../../src/react-ui/blocks/Terminal/parsing/MultilineAggregator.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAapE;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,iDAAiD;IACjD,MAAM,EAAE,MAAM,EAAE,CAAC;IAEjB,qEAAqE;IACrE,WAAW,CAAC,EAAE;QACZ,WAAW,EAAE,MAAM,CAAC;QACpB,KAAK,EAAE,SAAS,CAAC;KAClB,CAAC;IAEF,0CAA0C;IAC1C,WAAW,EAAE,OAAO,CAAC;IAErB,2DAA2D;IAC3D,aAAa,CAAC,EAAE,GAAG,GAAG,GAAG,CAAC;IAE1B,8CAA8C;IAC9C,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,mBAAmB;IAC9B;;;;;;;;;;;;;OAaG;IACH,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO;IA6BjE;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,YAAY,CAAC,EAAE,eAAe,GAAG;QAAE,OAAO,EAAE,eAAe,EAAE,CAAC;QAAC,KAAK,EAAE,eAAe,CAAA;KAAE;IA+G7H;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;IAyBtB;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;IAItB;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc;IAatB;;;;;;OAMG;IACH,OAAO,CAAC,gBAAgB;IAMxB;;;;;;OAMG;IACH,OAAO,CAAC,kBAAkB;IAM1B;;;;;;OAMG;IACH,OAAO,CAAC,WAAW;IAWnB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,iBAAiB;IA2BzB;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,kBAAkB;IA+C1B;;;;;;OAMG;IACH,OAAO,CAAC,kBAAkB;IAK1B;;;;OAIG;IACH,kBAAkB,IAAI,eAAe;CAOtC"}