@cldmv/slothlet 2.10.0 → 3.0.0

package/types/dist/lib/helpers/api_builder/metadata.d.mts

@@ -1,99 +0,0 @@
-/**
- *	@Project: @cldmv/slothlet
- *	@Filename: /src/lib/helpers/api_builder/metadata.mjs
- *	@Date: 2025-12-31 00:00:00 -08:00
- *	@Author: Nate Hyson <CLDMV>
- *	@Email: <Shinrai@users.noreply.github.com>
- *	-----
- *	@Last modified by: Nate Hyson <CLDMV> (Shinrai@users.noreply.github.com)
- *	@Last modified time: 2025-12-31 22:30:16 -08:00 (1767249016)
- *	-----
- *	@Copyright: Copyright (c) 2013-2025 Catalyzed Motivation Inc. All rights reserved.
- */
-/**
- * @fileoverview Metadata management utilities for API functions.
- * @module @cldmv/slothlet/lib/helpers/api_builder/metadata
- * @memberof module:@cldmv/slothlet.lib.helpers.api_builder
- * @internal
- * @private
- *
- * @description
- * Provides utilities for tagging functions with immutable metadata, cleaning stale metadata
- * from cached modules, and creating immutable metadata objects with deep freezing.
- *
- * Key Features:
- * - Immutable metadata with Proxy-based enforcement
- * - Deep freezing of nested objects and arrays
- * - Recursive traversal for tagging/cleaning object trees
- * - CommonJS cache-aware metadata cleanup
- */
-/**
- * Creates an immutable-but-extensible metadata proxy object.
- *
- * @function createImmutableMetadata
- * @param {object} initial - Initial metadata properties
- * @returns {object} Object with immutable existing properties but allows adding new ones
- *
- * @description
- * Creates an object that enforces immutability of existing properties while allowing
- * new properties to be added. This prevents tampering with security-critical metadata
- * while allowing runtime extension of metadata for additional context.
- *
- * Security features:
- * - Existing properties cannot be modified (non-writable, non-configurable after first set)
- * - Properties cannot be deleted
- * - New properties can be added, which then become immutable
- *
- * @example
- * const meta = createImmutableMetadata({ trusted: true, version: "1.0" });
- * meta.author = "Alice"; // OK - new property
- * meta.author = "Bob"; // FAIL - cannot modify after setting
- * meta.trusted = false;  // FAIL - cannot modify existing property
- * delete meta.version;   // FAIL - cannot delete properties
- */
-export function createImmutableMetadata(initial?: object): object;
-/**
- * Removes metadata from all functions in an object tree.
- *
- * @function cleanMetadata
- * @param {object|Function} obj - Object or function to clean
- * @param {WeakSet} [visited] - Visited objects tracker to prevent infinite recursion
- * @returns {void}
- *
- * @description
- * Traverses an object/function tree and removes __metadata and __sourceFolder properties.
- * This is needed when reloading CommonJS modules that cache function object references.
- */
-export function cleanMetadata(obj: object | Function, visited?: WeakSet<any>): void;
-/**
- * Recursively tags all functions in an object tree with metadata.
- *
- * @function tagLoadedFunctions
- * @param {object|Function} obj - Object or function to tag
- * @param {object} metadata - Metadata object to attach
- * @param {string} baseDir - Base directory path for relative file tracking
- * @param {WeakSet} [visited] - Visited objects tracker to prevent infinite recursion
- * @returns {void}
- *
- * @description
- * Traverses an object/function tree and attaches immutable metadata to all functions.
- * Also tracks source file information (__sourceFile, __sourceLine) for stack trace
- * matching. Only tags functions that don't already have metadata (non-overwriting).
- *
- * Attached properties:
- * - __metadata: Immutable metadata proxy with all user-provided metadata
- * - __sourceFolder: Absolute path to the folder the module was loaded from
- * - __sourceFile: Absolute file path (for stack trace matching)
- * - __sourceLine: Line number where function is defined (for stack trace matching)
- *
- * @example
- * const modules = { math: { add: (a, b) => a + b } };
- * tagLoadedFunctions(modules, {
- *     trusted: true,
- *     version: "1.0.0",
- *     author: "Alice"
- * }, "/path/to/plugins");
- * // Now modules.math.add.__metadata.trusted === true
- */
-export function tagLoadedFunctions(obj: object | Function, metadata: object, baseDir: string, visited?: WeakSet<any>): void;
-//# sourceMappingURL=metadata.d.mts.map

