@happyvertical/utils 0.74.8

package/dist/shared/code/sandbox.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Sandbox creation and safe code execution utilities
+ *
+ * Provides secure execution of generated code in isolated VM contexts with
+ * controlled globals, timeouts, and resource constraints.
+ */
+import * as vm from 'node:vm';
+/**
+ * Options for creating a sandbox execution context
+ */
+export interface SandboxOptions {
+    /**
+     * Global variables to make available in the sandbox
+     * These will be accessible as global variables in the executed code
+     */
+    globals?: Record<string, any>;
+    /**
+     * Maximum execution time in milliseconds
+     * Default: 5000ms (5 seconds)
+     */
+    timeout?: number;
+    /**
+     * Allowed built-in JavaScript objects
+     * Default: ['Array', 'Object', 'JSON', 'Math', 'Date', 'String', 'Number', 'Boolean', 'RegExp']
+     */
+    allowedBuiltins?: string[];
+    /**
+     * Whether to allow console access (useful for debugging)
+     * Default: false (console will be undefined unless provided in globals)
+     */
+    allowConsole?: boolean;
+}
+/**
+ * Options for executing code in a sandbox
+ */
+export interface ExecuteOptions {
+    /**
+     * Maximum execution time in milliseconds
+     * Overrides the sandbox-level timeout if provided
+     */
+    timeout?: number;
+    /**
+     * Filename to use in error messages and stack traces
+     * Default: 'generated-code.js'
+     */
+    filename?: string;
+    /**
+     * Whether to capture and return the last expression value
+     * Default: true
+     */
+    captureResult?: boolean;
+}
+/**
+ * Creates a secure sandbox execution context with controlled globals
+ *
+ * @param options - Configuration for the sandbox
+ * @returns A VM context that can be used with executeCode()
+ *
+ * @example
+ * ```typescript
+ * const sandbox = createSandbox({
+ *   globals: {
+ *     cheerio: require('cheerio'),
+ *     data: { foo: 'bar' }
+ *   },
+ *   timeout: 5000,
+ *   allowedBuiltins: ['Array', 'Object', 'JSON']
+ * });
+ *
+ * const result = executeCode('data.foo', sandbox);
+ * // Returns: "bar"
+ * ```
+ */
+export declare function createSandbox(options?: SandboxOptions): vm.Context;
+/**
+ * Executes code in a sandbox with timeout and error handling
+ *
+ * @param code - The JavaScript code to execute
+ * @param sandbox - The VM context created by createSandbox()
+ * @param options - Execution options
+ * @returns The result of the code execution
+ * @throws {Error} If code execution fails or times out
+ *
+ * @example
+ * ```typescript
+ * const sandbox = createSandbox({
+ *   globals: { x: 10, y: 20 }
+ * });
+ *
+ * const result = executeCode('x + y', sandbox);
+ * // Returns: 30
+ *
+ * // With a function
+ * const funcResult = executeCode(`
+ *   function add(a, b) {
+ *     return a + b;
+ *   }
+ *   add(x, y);
+ * `, sandbox);
+ * // Returns: 30
+ * ```
+ */
+export declare function executeCode<T = any>(code: string, sandbox: vm.Context, options?: ExecuteOptions): T;
+/**
+ * Executes async code in a sandbox with timeout and error handling
+ *
+ * @param code - The JavaScript code to execute (can contain async/await)
+ * @param sandbox - The VM context created by createSandbox()
+ * @param options - Execution options
+ * @returns Promise resolving to the result of the code execution
+ * @throws {Error} If code execution fails or times out
+ *
+ * @example
+ * ```typescript
+ * const sandbox = createSandbox({
+ *   globals: {
+ *     fetch: require('node-fetch')
+ *   }
+ * });
+ *
+ * const result = await executeCodeAsync(`
+ *   const response = await fetch('https://api.example.com/data');
+ *   const data = await response.json();
+ *   data;
+ * `, sandbox);
+ * ```
+ */
+export declare function executeCodeAsync<T = any>(code: string, sandbox: vm.Context, options?: ExecuteOptions): Promise<T>;
+/**
+ * Convenience function to create a sandbox and execute code in one step
+ *
+ * @param code - The JavaScript code to execute
+ * @param options - Combined sandbox and execution options
+ * @returns The result of the code execution
+ *
+ * @example
+ * ```typescript
+ * const result = executeInSandbox('Math.sqrt(16)', {
+ *   globals: { x: 10 },
+ *   timeout: 1000
+ * });
+ * // Returns: 4
+ * ```
+ */
+export declare function executeInSandbox<T = any>(code: string, options?: SandboxOptions & ExecuteOptions): T;
+/**
+ * Convenience function to create a sandbox and execute async code in one step
+ *
+ * @param code - The JavaScript code to execute (can contain async/await)
+ * @param options - Combined sandbox and execution options
+ * @returns Promise resolving to the result of the code execution
+ *
+ * @example
+ * ```typescript
+ * const result = await executeInSandboxAsync(`
+ *   const data = await Promise.resolve({ value: 42 });
+ *   data.value;
+ * `, {
+ *   timeout: 2000
+ * });
+ * // Returns: 42
+ * ```
+ */
+export declare function executeInSandboxAsync<T = any>(code: string, options?: SandboxOptions & ExecuteOptions): Promise<T>;
+//# sourceMappingURL=sandbox.d.ts.map

