@eddacraft/anvil-core 0.1.0

package/dist/provenance/store.js

@@ -0,0 +1,248 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { ProvenanceRecordSchema, ProvenanceIndexSchema } from './types.js';
+import { createDebugger } from '../utils/debug.js';
+import { sanitizeIdentifier } from '../utils/path-safety.js';
+const debug = createDebugger('provenance');
+const PROVENANCE_DIR = '.anvil';
+const HISTORY_DIR = 'history';
+const INDEX_FILE = 'index.json';
+const MAX_RECORDS = 1000; // Maximum records to keep in history
+/**
+ * ProvenanceStore - manages provenance records on disk
+ */
+export class ProvenanceStore {
+    baseDir;
+    historyDir;
+    indexPath;
+    constructor(workspaceRoot) {
+        this.baseDir = join(workspaceRoot, PROVENANCE_DIR);
+        this.historyDir = join(this.baseDir, HISTORY_DIR);
+        this.indexPath = join(this.historyDir, INDEX_FILE);
+    }
+    /**
+     * Ensures the provenance directories exist
+     */
+    ensureDirectories() {
+        if (!existsSync(this.baseDir)) {
+            mkdirSync(this.baseDir, { recursive: true });
+        }
+        if (!existsSync(this.historyDir)) {
+            mkdirSync(this.historyDir, { recursive: true });
+        }
+        // Create .gitignore in .anvil if it doesn't exist
+        const gitignorePath = join(this.baseDir, '.gitignore');
+        if (!existsSync(gitignorePath)) {
+            writeFileSync(gitignorePath, `# Anvil local data
+history/
+*.local.json
+`);
+        }
+    }
+    /**
+     * Loads the provenance index
+     */
+    createEmptyIndex() {
+        return {
+            version: 1,
+            last_updated: new Date().toISOString(),
+            records: [],
+            statistics: {
+                total_checks: 0,
+                total_passed: 0,
+                total_failed: 0,
+            },
+        };
+    }
+    loadIndex() {
+        if (!existsSync(this.indexPath)) {
+            return this.createEmptyIndex();
+        }
+        try {
+            const content = readFileSync(this.indexPath, 'utf-8');
+            const parsed = JSON.parse(content);
+            const result = ProvenanceIndexSchema.safeParse(parsed);
+            if (!result.success) {
+                debug('Index validation failed, starting fresh', result.error);
+                return this.createEmptyIndex();
+            }
+            return result.data;
+        }
+        catch (error) {
+            debug('Failed to load provenance index', error);
+            return this.createEmptyIndex();
+        }
+    }
+    /**
+     * Saves the provenance index
+     */
+    saveIndex(index) {
+        this.ensureDirectories();
+        index.last_updated = new Date().toISOString();
+        writeFileSync(this.indexPath, JSON.stringify(index, null, 2));
+    }
+    /**
+     * Saves a provenance record
+     */
+    save(record) {
+        this.ensureDirectories();
+        // Save the full record
+        const safeId = sanitizeIdentifier(record.id);
+        const recordPath = join(this.historyDir, `${safeId}.json`);
+        writeFileSync(recordPath, JSON.stringify(record, null, 2));
+        // Update the index
+        const index = this.loadIndex();
+        // Add to records (prepend for most recent first)
+        index.records.unshift({
+            id: record.id,
+            timestamp: record.timestamp,
+            passed: record.overall_passed,
+            scope: record.scope,
+            files_count: record.files_count,
+            commit: record.git?.commit?.substring(0, 8),
+        });
+        if (index.records.length > MAX_RECORDS) {
+            index.records.splice(MAX_RECORDS);
+        }
+        // Update statistics
+        index.statistics.total_checks++;
+        if (record.overall_passed) {
+            index.statistics.total_passed++;
+            index.statistics.last_pass = record.timestamp;
+        }
+        else {
+            index.statistics.total_failed++;
+            index.statistics.last_fail = record.timestamp;
+        }
+        this.saveIndex(index);
+    }
+    /**
+     * Gets a specific provenance record by ID
+     */
+    get(id) {
+        const safeId = sanitizeIdentifier(id);
+        const recordPath = join(this.historyDir, `${safeId}.json`);
+        if (!existsSync(recordPath)) {
+            return null;
+        }
+        try {
+            const content = readFileSync(recordPath, 'utf-8');
+            const parsed = JSON.parse(content);
+            const result = ProvenanceRecordSchema.safeParse(parsed);
+            if (!result.success) {
+                debug(`Record ${id} validation failed`, result.error);
+                return null;
+            }
+            return result.data;
+        }
+        catch (error) {
+            debug(`Failed to load provenance record ${id}`, error);
+            return null;
+        }
+    }
+    /**
+     * Gets the most recent provenance record
+     */
+    getLatest() {
+        const index = this.loadIndex();
+        if (index.records.length === 0) {
+            return null;
+        }
+        return this.get(index.records[0].id);
+    }
+    /**
+     * Gets the provenance index with statistics
+     */
+    getIndex() {
+        return this.loadIndex();
+    }
+    /**
+     * Lists recent provenance records
+     */
+    list(options) {
+        const index = this.loadIndex();
+        let records = index.records;
+        // Filter by passed/failed
+        if (options?.passed !== undefined) {
+            records = records.filter((r) => r.passed === options.passed);
+        }
+        // Filter by date
+        if (options?.since) {
+            const sinceTime = options.since.getTime();
+            records = records.filter((r) => new Date(r.timestamp).getTime() >= sinceTime);
+        }
+        // Apply limit
+        const limit = options?.limit || 10;
+        records = records.slice(0, limit);
+        // Load full records
+        return records.map((r) => this.get(r.id)).filter((r) => r !== null);
+    }
+    /**
+     * Finds records by git commit
+     */
+    findByCommit(commitPrefix) {
+        const index = this.loadIndex();
+        const matching = index.records.filter((r) => r.commit?.startsWith(commitPrefix));
+        return matching.map((r) => this.get(r.id)).filter((r) => r !== null);
+    }
+    /**
+     * Gets statistics about provenance history
+     */
+    getStatistics() {
+        const index = this.loadIndex();
+        const stats = index.statistics;
+        const lastRecord = index.records[0];
+        return {
+            total: stats.total_checks,
+            passed: stats.total_passed,
+            failed: stats.total_failed,
+            passRate: stats.total_checks > 0 ? (stats.total_passed / stats.total_checks) * 100 : 0,
+            lastCheck: lastRecord?.timestamp || null,
+            lastPass: stats.last_pass || null,
+            lastFail: stats.last_fail || null,
+        };
+    }
+    /**
+     * Exports provenance history as JSON
+     */
+    export(options) {
+        const records = this.list(options);
+        const stats = this.getStatistics();
+        return JSON.stringify({
+            exported_at: new Date().toISOString(),
+            statistics: stats,
+            records,
+        }, null, 2);
+    }
+    /**
+     * Clears all provenance history
+     */
+    clear() {
+        const index = this.loadIndex();
+        for (const record of index.records) {
+            const safeId = sanitizeIdentifier(record.id);
+            const recordPath = join(this.historyDir, `${safeId}.json`);
+            try {
+                if (existsSync(recordPath)) {
+                    unlinkSync(recordPath);
+                }
+            }
+            catch (error) {
+                debug(`Failed to delete record file ${record.id}`, error);
+            }
+        }
+        this.saveIndex(this.createEmptyIndex());
+    }
+    /**
+     * Checks if provenance tracking is initialised
+     */
+    isInitialised() {
+        return existsSync(this.historyDir);
+    }
+}
+/**
+ * Creates a provenance store for the given workspace
+ */
+export function createProvenanceStore(workspaceRoot) {
+    return new ProvenanceStore(workspaceRoot);
+}

