@zintrust/core 0.1.0

package/src/cli/scaffolding/FileGenerator.d.ts

@@ -0,0 +1,31 @@
+/**
+ * File Generator
+ * Handles creation of files and directories
+ * Sealed namespace with file I/O operations
+ */
+export interface FileCreationOptions {
+    overwrite?: boolean;
+    createDirs?: boolean;
+    encoding?: BufferEncoding;
+}
+/**
+ * FileGenerator namespace - sealed for immutability
+ */
+export declare const FileGenerator: Readonly<{
+    createDirectory: (dirPath: string) => boolean;
+    createDirectories: (directories: string[], baseDir: string) => void;
+    writeFile: (filePath: string, content: string, options?: FileCreationOptions) => boolean;
+    writeFiles: (files: Array<{
+        path: string;
+        content: string;
+    }>, baseDir: string, options?: FileCreationOptions) => number;
+    readFile: (filePath: string, encoding?: BufferEncoding) => string;
+    fileExists: (filePath: string) => boolean;
+    directoryExists: (dirPath: string) => boolean;
+    deleteFile: (filePath: string) => boolean;
+    deleteDirectory: (dirPath: string) => boolean;
+    listFiles: (dirPath: string, recursive?: boolean) => string[];
+    copyFile: (source: string, destination: string, options?: FileCreationOptions) => boolean;
+    getDirectorySize: (dirPath: string) => number;
+}>;
+//# sourceMappingURL=FileGenerator.d.ts.map

package/src/cli/scaffolding/FileGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileGenerator.d.ts","sourceRoot":"","sources":["../../../../src/cli/scaffolding/FileGenerator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH,MAAM,WAAW,mBAAmB;IAClC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAsOD;;GAEG;AACH,eAAO,MAAM,aAAa;+BApOQ,MAAM,KAAG,OAAO;qCAgBV,MAAM,EAAE,WAAW,MAAM,KAAG,IAAI;0BAW5D,MAAM,WACP,MAAM,YACN,mBAAmB,KAC3B,OAAO;wBA8BD,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,WACtC,MAAM,YACL,mBAAmB,KAC5B,MAAM;yBAgBmB,MAAM,aAAY,cAAc,KAAa,MAAM;2BAWjD,MAAM,KAAG,OAAO;+BAOZ,MAAM,KAAG,OAAO;2BAOpB,MAAM,KAAG,OAAO;+BAgBZ,MAAM,KAAG,OAAO;yBAgBtB,MAAM,0BAAsB,MAAM,EAAE;uBAiCtD,MAAM,eACD,MAAM,YACV,mBAAmB,KAC3B,OAAO;gCAwByB,MAAM,KAAG,MAAM;EA6ChD,CAAC"}

package/src/cli/scaffolding/FileGenerator.js