package/dist/shared/code/sandbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandbox.d.ts","sourceRoot":"","sources":["../../../src/shared/code/sandbox.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,MAAM,SAAS,CAAC;AAE9B;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAE9B;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAE3B;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAuBD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,aAAa,CAAC,OAAO,GAAE,cAAmB,GAAG,EAAE,CAAC,OAAO,CA2BtE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,WAAW,CAAC,CAAC,GAAG,GAAG,EACjC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,EAAE,CAAC,OAAO,EACnB,OAAO,GAAE,cAAmB,GAC3B,CAAC,CAiDH;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,GAAG,GAAG,EAC5C,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,EAAE,CAAC,OAAO,EACnB,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,CAAC,CAAC,CAmEZ;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,GAAG,GAAG,EACtC,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,cAAc,GAAG,cAAmB,GAC5C,CAAC,CAGH;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,qBAAqB,CAAC,CAAC,GAAG,GAAG,EACjD,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,cAAc,GAAG,cAAmB,GAC5C,OAAO,CAAC,CAAC,CAAC,CAGZ"}

package/dist/shared/code/validation.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Code validation utilities for checking generated code before execution
+ *
+ * Provides functions to validate code syntax, check for dangerous patterns,
+ * and verify code meets security requirements before sandbox execution.
+ */
+/**
+ * Options for code validation
+ */
+export interface ValidationOptions {
+    /**
+     * List of allowed global variables
+     * If provided, code will be checked for undeclared variables
+     */
+    allowedGlobals?: string[];
+    /**
+     * List of disallowed patterns (regex)
+     * Code containing these patterns will fail validation
+     */
+    disallowedPatterns?: RegExp[];
+    /**
+     * Maximum code length in characters
+     * Default: 50000
+     */
+    maxLength?: number;
+    /**
+     * Whether to allow require() calls
+     * Default: false (dangerous in untrusted code)
+     */
+    allowRequire?: boolean;
+    /**
+     * Whether to allow import statements
+     * Default: false (dangerous in untrusted code)
+     */
+    allowImport?: boolean;
+    /**
+     * Whether to allow eval() and Function() constructor
+     * Default: false (dangerous in any code)
+     */
+    allowEval?: boolean;
+    /**
+     * Whether to perform syntax check
+     * Default: true
+     */
+    checkSyntax?: boolean;
+}
+/**
+ * Result of code validation
+ */
+export interface ValidationResult {
+    /**
+     * Whether the code passed all validation checks
+     */
+    valid: boolean;
+    /**
+     * Critical errors that prevent execution
+     */
+    errors: string[];
+    /**
+     * Non-critical warnings about the code
+     */
+    warnings: string[];
+    /**
+     * Statistics about the code
+     */
+    stats?: {
+        length: number;
+        lines: number;
+        hasAsync: boolean;
+        hasArrowFunctions: boolean;
+        hasClasses: boolean;
+    };
+}
+/**
+ * Validates code before execution in a sandbox
+ *
+ * @param code - The code to validate
+ * @param options - Validation options
+ * @returns Validation result with errors and warnings
+ *
+ * @example
+ * ```typescript
+ * const result = validateCode(`
+ *   function parse(data) {
+ *     return JSON.parse(data);
+ *   }
+ * `, {
+ *   allowedGlobals: ['JSON'],
+ *   maxLength: 10000
+ * });
+ *
+ * if (!result.valid) {
+ *   console.error('Code validation failed:', result.errors);
+ * }
+ * ```
+ */
+export declare function validateCode(code: string, options?: ValidationOptions): ValidationResult;
+/**
+ * Quick validation to check if code is safe for execution
+ * Returns true if code passes basic safety checks
+ *
+ * @param code - The code to check
+ * @returns true if code is safe, false otherwise
+ *
+ * @example
+ * ```typescript
+ * if (isSafeCode('return x + y')) {
+ *   // Safe to execute
+ * }
+ * ```
+ */
+export declare function isSafeCode(code: string): boolean;
+//# sourceMappingURL=validation.d.ts.map