package/types/dist/lib/helpers/api_builder/metadata.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"metadata.d.mts","sourceRoot":"","sources":["../../../../../dist/lib/helpers/api_builder/metadata.mjs"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,kDApBW,MAAM,GACJ,MAAM,CAmJlB;AAED;;;;;;;;;;;GAWG;AACH,mCARW,MAAM,WAAS,2BAEb,IAAI,CAyChB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wCA1BW,MAAM,WAAS,YACf,MAAM,WACN,MAAM,2BAEJ,IAAI,CA+EhB"}

package/types/dist/lib/helpers/api_builder.d.mts

@@ -1,6 +0,0 @@
-export { addApiFromFolder } from "@cldmv/slothlet/helpers/api_builder/add_api";
-export { isLikelySerializable, analyzeModule, processModuleFromAnalysis, analyzeDirectoryStructure, getCategoryBuildingDecisions } from "@cldmv/slothlet/helpers/api_builder/analysis";
-export { getFlatteningDecision, applyFunctionNamePreference, processModuleForAPI, buildCategoryDecisions } from "@cldmv/slothlet/helpers/api_builder/decisions";
-export { buildCategoryStructure, buildRootAPI, toapiPathKey, shouldIncludeFile } from "@cldmv/slothlet/helpers/api_builder/construction";
-export { safeDefine, deepMerge, mutateLiveBindingFunction } from "@cldmv/slothlet/helpers/utilities";
-//# sourceMappingURL=api_builder.d.mts.map

package/types/dist/lib/helpers/api_builder.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"api_builder.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/api_builder.mjs"],"names":[],"mappings":""}

package/types/dist/lib/helpers/auto-wrap.d.mts

@@ -1,49 +0,0 @@
-/**
- *	@Project: @cldmv/slothlet
- *	@Filename: /src/lib/helpers/auto-wrap.mjs
- *	@Date: 2025-10-21 13:32:36 -07:00 (1761078756)
- *	@Author: Nate Hyson <CLDMV>
- *	@Email: <Shinrai@users.noreply.github.com>
- *	-----
- *	@Last modified by: Nate Hyson <CLDMV> (Shinrai@users.noreply.github.com)
- *	@Last modified time: 2025-10-22 06:59:17 -07:00 (1761141557)
- *	-----
- *	@Copyright: Copyright (c) 2013-2025 Catalyzed Motivation Inc. All rights reserved.
- */
-/**
- * @fileoverview Helper for automatically wrapping Node.js EventEmitter instances within API modules.
- * Internal file (not exported in package.json).
- * @module @cldmv/slothlet/src/lib/helpers/auto-wrap
- */
-/**
- * Automatically wrap Node.js EventEmitter constructors when called within slothlet API context.
- * This ensures that EventEmitter instances created inside API modules preserve AsyncLocalStorage context.
- * @function autoWrapEventEmitters
- * @package
- * @param {NetModule} nodeModule - The Node.js module to wrap (e.g., require("node:net"))
- * @returns {NetModule} Wrapped module with auto-wrapping constructors
- *
- * @description
- * Wraps Node.js module functions that return EventEmitter instances so they automatically
- * return wrapped instances when called within slothlet API context.
- *
- * @example
- * // Usage in API modules:
- * import { autoWrapEventEmitters } from "@cldmv/slothlet/src/lib/helpers/auto-wrap";
- * import originalNet from "node:net";
- * const net = autoWrapEventEmitters(originalNet);
- * // Now net.createServer() returns wrapped instances automatically
- */
-export function autoWrapEventEmitters(nodeModule: NetModule): NetModule;
-/**
- * Lazily get the pre-wrapped net module for convenient use in API modules.
- * @function getNet
- * @package
- * @returns {Promise<NetModule>} Promise resolving to the wrapped net module
- * @example
- * const net = await getNet();
- */
-export function getNet(): Promise<NetModule>;
-export type NetModule = typeof import("node:net");
-export type NetServer = import("node:net").Server;
-//# sourceMappingURL=auto-wrap.d.mts.map

