@but212/atom-effect 0.1.4 → 0.2.0

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@but212/atom-effect",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "type": "module",
   "description": "A reactive state management library that combines the power of `atom`, `computed`, and `effect` for seamless management of reactive state.",
-  "main": "dist/index.cjs",
-  "module": "dist/index.mjs",
-  "types": "dist/index.d.ts",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
   "files": [
     "dist"
   ],

package/dist/constants.d.ts

@@ -1,64 +0,0 @@
-/**
- * @fileoverview Constants and configuration for atom-effect library
- * @description Centralized constants for async states, bit flags, and performance tuning
- */
-/**
- * Async computation states for computed atoms
- */
-export declare const AsyncState: {
-    IDLE: "idle";
-    PENDING: "pending";
-    RESOLVED: "resolved";
-    REJECTED: "rejected";
-};
-/**
- * Bit flags for effect state management
- * Using bit flags for efficient state checks (O(1) operations)
- */
-export declare const EFFECT_STATE_FLAGS: {
-    readonly DISPOSED: number;
-    readonly EXECUTING: number;
-};
-/**
- * Bit flags for computed atom state management
- * Enables fast state transitions and checks without multiple boolean fields
- */
-export declare const COMPUTED_STATE_FLAGS: {
-    readonly DIRTY: number;
-    readonly IDLE: number;
-    readonly PENDING: number;
-    readonly RESOLVED: number;
-    readonly REJECTED: number;
-    readonly RECOMPUTING: number;
-    readonly HAS_ERROR: number;
-};
-/**
- * Object pool configuration
- * Controls memory management and GC pressure reduction
- */
-export declare const POOL_CONFIG: {
-    /** Maximum number of pooled objects to prevent memory bloat */
-    readonly MAX_SIZE: 1000;
-    /** Number of objects to pre-allocate for performance-critical paths */
-    readonly WARMUP_SIZE: 100;
-};
-/**
- * Scheduler configuration
- * Controls batching behavior and performance limits
- */
-export declare const SCHEDULER_CONFIG: {
-    /** Maximum effect executions per second to detect infinite loops */
-    readonly MAX_EXECUTIONS_PER_SECOND: 100;
-    /** Threshold for cleaning up old execution timestamps */
-    readonly CLEANUP_THRESHOLD: 100;
-};
-/**
- * Debug configuration defaults
- */
-export declare const DEBUG_CONFIG: {
-    /** Maximum dependencies before warning about large dependency graphs */
-    readonly MAX_DEPENDENCIES: 1000;
-    /** Enable infinite loop detection warnings */
-    readonly WARN_INFINITE_LOOP: true;
-};
-//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;CAKtB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;CAGrB,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;CAQvB,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,WAAW;IACtB,+DAA+D;;IAE/D,uEAAuE;;CAE/D,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,gBAAgB;IAC3B,oEAAoE;;IAEpE,yDAAyD;;CAEjD,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,YAAY;IACvB,wEAAwE;;IAExE,8CAA8C;;CAEtC,CAAC"}

package/dist/core/atom/atom.d.ts

@@ -1,25 +0,0 @@
-import { AtomOptions, WritableAtom } from '../../types';
-/**
- * Creates a new atom with the given initial value.
- *
- * @template T - The type of value stored in the atom
- * @param initialValue - The initial value of the atom
- * @param options - Optional configuration options
- * @returns A writable atom instance
- *
- * @example
- * ```ts
- * // Basic usage
- * const count = atom(0);
- *
- * // With sync option for immediate notifications
- * const syncCount = atom(0, { sync: true });
- *
- * // Reading and writing
- * console.log(count.value); // 0
- * count.value = 5;
- * console.log(count.peek()); // 5 (non-tracking read)
- * ```
- */
-export declare function atom<T>(initialValue: T, options?: AtomOptions): WritableAtom<T>;
-//# sourceMappingURL=atom.d.ts.map

package/dist/core/atom/atom.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"atom.d.ts","sourceRoot":"","sources":["../../../src/core/atom/atom.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAMH,OAAO,KAAK,EAAE,WAAW,EAAc,YAAY,EAAE,MAAM,aAAa,CAAC;AAqPzE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,OAAO,GAAE,WAAgB,GAAG,YAAY,CAAC,CAAC,CAAC,CAEnF"}

