@aexol/spectral 0.9.220 → 0.9.222

package/dist/generated/parser/tokenizer.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Aexol Language Tokenizer
+ *
+ * Provides a stream-like interface for token consumption and lookahead.
+ * Builds on the Lexer to handle token stream management.
+ */
+import { TokenType } from "./lexer.js";
+import type { Token } from "./lexer.js";
+export declare class Tokenizer {
+    private tokens;
+    private position;
+    constructor(source: string);
+    /**
+     * Get the current token without advancing
+     */
+    current(): Token;
+    /**
+     * Peek at the next token(s) without advancing
+     */
+    peek(offset?: number): Token;
+    /**
+     * Peek backwards
+     */
+    peekBack(offset?: number): Token;
+    /**
+     * Advance to the next token and return the current one
+     */
+    advance(): Token;
+    /**
+     * Check if current token matches a type
+     */
+    check(type: TokenType): boolean;
+    /**
+     * Check if current token matches multiple types
+     */
+    checkAny(...types: TokenType[]): boolean;
+    /**
+     * Consume a token of expected type or throw error
+     */
+    consume(type: TokenType, message?: string): Token;
+    /**
+     * Try to consume a token of type, return null if not found
+     */
+    tryConsume(type: TokenType): Token | null;
+    /**
+     * Match and consume one of multiple types
+     */
+    match(...types: TokenType[]): Token | null;
+    /**
+     * Check if we've reached EOF
+     */
+    isAtEnd(): boolean;
+    /**
+     * Get all tokens
+     */
+    getAllTokens(): Token[];
+    /**
+     * Get current position in token stream
+     */
+    getPosition(): number;
+    /**
+     * Set position in token stream
+     */
+    setPosition(pos: number): void;
+    /**
+     * Get tokens until a certain type is encountered
+     */
+    collectUntil(type: TokenType): Token[];
+    /**
+     * Get a range of tokens
+     */
+    getRange(start: number, end: number): Token[];
+    /**
+     * Synchronize on error - skip tokens until we find a statement boundary
+     */
+    synchronize(): void;
+    /**
+     * Create a copy of the tokenizer at current position
+     */
+    clone(): Tokenizer;
+    /**
+     * Get human-readable representation of current token
+     */
+    getErrorContext(): string;
+    /**
+     * Get tokens in a specific line
+     */
+    getLineTokens(lineNumber: number): Token[];
+    /**
+     * Skip newlines
+     */
+    skipNewlines(): void;
+    /**
+     * Skip indentation tokens
+     */
+    skipIndentation(): void;
+    /**
+     * Get diagnostic information about tokenizer state
+     */
+    getDiagnostics(): {
+        totalTokens: number;
+        currentPosition: number;
+        currentToken: Token;
+        tokensRemaining: number;
+    };
+}
+//# sourceMappingURL=tokenizer.d.ts.map

package/dist/generated/parser/tokenizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenizer.d.ts","sourceRoot":"","sources":["../../../src/generated/parser/tokenizer.ts"],"names":[],"mappings":"AACA;;;;;GAKG;AAEH,OAAO,EAAS,SAAS,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,QAAQ,CAAa;gBAEjB,MAAM,EAAE,MAAM;IAS1B;;OAEG;IACI,OAAO,IAAI,KAAK;IAIvB;;OAEG;IACI,IAAI,CAAC,MAAM,SAAI,GAAG,KAAK;IAK9B;;OAEG;IACI,QAAQ,CAAC,MAAM,SAAI,GAAG,KAAK;IAIlC;;OAEG;IACI,OAAO,IAAI,KAAK;IAQvB;;OAEG;IACI,KAAK,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO;IAItC;;OAEG;IACI,QAAQ,CAAC,GAAG,KAAK,EAAE,SAAS,EAAE,GAAG,OAAO;IAI/C;;OAEG;IACI,OAAO,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,KAAK;IAUxD;;OAEG;IACI,UAAU,CAAC,IAAI,EAAE,SAAS,GAAG,KAAK,GAAG,IAAI;IAOhD;;OAEG;IACI,KAAK,CAAC,GAAG,KAAK,EAAE,SAAS,EAAE,GAAG,KAAK,GAAG,IAAI;IAOjD;;OAEG;IACI,OAAO,IAAI,OAAO;IAIzB;;OAEG;IACI,YAAY,IAAI,KAAK,EAAE;IAI9B;;OAEG;IACI,WAAW,IAAI,MAAM;IAI5B;;OAEG;IACI,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAIrC;;OAEG;IACI,YAAY,CAAC,IAAI,EAAE,SAAS,GAAG,KAAK,EAAE;IAQ7C;;OAEG;IACI,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,KAAK,EAAE;IAIpD;;OAEG;IACI,WAAW,IAAI,IAAI;IAqB1B;;OAEG;IACI,KAAK,IAAI,SAAS;IAOzB;;OAEG;IACI,eAAe,IAAI,MAAM;IAYhC;;OAEG;IACI,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,KAAK,EAAE;IAIjD;;OAEG;IACI,YAAY,IAAI,IAAI;IAM3B;;OAEG;IACI,eAAe,IAAI,IAAI;IAM9B;;OAEG;IACI,cAAc,IAAI;QACvB,WAAW,EAAE,MAAM,CAAC;QACpB,eAAe,EAAE,MAAM,CAAC;QACxB,YAAY,EAAE,KAAK,CAAC;QACpB,eAAe,EAAE,MAAM,CAAC;KACzB;CAQF"}