package/dist/shared/code/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/shared/code/validation.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAE1B;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;IAE9B;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,KAAK,EAAE,OAAO,CAAC;IAEf;;OAEG;IACH,MAAM,EAAE,MAAM,EAAE,CAAC;IAEjB;;OAEG;IACH,QAAQ,EAAE,MAAM,EAAE,CAAC;IAEnB;;OAEG;IACH,KAAK,CAAC,EAAE;QACN,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,OAAO,CAAC;QAClB,iBAAiB,EAAE,OAAO,CAAC;QAC3B,UAAU,EAAE,OAAO,CAAC;KACrB,CAAC;CACH;AAkBD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,iBAAsB,GAC9B,gBAAgB,CAqGlB;AAqMD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAOhD"}

package/dist/shared/index.d.ts

@@ -0,0 +1,5 @@
+export * from './code';
+export * from './logger';
+export * from './types';
+export * from './universal';
+//# sourceMappingURL=index.d.ts.map

package/dist/shared/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/shared/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC"}

package/dist/shared/logger.d.ts

@@ -0,0 +1,43 @@
+import { Logger } from './types';
+/**
+ * Replace the global logger with a custom implementation
+ *
+ * @param logger - Custom logger implementation
+ * @example
+ * ```typescript
+ * setLogger(new CustomLogger());
+ * ```
+ */
+export declare const setLogger: (logger: Logger) => void;
+/**
+ * Get the current global logger instance
+ *
+ * @returns Current logger implementation
+ * @example
+ * ```typescript
+ * const logger = getLogger();
+ * logger.info('Application started');
+ * ```
+ */
+export declare const getLogger: () => Logger;
+/**
+ * Disable all logging by switching to no-op logger
+ *
+ * @example
+ * ```typescript
+ * if (process.env.NODE_ENV === 'production') {
+ *   disableLogging();
+ * }
+ * ```
+ */
+export declare const disableLogging: () => void;
+/**
+ * Enable console logging by switching to console logger
+ *
+ * @example
+ * ```typescript
+ * enableLogging(); // Re-enable after disabling
+ * ```
+ */
+export declare const enableLogging: () => void;
+//# sourceMappingURL=logger.d.ts.map

package/dist/shared/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/shared/logger.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAwDtC;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,GAAI,QAAQ,MAAM,KAAG,IAE1C,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,SAAS,QAAO,MAE5B,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,QAAO,IAEjC,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,QAAO,IAEhC,CAAC"}

