@soederpop/luca 0.1.2 → 0.2.1

package/dist/node/features/postgres.d.ts

@@ -0,0 +1,173 @@
+import { z } from 'zod';
+import { SQL } from 'bun';
+import { Feature } from '../feature.js';
+import type { ContainerContext } from '../../container.js';
+type SqlValue = string | number | boolean | bigint | Uint8Array | Buffer | null;
+export declare const PostgresStateSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    connected: z.ZodDefault<z.ZodBoolean>;
+    url: z.ZodDefault<z.ZodString>;
+    lastQuery: z.ZodOptional<z.ZodString>;
+    lastRowCount: z.ZodOptional<z.ZodNumber>;
+    lastError: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const PostgresOptionsSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    _cacheKey: z.ZodOptional<z.ZodString>;
+    cached: z.ZodOptional<z.ZodBoolean>;
+    enable: z.ZodOptional<z.ZodBoolean>;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PostgresState = z.infer<typeof PostgresStateSchema>;
+export type PostgresOptions = z.infer<typeof PostgresOptionsSchema>;
+export declare const PostgresEventsSchema: z.ZodObject<{
+    stateChange: z.ZodTuple<[z.ZodAny], null>;
+    enabled: z.ZodTuple<[], null>;
+    query: z.ZodTuple<[z.ZodString, z.ZodArray<z.ZodAny>, z.ZodNumber], null>;
+    execute: z.ZodTuple<[z.ZodString, z.ZodArray<z.ZodAny>, z.ZodNumber], null>;
+    error: z.ZodTuple<[z.ZodAny], null>;
+    closed: z.ZodTuple<[], null>;
+}, z.core.$strip>;
+/**
+ * Postgres feature for safe SQL execution through Bun's native SQL client.
+ *
+ * Supports:
+ * - parameterized query execution (`query` / `execute`)
+ * - tagged-template query execution (`sql`) to avoid manual placeholder wiring
+ *
+ * @example
+ * ```typescript
+ * const postgres = container.feature('postgres', { url: process.env.DATABASE_URL! })
+ *
+ * const users = await postgres.query<{ id: number; email: string }>(
+ *   'select id, email from users where id = $1',
+ *   [123]
+ * )
+ *
+ * const rows = await postgres.sql<{ id: number }>`
+ *   select id from users where email = ${'hello@example.com'}
+ * `
+ * ```
+ */
+export declare class Postgres extends Feature<PostgresState, PostgresOptions> {
+    static shortcut: "features.postgres";
+    static stateSchema: z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        connected: z.ZodDefault<z.ZodBoolean>;
+        url: z.ZodDefault<z.ZodString>;
+        lastQuery: z.ZodOptional<z.ZodString>;
+        lastRowCount: z.ZodOptional<z.ZodNumber>;
+        lastError: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+    static optionsSchema: z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        _cacheKey: z.ZodOptional<z.ZodString>;
+        cached: z.ZodOptional<z.ZodBoolean>;
+        enable: z.ZodOptional<z.ZodBoolean>;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    static eventsSchema: z.ZodObject<{
+        stateChange: z.ZodTuple<[z.ZodAny], null>;
+        enabled: z.ZodTuple<[], null>;
+        query: z.ZodTuple<[z.ZodString, z.ZodArray<z.ZodAny>, z.ZodNumber], null>;
+        execute: z.ZodTuple<[z.ZodString, z.ZodArray<z.ZodAny>, z.ZodNumber], null>;
+        error: z.ZodTuple<[z.ZodAny], null>;
+        closed: z.ZodTuple<[], null>;
+    }, z.core.$strip>;
+    private _client;
+    /**
+     * Default state for the Postgres feature before a connection is established.
+     * @returns The initial PostgresState with `connected: false` and empty `url`
+     */
+    get initialState(): PostgresState;
+    constructor(options: PostgresOptions, context: ContainerContext);
+    /**
+     * Returns the underlying Bun SQL postgres client.
+     * @returns The raw `SQL` instance used for all database operations
+     */
+    get client(): SQL;
+    /**
+     * Executes a SELECT-like query and returns result rows.
+     *
+     * Use postgres placeholders (`$1`, `$2`, ...) for `params`.
+     *
+     * @param queryText - The SQL query string with optional `$N` placeholders
+     * @param params - Ordered array of values to bind to the placeholders
+     * @returns Promise resolving to an array of typed result rows
+     * @throws {Error} When query text is empty or params contain `undefined`
+     *
+     * @example
+     * ```typescript
+     * const pg = container.feature('postgres', { url: process.env.DATABASE_URL! })
+     * const users = await pg.query<{ id: number; email: string }>(
+     *   'SELECT id, email FROM users WHERE active = $1',
+     *   [true]
+     * )
+     * ```
+     */
+    query<T extends object = Record<string, unknown>>(queryText: string, params?: SqlValue[]): Promise<T[]>;
+    /**
+     * Executes a write/update/delete statement and returns metadata.
+     *
+     * Use postgres placeholders (`$1`, `$2`, ...) for `params`.
+     *
+     * @param queryText - The SQL statement string with optional `$N` placeholders
+     * @param params - Ordered array of values to bind to the placeholders
+     * @returns Promise resolving to `{ rowCount }` indicating affected rows
+     * @throws {Error} When query text is empty or params contain `undefined`
+     *
+     * @example
+     * ```typescript
+     * const pg = container.feature('postgres', { url: process.env.DATABASE_URL! })
+     * const { rowCount } = await pg.execute(
+     *   'UPDATE users SET active = $1 WHERE last_login < $2',
+     *   [false, '2024-01-01']
+     * )
+     * console.log(`Deactivated ${rowCount} users`)
+     * ```
+     */
+    execute(queryText: string, params?: SqlValue[]): Promise<{
+        rowCount: number;
+    }>;
+    /**
+     * Safe tagged-template SQL helper.
+     *
+     * Values become bound parameters automatically, preventing SQL injection.
+     *
+     * @param strings - Template literal string segments
+     * @param values - Interpolated values that become bound `$N` parameters
+     * @returns Promise resolving to an array of typed result rows
+     *
+     * @example
+     * ```typescript
+     * const pg = container.feature('postgres', { url: process.env.DATABASE_URL! })
+     * const email = 'hello@example.com'
+     * const rows = await pg.sql<{ id: number }>`
+     *   SELECT id FROM users WHERE email = ${email}
+     * `
+     * ```
+     */
+    sql<T extends object = Record<string, unknown>>(strings: TemplateStringsArray, ...values: SqlValue[]): Promise<T[]>;
+    /**
+     * Closes the postgres connection and updates feature state.
+     *
+     * Emits `closed` after the connection is torn down.
+     *
+     * @returns This Postgres feature instance for method chaining
+     *
+     * @example
+     * ```typescript
+     * const pg = container.feature('postgres', { url: process.env.DATABASE_URL! })
+     * // ... run queries ...
+     * await pg.close()
+     * ```
+     */
+    close(): Promise<this>;
+}
+export default Postgres;
+declare module '../../feature.js' {
+    interface AvailableFeatures {
+        postgres: typeof Postgres;
+    }
+}
+//# sourceMappingURL=postgres.d.ts.map