package/dist/generated/parser/tokenizer.js

@@ -0,0 +1,202 @@
+// GENERATED by cli-node/scripts/vendor-parser.mjs — do not edit; regenerate with `node scripts/vendor-parser.mjs`; source: packages/parser/
+/**
+ * Aexol Language Tokenizer
+ *
+ * Provides a stream-like interface for token consumption and lookahead.
+ * Builds on the Lexer to handle token stream management.
+ */
+import { Lexer, TokenType } from "./lexer.js";
+export class Tokenizer {
+    tokens;
+    position = 0;
+    constructor(source) {
+        const lexer = new Lexer(source);
+        this.tokens = lexer.tokenize();
+        // Filter out comments and whitespace tokens for parsing
+        this.tokens = this.tokens.filter((token) => token.type !== TokenType.COMMENT && token.type !== TokenType.WHITESPACE);
+    }
+    /**
+     * Get the current token without advancing
+     */
+    current() {
+        return this.tokens[this.position] || this.tokens[this.tokens.length - 1]; // Return EOF if past end
+    }
+    /**
+     * Peek at the next token(s) without advancing
+     */
+    peek(offset = 1) {
+        return this.tokens[this.position + offset] ||
+            this.tokens[this.tokens.length - 1];
+    }
+    /**
+     * Peek backwards
+     */
+    peekBack(offset = 1) {
+        return this.tokens[Math.max(0, this.position - offset)];
+    }
+    /**
+     * Advance to the next token and return the current one
+     */
+    advance() {
+        const token = this.current();
+        if (this.position < this.tokens.length - 1) {
+            this.position++;
+        }
+        return token;
+    }
+    /**
+     * Check if current token matches a type
+     */
+    check(type) {
+        return this.current().type === type;
+    }
+    /**
+     * Check if current token matches multiple types
+     */
+    checkAny(...types) {
+        return types.includes(this.current().type);
+    }
+    /**
+     * Consume a token of expected type or throw error
+     */
+    consume(type, message) {
+        if (!this.check(type)) {
+            throw new SyntaxError(message ||
+                `Expected ${type} but got ${this.current().type} at line ${this.current().location.line}:${this.current().location.column}`);
+        }
+        return this.advance();
+    }
+    /**
+     * Try to consume a token of type, return null if not found
+     */
+    tryConsume(type) {
+        if (this.check(type)) {
+            return this.advance();
+        }
+        return null;
+    }
+    /**
+     * Match and consume one of multiple types
+     */
+    match(...types) {
+        if (this.checkAny(...types)) {
+            return this.advance();
+        }
+        return null;
+    }
+    /**
+     * Check if we've reached EOF
+     */
+    isAtEnd() {
+        return this.check(TokenType.EOF);
+    }
+    /**
+     * Get all tokens
+     */
+    getAllTokens() {
+        return this.tokens;
+    }
+    /**
+     * Get current position in token stream
+     */
+    getPosition() {
+        return this.position;
+    }
+    /**
+     * Set position in token stream
+     */
+    setPosition(pos) {
+        this.position = Math.max(0, Math.min(pos, this.tokens.length - 1));
+    }
+    /**
+     * Get tokens until a certain type is encountered
+     */
+    collectUntil(type) {
+        const collected = [];
+        while (!this.check(type) && !this.isAtEnd()) {
+            collected.push(this.advance());
+        }
+        return collected;
+    }
+    /**
+     * Get a range of tokens
+     */
+    getRange(start, end) {
+        return this.tokens.slice(start, end);
+    }
+    /**
+     * Synchronize on error - skip tokens until we find a statement boundary
+     */
+    synchronize() {
+        this.advance();
+        while (!this.isAtEnd()) {
+            if (this.peekBack().type === TokenType.NEWLINE) {
+                return;
+            }
+            switch (this.current().type) {
+                case TokenType.VISITOR:
+                case TokenType.DEFINE:
+                case TokenType.AGENT:
+                case TokenType.WORKFLOW:
+                case TokenType.TYPE:
+                    return;
+            }
+            this.advance();
+        }
+    }
+    /**
+     * Create a copy of the tokenizer at current position
+     */
+    clone() {
+        const newTokenizer = Object.create(Object.getPrototypeOf(this));
+        newTokenizer.tokens = this.tokens;
+        newTokenizer.position = this.position;
+        return newTokenizer;
+    }
+    /**
+     * Get human-readable representation of current token
+     */
+    getErrorContext() {
+        const token = this.current();
+        const prevToken = this.peekBack();
+        const nextToken = this.peek();
+        return `
+      Previous: ${prevToken.type} "${prevToken.value}"
+      Current:  ${token.type} "${token.value}" at ${token.location.line}:${token.location.column}
+      Next:     ${nextToken.type} "${nextToken.value}"
+    `;
+    }
+    /**
+     * Get tokens in a specific line
+     */
+    getLineTokens(lineNumber) {
+        return this.tokens.filter((token) => token.location.line === lineNumber);
+    }
+    /**
+     * Skip newlines
+     */
+    skipNewlines() {
+        while (this.check(TokenType.NEWLINE)) {
+            this.advance();
+        }
+    }
+    /**
+     * Skip indentation tokens
+     */
+    skipIndentation() {
+        while (this.checkAny(TokenType.INDENT, TokenType.DEDENT)) {
+            this.advance();
+        }
+    }
+    /**
+     * Get diagnostic information about tokenizer state
+     */
+    getDiagnostics() {
+        return {
+            totalTokens: this.tokens.length,
+            currentPosition: this.position,
+            currentToken: this.current(),
+            tokensRemaining: this.tokens.length - this.position,
+        };
+    }
+}