package/dist/core/atom/index.d.ts

@@ -1,6 +0,0 @@
-/**
- * @fileoverview Atom module exports
- * @description Re-exports all atom-related functionality including the atom factory function and types
- */
-export * from './atom';
-//# sourceMappingURL=index.d.ts.map

package/dist/core/atom/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/atom/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,cAAc,QAAQ,CAAC"}

package/dist/core/computed/computed-async-handler.d.ts

@@ -1,237 +0,0 @@
-import { AtomError } from '../../errors/errors';
-import { ComputedStateFlags } from './computed-state-flags';
-/**
- * Promise ID manager to prevent race conditions in async computed values.
- *
- * @description
- * Generates and tracks unique IDs for async computations. When a new computation
- * starts, it receives a new ID. If a previous computation completes after a newer
- * one has started, its ID will no longer be valid, and its result will be discarded.
- *
- * @remarks
- * - IDs are monotonically increasing integers
- * - Overflow protection wraps around at MAX_SAFE_INTEGER
- * - Thread-safe for single-threaded JavaScript execution
- *
- * @example
- * ```ts
- * const manager = new PromiseIdManager();
- *
- * const id1 = manager.next(); // 1
- * const id2 = manager.next(); // 2
- *
- * manager.isValid(id1); // false - superseded by id2
- * manager.isValid(id2); // true - current ID
- *
- * manager.invalidate(); // Increments to 3, invalidating id2
- * ```
- */
-export declare class PromiseIdManager {
-    /**
-     * The most recently generated Promise ID.
-     * Used to track the current/latest computation.
-     * @private
-     */
-    private lastPromiseId;
-    /**
-     * Maximum allowed Promise ID before overflow wrap-around.
-     * Set to MAX_SAFE_INTEGER - 1 to ensure safe increment operations.
-     * @private
-     * @readonly
-     */
-    private readonly MAX_PROMISE_ID;
-    /**
-     * Generates the next unique Promise ID with overflow protection.
-     *
-     * @description
-     * Increments the internal counter and returns the new ID.
-     * If the counter reaches MAX_SAFE_INTEGER, it wraps around to 0
-     * to prevent integer overflow issues.
-     *
-     * @returns A new unique Promise ID
-     *
-     * @example
-     * ```ts
-     * const manager = new PromiseIdManager();
-     * const id = manager.next(); // Returns 1, 2, 3, ...
-     * ```
-     */
-    next(): number;
-    /**
-     * Gets the current (most recent) Promise ID without incrementing.
-     *
-     * @description
-     * Returns the ID of the most recently started computation.
-     * Useful for checking the current state without side effects.
-     *
-     * @returns The current Promise ID
-     *
-     * @example
-     * ```ts
-     * const manager = new PromiseIdManager();
-     * manager.next(); // 1
-     * manager.current(); // 1 (doesn't increment)
-     * ```
-     */
-    current(): number;
-    /**
-     * Checks if a Promise ID is still valid (not superseded by newer computation).
-     *
-     * @description
-     * A Promise ID is valid only if it matches the current ID, meaning no newer
-     * computation has been started since this ID was generated.
-     *
-     * @param id - The Promise ID to validate
-     * @returns true if the ID is current and valid, false if superseded
-     *
-     * @example
-     * ```ts
-     * const manager = new PromiseIdManager();
-     * const id1 = manager.next(); // 1
-     * manager.isValid(id1); // true
-     *
-     * const id2 = manager.next(); // 2
-     * manager.isValid(id1); // false - superseded
-     * manager.isValid(id2); // true
-     * ```
-     */
-    isValid(id: number): boolean;
-    /**
-     * Invalidates all previous computations by incrementing the Promise ID.
-     *
-     * @description
-     * Call this method to cancel/ignore results from all pending computations.
-     * Useful when manually triggering a recomputation or during cleanup.
-     *
-     * @example
-     * ```ts
-     * const manager = new PromiseIdManager();
-     * const id = manager.next();
-     * manager.isValid(id); // true
-     *
-     * manager.invalidate();
-     * manager.isValid(id); // false - invalidated
-     * ```
-     */
-    invalidate(): void;
-}
-/**
- * Async computation handler for computed atoms.
- *
- * @description
- * Manages the complete lifecycle of asynchronous computations:
- * 1. Sets pending state when computation starts
- * 2. Handles successful resolution with value updates
- * 3. Handles rejection with error state management
- * 4. Prevents race conditions using PromiseIdManager
- * 5. Notifies subscribers of state changes
- *
- * @template T - The type of value produced by the async computation
- *
- * @remarks
- * - Only the most recent computation's result is applied
- * - State transitions: IDLE → PENDING → RESOLVED | REJECTED
- * - Subscribers are notified on value changes and errors
- * - Custom error handlers are supported via onError callback
- *
- * @example
- * ```ts
- * const handler = new AsyncComputationHandler<User>(
- *   stateFlags,
- *   promiseIdManager,
- *   (a, b) => a.id === b.id, // equality function
- *   (error) => console.error(error), // error handler
- *   () => notifyAllSubscribers() // notification callback
- * );
- *
- * // Handle an async computation
- * handler.handle(
- *   fetchUser(userId),
- *   () => currentUser,
- *   (user) => { currentUser = user; },
- *   (error) => { lastError = error; }
- * );
- * ```
- */
-export declare class AsyncComputationHandler<T> {
-    private stateFlags;
-    private promiseIdManager;
-    private equal;
-    private onError;
-    private notifySubscribers;
-    /**
-     * Creates a new AsyncComputationHandler instance.
-     *
-     * @param stateFlags - State manager for tracking computation status
-     * @param promiseIdManager - Manager for race condition prevention
-     * @param equal - Equality function to compare values
-     * @param onError - Optional error callback
-     * @param notifySubscribers - Callback to notify subscribers of changes
-     */
-    constructor(stateFlags: ComputedStateFlags, promiseIdManager: PromiseIdManager, equal: (a: T, b: T) => boolean, onError: ((error: Error) => void) | null, notifySubscribers: () => void);
-    /**
-     * Handles an async computation Promise.
-     *
-     * @description
-     * Initiates handling of a Promise-based computation:
-     * 1. Sets state to PENDING
-     * 2. Generates a unique Promise ID for race condition tracking
-     * 3. Attaches then/catch handlers for resolution/rejection
-     * 4. Validates Promise ID before applying results
-     *
-     * @param result - The Promise to handle
-     * @param getValue - Getter function for the current cached value
-     * @param setValue - Setter function for updating the cached value
-     * @param setError - Setter function for error state
-     *
-     * @example
-     * ```ts
-     * handler.handle(
-     *   fetch('/api/data').then(r => r.json()),
-     *   () => cachedData,
-     *   (data) => { cachedData = data; },
-     *   (error) => { lastError = error; }
-     * );
-     * ```
-     */
-    handle(result: Promise<T>, getValue: () => T, setValue: (value: T) => void, setError: (error: AtomError | null) => void): void;
-    /**
-     * Handles successful Promise resolution.
-     *
-     * @description
-     * Called when an async computation completes successfully:
-     * 1. Determines if the value has changed (using equality function)
-     * 2. Updates the cached value
-     * 3. Clears dirty flag and sets resolved state
-     * 4. Clears any previous error
-     * 5. Notifies subscribers if value changed
-     *
-     * @private
-     * @param resolvedValue - The resolved value from the Promise
-     * @param getValue - Getter for current cached value
-     * @param setValue - Setter for cached value
-     * @param setError - Setter for error state
-     */
-    private handleResolution;
-    /**
-     * Handles Promise rejection.
-     *
-     * @description
-     * Called when an async computation fails:
-     * 1. Wraps the error in a ComputedError for consistent error handling
-     * 2. Sets the error state
-     * 3. Updates state flags to rejected
-     * 4. Invokes the onError callback if provided
-     * 5. Notifies subscribers of the error state
-     *
-     * @private
-     * @param err - The error/rejection reason from the Promise
-     * @param setError - Setter for error state
-     *
-     * @remarks
-     * Errors in the onError callback are caught and logged to prevent
-     * cascading failures.
-     */
-    private handleRejection;
-}
-//# sourceMappingURL=computed-async-handler.d.ts.map

