@eddacraft/anvil-adapters 0.1.0

package/dist/base/testing.js

@@ -0,0 +1,221 @@
+/**
+ * Adapter Testing Utilities
+ *
+ * Helpers for testing format adapters with common patterns and assertions.
+ */
+/**
+ * Test helper for adapter detection
+ */
+export class AdapterTester {
+    adapter;
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    /**
+     * Test detection with a fixture
+     */
+    testDetection(fixture) {
+        const result = this.adapter.detect(fixture.content);
+        if (fixture.expectedDetection) {
+            if (fixture.expectedDetection.detected !== undefined) {
+                if (result.detected !== fixture.expectedDetection.detected) {
+                    throw new Error(`Detection mismatch for "${fixture.name}": expected ${fixture.expectedDetection.detected}, got ${result.detected}`);
+                }
+            }
+            if (fixture.expectedDetection.confidence !== undefined) {
+                if (result.confidence < fixture.expectedDetection.confidence) {
+                    throw new Error(`Confidence too low for "${fixture.name}": expected >=${fixture.expectedDetection.confidence}, got ${result.confidence}`);
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Test parsing with a fixture
+     */
+    async testParse(fixture) {
+        const result = await this.adapter.parse(fixture.content, fixture.parseContext, fixture.options);
+        if (fixture.expectParseSuccess !== undefined) {
+            if (result.success !== fixture.expectParseSuccess) {
+                throw new Error(`Parse success mismatch for "${fixture.name}": expected ${fixture.expectParseSuccess}, got ${result.success}`);
+            }
+        }
+        if (fixture.expectedErrors && fixture.expectedErrors.length > 0) {
+            if (!result.errors || result.errors.length === 0) {
+                throw new Error(`Expected errors for "${fixture.name}" but got none`);
+            }
+            const errorCodes = result.errors.map((e) => e.code);
+            for (const expectedCode of fixture.expectedErrors) {
+                if (!errorCodes.includes(expectedCode)) {
+                    throw new Error(`Expected error code "${expectedCode}" for "${fixture.name}" but found: ${errorCodes.join(', ')}`);
+                }
+            }
+        }
+        if (fixture.expectedWarnings && fixture.expectedWarnings.length > 0) {
+            if (!result.warnings || result.warnings.length === 0) {
+                throw new Error(`Expected warnings for "${fixture.name}" but got none`);
+            }
+            const warningCodes = result.warnings.map((w) => w.code);
+            for (const expectedCode of fixture.expectedWarnings) {
+                if (!warningCodes.includes(expectedCode)) {
+                    throw new Error(`Expected warning code "${expectedCode}" for "${fixture.name}" but found: ${warningCodes.join(', ')}`);
+                }
+            }
+        }
+        if (fixture.expectedPlan && result.data) {
+            this.assertPlanMatches(result.data, fixture.expectedPlan, fixture.name);
+        }
+        return result;
+    }
+    /**
+     * Test serialization
+     */
+    async testSerialize(plan, options) {
+        return this.adapter.serialize(plan, options);
+    }
+    /**
+     * Test round-trip: parse then serialize then parse again
+     */
+    async testRoundTrip(fixture) {
+        // First parse
+        const firstParse = await this.adapter.parse(fixture.content, fixture.parseContext, fixture.options);
+        if (!firstParse.success || !firstParse.data) {
+            throw new Error(`First parse failed for "${fixture.name}"`);
+        }
+        // Serialize
+        const serialized = await this.adapter.serialize(firstParse.data, fixture.options);
+        if (!serialized.success || !serialized.content) {
+            throw new Error(`Serialization failed for "${fixture.name}"`);
+        }
+        // Second parse
+        const secondParse = await this.adapter.parse(serialized.content, fixture.parseContext, fixture.options);
+        if (!secondParse.success || !secondParse.data) {
+            throw new Error(`Second parse failed for "${fixture.name}"`);
+        }
+        // Compare plans
+        const planMatches = this.plansEqual(firstParse.data, secondParse.data);
+        return {
+            firstParse,
+            serialized,
+            secondParse,
+            planMatches,
+        };
+    }
+    /**
+     * Assert that parsed plan matches expected values
+     */
+    assertPlanMatches(actual, expected, testName) {
+        if (expected.intent !== undefined && actual.intent !== expected.intent) {
+            throw new Error(`Intent mismatch for "${testName}": expected "${expected.intent}", got "${actual.intent}"`);
+        }
+        if (expected.id !== undefined && actual.id !== expected.id) {
+            throw new Error(`ID mismatch for "${testName}": expected "${expected.id}", got "${actual.id}"`);
+        }
+        if (expected.proposed_changes !== undefined &&
+            actual.proposed_changes.length !== expected.proposed_changes.length) {
+            throw new Error(`Changes count mismatch for "${testName}": expected ${expected.proposed_changes.length}, got ${actual.proposed_changes.length}`);
+        }
+    }
+    /**
+     * Compare two plans for equality (ignoring hash and timestamps)
+     */
+    plansEqual(plan1, plan2) {
+        // Compare intents
+        if (plan1.intent !== plan2.intent)
+            return false;
+        // Compare changes count
+        if (plan1.proposed_changes.length !== plan2.proposed_changes.length)
+            return false;
+        // Compare each change
+        for (let i = 0; i < plan1.proposed_changes.length; i++) {
+            const change1 = plan1.proposed_changes[i];
+            const change2 = plan2.proposed_changes[i];
+            if (change1.type !== change2.type)
+                return false;
+            if (change1.path !== change2.path)
+                return false;
+            if (change1.description !== change2.description)
+                return false;
+        }
+        return true;
+    }
+}
+/**
+ * Create a test adapter tester
+ */
+export function createTester(adapter) {
+    return new AdapterTester(adapter);
+}
+/**
+ * Create a basic parse context for testing
+ */
+export function createTestContext(overrides) {
+    return {
+        author: 'test-user',
+        repositoryPath: '/test/repo',
+        branch: 'main',
+        commit: 'abc123',
+        timestamp: '2024-01-01T00:00:00.000Z',
+        ...overrides,
+    };
+}
+/**
+ * Create basic adapter options for testing
+ */
+export function createTestOptions(overrides) {
+    return {
+        preserveComments: true,
+        preserveMetadata: true,
+        strict: false,
+        ...overrides,
+    };
+}
+/**
+ * Assert detection result
+ */
+export function assertDetection(result, expected) {
+    if (result.detected !== expected.detected) {
+        throw new Error(`Detection mismatch: expected ${expected.detected}, got ${result.detected}. Reason: ${result.reason}`);
+    }
+    if (expected.minConfidence !== undefined && result.confidence < expected.minConfidence) {
+        throw new Error(`Confidence too low: expected >=${expected.minConfidence}, got ${result.confidence}`);
+    }
+}
+/**
+ * Assert parse success
+ */
+export function assertParseSuccess(result) {
+    if (!result.success) {
+        const errorMsg = result.errors?.map((e) => `${e.code}: ${e.message}`).join(', ') || 'Unknown error';
+        throw new Error(`Parse failed: ${errorMsg}`);
+    }
+    if (!result.data) {
+        throw new Error('Parse succeeded but no data returned');
+    }
+}
+/**
+ * Assert parse failure
+ */
+export function assertParseFailure(result, expectedErrorCode) {
+    if (result.success) {
+        throw new Error('Expected parse to fail but it succeeded');
+    }
+    if (expectedErrorCode && result.errors) {
+        const errorCodes = result.errors.map((e) => e.code);
+        if (!errorCodes.includes(expectedErrorCode)) {
+            throw new Error(`Expected error code "${expectedErrorCode}" but found: ${errorCodes.join(', ')}`);
+        }
+    }
+}
+/**
+ * Assert serialize success
+ */
+export function assertSerializeSuccess(result) {
+    if (!result.success) {
+        const errorMsg = result.errors?.map((e) => `${e.code}: ${e.message}`).join(', ') || 'Unknown error';
+        throw new Error(`Serialize failed: ${errorMsg}`);
+    }
+    if (!result.content) {
+        throw new Error('Serialize succeeded but no content returned');
+    }
+}

package/dist/base/types.d.ts

@@ -0,0 +1,255 @@
+/**
+ * Base Adapter Framework Types
+ *
+ * Defines the core interfaces for format adapters that convert between
+ * external planning formats (SpecKit, BMAD, etc.) and APS.
+ */
+import type { APSPlan, ValidationResult } from '@eddacraft/anvil-core';
+/**
+ * Result of format detection
+ */
+export interface DetectionResult {
+    /** Whether this adapter can handle the content */
+    detected: boolean;
+    /** Confidence score (0-100) */
+    confidence: number;
+    /** Reason for detection result */
+    reason?: string;
+}
+/**
+ * Result of parsing external format to APS
+ */
+export interface ParseResult {
+    /** Whether parsing succeeded */
+    success: boolean;
+    /** Parsed APS plan (if successful) */
+    data?: APSPlan;
+    /** Errors encountered during parsing */
+    errors?: AdapterError[];
+    /** Non-fatal warnings */
+    warnings?: AdapterWarning[];
+}
+/**
+ * Result of serializing APS to external format
+ */
+export interface SerializeResult {
+    /** Whether serialization succeeded */
+    success: boolean;
+    /** Serialized content (if successful) */
+    content?: string;
+    /** Errors encountered during serialization */
+    errors?: AdapterError[];
+    /** Non-fatal warnings */
+    warnings?: AdapterWarning[];
+    /** Additional metadata about serialization */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Error encountered during adapter operation
+ */
+export interface AdapterError {
+    /** Error code for programmatic handling */
+    code: string;
+    /** Human-readable error message */
+    message: string;
+    /** Path to the problematic element (e.g., "changes[0].path") */
+    path?: string;
+    /** Line number in source content (if applicable) */
+    line?: number;
+    /** Column number in source content (if applicable) */
+    column?: number;
+    /** Additional error details */
+    details?: unknown;
+}
+/**
+ * Warning encountered during adapter operation
+ */
+export interface AdapterWarning {
+    /** Warning code for programmatic handling */
+    code: string;
+    /** Human-readable warning message */
+    message: string;
+    /** Path to the element (e.g., "changes[0].description") */
+    path?: string;
+    /** Line number in source content (if applicable) */
+    line?: number;
+    /** Column number in source content (if applicable) */
+    column?: number;
+    /** Additional warning details */
+    details?: unknown;
+}
+/**
+ * Context provided when parsing external formats
+ */
+export interface ParseContext {
+    /** Repository path or URL */
+    repositoryPath?: string;
+    /** Git branch */
+    branch?: string;
+    /** Git commit hash */
+    commit?: string;
+    /** Author information */
+    author?: string;
+    /** Timestamp for provenance */
+    timestamp?: string;
+    /** Additional context metadata */
+    metadata?: Record<string, unknown>;
+    /** Pre-generated plan ID (for deterministic parsing) */
+    planId?: string;
+}
+/**
+ * Hint for path-based format detection
+ *
+ * Provides file path and sibling file information to improve
+ * detection accuracy for formats that use folder conventions.
+ */
+export interface PathDetectionHint {
+    /** File path being analyzed */
+    filePath: string;
+    /** Sibling file names in the same directory */
+    siblingFiles?: string[];
+    /** Parent directory names (innermost first) */
+    parentDirs?: string[];
+}
+/**
+ * Options for adapter operations
+ */
+export interface AdapterOptions {
+    /** Preserve comments from source */
+    preserveComments?: boolean;
+    /** Preserve metadata from source */
+    preserveMetadata?: boolean;
+    /** Strict validation mode */
+    strict?: boolean;
+    /** Format-specific options */
+    formatOptions?: Record<string, unknown>;
+}
+/**
+ * Metadata about an adapter
+ */
+export interface AdapterMetadata {
+    /** Adapter name (e.g., "speckit", "bmad") */
+    name: string;
+    /** Adapter version */
+    version: string;
+    /** Human-readable display name */
+    displayName: string;
+    /** Short description of what this adapter handles */
+    description: string;
+    /** File extensions supported (e.g., [".md", ".spec.md"]) */
+    extensions: readonly string[];
+    /** Format identifiers (e.g., ["speckit", "spec"]) */
+    formats: readonly string[];
+}
+/**
+ * Core interface for format adapters
+ *
+ * Adapters convert between external planning formats and APS.
+ * Each adapter should handle one external format (e.g., SpecKit, BMAD).
+ */
+export interface FormatAdapter {
+    /** Adapter metadata */
+    readonly metadata: AdapterMetadata;
+    /**
+     * Detect if this adapter can handle the given content
+     *
+     * @param content - Raw content to analyze
+     * @returns Detection result with confidence score
+     */
+    detect(content: string): DetectionResult;
+    /**
+     * Parse external format content into APS
+     *
+     * @param content - Raw content in external format
+     * @param context - Context for provenance tracking
+     * @param options - Parsing options
+     * @returns Parse result with APS plan or errors
+     */
+    parse(content: string, context?: ParseContext, options?: AdapterOptions): Promise<ParseResult>;
+    /**
+     * Serialize APS plan to external format
+     *
+     * @param plan - APS plan to serialize
+     * @param options - Serialization options
+     * @returns Serialize result with content or errors
+     */
+    serialize(plan: APSPlan, options?: AdapterOptions): Promise<SerializeResult>;
+    /**
+     * Validate external format content
+     *
+     * Validates the content without full conversion to APS.
+     * Useful for fast validation feedback.
+     *
+     * @param content - Raw content to validate
+     * @param options - Validation options
+     * @returns Validation result
+     */
+    validate(content: string, options?: AdapterOptions): Promise<ValidationResult>;
+    /**
+     * Detect if this adapter can handle content using file path hints
+     *
+     * Optional method that uses folder structure and sibling files
+     * to improve detection accuracy. Falls back to content-only
+     * detection if not implemented.
+     *
+     * @param content - Raw content to analyze
+     * @param hint - Path and directory information
+     * @returns Detection result with confidence score
+     */
+    detectWithPath?(content: string, hint: PathDetectionHint): DetectionResult;
+    /**
+     * Check if this adapter can import from a given format
+     *
+     * @param format - Format identifier or file extension
+     * @returns True if adapter supports importing from this format
+     */
+    canImport(format: string): boolean;
+    /**
+     * Check if this adapter can export to a given format
+     *
+     * @param format - Format identifier or file extension
+     * @returns True if adapter supports exporting to this format
+     */
+    canExport(format: string): boolean;
+}
+/**
+ * Abstract base class for format adapters
+ *
+ * Provides common functionality and structure for concrete adapters.
+ */
+export declare abstract class BaseFormatAdapter implements FormatAdapter {
+    protected options: AdapterOptions;
+    abstract readonly metadata: AdapterMetadata;
+    constructor(options?: AdapterOptions);
+    abstract detect(content: string): DetectionResult;
+    abstract parse(content: string, context?: ParseContext, options?: AdapterOptions): Promise<ParseResult>;
+    abstract serialize(plan: APSPlan, options?: AdapterOptions): Promise<SerializeResult>;
+    abstract validate(content: string, options?: AdapterOptions): Promise<ValidationResult>;
+    canImport(format: string): boolean;
+    canExport(format: string): boolean;
+    /**
+     * Helper to create a successful parse result
+     */
+    protected createParseSuccess(data: APSPlan, warnings?: AdapterWarning[]): ParseResult;
+    /**
+     * Helper to create a failed parse result
+     */
+    protected createParseError(errors: AdapterError[], warnings?: AdapterWarning[]): ParseResult;
+    /**
+     * Helper to create a successful serialize result
+     */
+    protected createSerializeSuccess(content: string, warnings?: AdapterWarning[], metadata?: Record<string, unknown>): SerializeResult;
+    /**
+     * Helper to create a failed serialize result
+     */
+    protected createSerializeError(errors: AdapterError[], warnings?: AdapterWarning[]): SerializeResult;
+    /**
+     * Helper to add an error
+     */
+    protected addError(errors: AdapterError[], code: string, message: string, path?: string, details?: unknown): void;
+    /**
+     * Helper to add a warning
+     */
+    protected addWarning(warnings: AdapterWarning[], code: string, message: string, path?: string, details?: unknown): void;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/base/types.ts"],"names":[],"mappings":"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"}

package/dist/base/types.js

@@ -0,0 +1,78 @@
+/**
+ * Base Adapter Framework Types
+ *
+ * Defines the core interfaces for format adapters that convert between
+ * external planning formats (SpecKit, BMAD, etc.) and APS.
+ */
+/**
+ * Abstract base class for format adapters
+ *
+ * Provides common functionality and structure for concrete adapters.
+ */
+export class BaseFormatAdapter {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    canImport(format) {
+        const normalized = format.toLowerCase().replace(/^\./, '');
+        return (this.metadata.formats.includes(normalized) ||
+            this.metadata.extensions.some((ext) => ext.replace(/^\./, '') === normalized));
+    }
+    canExport(format) {
+        return this.canImport(format);
+    }
+    /**
+     * Helper to create a successful parse result
+     */
+    createParseSuccess(data, warnings) {
+        return {
+            success: true,
+            data,
+            warnings: warnings && warnings.length > 0 ? warnings : undefined,
+        };
+    }
+    /**
+     * Helper to create a failed parse result
+     */
+    createParseError(errors, warnings) {
+        return {
+            success: false,
+            errors,
+            warnings: warnings && warnings.length > 0 ? warnings : undefined,
+        };
+    }
+    /**
+     * Helper to create a successful serialize result
+     */
+    createSerializeSuccess(content, warnings, metadata) {
+        return {
+            success: true,
+            content,
+            warnings: warnings && warnings.length > 0 ? warnings : undefined,
+            metadata,
+        };
+    }
+    /**
+     * Helper to create a failed serialize result
+     */
+    createSerializeError(errors, warnings) {
+        return {
+            success: false,
+            errors,
+            warnings: warnings && warnings.length > 0 ? warnings : undefined,
+        };
+    }
+    /**
+     * Helper to add an error
+     */
+    addError(errors, code, message, path, details) {
+        errors.push({ code, message, path, details });
+    }
+    /**
+     * Helper to add a warning
+     */
+    addWarning(warnings, code, message, path, details) {
+        warnings.push({ code, message, path, details });
+    }
+}

package/dist/base/utils.d.ts

@@ -0,0 +1,127 @@
+import type { AdapterError, AdapterWarning, ParseResult, SerializeResult, DetectionResult } from './types.js';
+export declare function generateDeterministicPlanId(content: string): string;
+/**
+ * Create a detection result
+ *
+ * @param detected - Whether format was detected
+ * @param confidence - Confidence score (0-100)
+ * @param reason - Optional reason
+ * @returns Detection result
+ */
+export declare function createDetection(detected: boolean, confidence: number, reason?: string): DetectionResult;
+/**
+ * Create an adapter error
+ *
+ * @param code - Error code
+ * @param message - Error message
+ * @param options - Additional options
+ * @returns Adapter error
+ */
+export declare function createError(code: string, message: string, options?: {
+    path?: string;
+    line?: number;
+    column?: number;
+    details?: unknown;
+}): AdapterError;
+/**
+ * Create an adapter warning
+ *
+ * @param code - Warning code
+ * @param message - Warning message
+ * @param options - Additional options
+ * @returns Adapter warning
+ */
+export declare function createWarning(code: string, message: string, options?: {
+    path?: string;
+    line?: number;
+    column?: number;
+    details?: unknown;
+}): AdapterWarning;
+/**
+ * Check if content matches a pattern
+ *
+ * Useful for format detection.
+ *
+ * @param content - Content to check
+ * @param patterns - Array of regex patterns or strings
+ * @returns Number of patterns matched (0 to patterns.length)
+ */
+export declare function matchesPatterns(content: string, patterns: Array<string | RegExp>): number;
+/**
+ * Calculate confidence score based on pattern matches
+ *
+ * @param matchCount - Number of patterns matched
+ * @param totalPatterns - Total number of patterns checked
+ * @param requiredMatches - Minimum matches for 100% confidence
+ * @returns Confidence score (0-100)
+ */
+export declare function calculateConfidence(matchCount: number, totalPatterns: number, requiredMatches?: number): number;
+/**
+ * Extract file extension from filename or path
+ *
+ * @param filename - Filename or path
+ * @returns Extension (including dot) or empty string
+ */
+export declare function getExtension(filename: string): string;
+/**
+ * Normalize format identifier
+ *
+ * Removes leading dot and converts to lowercase.
+ *
+ * @param format - Format identifier or extension
+ * @returns Normalized format
+ */
+export declare function normalizeFormat(format: string): string;
+/**
+ * Format errors for display
+ *
+ * @param errors - Array of errors
+ * @returns Formatted error string
+ */
+export declare function formatErrors(errors: AdapterError[]): string;
+/**
+ * Format warnings for display
+ *
+ * @param warnings - Array of warnings
+ * @returns Formatted warning string
+ */
+export declare function formatWarnings(warnings: AdapterWarning[]): string;
+/**
+ * Merge parse results
+ *
+ * Useful when parsing composite formats.
+ *
+ * @param results - Array of parse results
+ * @returns Merged result
+ */
+export declare function mergeParseResults(results: ParseResult[]): ParseResult;
+/**
+ * Check if result has errors
+ *
+ * @param result - Parse or serialize result
+ * @returns True if result has errors
+ */
+export declare function hasErrors(result: ParseResult | SerializeResult): boolean;
+/**
+ * Check if result has warnings
+ *
+ * @param result - Parse or serialize result
+ * @returns True if result has warnings
+ */
+export declare function hasWarnings(result: ParseResult | SerializeResult): boolean;
+/**
+ * Extract first line from content (useful for format detection)
+ *
+ * @param content - Content string
+ * @returns First non-empty line or empty string
+ */
+export declare function getFirstLine(content: string): string;
+/**
+ * Count occurrences of pattern in content
+ *
+ * @param content - Content to search
+ * @param pattern - Pattern to count
+ * @returns Number of occurrences
+ */
+export declare function countOccurrences(content: string, pattern: string | RegExp): number;
+//# sourceMappingURL=utils.d.ts.map

package/dist/base/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/base/utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,YAAY,EACZ,cAAc,EACd,WAAW,EACX,eAAe,EACf,eAAe,EAChB,MAAM,YAAY,CAAC;AAEpB,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAGnE;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,OAAO,EACjB,UAAU,EAAE,MAAM,EAClB,MAAM,CAAC,EAAE,MAAM,GACd,eAAe,CAMjB;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;IACR,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,GACA,YAAY,CAMd;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;IACR,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,GACA,cAAc,CAMhB;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,MAAM,CAczF;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EACrB,eAAe,GAAE,MAAsB,GACtC,MAAM,CAMR;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGrD;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,MAAM,CAiB3D;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,cAAc,EAAE,GAAG,MAAM,CAiBjE;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,WAAW,EAAE,GAAG,WAAW,CA2CrE;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,WAAW,GAAG,eAAe,GAAG,OAAO,CAExE;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,eAAe,GAAG,OAAO,CAE1E;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CASpD;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAKlF"}