package/dist/generated/parser/validator.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Aexol Language Validator
+ *
+ * Validates the AST and provides semantic analysis.
+ * Checks for errors, warnings, and best practices.
+ */
+import type { ASTNode, Program } from "./parser.js";
+export interface ValidationError {
+    type: "error" | "warning" | "info";
+    message: string;
+    node: ASTNode;
+    code: string;
+}
+export interface ValidationResult {
+    isValid: boolean;
+    errors: ValidationError[];
+    warnings: ValidationError[];
+    infos: ValidationError[];
+}
+export declare class Validator {
+    private program;
+    private errors;
+    private warnings;
+    private infos;
+    private visitorNameCounts;
+    private anonymousVisitorCount;
+    private definedTypes;
+    private definedRoles;
+    private definedWorkflows;
+    private definedAgents;
+    constructor(program: Program);
+    validate(): ValidationResult;
+    private validateVisitor;
+    private validateCapability;
+    private validateRole;
+    private validateWorkflow;
+    private validateAgent;
+    private validateDomainAgent;
+    private validateBuilderAgent;
+    private validateType;
+    private addError;
+    private addWarning;
+    private addInfo;
+}
+//# sourceMappingURL=validator.d.ts.map

package/dist/generated/parser/validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../../../src/generated/parser/validator.ts"],"names":[],"mappings":"AACA;;;;;GAKG;AAEH,OAAO,KAAK,EAEV,OAAO,EAEP,OAAO,EAKR,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,KAAK,EAAE,eAAe,EAAE,CAAC;CAC1B;AAED,qBAAa,SAAS;IACpB,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,MAAM,CAAyB;IACvC,OAAO,CAAC,QAAQ,CAAyB;IACzC,OAAO,CAAC,KAAK,CAAyB;IACtC,OAAO,CAAC,iBAAiB,CAAkC;IAC3D,OAAO,CAAC,qBAAqB,CAAK;IAClC,OAAO,CAAC,YAAY,CAA0B;IAC9C,OAAO,CAAC,YAAY,CAA0B;IAC9C,OAAO,CAAC,gBAAgB,CAA0B;IAClD,OAAO,CAAC,aAAa,CAA0B;gBAEnC,OAAO,EAAE,OAAO;IAIrB,QAAQ,IAAI,gBAAgB;IAgEnC,OAAO,CAAC,eAAe;IAiCvB,OAAO,CAAC,kBAAkB;IAgB1B,OAAO,CAAC,YAAY;IAepB,OAAO,CAAC,gBAAgB;IA+BxB,OAAO,CAAC,aAAa;IAkCrB,OAAO,CAAC,mBAAmB;IAmB3B,OAAO,CAAC,oBAAoB;IA2B5B,OAAO,CAAC,YAAY;IA2BpB,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,OAAO;CAGhB"}

