@zintrust/core 0.4.17 → 0.4.19

package/src/cli/CLI.js

@@ -0,0 +1,306 @@
+/**
+ * CLI - Main CLI Class
+ * Orchestrates all CLI commands using Commander
+ */
+import { AddCommand } from './commands/AddCommand.js';
+import { BroadcastWorkCommand } from './commands/BroadcastWorkCommand.js';
+import { BulletproofKeyGenerateCommand } from './commands/BulletproofKeyGenerateCommand.js';
+import { ConfigCommand } from './commands/ConfigCommand.js';
+import { ContainerProxiesCommand } from './commands/ContainerProxiesCommand.js';
+import { ContainerWorkersCommand } from './commands/ContainerWorkersCommand.js';
+import { AddMigrationCommand, CreateCommand, CreateMigrationCommand, } from './commands/CreateCommand.js';
+import { D1LearnCommand } from './commands/D1LearnCommand.js';
+import { D1MigrateCommand } from './commands/D1MigrateCommand.js';
+import { DbSeedCommand } from './commands/DbSeedCommand.js';
+import { DebugCommand } from './commands/DebugCommand.js';
+import { DeployCommand } from './commands/DeployCommand.js';
+import { DeployContainerProxiesCommand } from './commands/DeployContainerProxiesCommand.js';
+import { DeployContainersProxyCommand } from './commands/DeployContainersProxyCommand.js';
+import { DeployContainerWorkersCommand } from './commands/DeployContainerWorkersCommand.js';
+import { DockerCommand } from './commands/DockerCommand.js';
+import { DockerPushCommand } from './commands/DockerPushCommand.js';
+import { DoctorArchitectureCommand } from './commands/DoctorArchitectureCommand.js';
+import { FixCommand } from './commands/FixCommand.js';
+import { InitContainerCommand } from './commands/InitContainerCommand.js';
+import { InitContainersProxyCommand } from './commands/InitContainersProxyCommand.js';
+import { InitEcosystemCommand } from './commands/InitEcosystemCommand.js';
+import { InitProducerCommand } from './commands/InitProducerCommand.js';
+import { InitProxyCommand } from './commands/InitProxyCommand.js';
+import { JwtDevCommand } from './commands/JwtDevCommand.js';
+import { KeyGenerateCommand } from './commands/KeyGenerateCommand.js';
+import { MakeMailTemplateCommand } from './commands/MakeMailTemplateCommand.js';
+import { MakeNotificationTemplateCommand } from './commands/MakeNotificationTemplateCommand.js';
+import { MigrateCommand } from './commands/MigrateCommand.js';
+import { MigrateWorkerCommand } from './commands/MigrateWorkerCommand.js';
+import { MongoDBProxyCommand } from './commands/MongoDBProxyCommand.js';
+import { MySqlProxyCommand } from './commands/MySqlProxyCommand.js';
+import { NewCommand } from './commands/NewCommand.js';
+import { NotificationWorkCommand } from './commands/NotificationWorkCommand.js';
+import { PluginCommand } from './commands/PluginCommand.js';
+import { PostgresProxyCommand } from './commands/PostgresProxyCommand.js';
+import { PrepareCommand } from './commands/PrepareCommand.js';
+import { ProxyCommand } from './commands/ProxyCommand.js';
+import { PublishCommand } from './commands/PublishCommand.js';
+import { PutCommand } from './commands/PutCommand.js';
+import { QACommand } from './commands/QACommand.js';
+import { QueueCommand } from './commands/QueueCommand.js';
+import { QueueRecoveryCommand } from './commands/QueueRecoveryCommand.js';
+import { RedisProxyCommand } from './commands/RedisProxyCommand.js';
+import { ResourceControlCommand } from './commands/ResourceControlCommand.js';
+import { RoutesCommand } from './commands/RoutesCommand.js';
+import { ScheduleListCommand } from './commands/ScheduleListCommand.js';
+import { ScheduleRunCommand } from './commands/ScheduleRunCommand.js';
+import { ScheduleStartCommand } from './commands/ScheduleStartCommand.js';
+import { SecretsCommand } from './commands/SecretsCommand.js';
+import { SimulateCommand } from './commands/SimulateCommand.js';
+import { SmtpProxyCommand } from './commands/SmtpProxyCommand.js';
+import { SqlServerProxyCommand } from './commands/SqlServerProxyCommand.js';
+import { StartCommand } from './commands/StartCommand.js';
+import { TemplatesCommand } from './commands/TemplatesCommand.js';
+import { UpgradeCommand } from './commands/UpgradeCommand.js';
+import { ErrorHandler } from './ErrorHandler.js';
+import { OptionalCliCommandRegistry } from './OptionalCliCommandRegistry.js';
+import { VersionChecker } from './services/VersionChecker.js';
+import { esmDirname } from '../common/index.js';
+import { Logger } from '../config/logger.js';
+import { ErrorFactory } from '../exceptions/ZintrustError.js';
+import { readFileSync } from '../node-singletons/fs.js';
+import { join } from '../node-singletons/path.js';
+import { Command } from 'commander';
+const __dirname = esmDirname(import.meta.url);
+const isCommandProvider = (command) => {
+    return (typeof command === 'object' &&
+        command !== null &&
+        'getCommand' in command &&
+        typeof command.getCommand === 'function');
+};
+const buildCommandRegistry = () => {
+    return [
+        NewCommand.create(),
+        UpgradeCommand.create(),
+        PrepareCommand,
+        InitContainerCommand.create(),
+        InitContainersProxyCommand.create(),
+        InitProxyCommand.create(),
+        InitProducerCommand.create(),
+        InitEcosystemCommand.create(),
+        DoctorArchitectureCommand.create(),
+        AddCommand.create(),
+        CreateCommand.create(),
+        CreateMigrationCommand.create(),
+        AddMigrationCommand.create(),
+        StartCommand.create(),
+        DockerCommand.create(),
+        DockerPushCommand.create(),
+        QueueCommand.create(),
+        QueueRecoveryCommand.create(),
+        ScheduleListCommand.create(),
+        ScheduleRunCommand.create(),
+        ScheduleStartCommand.create(),
+        BroadcastWorkCommand.create(),
+        NotificationWorkCommand.create(),
+        ResourceControlCommand,
+        MigrateWorkerCommand.create(),
+        MigrateCommand.create(),
+        DbSeedCommand.create(),
+        D1LearnCommand.create(),
+        D1MigrateCommand.create(),
+        DebugCommand.create(),
+        SecretsCommand.create(),
+        ConfigCommand.create(),
+        ContainerWorkersCommand.create(),
+        ContainerProxiesCommand.create(),
+        PluginCommand.create(),
+        PublishCommand.create(),
+        PutCommand.create(),
+        DeployCommand.create(),
+        DeployContainersProxyCommand.create(),
+        DeployContainerWorkersCommand.create(),
+        DeployContainerProxiesCommand.create(),
+        QACommand(),
+        FixCommand.create(),
+        KeyGenerateCommand.create(),
+        BulletproofKeyGenerateCommand.create(),
+        SimulateCommand,
+        TemplatesCommand,
+        MakeMailTemplateCommand.create(),
+        MakeNotificationTemplateCommand.create(),
+        RoutesCommand.create(),
+        JwtDevCommand,
+        ProxyCommand.create(),
+        MySqlProxyCommand.create(),
+        PostgresProxyCommand.create(),
+        MongoDBProxyCommand.create(),
+        SqlServerProxyCommand.create(),
+        RedisProxyCommand.create(),
+        SmtpProxyCommand.create(),
+        ...OptionalCliCommandRegistry.list(),
+    ];
+};
+/**
+ * Load version from package.json
+ */
+const loadVersion = () => {
+    try {
+        const packagePath = join(__dirname, '../../package.json');
+        const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
+        return typeof packageJson.version === 'string' ? packageJson.version : '1.0.0';
+    }
+    catch (error) {
+        ErrorFactory.createCliError('Failed to load version from package.json', error);
+        // Use default version if package.json not found
+        return '1.0.0';
+    }
+};
+/**
+ * Setup program metadata
+ */
+const setupProgram = (program, version) => {
+    program
+        .name('zintrust')
+        .description('ZinTrust Framework CLI - Build production-grade TypeScript APIs')
+        .version(version, '-v, --version', 'Output version number')
+        .helpOption('-h, --help', 'Display help for command')
+        .usage('[command] [options]');
+    // Global error handling
+    program.exitOverride();
+};
+/**
+ * Register all available commands
+ */
+const registerCommands = (program) => {
+    const commands = buildCommandRegistry();
+    for (const command of commands) {
+        if (isCommandProvider(command)) {
+            program.addCommand(command.getCommand());
+        }
+        else {
+            program.addCommand(command);
+        }
+    }
+    // Help command
+    program
+        .command('help [command]')
+        .description('Display help for a command')
+        .action((commandName) => {
+        if (commandName) {
+            const cmd = program.commands.find((c) => c.name() === commandName);
+            if (cmd) {
+                cmd.help();
+            }
+            else {
+                Logger.error(`Unknown command: ${commandName}`);
+                program.help();
+            }
+        }
+        else {
+            program.help();
+        }
+    });
+};
+/**
+ * Check if error is a commander error that can be safely ignored
+ */
+const isIgnorableCommanderError = (error) => {
+    if (error instanceof Error &&
+        'code' in error &&
+        typeof error.code === 'string' &&
+        error.code.startsWith('commander.')) {
+        const commanderError = error;
+        return typeof commanderError.exitCode === 'number' && commanderError.exitCode === 0;
+    }
+    return false;
+};
+/**
+ * Get exit code from error
+ */
+const getExitCode = (error) => {
+    if (error instanceof Error &&
+        'exitCode' in error &&
+        typeof error.exitCode === 'number') {
+        return error.exitCode;
+    }
+    return 1;
+};
+/**
+ * Handle CLI execution error
+ */
+const handleExecutionError = (error, version, log = true) => {
+    if (isIgnorableCommanderError(error)) {
+        return;
+    }
+    if (error === version) {
+        return;
+    }
+    const exitCode = getExitCode(error);
+    if (error instanceof Error) {
+        ErrorHandler.handle(error, undefined, log);
+    }
+    // Check for commander-specific errors that need special handling
+    if (error instanceof Error &&
+        'code' in error &&
+        typeof error.code === 'string' &&
+        error.code.startsWith('commander.')) {
+        ErrorFactory.createCliError('CLI execution failed', error);
+        process.exit(exitCode);
+        return;
+    }
+    throw ErrorFactory.createCliError('Unhandled CLI execution error', error);
+};
+/**
+ * Run CLI with arguments
+ */
+const runCLI = async (program, version, args) => {
+    try {
+        // If version is requested, let Commander print it (no banner, fast/clean output).
+        if (args.includes('-v') || args.includes('--version')) {
+            await program.parseAsync(['node', 'zintrust', ...args]);
+            return;
+        }
+        // Always show banner for normal commands
+        ErrorHandler.banner(version);
+        // Run version check in background (non-blocking)
+        VersionChecker.runVersionCheck().catch((error) => {
+            // Version check should never crash the CLI
+            Logger.debug('Version check encountered an error', error);
+        });
+        // Show help if no arguments provided
+        if (args.length === 0) {
+            program.help();
+            return;
+        }
+        // Convert global aliases to subcommand format
+        // e.g., `zin -sim my-app` -> `zin simulate my-app`
+        let processedArgs = args;
+        if (args[0] === '-sim' || args[0] === '--sim') {
+            processedArgs = ['simulate', ...args.slice(1)];
+        }
+        await program.parseAsync(['node', 'zintrust', ...processedArgs]);
+    }
+    catch (error) {
+        // Handle all errors with proper logging and exit logic
+        handleExecutionError(error, version, false);
+    }
+};
+/**
+ * CLI - Main CLI Class
+ * Orchestrates all CLI commands using Commander
+ *
+ * Notes:
+ * - `CLI.create()` is the preferred API (used by current bin scripts/tests).
+ * - `new CLI()` remains supported for backward compatibility with older bin scripts.
+ */
+export const CLI = Object.freeze({
+    create() {
+        const program = new Command();
+        const version = loadVersion();
+        setupProgram(program, version);
+        registerCommands(program);
+        const run = async (args) => runCLI(program, version, args);
+        const getProgram = () => program;
+        return Object.freeze({
+            run,
+            getProgram,
+        });
+    },
+});

