@eddacraft/anvil-adapters 0.1.0

package/dist/bmad/parser.js

@@ -0,0 +1,181 @@
+/**
+ * BMAD Parser
+ *
+ * Parses BMAD format documents (PRD, Architecture, Epics, Stories) into APS plans.
+ */
+import { validateRelativePath } from '@eddacraft/anvil-core';
+import { RequirementType } from './types.js';
+import { extractFrontMatter, extractRequirements, extractUserStories, extractChangeLog, identifyDocumentType, extractTitle, extractIntent, } from './utils.js';
+import { createError, createWarning, generateDeterministicPlanId } from '../base/utils.js';
+/**
+ * Parse BMAD document into internal structure
+ *
+ * @param content - BMAD markdown content
+ * @returns Parsed document
+ */
+/**
+ * Validate and sanitize a file path to prevent path traversal attacks.
+ * Falls back to stripping special characters if validation fails.
+ */
+function safePath(raw) {
+    try {
+        return validateRelativePath(raw);
+    }
+    catch {
+        return raw.replace(/[^a-z0-9/._-]/gi, '').replace(/\.{2,}/g, '');
+    }
+}
+/** Maximum input size for BMAD parsing (2MB) */
+const MAX_INPUT_SIZE = 2 * 1024 * 1024;
+export function parseBMADDocument(content) {
+    if (content.length > MAX_INPUT_SIZE) {
+        throw new Error(`Input exceeds maximum size of ${MAX_INPUT_SIZE} bytes`);
+    }
+    const frontMatter = extractFrontMatter(content);
+    const docType = identifyDocumentType(content, frontMatter);
+    const requirements = extractRequirements(content);
+    const userStories = extractUserStories(content);
+    const changeLog = extractChangeLog(content);
+    const title = extractTitle(content);
+    const intent = extractIntent(content, docType);
+    return {
+        type: docType,
+        frontMatter: frontMatter || undefined,
+        title: title || undefined,
+        intent,
+        requirements,
+        userStories,
+        changeLog,
+        sections: new Map(),
+        raw: content,
+    };
+}
+/**
+ * Convert BMAD requirement to APS change
+ *
+ * @param requirement - BMAD requirement
+ * @returns APS change
+ */
+function requirementToChange(requirement) {
+    // Map requirement type to change type
+    switch (requirement.type) {
+        case RequirementType.FUNCTIONAL:
+            // FR typically means creating or updating files
+            return {
+                type: 'file_create',
+                path: safePath(`features/${requirement.id.toLowerCase()}.ts`),
+                description: `${requirement.id}: ${requirement.description}`,
+            };
+        case RequirementType.NON_FUNCTIONAL:
+            // NFR typically means configuration or validation
+            return {
+                type: 'config_update',
+                path: 'config/requirements.json',
+                description: `${requirement.id}: ${requirement.description}`,
+            };
+        case RequirementType.USER_STORY:
+            // US typically means creating feature files
+            return {
+                type: 'file_create',
+                path: safePath(`features/stories/${requirement.id.toLowerCase()}.ts`),
+                description: `${requirement.id}: ${requirement.description}`,
+            };
+        default:
+            return {
+                type: 'file_create',
+                path: safePath(`requirements/${requirement.id.toLowerCase()}.md`),
+                description: requirement.description,
+            };
+    }
+}
+/**
+ * Convert BMAD user story to APS change
+ *
+ * @param story - BMAD user story
+ * @returns APS change
+ */
+function userStoryToChange(story) {
+    let description = `${story.id}: ${story.title}`;
+    if (story.userType && story.action && story.benefit) {
+        description += ` (As a ${story.userType}, I want ${story.action}, so that ${story.benefit})`;
+    }
+    if (story.acceptanceCriteria && story.acceptanceCriteria.length > 0) {
+        description += ` - Acceptance criteria: ${story.acceptanceCriteria.join('; ')}`;
+    }
+    return {
+        type: 'file_create',
+        path: safePath(`features/stories/${story.id.toLowerCase()}.ts`),
+        description,
+    };
+}
+export function bmadToAPS(document, context, originalContent) {
+    const planId = context?.planId ??
+        (originalContent
+            ? generateDeterministicPlanId(originalContent)
+            : `aps-${Date.now().toString(16).substring(0, 8)}`);
+    // Convert requirements and stories to changes
+    const changes = [];
+    const errors = [];
+    const warnings = [];
+    // Add requirements as changes
+    for (const requirement of document.requirements) {
+        try {
+            const change = requirementToChange(requirement);
+            changes.push(change);
+        }
+        catch (error) {
+            errors.push(createError('REQUIREMENT_CONVERSION_ERROR', `Failed to convert requirement ${requirement.id}`, {
+                details: error,
+            }));
+        }
+    }
+    // Add user stories as changes
+    for (const story of document.userStories) {
+        try {
+            const change = userStoryToChange(story);
+            changes.push(change);
+        }
+        catch (error) {
+            errors.push(createError('STORY_CONVERSION_ERROR', `Failed to convert story ${story.id}`, {
+                details: error,
+            }));
+        }
+    }
+    // If no changes found, add warning
+    if (changes.length === 0) {
+        warnings.push(createWarning('NO_CHANGES', 'No requirements or user stories found in document', {
+            details: { type: document.type },
+        }));
+    }
+    // Extract provenance from front-matter or context
+    const timestamp = document.frontMatter?.date || context?.timestamp || new Date().toISOString();
+    const author = document.frontMatter?.author || context?.author || 'unknown';
+    const version = document.frontMatter?.version || '1.0.0';
+    // Build APS plan
+    const plan = {
+        id: planId,
+        schema_version: '0.1.0',
+        intent: document.intent || 'BMAD document conversion',
+        proposed_changes: changes,
+        provenance: {
+            timestamp,
+            author,
+            source: 'cli',
+            version,
+            repository: context?.repositoryPath,
+            branch: context?.branch,
+            commit: context?.commit,
+        },
+        validations: {
+            required_checks: ['lint', 'test', 'coverage'],
+            skip_checks: [],
+        },
+        // Note: hash will be generated by the adapter after plan creation
+        hash: '0000000000000000000000000000000000000000000000000000000000000000',
+    };
+    return plan;
+}
+export function parseBMAD(content, context) {
+    const document = parseBMADDocument(content);
+    return bmadToAPS(document, context, content);
+}