package/dist/generated/parser/validator.js

@@ -0,0 +1,202 @@
+// GENERATED by cli-node/scripts/vendor-parser.mjs — do not edit; regenerate with `node scripts/vendor-parser.mjs`; source: packages/parser/
+/**
+ * Aexol Language Validator
+ *
+ * Validates the AST and provides semantic analysis.
+ * Checks for errors, warnings, and best practices.
+ */
+export class Validator {
+    program;
+    errors = [];
+    warnings = [];
+    infos = [];
+    visitorNameCounts = new Map();
+    anonymousVisitorCount = 0;
+    definedTypes = new Set();
+    definedRoles = new Set();
+    definedWorkflows = new Set();
+    definedAgents = new Set();
+    constructor(program) {
+        this.program = program;
+    }
+    validate() {
+        this.errors = [];
+        this.warnings = [];
+        this.infos = [];
+        this.visitorNameCounts = new Map();
+        this.anonymousVisitorCount = 0;
+        this.definedTypes = new Set();
+        this.definedRoles = new Set();
+        this.definedWorkflows = new Set();
+        this.definedAgents = new Set();
+        // First pass: collect definitions
+        for (const node of this.program.body) {
+            if (node.type === "TypeDefinition") {
+                this.definedTypes.add(node.name);
+            }
+            else if (node.type === "VisitorDefinition") {
+                const visitorName = node.name?.trim();
+                if (visitorName) {
+                    this.visitorNameCounts.set(visitorName, (this.visitorNameCounts.get(visitorName) ?? 0) + 1);
+                }
+                else {
+                    this.anonymousVisitorCount += 1;
+                }
+            }
+            else if (node.type === "RoleDefinition") {
+                this.definedRoles.add(node.name);
+            }
+            else if (node.type === "WorkflowDefinition") {
+                this.definedWorkflows.add(node.name);
+            }
+            else if (node.type === "AgentDefinition") {
+                this.definedAgents.add(node.name);
+            }
+        }
+        // Second pass: validate
+        for (const node of this.program.body) {
+            switch (node.type) {
+                case "VisitorDefinition":
+                    this.validateVisitor(node);
+                    break;
+                case "RoleDefinition":
+                    this.validateRole(node);
+                    break;
+                case "WorkflowDefinition":
+                    this.validateWorkflow(node);
+                    break;
+                case "AgentDefinition":
+                    this.validateAgent(node);
+                    break;
+                case "TypeDefinition":
+                    this.validateType(node);
+                    break;
+            }
+        }
+        return {
+            isValid: this.errors.length === 0,
+            errors: this.errors,
+            warnings: this.warnings,
+            infos: this.infos,
+        };
+    }
+    validateVisitor(visitor) {
+        const visitorName = visitor.name?.trim();
+        if (visitorName && (this.visitorNameCounts.get(visitorName) ?? 0) > 1) {
+            this.addError(visitor, "DUPLICATE_VISITOR_NAME", `Visitor name '${visitorName}' is defined multiple times`);
+        }
+        if (!visitorName && this.anonymousVisitorCount > 1) {
+            this.addError(visitor, "MULTIPLE_ANONYMOUS_VISITORS", "Only one anonymous visitor definition is allowed");
+        }
+        if (visitor.capabilities.length === 0) {
+            const displayName = visitorName ?? "Anonymous Visitor";
+            this.addWarning(visitor, "EMPTY_VISITOR", `Visitor '${displayName}' has no capabilities`);
+        }
+        for (const capability of visitor.capabilities) {
+            this.validateCapability(capability);
+        }
+    }
+    validateCapability(capability) {
+        if (!capability.action || capability.action.trim() === "") {
+            this.addError(capability, "INVALID_ACTION", "Capability must have an action");
+        }
+        if (capability.nested && capability.nested.length > 0) {
+            for (const nested of capability.nested) {
+                this.validateCapability(nested);
+            }
+        }
+    }
+    validateRole(role) {
+        if (!role.name || role.name.trim() === "") {
+            this.addError(role, "INVALID_NAME", "Role must have a name");
+            return;
+        }
+        if (role.permissions.length === 0) {
+            this.addWarning(role, "EMPTY_ROLE", `Role '${role.name}' has no permissions`);
+        }
+    }
+    validateWorkflow(workflow) {
+        if (!workflow.name || workflow.name.trim() === "") {
+            this.addError(workflow, "INVALID_NAME", "Workflow must have a name");
+            return;
+        }
+        if (workflow.steps.length === 0) {
+            this.addWarning(workflow, "EMPTY_WORKFLOW", `Workflow '${workflow.name}' has no steps`);
+        }
+        if (!workflow.initialState || workflow.initialState.trim() === "") {
+            this.addWarning(workflow, "MISSING_INITIAL_STATE", `Workflow '${workflow.name}' has no initial state`);
+        }
+        if (workflow.finalStates.length === 0) {
+            this.addWarning(workflow, "MISSING_FINAL_STATES", `Workflow '${workflow.name}' has no final states`);
+        }
+    }
+    validateAgent(agent) {
+        if (!agent.name || agent.name.trim() === "") {
+            this.addError(agent, "INVALID_NAME", "Agent must have a name");
+            return;
+        }
+        // Different validation based on agent kind
+        if (agent.agentKind === "builder") {
+            this.validateBuilderAgent(agent);
+        }
+        else {
+            this.validateDomainAgent(agent);
+        }
+        // Check for mixed properties (warning)
+        // Builder properties: skills, model, maxConcurrent
+        const hasBuilderProps = agent.skills !== undefined ||
+            agent.model !== undefined || agent.maxConcurrent !== undefined;
+        // Domain properties: role assignment, capabilities with conditions
+        const hasDomainRole = agent.role !== undefined && agent.role.trim() !== "";
+        const hasConditionalCapabilities = agent.capabilities.some((c) => c.conditions !== undefined && c.conditions.length > 0);
+        if (hasBuilderProps && (hasDomainRole || hasConditionalCapabilities)) {
+            this.addWarning(agent, "MIXED_AGENT_PROPERTIES", `Agent '${agent.name}' mixes builder properties (skills/model/max_concurrent) with domain properties (role${hasConditionalCapabilities ? "/conditional capabilities" : ""}). Consider separating into two distinct agents: one for business logic and one for AI assistance.`);
+        }
+    }
+    validateDomainAgent(agent) {
+        // Domain agents represent business logic actors
+        if (agent.role && !this.definedRoles.has(agent.role)) {
+            this.addWarning(agent, "UNDEFINED_ROLE", `Agent '${agent.name}' references undefined role '${agent.role}'`);
+        }
+        if (agent.capabilities.length === 0) {
+            this.addWarning(agent, "EMPTY_AGENT", `Domain agent '${agent.name}' has no capabilities`);
+        }
+    }
+    validateBuilderAgent(agent) {
+        // Builder agents are for AI-assisted code generation
+        if (!agent.skills && !agent.model && !agent.capabilities.length) {
+            this.addWarning(agent, "EMPTY_BUILDER", `Builder agent '${agent.name}' should have skills, capabilities, or model specified`);
+        }
+        if (agent.model && !agent.model.match(/^[a-z0-9\-\.]+$/)) {
+            this.addWarning(agent, "INVALID_MODEL_FORMAT", `Builder agent '${agent.name}' has invalid model format: '${agent.model}'`);
+        }
+        if (agent.maxConcurrent !== undefined && agent.maxConcurrent <= 0) {
+            this.addError(agent, "INVALID_MAX_CONCURRENT", `Builder agent '${agent.name}' max_concurrent must be a positive number`);
+        }
+    }
+    validateType(type) {
+        if (!type.name || type.name.trim() === "") {
+            this.addError(type, "INVALID_NAME", "Type must have a name");
+            return;
+        }
+        if (type.kind === "type" || type.kind === "interface") {
+            if (!type.fields || type.fields.length === 0) {
+                this.addWarning(type, "EMPTY_TYPE", `Type '${type.name}' has no fields`);
+            }
+        }
+        if (type.kind === "enum") {
+            if (!type.values || type.values.length === 0) {
+                this.addWarning(type, "EMPTY_ENUM", `Enum '${type.name}' has no values`);
+            }
+        }
+    }
+    addError(node, code, message) {
+        this.errors.push({ type: "error", message, node, code });
+    }
+    addWarning(node, code, message) {
+        this.warnings.push({ type: "warning", message, node, code });
+    }
+    addInfo(node, code, message) {
+        this.infos.push({ type: "info", message, node, code });
+    }
+}

package/dist/generated/zeus/const.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../../../src/generated/zeus/const.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAC,GAAG,CAm2B5C,CAAA;AAED,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAC,GAAG,CAqtC1C,CAAA;AAED,eAAO,MAAM,GAAG;;;;CAIf,CAAA"}
+{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../../../src/generated/zeus/const.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAC,GAAG,CAwyB5C,CAAA;AAED,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAC,GAAG,CA0lC1C,CAAA;AAED,eAAO,MAAM,GAAG;;;;CAIf,CAAA"}