@@ -0,0 +1,222 @@
+/**
+ * File Generator
+ * Handles creation of files and directories
+ * Sealed namespace with file I/O operations
+ */
+import { Logger } from '../../config/logger';
+import { ErrorFactory } from '../../exceptions/ZintrustError';
+import fs from '../../node-singletons/fs';
+import * as path from 'node:path';
+/**
+ * Create a directory recursively
+ */
+const createDirectory = (dirPath) => {
+    try {
+        if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, { recursive: true });
+            Logger.info(`Created directory: ${dirPath}`);
+            return true;
+        }
+        return false;
+    }
+    catch (error) {
+        throw ErrorFactory.createCliError(`Failed to create directory ${dirPath}:`, error);
+    }
+};
+/**
+ * Create multiple directories
+ */
+const createDirectories = (directories, baseDir) => {
+    for (const dir of directories) {
+        const fullPath = path.join(baseDir, dir);
+        createDirectory(fullPath);
+    }
+};
+/**
+ * Write file content
+ */
+const writeFile = (filePath, content, options = {}) => {
+    const { overwrite = false, createDirs = true, encoding = 'utf-8' } = options;
+    try {
+        const dir = path.dirname(filePath);
+        // Create parent directories if needed
+        if (createDirs && !fs.existsSync(dir)) {
+            createDirectory(dir);
+        }
+        // Check if file exists
+        if (fs.existsSync(filePath) && !overwrite) {
+            Logger.warn(`File already exists (skipped): ${filePath}`);
+            return false;
+        }
+        // Write file
+        fs.writeFileSync(filePath, content, { encoding });
+        Logger.info(`Created file: ${filePath}`);
+        return true;
+    }
+    catch (error) {
+        throw ErrorFactory.createCliError(`Failed to write file ${filePath}:`, error);
+    }
+};
+/**
+ * Write multiple files
+ */
+const writeFiles = (files, baseDir, options) => {
+    let count = 0;
+    for (const file of files) {
+        const fullPath = path.join(baseDir, file.path);
+        if (writeFile(fullPath, file.content, options)) {
+            count++;
+        }
+    }
+    return count;
+};
+/**
+ * Read file content
+ */
+const readFile = (filePath, encoding = 'utf-8') => {
+    try {
+        return fs.readFileSync(filePath, { encoding });
+    }
+    catch (error) {
+        throw ErrorFactory.createCliError(`Failed to read file ${filePath}:`, error);
+    }
+};
+/**
+ * Check if file exists
+ */
+const fileExists = (filePath) => {
+    return fs.existsSync(filePath) && fs.statSync(filePath).isFile();
+};
+/**
+ * Check if directory exists
+ */
+const directoryExists = (dirPath) => {
+    return fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory();
+};
+/**
+ * Delete file
+ */
+const deleteFile = (filePath) => {
+    try {
+        if (fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+            Logger.info(`Deleted file: ${filePath}`);
+            return true;
+        }
+        return false;
+    }
+    catch (error) {
+        throw ErrorFactory.createCliError(`Failed to delete file ${filePath}:`, error);
+    }
+};
+/**
+ * Delete directory recursively
+ */
+const deleteDirectory = (dirPath) => {
+    try {
+        if (fs.existsSync(dirPath)) {
+            fs.rmSync(dirPath, { recursive: true, force: true });
+            Logger.info(`Deleted directory: ${dirPath}`);
+            return true;
+        }
+        return false;
+    }
+    catch (error) {
+        throw ErrorFactory.createCliError(`Failed to delete directory ${dirPath}:`, error);
+    }
+};
+/**
+ * List files in directory
+ */
+const listFiles = (dirPath, recursive = false) => {
+    try {
+        if (!fs.existsSync(dirPath))
+            return [];
+        const files = [];
+        const traverse = (dir) => {
+            const entries = fs.readdirSync(dir);
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry);
+                const stat = fs.statSync(fullPath);
+                if (stat.isFile()) {
+                    files.push(fullPath);
+                }
+                else if (stat.isDirectory() && recursive) {
+                    traverse(fullPath);
+                }
+            }
+        };
+        traverse(dirPath);
+        return files;
+    }
+    catch (error) {
+        ErrorFactory.createCliError(`Failed to list files in ${dirPath}:`, error);
+        return [];
+    }
+};
+/**
+ * Copy file
+ */
+const copyFile = (source, destination, options = {}) => {
+    try {
+        const { createDirs = true } = options;
+        if (!fs.existsSync(source)) {
+            ErrorFactory.createCliError(`Source file not found: ${source}`, { source });
+        }
+        const dir = path.dirname(destination);
+        if (createDirs && !fs.existsSync(dir)) {
+            createDirectory(dir);
+        }
+        fs.copyFileSync(source, destination);
+        Logger.info(`Copied file: ${source} → ${destination}`);
+        return true;
+    }
+    catch (error) {
+        throw ErrorFactory.createCliError(`Failed to copy file ${source}:`, error);
+    }
+};
+/**
+ * Get directory size in bytes
+ */
+const getDirectorySize = (dirPath) => {
+    let size = 0;
+    try {
+        if (!fs.existsSync(dirPath))
+            return 0;
+        const traverse = (dir) => {
+            const entries = fs.readdirSync(dir);
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry);
+                const stat = fs.statSync(fullPath);
+                if (stat.isFile()) {
+                    size += stat.size;
+                }
+                else if (stat.isDirectory()) {
+                    traverse(fullPath);
+                }
+            }
+        };
+        traverse(dirPath);
+    }
+    catch (error) {
+        throw ErrorFactory.createCliError(`Failed to calculate directory size for ${dirPath}:`, error);
+    }
+    return size;
+};
+/**
+ * FileGenerator namespace - sealed for immutability
+ */
+export const FileGenerator = Object.freeze({
+    createDirectory,
+    createDirectories,
+    writeFile,
+    writeFiles,
+    readFile,
+    fileExists,
+    directoryExists,
+    deleteFile,
+    deleteDirectory,
+    listFiles,
+    copyFile,
+    getDirectorySize,
+});

