@shepai/cli 1.180.0 → 1.181.0-pr539.0993dc0

package/dist/packages/core/src/infrastructure/services/token-optimization/command-output-filter.service.js

@@ -0,0 +1,245 @@
+/**
+ * Command Output Filter Service
+ *
+ * Regex-based filter that reduces test/build/git output tokens embedded in
+ * prompts while preserving all error-relevant lines. Applies configurable
+ * filter policies within fenced code blocks only.
+ *
+ * Safety guarantee: any line containing error-related keywords is preserved
+ * verbatim regardless of other filter rules.
+ */
+/**
+ * Safety keywords — any line containing one of these (case-insensitive) is
+ * preserved unconditionally. Biased toward preservation: when in doubt, keep.
+ */
+const SAFETY_KEYWORDS = [
+    /error/i,
+    /fail/i,
+    /warn/i,
+    /warning/i,
+    /enoent/i,
+    /exception/i,
+    /stack/i,
+    /panic/i,
+    /timeout/i,
+    /denied/i,
+    /unauthorized/i,
+    /not found/i,
+    /undefined/i,
+    /\bnull\b/i,
+    /\bnan\b/i,
+    /syntax/i,
+    /rejected/i,
+    /type error/i,
+    /segfault/i,
+    /abort/i,
+    /killed/i,
+];
+/**
+ * Patterns for lines that can be removed from test output.
+ * Only applied within fenced code blocks.
+ */
+const REMOVABLE_TEST_PATTERNS = [
+    // Jest/Vitest PASS lines: "PASS src/file.test.ts"
+    /^\s*PASS\s+\S/,
+    // Checkmark passing lines: "  ✓ test name (2ms)"
+    /^\s*✓\s+/,
+    // Vitest checkmark passing lines: " ✓ src/file.test.ts"
+    /^\s*✓\s+\S/,
+];
+/**
+ * Patterns for lines that are always preserved (in addition to safety keywords).
+ */
+const ALWAYS_PRESERVE_PATTERNS = [
+    // Stack trace lines
+    /^\s+at\s+/,
+    // Test summary lines
+    /^(Tests?|Test Suites?|Time|Snapshots?):\s+/,
+    // Bullet points with test names (failure details)
+    /^\s*●\s+/,
+    // Cross mark failing lines
+    /^\s*[✗×]\s+/,
+    // Diff headers
+    /^diff --git\s/,
+    /^(---|\+\+\+)\s/,
+    /^@@\s/,
+    // Diff changed lines
+    /^[+-][^+-]/,
+    // Git index lines
+    /^index\s+[0-9a-f]+/,
+];
+/**
+ * Patterns identifying context lines in git diffs that can be removed when
+ * the diff is excessively long.
+ */
+const DIFF_CONTEXT_LINE = /^ [^+-@]/;
+/** Maximum number of consecutive diff context lines to keep at start/end. */
+const MAX_DIFF_CONTEXT_LINES = 5;
+/**
+ * Check whether a line contains any safety keyword.
+ */
+function isSafeLine(line) {
+    return SAFETY_KEYWORDS.some((kw) => kw.test(line));
+}
+/**
+ * Check whether a line matches any always-preserve pattern.
+ */
+function isPreservedPattern(line) {
+    return ALWAYS_PRESERVE_PATTERNS.some((p) => p.test(line));
+}
+/**
+ * Check whether a line matches a removable test pattern.
+ */
+function isRemovableTestLine(line) {
+    return REMOVABLE_TEST_PATTERNS.some((p) => p.test(line));
+}
+/**
+ * Filter lines within a single code block. Returns the filtered lines and
+ * the count of removed lines.
+ */
+function filterCodeBlock(lines) {
+    const isDiff = lines.some((l) => /^diff --git\s/.test(l));
+    if (isDiff) {
+        return filterDiffBlock(lines);
+    }
+    return filterTestOrBuildBlock(lines);
+}
+/**
+ * Filter a git diff code block — truncate long runs of unchanged context
+ * lines while preserving headers, changed lines, and hunk markers.
+ */
+function filterDiffBlock(lines) {
+    const result = [];
+    let removed = 0;
+    let contextRun = [];
+    const flushContextRun = () => {
+        if (contextRun.length <= MAX_DIFF_CONTEXT_LINES * 2) {
+            result.push(...contextRun);
+        }
+        else {
+            // Keep first N and last N context lines, remove middle
+            const head = contextRun.slice(0, MAX_DIFF_CONTEXT_LINES);
+            const tail = contextRun.slice(-MAX_DIFF_CONTEXT_LINES);
+            const skipped = contextRun.length - head.length - tail.length;
+            result.push(...head);
+            result.push(`  ... (${skipped} unchanged lines omitted)`);
+            result.push(...tail);
+            removed += skipped;
+        }
+        contextRun = [];
+    };
+    for (const line of lines) {
+        if (DIFF_CONTEXT_LINE.test(line)) {
+            contextRun.push(line);
+        }
+        else {
+            if (contextRun.length > 0) {
+                flushContextRun();
+            }
+            // Always keep non-context lines in diffs (headers, changed lines, hunks)
+            result.push(line);
+        }
+    }
+    // Flush trailing context
+    if (contextRun.length > 0) {
+        flushContextRun();
+    }
+    return { filtered: result, removed };
+}
+/**
+ * Filter test/build/pnpm output — remove passing test lines and collapse
+ * repeated blank lines while preserving everything error-related.
+ */
+function filterTestOrBuildBlock(lines) {
+    const result = [];
+    let removed = 0;
+    let consecutiveBlanks = 0;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Collapse multiple blank lines
+        if (trimmed === '') {
+            consecutiveBlanks++;
+            if (consecutiveBlanks <= 1) {
+                result.push(line);
+            }
+            else {
+                removed++;
+            }
+            continue;
+        }
+        consecutiveBlanks = 0;
+        // Safety keywords always preserved
+        if (isSafeLine(line)) {
+            result.push(line);
+            continue;
+        }
+        // Always-preserve patterns (stack traces, summaries, failure markers)
+        if (isPreservedPattern(line)) {
+            result.push(line);
+            continue;
+        }
+        // Removable test output lines
+        if (isRemovableTestLine(line)) {
+            removed++;
+            continue;
+        }
+        // Default: preserve the line
+        result.push(line);
+    }
+    return { filtered: result, removed };
+}
+export class CommandOutputFilterService {
+    /**
+     * Filter command output embedded in a prompt string.
+     *
+     * Detects fenced code blocks and applies reduction policies within them.
+     * Text outside code blocks is never modified. Lines containing error-related
+     * keywords are always preserved.
+     */
+    filter(prompt) {
+        if (prompt === '') {
+            return { filtered: '', linesRemoved: 0 };
+        }
+        const lines = prompt.split('\n');
+        const result = [];
+        let totalRemoved = 0;
+        let inCodeBlock = false;
+        let codeBlockLines = [];
+        for (const line of lines) {
+            // Detect code fence boundaries
+            if (line.trimStart().startsWith('```')) {
+                if (!inCodeBlock) {
+                    // Opening fence
+                    inCodeBlock = true;
+                    codeBlockLines = [];
+                    result.push(line);
+                }
+                else {
+                    // Closing fence — filter accumulated code block lines
+                    const { filtered, removed } = filterCodeBlock(codeBlockLines);
+                    result.push(...filtered);
+                    totalRemoved += removed;
+                    result.push(line);
+                    inCodeBlock = false;
+                    codeBlockLines = [];
+                }
+                continue;
+            }
+            if (inCodeBlock) {
+                codeBlockLines.push(line);
+            }
+            else {
+                // Outside code blocks — always preserve
+                result.push(line);
+            }
+        }
+        // If code block was never closed, include accumulated lines unfiltered
+        if (inCodeBlock) {
+            result.push(...codeBlockLines);
+        }
+        return {
+            filtered: result.join('\n'),
+            linesRemoved: totalRemoved,
+        };
+    }
+}