package/src/cli/ErrorHandler.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Error Handler - CLI Error Formatting & Exit Codes
+ * Provides consistent error formatting and proper Unix exit codes
+ * Sealed namespace with immutable error handling methods
+ */
+export declare const EXIT_CODES: {
+    readonly SUCCESS: 0;
+    readonly RUNTIME_ERROR: 1;
+    readonly USAGE_ERROR: 2;
+};
+/**
+ * ErrorHandler namespace - sealed for immutability
+ */
+export declare const ErrorHandler: Readonly<{
+    handle: (error: Error | string, exitCode?: number, log?: boolean) => void;
+    usageError: (message: string, command?: string) => void;
+    info: (message: string) => void;
+    success: (message: string) => void;
+    warn: (message: string) => void;
+    debug: (message: string, verbose?: boolean) => void;
+    banner: (version: string) => void;
+}>;
+//# sourceMappingURL=ErrorHandler.d.ts.map

package/src/cli/ErrorHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorHandler.d.ts","sourceRoot":"","sources":["../../../src/cli/ErrorHandler.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,eAAO,MAAM,UAAU;;;;CAIb,CAAC;AAwGX;;GAEG;AACH,eAAO,MAAM,YAAY;oBApGhB,KAAK,GAAG,MAAM,aACX,MAAM,QACX,OAAO,KACX,IAAI;0BAYsB,MAAM,YAAY,MAAM,KAAG,IAAI;oBAY9B,MAAM,KAAG,IAAI;uBA+CV,MAAM,KAAG,IAAI;oBAQb,MAAM,KAAG,IAAI;qBAQf,MAAM,YAAW,OAAO,KAAW,IAAI;sBAvDtC,MAAM,KAAG,IAAI;EAyE3C,CAAC"}

