@zintrust/d1-migrator 0.4.0

package/dist/schema/Validator.js

@@ -0,0 +1,225 @@
+/**
+ * Schema Validator
+ * Validates schemas and provides detailed error reporting
+ */
+/**
+ * SchemaValidator - Sealed namespace for schema validation
+ * Provides comprehensive schema validation utilities
+ */
+export const SchemaValidator = Object.freeze({
+    /**
+     * Validate complete schema
+     */
+    validateSchema(tables) {
+        const errors = [];
+        const warnings = [];
+        tables.forEach((table, index) => {
+            const tableValidation = SchemaValidator.validateTable(table);
+            errors.push(...tableValidation.errors.map((error) => `Table ${index + 1} (${table.name}): ${error}`));
+            warnings.push(...tableValidation.warnings.map((warning) => `Table ${index + 1} (${table.name}): ${warning}`));
+        });
+        // Check for duplicate table names
+        const tableNames = tables.map((t) => t.name.toLowerCase());
+        const duplicates = tableNames.filter((name, index) => tableNames.indexOf(name) !== index);
+        if (duplicates.length > 0) {
+            errors.push(`Duplicate table names: ${[...new Set(duplicates)].join(', ')}`);
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    },
+    /**
+     * Validate single table
+     */
+    validateTable(table) {
+        const errors = [];
+        const warnings = [];
+        // Validate table name
+        if (!table.name || table.name.trim() === '') {
+            errors.push('Table name is required');
+        }
+        else if (!/^\w*$/.test(table.name)) {
+            errors.push(`Invalid table name: ${table.name}. Must start with letter or underscore and contain only letters, numbers, and underscores`);
+        }
+        else if (table.name.length > 64) {
+            errors.push(`Table name too long: ${table.name}. Maximum 64 characters`);
+        }
+        // Validate columns
+        if (!table.columns || table.columns.length === 0) {
+            errors.push('Table must have at least one column');
+        }
+        else {
+            const columnNames = table.columns.map((c) => c.name.toLowerCase());
+            const duplicateColumns = columnNames.filter((name, index) => columnNames.indexOf(name) !== index);
+            if (duplicateColumns.length > 0) {
+                errors.push(`Duplicate column names: ${[...new Set(duplicateColumns)].join(', ')}`);
+            }
+            table.columns.forEach((column, colIndex) => {
+                const columnValidation = SchemaValidator.validateColumn(column);
+                errors.push(...columnValidation.errors.map((error) => `Column ${colIndex + 1} (${column.name}): ${error}`));
+                warnings.push(...columnValidation.warnings.map((warning) => `Column ${colIndex + 1} (${column.name}): ${warning}`));
+            });
+        }
+        // Validate primary key
+        if (table.primaryKey) {
+            const hasPrimaryKeyColumn = table.columns.some((column) => column.name === table.primaryKey);
+            if (!hasPrimaryKeyColumn) {
+                errors.push(`Primary key column '${table.primaryKey}' not found in table definition`);
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    },
+    /**
+     * Validate single column
+     */
+    validateColumn(column) {
+        const errors = [];
+        const warnings = [];
+        // Validate column name
+        if (!column.name || column.name.trim() === '') {
+            errors.push('Column name is required');
+        }
+        else if (!/^\w*$/.test(column.name)) {
+            errors.push(`Invalid column name: ${column.name}. Must start with letter or underscore and contain only letters, numbers, and underscores`);
+        }
+        else if (column.name.length > 64) {
+            errors.push(`Column name too long: ${column.name}. Maximum 64 characters`);
+        }
+        // Validate column type
+        if (!column.type || column.type.trim() === '') {
+            errors.push('Column type is required');
+        }
+        else {
+            const validTypes = [
+                'integer',
+                'text',
+                'real',
+                'numeric',
+                'blob',
+                'varchar',
+                'char',
+                'date',
+                'datetime',
+                'boolean',
+            ];
+            const normalizedType = column.type.toLowerCase();
+            if (!validTypes.includes(normalizedType)) {
+                warnings.push(`Potentially unsupported column type: ${column.type}. SQLite/D1 may not fully support this type`);
+            }
+        }
+        // Validate nullable
+        if (column.nullable !== undefined && typeof column.nullable !== 'boolean') {
+            errors.push('Nullable property must be a boolean');
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    },
+    /**
+     * Check for schema compatibility issues
+     */
+    checkCompatibility(issues) {
+        const blocking = [];
+        const warnings = [];
+        const { sourceDriver, tables } = issues;
+        tables.forEach((table) => {
+            table.columns.forEach((column) => {
+                const type = column.type.toLowerCase();
+                const compatibilityWarning = SchemaValidator.checkColumnTypeCompatibility(type, sourceDriver, table.name, column.name);
+                if (compatibilityWarning) {
+                    warnings.push(compatibilityWarning);
+                }
+            });
+        });
+        return { blocking, warnings };
+    },
+    /**
+     * Check column type compatibility for specific driver
+     */
+    checkColumnTypeCompatibility(type, sourceDriver, tableName, columnName) {
+        switch (sourceDriver) {
+            case 'mysql':
+                return SchemaValidator.checkMySQLCompatibility(type, tableName, columnName);
+            case 'postgresql':
+                return SchemaValidator.checkPostgreSQLCompatibility(type, tableName, columnName);
+            case 'sqlserver':
+                return SchemaValidator.checkSQLServerCompatibility(type, tableName, columnName);
+            default:
+                return SchemaValidator.checkGeneralCompatibility(type, tableName, columnName);
+        }
+    },
+    /**
+     * Check MySQL-specific compatibility
+     */
+    checkMySQLCompatibility(type, tableName, columnName) {
+        if (type.includes('enum') || type.includes('set')) {
+            return `MySQL ENUM/SET types will be converted to TEXT in table: ${tableName}.${columnName}`;
+        }
+        if (type.includes('json')) {
+            return `MySQL JSON types will be converted to TEXT in table: ${tableName}.${columnName}`;
+        }
+        return null;
+    },
+    /**
+     * Check PostgreSQL-specific compatibility
+     */
+    checkPostgreSQLCompatibility(type, tableName, columnName) {
+        if (type.includes('uuid')) {
+            return `PostgreSQL UUID will be converted to TEXT in table: ${tableName}.${columnName}`;
+        }
+        if (type.includes('jsonb')) {
+            return `PostgreSQL JSONB will be converted to TEXT in table: ${tableName}.${columnName}`;
+        }
+        return null;
+    },
+    /**
+     * Check SQL Server-specific compatibility
+     */
+    checkSQLServerCompatibility(type, tableName, columnName) {
+        if (type.includes('uniqueidentifier')) {
+            return `SQL Server UNIQUEIDENTIFIER will be converted to TEXT in table: ${tableName}.${columnName}`;
+        }
+        if (type.includes('varbinary') || type.includes('image')) {
+            return `SQL Server binary types will be converted to BLOB in table: ${tableName}.${columnName}`;
+        }
+        return null;
+    },
+    /**
+     * Check general compatibility issues
+     */
+    checkGeneralCompatibility(type, tableName, columnName) {
+        if (type.includes('decimal') || type.includes('numeric')) {
+            return `Decimal/numeric types may lose precision when converted to REAL in table: ${tableName}.${columnName}`;
+        }
+        return null;
+    },
+    /**
+     * Generate validation report
+     */
+    generateReport(validation) {
+        let report = '# Schema Validation Report\n\n';
+        report += `## Status: ${validation.valid ? 'VALID' : 'INVALID'}\n\n`;
+        if (validation.errors.length > 0) {
+            report += `## Errors (${validation.errors.length})\n\n`;
+            validation.errors.forEach((error, index) => {
+                report += `${index + 1}. ${error}\n`;
+            });
+            report += '\n';
+        }
+        if (validation.warnings.length > 0) {
+            report += `## Warnings (${validation.warnings.length})\n\n`;
+            validation.warnings.forEach((warning, index) => {
+                report += `${index + 1}. ${warning}\n`;
+            });
+        }
+        return report;
+    },
+});

package/dist/types.d.ts

@@ -0,0 +1,145 @@
+/**
+ * D1 Migrator Types
+ * Type definitions for migration operations
+ */
+export type SourceDatabaseDriver = 'mysql' | 'postgresql' | 'sqlite' | 'sqlserver';
+export interface MigrationConfig {
+    sourceConnection: string;
+    sourceDriver: SourceDatabaseDriver;
+    targetDatabase: string;
+    targetType: 'd1' | 'd1-remote';
+    batchSize?: number;
+    checkpointInterval?: number;
+    dryRun?: boolean;
+    interactive?: boolean;
+    migrationId?: string;
+}
+export interface MigrationState {
+    id: string;
+    status: 'pending' | 'running' | 'paused' | 'completed' | 'failed';
+    startTime: Date;
+    lastCheckpoint?: Date;
+    totalTables: number;
+    completedTables: number;
+    totalRows: number;
+    completedRows: number;
+    errors: MigrationError[];
+    config: MigrationConfig;
+}
+export interface CheckpointData {
+    migrationId: string;
+    table: string;
+    lastProcessedId?: string | number;
+    processedRows: number;
+    totalRows: number;
+    checksum?: string;
+    timestamp: Date;
+    batchIndex: number;
+}
+export interface SchemaAnalysisResult {
+    tables: TableSchema[];
+    dependencies: TableDependency[];
+    conflicts: SchemaConflict[];
+    warnings: SchemaWarning[];
+}
+export interface DatabaseSchema {
+    tables: TableSchema[];
+    relationships: TableRelationship[];
+    constraints: TableConstraint[];
+}
+export interface TableRelationship {
+    sourceTable: string;
+    targetTable: string;
+    sourceColumn: string;
+    targetColumn: string;
+    type: 'one-to-one' | 'one-to-many' | 'many-to-many';
+}
+export interface TableConstraint {
+    table: string;
+    type: 'primary_key' | 'foreign_key' | 'unique' | 'check' | 'not_null';
+    columns: string[];
+    definition?: string;
+}
+export interface TableSchema {
+    primaryKey: string;
+    name: string;
+    columns: ColumnSchema[];
+    indexes: IndexSchema[];
+    foreignKeys: ForeignKeySchema[];
+    primaryKeys: string[];
+    rowCount?: number;
+}
+export interface ColumnSchema {
+    name: string;
+    type: string;
+    nullable: boolean;
+    defaultValue?: unknown;
+    autoIncrement?: boolean;
+    maxLength?: number;
+    precision?: number;
+    scale?: number;
+}
+export interface IndexSchema {
+    name: string;
+    columns: string[];
+    unique: boolean;
+    primary?: boolean;
+}
+export interface ForeignKeySchema {
+    name: string;
+    column: string;
+    referencedTable: string;
+    referencedColumn: string;
+    onDelete?: 'CASCADE' | 'SET NULL' | 'RESTRICT';
+    onUpdate?: 'CASCADE' | 'SET NULL' | 'RESTRICT';
+}
+export interface TableDependency {
+    table: string;
+    dependsOn: string[];
+    level: number;
+}
+export interface SchemaConflict {
+    type: 'unsupported_type' | 'size_limitation' | 'constraint_incompatible';
+    table: string;
+    column?: string;
+    description: string;
+    severity: 'error' | 'warning';
+    suggestion?: string;
+}
+export interface SchemaWarning {
+    type: 'data_loss_risk' | 'performance_impact' | 'manual_review';
+    table: string;
+    description: string;
+    suggestion?: string;
+}
+export interface MigrationProgress {
+    migrationId: string;
+    currentTable: string;
+    table: string;
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+    processedRows: number;
+    totalTables: number;
+    totalRows: number;
+    percentage: number;
+    errors: Record<string, string>;
+    startTime?: Date;
+    endTime?: Date;
+}
+export interface MigrationError {
+    table?: string;
+    batch?: number;
+    error: string;
+    timestamp: Date;
+    retryCount: number;
+    resolved: boolean;
+}
+export interface DataValidationResult {
+    table: string;
+    sourceCount: number;
+    targetCount: number;
+    checksumMatch: boolean;
+    missingRows?: string[];
+    extraRows?: string[];
+    errors: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

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

package/dist/types.js

@@ -0,0 +1,5 @@
+/**
+ * D1 Migrator Types
+ * Type definitions for migration operations
+ */
+export {};

package/dist/utils/CheckpointManager.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Checkpoint Manager
+ * File-based persistent state tracking for resumable operations
+ */
+import type { CheckpointData, MigrationError, MigrationState } from '../types';
+/**
+ * CheckpointManager - Sealed namespace for migration state management
+ * Provides file-based persistent storage for migration progress
+ */
+export declare const CheckpointManager: Readonly<{
+    /**
+     * Initialize migration directory
+     */
+    initDirectory(): Promise<void>;
+    /**
+     * Save migration state to file
+     */
+    saveState(state: MigrationState): Promise<void>;
+    /**
+     * Load migration state from file
+     */
+    loadState(migrationId: string): Promise<MigrationState | null>;
+    /**
+     * Save checkpoint data
+     */
+    saveCheckpoint(checkpoint: CheckpointData): Promise<void>;
+    /**
+     * Load checkpoint data
+     */
+    loadCheckpoint(migrationId: string, table: string): Promise<CheckpointData | null>;
+    /**
+     * Get all checkpoints for a migration
+     */
+    getAllCheckpoints(migrationId: string): Promise<CheckpointData[]>;
+    /**
+     * Clean up migration files
+     */
+    cleanup(migrationId: string): Promise<void>;
+    /**
+     * List all migrations
+     */
+    listMigrations(): Promise<string[]>;
+    /**
+     * Log migration error
+     */
+    logError(migrationId: string, errorData: MigrationError): Promise<void>;
+}>;
+//# sourceMappingURL=CheckpointManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CheckpointManager.d.ts","sourceRoot":"","sources":["../../src/utils/CheckpointManager.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAM/E;;;GAGG;AACH,eAAO,MAAM,iBAAiB;IAC5B;;OAEG;qBACoB,OAAO,CAAC,IAAI,CAAC;IASpC;;OAEG;qBACoB,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAerD;;OAEG;2BAC0B,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;IAoBpE;;OAEG;+BAC8B,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAkB/D;;OAEG;gCAC+B,MAAM,SAAS,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;IAcxF;;OAEG;mCACkC,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAuCvE;;OAEG;yBACwB,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAwBjD;;OAEG;sBACqB,OAAO,CAAC,MAAM,EAAE,CAAC;IAgBzC;;OAEG;0BACyB,MAAM,aAAa,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;EAuB7E,CAAC"}

package/dist/utils/CheckpointManager.js

@@ -0,0 +1,191 @@
+/**
+ * Checkpoint Manager
+ * File-based persistent state tracking for resumable operations
+ */
+import { ErrorFactory, Logger, NodeSingletons } from '@zintrust/core';
+const MIGRATION_DIR = '.zintrust/migration';
+const path = NodeSingletons.path;
+const { fsPromises, mkdir, readFile, rm, writeFile } = NodeSingletons.fs;
+/**
+ * CheckpointManager - Sealed namespace for migration state management
+ * Provides file-based persistent storage for migration progress
+ */
+export const CheckpointManager = Object.freeze({
+    /**
+     * Initialize migration directory
+     */
+    async initDirectory() {
+        try {
+            await mkdir(MIGRATION_DIR, { recursive: true });
+        }
+        catch (initError) {
+            Logger.error('Failed to create migration directory:', initError);
+            throw ErrorFactory.createConfigError('Cannot create migration directory');
+        }
+    },
+    /**
+     * Save migration state to file
+     */
+    async saveState(state) {
+        await CheckpointManager.initDirectory();
+        const filePath = path.join(MIGRATION_DIR, `migration-${state.id}.json`);
+        const content = JSON.stringify(state, null, 2);
+        try {
+            await writeFile(filePath, content, 'utf-8');
+            Logger.info(`Migration state saved: ${filePath}`);
+        }
+        catch (writeError) {
+            Logger.error('Failed to save migration state:', writeError);
+            throw ErrorFactory.createConfigError('Cannot save migration state');
+        }
+    },
+    /**
+     * Load migration state from file
+     */
+    async loadState(migrationId) {
+        const filePath = NodeSingletons.path.join(MIGRATION_DIR, `migration-${migrationId}.json`);
+        try {
+            const content = await readFile(filePath, 'utf-8');
+            const state = JSON.parse(content);
+            // Convert date strings back to Date objects
+            state.startTime = new Date(state.startTime);
+            if (state.lastCheckpoint) {
+                state.lastCheckpoint = new Date(state.lastCheckpoint);
+            }
+            return state;
+        }
+        catch {
+            Logger.warn(`Migration state not found: ${filePath}`);
+            return null;
+        }
+    },
+    /**
+     * Save checkpoint data
+     */
+    async saveCheckpoint(checkpoint) {
+        await CheckpointManager.initDirectory();
+        const filePath = path.join(MIGRATION_DIR, `checkpoint-${checkpoint.migrationId}-${checkpoint.table}.json`);
+        const content = JSON.stringify(checkpoint, null, 2);
+        try {
+            await writeFile(filePath, content, 'utf-8');
+            Logger.debug(`Checkpoint saved: ${filePath}`);
+        }
+        catch (writeError) {
+            Logger.error('Failed to save checkpoint:', writeError);
+            throw ErrorFactory.createConfigError('Cannot save checkpoint');
+        }
+    },
+    /**
+     * Load checkpoint data
+     */
+    async loadCheckpoint(migrationId, table) {
+        const filePath = path.join(MIGRATION_DIR, `checkpoint-${migrationId}-${table}.json`);
+        try {
+            const content = await readFile(filePath, 'utf-8');
+            const checkpoint = JSON.parse(content);
+            checkpoint.timestamp = new Date(checkpoint.timestamp);
+            return checkpoint;
+        }
+        catch {
+            Logger.debug(`Checkpoint not found: ${filePath}`);
+            return null;
+        }
+    },
+    /**
+     * Get all checkpoints for a migration
+     */
+    async getAllCheckpoints(migrationId) {
+        await CheckpointManager.initDirectory();
+        try {
+            const files = await fsPromises.readdir(MIGRATION_DIR);
+            const checkpointFiles = files.filter((file) => file.startsWith(`checkpoint-${migrationId}-`) && file.endsWith('.json'));
+            const checkpoints = [];
+            // Process files in parallel for better performance
+            const checkpointPromises = checkpointFiles.map(async (file) => {
+                try {
+                    const filePath = path.join(MIGRATION_DIR, file);
+                    const content = await readFile(filePath, 'utf-8');
+                    const checkpoint = JSON.parse(content);
+                    checkpoint.timestamp = new Date(checkpoint.timestamp);
+                    return checkpoint;
+                }
+                catch (parseError) {
+                    Logger.warn(`Failed to load checkpoint file ${file}:`, parseError);
+                    return null;
+                }
+            });
+            const results = await Promise.allSettled(checkpointPromises);
+            results.forEach((result) => {
+                if (result.status === 'fulfilled' && result.value !== null) {
+                    checkpoints.push(result.value);
+                }
+            });
+            return checkpoints.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+        }
+        catch (readError) {
+            Logger.error('Failed to list checkpoints:', readError);
+            return [];
+        }
+    },
+    /**
+     * Clean up migration files
+     */
+    async cleanup(migrationId) {
+        try {
+            const files = await fsPromises.readdir(MIGRATION_DIR);
+            const migrationFiles = files.filter((file) => file.includes(migrationId) && file.endsWith('.json'));
+            // Process cleanup in parallel
+            const cleanupPromises = migrationFiles.map(async (file) => {
+                try {
+                    const filePath = path.join(MIGRATION_DIR, file);
+                    await rm(filePath);
+                    Logger.debug(`Cleaned up migration file: ${file}`);
+                }
+                catch (cleanupError) {
+                    Logger.warn(`Failed to cleanup file ${file}:`, cleanupError);
+                }
+            });
+            await Promise.allSettled(cleanupPromises);
+        }
+        catch (readError) {
+            Logger.error('Failed to cleanup migration files:', readError);
+        }
+    },
+    /**
+     * List all migrations
+     */
+    async listMigrations() {
+        try {
+            const files = await fsPromises.readdir(MIGRATION_DIR);
+            const migrationFiles = files.filter((file) => file.startsWith('migration-') && file.endsWith('.json'));
+            return migrationFiles.map((file) => file.replace('migration-', '').replace('.json', ''));
+        }
+        catch (readError) {
+            Logger.error('Failed to list migrations:', readError);
+            return [];
+        }
+    },
+    /**
+     * Log migration error
+     */
+    async logError(migrationId, errorData) {
+        await CheckpointManager.initDirectory();
+        const filePath = path.join(MIGRATION_DIR, `errors-${migrationId}.json`);
+        try {
+            let errors = [];
+            try {
+                const content = await readFile(filePath, 'utf-8');
+                errors = JSON.parse(content);
+            }
+            catch {
+                // File doesn't exist, start with empty array
+            }
+            errors.push(errorData);
+            await writeFile(filePath, JSON.stringify(errors, null, 2), 'utf-8');
+            Logger.error(`Migration error logged: ${errorData.error}`);
+        }
+        catch (writeError) {
+            Logger.error('Failed to log migration error:', writeError);
+        }
+    },
+});

package/dist/utils/DataValidator.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Data Validator
+ * Integrity checks and validation for migrated data
+ */
+import type { DataValidationResult } from '../types';
+/**
+ * DataValidator - Sealed namespace for data integrity validation
+ * Provides comprehensive validation of migrated data
+ */
+export declare const DataValidator: Readonly<{
+    /**
+     * Validate data integrity between source and target
+     */
+    validateDataIntegrity(sourceCount: number, targetCount: number, tableName: string): Promise<boolean>;
+    /**
+     * Generate checksum for data validation
+     */
+    generateChecksum(data: unknown[]): Promise<string>;
+    /**
+     * Validate data checksums
+     */
+    validateChecksum(sourceData: unknown[], targetData: unknown[], tableName: string): Promise<boolean>;
+    /**
+     * Comprehensive data validation
+     */
+    validateTable(sourceData: unknown[], targetData: unknown[], tableName: string): Promise<DataValidationResult>;
+    /**
+     * Validate schema compatibility
+     */
+    validateSchemaCompatibility(sourceSchema: unknown, targetSchema: unknown, tableName: string): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Sanitize table name for D1 compatibility
+     */
+    sanitizeTableName(tableName: string): string;
+    /**
+     * Validate column type conversion
+     */
+    validateColumnType(sourceType: string, targetType: string, tableName: string, columnName: string): {
+        valid: boolean;
+        warning?: string;
+    };
+}>;
+//# sourceMappingURL=DataValidator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DataValidator.d.ts","sourceRoot":"","sources":["../../src/utils/DataValidator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAErD;;;GAGG;AACH,eAAO,MAAM,aAAa;IACxB;;OAEG;uCAEY,MAAM,eACN,MAAM,aACR,MAAM,GAChB,OAAO,CAAC,OAAO,CAAC;IAcnB;;OAEG;2BAC0B,OAAO,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAMxD;;OAEG;iCAEW,OAAO,EAAE,cACT,OAAO,EAAE,aACV,MAAM,GAChB,OAAO,CAAC,OAAO,CAAC;IAiBnB;;OAEG;8BAEW,OAAO,EAAE,cACT,OAAO,EAAE,aACV,MAAM,GAChB,OAAO,CAAC,oBAAoB,CAAC;IAsChC;;OAEG;8CAEa,OAAO,gBACP,OAAO,aACV,MAAM,GAChB;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE;IAsBvC;;OAEG;iCAC0B,MAAM,GAAG,MAAM;IAe5C;;OAEG;mCAEW,MAAM,cACN,MAAM,aACP,MAAM,cACL,MAAM,GACjB;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE;EA2BvC,CAAC"}