package/dist/core/computed/computed-async-handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"computed-async-handler.d.ts","sourceRoot":"","sources":["../../../src/core/computed/computed-async-handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAGrD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,gBAAgB;IAC3B;;;;OAIG;IACH,OAAO,CAAC,aAAa,CAAK;IAE1B;;;;;OAKG;IACH,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA+B;IAE9D;;;;;;;;;;;;;;;OAeG;IACH,IAAI,IAAI,MAAM;IAQd;;;;;;;;;;;;;;;OAeG;IACH,OAAO,IAAI,MAAM;IAIjB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAI5B;;;;;;;;;;;;;;;;OAgBG;IACH,UAAU,IAAI,IAAI;CAGnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,qBAAa,uBAAuB,CAAC,CAAC;IAWlC,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,iBAAiB;IAd3B;;;;;;;;OAQG;gBAEO,UAAU,EAAE,kBAAkB,EAC9B,gBAAgB,EAAE,gBAAgB,EAClC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,EAC9B,OAAO,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,IAAI,EACxC,iBAAiB,EAAE,MAAM,IAAI;IAGvC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,MAAM,CACJ,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,EAClB,QAAQ,EAAE,MAAM,CAAC,EACjB,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EAC5B,QAAQ,EAAE,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,KAAK,IAAI,GAC1C,IAAI;IAoBP;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,gBAAgB;IAmBxB;;;;;;;;;;;;;;;;;;OAkBG;IACH,OAAO,CAAC,eAAe;CAkBxB"}