package/src/cli/ErrorHandler.js

@@ -0,0 +1,99 @@
+/**
+ * Error Handler - CLI Error Formatting & Exit Codes
+ * Provides consistent error formatting and proper Unix exit codes
+ * Sealed namespace with immutable error handling methods
+ */
+import { Env } from '../config/env.js';
+import { Logger } from '../config/logger.js';
+import chalk from 'chalk';
+export const EXIT_CODES = {
+    SUCCESS: 0,
+    RUNTIME_ERROR: 1,
+    USAGE_ERROR: 2,
+};
+/**
+ * Format and display error
+ * Exit codes: 0 (success), 1 (runtime error), 2 (usage error)
+ */
+const handleError = (error, exitCode = EXIT_CODES.RUNTIME_ERROR, log = true) => {
+    const message = typeof error === 'string' ? error : error.message;
+    if (log) {
+        Logger.error(message);
+    }
+    process.exit(exitCode);
+};
+/**
+ * Display usage error with help hint
+ */
+const usageError = (message, command) => {
+    const helpText = `Run: zin ${command} --help`;
+    const hint = command !== undefined && command !== '' ? `\n${chalk.gray(helpText)}` : '';
+    Logger.error(`${message}${hint}`);
+    process.exit(EXIT_CODES.USAGE_ERROR);
+};
+/**
+ * Display info message
+ */
+const displayInfo = (message) => {
+    const formatted = `${chalk.blue('[i]')} ${message}`;
+    Logger.info(formatted);
+};
+/**
+ * Display framework banner
+ */
+const displayBanner = (version) => {
+    /* eslint-disable no-console */
+    const framework = 'ZinTrust Framework';
+    const bannerWidth = 46;
+    const env = Env.NODE_ENV ?? 'development';
+    const db = Env.DB_CONNECTION || 'sqlite';
+    const border = chalk.cyanBright;
+    const label = chalk.bold.white;
+    const frameworkValue = chalk.bold.cyanBright;
+    const versionValue = chalk.bold.greenBright;
+    const envValue = chalk.bold.yellowBright;
+    const dbValue = chalk.bold.magentaBright;
+    console.log(border('┌' + '─'.repeat(bannerWidth) + '┐'));
+    console.log(`${border('│')} ${label('Framework: ')}${frameworkValue(framework.padEnd(bannerWidth - 12))} ${border('│')}`);
+    console.log(`${border('│')} ${label('Version:   ')}${versionValue(version.padEnd(bannerWidth - 12))} ${border('│')}`);
+    console.log(`${border('│')} ${label('Env:       ')}${envValue(env.padEnd(bannerWidth - 12))} ${border('│')}`);
+    console.log(`${border('│')} ${label('Database:  ')}${dbValue(db.padEnd(bannerWidth - 12))} ${border('│')}`);
+    console.log(border('└' + '─'.repeat(bannerWidth) + '┘'));
+    console.log();
+    /* eslint-enable no-console */
+};
+/**
+ * Display success message
+ */
+const displaySuccess = (message) => {
+    const formatted = `${chalk.green('[✓]')} ${message}`;
+    Logger.info(formatted);
+};
+/**
+ * Display warning message
+ */
+const displayWarning = (message) => {
+    const formatted = `${chalk.yellow('[!]')} ${message}`;
+    Logger.warn(formatted);
+};
+/**
+ * Display debug message (only if verbose)
+ */
+const displayDebug = (message, verbose = false) => {
+    if (verbose) {
+        const formatted = `${chalk.gray('[DEBUG]')} ${message}`;
+        Logger.debug(formatted);
+    }
+};
+/**
+ * ErrorHandler namespace - sealed for immutability
+ */
+export const ErrorHandler = Object.freeze({
+    handle: handleError,
+    usageError,
+    info: displayInfo,
+    success: displaySuccess,
+    warn: displayWarning,
+    debug: displayDebug,
+    banner: displayBanner,
+});