package/dist/packages/core/src/infrastructure/services/token-optimization/delta-context.service.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Delta-Context Service
+ *
+ * Hash-based spec file change detection using SHA-256. Compares current
+ * file contents against hashes from the previous phase. Unchanged files
+ * are replaced with compact summaries to reduce repeated context tokens
+ * across multi-phase workflows.
+ *
+ * Safety: changed files and first-phase files always pass through with
+ * full content. Only verified-unchanged files are summarized.
+ */
+import type { IDeltaContextService, SpecFileEntry, DeltaContextResult } from '../../../application/ports/output/services/delta-context.interface.js';
+export declare class DeltaContextService implements IDeltaContextService {
+    /**
+     * Diff spec files against previous phase hashes.
+     *
+     * For unchanged files: replaces content with a compact summary.
+     * For changed files or first phase (no previous hashes): returns full content.
+     */
+    diff(files: SpecFileEntry[], previousHashes: Record<string, string>, previousPhaseName?: string): DeltaContextResult;
+}
+//# sourceMappingURL=delta-context.service.d.ts.map

package/dist/packages/core/src/infrastructure/services/token-optimization/delta-context.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delta-context.service.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/token-optimization/delta-context.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EACV,oBAAoB,EACpB,aAAa,EACb,kBAAkB,EACnB,MAAM,gEAAgE,CAAC;AASxE,qBAAa,mBAAoB,YAAW,oBAAoB;IAC9D;;;;;OAKG;IACH,IAAI,CACF,KAAK,EAAE,aAAa,EAAE,EACtB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACtC,iBAAiB,CAAC,EAAE,MAAM,GACzB,kBAAkB;CA4BtB"}

