mutts 1.0.11 → 1.0.13

package/dist/index.d.ts

@@ -1,1322 +0,0 @@
-import { c as EffectAccess, d as EffectCloser, S as ScopedCallback, e as State, a as Evolution, b as EffectCleanup, Z as ZoneAggregator, C as CleanupReason, H as HistoryValue, E as EffectTrigger, f as CatchFunction, g as EffectOptions } from './types-Bx2PhORg.js';
-export { A as AZone, G as GetterWrapper, P as PropTrigger, R as ReactiveError, h as ReactiveErrorCode, i as Zone, j as ZoneHistory, k as asyncZone, l as debugPreset, m as devPreset, n as formatCleanupReason, o as isReactive, p as objectToProxy, q as prodPreset, r as proxyToObject, s as reactiveOptions, u as unwrap } from './types-Bx2PhORg.js';
-
-type Restorer = () => () => void;
-type Hook = () => Restorer;
-declare const hooks$1: Set<Hook>;
-declare const asyncHooks: {
-    addHook(hook: Hook): () => void;
-    /**
-     * [Hack] Sanitize a promise (or value) to prevent context leaks.
-     * Default: Identity function.
-     * Browser: Uses Macrotask wrapping to break microtask chains.
-     */
-    sanitizePromise(p: any): any;
-};
-/**
- * Register a hook that will be called whenever an asynchronous operation is initiated.
- * The hook should return a restorer function which will be called just before the async callback runs.
- * That restorer should in turn return an undoer function which will be called just after the async callback finishes.
- */
-declare const asyncHook: (hook: Hook) => () => void;
-
-/**
- * Error thrown when decorator operations fail
- */
-declare class DecoratorError extends Error {
-    constructor(message: string);
-}
-/**
- * Legacy property decorator type for methods, getters, and setters
- */
-type LegacyPropertyDecorator<T> = (target: T, name: string | symbol, descriptor: PropertyDescriptor) => any;
-/**
- * Legacy class decorator type
- */
-type LegacyClassDecorator<T> = (target: T) => any;
-/**
- * Modern method decorator type
- */
-type ModernMethodDecorator<T> = (target: T, context: ClassMethodDecoratorContext) => any;
-/**
- * Modern getter decorator type
- */
-type ModernGetterDecorator<T> = (target: T, context: ClassGetterDecoratorContext) => any;
-/**
- * Modern setter decorator type
- */
-type ModernSetterDecorator<T> = (target: T, context: ClassSetterDecoratorContext) => any;
-/**
- * Modern accessor decorator type
- */
-type ModernAccessorDecorator<T> = (target: T, context: ClassAccessorDecoratorContext) => any;
-/**
- * Modern class decorator type
- */
-type ModernClassDecorator<T> = (target: T, context: ClassDecoratorContext) => any;
-type DDMethod<T> = (original: (this: T, ...args: any[]) => any, target: any, name: PropertyKey) => ((this: T, ...args: any[]) => any) | void;
-type DDGetter<T> = (original: (this: T) => any, target: any, name: PropertyKey) => ((this: T) => any) | void;
-type DDSetter<T> = (original: (this: T, value: any) => void, target: any, name: PropertyKey) => ((this: T, value: any) => void) | void;
-type DDClass<T> = <Ctor extends new (...args: any[]) => T = new (...args: any[]) => T>(target: Ctor) => Ctor | void;
-/**
- * Description object for creating decorators that work with both Legacy and Modern decorator proposals
- */
-interface DecoratorDescription<T> {
-    /** Handler for method decorators */
-    method?: DDMethod<T>;
-    /** Handler for class decorators */
-    class?: DDClass<T>;
-    /** Handler for getter decorators */
-    getter?: DDGetter<T>;
-    /** Handler for setter decorators */
-    setter?: DDSetter<T>;
-    /** Default handler for any decorator type not explicitly defined */
-    default?: (...args: any[]) => any;
-}
-/**
- * Type for decorators that work with both Legacy and Modern decorator proposals
- * Automatically infers the correct decorator type based on the description
- */
-type Decorator<T, Description extends DecoratorDescription<T>> = (Description extends {
-    method: DDMethod<T>;
-} ? LegacyPropertyDecorator<T> & ModernMethodDecorator<T> : unknown) & (Description extends {
-    class: DDClass<new (...args: any[]) => T>;
-} ? LegacyClassDecorator<new (...args: any[]) => T> & ModernClassDecorator<new (...args: any[]) => T> : unknown) & (Description extends {
-    getter: DDGetter<T>;
-} ? LegacyPropertyDecorator<T> & ModernGetterDecorator<T> & ModernAccessorDecorator<T> : unknown) & (Description extends {
-    setter: DDSetter<T>;
-} ? LegacyPropertyDecorator<T> & ModernSetterDecorator<T> & ModernAccessorDecorator<T> : unknown) & (Description extends {
-    default: infer Signature;
-} ? Signature : unknown);
-/**
- * Factory type for creating decorators that work with both Legacy and Modern decorator proposals
- */
-type DecoratorFactory<T> = <Description extends DecoratorDescription<T>>(description: Description) => (Description extends {
-    method: DDMethod<T>;
-} ? LegacyPropertyDecorator<T> & ModernMethodDecorator<T> : unknown) & (Description extends {
-    class: DDClass<new (...args: any[]) => T>;
-} ? LegacyClassDecorator<new (...args: any[]) => T> & ModernClassDecorator<new (...args: any[]) => T> : unknown) & (Description extends {
-    getter: DDGetter<T>;
-} ? LegacyPropertyDecorator<T> & ModernGetterDecorator<T> & ModernAccessorDecorator<T> : unknown) & (Description extends {
-    setter: DDSetter<T>;
-} ? LegacyPropertyDecorator<T> & ModernSetterDecorator<T> & ModernAccessorDecorator<T> : unknown) & (Description extends {
-    default: infer Signature;
-} ? Signature : unknown);
-/**
- * Creates a decorator that works with Legacy decorator proposals
- * @param description - The decorator description object
- * @returns A decorator function compatible with Legacy decorators
- */
-declare function legacyDecorator<T = any>(description: DecoratorDescription<T>): any;
-/**
- * Creates a decorator that works with Modern decorator proposals
- * @param description - The decorator description object
- * @returns A decorator function compatible with Modern decorators
- */
-declare function modernDecorator<T = any>(description: DecoratorDescription<T>): any;
-/**
- * Main decorator factory that automatically detects and works with both Legacy and Modern decorator proposals
- * @param description - The decorator description object
- * @returns A decorator that works in both Legacy and Modern environments
- */
-declare const decorator: DecoratorFactory<any>;
-/**
- * Generic class decorator type that works with both Legacy and Modern decorator proposals
- */
-type GenericClassDecorator<T> = LegacyClassDecorator<abstract new (...args: any[]) => T> & ModernClassDecorator<abstract new (...args: any[]) => T>;
-
-/**
- * Symbol for marking destructor methods
- */
-declare const destructor: unique symbol;
-/**
- * Symbol for accessing allocated values in destroyable objects
- */
-declare const allocatedValues: unique symbol;
-/**
- * Error thrown when attempting to access a destroyed object
- */
-declare class DestructionError extends Error {
-    static throw<_T = void>(msg: string): () => never;
-    constructor(msg: string);
-}
-declare abstract class AbstractDestroyable<Allocated> {
-    abstract [destructor](allocated: Allocated): void;
-    [Symbol.dispose](): void;
-}
-interface Destructor<Allocated> {
-    destructor(allocated: Allocated): void;
-}
-/**
- * Creates a destroyable class with a base class and destructor object
- * @param base - The base class to extend
- * @param destructorObj - Object containing the destructor method
- * @returns A destroyable class with static destroy and isDestroyable methods
- */
-declare function Destroyable<T extends new (...args: any[]) => any, Allocated extends Partial<InstanceType<T>>>(base: T, destructorObj: Destructor<Allocated>): (new (...args: ConstructorParameters<T>) => InstanceType<T> & {
-    [allocatedValues]: Allocated;
-}) & {
-    destroy(obj: InstanceType<T>): boolean;
-    isDestroyable(obj: InstanceType<T>): boolean;
-};
-/**
- * Creates a destroyable class with only a destructor object (no base class)
- * @param destructorObj - Object containing the destructor method
- * @returns A destroyable class with static destroy and isDestroyable methods
- */
-declare function Destroyable<Allocated extends Record<PropertyKey, any> = Record<PropertyKey, any>>(destructorObj: Destructor<Allocated>): (new () => {
-    [allocatedValues]: Allocated;
-}) & {
-    destroy(obj: any): boolean;
-    isDestroyable(obj: any): boolean;
-};
-/**
- * Creates a destroyable class with a base class (requires [destructor] method)
- * @param base - The base class to extend
- * @returns A destroyable class with static destroy and isDestroyable methods
- */
-declare function Destroyable<T extends new (...args: any[]) => any, Allocated extends Record<PropertyKey, any> = Record<PropertyKey, any>>(base: T): (new (...args: ConstructorParameters<T>) => AbstractDestroyable<Allocated> & InstanceType<T> & {
-    [allocatedValues]: Allocated;
-}) & {
-    destroy(obj: InstanceType<T>): boolean;
-    isDestroyable(obj: InstanceType<T>): boolean;
-};
-/**
- * Creates an abstract destroyable base class
- * @returns An abstract destroyable class with static destroy and isDestroyable methods
- */
-declare function Destroyable<Allocated extends Record<PropertyKey, any> = Record<PropertyKey, any>>(): abstract new () => (AbstractDestroyable<Allocated> & {
-    [allocatedValues]: Allocated;
-}) & {
-    destroy(obj: any): boolean;
-    isDestroyable(obj: any): boolean;
-};
-/**
- * Decorator that marks properties to be stored in the allocated object and passed to the destructor
- * Use with accessor properties or explicit get/set pairs
- */
-declare const allocated: LegacyPropertyDecorator<any> & ModernSetterDecorator<any> & ModernAccessorDecorator<any>;
-/**
- * Registers a callback to be called when an object is garbage collected
- * @param cb - The callback function to execute on garbage collection
- * @returns The object whose reference can be collected
- */
-declare function callOnGC(cb: () => void): () => void;
-/**
- * Context Manager Protocol for `using` statement integration
- * Provides automatic resource cleanup when used with the `using` statement
- */
-interface ContextManager<T = any> {
-    [Symbol.dispose](): void;
-    value?: T;
-}
-
-interface ArrayDiffResult<T> {
-    indexA: number;
-    indexB: number;
-    sliceA: T[];
-    sliceB: T[];
-}
-/**
- * Myers' diff producing grouped patches: `{indexA, indexB, sliceA, sliceB}[]`.
- * - O(N) for identical or prefix/suffix-only differences
- * - O(ND) for small D, with a hard bailout at D=BAILOUT_D → single replacement patch
- */
-declare function arrayDiff<T>(A: readonly T[], B: readonly T[]): ArrayDiffResult<T>[];
-
-/**
- * Base type for event maps - all event handlers must be functions
- */
-type EventsBase = Record<string, (...args: any[]) => void>;
-declare const events: unique symbol;
-declare const hooks: unique symbol;
-/**
- * A type-safe event system that provides a clean API for event handling
- * @template Events - The event map defining event names and their handler signatures
- */
-declare class Eventful<Events extends EventsBase> {
-    private readonly [events];
-    private readonly [hooks];
-    hook(cb: <EventType extends keyof Events>(event: EventType, ...args: Parameters<Events[EventType]>) => void): () => void;
-    on: ((events: Partial<Events>) => void) & (<EventType extends keyof Events>(event: EventType, cb: Events[EventType]) => () => void) & { [event in keyof Events]: (cb: Events[event]) => () => void; };
-    off: ((events: Partial<Events>) => void) & (<EventType extends keyof Events>(event: EventType, cb?: Events[EventType]) => void) & { [event in keyof Events]: (cb?: Events[event]) => void; };
-    emit: (<EventType extends keyof Events>(event: EventType, ...args: Parameters<Events[EventType]>) => void) & Events;
-}
-
-/**
- * Creates a flavored (extensible) version of a function with chainable property modifiers.
- */
-declare function flavored<T extends (...args: any[]) => any, F>(fn: T, flavors: F & ThisType<T & F>): T & F;
-/**
- * Creates a new flavored function that transforms arguments before calling the base.
- *
- * @param fn - The base flavored function
- * @param transform - Function that receives the original arguments and returns transformed arguments
- * @returns A new flavored function with the transformation applied
- *
- * @example
- * ```typescript
- * const loudGreet = createFlavor(greet, (name, opts) => [name, { ...opts, loud: true }])
- * ```
- */
-declare function createFlavor<T extends (...args: any[]) => any>(fn: T, transform: (...args: Parameters<T>) => Parameters<T>, name?: string): T;
-/**
- * Creates a new flavored function that merges options objects at a specific index.
- * By default, uses the function's arity (length) as the index for options.
- *
- * @param fn - The base flavored function
- * @param defaultOptions - Options to merge
- * @param optionsIndex - Optional explicit index for options (defaults to fn.length)
- * @param name - Optional name for the wrapper
- * @returns A new flavored function
- */
-declare function flavorOptions<T extends (...args: any[]) => any>(fn: T, defaultOptions: Record<string, any>, opts?: {
-    optionsIndex?: number;
-    name?: string;
-}): T;
-
-/**
- * Symbol for defining custom getter logic for numeric index access
- */
-declare const getAt: unique symbol;
-/**
- * Symbol for defining custom setter logic for numeric index access
- */
-declare const setAt: unique symbol;
-interface IndexingAt<Items = any> {
-    [getAt](index: number): Items;
-}
-interface Accessor<T, Items> {
-    get(this: T, index: number): Items;
-    set?(this: T, index: number, value: Items): void;
-    getLength?(this: T): number;
-    setLength?(this: T, value: number): void;
-}
-declare abstract class AbstractGetAt<Items = any> {
-    abstract [getAt](index: number): Items;
-}
-/**
- * Creates an indexable class with a base class and accessor object
- * @param base - The base class to extend
- * @param accessor - Object containing get/set methods for numeric index access
- * @returns A class that supports numeric index access
- */
-declare function Indexable<Items, Base extends abstract new (...args: any[]) => any>(base: Base, accessor: Accessor<InstanceType<Base>, Items>): new (...args: ConstructorParameters<Base>) => InstanceType<Base> & {
-    [x: number]: Items;
-};
-/**
- * Creates an indexable class with only an accessor object (no base class)
- * @param accessor - Object containing get/set methods for numeric index access
- * @returns A class that supports numeric index access
- */
-declare function Indexable<Items>(accessor: Accessor<any, Items>): new () => {
-    [x: number]: Items;
-};
-/**
- * Creates an indexable class with a base class that has [getAt] method
- * @param base - The base class that implements [getAt] method
- * @returns A class that supports numeric index access using the base class's [getAt] method
- */
-declare function Indexable<Base extends new (...args: any[]) => IndexingAt>(base: Base): new (...args: ConstructorParameters<Base>) => InstanceType<Base> & {
-    [x: number]: AtReturnType<InstanceType<Base>>;
-};
-/**
- * Creates an abstract indexable base class
- * @returns An abstract class that supports numeric index access
- */
-declare function Indexable<Items>(): abstract new (...args: any[]) => AbstractGetAt & {
-    [x: number]: Items;
-};
-type AtReturnType<T> = T extends {
-    [getAt](index: number): infer R;
-} ? R : never;
-/**
- * Symbol for accessing the forwarded array in ArrayReadForward
- */
-declare const forwardArray: unique symbol;
-/**
- * A read-only array forwarder that implements all reading/iterating methods of Array
- * but does not implement modification methods.
- *
- * The constructor takes a callback that returns an array, and all methods forward
- * their behavior to the result of that callback.
- */
-declare class ArrayReadForward<T> {
-    protected get [forwardArray](): readonly T[];
-    /**
-     * Get the length of the array
-     */
-    get length(): number;
-    /**
-     * Get an element at a specific index
-     */
-    [index: number]: T | undefined;
-    /**
-     * Iterator protocol support
-     */
-    [Symbol.iterator](): Iterator<T>;
-    /**
-     * Creates a new array with the results of calling a provided function on every element
-     */
-    map<U>(callbackfn: (value: T, index: number, array: readonly T[]) => U, thisArg?: any): U[];
-    /**
-     * Creates a new array with all elements that pass the test implemented by the provided function
-     */
-    filter<S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): S[];
-    filter(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): T[];
-    /**
-     * Executes a reducer function on each element of the array, resulting in a single output value
-     */
-    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T): T;
-    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T, initialValue: T): T;
-    reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: readonly T[]) => U, initialValue: U): U;
-    /**
-     * Executes a reducer function on each element of the array (right-to-left), resulting in a single output value
-     */
-    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T): T;
-    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T, initialValue: T): T;
-    reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: readonly T[]) => U, initialValue: U): U;
-    /**
-     * Executes a provided function once for each array element
-     */
-    forEach(callbackfn: (value: T, index: number, array: readonly T[]) => void, thisArg?: any): void;
-    /**
-     * Returns the value of the first element in the array that satisfies the provided testing function
-     */
-    find<S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): S | undefined;
-    find(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): T | undefined;
-    /**
-     * Returns the index of the first element in the array that satisfies the provided testing function
-     */
-    findIndex(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): number;
-    /**
-     * Returns the value of the last element in the array that satisfies the provided testing function
-     */
-    findLast<S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): S | undefined;
-    findLast(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): T | undefined;
-    /**
-     * Returns the index of the last element in the array that satisfies the provided testing function
-     */
-    findLastIndex(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): number;
-    /**
-     * Determines whether an array includes a certain value among its entries
-     */
-    includes(searchElement: T, fromIndex?: number): boolean;
-    /**
-     * Returns the first index at which a given element can be found in the array
-     */
-    indexOf(searchElement: T, fromIndex?: number): number;
-    /**
-     * Returns the last index at which a given element can be found in the array
-     */
-    lastIndexOf(searchElement: T, fromIndex?: number): number;
-    /**
-     * Returns a shallow copy of a portion of an array into a new array object
-     */
-    slice(start?: number, end?: number): T[];
-    /**
-     * Returns a new array comprised of this array joined with other array(s) and/or value(s)
-     */
-    concat(...items: ConcatArray<T>[]): T[];
-    concat(...items: (T | ConcatArray<T>)[]): T[];
-    /**
-     * Tests whether all elements in the array pass the test implemented by the provided function
-     */
-    every(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): boolean;
-    /**
-     * Tests whether at least one element in the array passes the test implemented by the provided function
-     */
-    some(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): boolean;
-    /**
-     * Joins all elements of an array into a string
-     */
-    join(separator?: string): string;
-    /**
-     * Returns a new array iterator that contains the keys for each index in the array
-     */
-    keys(): IterableIterator<number>;
-    /**
-     * Returns a new array iterator that contains the values for each index in the array
-     */
-    values(): IterableIterator<T>;
-    /**
-     * Returns a new array iterator that contains the key/value pairs for each index in the array
-     */
-    entries(): IterableIterator<[number, T]>;
-    /**
-     * Returns a string representation of the array
-     */
-    toString(): string;
-    /**
-     * Returns a localized string representing the array
-     */
-    toLocaleString(locales?: string | string[], options?: Intl.NumberFormatOptions | Intl.DateTimeFormatOptions): string;
-    /**
-     * Returns the element at the specified index, or undefined if the index is out of bounds
-     */
-    at(index: number): T | undefined;
-    /**
-     * Returns a new array with all sub-array elements concatenated into it recursively up to the specified depth
-     */
-    flat(depth?: number): T[];
-    /**
-     * Returns a new array formed by applying a given callback function to each element of the array,
-     * and then flattening the result by one level
-     */
-    flatMap<U, This = undefined>(callback: (this: This, value: T, index: number, array: readonly T[]) => U | ReadonlyArray<U>, thisArg?: This): U[];
-    /**
-     * Returns a new array with elements in reversed order (ES2023)
-     */
-    toReversed(): T[];
-    /**
-     * Returns a new array with elements sorted (ES2023)
-     */
-    toSorted(compareFn?: ((a: T, b: T) => number) | undefined): T[];
-    /**
-     * Returns a new array with some elements removed and/or replaced at a given index (ES2023)
-     */
-    toSpliced(start: number, deleteCount?: number, ...items: T[]): T[];
-    /**
-     * Returns a new array with the element at the given index replaced with the given value (ES2023)
-     */
-    with(index: number, value: T): T[];
-    get [Symbol.unscopables](): {
-        readonly [x: number]: boolean;
-        readonly length?: boolean;
-        toString?: boolean;
-        toLocaleString?: boolean;
-        concat?: boolean;
-        join?: boolean;
-        slice?: boolean;
-        indexOf?: boolean;
-        lastIndexOf?: boolean;
-        every?: boolean;
-        some?: boolean;
-        forEach?: boolean;
-        map?: boolean;
-        filter?: boolean;
-        reduce?: boolean;
-        reduceRight?: boolean;
-        find?: boolean;
-        findIndex?: boolean;
-        entries?: boolean;
-        keys?: boolean;
-        values?: boolean;
-        includes?: boolean;
-        flatMap?: boolean;
-        flat?: boolean;
-        at?: boolean;
-        findLast?: boolean;
-        findLastIndex?: boolean;
-        toReversed?: boolean;
-        toSorted?: boolean;
-        toSpliced?: boolean;
-        with?: boolean;
-        [Symbol.iterator]?: boolean;
-        readonly [Symbol.unscopables]?: boolean;
-    };
-}
-
-/**
- * Uses weak references but still may iterate through them
- * Note: The behavior is highly dependant on the garbage collector - some entries are perhaps deemed to be collected: don't resuscitate them
- */
-declare class IterableWeakMap<K extends WeakKey, V> implements Map<K, V> {
-    private uuids;
-    private refs;
-    private readonly registry;
-    constructor(entries?: Iterable<[K, V]>);
-    private createIterator;
-    clear(): void;
-    delete(key: K): boolean;
-    forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
-    get(key: K): V | undefined;
-    has(key: K): boolean;
-    set(key: K, value: V): this;
-    get size(): number;
-    entries(): MapIterator<[K, V]>;
-    keys(): MapIterator<K>;
-    values(): MapIterator<V>;
-    [Symbol.iterator](): MapIterator<[K, V]>;
-    readonly [Symbol.toStringTag]: string;
-}
-/**
- * Uses weak references but still may iterate through them
- * Note: The behavior is highly dependant on the garbage collector - some entries are perhaps deemed to be collected: don't resuscitate them
- */
-declare class IterableWeakSet<K extends WeakKey> implements Set<K> {
-    private uuids;
-    private refs;
-    private readonly registry;
-    constructor(entries?: Iterable<K>);
-    private createIterator;
-    clear(): void;
-    add(value: K): this;
-    delete(value: K): boolean;
-    forEach(callbackfn: (value: K, value2: K, set: Set<K>) => void, thisArg?: any): void;
-    has(value: K): boolean;
-    get size(): number;
-    entries(): SetIterator<[K, K]>;
-    keys(): SetIterator<K>;
-    values(): SetIterator<K>;
-    [Symbol.iterator](): SetIterator<K>;
-    readonly [Symbol.toStringTag]: string;
-    union<U>(other: ReadonlySetLike<U>): Set<K | U>;
-    intersection<U>(other: ReadonlySetLike<U>): Set<K & U>;
-    difference<U>(other: ReadonlySetLike<U>): Set<K>;
-    symmetricDifference<U>(other: ReadonlySetLike<U>): Set<K | U>;
-    isSubsetOf(other: ReadonlySetLike<unknown>): boolean;
-    isSupersetOf(other: ReadonlySetLike<unknown>): boolean;
-    isDisjointFrom(other: ReadonlySetLike<unknown>): boolean;
-}
-
-/**
- * A mixin function that takes a base class and returns a new class with mixed-in functionality
- * @template Mixed - The functionality to be mixed in
- */
-type MixinFunction<Mixed> = <Base>(base: new (...args: any[]) => Base) => new (...args: any[]) => Base & Mixed;
-/**
- * A mixin class that can be used both as a base class and as a mixin function
- * @template Mixed - The functionality to be mixed in
- */
-type MixinClass<Mixed> = new (...args: any[]) => Mixed;
-/**
- * Creates a mixin that can be used both as a class (extends) and as a function (mixin)
- *
- * This function supports:
- * - Using mixins as base classes: `class MyClass extends MyMixin`
- * - Using mixins as functions: `class MyClass extends MyMixin(SomeBase)`
- * - Composing mixins: `const Composed = MixinA(MixinB)`
- * - Type-safe property inference for all patterns
- *
- * @param mixinFunction - The function that creates the mixin
- * @param unwrapFunction - Optional function to unwrap reactive objects for method calls
- * @returns A mixin that can be used both as a class and as a function
- */
-declare function mixin<MixinFn extends (base: any) => new (...args: any[]) => any>(mixinFunction: MixinFn, unwrapFunction?: (obj: any) => any): (new (...args: any[]) => InstanceType<ReturnType<MixinFn>>) & (<Base>(base: abstract new (...args: any[]) => Base) => new (...args: any[]) => InstanceType<ReturnType<MixinFn>> & Base);
-
-type Resolved<T> = T extends Promise<infer U> ? Resolved<U> : T extends (...args: infer Args) => infer R ? (...args: Args) => Resolved<R> : T extends object ? {
-    [k in keyof T]: k extends 'then' | 'catch' | 'finally' ? T[k] : Resolved<T[k]>;
-} : T;
-type PromiseAnd<T> = Resolved<T> & Promise<Resolved<T>>;
-/**
- * Type that transforms promises into chainable objects
- * Allows calling methods directly on promise results without awaiting them first
- */
-type PromiseChain<T> = T extends (...args: infer Args) => infer R ? PromiseAnd<(...args: Args) => PromiseChain<Resolved<R>>> : T extends object ? PromiseAnd<{
-    [k in keyof T]: k extends 'then' | 'catch' | 'finally' ? T[k] : PromiseChain<Resolved<T[k]>>;
-}> : Promise<Resolved<T>>;
-/**
- * Transforms a promise or value into a chainable object
- * Allows calling methods directly on promise results without awaiting them first
- * @param given - The promise or value to make chainable
- * @returns A chainable version of the input
- */
-declare function chainPromise<T>(given: Promise<T> | T): PromiseChain<T>;
-
-/**
- * Reactively attends to each entry of a collection or each key yielded by an
- * enumeration callback. For each key, an inner effect runs the callback. When a
- * key disappears, its inner effect is disposed. The callback may return a cleanup
- * (like a regular effect closer).
- *
- * Accepts arrays, records, Maps, Sets, or a raw `() => Iterable<Key>` callback.
- *
- * @example
- * ```typescript
- * // Record shorthand
- * attend(record, (key) => { console.log(key, record[key]) })
- *
- * // Array shorthand
- * attend(array, (index) => { console.log(index, array[index]) })
- *
- * // Raw enumeration callback
- * attend(() => Object.keys(record), (key) => { ... })
- * ```
- */
-declare function attend<T>(source: readonly T[], callback: (index: number, access: EffectAccess) => EffectCloser | void): ScopedCallback;
-declare function attend<K, V>(source: Map<K, V>, callback: (key: K, access: EffectAccess) => EffectCloser | void): ScopedCallback;
-declare function attend<T>(source: Set<T>, callback: (value: T, access: EffectAccess) => EffectCloser | void): ScopedCallback;
-declare function attend<S extends object>(source: S, callback: (key: keyof S & string, access: EffectAccess) => EffectCloser | void): ScopedCallback;
-declare function attend<Key>(enumerate: () => Iterable<Key>, callback: (key: Key, access: EffectAccess) => EffectCloser | void): ScopedCallback;
-/**
- * Lifts a callback that returns an array into a reactive array that automatically
- * synchronizes with the source array returned by the callback.
- *
- * The returned reactive array will update whenever the callback's dependencies change,
- * efficiently syncing only the elements that differ from the previous result.
- *
- * @example
- * ```typescript
- * const items = reactive([1, 2, 3])
- * const doubled = lift(() => items.map(x => x * 2))
- *
- * console.log([...doubled]) // [2, 4, 6]
- *
- * items.push(4)
- * console.log([...doubled]) // [2, 4, 6, 8]
- * ```
- *
- * @param cb Callback function that returns an array
- * @returns A reactive array synchronized with the callback's result, with a [cleanup] property to stop tracking
- */
-declare function lift<Output extends any[]>(cb: (access: EffectAccess) => Output): Output;
-/**
- * Lifts a callback that returns an object into a reactive object that automatically
- * synchronizes with the source object returned by the callback.
- *
- * The returned reactive object will update whenever the callback's dependencies change,
- * efficiently syncing only the properties that differ from the previous result using
- * Object.assign(). Properties that no longer exist in the source are automatically removed.
- *
- * @example
- * ```typescript
- * const user = reactive({ name: 'John', age: 30 })
- * const profile = lift(() => ({
- *   displayName: user.name.toUpperCase(),
- *   isAdult: user.age >= 18,
- *   description: `${user.name} is ${user.age} years old`
- * }))
- *
- * console.log(profile.displayName) // JOHN
- * console.log(profile.isAdult) // true
- *
- * user.name = 'Jane'
- * console.log(profile.displayName) // JANE
- * console.log(profile.description) // Jane is 30 years old
- * ```
- *
- * @param cb Callback function that returns an object
- * @returns A reactive object synchronized with the callback's result, with a [cleanup] property to stop tracking
- */
-declare function lift<Output extends object>(cb: (access: EffectAccess) => Output): Output;
-/**
- * Options for `morph` and its variants.
- *
- * @property pure - When `true`, the mapping function is assumed pure (no reactive reads inside `fn`).
- *   Per-item effects are skipped and items are computed eagerly. When a predicate `(i) => boolean`,
- *   purity is evaluated per item — pure items skip the effect wrapper, non-pure items get their own.
- */
-type MorphOptions<I> = {
-    pure?: boolean | ((i: I) => boolean);
-};
-/**
- * Unified reactive collection mapper. Dispatches to `morphArray`, `morphMap`, or `morphRecord`
- * based on the source type. Access `morph.pure(source, fn)` for the `{ pure: true }` shorthand.
- *
- * @see morphArray
- * @see morphMap
- * @see morphRecord
- */
-type Morph = {
-    <I, O>(source: readonly I[] | (() => readonly I[]), fn: (arg: I, access?: EffectAccess) => O, options?: MorphOptions<I>): readonly O[];
-    <K, V, O>(source: Map<K, V>, fn: (arg: V, key: K, access?: EffectAccess) => O, options?: MorphOptions<V>): Map<K, O>;
-    <S extends Record<PropertyKey, any>, O>(source: S, fn: (arg: S[keyof S], key: keyof S, access?: EffectAccess) => O, options?: MorphOptions<S[keyof S]>): {
-        [K in keyof S]: O;
-    };
-    pure: Morph;
-};
-/**
- * Reactively maps a collection (array, Map, or record) through a per-entry function.
- *
- * Each entry in the source gets its own reactive context — when only one entry's dependencies
- * change, only that entry's projection recomputes. Structural changes (additions, removals,
- * reorders) are detected via diffing and applied surgically.
- *
- * Use `morph.pure(source, fn)` when `fn` has no reactive reads (skips per-item effects).
- *
- * @example
- * ```ts
- * const users = reactive([{ name: 'John' }, { name: 'Jane' }])
- * const names = morph(users, u => u.name.toUpperCase())
- * // names[0] = 'JOHN', names[1] = 'JANE'
- * // Changing users[0].name only recomputes names[0]
- * ```
- */
-declare const morph: Morph;
-
-/**
- * Gets the current state of a reactive object for evolution tracking
- * @param obj - The reactive object
- * @returns The current state object
- */
-declare function getState(obj: any): State;
-/**
- * Triggers effects for a single property change
- * @param obj - The object that changed
- * @param evolution - The type of change
- * @param prop - The property that changed
- */
-declare function touched1(obj: any, evolution: Evolution, prop: any): void;
-/**
- * Triggers effects for property changes
- * @param obj - The object that changed
- * @param evolution - The type of change
- * @param props - The properties that changed
- */
-declare function touched(obj: any, evolution: Evolution, props?: Iterable<any>): void;
-
-/**
- * Deep watch an object and all its nested properties
- * @param target - The object to watch deeply
- * @param callback - The callback to call when any nested property changes
- * @param options - Options for the deep watch
- * @returns A cleanup function to stop watching
- */
-/**
- * Sets up deep watching for an object, tracking all nested property changes
- * @param target - The object to watch
- * @param callback - The callback to call when changes occur
- * @param options - Options for deep watching
- * @returns A cleanup function to stop deep watching
- */
-declare function deepWatch<T extends object>(target: T, callback: (value: T) => void, { immediate }?: {
-    immediate?: boolean;
-}): EffectCleanup | undefined;
-
-/**
- * Aggregator for zones that need to be tracked along effects.
- * ie. in each effect, the active zone of the given zoning will be the one active at effect's definition
- */
-declare const effectAggregator: ZoneAggregator;
-declare function getActiveEffect(): ScopedCallback;
-/**
- * Attach cleanup dependencies to an object. When `unlink(obj)` is called,
- * each dependency is disposed: functions are invoked with the cleanup reason,
- * objects are recursively `unlink`ed. This forms a cleanup tree.
- *
- * @param obj - The owner object
- * @param cleanupFns - Cleanup callbacks and/or child objects to unlink recursively
- * @returns The owner object (for chaining)
- *
- * @example
- * ```ts
- * // Functions are called with CleanupReason
- * link(parent, () => console.log('disposed'))
- *
- * // Objects are recursively unlinked
- * link(parent, childA, childB)
- *
- * // Mixed
- * link(parent, childObj, () => timer.clear())
- *
- * unlink(parent) // disposes childA, childB, calls the function
- * ```
- */
-declare function link<T extends object>(obj: T, ...cleanupFns: (ScopedCallback | object | undefined)[]): T;
-/**
- * Dispose an object's cleanup dependencies. Functions are called with the
- * reason; linked objects are recursively unlinked. The cleanup set is removed
- * so calling `unlink` twice is safe (second call is a no-op).
- *
- * @param obj - The object to dispose
- * @param reason - Optional cleanup reason propagated to callbacks
- */
-declare function unlink(obj: object, reason?: CleanupReason): void;
-
-interface ActivationRecord {
-    effect: EffectTrigger;
-    obj: any;
-    evolution: Evolution;
-    prop: any;
-    batchId: number;
-}
-/**
- * Returns the activation log containing recent effect activations for debugging.
- * The log is a circular buffer of the last 100 activations.
- *
- * @returns Array of activation records
- */
-declare function getActivationLog(): Omit<ActivationRecord, "batchId">[];
-declare function caught(onThrow: CatchFunction, effect?: EffectTrigger): void;
-/** @deprecated Use `caught` instead */
-declare const onEffectThrow: typeof caught;
-/**
- * Adds a cleanup function to be called when the current batch of effects completes
- * @param cleanup - The cleanup function to add
- */
-declare function addBatchCleanup(cleanup: EffectCleanup): void;
-/**
- * Semantic alias for `addBatchCleanup` - defers work to the end of the current reactive batch.
- *
- * Use this when an effect needs to perform an action that would modify state the effect depends on,
- * which would create a reactive cycle. The deferred callback runs after all effects complete.
- *
- * @param callback - The callback to defer until after the current batch completes
- *
- * @example
- * ```typescript
- * effect(() => {
- *   processData()
- *
- *   // Defer to avoid cycle (createMovement modifies state this effect reads)
- *   defer(() => {
- *     createMovement(data)
- *   })
- * })
- * ```
- */
-declare const defer: typeof addBatchCleanup;
-/**
- * Resets the reactive system to a consistent state.
- * Call this after an unrecoverable error has set the system to "broken".
- * This clears all batch state, effect dependency graphs, and watcher registrations.
- * All existing effects become orphaned and must be recreated.
- */
-declare function reset(): void;
-
-/**
- * Decorator that makes methods atomic - batches all effects triggered within the method
- */
-declare const atomic: LegacyPropertyDecorator<any> & ModernMethodDecorator<any> & (<Args extends any[], Return>(original: (...args: Args) => Return) => (...args: Args) => Return);
-/**
- * Wraps `fn` so it runs within `effect`'s zone context when invoked later.
- *
- * Useful for deferred callbacks (event listeners, `DOMContentLoaded`, etc.)
- * that need sub-effects parented to the original effect.
- *
- * @param prev - The effect whose context should be restored, or `undefined` for root context
- * @param fn - The function to wrap
- * @returns A function with the same signature that restores the effect context before calling `fn`
- */
-declare function captured<Args extends any[], Return>(prev: HistoryValue<EffectTrigger> | undefined, fn: (...args: Args) => Return): (...args: Args) => Return;
-/**
- * Runs `fn` atomically and **always immediately**, batching all reactive effects
- * triggered inside it so they fire only once after `fn` completes.
- *
- * Unlike `atomic(fn)` which **wraps** a function for later invocation,
- * `atom(fn)` **executes** the function right away.
- *
- * @example
- * ```ts
- * const state = reactive({ a: 0, b: 0 })
- * effect(() => console.log(state.a, state.b)) // logs once after atom completes
- *
- * atom(() => {
- *   state.a = 1
- *   state.b = 2
- * })
- * ```
- */
-declare function atom<T>(fn: () => T): any;
-/**
- * @param fn - The effect function to run - provides the cleaner
- * @returns The cleanup function
- */
-/**
- * Reactive effect function with chainable flavor modifiers.
- */
-interface Effect {
-    (fn: (access: EffectAccess) => EffectCloser | undefined | void | Promise<any>, effectOptions?: EffectOptions): EffectCleanup;
-    /** Opaque flavor: bypasses deep-touch optimizations */
-    readonly opaque: Effect;
-    /** Named flavor: assigns a debug name */
-    named(name: string): Effect;
-}
-/**
- * Creates a reactive effect that automatically re-runs when dependencies change
- * @param fn - The effect function that provides dependencies and may return a cleanup function or Promise
- * @param options - Options for effect execution
- * @returns A cleanup function to stop the effect
- */
-declare const effect: Effect;
-/**
- * Executes a function without tracking dependencies but maintains parent cleanup relationship
- * Effects created inside will still be cleaned up when the parent effect is destroyed
- * @param fn - The function to execute
- */
-declare function untracked<T>(fn: () => T): T;
-/**
- * Executes a function from a virgin/root context - no parent effect, no tracking
- * Creates completely independent effects that won't be cleaned up by any parent
- * @param fn - The function to execute
- */
-declare function root<T>(fn: () => T): T;
-/**
- * Creates a bidirectional binding between a reactive value and a non-reactive external value
- * Prevents infinite loops by automatically suppressing circular notifications
- *
- * @param received - Function called when the reactive value changes (external setter)
- * @param get - Getter for the reactive value OR an object with `{ get, set }` properties
- * @param set - Setter for the reactive value (required if `get` is a function)
- * @returns A function to manually provide updates from the external side
- *
- * @example
- * ```typescript
- * const model = reactive({ value: '' })
- * const input = { value: '' }
- *
- * // Bidirectional binding
- * const provide = biDi(
- *   (v) => input.value = v,  // external setter
- *   () => model.value,        // reactive getter
- *   (v) => model.value = v    // reactive setter
- * )
- *
- * // External notification (e.g., from input event)
- * provide('new value')  // Updates model.value, doesn't trigger circular loop
- * ```
- *
- * @example Using object syntax
- * ```typescript
- * const provide = biDi(
- *   (v) => setHTMLValue(v),
- *   { get: () => reactiveObj.value, set: (v) => reactiveObj.value = v }
- * )
- * ```
- */
-declare function biDi<T>(received: (value: T) => void, value: {
-    get: () => T;
-    set: (value: T) => void;
-}): (value: T) => void;
-declare function biDi<T>(received: (value: T) => void, get: () => T, set: (value: T) => void): (value: T) => void;
-
-type MemoizableArgument = object | any[] | ((...args: any[]) => any);
-type Memoizable = ((...args: MemoizableArgument[]) => unknown) | Record<string, any>;
-/**
- * Decorator and function wrapper for memoizing computed values based on reactive dependencies.
- *
- * When used as a decorator on getters or methods, it caches the result and automatically
- * invalidates the cache when reactive dependencies change.
- *
- * When used as a function wrapper, it memoizes based on object arguments (WeakMap-based cache).
- *
- * @example
- * ```typescript
- * class User {
- *   @memoize
- *   get fullName() {
- *     return `${this.firstName} ${this.lastName}`
- *   }
- * }
- *
- * // Or as a function wrapper
- * const expensive = memoize((obj: SomeObject) => {
- *   return heavyComputation(obj)
- * })
- * ```
- */
-declare function makeMemoizeDecorator(memoizeOpts?: {
-    lenient?: boolean;
-}): LegacyPropertyDecorator<any> & ModernMethodDecorator<any> & ModernGetterDecorator<any> & ModernAccessorDecorator<any> & (<T extends Memoizable>(target: T) => T);
-declare const memoize: ReturnType<typeof makeMemoizeDecorator> & {
-    readonly lenient: ReturnType<typeof makeMemoizeDecorator>;
-};
-
-/**
- * Add unreactive properties to a prototype.
- * If no set is provided, marks the entire object/prototype as non-reactive (sets [unreactiveProperties] = true).
- * If a set is provided, merges with existing unreactive properties (never overrides true).
- */
-declare function addUnreactiveProps<T extends object>(proto: T, set?: Iterable<PropertyKey>): T;
-declare function isNonReactive(obj: any): boolean;
-
-type SubProxy = {
-    get?(obj: any, prop: PropertyKey, receiver: any): any;
-    has?(obj: any, prop: PropertyKey): boolean;
-    ownKeys?(obj: any): ArrayLike<string | symbol>;
-    getOwnPropertyDescriptor?(obj: any, prop: PropertyKey): PropertyDescriptor | undefined;
-};
-/**
- * Base mixin for reactive classes that provides proper constructor reactivity
- * Solves constructor reactivity issues in complex inheritance trees
- */
-declare const ReactiveBase: (new (...args: any[]) => {
-    [x: string]: any;
-}) & (<Base>(base: abstract new (...args: any[]) => Base) => new (...args: any[]) => {
-    [x: string]: any;
-} & Base);
-declare function reactiveObject<T>(anyTarget: T, subProxy?: SubProxy): T;
-/**
- * Main decorator for making classes reactive
- * Automatically makes class instances reactive when created
- */
-declare const reactive: LegacyClassDecorator<new (...args: any[]) => any> & ModernClassDecorator<new (...args: any[]) => any> & typeof reactiveObject;
-
-/**
- * Provides type-safe access to a source object's property within the organized callback.
- * @template Source - The type of the source object
- * @template Key - The type of the property key in the source object
- */
-type OrganizedAccess<Source extends Record<PropertyKey, any>, Key extends keyof Source> = {
-    /** The property key being accessed */
-    readonly key: Key;
-    /**
-     * Gets the current value of the property from the source object
-     * @returns The current value of the property
-     */
-    get(): Source[Key];
-    /**
-     * Updates the property value in the source object
-     * @param value - The new value to set
-     * @returns {boolean} True if the update was successful
-     */
-    set(value: Source[Key]): boolean;
-    /**
-     * The current value of the property (equivalent to using get()/set() directly)
-     */
-    value: Source[Key];
-};
-/**
- * Callback function type for the organized function that processes each source property.
- * @template Source - The type of the source object
- * @template Target - The type of the target object
- */
-type OrganizedCallback<Source extends Record<PropertyKey, any>, Target extends object> = <Key extends keyof Source>(
-/**
- * Accessor object for the current source property
- */
-access: OrganizedAccess<Source, Key>, 
-/**
- * The target object where organized data will be stored
- */
-target: Target) => EffectCloser | undefined;
-/**
- * The result type of the organized function, combining the target object with cleanup capability.
- * @template Target - The type of the target object
- */
-type OrganizedResult<Target extends object> = Target;
-/**
- * Organizes a source object's properties into a target object using a callback function.
- * This creates a reactive mapping between source properties and a target object,
- * automatically handling property additions, updates, and removals.
- *
- * @template Source - The type of the source object
- * @template Target - The type of the target object (defaults to Record<PropertyKey, any>)
- *
- * @param {Source} source - The source object to organize
- * @param {OrganizedCallback<Source, Target>} apply - Callback function that defines how each source property is mapped to the target
- * @param {Target} [baseTarget={}] - Optional base target object to use (will be made reactive if not already)
- *
- * @returns {OrganizedResult<Target>} The target object with cleanup capability
- *
- * @example
- * // Organize user permissions into role-based access
- * const user = reactive({ isAdmin: true, canEdit: false });
- * const permissions = organized(
- *   user,
- *   (access, target) => {
- *     if (access.key === 'isAdmin') {
- *       target.hasFullAccess = access.value;
- *     }
- *     target[`can${access.key.charAt(0).toUpperCase() + access.key.slice(1)}`] = access.value;
- *   }
- * );
- *
- * @example
- * // Transform object structure with cleanup
- * const source = reactive({ firstName: 'John', lastName: 'Doe' });
- * const formatted = organized(
- *   source,
- *   (access, target) => {
- *     if (access.key === 'firstName' || access.key === 'lastName') {
- *       target.fullName = `${source.firstName} ${source.lastName}`.trim();
- *     }
- *   }
- * );
- *
- * @example
- * // Using with cleanup in a component
- * effect(() => {
- *   const data = fetchData();
- *   const organizedData = organized(data, (access, target) => {
- *     // Transform data
- *   });
- *
- *   // The cleanup will be called automatically when the effect is disposed
- *   return () => organizedData[cleanup]();
- * });
- */
-declare function organized<Source extends Record<PropertyKey, any>, Target extends object = Record<PropertyKey, any>>(source: Source, apply: OrganizedCallback<Source, Target>, baseTarget?: Target): OrganizedResult<Target>;
-/**
- * Organizes a property on a target object
- * Shortcut for defineProperty/delete with touched signal
- * @param target - The target object
- * @param property - The property to organize
- * @param access - The access object
- * @returns The property descriptor
- */
-declare function organize<T>(target: object, property: PropertyKey, access: {
-    get?(): T;
-    set?(value: T): boolean;
-}): () => boolean;
-
-/**
- * Options for the watch function
- */
-interface WatchOptions {
-    /** Whether to call the callback immediately */
-    immediate?: boolean;
-    /** Whether to watch nested properties */
-    deep?: boolean;
-}
-/**
- * Watches a reactive value and calls a callback when it changes
- */
-interface Watch {
-    <T>(value: (dep: EffectAccess) => T, changed: (value: T, oldValue?: T) => void, options?: Omit<WatchOptions, 'deep'> & {
-        deep?: false;
-    }): EffectCleanup;
-    /**
-     * Watches a reactive value with deep watching enabled
-     */
-    <T extends object | any[]>(value: (dep: EffectAccess) => T, changed: (value: T, oldValue?: T) => void, options?: Omit<WatchOptions, 'deep'> & {
-        deep: true;
-    }): EffectCleanup;
-    /**
-     * Watches a reactive object directly
-     */
-    <T extends object | any[]>(value: T, changed: (value: T) => void, options?: WatchOptions): EffectCleanup;
-    /** Deep watch flavor */
-    get deep(): Watch;
-    /** Immediate watch flavor */
-    get immediate(): Watch;
-}
-declare const watch: Watch;
-/**
- * Returns a promise that resolves when the predicate returns a truthy value.
- * The predicate is evaluated reactively — it re-runs whenever its dependencies change.
- * @param predicate - Reactive function that returns a value; resolves when truthy
- * @param timeout - Optional timeout in milliseconds — rejects if condition is not met within this duration
- * @returns Promise that resolves with the first truthy return value
- */
-declare function when<T>(predicate: (dep: EffectAccess) => T, timeout?: number): Promise<T>;
-declare function unreactiveApplication<T extends object>(...args: (keyof T)[]): GenericClassDecorator<T>;
-declare function unreactiveApplication<T extends object>(obj: T): T;
-/**
- * Decorator that marks classes or properties as non-reactive
- * Prevents objects from being made reactive
- */
-declare const unreactive: LegacyClassDecorator<new (...args: any[]) => any> & ModernClassDecorator<new (...args: any[]) => any> & typeof unreactiveApplication;
-interface Resource<T> {
-    value: T | undefined;
-    loading: boolean;
-    error: any;
-    latest: T | undefined;
-    reload(): void;
-    promise: Promise<void>;
-}
-/**
- * Creates a reactive resource that automatically tracks async state.
- * @param fetcher - Async function that returns the value. Reactive dependencies are tracked.
- * @param options - Resource options (initialValue)
- * @returns Reactive Resource object with value, loading, error, latest properties
- */
-declare function resource<T>(fetcher: (access: EffectAccess) => Promise<T> | T, options?: {
-    initialValue?: T;
-}): Resource<T>;
-
-/**
- * Executes a function and throws if any reactive dependencies are tracked during execution.
- * Used to assert that code runs in an untracked context.
- */
-declare function assertUntracked<T>(fn: () => T): T;
-
-/**
- * Object containing internal reactive system state for debugging and profiling
- */
-declare const profileInfo: any;
-
-/**
- * Decorator that caches the result of a getter method and only recomputes when dependencies change
- * Prevents circular dependencies and provides automatic cache invalidation
- */
-declare const cached: LegacyPropertyDecorator<any> & ModernGetterDecorator<any> & ModernAccessorDecorator<any>;
-/**
- * Checks if a property is cached (has a cached value)
- * @param object - The object to check
- * @param propertyKey - The property key to check
- * @returns True if the property has a cached value
- */
-declare function isCached(object: Object, propertyKey: PropertyKey): boolean;
-/**
- * Caches a value for a property on an object
- * @param object - The object to cache the value on
- * @param propertyKey - The property key to cache
- * @param value - The value to cache
- */
-declare function cache(object: Object, propertyKey: PropertyKey, value: any): void;
-/**
- * Creates a decorator that modifies property descriptors for specified properties
- * @param descriptor - The descriptor properties to apply
- * @returns A class decorator that applies the descriptor to specified properties
- */
-declare const descriptor: any;
-/**
- * Decorator that marks methods, properties, or classes as deprecated
- * Provides warning messages when deprecated items are used
- */
-declare const deprecated: LegacyPropertyDecorator<any> & ModernMethodDecorator<any> & LegacyClassDecorator<new (...args: any[]) => any> & ModernClassDecorator<new (...args: any[]) => any> & ModernGetterDecorator<any> & ModernAccessorDecorator<any> & ModernSetterDecorator<any> & ((message: string) => LegacyPropertyDecorator<any> & ModernMethodDecorator<any> & LegacyClassDecorator<new (...args: any[]) => any> & ModernClassDecorator<new (...args: any[]) => any> & ModernGetterDecorator<any> & ModernAccessorDecorator<any> & ModernSetterDecorator<any>) & {
-    warn: (target: any, propertyKey: PropertyKey, message?: string) => void;
-};
-/**
- * Creates a debounced method decorator that delays execution until after the delay period has passed
- * @param delay - The delay in milliseconds
- * @returns A method decorator that debounces method calls
- */
-declare function debounce(delay: number): LegacyPropertyDecorator<any> & ModernMethodDecorator<any>;
-/**
- * Creates a throttled method decorator that limits execution to once per delay period
- * @param delay - The delay in milliseconds
- * @returns A method decorator that throttles method calls
- */
-declare function throttle(delay: number): LegacyPropertyDecorator<any> & ModernMethodDecorator<any>;
-
-type ElementTypes<T extends readonly unknown[]> = {
-    [K in keyof T]: T[K] extends readonly (infer U)[] ? U : T[K];
-};
-/**
- * Yields tuples containing elements from each input array, stopping at the longest array length
- * @param args - Arrays to zip together
- * @returns Generator yielding tuples containing elements from each input array
- */
-declare function zip<T extends (readonly unknown[])[]>(...args: T): Generator<ElementTypes<T>>;
-/**
- * Checks if two arrays are strictly equal (shallow comparison)
- * @param a - First value
- * @param b - Second value
- * @returns True if arrays are equal or values are strictly equal
- */
-declare function arrayEquals(a: any, b: any): boolean;
-/**
- * Checks if a function is a constructor (class or constructor function)
- * @param fn - The function to check
- * @returns True if the function is a constructor
- */
-declare function isConstructor(fn: Function): boolean;
-/**
- * Checks if a value is an object
- * @param value - The value to check
- * @returns True if the value is an object
- */
-declare function isObject(value: any): value is object;
-/**
- * Deeply compares two values.
- * For objects, compares prototypes with === and then own properties recursively.
- * Uses a cache to handle circular references.
- * @param a - First value
- * @param b - Second value
- * @param cache - Map for circular reference protection (internal use)
- * @returns True if values are deeply equal
- */
-declare function deepCompare(a: any, b: any, cache?: Map<object, Set<object>>): boolean;
-/**
- * Tags an object with a name
- * @param name - The name to tag the object with
- * @param obj - The object to tag
- * @returns The object with the tag
- */
-declare function tag<T extends object>(name: string, obj: T): T;
-/**
- * Renames a function with a new name
- * @param name - The new name for the function
- * @param fn - The function to rename
- * @returns The function with the new name
- */
-declare function named<T extends Function>(name: string, fn: T): T;
-declare const isDev: boolean;
-declare const isProd: boolean;
-declare const isTest: boolean;
-
-export { ArrayReadForward, CleanupReason, DecoratorError, Destroyable, DestructionError, EffectAccess, EffectCleanup, EffectCloser, EffectOptions, EffectTrigger, Eventful, Evolution, HistoryValue, Indexable, IterableWeakMap, IterableWeakSet, ReactiveBase, ScopedCallback, ZoneAggregator, addBatchCleanup, addUnreactiveProps, allocated, allocatedValues, arrayDiff, arrayEquals, assertUntracked, asyncHook, asyncHooks, atom, atomic, attend, biDi, cache, cached, callOnGC, captured, caught, chainPromise, createFlavor, debounce, decorator, deepCompare, deepWatch, defer, deprecated, descriptor, destructor, effect, effectAggregator, flavorOptions, flavored, forwardArray, getActivationLog, getActiveEffect, getAt, getState, hooks$1 as hooks, isCached, isConstructor, isDev, isNonReactive, isObject, isProd, isTest, legacyDecorator, lift, link, memoize, mixin, modernDecorator, morph, named, onEffectThrow, organize, organized, profileInfo, morph as project, reactive, reset, resource, root, setAt, tag, throttle, touched, touched1, unlink, unreactive, untracked, watch, when, zip };
-export type { ArrayDiffResult, ContextManager, Decorator, DecoratorDescription, DecoratorFactory, EventsBase, GenericClassDecorator, Hook, LegacyClassDecorator, LegacyPropertyDecorator, Memoizable, MemoizableArgument, MixinClass, MixinFunction, ModernAccessorDecorator, ModernClassDecorator, ModernGetterDecorator, ModernMethodDecorator, ModernSetterDecorator, PromiseChain, Resource, Restorer };