package/src/cli/OptionalCliCommandRegistry.d.ts

@@ -0,0 +1,12 @@
+import type { Command } from 'commander';
+export type CliCommandProvider = {
+    getCommand: () => Command;
+    name?: string;
+};
+export declare const OptionalCliCommandRegistry: Readonly<{
+    register(id: string, provider: CliCommandProvider): void;
+    get(id: string): CliCommandProvider | undefined;
+    has(id: string): boolean;
+    list(): CliCommandProvider[];
+}>;
+//# sourceMappingURL=OptionalCliCommandRegistry.d.ts.map

package/src/cli/OptionalCliCommandRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OptionalCliCommandRegistry.d.ts","sourceRoot":"","sources":["../../../src/cli/OptionalCliCommandRegistry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,MAAM,MAAM,kBAAkB,GAAG;IAC/B,UAAU,EAAE,MAAM,OAAO,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAiBF,eAAO,MAAM,0BAA0B;iBACxB,MAAM,YAAY,kBAAkB,GAAG,IAAI;YAMhD,MAAM,GAAG,kBAAkB,GAAG,SAAS;YAIvC,MAAM,GAAG,OAAO;YAIhB,kBAAkB,EAAE;EAG5B,CAAC"}

package/src/cli/OptionalCliCommandRegistry.js