package/src/cli/scaffolding/MigrationGenerator.d.ts

@@ -0,0 +1,35 @@
+/**
+ * MigrationGenerator - Generate database migrations
+ * Creates migration files for schema changes
+ */
+export type MigrationType = 'create' | 'alter' | 'drop';
+export interface MigrationOptions {
+    name: string;
+    migrationsPath: string;
+    type?: MigrationType;
+}
+export interface MigrationScaffoldResult {
+    success: boolean;
+    migrationName: string;
+    filePath: string;
+    message: string;
+}
+/**
+ * Validate migration options
+ */
+export declare function validateOptions(options: MigrationOptions): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Generate migration file
+ */
+export declare function generateMigration(options: MigrationOptions): Promise<MigrationScaffoldResult>;
+/**
+ * MigrationGenerator creates database migration files
+ */
+export declare const MigrationGenerator: Readonly<{
+    validateOptions: typeof validateOptions;
+    generateMigration: typeof generateMigration;
+}>;
+//# sourceMappingURL=MigrationGenerator.d.ts.map

package/src/cli/scaffolding/MigrationGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MigrationGenerator.d.ts","sourceRoot":"","sources":["../../../../src/cli/scaffolding/MigrationGenerator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,CAAC;AAExD,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,CAAC,EAAE,aAAa,CAAC;CACtB;AAED,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAmB/F;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,uBAAuB,CAAC,CAwDlC;AAqLD;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;EAG7B,CAAC"}

package/src/cli/scaffolding/MigrationGenerator.js

