@zintrust/core 0.1.28 → 0.1.30

package/src/cli/config/ConfigValidator.js

@@ -0,0 +1,200 @@
+/**
+ * Configuration Validator
+ * Validates configuration against schema and rules
+ */
+import { CONFIG_RULES, getConfigValue } from '../config/ConfigSchema.js';
+/**
+ * Validate entire config against schema
+ */
+export function validateConfig(config) {
+    const errors = [];
+    // Validate each rule
+    for (const key of Object.keys(CONFIG_RULES)) {
+        const value = getConfigValue(config, key);
+        const error = validateConfigValue(key, value);
+        if (error !== null) {
+            errors.push(error);
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Validate a single config value
+ */
+export function validateConfigValue(key, value) {
+    const rule = CONFIG_RULES[key];
+    if (rule === undefined) {
+        return null; // No rule, allow any value
+    }
+    // Check required
+    const requiredError = checkRequired(key, value, rule);
+    if (requiredError !== null)
+        return requiredError;
+    // Skip validation if not required and value is undefined
+    if (rule.required !== true && value === undefined) {
+        return null;
+    }
+    // Check type
+    const typeError = checkType(key, value, rule);
+    if (typeError !== null)
+        return typeError;
+    // Check enum
+    const enumError = checkEnum(key, value, rule);
+    if (enumError !== null)
+        return enumError;
+    // Check pattern
+    const patternError = checkPattern(key, value, rule);
+    if (patternError !== null)
+        return patternError;
+    // Check string length
+    const stringLengthError = checkStringLength(key, value, rule);
+    if (stringLengthError !== null)
+        return stringLengthError;
+    // Check number range
+    const numberRangeError = checkNumberRange(key, value, rule);
+    if (numberRangeError !== null)
+        return numberRangeError;
+    return null;
+}
+/**
+ * Check if value is required
+ */
+function checkRequired(key, value, rule) {
+    if (rule.required === true && (value === undefined || value === null)) {
+        return {
+            key,
+            value,
+            message: `${key} is required`,
+            rule: 'required',
+        };
+    }
+    return null;
+}
+/**
+ * Check type compatibility
+ */
+function checkType(key, value, rule) {
+    if (rule.type !== undefined && typeof value !== rule.type) {
+        return {
+            key,
+            value,
+            message: `${key} must be of type ${rule.type}, got ${typeof value}`,
+            rule: 'type',
+        };
+    }
+    return null;
+}
+/**
+ * Check enum values
+ */
+function checkEnum(key, value, rule) {
+    if (rule.enum !== undefined) {
+        if (!rule.enum.includes(value)) {
+            return {
+                key,
+                value,
+                message: `${key} must be one of: ${rule.enum.join(', ')}`,
+                rule: 'enum',
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Check string pattern
+ */
+function checkPattern(key, value, rule) {
+    if (rule.pattern !== undefined && typeof value === 'string') {
+        if (!rule.pattern.test(value)) {
+            return {
+                key,
+                value,
+                message: `${key} must match pattern: ${rule.pattern}`,
+                rule: 'pattern',
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Check string length constraints
+ */
+function checkStringLength(key, value, rule) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    if (rule.minLength !== undefined && value.length < rule.minLength) {
+        return {
+            key,
+            value,
+            message: `${key} must be at least ${rule.minLength} characters`,
+            rule: 'minLength',
+        };
+    }
+    if (rule.maxLength !== undefined && value.length > rule.maxLength) {
+        return {
+            key,
+            value,
+            message: `${key} must be at most ${rule.maxLength} characters`,
+            rule: 'maxLength',
+        };
+    }
+    return null;
+}
+/**
+ * Check number range constraints
+ */
+function checkNumberRange(key, value, rule) {
+    if (typeof value !== 'number') {
+        return null;
+    }
+    if (rule.min !== undefined && value < rule.min) {
+        return {
+            key,
+            value,
+            message: `${key} must be at least ${rule.min}`,
+            rule: 'min',
+        };
+    }
+    if (rule.max !== undefined && value > rule.max) {
+        return {
+            key,
+            value,
+            message: `${key} must be at most ${rule.max}`,
+            rule: 'max',
+        };
+    }
+    return null;
+}
+/**
+ * Format validation errors for display
+ */
+export function formatValidationErrors(result) {
+    if (result.valid) {
+        return 'Configuration is valid';
+    }
+    const lines = ['Configuration validation failed:'];
+    for (const error of result.errors) {
+        lines.push(`  ❌ ${error.key}: ${error.message}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Get validation rule description
+ */
+export function getConfigDescription(key) {
+    const rule = CONFIG_RULES[key];
+    return rule?.description;
+}
+/**
+ * ConfigValidator namespace - sealed for immutability
+ */
+export const ConfigValidator = Object.freeze({
+    validate: validateConfig,
+    validateValue: validateConfigValue,
+    formatErrors: formatValidationErrors,
+    getDescription: getConfigDescription,
+});

package/src/cli/config/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Configuration Module
+ * Exports config management classes
+ */
+export { ConfigManager } from '../config/ConfigManager';
+export { AuthConfig, CONFIG_RULES, ConfigPaths, DEFAULT_CONFIG, DatabaseConfig, FeatureConfig, MicroservicesConfig, ProjectConfig, ServerConfig, getConfigValue, getDefaultValue, setConfigValue, } from '../config/ConfigSchema';
+export { ConfigValidator, ValidationError, ValidationResult } from '../config/ConfigValidator';
+//# sourceMappingURL=index.d.ts.map

package/src/cli/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cli/config/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EACL,UAAU,EACV,YAAY,EACZ,WAAW,EACX,cAAc,EACd,cAAc,EACd,aAAa,EACb,mBAAmB,EACnB,aAAa,EACb,YAAY,EACZ,cAAc,EACd,eAAe,EACf,cAAc,GACf,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC"}

package/src/cli/config/index.js

@@ -0,0 +1,7 @@
+/**
+ * Configuration Module
+ * Exports config management classes
+ */
+export { ConfigManager } from '../config/ConfigManager.js';
+export { CONFIG_RULES, ConfigPaths, DEFAULT_CONFIG, getConfigValue, getDefaultValue, setConfigValue, } from '../config/ConfigSchema.js';
+export { ConfigValidator } from '../config/ConfigValidator.js';

package/src/cli/d1/D1SqlMigrations.d.ts

@@ -0,0 +1,20 @@
+type D1SqlMigrationsCompileOptions = {
+    projectRoot: string;
+    globalDir: string;
+    extension: string;
+    service?: string;
+    includeGlobal?: boolean;
+    serviceDirOverride?: string;
+    outputDir: string;
+};
+type GeneratedSqlMigration = {
+    sourceName: string;
+    outputFileName: string;
+    outputFilePath: string;
+    statements: string[];
+};
+export declare const D1SqlMigrations: Readonly<{
+    compileAndWrite(opts: D1SqlMigrationsCompileOptions): Promise<GeneratedSqlMigration[]>;
+}>;
+export {};
+//# sourceMappingURL=D1SqlMigrations.d.ts.map

package/src/cli/d1/D1SqlMigrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"D1SqlMigrations.d.ts","sourceRoot":"","sources":["../../../../src/cli/d1/D1SqlMigrations.ts"],"names":[],"mappings":"AAYA,KAAK,6BAA6B,GAAG;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,KAAK,qBAAqB,GAAG;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAiOF,eAAO,MAAM,eAAe;0BACE,6BAA6B,GAAG,OAAO,CAAC,qBAAqB,EAAE,CAAC;EAmC5F,CAAC"}

package/src/cli/d1/D1SqlMigrations.js

@@ -0,0 +1,230 @@
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import * as fs from '../../node-singletons/fs.js';
+import * as path from '../../node-singletons/path.js';
+import { AdaptersEnum } from '../../migrations/enum/index.js';
+import { MigrationDiscovery } from '../../migrations/MigrationDiscovery.js';
+import { MigrationLoader } from '../../migrations/MigrationLoader.js';
+import { BaseAdapter } from '../../orm/DatabaseAdapter.js';
+const RESOLVED_VOID = Promise.resolve();
+const ensureDir = (dir) => {
+    if (fs.existsSync(dir))
+        return;
+    fs.mkdirSync(dir, { recursive: true });
+};
+const getDefaultOutputFileName = (migrationName, index) => {
+    const m = /^(\d+)_(.+)$/.exec(migrationName);
+    if (m !== null) {
+        return `${m[1]}_${m[2]}.sql`;
+    }
+    const padded = String(index).padStart(4, '0');
+    return `${padded}_${migrationName}.sql`;
+};
+const normalizeSql = (sql) => {
+    const trimmed = sql.trim();
+    if (trimmed === '')
+        return '';
+    return trimmed.endsWith(';') ? trimmed : `${trimmed};`;
+};
+const interpolateSql = (sql, parameters) => {
+    const placeholders = (sql.match(/\?/g) ?? []).length;
+    if (placeholders !== parameters.length) {
+        throw ErrorFactory.createValidationError(`Cannot compile parameterized SQL: expected ${placeholders} params but got ${parameters.length}. SQL: ${sql}`);
+    }
+    let idx = 0;
+    return sql.replaceAll('?', () => {
+        const value = parameters[idx];
+        idx += 1;
+        return BaseAdapter.sanitize(value);
+    });
+};
+const isMutatingSql = (sql) => {
+    const s = sql.trimStart().toLowerCase();
+    return (s.startsWith('insert') ||
+        s.startsWith('update') ||
+        s.startsWith('delete') ||
+        s.startsWith('create') ||
+        s.startsWith('drop') ||
+        s.startsWith('alter') ||
+        s.startsWith('replace') ||
+        s.startsWith('pragma'));
+};
+const createNoopAdapter = (isConnected, setConnected) => ({
+    async connect() {
+        setConnected(true);
+        await RESOLVED_VOID;
+    },
+    async disconnect() {
+        setConnected(false);
+        await RESOLVED_VOID;
+    },
+    async query() {
+        await RESOLVED_VOID;
+        return { rows: [], rowCount: 0 };
+    },
+    async queryOne() {
+        await RESOLVED_VOID;
+        return null;
+    },
+    async ping() {
+        await RESOLVED_VOID;
+    },
+    async transaction(callback) {
+        await RESOLVED_VOID;
+        return callback(this);
+    },
+    async rawQuery() {
+        await RESOLVED_VOID;
+        return [];
+    },
+    getType() {
+        return AdaptersEnum.d1;
+    },
+    isConnected() {
+        return isConnected();
+    },
+    getPlaceholder() {
+        return '?';
+    },
+});
+const captureSql = (onSql, sql, parameters) => {
+    const compiled = parameters.length > 0 ? interpolateSql(sql, parameters) : sql;
+    if (!isMutatingSql(compiled))
+        return;
+    const normalized = normalizeSql(compiled);
+    if (normalized !== '')
+        onSql(normalized);
+};
+const createCaptureDb = (onSql) => {
+    let connected = false;
+    const setConnected = (v) => {
+        connected = v;
+    };
+    const noopAdapter = createNoopAdapter(() => connected, setConnected);
+    const db = {
+        async connect() {
+            connected = true;
+            await RESOLVED_VOID;
+        },
+        async disconnect() {
+            connected = false;
+            await RESOLVED_VOID;
+        },
+        isConnected() {
+            return connected;
+        },
+        async query(sql, parameters = []) {
+            captureSql(onSql, sql, parameters);
+            await RESOLVED_VOID;
+            return [];
+        },
+        async queryOne(sql, parameters = []) {
+            captureSql(onSql, sql, parameters);
+            await RESOLVED_VOID;
+            return null;
+        },
+        async execute(sql, parameters = []) {
+            captureSql(onSql, sql, parameters);
+            await RESOLVED_VOID;
+            return { rows: [], rowCount: 0 };
+        },
+        async transaction(callback) {
+            await RESOLVED_VOID;
+            return callback(this);
+        },
+        table() {
+            throw ErrorFactory.createCliError('D1 SQL compilation does not support QueryBuilder-based migrations yet. Use db.query(...) with explicit SQL.');
+        },
+        onBeforeQuery() {
+            return;
+        },
+        onAfterQuery() {
+            return;
+        },
+        offBeforeQuery() {
+            return;
+        },
+        offAfterQuery() {
+            return;
+        },
+        getAdapterInstance() {
+            return noopAdapter;
+        },
+        getType() {
+            return AdaptersEnum.d1;
+        },
+        getConfig() {
+            return { driver: AdaptersEnum.d1 };
+        },
+        dispose() {
+            // No resources to dispose for capture DB
+        },
+    };
+    return db;
+};
+async function runSerial(items, fn) {
+    let chain = Promise.resolve();
+    let idx = 0;
+    for (const item of items) {
+        const current = idx;
+        chain = chain.then(async () => fn(item, current));
+        idx += 1;
+    }
+    await chain;
+}
+const resolveServiceDir = (opts) => {
+    const service = typeof opts.service === 'string' && opts.service.length > 0 ? opts.service : null;
+    if (service === null)
+        return null;
+    const rel = opts.serviceDirOverride ?? path.join('services', service, 'database/migrations');
+    return MigrationDiscovery.resolveDir(opts.projectRoot, rel);
+};
+const discoverMigrations = async (opts) => {
+    const globalDir = MigrationDiscovery.resolveDir(opts.projectRoot, opts.globalDir);
+    const includeGlobal = opts.includeGlobal !== false;
+    const dirs = [];
+    if (includeGlobal)
+        dirs.push(globalDir);
+    const serviceDir = resolveServiceDir(opts);
+    if (serviceDir !== null)
+        dirs.push(serviceDir);
+    const files = dirs.flatMap((dir) => MigrationDiscovery.listMigrationFiles(dir, opts.extension));
+    const loaded = [];
+    let chain = Promise.resolve();
+    for (const file of files) {
+        chain = chain.then(async () => {
+            loaded.push(await MigrationLoader.load(file));
+        });
+    }
+    await chain;
+    return loaded.sort((a, b) => a.name.localeCompare(b.name));
+};
+export const D1SqlMigrations = Object.freeze({
+    async compileAndWrite(opts) {
+        const migrations = await discoverMigrations(opts);
+        ensureDir(opts.outputDir);
+        const out = [];
+        await runSerial(migrations, async (m, idx) => {
+            const statements = [];
+            const db = createCaptureDb((sql) => statements.push(sql));
+            await db.connect();
+            try {
+                await m.up(db);
+            }
+            finally {
+                await db.disconnect();
+            }
+            const outputFileName = getDefaultOutputFileName(m.name, idx);
+            const outputFilePath = path.join(opts.outputDir, outputFileName);
+            const header = `-- Generated from ${m.name}\n`;
+            const body = statements.length > 0 ? `${statements.join('\n')}\n` : '';
+            fs.writeFileSync(outputFilePath, `${header}${body}`, 'utf8');
+            out.push({
+                sourceName: m.name,
+                outputFileName,
+                outputFilePath,
+                statements,
+            });
+        });
+        return out;
+    },
+});

package/src/cli/d1/WranglerConfig.d.ts

@@ -0,0 +1,4 @@
+export declare const WranglerConfig: Readonly<{
+    getD1MigrationsDir(projectRoot: string, dbName?: string): string;
+}>;
+//# sourceMappingURL=WranglerConfig.d.ts.map

package/src/cli/d1/WranglerConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WranglerConfig.d.ts","sourceRoot":"","sources":["../../../../src/cli/d1/WranglerConfig.ts"],"names":[],"mappings":"AA2HA,eAAO,MAAM,cAAc;oCACO,MAAM,WAAW,MAAM,GAAG,MAAM;EAqBhE,CAAC"}

package/src/cli/d1/WranglerConfig.js

@@ -0,0 +1,122 @@
+import * as fs from '../../node-singletons/fs.js';
+import * as path from '../../node-singletons/path.js';
+const createStripState = () => ({
+    inString: false,
+    escaped: false,
+    inLineComment: false,
+    inBlockComment: false,
+    skipNext: false,
+});
+const consumeSkipNext = (state) => {
+    if (!state.skipNext)
+        return false;
+    state.skipNext = false;
+    return true;
+};
+const handleLineComment = (state, ch, out) => {
+    if (!state.inLineComment)
+        return false;
+    if (ch === '\n') {
+        state.inLineComment = false;
+        out.push(ch);
+    }
+    return true;
+};
+const handleBlockComment = (state, ch, next) => {
+    if (!state.inBlockComment)
+        return false;
+    if (ch === '*' && next === '/') {
+        state.inBlockComment = false;
+        state.skipNext = true;
+    }
+    return true;
+};
+const handleString = (state, ch, out) => {
+    if (!state.inString)
+        return false;
+    out.push(ch);
+    if (state.escaped) {
+        state.escaped = false;
+        return true;
+    }
+    if (ch === '\\') {
+        state.escaped = true;
+        return true;
+    }
+    if (ch === '"') {
+        state.inString = false;
+    }
+    return true;
+};
+const tryStartString = (state, ch, out) => {
+    if (ch !== '"')
+        return false;
+    state.inString = true;
+    out.push(ch);
+    return true;
+};
+const tryStartLineComment = (state, ch, next) => {
+    if (ch !== '/' || next !== '/')
+        return false;
+    state.inLineComment = true;
+    state.skipNext = true;
+    return true;
+};
+const tryStartBlockComment = (state, ch, next) => {
+    if (ch !== '/' || next !== '*')
+        return false;
+    state.inBlockComment = true;
+    state.skipNext = true;
+    return true;
+};
+const processStripChar = (state, ch, next, out) => {
+    if (consumeSkipNext(state))
+        return true;
+    if (handleLineComment(state, ch, out))
+        return true;
+    if (handleBlockComment(state, ch, next))
+        return true;
+    if (handleString(state, ch, out))
+        return true;
+    if (tryStartString(state, ch, out))
+        return true;
+    if (tryStartLineComment(state, ch, next))
+        return true;
+    if (tryStartBlockComment(state, ch, next))
+        return true;
+    return false;
+};
+const stripJsonc = (input) => {
+    const state = createStripState();
+    const out = [];
+    for (let i = 0; i < input.length; i += 1) {
+        const ch = input[i] ?? '';
+        const next = i + 1 < input.length ? (input[i + 1] ?? '') : '';
+        if (processStripChar(state, ch, next, out))
+            continue;
+        out.push(ch);
+    }
+    return out.join('');
+};
+export const WranglerConfig = Object.freeze({
+    getD1MigrationsDir(projectRoot, dbName) {
+        const configPath = path.join(projectRoot, 'wrangler.jsonc');
+        if (!fs.existsSync(configPath))
+            return 'migrations';
+        try {
+            const raw = fs.readFileSync(configPath, 'utf8');
+            const parsed = JSON.parse(stripJsonc(raw));
+            const list = parsed.d1_databases;
+            if (!Array.isArray(list) || list.length === 0)
+                return 'migrations';
+            const match = typeof dbName === 'string'
+                ? list.find((d) => d.database_name === dbName)
+                : (list[0] ?? undefined);
+            const dir = match?.migrations_dir;
+            return typeof dir === 'string' && dir.trim() !== '' ? dir : 'migrations';
+        }
+        catch {
+            return 'migrations';
+        }
+    },
+});

package/src/cli/d1/WranglerD1.d.ts

@@ -0,0 +1,11 @@
+import type { IBaseCommand } from '../BaseCommand';
+type ApplyOptions = {
+    cmd: IBaseCommand;
+    dbName: string;
+    isLocal: boolean;
+};
+export declare const WranglerD1: Readonly<{
+    applyMigrations(opts: ApplyOptions): string;
+}>;
+export {};
+//# sourceMappingURL=WranglerD1.d.ts.map

package/src/cli/d1/WranglerD1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WranglerD1.d.ts","sourceRoot":"","sources":["../../../../src/cli/d1/WranglerD1.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,KAAK,YAAY,GAAG;IAClB,GAAG,EAAE,YAAY,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,UAAU;0BACC,YAAY,GAAG,MAAM;EAc3C,CAAC"}

package/src/cli/d1/WranglerD1.js

@@ -0,0 +1,16 @@
+import { resolveNpmPath } from '../../common/index.js';
+import { appConfig } from '../../config/app.js';
+import { execFileSync } from '../../node-singletons/child-process.js';
+export const WranglerD1 = Object.freeze({
+    applyMigrations(opts) {
+        const args = ['d1', 'migrations', 'apply', opts.dbName, opts.isLocal ? '--local' : '--remote'];
+        const npmPath = resolveNpmPath();
+        opts.cmd.debug(`Executing: npm exec --yes -- wrangler ${args.join(' ')}`);
+        const result = execFileSync(npmPath, ['exec', '--yes', '--', 'wrangler', ...args], {
+            stdio: 'pipe',
+            encoding: 'utf8',
+            env: appConfig.getSafeEnv(),
+        });
+        return result;
+    },
+});

package/src/cli/debug/Dashboard.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Debug Dashboard
+ * Terminal-based real-time monitoring UI
+ */
+export interface DashboardStats {
+    uptime: number;
+    memory: {
+        total: number;
+        free: number;
+        used: number;
+    };
+    requests: {
+        total: number;
+        active: number;
+        avgDuration: number;
+    };
+    queries: {
+        total: number;
+        n1Warnings: number;
+    };
+}
+export interface IDashboard {
+    start(): void;
+    stop(): void;
+    update(newStats: Partial<DashboardStats>): void;
+}
+type DashboardCtor = {
+    new (): IDashboard;
+    (): IDashboard;
+    create(): IDashboard;
+};
+export declare const Dashboard: DashboardCtor;
+export {};
+//# sourceMappingURL=Dashboard.d.ts.map

package/src/cli/debug/Dashboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Dashboard.d.ts","sourceRoot":"","sources":["../../../../src/cli/debug/Dashboard.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE;QACN,KAAK,EAAE,MAAM,CAAC;QACd,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;IACF,QAAQ,EAAE;QACR,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;IACF,OAAO,EAAE;QACP,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;CACH;AAqGD,MAAM,WAAW,UAAU;IACzB,KAAK,IAAI,IAAI,CAAC;IACd,IAAI,IAAI,IAAI,CAAC;IACb,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC;CACjD;AAkFD,KAAK,aAAa,GAAG;IACnB,QAAQ,UAAU,CAAC;IACnB,IAAI,UAAU,CAAC;IACf,MAAM,IAAI,UAAU,CAAC;CACtB,CAAC;AAMF,eAAO,MAAM,SAAS,EAGN,aAAa,CAAC"}