@@ -0,0 +1,25 @@
+import { isObject } from '../helper/index.js';
+const globalWithRegistry = globalThis;
+const registry = globalWithRegistry.__zintrust_cli_command_registry__ ??
+    (globalWithRegistry.__zintrust_cli_command_registry__ = new Map());
+const isCliCommandProvider = (value) => {
+    return isObject(value) && typeof value['getCommand'] === 'function';
+};
+const normalizeId = (id) => id.trim();
+export const OptionalCliCommandRegistry = Object.freeze({
+    register(id, provider) {
+        const normalizedId = normalizeId(id);
+        if (normalizedId === '' || !isCliCommandProvider(provider))
+            return;
+        registry.set(normalizedId, provider);
+    },
+    get(id) {
+        return registry.get(normalizeId(id));
+    },
+    has(id) {
+        return registry.has(normalizeId(id));
+    },
+    list() {
+        return Array.from(registry.values());
+    },
+});

package/src/cli/OptionalCliExtensions.d.ts

@@ -0,0 +1,43 @@
+export type OptionalCliExtension = {
+    packageName: string;
+    specifier: string;
+    commands: string[];
+    installCommand: string;
+    localCandidates: string[];
+};
+type OptionalCliExtensionLoadSource = 'project' | 'package' | 'local-fallback' | 'missing';
+export type OptionalCliExtensionStatus = Readonly<{
+    packageName: string;
+    commands: string[];
+    installCommand: string;
+    loaded: boolean;
+    source: OptionalCliExtensionLoadSource;
+}>;
+type OptionalCliExtensionLoadOptions = Readonly<{
+    logFailures?: boolean;
+}>;
+export declare const OptionalCliExtensions: Readonly<{
+    tryImportInstalledExtensions(): Promise<OptionalCliExtensionStatus[]>;
+    loadForArgs(args: string[]): Promise<OptionalCliExtensionStatus[]>;
+    findMissingExtensionForArgs(args: string[], statuses: ReadonlyArray<OptionalCliExtensionStatus>): OptionalCliExtensionStatus | undefined;
+    getMissingExtensionMessage(status: OptionalCliExtensionStatus): string;
+    findRequestedExtension: (args: string[]) => OptionalCliExtension | undefined;
+}>;
+export declare const OptionalCliExtensionsInternal: Readonly<{
+    getProjectCwd: () => string;
+    resolveProjectRoot: () => string;
+    resolveProjectInstalledUrl: (entry: OptionalCliExtension, options?: OptionalCliExtensionLoadOptions) => string | null;
+    shouldLogFailures: (options?: OptionalCliExtensionLoadOptions) => boolean;
+    debugFailure: (message: string, meta: Record<string, unknown>, options?: OptionalCliExtensionLoadOptions) => void;
+    tryImportProjectInstalledPackage: (entry: OptionalCliExtension, options?: OptionalCliExtensionLoadOptions) => Promise<boolean>;
+    tryImportLocalCandidate: (entry: OptionalCliExtension, options?: OptionalCliExtensionLoadOptions) => Promise<boolean>;
+    tryImportPackageSpecifier: (entry: OptionalCliExtension, options?: OptionalCliExtensionLoadOptions) => Promise<boolean>;
+    tryImportExtension: (entry: OptionalCliExtension, options?: OptionalCliExtensionLoadOptions) => Promise<OptionalCliExtensionStatus>;
+    getRequestedCommand: (args: string[]) => string | undefined;
+    findRequestedExtension: (args: string[]) => OptionalCliExtension | undefined;
+    isRootHelpRequest: (args: string[]) => boolean;
+    getProjectLocalCandidates: (entry: OptionalCliExtension) => string[];
+    getLocalCandidates: (entry: OptionalCliExtension) => string[];
+}>;
+export {};
+//# sourceMappingURL=OptionalCliExtensions.d.ts.map

