@behavioral-contracts/verify-cli 1.0.0

package/dist/analyze-results.js

@@ -0,0 +1,253 @@
+#!/usr/bin/env node
+/**
+ * Phase 6.1: Analyze baseline test results
+ * Parses audit JSON files and generates summary report
+ */
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const OUTPUT_DATE = process.argv[2] || new Date().toISOString().split('T')[0].replace(/-/g, '');
+const OUTPUT_DIR = path.join(path.dirname(__dirname), 'output', OUTPUT_DATE);
+function parseAuditFile(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (err) {
+        console.error(`Failed to parse ${filePath}:`, err);
+        return null;
+    }
+}
+function analyzePackage(packageName) {
+    const safeName = packageName.replace(/\//g, '-');
+    const auditPath = path.join(OUTPUT_DIR, `${safeName}-audit.json`);
+    const result = {
+        name: packageName,
+        status: 'ERROR',
+        totalViolations: 0,
+        properViolations: 0,
+        missingViolations: 0,
+        instanceViolations: 0,
+        violations: [],
+    };
+    if (!fs.existsSync(auditPath)) {
+        result.error = 'Audit file not found';
+        return result;
+    }
+    const audit = parseAuditFile(auditPath);
+    if (!audit) {
+        result.error = 'Failed to parse audit file';
+        return result;
+    }
+    result.totalViolations = audit.violations.length;
+    result.violations = audit.violations;
+    // Categorize violations by fixture file
+    for (const violation of audit.violations) {
+        const filename = path.basename(violation.file);
+        if (filename === 'proper-error-handling.ts') {
+            result.properViolations++;
+        }
+        else if (filename === 'missing-error-handling.ts') {
+            result.missingViolations++;
+        }
+        else if (filename === 'instance-usage.ts') {
+            result.instanceViolations++;
+        }
+    }
+    // PASS if no violations in proper-error-handling.ts
+    result.status = result.properViolations === 0 ? 'PASS' : 'FAIL';
+    return result;
+}
+function generateReport(results) {
+    const passed = results.filter(r => r.status === 'PASS');
+    const failed = results.filter(r => r.status === 'FAIL');
+    const errors = results.filter(r => r.status === 'ERROR');
+    let report = `# Phase 6.1: Baseline Fixture Testing - Complete Results
+
+**Date:** ${new Date().toISOString().split('T')[0]}
+**Output Directory:** \`verify-cli/output/${OUTPUT_DATE}/\`
+
+---
+
+## Summary
+
+- **Total Packages:** ${results.length}
+- **Passed:** ${passed.length} (${((passed.length / results.length) * 100).toFixed(1)}%)
+- **Failed:** ${failed.length} (${((failed.length / results.length) * 100).toFixed(1)}%)
+- **Errors:** ${errors.length}
+
+**Pass Criteria:** 0 violations in \`proper-error-handling.ts\`
+
+---
+
+## Overall Results
+
+### ✅ Passed Packages (${passed.length})
+
+${passed.length > 0 ? passed.map(r => `- **${r.name}** - ${r.totalViolations} total violations (${r.missingViolations} missing, ${r.instanceViolations} instance)`).join('\n') : '_None_'}
+
+### ❌ Failed Packages (${failed.length})
+
+${failed.length > 0 ? failed.map(r => `- **${r.name}** - ${r.properViolations} violations in proper-error-handling.ts`).join('\n') : '_None_'}
+
+### ⚠️ Error Packages (${errors.length})
+
+${errors.length > 0 ? errors.map(r => `- **${r.name}** - ${r.error}`).join('\n') : '_None_'}
+
+---
+
+## Detailed Results by Package
+
+`;
+    // Sort by status then name
+    const sortedResults = results.sort((a, b) => {
+        if (a.status !== b.status) {
+            const order = { PASS: 0, FAIL: 1, ERROR: 2 };
+            return order[a.status] - order[b.status];
+        }
+        return a.name.localeCompare(b.name);
+    });
+    for (const result of sortedResults) {
+        const emoji = result.status === 'PASS' ? '✅' : result.status === 'FAIL' ? '❌' : '⚠️';
+        report += `### ${emoji} ${result.name}\n\n`;
+        report += `**Status:** ${result.status}\n\n`;
+        if (result.status === 'ERROR') {
+            report += `**Error:** ${result.error}\n\n`;
+            report += `---\n\n`;
+            continue;
+        }
+        report += `**Violations:**\n`;
+        report += `- Total: ${result.totalViolations}\n`;
+        report += `- In proper-error-handling.ts: ${result.properViolations}\n`;
+        report += `- In missing-error-handling.ts: ${result.missingViolations}\n`;
+        report += `- In instance-usage.ts: ${result.instanceViolations}\n\n`;
+        if (result.properViolations > 0) {
+            report += `**Issues in proper-error-handling.ts:**\n\n`;
+            const properViolations = result.violations.filter(v => path.basename(v.file) === 'proper-error-handling.ts');
+            for (const v of properViolations) {
+                report += `- Line ${v.line}: ${v.message}\n`;
+                report += `  - Package: \`${v.package}\`, Method: \`${v.method}\`\n`;
+                report += `  - Severity: ${v.severity}\n\n`;
+            }
+        }
+        report += `---\n\n`;
+    }
+    // Pattern analysis
+    report += `## Pattern Analysis\n\n`;
+    const failurePatterns = {};
+    for (const result of failed) {
+        for (const v of result.violations) {
+            if (path.basename(v.file) === 'proper-error-handling.ts') {
+                const key = `${v.package}:${v.method}`;
+                failurePatterns[key] = (failurePatterns[key] || 0) + 1;
+            }
+        }
+    }
+    if (Object.keys(failurePatterns).length > 0) {
+        report += `### Common False Positives\n\n`;
+        const sorted = Object.entries(failurePatterns).sort((a, b) => b[1] - a[1]);
+        for (const [pattern, count] of sorted) {
+            report += `- \`${pattern}\` - ${count} occurrence(s)\n`;
+        }
+        report += `\n`;
+    }
+    // Recommendations
+    report += `## Recommendations\n\n`;
+    if (failed.length > 0) {
+        report += `### High Priority Fixes\n\n`;
+        report += `The following packages have violations in proper-error-handling.ts and need investigation:\n\n`;
+        for (const result of failed.slice(0, 10)) {
+            report += `1. **${result.name}**\n`;
+            report += `   - Review proper-error-handling.ts fixture\n`;
+            report += `   - Verify error handling patterns are actually proper\n`;
+            report += `   - Update contract or analyzer if needed\n\n`;
+        }
+        if (failed.length > 10) {
+            report += `_...and ${failed.length - 10} more packages_\n\n`;
+        }
+    }
+    report += `### Next Steps\n\n`;
+    report += `1. **Investigate Failed Packages**: Review each package with proper-error-handling.ts violations\n`;
+    report += `2. **Fix Contracts**: Update contracts to match actual proper patterns\n`;
+    report += `3. **Fix Analyzer**: Improve analyzer detection logic if needed\n`;
+    report += `4. **Fix Fixtures**: Correct fixture code if patterns are actually improper\n`;
+    report += `5. **Re-test**: Run Phase 6.1 again after fixes\n\n`;
+    report += `---\n\n`;
+    report += `**Generated:** ${new Date().toISOString()}\n`;
+    return report;
+}
+async function main() {
+    console.log(`Analyzing results in: ${OUTPUT_DIR}`);
+    const packages = [
+        "axios",
+        "cloudinary",
+        "discord.js",
+        "express",
+        "firebase-admin",
+        "ioredis",
+        "mongodb",
+        "mongoose",
+        "openai",
+        "pg",
+        "react-hook-form",
+        "redis",
+        "square",
+        "stripe",
+        "twilio",
+        "typescript",
+        "zod",
+        "@anthropic-ai/sdk",
+        "@aws-sdk/client-s3",
+        "@clerk/nextjs",
+        "@octokit/rest",
+        "@prisma/client",
+        "@sendgrid/mail",
+        "@slack/web-api",
+        "@supabase/supabase-js",
+        "@tanstack/react-query",
+        "bullmq",
+        "@vercel/postgres",
+        "drizzle-orm",
+        "socket.io",
+        "joi",
+        "ethers",
+        "fastify",
+        "next",
+        "dotenv",
+        "jsonwebtoken",
+        "bcrypt",
+        "multer",
+        "helmet",
+        "cors",
+        "winston",
+        "passport",
+        "knex",
+        "typeorm",
+        "graphql",
+        "uuid",
+        "date-fns",
+        "@nestjs/common",
+        "@hapi/hapi",
+    ];
+    const results = [];
+    for (const pkg of packages) {
+        const result = analyzePackage(pkg);
+        results.push(result);
+        const emoji = result.status === 'PASS' ? '✅' : result.status === 'FAIL' ? '❌' : '⚠️';
+        console.log(`${emoji} ${pkg}: ${result.status} (${result.properViolations} proper violations)`);
+    }
+    console.log(`\nGenerating report...`);
+    const report = generateReport(results);
+    const reportPath = path.join(__dirname, '../dev-notes/findings/phase6-baseline-complete-results.md');
+    // Ensure directory exists
+    fs.mkdirSync(path.dirname(reportPath), { recursive: true });
+    fs.writeFileSync(reportPath, report, 'utf-8');
+    console.log(`\nReport saved to: ${reportPath}`);
+    console.log(`\nSummary:`);
+    console.log(`  Passed: ${results.filter(r => r.status === 'PASS').length}`);
+    console.log(`  Failed: ${results.filter(r => r.status === 'FAIL').length}`);
+    console.log(`  Errors: ${results.filter(r => r.status === 'ERROR').length}`);
+}
+main().catch(console.error);

package/dist/analyzer.d.ts

@@ -0,0 +1,366 @@
+/**
+ * AST Analyzer - uses TypeScript Compiler API to detect behavioral contract violations
+ */
+import type { PackageContract, Violation, AnalyzerConfig } from './types.js';
+/**
+ * Main analyzer that coordinates the verification process
+ */
+export declare class Analyzer {
+    private program;
+    private typeChecker;
+    private contracts;
+    private violations;
+    private projectRoot;
+    private includeTests;
+    private typeToPackage;
+    private classToPackage;
+    private factoryToPackage;
+    private awaitPatternToPackage;
+    constructor(config: AnalyzerConfig, contracts: Map<string, PackageContract>);
+    /**
+     * Builds detection maps from contract definitions
+     * This replaces hardcoded mappings with data-driven approach
+     */
+    private buildDetectionMaps;
+    /**
+     * Analyzes all files in the program and returns violations
+     */
+    analyze(): Violation[];
+    /**
+     * Extracts all package imports from a source file
+     */
+    private extractImports;
+    /**
+     * Determines if a file is a test file based on common patterns
+     * Test files are excluded by default because:
+     * - Tests intentionally expect errors to be thrown
+     * - Test frameworks (Jest, Vitest) handle errors automatically
+     * - 90%+ of test violations are false positives
+     */
+    private isTestFile;
+    /**
+     * Analyzes a single source file
+     */
+    private analyzeFile;
+    /**
+     * Detects async functions with unprotected await expressions
+     */
+    private detectAsyncErrors;
+    /**
+     * Detects functions with unprotected return value error checks
+     */
+    private detectReturnValueErrors;
+    /**
+     * Creates a violation for unprotected return value error checks
+     */
+    private createReturnValueViolation;
+    /**
+     * Detects instances missing required event listeners
+     */
+    private detectEventListenerErrors;
+    /**
+     * Creates a violation for missing required event listeners
+     */
+    private createEventListenerViolation;
+    /**
+     * Creates a violation for unprotected async calls
+     */
+    private createAsyncErrorViolation;
+    /**
+     * Detects which package is being called from the await expression text
+     * Uses dynamic pattern matching from contract detection rules
+     */
+    private detectPackageFromAwaitText;
+    /**
+     * Detects package using TypeScript's type system (MOST ACCURATE METHOD)
+     *
+     * Uses TypeScript's type checker to determine which package a variable belongs to
+     * based on its type, eliminating false positives from pattern matching.
+     *
+     * Steps:
+     * 1. Get the type of the object the method is called on
+     * 2. Extract the type name (e.g., "TextChannel", "Model")
+     * 3. Look up which package defines this type
+     *
+     * Example:
+     *   const channel: TextChannel = getChannel();
+     *   await channel.createInvite();
+     *
+     *   → channel has type TextChannel
+     *   → TextChannel is from discord.js (per contract detection.type_names)
+     *   → Return "discord.js"
+     *
+     * This eliminates false positives from pattern overlap:
+     *   - mongoose ".create" won't match discord.js ".createInvite()"
+     *   - Each type uniquely identifies its package
+     *
+     * @param node The call expression node from the AST
+     * @returns Package name if type is recognized, null otherwise
+     */
+    private detectPackageFromType;
+    /**
+     * Extracts package name from a TypeScript type
+     * Handles edge cases: generics, aliases, unions, intersections
+     *
+     * Edge cases:
+     * 1. Type aliases: import { Client as Bot } from 'discord.js' → resolve "Bot" to "Client"
+     * 2. Generic types: Model<User> → extract base type "Model"
+     * 3. Union types: TextChannel | VoiceChannel → try all types in union
+     * 4. Intersection types: A & B → try all types in intersection
+     *
+     * @param type The TypeScript type to analyze
+     * @returns Package name if recognized, null otherwise
+     */
+    private extractPackageFromType;
+    /**
+     * Detects package from tracked instance (most accurate method)
+     * Extracts instance name from await expression and checks if it's tracked
+     *
+     * Examples:
+     *   "await this.catModel.find()" → extracts "catModel" → checks if tracked
+     *   "await user.save()" → extracts "user" → checks if tracked
+     *   "await Model.create()" → extracts "Model" → checks if tracked
+     */
+    private detectPackageFromTrackedInstance;
+    /**
+     * Creates a violation for a detected package
+     * Extracted from createAsyncErrorViolation to reduce duplication
+     */
+    private createViolationForPackage;
+    /**
+     * Creates a violation for empty or ineffective catch blocks
+     */
+    private createEmptyCatchViolation;
+    /**
+     * Analyzes a call expression to see if it violates any contracts
+     */
+    private analyzeCallExpression;
+    /**
+     * Analyzes React Query hooks for error handling
+     */
+    private analyzeReactQueryHook;
+    /**
+     * Checks if a mutation variable is used with mutateAsync in a try-catch block
+     */
+    private checkMutateAsyncInTryCatch;
+    /**
+     * Checks a React Query postcondition and returns a violation if not met
+     */
+    private checkReactQueryPostcondition;
+    /**
+     * Walks up a property access chain and returns components
+     * Example: prisma.user.create → { root: 'prisma', chain: ['user'], method: 'create' }
+     * Example: axios.get → { root: 'axios', chain: [], method: 'get' }
+     * Example: openai.chat.completions.create → { root: 'openai', chain: ['chat', 'completions'], method: 'create' }
+     */
+    private walkPropertyAccessChain;
+    /**
+     * Extracts call site information from a call expression
+     */
+    private extractCallSite;
+    /**
+     * Extracts the instance variable name from a call expression
+     * e.g., for "axiosInstance.get(...)" returns "axiosInstance"
+     */
+    private extractInstanceVariable;
+    /**
+     * Resolves which package a function comes from by looking at imports
+     */
+    private resolvePackageFromImports;
+    /**
+     * Extracts package name from new expressions
+     * Examples: new PrismaClient() → "@prisma/client"
+     *          new Stripe(key) → "stripe"
+     *          new OpenAI(config) → "openai"
+     */
+    private extractPackageFromNewExpression;
+    /**
+     * Extracts package name from axios.create() call
+     * Returns the package name if this is an axios.create() or similar factory call
+     */
+    private extractPackageFromAxiosCreate;
+    /**
+     * Extracts package name from generic factory methods defined in detection rules
+     * Examples:
+     *   mongoose.model('User', schema) → "mongoose" (if factory_methods includes "model")
+     *   prisma.client() → "prisma" (if factory_methods includes "client")
+     */
+    private extractPackageFromGenericFactory;
+    /**
+     * Extracts package name from schema factory methods (z.object(), z.string(), etc.)
+     * Returns the package name if this is a schema creation call
+     */
+    private extractPackageFromSchemaFactory;
+    /**
+     * Analyzes what error handling exists around a call site
+     */
+    /**
+     * Checks if a call is within an Express route that has error middleware
+     * Pattern: app.post('/route', middleware, errorHandler)
+     * where errorHandler has 4 parameters (err, req, res, next)
+     */
+    private isWithinExpressErrorMiddleware;
+    /**
+     * Checks if a call is within a NestJS controller method
+     * NestJS controllers use exception filters to handle errors globally
+     */
+    private isWithinNestJSController;
+    /**
+     * Checks if a node has a specific decorator
+     */
+    private hasDecorator;
+    /**
+     * Finds a function definition by name in the source file
+     */
+    private findFunctionDefinition;
+    private analyzeErrorHandling;
+    /**
+     * Checks if a node is inside a try-catch block
+     */
+    private isInTryCatch;
+    /**
+     * Checks if a node is inside a callback/arrow function that contains a try-catch block
+     * Handles fastify routes, socket.io event handlers, etc.
+     */
+    private isInsideCallbackWithTryCatch;
+    /**
+     * Checks if a node is inside a try block within a function
+     */
+    private isNodeInsideTryBlock;
+    /**
+     * Checks if a function contains a try-catch block in its body
+     */
+    private functionContainsTryCatch;
+    /**
+     * Checks if this is a route/event handler registration with try-catch in the handler
+     * Handles: fastify routes (app.get, app.post), socket.io events (io.on, socket.on)
+     * Pattern: app.get('/route', async (req, res) => { try { ... } catch { ... } })
+     */
+    private isRouteHandlerWithTryCatch;
+    /**
+     * Checks if a function contains await expressions
+     */
+    private functionContainsAwait;
+    /**
+     * Checks if there's a finally block that cleans up resources
+     * Pattern: const client = await pool.connect(); ... finally { client.release(); }
+     */
+    private hasFinallyCleanup;
+    /**
+     * Checks if a finally block calls a cleanup method on a variable
+     */
+    private finallyBlockCallsCleanup;
+    /**
+     * Checks if a call uses callback-based error handling
+     * Pattern: callback((error, result) => { if (error) return reject(error); })
+     */
+    private hasCallbackErrorHandling;
+    /**
+     * Checks if a callback function body checks the error parameter
+     * Looks for patterns like: if (error) or if (err)
+     */
+    private callbackChecksErrorParam;
+    /**
+     * Finds the enclosing catch clause for a node
+     */
+    private findEnclosingCatchClause;
+    /**
+     * Checks if a catch block checks error.response exists
+     */
+    private catchChecksResponseExists;
+    /**
+     * Checks if an expression checks for response property
+     */
+    private expressionChecksResponse;
+    /**
+     * Checks if a catch block checks status codes
+     */
+    private catchChecksStatusCode;
+    /**
+     * Extracts which status codes are explicitly handled
+     */
+    private extractHandledStatusCodes;
+    /**
+     * Checks if catch block has retry logic
+     */
+    private catchHasRetryLogic;
+    /**
+     * Checks if a postcondition is violated at a call site
+     */
+    private checkPostcondition;
+    /**
+     * Checks if a function call result has proper null handling
+     * Used for Clerk functions that return null when not authenticated
+     */
+    private checkNullHandling;
+    /**
+     * Checks if a condition is a null check for the given variables
+     */
+    private isNullCheckCondition;
+    /**
+     * Finds the containing function/method for a node
+     */
+    private findContainingFunction;
+    /**
+     * Checks if a function call has hardcoded credentials (string literals)
+     * vs environment variables (process.env.*)
+     *
+     * Returns true if hardcoded credentials are detected (violation)
+     * Returns false if credentials come from environment variables (valid)
+     */
+    private checkHardcodedCredentials;
+    /**
+     * Finds a variable declaration in the scope of the given node
+     */
+    private findVariableDeclaration;
+    /**
+     * Checks if a specific file exists in the project
+     * Tries multiple possible locations (root, src/, etc.)
+     *
+     * @param fileName - The file name to search for (e.g., 'middleware.ts')
+     * @param variations - Optional variations of the file name (e.g., ['middleware.ts', 'middleware.js'])
+     * @returns The full path if found, null otherwise
+     */
+    private checkFileExists;
+    /**
+     * Checks if a file imports and exports specific patterns
+     *
+     * @param filePath - Absolute path to the file to check
+     * @param importPattern - Object specifying what to look for in imports
+     * @param exportPattern - Object specifying what to look for in exports
+     * @returns Object with hasImport and hasExport booleans
+     */
+    private checkFileImportsAndExports;
+    /**
+     * Checks if middleware.ts exists and properly exports clerkMiddleware
+     * This is specific to @clerk/nextjs middleware setup
+     *
+     * @returns true if middleware is properly configured, false otherwise
+     */
+    private checkClerkMiddlewareExists;
+    /**
+     * Creates a violation object
+     */
+    private createViolation;
+    /**
+     * Gets statistics about the analysis run
+     */
+    getStats(): {
+        filesAnalyzed: number;
+        contractsApplied: number;
+    };
+    /**
+     * Analyzes S3 send() calls to detect command type
+     * Pattern: s3Client.send(new GetObjectCommand(...))
+     */
+    private analyzeS3SendCall;
+    /**
+     * Analyzes an S3 command call and creates violations if needed
+     */
+    private analyzeS3Command;
+    /**
+     * Maps S3 command types to their corresponding postcondition IDs
+     */
+    private mapS3CommandToPostcondition;
+}
+//# sourceMappingURL=analyzer.d.ts.map

package/dist/analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../src/analyzer.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EACV,eAAe,EACf,SAAS,EAGT,cAAc,EAEf,MAAM,YAAY,CAAC;AAMpB;;GAEG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,WAAW,CAAiB;IACpC,OAAO,CAAC,SAAS,CAA+B;IAChD,OAAO,CAAC,UAAU,CAAmB;IACrC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,YAAY,CAAU;IAG9B,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,cAAc,CAAsB;IAC5C,OAAO,CAAC,gBAAgB,CAAsB;IAC9C,OAAO,CAAC,qBAAqB,CAAsB;gBAEvC,MAAM,EAAE,cAAc,EAAE,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC;IA+B3E;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IA4B1B;;OAEG;IACH,OAAO,IAAI,SAAS,EAAE;IAoBtB;;OAEG;IACH,OAAO,CAAC,cAAc;IAgCtB;;;;;;OAMG;IACH,OAAO,CAAC,UAAU;IAiBlB;;OAEG;IACH,OAAO,CAAC,WAAW;IA8KnB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA0DzB;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAuC/B;;OAEG;IACH,OAAO,CAAC,0BAA0B;IAqClC;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAuCjC;;OAEG;IACH,OAAO,CAAC,4BAA4B;IA+BpC;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAmDjC;;;OAGG;IACH,OAAO,CAAC,0BAA0B;IAiClC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,OAAO,CAAC,qBAAqB;IA6B7B;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,sBAAsB;IA4D9B;;;;;;;;OAQG;IACH,OAAO,CAAC,gCAAgC;IAqCxC;;;OAGG;IACH,OAAO,CAAC,yBAAyB;IA0DjC;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAwDjC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAiF7B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAqE7B;;OAEG;IACH,OAAO,CAAC,0BAA0B;IA8BlC;;OAEG;IACH,OAAO,CAAC,4BAA4B;IAoEpC;;;;;OAKG;IACH,OAAO,CAAC,uBAAuB;IAsD/B;;OAEG;IACH,OAAO,CAAC,eAAe;IAqGvB;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAa/B;;OAEG;IACH,OAAO,CAAC,yBAAyB;IA8DjC;;;;;OAKG;IACH,OAAO,CAAC,+BAA+B;IAkBvC;;;OAGG;IACH,OAAO,CAAC,6BAA6B;IAoDrC;;;;;OAKG;IACH,OAAO,CAAC,gCAAgC;IAyBxC;;;OAGG;IACH,OAAO,CAAC,+BAA+B;IA+EvC;;OAEG;IACH;;;;OAIG;IACH,OAAO,CAAC,8BAA8B;IAuDtC;;;OAGG;IACH,OAAO,CAAC,wBAAwB;IA4BhC;;OAEG;IACH,OAAO,CAAC,YAAY;IAuBpB;;OAEG;IACH,OAAO,CAAC,sBAAsB;IA2B9B,OAAO,CAAC,oBAAoB;IAgG5B;;OAEG;IACH,OAAO,CAAC,YAAY;IAmBpB;;;OAGG;IACH,OAAO,CAAC,4BAA4B;IAoBpC;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAiC5B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAwBhC;;;;OAIG;IACH,OAAO,CAAC,0BAA0B;IAiClC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAmB7B;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IA+CzB;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAwBhC;;;OAGG;IACH,OAAO,CAAC,wBAAwB;IAuBhC;;;OAGG;IACH,OAAO,CAAC,wBAAwB;IA6ChC;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAahC;;OAEG;IACH,OAAO,CAAC,yBAAyB;IA6BjC;;OAEG;IACH,OAAO,CAAC,wBAAwB;IA0BhC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAmB7B;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAwBjC;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAS1B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IA+J1B;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IA6FzB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAgD5B;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAc9B;;;;;;OAMG;IACH,OAAO,CAAC,yBAAyB;IAoFjC;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAoC/B;;;;;;;OAOG;IACH,OAAO,CAAC,eAAe;IAoBvB;;;;;;;OAOG;IACH,OAAO,CAAC,0BAA0B;IA8ElC;;;;;OAKG;IACH,OAAO,CAAC,0BAA0B;IAqBlC;;OAEG;IACH,OAAO,CAAC,eAAe;IAuBvB;;OAEG;IACH,QAAQ;;;;IAWR;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IA2CzB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAkExB;;OAEG;IACH,OAAO,CAAC,2BAA2B;CAgDpC"}