package/dist/packages/core/src/infrastructure/services/token-optimization/delta-context.service.js

@@ -0,0 +1,50 @@
+/**
+ * Delta-Context Service
+ *
+ * Hash-based spec file change detection using SHA-256. Compares current
+ * file contents against hashes from the previous phase. Unchanged files
+ * are replaced with compact summaries to reduce repeated context tokens
+ * across multi-phase workflows.
+ *
+ * Safety: changed files and first-phase files always pass through with
+ * full content. Only verified-unchanged files are summarized.
+ */
+import { createHash } from 'node:crypto';
+/**
+ * Compute the SHA-256 hex digest of a string.
+ */
+function computeHash(content) {
+    return createHash('sha256').update(content, 'utf8').digest('hex');
+}
+export class DeltaContextService {
+    /**
+     * Diff spec files against previous phase hashes.
+     *
+     * For unchanged files: replaces content with a compact summary.
+     * For changed files or first phase (no previous hashes): returns full content.
+     */
+    diff(files, previousHashes, previousPhaseName) {
+        const optimizedFiles = {};
+        const currentHashes = {};
+        let filesSkipped = 0;
+        const hasPreviousHashes = Object.keys(previousHashes).length > 0;
+        for (const file of files) {
+            const hash = computeHash(file.content);
+            currentHashes[file.fileName] = hash;
+            const previousHash = previousHashes[file.fileName];
+            const isUnchanged = hasPreviousHashes && previousHash === hash;
+            if (isUnchanged) {
+                const lineCount = file.content.split('\n').length;
+                const shortHash = hash.slice(0, 8);
+                const phase = previousPhaseName ?? 'previous';
+                optimizedFiles[file.fileName] =
+                    `[${file.fileName} unchanged since ${phase} - ${lineCount} lines, hash ${shortHash}]`;
+                filesSkipped++;
+            }
+            else {
+                optimizedFiles[file.fileName] = file.content;
+            }
+        }
+        return { optimizedFiles, currentHashes, filesSkipped };
+    }
+}