package/dist/core/computed/computed-dependencies.d.ts

@@ -1,173 +0,0 @@
-import { DependencyManager } from '../../tracking/dependency-manager';
-/**
- * Manages dependency synchronization for computed values.
- *
- * Uses a delta sync algorithm to efficiently update dependencies by:
- * 1. Fast path: O(1) check if no changes occurred
- * 2. Slow path: Only subscribe/unsubscribe changed dependencies
- *
- * @example
- * ```typescript
- * const syncManager = new DependencySyncManager(depManager, computed, markDirty);
- *
- * // During recomputation, collect new dependencies
- * const newDeps = new Set<unknown>();
- * // ... computation that populates newDeps ...
- *
- * // Efficiently sync dependencies
- * syncManager.update(newDeps);
- * ```
- *
- * @remarks
- * - WeakMap is used internally for automatic garbage collection
- * - Circular dependency detection is performed on each new subscription
- * - Thread-safe for single-threaded JavaScript execution
- */
-export declare class DependencySyncManager {
-    private dependencyManager;
-    private computedObject;
-    private markDirty;
-    /**
-     * Creates a new DependencySyncManager instance.
-     *
-     * @param dependencyManager - The underlying dependency manager for subscription handling
-     * @param computedObject - Reference to the computed object for circular detection
-     * @param markDirty - Callback invoked when any dependency changes
-     *
-     * @throws If dependencyManager is null or undefined
-     */
-    constructor(dependencyManager: DependencyManager, computedObject: unknown, markDirty: () => void);
-    /**
-     * Updates dependencies using the delta sync algorithm.
-     *
-     * This method compares the current dependencies with new ones and
-     * performs minimal subscription changes for optimal performance.
-     *
-     * @param newDeps - Set of dependencies detected during the latest computation
-     *
-     * @remarks
-     * Performance characteristics:
-     * - Best case (no changes): O(n) where n is dependency count
-     * - Worst case (all changed): O(n + m) where m is new dependency count
-     *
-     * @example
-     * ```typescript
-     * const newDeps = new Set([atomA, atomB, computedC]);
-     * syncManager.update(newDeps);
-     * ```
-     */
-    update(newDeps: Set<unknown>): void;
-    /**
-     * Checks if current dependencies are identical to new dependencies.
-     *
-     * This is the fast path optimization that avoids expensive subscription
-     * operations when dependencies haven't changed.
-     *
-     * @param current - Array of current dependencies
-     * @param newDeps - Set of new dependencies to compare
-     * @returns True if dependencies are identical, false otherwise
-     *
-     * @remarks
-     * Time complexity: O(n) where n is the number of current dependencies
-     * Space complexity: O(1)
-     */
-    private hasSameDependencies;
-    /**
-     * Performs delta synchronization between current and new dependencies.
-     *
-     * This method:
-     * 1. Identifies dependencies to remove (in current but not in new)
-     * 2. Identifies dependencies to add (in new but not in current)
-     * 3. Unsubscribes from removed dependencies
-     * 4. Subscribes to new dependencies
-     * 5. Updates the internal dependency array
-     *
-     * @param current - Array of current dependencies (will be mutated)
-     * @param newDeps - Set of new dependencies
-     *
-     * @remarks
-     * Time complexity: O(n + m) where n is current count and m is new count
-     * Space complexity: O(n + m) for temporary sets and arrays
-     */
-    private performDeltaSync;
-    /**
-     * Adds a single dependency with circular reference detection.
-     *
-     * @param dep - The dependency to add and subscribe to
-     *
-     * @throws If circular dependency is detected
-     * @throws If subscription fails for any reason
-     *
-     * @remarks
-     * This method performs circular reference detection before subscribing
-     * to prevent infinite loops in the dependency graph.
-     */
-    private addDependency;
-    /**
-     * Gets the current number of active dependencies.
-     *
-     * @returns The count of dependencies currently being tracked
-     *
-     * @remarks
-     * This count may be less than the total subscriptions made if some
-     * dependencies have been garbage collected (due to WeakRef usage).
-     */
-    getDependencyCount(): number;
-    /**
-     * Checks if dependency count exceeds the configured threshold and warns.
-     *
-     * Large dependency graphs can indicate architectural issues and may
-     * cause performance problems. This method helps identify such cases.
-     *
-     * @remarks
-     * The warning threshold is configured via `debug.maxDependencies`.
-     * Warnings are only emitted in development mode when debug is enabled.
-     *
-     * @see {@link debug.maxDependencies} for threshold configuration
-     */
-    checkDependencyLimit(): void;
-}
-/**
- * Temporary dependency tracker returned by createDependencyTracker.
- *
- * @remarks
- * This type combines a callable function with dependency tracking methods.
- */
-export type DependencyTrackerFunction = (() => void) & {
-    /**
-     * Adds a dependency to be tracked during computation.
-     * @param dep - The dependency to track
-     */
-    addDependency: (dep: unknown) => void;
-    /**
-     * Gets all collected dependencies.
-     * @returns Set of all tracked dependencies
-     */
-    getDependencies: () => Set<unknown>;
-};
-/**
- * Creates a temporary dependency tracker for a single computation cycle.
- *
- * This factory function creates a tracker that collects dependencies
- * during a computation and can be used with the tracking context.
- *
- * @param markDirty - Callback to invoke when the computation needs rerun
- * @returns A tracking function with addDependency and getDependencies methods
- *
- * @example
- * ```typescript
- * const tracker = createDependencyTracker(() => markDirty());
- *
- * // Use in tracking context
- * const result = trackingContext.run(tracker, computeFn);
- *
- * // Get collected dependencies
- * const deps = tracker.getDependencies();
- * ```
- *
- * @remarks
- * The returned tracker is designed for single-use during one computation.
- * Create a new tracker for each recomputation cycle.
- */
-export declare function createDependencyTracker(markDirty: () => void): DependencyTrackerFunction;
-//# sourceMappingURL=computed-dependencies.d.ts.map

package/dist/core/computed/computed-dependencies.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"computed-dependencies.d.ts","sourceRoot":"","sources":["../../../src/core/computed/computed-dependencies.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAI3E;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,qBAAqB;IAW9B,OAAO,CAAC,iBAAiB;IACzB,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,SAAS;IAZnB;;;;;;;;OAQG;gBAEO,iBAAiB,EAAE,iBAAiB,EACpC,cAAc,EAAE,OAAO,EACvB,SAAS,EAAE,MAAM,IAAI;IAG/B;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAAM,CAAC,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC,GAAG,IAAI;IAYnC;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,mBAAmB;IAc3B;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,gBAAgB;IAqCxB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,aAAa;IAWrB;;;;;;;;OAQG;IACH,kBAAkB,IAAI,MAAM;IAI5B;;;;;;;;;;;OAWG;IACH,oBAAoB,IAAI,IAAI;CAI7B;AAED;;;;;GAKG;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG;IACrD;;;OAGG;IACH,aAAa,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAC;IAEtC;;;OAGG;IACH,eAAe,EAAE,MAAM,GAAG,CAAC,OAAO,CAAC,CAAC;CACrC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,IAAI,GAAG,yBAAyB,CAOxF"}