@yalehwang/archguard 0.1.0

package/dist/cli/config-loader.d.ts

@@ -0,0 +1,701 @@
+import { z } from 'zod';
+export type { ArchGuardConfig } from '../types/config.js';
+declare const configSchema: z.ZodObject<{
+    outputDir: z.ZodDefault<z.ZodString>;
+    format: z.ZodDefault<z.ZodEnum<["mermaid", "json"]>>;
+    mermaid: z.ZodDefault<z.ZodObject<{
+        renderer: z.ZodDefault<z.ZodEnum<["isomorphic", "cli"]>>;
+        theme: z.ZodDefault<z.ZodEnum<["default", "forest", "dark", "neutral"]>>;
+        transparentBackground: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        renderer?: "isomorphic" | "cli";
+        theme?: "default" | "forest" | "dark" | "neutral";
+        transparentBackground?: boolean;
+    }, {
+        renderer?: "isomorphic" | "cli";
+        theme?: "default" | "forest" | "dark" | "neutral";
+        transparentBackground?: boolean;
+    }>>;
+    exclude: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    cli: z.ZodDefault<z.ZodObject<{
+        command: z.ZodDefault<z.ZodString>;
+        args: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        timeout: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number;
+        command?: string;
+        args?: string[];
+    }, {
+        timeout?: number;
+        command?: string;
+        args?: string[];
+    }>>;
+    cache: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        ttl: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean;
+        ttl?: number;
+    }, {
+        enabled?: boolean;
+        ttl?: number;
+    }>>;
+    concurrency: z.ZodDefault<z.ZodNumber>;
+    verbose: z.ZodDefault<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        system: z.ZodOptional<z.ZodString>;
+        author: z.ZodOptional<z.ZodString>;
+        projectUrl: z.ZodOptional<z.ZodString>;
+        keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        title?: string;
+        description?: string;
+        system?: string;
+        author?: string;
+        projectUrl?: string;
+        keywords?: string[];
+    }, {
+        title?: string;
+        description?: string;
+        system?: string;
+        author?: string;
+        projectUrl?: string;
+        keywords?: string[];
+    }>>;
+    diagrams: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        sources: z.ZodArray<z.ZodString, "many">;
+        level: z.ZodEnum<["package", "class", "method"]>;
+        description: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodEnum<["mermaid", "json"]>>;
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        metadata: z.ZodOptional<z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            subtitle: z.ZodOptional<z.ZodString>;
+            purpose: z.ZodOptional<z.ZodString>;
+            primaryActors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            input: z.ZodOptional<z.ZodObject<{
+                type: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                example: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                type?: string;
+                description?: string;
+                example?: string;
+            }, {
+                type?: string;
+                description?: string;
+                example?: string;
+            }>>;
+            output: z.ZodOptional<z.ZodObject<{
+                description: z.ZodString;
+                formats: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                example: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                description?: string;
+                example?: string;
+                formats?: string[];
+            }, {
+                description?: string;
+                example?: string;
+                formats?: string[];
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            title?: string;
+            subtitle?: string;
+            purpose?: string;
+            input?: {
+                type?: string;
+                description?: string;
+                example?: string;
+            };
+            output?: {
+                description?: string;
+                example?: string;
+                formats?: string[];
+            };
+            primaryActors?: string[];
+        }, {
+            title?: string;
+            subtitle?: string;
+            purpose?: string;
+            input?: {
+                type?: string;
+                description?: string;
+                example?: string;
+            };
+            output?: {
+                description?: string;
+                example?: string;
+                formats?: string[];
+            };
+            primaryActors?: string[];
+        }>>;
+        design: z.ZodOptional<z.ZodObject<{
+            architectureStyle: z.ZodOptional<z.ZodEnum<["layered", "event-driven", "microkernel", "serverless"]>>;
+            patterns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                category: z.ZodEnum<["creational", "structural", "behavioral", "concurrency"]>;
+                participants: z.ZodArray<z.ZodString, "many">;
+                description: z.ZodString;
+                codeExample: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                description?: string;
+                name?: string;
+                category?: "creational" | "structural" | "behavioral" | "concurrency";
+                participants?: string[];
+                codeExample?: string;
+            }, {
+                description?: string;
+                name?: string;
+                category?: "creational" | "structural" | "behavioral" | "concurrency";
+                participants?: string[];
+                codeExample?: string;
+            }>, "many">>;
+            principles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            decisions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                topic: z.ZodString;
+                decision: z.ZodString;
+                rationale: z.ZodString;
+                alternatives: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                topic?: string;
+                decision?: string;
+                rationale?: string;
+                alternatives?: string[];
+            }, {
+                topic?: string;
+                decision?: string;
+                rationale?: string;
+                alternatives?: string[];
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            patterns?: {
+                description?: string;
+                name?: string;
+                category?: "creational" | "structural" | "behavioral" | "concurrency";
+                participants?: string[];
+                codeExample?: string;
+            }[];
+            principles?: string[];
+            architectureStyle?: "layered" | "event-driven" | "microkernel" | "serverless";
+            decisions?: {
+                topic?: string;
+                decision?: string;
+                rationale?: string;
+                alternatives?: string[];
+            }[];
+        }, {
+            patterns?: {
+                description?: string;
+                name?: string;
+                category?: "creational" | "structural" | "behavioral" | "concurrency";
+                participants?: string[];
+                codeExample?: string;
+            }[];
+            principles?: string[];
+            architectureStyle?: "layered" | "event-driven" | "microkernel" | "serverless";
+            decisions?: {
+                topic?: string;
+                decision?: string;
+                rationale?: string;
+                alternatives?: string[];
+            }[];
+        }>>;
+        process: z.ZodOptional<z.ZodObject<{
+            stages: z.ZodOptional<z.ZodNumber>;
+            stageList: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                order: z.ZodNumber;
+                name: z.ZodString;
+                description: z.ZodString;
+                namespace: z.ZodOptional<z.ZodString>;
+                patterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                patterns?: string[];
+                description?: string;
+                name?: string;
+                order?: number;
+                namespace?: string;
+            }, {
+                patterns?: string[];
+                description?: string;
+                name?: string;
+                order?: number;
+                namespace?: string;
+            }>, "many">>;
+            dataFlow: z.ZodOptional<z.ZodString>;
+            keyDependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            stages?: number;
+            stageList?: {
+                patterns?: string[];
+                description?: string;
+                name?: string;
+                order?: number;
+                namespace?: string;
+            }[];
+            dataFlow?: string;
+            keyDependencies?: string[];
+        }, {
+            stages?: number;
+            stageList?: {
+                patterns?: string[];
+                description?: string;
+                name?: string;
+                order?: number;
+                namespace?: string;
+            }[];
+            dataFlow?: string;
+            keyDependencies?: string[];
+        }>>;
+        annotations: z.ZodOptional<z.ZodObject<{
+            enableComments: z.ZodOptional<z.ZodBoolean>;
+            highlightPatterns: z.ZodOptional<z.ZodBoolean>;
+            showExternalDeps: z.ZodOptional<z.ZodBoolean>;
+            includeUsageExample: z.ZodOptional<z.ZodBoolean>;
+            enableVisibleTitle: z.ZodOptional<z.ZodBoolean>;
+            visibleTitleSections: z.ZodOptional<z.ZodArray<z.ZodEnum<["title", "subtitle", "purpose", "input", "output", "patterns", "principles", "process"]>, "many">>;
+            titlePosition: z.ZodOptional<z.ZodEnum<["top", "bottom"]>>;
+        }, "strip", z.ZodTypeAny, {
+            enableComments?: boolean;
+            highlightPatterns?: boolean;
+            showExternalDeps?: boolean;
+            includeUsageExample?: boolean;
+            enableVisibleTitle?: boolean;
+            visibleTitleSections?: ("title" | "subtitle" | "purpose" | "input" | "output" | "patterns" | "principles" | "process")[];
+            titlePosition?: "top" | "bottom";
+        }, {
+            enableComments?: boolean;
+            highlightPatterns?: boolean;
+            showExternalDeps?: boolean;
+            includeUsageExample?: boolean;
+            enableVisibleTitle?: boolean;
+            visibleTitleSections?: ("title" | "subtitle" | "purpose" | "input" | "output" | "patterns" | "principles" | "process")[];
+            titlePosition?: "top" | "bottom";
+        }>>;
+        classes: z.ZodOptional<z.ZodObject<{
+            highlightClasses: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            annotateClasses: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                className: z.ZodString;
+                note: z.ZodOptional<z.ZodString>;
+                stereotypes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                responsibility: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                className?: string;
+                note?: string;
+                stereotypes?: string[];
+                responsibility?: string;
+            }, {
+                className?: string;
+                note?: string;
+                stereotypes?: string[];
+                responsibility?: string;
+            }>, "many">>;
+            visibility: z.ZodOptional<z.ZodObject<{
+                show: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                hide: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                show?: string[];
+                hide?: string[];
+            }, {
+                show?: string[];
+                hide?: string[];
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            highlightClasses?: string[];
+            annotateClasses?: {
+                className?: string;
+                note?: string;
+                stereotypes?: string[];
+                responsibility?: string;
+            }[];
+            visibility?: {
+                show?: string[];
+                hide?: string[];
+            };
+        }, {
+            highlightClasses?: string[];
+            annotateClasses?: {
+                className?: string;
+                note?: string;
+                stereotypes?: string[];
+                responsibility?: string;
+            }[];
+            visibility?: {
+                show?: string[];
+                hide?: string[];
+            };
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        process?: {
+            stages?: number;
+            stageList?: {
+                patterns?: string[];
+                description?: string;
+                name?: string;
+                order?: number;
+                namespace?: string;
+            }[];
+            dataFlow?: string;
+            keyDependencies?: string[];
+        };
+        description?: string;
+        name?: string;
+        format?: "mermaid" | "json";
+        exclude?: string[];
+        metadata?: {
+            title?: string;
+            subtitle?: string;
+            purpose?: string;
+            input?: {
+                type?: string;
+                description?: string;
+                example?: string;
+            };
+            output?: {
+                description?: string;
+                example?: string;
+                formats?: string[];
+            };
+            primaryActors?: string[];
+        };
+        sources?: string[];
+        level?: "package" | "class" | "method";
+        design?: {
+            patterns?: {
+                description?: string;
+                name?: string;
+                category?: "creational" | "structural" | "behavioral" | "concurrency";
+                participants?: string[];
+                codeExample?: string;
+            }[];
+            principles?: string[];
+            architectureStyle?: "layered" | "event-driven" | "microkernel" | "serverless";
+            decisions?: {
+                topic?: string;
+                decision?: string;
+                rationale?: string;
+                alternatives?: string[];
+            }[];
+        };
+        annotations?: {
+            enableComments?: boolean;
+            highlightPatterns?: boolean;
+            showExternalDeps?: boolean;
+            includeUsageExample?: boolean;
+            enableVisibleTitle?: boolean;
+            visibleTitleSections?: ("title" | "subtitle" | "purpose" | "input" | "output" | "patterns" | "principles" | "process")[];
+            titlePosition?: "top" | "bottom";
+        };
+        classes?: {
+            highlightClasses?: string[];
+            annotateClasses?: {
+                className?: string;
+                note?: string;
+                stereotypes?: string[];
+                responsibility?: string;
+            }[];
+            visibility?: {
+                show?: string[];
+                hide?: string[];
+            };
+        };
+    }, {
+        process?: {
+            stages?: number;
+            stageList?: {
+                patterns?: string[];
+                description?: string;
+                name?: string;
+                order?: number;
+                namespace?: string;
+            }[];
+            dataFlow?: string;
+            keyDependencies?: string[];
+        };
+        description?: string;
+        name?: string;
+        format?: "mermaid" | "json";
+        exclude?: string[];
+        metadata?: {
+            title?: string;
+            subtitle?: string;
+            purpose?: string;
+            input?: {
+                type?: string;
+                description?: string;
+                example?: string;
+            };
+            output?: {
+                description?: string;
+                example?: string;
+                formats?: string[];
+            };
+            primaryActors?: string[];
+        };
+        sources?: string[];
+        level?: "package" | "class" | "method";
+        design?: {
+            patterns?: {
+                description?: string;
+                name?: string;
+                category?: "creational" | "structural" | "behavioral" | "concurrency";
+                participants?: string[];
+                codeExample?: string;
+            }[];
+            principles?: string[];
+            architectureStyle?: "layered" | "event-driven" | "microkernel" | "serverless";
+            decisions?: {
+                topic?: string;
+                decision?: string;
+                rationale?: string;
+                alternatives?: string[];
+            }[];
+        };
+        annotations?: {
+            enableComments?: boolean;
+            highlightPatterns?: boolean;
+            showExternalDeps?: boolean;
+            includeUsageExample?: boolean;
+            enableVisibleTitle?: boolean;
+            visibleTitleSections?: ("title" | "subtitle" | "purpose" | "input" | "output" | "patterns" | "principles" | "process")[];
+            titlePosition?: "top" | "bottom";
+        };
+        classes?: {
+            highlightClasses?: string[];
+            annotateClasses?: {
+                className?: string;
+                note?: string;
+                stereotypes?: string[];
+                responsibility?: string;
+            }[];
+            visibility?: {
+                show?: string[];
+                hide?: string[];
+            };
+        };
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    cli?: {
+        timeout?: number;
+        command?: string;
+        args?: string[];
+    };
+    mermaid?: {
+        renderer?: "isomorphic" | "cli";
+        theme?: "default" | "forest" | "dark" | "neutral";
+        transparentBackground?: boolean;
+    };
+    concurrency?: number;
+    cache?: {
+        enabled?: boolean;
+        ttl?: number;
+    };
+    outputDir?: string;
+    format?: "mermaid" | "json";
+    exclude?: string[];
+    verbose?: boolean;
+    metadata?: {
+        title?: string;
+        description?: string;
+        system?: string;
+        author?: string;
+        projectUrl?: string;
+        keywords?: string[];
+    };
+    diagrams?: {
+        process?: {
+            stages?: number;
+            stageList?: {
+                patterns?: string[];
+                description?: string;
+                name?: string;
+                order?: number;
+                namespace?: string;
+            }[];
+            dataFlow?: string;
+            keyDependencies?: string[];
+        };
+        description?: string;
+        name?: string;
+        format?: "mermaid" | "json";
+        exclude?: string[];
+        metadata?: {
+            title?: string;
+            subtitle?: string;
+            purpose?: string;
+            input?: {
+                type?: string;
+                description?: string;
+                example?: string;
+            };
+            output?: {
+                description?: string;
+                example?: string;
+                formats?: string[];
+            };
+            primaryActors?: string[];
+        };
+        sources?: string[];
+        level?: "package" | "class" | "method";
+        design?: {
+            patterns?: {
+                description?: string;
+                name?: string;
+                category?: "creational" | "structural" | "behavioral" | "concurrency";
+                participants?: string[];
+                codeExample?: string;
+            }[];
+            principles?: string[];
+            architectureStyle?: "layered" | "event-driven" | "microkernel" | "serverless";
+            decisions?: {
+                topic?: string;
+                decision?: string;
+                rationale?: string;
+                alternatives?: string[];
+            }[];
+        };
+        annotations?: {
+            enableComments?: boolean;
+            highlightPatterns?: boolean;
+            showExternalDeps?: boolean;
+            includeUsageExample?: boolean;
+            enableVisibleTitle?: boolean;
+            visibleTitleSections?: ("title" | "subtitle" | "purpose" | "input" | "output" | "patterns" | "principles" | "process")[];
+            titlePosition?: "top" | "bottom";
+        };
+        classes?: {
+            highlightClasses?: string[];
+            annotateClasses?: {
+                className?: string;
+                note?: string;
+                stereotypes?: string[];
+                responsibility?: string;
+            }[];
+            visibility?: {
+                show?: string[];
+                hide?: string[];
+            };
+        };
+    }[];
+}, {
+    cli?: {
+        timeout?: number;
+        command?: string;
+        args?: string[];
+    };
+    mermaid?: {
+        renderer?: "isomorphic" | "cli";
+        theme?: "default" | "forest" | "dark" | "neutral";
+        transparentBackground?: boolean;
+    };
+    concurrency?: number;
+    cache?: {
+        enabled?: boolean;
+        ttl?: number;
+    };
+    outputDir?: string;
+    format?: "mermaid" | "json";
+    exclude?: string[];
+    verbose?: boolean;
+    metadata?: {
+        title?: string;
+        description?: string;
+        system?: string;
+        author?: string;
+        projectUrl?: string;
+        keywords?: string[];
+    };
+    diagrams?: {
+        process?: {
+            stages?: number;
+            stageList?: {
+                patterns?: string[];
+                description?: string;
+                name?: string;
+                order?: number;
+                namespace?: string;
+            }[];
+            dataFlow?: string;
+            keyDependencies?: string[];
+        };
+        description?: string;
+        name?: string;
+        format?: "mermaid" | "json";
+        exclude?: string[];
+        metadata?: {
+            title?: string;
+            subtitle?: string;
+            purpose?: string;
+            input?: {
+                type?: string;
+                description?: string;
+                example?: string;
+            };
+            output?: {
+                description?: string;
+                example?: string;
+                formats?: string[];
+            };
+            primaryActors?: string[];
+        };
+        sources?: string[];
+        level?: "package" | "class" | "method";
+        design?: {
+            patterns?: {
+                description?: string;
+                name?: string;
+                category?: "creational" | "structural" | "behavioral" | "concurrency";
+                participants?: string[];
+                codeExample?: string;
+            }[];
+            principles?: string[];
+            architectureStyle?: "layered" | "event-driven" | "microkernel" | "serverless";
+            decisions?: {
+                topic?: string;
+                decision?: string;
+                rationale?: string;
+                alternatives?: string[];
+            }[];
+        };
+        annotations?: {
+            enableComments?: boolean;
+            highlightPatterns?: boolean;
+            showExternalDeps?: boolean;
+            includeUsageExample?: boolean;
+            enableVisibleTitle?: boolean;
+            visibleTitleSections?: ("title" | "subtitle" | "purpose" | "input" | "output" | "patterns" | "principles" | "process")[];
+            titlePosition?: "top" | "bottom";
+        };
+        classes?: {
+            highlightClasses?: string[];
+            annotateClasses?: {
+                className?: string;
+                note?: string;
+                stereotypes?: string[];
+                responsibility?: string;
+            }[];
+            visibility?: {
+                show?: string[];
+                hide?: string[];
+            };
+        };
+    }[];
+}>;
+export type Config = z.infer<typeof configSchema>;
+export declare class ConfigLoader {
+    private configDir;
+    constructor(configDir?: string);
+    load(cliOptions?: Partial<Config>, configPath?: string): Promise<Config>;
+    private normalizeConfig;
+    private deepMerge;
+    private isObject;
+    private loadFromFile;
+    init(options?: {
+        format?: 'json' | 'js';
+    }): Promise<void>;
+    getConfigPath(): Promise<string | null>;
+}
+//# sourceMappingURL=config-loader.d.ts.map

package/dist/cli/config-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-loader.d.ts","sourceRoot":"","sources":["../../src/cli/config-loader.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,YAAY,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAkI1D,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoFhB,CAAC;AAEH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAqDlD,qBAAa,YAAY;IACvB,OAAO,CAAC,SAAS,CAAS;gBAEd,SAAS,GAAE,MAAsB;IAUvC,IAAI,CAAC,UAAU,GAAE,OAAO,CAAC,MAAM,CAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IA2BlF,OAAO,CAAC,eAAe;IAYvB,OAAO,CAAC,SAAS;IAiCjB,OAAO,CAAC,QAAQ;YAUF,YAAY;IA4CpB,IAAI,CAAC,OAAO,GAAE;QAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAuB7D,aAAa,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;CAa9C"}