@@ -0,0 +1,257 @@
+/**
+ * MigrationGenerator - Generate database migrations
+ * Creates migration files for schema changes
+ */
+import { FileGenerator } from '../scaffolding/FileGenerator';
+import { CommonUtils } from '../../common/index';
+import { Logger } from '../../config/logger';
+import * as path from '../../node-singletons/path';
+/**
+ * Validate migration options
+ */
+export function validateOptions(options) {
+    const errors = [];
+    if (options.name.trim().length === 0) {
+        errors.push('Migration name is required');
+    }
+    if (!/^[a-z_]+$/.test(options.name)) {
+        errors.push('Migration name must contain only lowercase letters and underscores');
+    }
+    if (options.migrationsPath === '' || !FileGenerator.directoryExists(options.migrationsPath)) {
+        errors.push(`Migrations directory does not exist: ${options.migrationsPath}`);
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Generate migration file
+ */
+export async function generateMigration(options) {
+    try {
+        // Validate options
+        const validation = validateOptions(options);
+        if (!validation.valid) {
+            return {
+                success: false,
+                migrationName: options.name,
+                filePath: '',
+                message: `Validation failed: ${validation.errors.join(', ')}`,
+            };
+        }
+        // Generate migration filename with timestamp
+        const timestamp = new Date()
+            .toISOString()
+            .replaceAll(/[-:T.Z]/g, '')
+            .slice(0, 14);
+        const filename = `${timestamp}_${options.name}.ts`;
+        const filePath = path.join(options.migrationsPath, filename);
+        // Check if migration already exists
+        if (FileGenerator.fileExists(filePath)) {
+            return {
+                success: false,
+                migrationName: options.name,
+                filePath,
+                message: `Migration file already exists: ${filePath}`,
+            };
+        }
+        // Generate migration content based on type
+        const type = options.type ?? detectType(options.name);
+        const content = generateMigrationContent(options.name, type);
+        // Write migration file
+        FileGenerator.writeFile(filePath, content);
+        Logger.info(`✅ Created migration: ${filename}`);
+        return {
+            success: true,
+            migrationName: options.name,
+            filePath,
+            message: `Migration '${options.name}' created successfully`,
+        };
+    }
+    catch (error) {
+        Logger.error('Migration generation error:', error);
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        return {
+            success: false,
+            migrationName: options.name,
+            filePath: '',
+            message: `Failed to create migration: ${errorMsg}`,
+        };
+    }
+}
+/**
+ * Detect migration type from name
+ */
+function detectType(name) {
+    if (name.startsWith('create_'))
+        return 'create';
+    if (name.startsWith('drop_'))
+        return 'drop';
+    return 'alter';
+}
+/**
+ * Generate migration file content
+ */
+function generateMigrationContent(name, type) {
+    const className = CommonUtils.toPascalCase(name);
+    if (type === 'create') {
+        return generateCreateMigration(className);
+    }
+    else if (type === 'drop') {
+        return generateDropMigration(className);
+    }
+    else {
+        return generateAlterMigration(className);
+    }
+}
+/**
+ * Generate CREATE migration
+ */
+function generateCreateMigration(className) {
+    const tableName = getTableNameFromClass(className);
+    return `/**
+ * Migration: ${className}
+ * Creates ${tableName} table
+ */
+
+export interface Migration {
+  up(): Promise<void>;
+  down(): Promise<void>;
+}
+
+export const migration: Migration = {
+  /**
+   * Run migration
+   */
+  async up(): Promise<void> {
+    // Create table
+    // await db.schema.createTable('${tableName}', (table) => {
+    //   table.increments('id').primary();
+    //   table.string('name').notNullable();
+    //   table.string('email').unique();
+    //   table.timestamps();
+    // });
+  },
+
+  /**
+   * Rollback migration
+   */
+  async down(): Promise<void> {
+    // Drop table
+    // await db.schema.dropTable('${tableName}');
+  },
+};
+`;
+}
+/**
+ * Generate ALTER migration
+ */
+function generateAlterMigration(className) {
+    const tableName = getTableNameFromClass(className);
+    return `/**
+ * Migration: ${className}
+ * Modifies ${tableName} table
+ */
+
+export interface Migration {
+  up(): Promise<void>;
+  down(): Promise<void>;
+}
+
+export const migration: Migration = {
+  /**
+   * Run migration
+   */
+  async up(): Promise<void> {
+    // Add/modify columns
+    // await db.schema.alterTable('${tableName}', (table) => {
+    //   table.string('new_column').nullable();
+    // });
+  },
+
+  /**
+   * Rollback migration
+   */
+  async down(): Promise<void> {
+    // Remove columns
+    // await db.schema.alterTable('${tableName}', (table) => {
+    //   table.dropColumn('new_column');
+    // });
+  },
+};
+`;
+}
+/**
+ * Generate DROP migration
+ */
+function generateDropMigration(className) {
+    const tableName = getTableNameFromClass(className);
+    return `/**
+ * Migration: ${className}
+ * Drops ${tableName} table
+ */
+
+export interface Migration {
+  up(): Promise<void>;
+  down(): Promise<void>;
+}
+
+export const migration: Migration = {
+  /**
+   * Run migration
+   */
+  async up(): Promise<void> {
+    // Drop table
+    // await db.schema.dropTable('${tableName}');
+  },
+
+  /**
+   * Rollback migration
+   */
+  async down(): Promise<void> {
+    // Recreate table
+    // await db.schema.createTable('${tableName}', (table) => {
+    //   table.increments('id').primary();
+    //   table.timestamps();
+    // });
+  },
+};
+`;
+}
+/**
+ * Convert name to table name
+ */
+function getTableNameFromClass(className) {
+    // Remove prefixes
+    let tableName = className
+        .replace(/^Create/, '')
+        .replace(/^Drop/, '')
+        .replace(/^Alter/, '');
+    // Convert PascalCase to snake_case
+    tableName = tableName
+        .replaceAll(/([A-Z])/g, '_$1')
+        .toLowerCase()
+        .replace(/^_/, '');
+    // Remove 'table' suffix if present
+    if (tableName.endsWith('_table')) {
+        tableName = tableName.slice(0, -6); // Remove '_table'
+    }
+    // For ALTER migrations like "add_status_to_orders", extract the table name (last word)
+    if (tableName.includes('_to_')) {
+        const parts = tableName.split('_to_');
+        tableName = parts.at(-1) ?? tableName;
+    }
+    // Make plural if not already
+    if (!tableName.endsWith('s')) {
+        tableName += 's';
+    }
+    return tableName;
+}
+/**
+ * MigrationGenerator creates database migration files
+ */
+export const MigrationGenerator = Object.freeze({
+    validateOptions,
+    generateMigration,
+});

package/src/cli/scaffolding/ModelGenerator.d.ts

@@ -0,0 +1,81 @@
+/**
+ * ModelGenerator - Generate ORM model files
+ * Creates type-safe model modules with relationships and validation
+ */
+export type FieldType = 'string' | 'integer' | 'float' | 'boolean' | 'text' | 'datetime' | 'json' | '';
+export interface ModelField {
+    name: string;
+    type: FieldType;
+    nullable?: boolean;
+    default?: unknown;
+    unique?: boolean;
+    comment?: string;
+}
+export interface ModelRelationship {
+    type: 'hasOne' | 'hasMany' | 'belongsTo';
+    model: string;
+    foreignKey?: string;
+    localKey?: string;
+}
+export interface ModelOptions {
+    name: string;
+    modelPath: string;
+    table?: string;
+    fields?: ModelField[];
+    relationships?: ModelRelationship[];
+    timestamps?: boolean;
+    fillable?: string[];
+    hidden?: string[];
+    softDelete?: boolean;
+    withMigration?: boolean;
+    withFactory?: boolean;
+    withController?: boolean;
+}
+export interface ModelGeneratorResult {
+    success: boolean;
+    modelName: string;
+    modelFile: string;
+    migrationFile?: string;
+    factoryFile?: string;
+    controllerFile?: string;
+    message: string;
+}
+/**
+ * Validate model options
+ */
+export declare function validateOptions(options: ModelOptions): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Generate model file
+ */
+export declare function generateModel(options: ModelOptions): Promise<ModelGeneratorResult>;
+/**
+ * Get common field types
+ */
+export declare function getCommonFieldTypes(): FieldType[];
+/**
+ * Generate common model fields (User example)
+ */
+export declare function getUserFields(): ModelField[];
+/**
+ * Generate common model fields (Post example)
+ */
+export declare function getPostFields(): ModelField[];
+/**
+ * Generate common model fields (Order example)
+ */
+export declare function getOrderFields(): ModelField[];
+/**
+ * ModelGenerator creates type-safe ORM models
+ */
+export declare const ModelGenerator: Readonly<{
+    validateOptions: typeof validateOptions;
+    generateModel: typeof generateModel;
+    getCommonFieldTypes: typeof getCommonFieldTypes;
+    getUserFields: typeof getUserFields;
+    getPostFields: typeof getPostFields;
+    getOrderFields: typeof getOrderFields;
+}>;
+//# sourceMappingURL=ModelGenerator.d.ts.map

package/src/cli/scaffolding/ModelGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelGenerator.d.ts","sourceRoot":"","sources":["../../../../src/cli/scaffolding/ModelGenerator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,MAAM,MAAM,SAAS,GACjB,QAAQ,GACR,SAAS,GACT,OAAO,GACP,SAAS,GACT,MAAM,GACN,UAAU,GACV,MAAM,GACN,EAAE,CAAC;AAEP,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,SAAS,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,WAAW,CAAC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,UAAU,EAAE,CAAC;IACtB,aAAa,CAAC,EAAE,iBAAiB,EAAE,CAAC;IACpC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAsB3F;AAED;;GAEG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,oBAAoB,CAAC,CA0CxF;AA+HD;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,SAAS,EAAE,CAEjD;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,UAAU,EAAE,CAW5C;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,UAAU,EAAE,CAU5C;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,UAAU,EAAE,CAU7C;AAED;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;EAOzB,CAAC"}