package/dist/bmad/serializer.d.ts

@@ -0,0 +1,16 @@
+/**
+ * BMAD Serializer
+ *
+ * Serializes APS plans to BMAD format documents.
+ */
+import type { APSPlan } from '@eddacraft/anvil-core';
+/**
+ * Serialize APS plan to BMAD format
+ *
+ * Generates a BMAD PRD document from an APS plan.
+ *
+ * @param plan - APS plan to serialize
+ * @returns BMAD markdown content
+ */
+export declare function serializeToBMAD(plan: APSPlan): string;
+//# sourceMappingURL=serializer.d.ts.map

package/dist/bmad/serializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.d.ts","sourceRoot":"","sources":["../../src/bmad/serializer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAU,MAAM,uBAAuB,CAAC;AAE7D;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CA6LrD"}

package/dist/bmad/serializer.js

@@ -0,0 +1,170 @@
+/**
+ * BMAD Serializer
+ *
+ * Serializes APS plans to BMAD format documents.
+ */
+/**
+ * Serialize APS plan to BMAD format
+ *
+ * Generates a BMAD PRD document from an APS plan.
+ *
+ * @param plan - APS plan to serialize
+ * @returns BMAD markdown content
+ */
+export function serializeToBMAD(plan) {
+    const lines = [];
+    // Generate YAML front-matter
+    lines.push('---');
+    lines.push('name: "Product Requirements Document"');
+    lines.push(`version: "${plan.provenance.version || '1.0.0'}"`);
+    lines.push(`date: "${plan.provenance.timestamp}"`);
+    lines.push(`author: "${plan.provenance.author || 'unknown'}"`);
+    lines.push('description: "Generated from Anvil Plan Specification"');
+    lines.push('---');
+    lines.push('');
+    // Generate document header
+    const projectName = plan.metadata?.['projectName'] || 'Project';
+    lines.push(`# ${projectName} - Product Requirements Document`);
+    lines.push('');
+    lines.push(`**Author:** ${plan.provenance.author || 'unknown'}`);
+    lines.push(`**Date:** ${plan.provenance.timestamp}`);
+    lines.push(`**Version:** ${plan.provenance.version || '1.0.0'}`);
+    lines.push('');
+    // Generate change log
+    lines.push('## Change Log');
+    lines.push('');
+    lines.push('| Date | Version | Description | Author |');
+    lines.push('| :--- | :------ | :---------- | :----- |');
+    const date = new Date(plan.provenance.timestamp).toISOString().split('T')[0];
+    const version = plan.provenance.version || '1.0.0';
+    const author = plan.provenance.author || 'unknown';
+    lines.push(`| ${date} | ${version} | Initial version | ${author} |`);
+    lines.push('');
+    // Generate overview/intent section
+    lines.push('## Overview');
+    lines.push('');
+    lines.push(plan.intent);
+    lines.push('');
+    // Categorize changes
+    const functionalRequirements = [];
+    const nonFunctionalRequirements = [];
+    const userStories = [];
+    for (const change of plan.proposed_changes) {
+        // Categorize based on change type and path
+        if (change.path.includes('stories/') || change.description.match(/^US-\d{2}/)) {
+            userStories.push(change);
+        }
+        else if (change.type === 'config_update' ||
+            change.type === 'dependency_add' ||
+            change.type === 'dependency_update' ||
+            change.description.match(/^NFR-\d{2}/)) {
+            nonFunctionalRequirements.push(change);
+        }
+        else {
+            functionalRequirements.push(change);
+        }
+    }
+    // Generate Functional Requirements section
+    if (functionalRequirements.length > 0) {
+        lines.push('## Functional Requirements');
+        lines.push('');
+        functionalRequirements.forEach((change, index) => {
+            const reqNum = String(index + 1).padStart(2, '0');
+            const reqId = `FR-${reqNum}`;
+            // Extract description (remove existing FR-XX if present)
+            let description = change.description.replace(/^FR-\d{2}:\s*/, '');
+            // Add path context if not already in description
+            if (!description.includes(change.path)) {
+                description += ` (${change.path})`;
+            }
+            lines.push(`${reqId}: ${description}`);
+        });
+        lines.push('');
+    }
+    // Generate Non-Functional Requirements section
+    if (nonFunctionalRequirements.length > 0) {
+        lines.push('## Non-Functional Requirements');
+        lines.push('');
+        nonFunctionalRequirements.forEach((change, index) => {
+            const reqNum = String(index + 1).padStart(2, '0');
+            const reqId = `NFR-${reqNum}`;
+            // Extract description
+            const description = change.description.replace(/^NFR-\d{2}:\s*/, '');
+            lines.push(`${reqId}: ${description}`);
+        });
+        lines.push('');
+    }
+    // Add validation requirements as NFRs
+    if (plan.validations.required_checks.length > 0) {
+        if (nonFunctionalRequirements.length === 0) {
+            lines.push('## Non-Functional Requirements');
+            lines.push('');
+        }
+        const startIndex = nonFunctionalRequirements.length + 1;
+        plan.validations.required_checks.forEach((check, index) => {
+            const reqNum = String(startIndex + index).padStart(2, '0');
+            const reqId = `NFR-${reqNum}`;
+            lines.push(`${reqId}: Must pass ${check} validation`);
+        });
+        lines.push('');
+    }
+    // Generate User Stories section
+    if (userStories.length > 0) {
+        lines.push('## User Stories');
+        lines.push('');
+        userStories.forEach((story, index) => {
+            const storyNum = String(index + 1).padStart(2, '0');
+            const storyId = `US-${storyNum}`;
+            // Extract story title
+            let title = story.description.replace(/^US-\d{2}:\s*/, '');
+            // Check if description contains "As a... I want... so that..." pattern
+            const storyMatch = title.match(/\(As a (.+?), I want (.+?), so that (.+?)\)/);
+            if (storyMatch) {
+                const [, userType, action, benefit] = storyMatch;
+                title = title.replace(/\(As a .+?\)/, '').trim();
+                lines.push(`### ${storyId}: ${title}`);
+                lines.push('');
+                lines.push(`As a ${userType},`);
+                lines.push(`I want ${action},`);
+                lines.push(`so that ${benefit}.`);
+                lines.push('');
+                // Extract acceptance criteria if present
+                const criteriaMatch = title.match(/- Acceptance criteria: (.+)$/);
+                if (criteriaMatch) {
+                    const criteria = criteriaMatch[1].split(';').map((c) => c.trim());
+                    lines.push('**Acceptance Criteria:**');
+                    lines.push('');
+                    criteria.forEach((criterion, i) => {
+                        lines.push(`${i + 1}. ${criterion}`);
+                    });
+                    lines.push('');
+                }
+            }
+            else {
+                lines.push(`### ${storyId}: ${title}`);
+                lines.push('');
+            }
+        });
+    }
+    // Add repository information if available
+    if (plan.provenance.repository || plan.provenance.branch) {
+        lines.push('## Repository Information');
+        lines.push('');
+        if (plan.provenance.repository) {
+            lines.push(`**Repository:** ${plan.provenance.repository}`);
+        }
+        if (plan.provenance.branch) {
+            lines.push(`**Branch:** ${plan.provenance.branch}`);
+        }
+        if (plan.provenance.commit) {
+            lines.push(`**Commit:** ${plan.provenance.commit}`);
+        }
+        lines.push('');
+    }
+    // Add footer
+    lines.push('---');
+    lines.push('');
+    lines.push('*Generated by Anvil - https://github.com/EddaCraft/anvil-001*');
+    lines.push('');
+    return lines.join('\n');
+}