package/src/cli/OptionalCliExtensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OptionalCliExtensions.d.ts","sourceRoot":"","sources":["../../../src/cli/OptionalCliExtensions.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,oBAAoB,GAAG;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,EAAE,CAAC;CAC3B,CAAC;AAEF,KAAK,8BAA8B,GAAG,SAAS,GAAG,SAAS,GAAG,gBAAgB,GAAG,SAAS,CAAC;AAE3F,MAAM,MAAM,0BAA0B,GAAG,QAAQ,CAAC;IAChD,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,8BAA8B,CAAC;CACxC,CAAC,CAAC;AAEH,KAAK,+BAA+B,GAAG,QAAQ,CAAC;IAC9C,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC,CAAC;AAkRH,eAAO,MAAM,qBAAqB;oCACM,OAAO,CAAC,0BAA0B,EAAE,CAAC;sBAQnD,MAAM,EAAE,GAAG,OAAO,CAAC,0BAA0B,EAAE,CAAC;sCAmBhE,MAAM,EAAE,YACJ,aAAa,CAAC,0BAA0B,CAAC,GAClD,0BAA0B,GAAG,SAAS;uCASN,0BAA0B,GAAG,MAAM;mCArDlC,MAAM,EAAE,KAAG,oBAAoB,GAAG,SAAS;EA8D/E,CAAC;AAEH,eAAO,MAAM,6BAA6B;yBA/ThB,MAAM;8BAQD,MAAM;wCAoF5B,oBAAoB,YACjB,+BAA+B,KACxC,MAAM,GAAG,IAAI;kCAhFqB,+BAA+B,KAAG,OAAO;4BAMnE,MAAM,QACT,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,YACnB,+BAA+B,KACxC,IAAI;8CA6FE,oBAAoB,YACjB,+BAA+B,KACxC,OAAO,CAAC,OAAO,CAAC;qCA0BV,oBAAoB,YACjB,+BAA+B,KACxC,OAAO,CAAC,OAAO,CAAC;uCAgCV,oBAAoB,YACjB,+BAA+B,KACxC,OAAO,CAAC,OAAO,CAAC;gCAuBV,oBAAoB,YACjB,+BAA+B,KACxC,OAAO,CAAC,0BAA0B,CAAC;gCAwCH,MAAM,EAAE,KAAG,MAAM,GAAG,SAAS;mCAU1B,MAAM,EAAE,KAAG,oBAAoB,GAAG,SAAS;8BAOhD,MAAM,EAAE,KAAG,OAAO;uCAvMT,oBAAoB,KAAG,MAAM,EAAE;gCAwBtC,oBAAoB,KAAG,MAAM,EAAE;EAuPhE,CAAC"}