package/types/dist/lib/helpers/auto-wrap.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"auto-wrap.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/auto-wrap.mjs"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH,kDAdW,SAAS,GACP,SAAS,CA6CrB;AAED;;;;;;;GAOG;AACH,0BAJa,OAAO,CAAC,SAAS,CAAC,CAO9B;wBAGY,cAAc,UAAU,CAAC;wBACzB,OAAO,UAAU,EAAE,MAAM"}

package/types/dist/lib/helpers/hooks.d.mts

@@ -1,342 +0,0 @@
-/**
- * @class HookManager
- * @internal
- * @private
- *
- * @description
- * Manages registration, pattern matching, and execution of hooks for slothlet API calls.
- * Hooks are executed in priority order (higher priority first), then registration order.
- *
- * @example
- * // Create hook manager
- * const manager = new HookManager();
- * manager.on("logger", "before", (ctx) => { console.log(ctx.path); });
- */
-export class HookManager {
-    /**
-     * @constructor
-     * @param {boolean} [enabled=true] - Initial enabled state
-     * @param {string} [defaultPattern="**"] - Default pattern for filtering
-     * @param {object} [options={}] - Additional options
-     * @param {boolean} [options.suppressErrors=false] - If true, errors are logged but not thrown (except for before/after hooks)
-     */
-    constructor(enabled?: boolean, defaultPattern?: string, options?: {
-        suppressErrors?: boolean;
-    });
-    enabled: boolean;
-    defaultPattern: string;
-    suppressErrors: boolean;
-    hooks: Map<any, any>;
-    registrationOrder: number;
-    reportedErrors: WeakSet<object>;
-    /**
-     * @function on
-     * @public
-     * @param {string} name - Hook name/ID for debugging and removal
-     * @param {string} type - Hook type: "before", "after", "always", or "error"
-     * @param {Function} handler - Hook handler function with type-specific signature:
-     *   - before: ({ path, args }) => modified args array or value to short-circuit
-     *   - after: ({ path, result }) => transformed result
-     *   - always: ({ path, result, hasError, errors }) => void (read-only)
-     *   - error: ({ path, error, errorType, source }) => void (observer)
-     * @param {object} [options] - Registration options
-     * @param {number} [options.priority=100] - Execution priority (higher = earlier)
-     * @param {string} [options.pattern] - Glob pattern for path filtering
-     * @returns {string} Hook name/ID for later removal
-     *
-     * @description
-     * Register a hook with optional priority and pattern filtering.
-     *
-     * @example
-     * // Register hook with priority
-     * manager.on("validator", "before", handler, { priority: 200 });
-     */
-    public on(name: string, type: string, handler: Function, options?: {
-        priority?: number;
-        pattern?: string;
-    }): string;
-    /**
-     * Clean up all hooks and resources
-     * @public
-     * @description
-     * Clears all registered hooks and resets internal state.
-     * Should be called during shutdown to prevent memory leaks.
-     *
-     * @example
-     * // Clean up during shutdown
-     * manager.cleanup();
-     */
-    public cleanup(): void;
-    /**
-     * @function off
-     * @public
-     * @param {string} nameOrPattern - Hook name or glob pattern to remove
-     * @returns {boolean} True if one or more hooks were removed
-     *
-     * @description
-     * Remove registered hook(s) by exact name or pattern matching.
-     *
-     * @example
-     * // Remove hook by exact name
-     * manager.off("validator");
-     *
-     * @example
-     * // Remove all hooks matching pattern
-     * manager.off("math.*");
-     */
-    public off(nameOrPattern: string): boolean;
-    /**
-     * @function clear
-     * @public
-     * @param {string} [type] - Optional hook type to clear ("before", "after", "always", "error")
-     * @returns {void}
-     *
-     * @description
-     * Remove registered hooks. If type is provided, only hooks of that type are removed.
-     *
-     * @example
-     * // Clear all hooks
-     * manager.clear();
-     *
-     * @example
-     * // Clear only before hooks
-     * manager.clear("before");
-     */
-    public clear(type?: string): void;
-    /**
-     * @function list
-     * @public
-     * @param {string} [type] - Optional hook type to filter by ("before", "after", "always", "error")
-     * @returns {Array<object>} Array of hook metadata
-     *
-     * @description
-     * List registered hooks with their metadata. When type is provided, only hooks
-     * matching that type are returned.
-     *
-     * @example
-     * // List all hooks
-     * const hooks = manager.list();
-     *
-     * @example
-     * // List only before hooks
-     * const beforeHooks = manager.list("before");
-     */
-    public list(type?: string): Array<object>;
-    /**
-     * @function enable
-     * @public
-     * @param {string} [pattern] - Optional new default pattern
-     * @returns {void}
-     *
-     * @description
-     * Enable hook execution, optionally updating default pattern.
-     *
-     * @example
-     * // Enable with new pattern
-     * manager.enable("database.*");
-     */
-    public enable(pattern?: string): void;
-    /**
-     * @function disable
-     * @public
-     * @returns {void}
-     *
-     * @description
-     * Disable hook execution (fast-path bypass).
-     *
-     * @example
-     * // Disable hooks
-     * manager.disable();
-     */
-    public disable(): void;
-    /**
-     * @function executeBeforeHooks
-     * @internal
-     * @private
-     * @param {string} path - Function path (e.g., "database.users.create")
-     * @param {Array} args - Function arguments
-     * @returns {{cancelled: boolean, value?: any, args: Array}} Execution result
-     *
-     * @description
-     * Execute before hooks in priority order. Returns object indicating if execution
-     * should be cancelled (short-circuited) and potentially modified arguments.
-     *
-     * Hook return semantics:
-     * - undefined: continue to next hook/function
-     * - Array: modified arguments for next hook/function
-     * - Other value: short-circuit and return this value
-     *
-     * @example
-     * // Execute before hooks
-     * const result = manager.executeBeforeHooks("database.users.create", [data]);
-     * if (result.cancelled) return result.value;
-     */
-    private executeBeforeHooks;
-    /**
-     * @function executeAfterHooks
-     * @internal
-     * @private
-     * @param {string} path - Function path
-     * @param {any} initialResult - Initial result from function
-     * @returns {any} Transformed result
-     *
-     * @description
-     * Execute after hooks in priority order, chaining results through each hook.
-     * Each hook receives the previous hook's return value (or initial result).
-     * After hooks only run if the function actually executed (not short-circuited).
-     *
-     * @example
-     * // Execute after hooks with chaining
-     * const finalResult = manager.executeAfterHooks("database.users.create", result);
-     */
-    private executeAfterHooks;
-    /**
-     * @function executeAlwaysHooks
-     * @internal
-     * @private
-     * @param {string} path - Function path
-     * @param {any} result - Final result (from function or short-circuit)
-     * @param {Array<Error>} [errors=[]] - Array of errors that occurred during execution
-     * @returns {void}
-     *
-     * @description
-     * Execute always hooks (like finally blocks). These hooks always run regardless
-     * of whether execution was short-circuited, completed normally, or threw errors.
-     * Always hooks receive full execution context including both errors and results,
-     * allowing a single hook to handle all logging scenarios.
-     *
-     * @example
-     * // Execute always hooks with success result
-     * manager.executeAlwaysHooks("database.users.create", result, []);
-     *
-     * @example
-     * // Execute always hooks with error context
-     * manager.executeAlwaysHooks("database.users.create", undefined, [error]);
-     */
-    private executeAlwaysHooks;
-    /**
-     * @function executeErrorHooks
-     * @internal
-     * @private
-     * @param {string} path - Function path
-     * @param {Error} error - Error that was thrown
-     * @param {Object} [source] - Source information about where error originated
-     * @param {string} source.type - Source type: 'before', 'function', 'after', 'always'
-     * @param {string} [source.hookId] - Hook ID if error came from a hook
-     * @param {string} [source.hookTag] - Hook tag if error came from a hook
-     * @returns {void}
-     *
-     * @description
-     * Execute error hooks (observers only, errors bubble naturally).
-     * Provides detailed context about where the error originated.
-     *
-     * @example
-     * // Execute error hooks with source info
-     * manager.executeErrorHooks("database.users.create", error, {
-     *   type: 'before',
-     *   hookId: 'hook-123',
-     *   hookTag: 'validation'
-     * });
-     */
-    private executeErrorHooks;
-    /**
-     * @function _getMatchingHooks
-     * @internal
-     * @private
-     * @param {string} type - Hook type to match
-     * @param {string} path - Function path to test against patterns
-     * @returns {Array<object>} Sorted array of matching hooks
-     *
-     * @description
-     * Get hooks matching type and path, sorted by priority (DESC) then order (ASC).
-     *
-     * @example
-     * // Get matching hooks
-     * const hooks = manager._getMatchingHooks("before", "database.users.create");
-     */
-    private _getMatchingHooks;
-    /**
-     * @function _compilePattern
-     * @internal
-     * @private
-     * @param {string} pattern - Glob pattern string
-     * @returns {RegExp|null} Compiled RegExp or null for negation patterns
-     *
-     * @description
-     * Compile glob pattern to RegExp with support for:
-     * - `*`: single-level wildcard
-     * - `**`: multi-level wildcard
-     * - `{users,posts}`: brace expansion (max 10 nesting levels)
-     * - `!internal.*`: negation patterns
-     *
-     * @example
-     * // Compile pattern
-     * const regex = manager._compilePattern("database.*.create");
-     */
-    private _compilePattern;
-    /**
-     * @function _expandBraces
-     * @internal
-     * @private
-     * @param {string} pattern - Pattern with potential braces
-     * @param {number} [depth=0] - Current nesting depth
-     * @returns {Array<string>} Expanded pattern alternatives
-     *
-     * @description
-     * Expand brace patterns like `{users,posts}` to multiple alternatives.
-     * Limits nesting to MAX_BRACE_NESTING to prevent performance issues.
-     *
-     * @example
-     * // Expand braces
-     * const patterns = manager._expandBraces("{users,posts}.create");
-     * // Returns: ["users.create", "posts.create"]
-     */
-    private _expandBraces;
-    /**
-     * @function _splitAlternatives
-     * @internal
-     * @private
-     * @param {string} str - String to split on commas
-     * @returns {Array<string>} Split alternatives
-     *
-     * @description
-     * Split brace content on commas, respecting nested braces.
-     *
-     * @example
-     * // Split alternatives
-     * const alts = manager._splitAlternatives("users,posts,{admin,guest}");
-     */
-    private _splitAlternatives;
-    /**
-     * @function _patternToRegex
-     * @internal
-     * @private
-     * @param {string} pattern - Pattern without braces
-     * @returns {string} Regex pattern string
-     *
-     * @description
-     * Convert glob pattern to regex pattern string.
-     *
-     * @example
-     * // Convert pattern
-     * const regex = manager._patternToRegex("database.*.create");
-     */
-    private _patternToRegex;
-    /**
-     * @function _matchPattern
-     * @internal
-     * @private
-     * @param {RegExp|object} compiledPattern - Compiled pattern or negation object
-     * @param {string} path - Path to test
-     * @returns {boolean} True if path matches pattern
-     *
-     * @description
-     * Test if path matches compiled pattern, handling negation.
-     *
-     * @example
-     * // Match pattern
-     * const matches = manager._matchPattern(compiledPattern, "database.users.create");
-     */
-    private _matchPattern;
-}
-//# sourceMappingURL=hooks.d.mts.map