package/dist/node/features/postgres.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../../../src/node/features/postgres.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AACzB,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAE1D,KAAK,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,UAAU,GAAG,MAAM,GAAG,IAAI,CAAA;AAE/E,eAAO,MAAM,mBAAmB;;;;;;;iBAM9B,CAAA;AAEF,eAAO,MAAM,qBAAqB;;;;;;iBAEhC,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,eAAO,MAAM,oBAAoB;;;;;;;iBAaH,CAAA;AAE9B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,QAAS,SAAQ,OAAO,CAAC,aAAa,EAAE,eAAe,CAAC;IACnE,OAAgB,QAAQ,EAAG,mBAAmB,CAAS;IACvD,OAAgB,WAAW;;;;;;;sBAAsB;IACjD,OAAgB,aAAa;;;;;;sBAAwB;IACrD,OAAgB,YAAY;;;;;;;sBAAuB;IAGnD,OAAO,CAAC,OAAO,CAAK;IAEpB;;;OAGG;IACH,IAAa,YAAY,IAAI,aAAa,CAMzC;gBAEW,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,gBAAgB;IAgB/D;;;OAGG;IACH,IAAI,MAAM,QAET;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACG,KAAK,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,GAAE,QAAQ,EAAO,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IA4BjH;;;;;;;;;;;;;;;;;;;OAmBG;IACG,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,GAAE,QAAQ,EAAO,GAAG,OAAO,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IA2BxF;;;;;;;;;;;;;;;;;OAiBG;IACG,GAAG,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAKzH;;;;;;;;;;;;;OAaG;IACG,KAAK;CAMZ;AAED,eAAe,QAAQ,CAAA;AACvB,OAAO,QAAQ,kBAAkB,CAAC;IAChC,UAAU,iBAAiB;QACzB,QAAQ,EAAE,OAAO,QAAQ,CAAA;KAC1B;CACF"}