package/dist/shared/types.d.ts

@@ -0,0 +1,195 @@
+/**
+ * Shared type definitions and interfaces for universal use
+ *
+ * This module provides standardized error classes and logging interfaces
+ * used throughout the HAVE SDK. All error classes extend BaseError to
+ * provide consistent error handling with context and timestamps.
+ */
+/**
+ * Standardized error codes used across the HAVE SDK
+ *
+ * These codes provide consistent error categorization for better error handling
+ * and monitoring across all packages in the SDK.
+ */
+export declare enum ErrorCode {
+    /** Input validation failed */
+    VALIDATION_ERROR = "VALIDATION_ERROR",
+    /** API request/response error */
+    API_ERROR = "API_ERROR",
+    /** File system operation error */
+    FILE_ERROR = "FILE_ERROR",
+    /** Network connectivity or HTTP error */
+    NETWORK_ERROR = "NETWORK_ERROR",
+    /** Database operation error */
+    DATABASE_ERROR = "DATABASE_ERROR",
+    /** Data parsing or format error */
+    PARSING_ERROR = "PARSING_ERROR",
+    /** Operation timeout error */
+    TIMEOUT_ERROR = "TIMEOUT_ERROR",
+    /** Unspecified or unexpected error */
+    UNKNOWN_ERROR = "UNKNOWN_ERROR"
+}
+/**
+ * Base error class providing standardized error handling across the HAVE SDK
+ *
+ * All custom errors extend this class to ensure consistent error structure,
+ * context preservation, and debugging capabilities.
+ *
+ * @example
+ * ```typescript
+ * throw new BaseError('Something went wrong', ErrorCode.UNKNOWN_ERROR, {
+ *   userId: 123,
+ *   operation: 'processData'
+ * });
+ * ```
+ */
+export declare class BaseError extends Error {
+    /** Error classification code */
+    readonly code: ErrorCode;
+    /** Additional context data for debugging */
+    readonly context?: Record<string, unknown>;
+    /** When the error occurred */
+    readonly timestamp: Date;
+    constructor(message: string, code?: ErrorCode, context?: Record<string, unknown>);
+    /**
+     * Serializes the error to a JSON-compatible object
+     * @returns Object containing all error properties
+     */
+    toJSON(): {
+        name: string;
+        message: string;
+        code: ErrorCode;
+        context: Record<string, unknown> | undefined;
+        timestamp: string;
+        stack: string | undefined;
+    };
+}
+/**
+ * Error thrown when input validation fails
+ *
+ * @example
+ * ```typescript
+ * throw new ValidationError('Email format invalid', {
+ *   email: 'invalid-email',
+ *   field: 'userEmail'
+ * });
+ * ```
+ */
+export declare class ValidationError extends BaseError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+/**
+ * Error thrown for API-related failures
+ *
+ * @example
+ * ```typescript
+ * throw new ApiError('HTTP 404 Not Found', {
+ *   url: 'https://api.example.com/users/123',
+ *   status: 404
+ * });
+ * ```
+ */
+export declare class ApiError extends BaseError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+/**
+ * Error thrown for file system operation failures
+ *
+ * @example
+ * ```typescript
+ * throw new FileError('File not found', {
+ *   path: '/path/to/missing/file.txt',
+ *   operation: 'read'
+ * });
+ * ```
+ */
+export declare class FileError extends BaseError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+/**
+ * Error thrown for network connectivity or HTTP failures
+ *
+ * @example
+ * ```typescript
+ * throw new NetworkError('Connection timeout', {
+ *   host: 'example.com',
+ *   timeout: 5000,
+ *   attempt: 3
+ * });
+ * ```
+ */
+export declare class NetworkError extends BaseError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+/**
+ * Error thrown for database operation failures
+ *
+ * @example
+ * ```typescript
+ * throw new DatabaseError('Connection failed', {
+ *   database: 'production',
+ *   query: 'SELECT * FROM users',
+ *   errorCode: 'ECONNREFUSED'
+ * });
+ * ```
+ */
+export declare class DatabaseError extends BaseError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+/**
+ * Error thrown for data parsing or format failures
+ *
+ * @example
+ * ```typescript
+ * throw new ParsingError('Invalid JSON format', {
+ *   input: '{invalid json}',
+ *   parser: 'JSON.parse',
+ *   position: 1
+ * });
+ * ```
+ */
+export declare class ParsingError extends BaseError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+/**
+ * Error thrown when operations exceed their timeout duration
+ *
+ * @example
+ * ```typescript
+ * throw new TimeoutError('Operation timed out', {
+ *   timeout: 5000,
+ *   operation: 'fetchData',
+ *   elapsedTime: 5234
+ * });
+ * ```
+ */
+export declare class TimeoutError extends BaseError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+/**
+ * Logging interface for consistent logging across the HAVE SDK
+ *
+ * All logging implementations should follow this interface to ensure
+ * consistent behavior and easy swapping of logging backends.
+ *
+ * @example
+ * ```typescript
+ * class CustomLogger implements Logger {
+ *   info(message: string, context?: Record<string, unknown>) {
+ *     console.log(`INFO: ${message}`, context);
+ *   }
+ *   // ... implement other methods
+ * }
+ * ```
+ */
+export interface Logger {
+    /** Log debug information (lowest priority) */
+    debug(message: string, context?: Record<string, unknown>): void;
+    /** Log informational messages */
+    info(message: string, context?: Record<string, unknown>): void;
+    /** Log warning messages */
+    warn(message: string, context?: Record<string, unknown>): void;
+    /** Log error messages (highest priority) */
+    error(message: string, context?: Record<string, unknown>): void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/shared/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/shared/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;GAKG;AACH,oBAAY,SAAS;IACnB,8BAA8B;IAC9B,gBAAgB,qBAAqB;IACrC,iCAAiC;IACjC,SAAS,cAAc;IACvB,kCAAkC;IAClC,UAAU,eAAe;IACzB,yCAAyC;IACzC,aAAa,kBAAkB;IAC/B,+BAA+B;IAC/B,cAAc,mBAAmB;IACjC,mCAAmC;IACnC,aAAa,kBAAkB;IAC/B,8BAA8B;IAC9B,aAAa,kBAAkB;IAC/B,sCAAsC;IACtC,aAAa,kBAAkB;CAChC;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,SAAU,SAAQ,KAAK;IAClC,gCAAgC;IAChC,SAAgB,IAAI,EAAE,SAAS,CAAC;IAChC,4CAA4C;IAC5C,SAAgB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClD,8BAA8B;IAC9B,SAAgB,SAAS,EAAE,IAAI,CAAC;gBAG9B,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,SAAmC,EACzC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAUnC;;;OAGG;IACH,MAAM;;;;;;;;CAUP;AAED;;;;;;;;;;GAUG;AACH,qBAAa,eAAgB,SAAQ,SAAS;gBAChC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAG/D;AAED;;;;;;;;;;GAUG;AACH,qBAAa,QAAS,SAAQ,SAAS;gBACzB,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAG/D;AAED;;;;;;;;;;GAUG;AACH,qBAAa,SAAU,SAAQ,SAAS;gBAC1B,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAG/D;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,YAAa,SAAQ,SAAS;gBAC7B,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAG/D;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,aAAc,SAAQ,SAAS;gBAC9B,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAG/D;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,YAAa,SAAQ,SAAS;gBAC7B,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAG/D;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,YAAa,SAAQ,SAAS;gBAC7B,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAG/D;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,MAAM;IACrB,8CAA8C;IAC9C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAChE,iCAAiC;IACjC,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC/D,2BAA2B;IAC3B,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC/D,4CAA4C;IAC5C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CACjE"}