package/types/dist/lib/helpers/hooks.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hooks.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/hooks.mjs"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;GAaG;AACH;IACC;;;;;;OAMG;IACH,sBALW,OAAO,mBACP,MAAM,YAEd;QAA0B,cAAc,GAAhC,OAAO;KACjB,EAQA;IANA,iBAAsB;IACtB,uBAAoC;IACpC,wBAAqD;IACrD,qBAAsB;IACtB,0BAA0B;IAC1B,gCAAmC;IAGpC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,gBAnBW,MAAM,QACN,MAAM,+BAOd;QAAyB,QAAQ,GAAzB,MAAM;QACW,OAAO,GAAxB,MAAM;KACd,GAAU,MAAM,CA0BlB;IAED;;;;;;;;;;OAUG;IACH,uBAKC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,0BAdW,MAAM,GACJ,OAAO,CA6BnB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,oBAdW,MAAM,GACJ,IAAI,CA0BhB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,mBAfW,MAAM,GACJ,KAAK,CAAC,MAAM,CAAC,CA4BzB;IAED;;;;;;;;;;;;OAYG;IACH,wBAVW,MAAM,GACJ,IAAI,CAchB;IAED;;;;;;;;;;;OAWG;IACH,kBATa,IAAI,CAWhB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,2BAkCC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,0BAwBC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,2BAqBC;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,0BAyBC;IAED;;;;;;;;;;;;;;OAcG;IACH,0BAkBC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,wBAmBC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,sBA4CC;IAED;;;;;;;;;;;;;OAaG;IACH,2BAuBC;IAED;;;;;;;;;;;;;OAaG;IACH,wBAiBC;IAED;;;;;;;;;;;;;;OAcG;IACH,sBAOC;CACD"}