package/dist/packages/core/src/infrastructure/services/token-optimization/optimization-metrics.service.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Optimization Metrics Service
+ *
+ * Persists token optimization metrics on existing PhaseTiming records.
+ * Updates the per-phase timing entry with optimization statistics so the
+ * data is queryable alongside timing and cost data via the existing
+ * phase timing infrastructure.
+ *
+ * Failure-tolerant: any persistence error is swallowed (after best-effort
+ * logging) so optimization metric recording can never break a phase run.
+ */
+import type { IOptimizationMetricsService } from '../../../application/ports/output/services/optimization-metrics.interface.js';
+import type { OptimizationMetrics } from '../../../application/ports/output/services/prompt-optimizer.interface.js';
+import type { IPhaseTimingRepository } from '../../../application/ports/output/agents/phase-timing-repository.interface.js';
+export declare class OptimizationMetricsService implements IOptimizationMetricsService {
+    private readonly phaseTimingRepository;
+    constructor(phaseTimingRepository: IPhaseTimingRepository);
+    /**
+     * Persist optimization metrics on the named PhaseTiming row.
+     *
+     * Token estimates are stored as bigint (PhaseTiming column type),
+     * capabilitiesApplied is serialized as a JSON string for the
+     * existing string column.
+     */
+    record(phaseTimingId: string, metrics: OptimizationMetrics): Promise<void>;
+    /**
+     * Retrieve previously recorded optimization metrics for a phase timing.
+     *
+     * Returns null when:
+     *   - the phase timing record does not exist
+     *   - the phase timing exists but has no optimization columns populated
+     *   - the underlying repository read fails
+     */
+    getByPhaseTimingId(phaseTimingId: string): Promise<OptimizationMetrics | null>;
+}
+//# sourceMappingURL=optimization-metrics.service.d.ts.map

package/dist/packages/core/src/infrastructure/services/token-optimization/optimization-metrics.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimization-metrics.service.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/token-optimization/optimization-metrics.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,uEAAuE,CAAC;AACzH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mEAAmE,CAAC;AAC7G,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,wEAAwE,CAAC;AAoDrH,qBACa,0BAA2B,YAAW,2BAA2B;IAG1E,OAAO,CAAC,QAAQ,CAAC,qBAAqB;gBAArB,qBAAqB,EAAE,sBAAsB;IAGhE;;;;;;OAMG;IACG,MAAM,CAAC,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBhF;;;;;;;OAOG;IACG,kBAAkB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;CAWrF"}

package/dist/packages/core/src/infrastructure/services/token-optimization/optimization-metrics.service.js