package/dist/node/features/proc.d.ts

@@ -0,0 +1,285 @@
+import { Feature } from "../feature.js";
+interface SpawnOptions {
+    /** Standard I/O mode for the child process */
+    stdio?: "ignore" | "inherit";
+    /** Stdout mode for the child process */
+    stdout?: "ignore" | "inherit";
+    /** Stderr mode for the child process */
+    stderr?: "ignore" | "inherit";
+    /** Working directory for the child process */
+    cwd?: string;
+    /** Environment variables to pass to the child process */
+    environment?: Record<string, any>;
+    /** Callback invoked when stderr data is received */
+    onError?: (data: string) => void;
+    /** Callback invoked when stdout data is received */
+    onOutput?: (data: string) => void;
+    /** Callback invoked when the process exits */
+    onExit?: (code: number) => void;
+    /** Callback invoked when the process starts */
+    onStart?: (childProcess: ChildProcess) => void;
+}
+interface RawSpawnOptions {
+    /** Working directory for the child process */
+    cwd?: string;
+    /** Environment variables to pass to the child process */
+    environment?: Record<string, any>;
+    /** Optional stdin payload written immediately after spawn */
+    stdin?: string | Buffer;
+    /** Stdout mode for the child process */
+    stdout?: "pipe" | "inherit" | "ignore";
+    /** Stderr mode for the child process */
+    stderr?: "pipe" | "inherit" | "ignore";
+}
+/**
+ * The ChildProcess feature provides utilities for executing external processes and commands.
+ *
+ * This feature wraps Node.js child process functionality to provide convenient methods
+ * for executing shell commands, spawning processes, and capturing their output.
+ * It supports both synchronous and asynchronous execution with various options.
+ *
+ * @example
+ * ```typescript
+ * const proc = container.feature('proc')
+ *
+ * // Execute a simple command synchronously
+ * const result = proc.exec('echo "Hello World"')
+ * console.log(result) // 'Hello World'
+ *
+ * // Execute and capture output asynchronously
+ * const { stdout, stderr } = await proc.spawnAndCapture('npm', ['--version'])
+ * console.log(`npm version: ${stdout}`)
+ *
+ * // Execute with callbacks for real-time output
+ * await proc.spawnAndCapture('npm', ['install'], {
+ *   onOutput: (data) => console.log('OUT:', data),
+ *   onError: (data) => console.log('ERR:', data)
+ * })
+ * ```
+ *
+ * @extends Feature
+ */
+export declare class ChildProcess extends Feature {
+    static shortcut: "features.proc";
+    static stateSchema: import("zod").ZodObject<{
+        enabled: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    }, import("zod/v4/core").$loose>;
+    static optionsSchema: import("zod").ZodObject<{
+        name: import("zod").ZodOptional<import("zod").ZodString>;
+        _cacheKey: import("zod").ZodOptional<import("zod").ZodString>;
+        cached: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        enable: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, import("zod/v4/core").$strip>;
+    /**
+     * Executes a command string and captures its output asynchronously.
+     *
+     * This method takes a complete command string, splits it into command and arguments,
+     * and executes it using the spawnAndCapture method. It's a convenient wrapper
+     * for simple command execution.
+     *
+     * @param {string} cmd - The complete command string to execute (e.g., "git status --porcelain")
+     * @param {any} [options] - Options to pass to the underlying spawn process
+     * @returns {Promise<object>} Promise resolving to execution result with stdout, stderr, exitCode, pid, and error
+     *
+     * @example
+     * ```typescript
+     * // Execute a git command
+     * const result = await proc.execAndCapture('git status --porcelain')
+     * if (result.exitCode === 0) {
+     *   console.log('Git status:', result.stdout)
+     * } else {
+     *   console.error('Git error:', result.stderr)
+     * }
+     *
+     * // Execute with options
+     * const result = await proc.execAndCapture('npm list --depth=0', {
+     *   cwd: '/path/to/project'
+     * })
+     * ```
+     */
+    execAndCapture(cmd: string, options?: any): Promise<{
+        stderr: string;
+        stdout: string;
+        error: null | any;
+        exitCode: number;
+        pid: number | null;
+    }>;
+    /**
+     * Spawns a process and captures its output with real-time monitoring capabilities.
+     *
+     * This method provides comprehensive process execution with the ability to capture
+     * output, monitor real-time data streams, and handle process lifecycle events.
+     * It's ideal for long-running processes where you need to capture output as it happens.
+     *
+     * @param {string} command - The command to execute (e.g., 'node', 'npm', 'git')
+     * @param {string[]} args - Array of arguments to pass to the command
+     * @param {SpawnOptions} [options] - Options for process execution and monitoring
+     * @param {string} [options.cwd] - Working directory for the process
+     * @param {Function} [options.onOutput] - Callback for stdout data
+     * @param {Function} [options.onError] - Callback for stderr data
+     * @param {Function} [options.onExit] - Callback for process exit
+     * @returns {Promise<object>} Promise resolving to complete execution result
+     *
+     * @example
+     * ```typescript
+     * // Basic usage
+     * const result = await proc.spawnAndCapture('node', ['--version'])
+     * console.log(`Node version: ${result.stdout}`)
+     *
+     * // With real-time output monitoring
+     * const result = await proc.spawnAndCapture('npm', ['install'], {
+     *   onOutput: (data) => console.log('📦 ', data.trim()),
+     *   onError: (data) => console.error('❌ ', data.trim()),
+     *   onExit: (code) => console.log(`Process exited with code ${code}`)
+     * })
+     *
+     * // Long-running process with custom working directory
+     * const buildResult = await proc.spawnAndCapture('npm', ['run', 'build'], {
+     *   cwd: '/path/to/project',
+     *   onOutput: (data) => {
+     *     if (data.includes('error')) {
+     *       console.error('Build error detected:', data)
+     *     }
+     *   }
+     * })
+     * ```
+     */
+    spawnAndCapture(command: string, args: string[], options?: SpawnOptions): Promise<{
+        stderr: string;
+        stdout: string;
+        error: null | any;
+        exitCode: number;
+        pid: number | null;
+    }>;
+    /**
+     * Spawn a raw child process and return the handle immediately.
+     *
+     * Useful when callers need streaming access to stdout/stderr and
+     * direct lifecycle control (for example, cancellation via kill()).
+     */
+    spawn(command: string, args?: string[], options?: RawSpawnOptions): import('child_process').ChildProcess;
+    /**
+     * Execute a command synchronously and return its output.
+     *
+     * Runs a shell command and waits for it to complete before returning.
+     * Useful for simple commands where you need the result immediately.
+     *
+     * @param command - The command to execute
+     * @param options - Options for command execution (cwd, encoding, etc.)
+     * @returns The trimmed stdout from the command execution
+     * @throws If the command fails or returns non-zero exit code
+     *
+     * @example
+     * ```typescript
+     * const branch = proc.exec('git branch --show-current')
+     * const version = proc.exec('node --version')
+     * ```
+     */
+    exec(command: string, options?: any): string;
+    execSync(command: string, options?: any): string;
+    /**
+     * Establishes a PID-file lock to prevent duplicate process instances.
+     *
+     * Writes the current process PID to the given file path. If the file already exists
+     * and the PID inside it refers to a running process, the current process exits immediately.
+     * Stale PID files (where the process is no longer running) are automatically cleaned up.
+     *
+     * Cleanup handlers are registered on SIGTERM, SIGINT, and process exit to remove the
+     * PID file when the process shuts down.
+     *
+     * @param {string} pidPath - Path to the PID file, resolved relative to container.cwd
+     * @returns {{ release: () => void }} Object with a release function to manually remove the lock
+     *
+     * @example
+     * ```typescript
+     * // In a command handler — exits if already running
+     * const lock = proc.establishLock('tmp/luca-main.pid')
+     *
+     * // Later, if you need to release manually
+     * lock.release()
+     * ```
+     */
+    establishLock(pidPath: string): {
+        release: () => void;
+    };
+    /**
+     * Kills a process by its PID.
+     *
+     * @param {number} pid - The process ID to kill
+     * @param {NodeJS.Signals | number} [signal='SIGTERM'] - The signal to send (e.g. 'SIGTERM', 'SIGKILL', 9)
+     * @returns {boolean} True if the signal was sent successfully, false if the process was not found
+     *
+     * @example
+     * ```typescript
+     * // Gracefully terminate a process
+     * proc.kill(12345)
+     *
+     * // Force kill a process
+     * proc.kill(12345, 'SIGKILL')
+     * ```
+     */
+    kill(pid: number, signal?: NodeJS.Signals | number): boolean;
+    /**
+     * Finds PIDs of processes listening on a given port.
+     *
+     * Uses `lsof` on macOS/Linux to discover which processes have a socket bound to the specified port.
+     *
+     * @param {number} port - The port number to search for
+     * @returns {number[]} Array of PIDs listening on that port (empty if none found)
+     *
+     * @example
+     * ```typescript
+     * const pids = proc.findPidsByPort(3000)
+     * console.log(`Processes on port 3000: ${pids}`)
+     *
+     * // Kill everything on port 3000
+     * for (const pid of proc.findPidsByPort(3000)) {
+     *   proc.kill(pid)
+     * }
+     * ```
+     */
+    findPidsByPort(port: number): number[];
+    /**
+     * Registers a handler for a process signal (e.g. SIGINT, SIGTERM, SIGUSR1).
+     *
+     * Returns a cleanup function that removes the listener when called.
+     *
+     * @param {NodeJS.Signals} signal - The signal name to listen for (e.g. 'SIGINT', 'SIGTERM', 'SIGUSR2')
+     * @param {() => void} handler - The function to call when the signal is received
+     * @returns {() => void} A function that removes the listener when called
+     *
+     * @example
+     * ```typescript
+     * // Graceful shutdown
+     * proc.onSignal('SIGTERM', () => {
+     *   console.log('Shutting down gracefully...')
+     *   process.exit(0)
+     * })
+     *
+     * // Remove the listener later
+     * const off = proc.onSignal('SIGUSR2', () => {
+     *   console.log('Received SIGUSR2')
+     * })
+     * off()
+     * ```
+     */
+    /**
+     * Checks whether any process matching a given name is currently running.
+     *
+     * Uses `pgrep -x` for an exact match against process names.
+     *
+     * @param {string} name - The process name to look for (e.g. 'afplay', 'node', 'nginx')
+     * @returns {boolean} True if at least one matching process is running
+     *
+     * @example
+     * ```typescript
+     * if (proc.isProcessRunning('afplay')) {
+     *   console.log('Audio is currently playing')
+     * }
+     * ```
+     */
+    isProcessRunning(name: string): boolean;
+    onSignal(signal: NodeJS.Signals, handler: () => void): () => void;
+}
+export default ChildProcess;
+//# sourceMappingURL=proc.d.ts.map

package/dist/node/features/proc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proc.d.ts","sourceRoot":"","sources":["../../../src/node/features/proc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAOxC,UAAU,YAAY;IACpB,8CAA8C;IAC9C,KAAK,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IAC7B,wCAAwC;IACxC,MAAM,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IAC9B,wCAAwC;IACxC,MAAM,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IAC9B,8CAA8C;IAC9C,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,yDAAyD;IACzD,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAClC,oDAAoD;IACpD,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,oDAAoD;IACpD,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,8CAA8C;IAC9C,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,+CAA+C;IAC/C,OAAO,CAAC,EAAE,CAAC,YAAY,EAAE,YAAY,KAAK,IAAI,CAAC;CAChD;AAED,UAAU,eAAe;IACvB,8CAA8C;IAC9C,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,yDAAyD;IACzD,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAClC,6DAA6D;IAC7D,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,wCAAwC;IACxC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,QAAQ,CAAC;IACvC,wCAAwC;IACxC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,QAAQ,CAAC;CACxC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,YAAa,SAAQ,OAAO;IACvC,OAAgB,QAAQ,EAAG,eAAe,CAAS;IACnD,OAAgB,WAAW;;qCAAqB;IAChD,OAAgB,aAAa;;;;;qCAAuB;IAIpD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACG,cAAc,CAClB,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,GAAG,GACZ,OAAO,CAAC;QACT,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,IAAI,GAAG,GAAG,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;QACjB,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;KACpB,CAAC;IAKF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuCG;IACG,eAAe,CACnB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC;QACT,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,IAAI,GAAG,GAAG,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;QACjB,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;KACpB,CAAC;IA8DF;;;;;OAKG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,GAAE,MAAM,EAAO,EAAE,OAAO,GAAE,eAAoB,GAAG,OAAO,eAAe,EAAE,YAAY;IAoBhH;;;;;;;;;;;;;;;;OAgBG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,MAAM;IAU5C,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,MAAM;IAIhD;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG;QAAE,OAAO,EAAE,MAAM,IAAI,CAAA;KAAE;IAqDvD;;;;;;;;;;;;;;;OAeG;IACH,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,CAAC,OAAO,GAAG,MAAkB,GAAG,OAAO;IAUvE;;;;;;;;;;;;;;;;;;OAkBG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE;IAgBtC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH;;;;;;;;;;;;;;OAcG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAWvC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;CAIlE;AAED,eAAe,YAAY,CAAA"}