package/types/dist/lib/helpers/instance-manager.d.mts

@@ -1,41 +0,0 @@
-/**
- * Get instance data by ID
- * @param {string} instanceId - Instance identifier
- * @returns {object|null} Instance data or null if not found
- */
-export function getInstanceData(instanceId: string): object | null;
-/**
- * Update instance data for a specific key
- * @param {string} instanceId - Instance identifier
- * @param {string} key - Data key (self, context, reference)
- * @param {any} value - Data value
- * @returns {void}
- */
-export function updateInstanceData(instanceId: string, key: string, value: any): void;
-/**
- * Clean up instance data when no longer needed
- * @param {string} instanceId - Instance identifier
- * @returns {Promise<void>}
- */
-export function cleanupInstance(instanceId: string): Promise<void>;
-/**
- * Set the currently active instance (called during module loading)
- * @param {string|null} instanceId - Instance ID to set as active
- */
-export function setActiveInstance(instanceId: string | null): void;
-/**
- * Get the current active instance ID
- * @returns {string|null} Current active instance ID
- */
-export function getCurrentActiveInstanceId(): string | null;
-/**
- * Detect current instance ID from stack trace
- * @returns {string|null} Detected instance ID or null
- */
-export function detectCurrentInstanceId(): string | null;
-/**
- * Get all registered instance IDs
- * @returns {string[]} Array of instance IDs
- */
-export function getAllInstanceIds(): string[];
-//# sourceMappingURL=instance-manager.d.mts.map

package/types/dist/lib/helpers/instance-manager.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"instance-manager.d.mts","sourceRoot":"","sources":["../../../../dist/lib/helpers/instance-manager.mjs"],"names":[],"mappings":"AAmBA;;;;GAIG;AACH,4CAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAIvB;AAED;;;;;;GAMG;AACH,+CALW,MAAM,OACN,MAAM,SACN,GAAG,GACD,IAAI,CAqBhB;AAED;;;;GAIG;AACH,4CAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CASzB;AAED;;;GAGG;AACH,8CAFW,MAAM,GAAC,IAAI,QAKrB;AAED;;;GAGG;AACH,8CAFa,MAAM,GAAC,IAAI,CAIvB;AAED;;;GAGG;AACH,2CAFa,MAAM,GAAC,IAAI,CAkCvB;AAED;;;GAGG;AACH,qCAFa,MAAM,EAAE,CAIpB"}