@@ -0,0 +1,123 @@
+/**
+ * Optimization Metrics Service
+ *
+ * Persists token optimization metrics on existing PhaseTiming records.
+ * Updates the per-phase timing entry with optimization statistics so the
+ * data is queryable alongside timing and cost data via the existing
+ * phase timing infrastructure.
+ *
+ * Failure-tolerant: any persistence error is swallowed (after best-effort
+ * logging) so optimization metric recording can never break a phase run.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { injectable, inject } from 'tsyringe';
+/**
+ * Parse the JSON-serialized capabilitiesApplied column. Returns an
+ * empty array on malformed JSON so a corrupted row never throws on read.
+ */
+function parseCapabilitiesApplied(serialized) {
+    if (serialized === undefined || serialized === null) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(serialized);
+        return Array.isArray(parsed)
+            ? parsed.filter((item) => typeof item === 'string')
+            : [];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Build an OptimizationMetrics object from a PhaseTiming row.
+ *
+ * Returns null when the row has no optimization columns populated
+ * (record was created but optimizer never ran for it).
+ */
+function metricsFromPhaseTiming(timing) {
+    // If no optimization fields are present at all, treat as "no metrics".
+    if (timing.originalTokenEstimate === undefined &&
+        timing.optimizedTokenEstimate === undefined &&
+        timing.savingsPercent === undefined &&
+        timing.capabilitiesApplied === undefined) {
+        return null;
+    }
+    return {
+        originalTokenEstimate: timing.originalTokenEstimate !== undefined ? Number(timing.originalTokenEstimate) : 0,
+        optimizedTokenEstimate: timing.optimizedTokenEstimate !== undefined ? Number(timing.optimizedTokenEstimate) : 0,
+        savingsPercent: timing.savingsPercent ?? 0,
+        capabilitiesApplied: parseCapabilitiesApplied(timing.capabilitiesApplied),
+        outputFilterLinesRemoved: timing.outputFilterLinesRemoved ?? 0,
+        deltaContextFilesSkipped: timing.deltaContextFilesSkipped ?? 0,
+        compressionRatio: timing.compressionRatio ?? 1.0,
+        aliasesCreated: timing.aliasesCreated ?? 0,
+    };
+}
+let OptimizationMetricsService = class OptimizationMetricsService {
+    phaseTimingRepository;
+    constructor(phaseTimingRepository) {
+        this.phaseTimingRepository = phaseTimingRepository;
+    }
+    /**
+     * Persist optimization metrics on the named PhaseTiming row.
+     *
+     * Token estimates are stored as bigint (PhaseTiming column type),
+     * capabilitiesApplied is serialized as a JSON string for the
+     * existing string column.
+     */
+    async record(phaseTimingId, metrics) {
+        try {
+            await this.phaseTimingRepository.update(phaseTimingId, {
+                originalTokenEstimate: BigInt(metrics.originalTokenEstimate),
+                optimizedTokenEstimate: BigInt(metrics.optimizedTokenEstimate),
+                savingsPercent: metrics.savingsPercent,
+                capabilitiesApplied: JSON.stringify(metrics.capabilitiesApplied),
+                outputFilterLinesRemoved: metrics.outputFilterLinesRemoved,
+                deltaContextFilesSkipped: metrics.deltaContextFilesSkipped,
+                compressionRatio: metrics.compressionRatio,
+                aliasesCreated: metrics.aliasesCreated,
+            });
+        }
+        catch {
+            // Persistence failure must never break optimization
+        }
+    }
+    /**
+     * Retrieve previously recorded optimization metrics for a phase timing.
+     *
+     * Returns null when:
+     *   - the phase timing record does not exist
+     *   - the phase timing exists but has no optimization columns populated
+     *   - the underlying repository read fails
+     */
+    async getByPhaseTimingId(phaseTimingId) {
+        try {
+            const timing = await this.phaseTimingRepository.findById(phaseTimingId);
+            if (!timing) {
+                return null;
+            }
+            return metricsFromPhaseTiming(timing);
+        }
+        catch {
+            return null;
+        }
+    }
+};
+OptimizationMetricsService = __decorate([
+    injectable(),
+    __param(0, inject('IPhaseTimingRepository')),
+    __metadata("design:paramtypes", [Object])
+], OptimizationMetricsService);
+export { OptimizationMetricsService };

package/dist/packages/core/src/infrastructure/services/token-optimization/prompt-optimizer.service.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Prompt Optimizer Service
+ *
+ * Top-level orchestrator for the token optimization layer. Composes the
+ * five capability services (delta-context, command output filter, skill
+ * routing, semantic compressor, alias compression) into a sequential
+ * pipeline driven by per-capability settings toggles.
+ *
+ * Pipeline order (from research decisions):
+ *   1. Output filter   - removes the most raw text early
+ *   2. Skill routing   - prepends a small directive section
+ *   3. Delta-context   - replaces unchanged spec files with summaries
+ *   4. Semantic compr  - compresses remaining natural language
+ *   5. Alias engine    - finds repeated long strings in the final text
+ *
+ * Each stage runs only when its individual toggle is true. The master
+ * toggle (config.enabled) short-circuits the pipeline entirely.
+ *
+ * Metrics from each stage are aggregated into the OptimizationMetrics
+ * record returned alongside the optimized prompt.
+ */
+import type { IPromptOptimizerService, PromptOptimizationContext, PromptOptimizationResult } from '../../../application/ports/output/services/prompt-optimizer.interface.js';
+import type { ICommandOutputFilterService } from '../../../application/ports/output/services/command-output-filter.interface.js';
+import type { ISkillRoutingService } from '../../../application/ports/output/services/skill-routing.interface.js';
+import type { IDeltaContextService } from '../../../application/ports/output/services/delta-context.interface.js';
+import type { ISemanticCompressorService } from '../../../application/ports/output/services/semantic-compressor.interface.js';
+import type { IAliasCompressionService } from '../../../application/ports/output/services/alias-compression.interface.js';
+import type { IOptimizationMetricsService } from '../../../application/ports/output/services/optimization-metrics.interface.js';
+export declare class PromptOptimizerService implements IPromptOptimizerService {
+    private readonly outputFilter;
+    private readonly skillRouting;
+    private readonly deltaContext;
+    private readonly semanticCompressor;
+    private readonly aliasCompression;
+    private readonly metricsService;
+    constructor(outputFilter: ICommandOutputFilterService, skillRouting: ISkillRoutingService, deltaContext: IDeltaContextService, semanticCompressor: ISemanticCompressorService, aliasCompression: IAliasCompressionService, metricsService: IOptimizationMetricsService);
+    /**
+     * Optimize a raw prompt by running enabled capability services in sequence.
+     *
+     * Returns the original prompt with zero-delta metrics when the master
+     * toggle is off. Each capability is independently skippable via its
+     * config toggle.
+     */
+    optimize(prompt: string, context: PromptOptimizationContext): Promise<PromptOptimizationResult>;
+    /**
+     * Persist metrics via the metrics service when a phaseTimingId is
+     * provided in the context. Failures are swallowed so a metrics
+     * persistence problem can never break the optimization pipeline.
+     */
+    private recordMetricsIfPossible;
+    /**
+     * Log a debug-level summary of optimizations applied for observability.
+     * Failure to log must never affect optimization output.
+     */
+    private logSummary;
+}
+//# sourceMappingURL=prompt-optimizer.service.d.ts.map

package/dist/packages/core/src/infrastructure/services/token-optimization/prompt-optimizer.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-optimizer.service.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/token-optimization/prompt-optimizer.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,OAAO,KAAK,EACV,uBAAuB,EACvB,yBAAyB,EACzB,wBAAwB,EAEzB,MAAM,mEAAmE,CAAC;AAC3E,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,wEAAwE,CAAC;AAC1H,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gEAAgE,CAAC;AAC3G,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gEAAgE,CAAC;AAC3G,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,sEAAsE,CAAC;AACvH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,oEAAoE,CAAC;AACnH,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,uEAAuE,CAAC;AAkCzH,qBACa,sBAAuB,YAAW,uBAAuB;IAGlE,OAAO,CAAC,QAAQ,CAAC,YAAY;IAE7B,OAAO,CAAC,QAAQ,CAAC,YAAY;IAE7B,OAAO,CAAC,QAAQ,CAAC,YAAY;IAE7B,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IAEnC,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IAEjC,OAAO,CAAC,QAAQ,CAAC,cAAc;gBAVd,YAAY,EAAE,2BAA2B,EAEzC,YAAY,EAAE,oBAAoB,EAElC,YAAY,EAAE,oBAAoB,EAElC,kBAAkB,EAAE,0BAA0B,EAE9C,gBAAgB,EAAE,wBAAwB,EAE1C,cAAc,EAAE,2BAA2B;IAG9D;;;;;;OAMG;IACG,QAAQ,CACZ,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,wBAAwB,CAAC;IA4HpC;;;;OAIG;YACW,uBAAuB;IAcrC;;;OAGG;IACH,OAAO,CAAC,UAAU;CAkBnB"}