package/dist/provenance/types.d.ts

@@ -0,0 +1,160 @@
+import { z } from 'zod';
+/**
+ * AI Tool detection - what generated this code?
+ */
+export declare const AIToolSchema: z.ZodObject<{
+    name: z.ZodEnum<{
+        unknown: "unknown";
+        manual: "manual";
+        cursor: "cursor";
+        copilot: "copilot";
+        "claude-code": "claude-code";
+        chatgpt: "chatgpt";
+        codewhisperer: "codewhisperer";
+        tabnine: "tabnine";
+    }>;
+    version: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+        inferred: "inferred";
+    }>;
+    indicators: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Environment context - where was this check run?
+ */
+export declare const EnvironmentSchema: z.ZodObject<{
+    os: z.ZodString;
+    node_version: z.ZodString;
+    anvil_version: z.ZodString;
+    cwd: z.ZodString;
+    ci: z.ZodBoolean;
+    ci_provider: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Git context - what was the repo state?
+ */
+export declare const GitContextSchema: z.ZodObject<{
+    repository: z.ZodOptional<z.ZodString>;
+    branch: z.ZodOptional<z.ZodString>;
+    commit: z.ZodOptional<z.ZodString>;
+    commit_message: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    dirty: z.ZodBoolean;
+    staged_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    modified_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Check result summary for provenance
+ */
+export declare const CheckSummarySchema: z.ZodObject<{
+    name: z.ZodString;
+    passed: z.ZodBoolean;
+    score: z.ZodOptional<z.ZodNumber>;
+    issues_count: z.ZodOptional<z.ZodNumber>;
+    duration_ms: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Full provenance record for a check run
+ */
+export declare const ProvenanceRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    timestamp: z.ZodString;
+    scope: z.ZodEnum<{
+        files: "files";
+        directory: "directory";
+        staged: "staged";
+        plan: "plan";
+    }>;
+    files_checked: z.ZodArray<z.ZodString>;
+    files_count: z.ZodNumber;
+    overall_passed: z.ZodBoolean;
+    overall_score: z.ZodNumber;
+    checks: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        passed: z.ZodBoolean;
+        score: z.ZodOptional<z.ZodNumber>;
+        issues_count: z.ZodOptional<z.ZodNumber>;
+        duration_ms: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    environment: z.ZodObject<{
+        os: z.ZodString;
+        node_version: z.ZodString;
+        anvil_version: z.ZodString;
+        cwd: z.ZodString;
+        ci: z.ZodBoolean;
+        ci_provider: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    git: z.ZodOptional<z.ZodObject<{
+        repository: z.ZodOptional<z.ZodString>;
+        branch: z.ZodOptional<z.ZodString>;
+        commit: z.ZodOptional<z.ZodString>;
+        commit_message: z.ZodOptional<z.ZodString>;
+        author: z.ZodOptional<z.ZodString>;
+        dirty: z.ZodBoolean;
+        staged_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        modified_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    ai_tool: z.ZodOptional<z.ZodObject<{
+        name: z.ZodEnum<{
+            unknown: "unknown";
+            manual: "manual";
+            cursor: "cursor";
+            copilot: "copilot";
+            "claude-code": "claude-code";
+            chatgpt: "chatgpt";
+            codewhisperer: "codewhisperer";
+            tabnine: "tabnine";
+        }>;
+        version: z.ZodOptional<z.ZodString>;
+        confidence: z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+            inferred: "inferred";
+        }>;
+        indicators: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    plan_id: z.ZodOptional<z.ZodString>;
+    parent_id: z.ZodOptional<z.ZodString>;
+    trigger: z.ZodEnum<{
+        api: "api";
+        manual: "manual";
+        watch: "watch";
+        ci: "ci";
+        "pre-commit": "pre-commit";
+    }>;
+    duration_ms: z.ZodNumber;
+    user: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Provenance index for quick lookups
+ */
+export declare const ProvenanceIndexSchema: z.ZodObject<{
+    version: z.ZodNumber;
+    last_updated: z.ZodString;
+    records: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        timestamp: z.ZodString;
+        passed: z.ZodBoolean;
+        scope: z.ZodString;
+        files_count: z.ZodNumber;
+        commit: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    statistics: z.ZodObject<{
+        total_checks: z.ZodNumber;
+        total_passed: z.ZodNumber;
+        total_failed: z.ZodNumber;
+        last_pass: z.ZodOptional<z.ZodString>;
+        last_fail: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type AITool = z.infer<typeof AIToolSchema>;
+export type Environment = z.infer<typeof EnvironmentSchema>;
+export type GitContext = z.infer<typeof GitContextSchema>;
+export type CheckSummary = z.infer<typeof CheckSummarySchema>;
+export type ProvenanceRecord = z.infer<typeof ProvenanceRecordSchema>;
+export type ProvenanceIndex = z.infer<typeof ProvenanceIndexSchema>;
+//# sourceMappingURL=types.d.ts.map

package/dist/provenance/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/provenance/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;iBAkBvB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;iBAO5B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;iBAS3B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;iBAM7B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8BjC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;iBAwBhC,CAAC;AAGH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAClD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/provenance/types.js

@@ -0,0 +1,112 @@
+import { z } from 'zod';
+/**
+ * AI Tool detection - what generated this code?
+ */
+export const AIToolSchema = z.object({
+    name: z
+        .enum([
+        'cursor',
+        'copilot',
+        'claude-code',
+        'chatgpt',
+        'codewhisperer',
+        'tabnine',
+        'unknown',
+        'manual',
+    ])
+        .describe('Detected AI coding tool'),
+    version: z.string().optional().describe('Version of the AI tool if detectable'),
+    confidence: z
+        .enum(['high', 'medium', 'low', 'inferred'])
+        .describe('Confidence level of detection'),
+    indicators: z.array(z.string()).optional().describe('What indicated this tool was used'),
+});
+/**
+ * Environment context - where was this check run?
+ */
+export const EnvironmentSchema = z.object({
+    os: z.string().describe('Operating system'),
+    node_version: z.string().describe('Node.js version'),
+    anvil_version: z.string().describe('Anvil CLI version'),
+    cwd: z.string().describe('Current working directory'),
+    ci: z.boolean().describe('Whether running in CI environment'),
+    ci_provider: z.string().optional().describe('CI provider name if detected'),
+});
+/**
+ * Git context - what was the repo state?
+ */
+export const GitContextSchema = z.object({
+    repository: z.string().optional().describe('Repository URL or name'),
+    branch: z.string().optional().describe('Current branch'),
+    commit: z.string().optional().describe('Current commit SHA'),
+    commit_message: z.string().optional().describe('Current commit message'),
+    author: z.string().optional().describe('Commit author'),
+    dirty: z.boolean().describe('Whether there are uncommitted changes'),
+    staged_files: z.array(z.string()).optional().describe('Files staged for commit'),
+    modified_files: z.array(z.string()).optional().describe('Modified files'),
+});
+/**
+ * Check result summary for provenance
+ */
+export const CheckSummarySchema = z.object({
+    name: z.string().describe('Check name'),
+    passed: z.boolean().describe('Whether the check passed'),
+    score: z.number().optional().describe('Score if applicable'),
+    issues_count: z.number().optional().describe('Number of issues found'),
+    duration_ms: z.number().optional().describe('How long the check took'),
+});
+/**
+ * Full provenance record for a check run
+ */
+export const ProvenanceRecordSchema = z.object({
+    // Identification
+    id: z.string().describe('Unique provenance record ID'),
+    timestamp: z.string().datetime().describe('When the check was run'),
+    // What was checked
+    scope: z.enum(['directory', 'staged', 'files', 'plan']).describe('What scope was checked'),
+    files_checked: z.array(z.string()).describe('List of files that were checked'),
+    files_count: z.number().describe('Total number of files checked'),
+    // Results
+    overall_passed: z.boolean().describe('Whether all checks passed'),
+    overall_score: z.number().describe('Overall score (0-100)'),
+    checks: z.array(CheckSummarySchema).describe('Summary of each check'),
+    // Context
+    environment: EnvironmentSchema.describe('Environment information'),
+    git: GitContextSchema.optional().describe('Git repository context'),
+    ai_tool: AIToolSchema.optional().describe('Detected AI tool'),
+    // Linking
+    plan_id: z.string().optional().describe('Associated plan ID if applicable'),
+    parent_id: z.string().optional().describe('Previous provenance record ID'),
+    // Metadata
+    trigger: z
+        .enum(['manual', 'pre-commit', 'ci', 'watch', 'api'])
+        .describe('What triggered this check'),
+    duration_ms: z.number().describe('Total duration of the check run'),
+    user: z.string().optional().describe('User who ran the check'),
+});
+/**
+ * Provenance index for quick lookups
+ */
+export const ProvenanceIndexSchema = z.object({
+    version: z.number().describe('Index format version'),
+    last_updated: z.string().datetime().describe('When the index was last updated'),
+    records: z
+        .array(z.object({
+        id: z.string(),
+        timestamp: z.string(),
+        passed: z.boolean(),
+        scope: z.string(),
+        files_count: z.number(),
+        commit: z.string().optional(),
+    }))
+        .describe('Summary of all provenance records'),
+    statistics: z
+        .object({
+        total_checks: z.number(),
+        total_passed: z.number(),
+        total_failed: z.number(),
+        last_pass: z.string().optional(),
+        last_fail: z.string().optional(),
+    })
+        .describe('Aggregate statistics'),
+});

package/dist/suppression/index.d.ts

@@ -0,0 +1,4 @@
+export { parseSuppressions, isExpired, suppressionMatches, findMatchingSuppression, ParsedSuppressionSchema, type ParsedSuppression, type SuppressionScope, type SuppressionParseError, type ParseResult, } from './parser.js';
+export { SuppressionStore, SuppressionStoreDataSchema, type SuppressionStoreData, type SuppressionMatch, } from './store.js';
+export { SuppressionService, type SuppressionStats, type FileSuppressions } from './service.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/suppression/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/suppression/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,SAAS,EACT,kBAAkB,EAClB,uBAAuB,EACvB,uBAAuB,EACvB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,EAC1B,KAAK,WAAW,GACjB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,gBAAgB,EAChB,0BAA0B,EAC1B,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,GACtB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,kBAAkB,EAAE,KAAK,gBAAgB,EAAE,KAAK,gBAAgB,EAAE,MAAM,cAAc,CAAC"}

package/dist/suppression/index.js

@@ -0,0 +1,3 @@
+export { parseSuppressions, isExpired, suppressionMatches, findMatchingSuppression, ParsedSuppressionSchema, } from './parser.js';
+export { SuppressionStore, SuppressionStoreDataSchema, } from './store.js';
+export { SuppressionService } from './service.js';

package/dist/suppression/parser.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+export type SuppressionScope = 'line' | 'statement' | 'file';
+export declare const ParsedSuppressionSchema: z.ZodObject<{
+    warningId: z.ZodString;
+    reason: z.ZodString;
+    expiresAt: z.ZodOptional<z.ZodDate>;
+    line: z.ZodNumber;
+    column: z.ZodOptional<z.ZodNumber>;
+    scope: z.ZodEnum<{
+        file: "file";
+        line: "line";
+        statement: "statement";
+    }>;
+    raw: z.ZodString;
+}, z.core.$strip>;
+export type ParsedSuppression = z.infer<typeof ParsedSuppressionSchema>;
+export interface SuppressionParseError {
+    line: number;
+    column?: number;
+    message: string;
+    raw: string;
+}
+export interface ParseResult {
+    suppressions: ParsedSuppression[];
+    errors: SuppressionParseError[];
+}
+export declare function parseSuppressions(content: string, _filePath?: string): ParseResult;
+export declare function isExpired(suppression: ParsedSuppression, now?: Date): boolean;
+export declare function suppressionMatches(suppression: ParsedSuppression, warningId: string, warningLine: number): boolean;
+export declare function findMatchingSuppression(suppressions: ParsedSuppression[], warningId: string, warningLine: number, now?: Date): ParsedSuppression | null;
+//# sourceMappingURL=parser.d.ts.map

package/dist/suppression/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/suppression/parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,CAAC;AAE7D,eAAO,MAAM,uBAAuB;;;;;;;;;;;;iBAWlC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,WAAW;IAC1B,YAAY,EAAE,iBAAiB,EAAE,CAAC;IAClC,MAAM,EAAE,qBAAqB,EAAE,CAAC;CACjC;AAkKD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,WAAW,CA8ClF;AAED,wBAAgB,SAAS,CAAC,WAAW,EAAE,iBAAiB,EAAE,GAAG,GAAE,IAAiB,GAAG,OAAO,CAKzF;AAED,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,iBAAiB,EAC9B,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,GAClB,OAAO,CAkBT;AAED,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,iBAAiB,EAAE,EACjC,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,GAAG,GAAE,IAAiB,GACrB,iBAAiB,GAAG,IAAI,CAY1B"}