package/dist/bmad/types.d.ts

@@ -0,0 +1,127 @@
+/**
+ * BMAD Format Types
+ *
+ * Type definitions for BMAD (Breakthrough Method for Agile AI-Driven Development) format.
+ */
+/**
+ * BMAD v6 folder structure constants
+ *
+ * v6 changed `.bmad` → `_bmad` and `_cfg` → `_config`.
+ * We support both legacy and new paths for backward compatibility.
+ */
+export declare const BMAD_FOLDERS: {
+    /** New v6 project folder */
+    readonly PROJECT: "_bmad";
+    /** Legacy project folder */
+    readonly PROJECT_LEGACY: ".bmad";
+    /** New v6 config folder */
+    readonly CONFIG: "_config";
+    /** Legacy config folder */
+    readonly CONFIG_LEGACY: "_cfg";
+    /** Agent memory folder (v6) */
+    readonly MEMORY: "_memory";
+    /** Module config file (v6) */
+    readonly MODULE_CONFIG: "module.yaml";
+};
+/**
+ * YAML front-matter metadata
+ */
+export interface BMADFrontMatter {
+    name?: string;
+    version?: string;
+    description?: string;
+    output_file?: string;
+    variables?: Record<string, string>;
+    template?: string;
+    date?: string;
+    author?: string;
+    /** v6: Whether the agent document has a sidecar config */
+    hasSidecar?: boolean;
+}
+/**
+ * BMAD document types
+ */
+export declare enum BMADDocumentType {
+    PRD = "prd",
+    ARCHITECTURE = "architecture",
+    EPIC = "epic",
+    STORY = "story",
+    /** v6: Agent persona/configuration document */
+    AGENT = "agent",
+    UNKNOWN = "unknown"
+}
+/**
+ * Requirement types
+ */
+export declare enum RequirementType {
+    FUNCTIONAL = "FR",
+    NON_FUNCTIONAL = "NFR",
+    USER_STORY = "US"
+}
+/**
+ * Parsed requirement
+ */
+export interface BMADRequirement {
+    type: RequirementType;
+    id: string;
+    number: number;
+    description: string;
+    line?: number;
+}
+/**
+ * User story structure
+ */
+export interface BMADUserStory {
+    id: string;
+    title: string;
+    userType?: string;
+    action?: string;
+    benefit?: string;
+    acceptanceCriteria?: string[];
+    line?: number;
+}
+/**
+ * Change log entry
+ */
+export interface BMADChangeLogEntry {
+    date: string;
+    version: string;
+    description: string;
+    author: string;
+}
+/**
+ * Parsed BMAD document
+ */
+export interface BMADDocument {
+    type: BMADDocumentType;
+    frontMatter?: BMADFrontMatter;
+    title?: string;
+    intent?: string;
+    requirements: BMADRequirement[];
+    userStories: BMADUserStory[];
+    changeLog: BMADChangeLogEntry[];
+    sections: Map<string, string>;
+    raw: string;
+}
+/**
+ * Detection indicators for confidence scoring
+ */
+export interface DetectionIndicators {
+    hasYamlFrontMatter: boolean;
+    hasFunctionalRequirements: boolean;
+    hasNonFunctionalRequirements: boolean;
+    hasUserStories: boolean;
+    hasUserStoryFormat: boolean;
+    hasChangeLogTable: boolean;
+    hasDocumentTitle: boolean;
+    requirementCount: number;
+    /** v6: Path is inside a BMAD project folder */
+    hasBmadFolderPath: boolean;
+    /** v6: Path is inside a BMAD config folder */
+    hasBmadConfigPath: boolean;
+    /** v6: Document has hasSidecar field */
+    hasHasSidecar: boolean;
+    /** v6: Document uses hyphenated variable syntax */
+    hasHyphenatedVariables: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

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

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

package/dist/bmad/types.js

@@ -0,0 +1,47 @@
+/**
+ * BMAD Format Types
+ *
+ * Type definitions for BMAD (Breakthrough Method for Agile AI-Driven Development) format.
+ */
+/**
+ * BMAD v6 folder structure constants
+ *
+ * v6 changed `.bmad` → `_bmad` and `_cfg` → `_config`.
+ * We support both legacy and new paths for backward compatibility.
+ */
+export const BMAD_FOLDERS = {
+    /** New v6 project folder */
+    PROJECT: '_bmad',
+    /** Legacy project folder */
+    PROJECT_LEGACY: '.bmad',
+    /** New v6 config folder */
+    CONFIG: '_config',
+    /** Legacy config folder */
+    CONFIG_LEGACY: '_cfg',
+    /** Agent memory folder (v6) */
+    MEMORY: '_memory',
+    /** Module config file (v6) */
+    MODULE_CONFIG: 'module.yaml',
+};
+/**
+ * BMAD document types
+ */
+export var BMADDocumentType;
+(function (BMADDocumentType) {
+    BMADDocumentType["PRD"] = "prd";
+    BMADDocumentType["ARCHITECTURE"] = "architecture";
+    BMADDocumentType["EPIC"] = "epic";
+    BMADDocumentType["STORY"] = "story";
+    /** v6: Agent persona/configuration document */
+    BMADDocumentType["AGENT"] = "agent";
+    BMADDocumentType["UNKNOWN"] = "unknown";
+})(BMADDocumentType || (BMADDocumentType = {}));
+/**
+ * Requirement types
+ */
+export var RequirementType;
+(function (RequirementType) {
+    RequirementType["FUNCTIONAL"] = "FR";
+    RequirementType["NON_FUNCTIONAL"] = "NFR";
+    RequirementType["USER_STORY"] = "US";
+})(RequirementType || (RequirementType = {}));

package/dist/bmad/utils.d.ts

@@ -0,0 +1,120 @@
+/**
+ * BMAD Adapter Utilities
+ *
+ * Helper functions for BMAD format parsing and serialization.
+ */
+import { BMADFrontMatter, BMADRequirement, BMADUserStory, BMADChangeLogEntry, BMADDocumentType, DetectionIndicators } from './types.js';
+import type { PathDetectionHint } from '../base/types.js';
+/**
+ * Analyze a file path for BMAD folder structure indicators
+ *
+ * Detects both v6 (`_bmad`, `_config`) and legacy (`.bmad`, `_cfg`) paths.
+ *
+ * @param hint - Path detection hint with file path and directory info
+ * @returns Object indicating which BMAD path patterns were found
+ */
+export declare function analyzePath(hint: PathDetectionHint): {
+    isBmadFolder: boolean;
+    isConfigFolder: boolean;
+};
+/**
+ * Expand BMAD template variables in content
+ *
+ * Supports both legacy underscore syntax `{project_root}` and
+ * v6 hyphenated syntax `{project-root}`.
+ *
+ * @param content - Content with variable placeholders
+ * @param variables - Variable values to substitute
+ * @returns Content with variables expanded
+ */
+export declare function expandVariables(content: string, variables: Record<string, string>): string;
+/**
+ * Check if content contains hyphenated variable syntax (v6)
+ *
+ * @param content - Content to check
+ * @returns True if hyphenated variables are found
+ */
+export declare function hasHyphenatedVariables(content: string): boolean;
+/**
+ * Parse a YAML boolean value
+ *
+ * Handles YAML 1.1 boolean forms: true/false, yes/no, on/off.
+ *
+ * @param value - String value from YAML
+ * @returns Boolean or undefined if not a boolean value
+ */
+export declare function parseYamlBoolean(value: string): boolean | undefined;
+/**
+ * Extract YAML front-matter from markdown content
+ *
+ * @param content - Markdown content
+ * @returns Parsed front-matter or null
+ */
+export declare function extractFrontMatter(content: string): BMADFrontMatter | null;
+/**
+ * Extract requirements from content
+ *
+ * @param content - Document content
+ * @returns Array of requirements
+ */
+export declare function extractRequirements(content: string): BMADRequirement[];
+/**
+ * Extract user stories from content
+ *
+ * @param content - Document content
+ * @returns Array of user stories
+ */
+export declare function extractUserStories(content: string): BMADUserStory[];
+/**
+ * Extract change log entries from content
+ *
+ * @param content - Document content
+ * @returns Array of change log entries
+ */
+export declare function extractChangeLog(content: string): BMADChangeLogEntry[];
+/**
+ * Identify document type from content
+ *
+ * @param content - Document content
+ * @param frontMatter - Parsed front-matter
+ * @returns Document type
+ */
+export declare function identifyDocumentType(content: string, frontMatter?: BMADFrontMatter | null): BMADDocumentType;
+/**
+ * Analyze content for detection indicators
+ *
+ * @param content - Document content
+ * @param hint - Optional path detection hint
+ * @returns Detection indicators
+ */
+export declare function analyzeContent(content: string, hint?: PathDetectionHint): DetectionIndicators;
+/**
+ * Calculate detection confidence score
+ *
+ * @param indicators - Detection indicators
+ * @returns Confidence score (0-100)
+ */
+export declare function calculateConfidenceScore(indicators: DetectionIndicators): number;
+/**
+ * Build detection reason message
+ *
+ * @param indicators - Detection indicators
+ * @returns Reason message
+ */
+export declare function buildDetectionReason(indicators: DetectionIndicators): string;
+/**
+ * Extract document title from content
+ *
+ * @param content - Document content
+ * @returns Title or null
+ */
+export declare function extractTitle(content: string): string | null;
+/**
+ * Extract intent/summary from document
+ *
+ * @param content - Document content
+ * @param docType - Document type
+ * @returns Intent description
+ */
+export declare function extractIntent(content: string, docType: BMADDocumentType): string;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/bmad/utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,eAAe,EACf,eAAe,EACf,aAAa,EACb,kBAAkB,EAElB,gBAAgB,EAChB,mBAAmB,EAEpB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAE1D;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,iBAAiB,GAAG;IACpD,YAAY,EAAE,OAAO,CAAC;IACtB,cAAc,EAAE,OAAO,CAAC;CACzB,CAqBA;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAc1F;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE/D;AAMD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAKnE;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CA2C1E;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,EAAE,CAuBtE;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,EAAE,CAiEnE;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,kBAAkB,EAAE,CAoCtE;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,WAAW,CAAC,EAAE,eAAe,GAAG,IAAI,GACnC,gBAAgB,CAkClB;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,iBAAiB,GAAG,mBAAmB,CA0B7F;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,mBAAmB,GAAG,MAAM,CAqDhF;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,mBAAmB,GAAG,MAAM,CAoC5E;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAa3D;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,GAAG,MAAM,CAsDhF"}