@the-w1zard/the-cloud 1.0.2 → 1.0.4

package/dist/hooks/rect.js

@@ -1,77 +0,0 @@
-/**
- * Observes an element's rectangle on screen (getBoundingClientRect)
- * This is useful to track elements on the screen and attach other elements
- * that might be in different layers, etc.
- */
-export function observeElementRect(
-/** The element whose rect to observe */
-elementToObserve, 
-/** The callback which will be called when the rect changes */
-callback) {
-    const observedData = observedElements.get(elementToObserve);
-    if (observedData === undefined) {
-        // add the element to the map of observed elements with its first callback
-        // because this is the first time this element is observed
-        observedElements.set(elementToObserve, { rect: {}, callbacks: [callback] });
-        if (observedElements.size === 1) {
-            // start the internal loop once at least 1 element is observed
-            rafId = requestAnimationFrame(runLoop);
-        }
-    }
-    else {
-        // only add a callback for this element as it's already observed
-        observedData.callbacks.push(callback);
-        callback(elementToObserve.getBoundingClientRect());
-    }
-    return () => {
-        const observedData = observedElements.get(elementToObserve);
-        if (observedData === undefined)
-            return;
-        // start by removing the callback
-        const index = observedData.callbacks.indexOf(callback);
-        if (index > -1) {
-            observedData.callbacks.splice(index, 1);
-        }
-        if (observedData.callbacks.length === 0) {
-            // stop observing this element because there are no
-            // callbacks registered for it anymore
-            observedElements.delete(elementToObserve);
-            if (observedElements.size === 0) {
-                // stop the internal loop once no elements are observed anymore
-                cancelAnimationFrame(rafId);
-            }
-        }
-    };
-}
-let rafId;
-export const observedElements = new Map();
-export function runLoop() {
-    const changedRectsData = [];
-    // process all DOM reads first (getBoundingClientRect)
-    observedElements.forEach((data, element) => {
-        const newRect = element.getBoundingClientRect();
-        // gather all the data for elements whose rects have changed
-        if (!rectEquals(data.rect, newRect)) {
-            data.rect = newRect;
-            changedRectsData.push(data);
-        }
-    });
-    // group DOM writes here after the DOM reads (getBoundingClientRect)
-    // as DOM writes will most likely happen with the callbacks
-    changedRectsData.forEach((data) => {
-        data.callbacks.forEach((callback) => callback(data.rect));
-    });
-    rafId = requestAnimationFrame(runLoop);
-}
-// ========================================================================
-/**
- * Returns whether 2 rects are equal in values
- */
-export function rectEquals(rect1, rect2) {
-    return (rect1.width === rect2.width &&
-        rect1.height === rect2.height &&
-        rect1.top === rect2.top &&
-        rect1.right === rect2.right &&
-        rect1.bottom === rect2.bottom &&
-        rect1.left === rect2.left);
-}

package/dist/hooks/state.d.ts

@@ -1 +0,0 @@
-export declare function useState<T = any, S = T>(initialValue?: T | (() => T), options?: StateOptions<T, S>, __sauron_id__?: string): readonly [S, (v: T | ((prev: T) => T)) => T, any] | readonly [S, (v: T | ((prev: T) => T)) => T];

package/dist/hooks/state.js

@@ -1,34 +0,0 @@
-export function useState(initialValue, options = {}, __sauron_id__ = _sid()) {
-    return createHook("useState", __sauron_id__, () => ({
-        value: {
-            current: typeof initialValue === "function" ? initialValue() : initialValue,
-            derived: undefined
-        }
-    }), (state, key, notify) => {
-        const s = state.value;
-        const equals = options.equals ?? ((a, b) => a === b);
-        const selector = options.selector ?? null;
-        const derive = options.derive ?? null;
-        const getValue = () => selector ? selector(s.current) : s.current;
-        const setValue = (v) => {
-            const next = typeof v === "function" ? v(s.current) : v;
-            const prevSelected = getValue();
-            const nextSelected = selector ? selector(next) : next;
-            if (!equals(prevSelected, nextSelected)) {
-                s.current = next;
-                if (derive) {
-                    s.derived = derive(next);
-                }
-                notify(key);
-            }
-            return next;
-        };
-        if (derive && s.derived === undefined) {
-            s.derived = derive(s.current);
-        }
-        if (derive) {
-            return [getValue(), setValue, s.derived];
-        }
-        return [getValue(), setValue];
-    });
-}

package/dist/hooks/suspense.d.ts

@@ -1,4 +0,0 @@
-export declare function Suspense({ children, fallback }: {
-    children: any;
-    fallback: any;
-}): any;

package/dist/hooks/suspense.js

@@ -1,10 +0,0 @@
-export function Suspense({ children, fallback }) {
-    try {
-        return children;
-    }
-    catch (e) {
-        if (e && typeof e.then === 'function')
-            return fallback;
-        throw e;
-    }
-}

package/dist/hooks/types.d.ts

@@ -1,25 +0,0 @@
-export interface ProviderProps<T> {
-    value: T;
-    children?: any | undefined;
-}
-export interface ConsumerProps<T> {
-    children: (value: T) => any;
-}
-export interface ExoticComponent<P = {}> {
-    (props: P): any;
-    readonly $$typeof?: symbol;
-}
-export interface ProviderExoticComponent<P> {
-    (props: P): any;
-    $$typeof?: symbol;
-}
-export type Provider<T> = ProviderExoticComponent<ProviderProps<T>>;
-export type Consumer<T> = ExoticComponent<ConsumerProps<T>>;
-export interface Context<T> {
-    Provider: Provider<T>;
-    Consumer: Consumer<T>;
-    displayName?: string | undefined;
-    _sauronKey: symbol;
-    defaultValue: T;
-    [key: string]: any;
-}

package/dist/hooks/types.js

@@ -1 +0,0 @@
-export {};

package/dist/index.d.ts

@@ -1,8 +0,0 @@
-import { root, ROOT, _root, getNestedMap, getMetadata, scheduleGlobalNotify, scheduleNotify, state, _devRecord, devRecord, registerDevRecorder, rerender, flushHookKey, _flushHookNotifications, getCurrentComponent, unmountComponent, mountComponent, hmrPreserve, hmrRestore, subscribeToHook, notifyHook, endHookDependencyCapture, beginHookDependencyCapture, registerDOMBinding, setCurrentComponent, registerDOMRef, getDOMRef, registerAdapter, _reactHookCursor, _currentRenderInstanceCheck, _isReactRenderContext, createHook, _broadcastSS, getChain, getReChain, get, getSauron, getAll, getAllSauron, getMany, setChain, set, setSauron, setMany, subChain, sub, subSauron, subAll, subAllSauron, delSauron, deleteSauron, deleteChain, deleteMany, waitFor, waitForSauron } from './the-cloud.js';
-import { useComposedRefs, composeRefs1, composeRefs, createRefForwarder, useDomRef, forwardRef, mergeAnyRefs, useReactRef, toReactRef, mergeForwardRefs, useForwardedRef, createForwardRef, isForwardRefObject, isForwardRefCallback } from './hooks/core/use-ref.js';
-import { useReducer } from './hooks/core/use-reducer.js';
-import { useRef } from './hooks/core/use-ref.js';
-import { useState2 } from './hooks/core/use-state2.js';
-import { useId } from './hooks/core/use-id.js';
-export { useId, useReducer, useRef, useState2, root, ROOT, _root, getNestedMap, getMetadata, scheduleGlobalNotify, scheduleNotify, state, _devRecord, devRecord, registerDevRecorder, rerender, flushHookKey, _flushHookNotifications, getCurrentComponent, unmountComponent, mountComponent, hmrPreserve, hmrRestore, subscribeToHook, notifyHook, endHookDependencyCapture, beginHookDependencyCapture, registerDOMBinding, setCurrentComponent, registerDOMRef, getDOMRef, registerAdapter, _reactHookCursor, _currentRenderInstanceCheck, _isReactRenderContext, createHook, _broadcastSS, getChain, getReChain, get, getSauron, getAll, getAllSauron, getMany, setChain, set, setSauron, setMany, subChain, sub, subSauron, subAll, subAllSauron, delSauron, deleteSauron, deleteChain, deleteMany, waitFor, waitForSauron, useComposedRefs, composeRefs1, composeRefs, createRefForwarder, useDomRef, forwardRef, mergeAnyRefs, useReactRef, toReactRef, mergeForwardRefs, useForwardedRef, createForwardRef, isForwardRefObject, isForwardRefCallback, };
-/**useSlideIn1 , useCounter , useToggle , useSessionStorage ,  useLocalStorage ,  useScript , usePagination ,useSwap , useMutationObserver ,  useLocales , useLucideDrawerAnimation , useExpandable , useExportMarkdownUsage , useExportMarkdown , useColorTheme , useSlideIn , useSliderWithInput ,useOverlayListener , useOverlayScrollListener , useSse , useStorage ,useCache2 , useControllableStateReducer , useControllableState ,  useSubmit, useEscapeKeydown  ,useDeclarativeSchema ,  */

package/dist/the-cloud.d.ts

@@ -1,406 +0,0 @@
-export declare function _sidi(): S;
-declare class SAURON {
-    root: ROOT;
-    constructor(root?: A);
-    online: boolean;
-    r: A;
-    m: A;
-    s: A;
-    k: A;
-    u: undefined;
-    uuuu: undefined[];
-    UUUU: any[];
-    uuu: undefined[];
-    UUU: any[];
-    uu: undefined[];
-    UU: any[];
-    _localChange: boolean;
-    _channel: BroadcastChannel | null;
-    init_hooks_context: boolean;
-    batchDepth: number;
-    openScopes: Set<symbol>;
-    dirty: Set<FlushCallback>;
-    _flushScheduled: boolean;
-    _adapter: RuntimeAdapter | null;
-    _currentHookState: HookState | null;
-    _currentComponent: ComponentInstance | null;
-    PRIORITY_ORDER: Priority[];
-    GLOBAL_SCOPE: symbol;
-    scopeCursors: Record<Priority, number>;
-    currentScope: symbol | string;
-    loopScheduled: boolean;
-    _subscribers: Map<string, Set<() => void>>;
-    __subscribers: Map<string, Map<string, Map<string, Map<any, Set<(value: A) => void>>>>>;
-    _externalSubscribers: Map<string, Map<string, Map<string, Map<any, Set<(value: A) => void>>>>>;
-    _components: Map<string, ComponentInstance>;
-    _pendingNotifications: Set<string>;
-    externalSubscribers: Set<() => void>;
-    readonly instanceId: string;
-    _root: ComponentInstance;
-    FULFIL_THIS_SAURON_DEPOT(r: A): void;
-    getNestedMap<K, V>(s?: any, m?: any, r?: any): Map<K, V>;
-    getMetadata(s?: any, m?: any, r?: any): any;
-    onFlush(cb: FlushCallback): void;
-    scheduleDrain(): void;
-    drain(): void;
-    microtask(fn: FlushCallback): void;
-    batch<T>(fn: () => T): T;
-    openBatch(): BatchScope;
-    closeBatch(scope: BatchScope): void;
-    isBatching(): boolean;
-    flushSync(): void;
-    flush<T>(fn?: () => T): T | void;
-    enqueue(task: ScheduledTask): void;
-    scheduleLoop(): void;
-    pickNext(): ScheduledTask | undefined;
-    runOne(task: ScheduledTask): void;
-    drainOne(): void;
-    schedule(fn: () => void, opts?: {
-        priority?: Priority;
-        scope?: string;
-        signal?: AbortSignal;
-    }): Task;
-    withRequestScope<T>(requestId: string, fn: () => T): T;
-    yieldToScheduler(): Promise<void>;
-    scheduleChunked(work: Iterable<() => void> | Iterator<() => void>, opts?: {
-        priority?: Priority;
-        scope?: string;
-        chunkBudgetMs?: number;
-    }): Task;
-    _globalNotifyCache: WeakMap<any, Map<any, () => void>>;
-    _notifyCache: WeakMap<Map<any, Set<(value: A) => void>>, Map<any, () => void>>;
-    scheduleGlobalNotify(key: string | symbol, meta: A, opts: ScopeOptions): void;
-    scheduleNotify(key: A, _listeners: Map<A, Set<(value: A) => void>>, _state: Map<A, A>): void;
-    store: {
-        get: <T = any>(key: A, opts?: ScopeOptions) => T | undefined;
-        set: <T = any>(key: A, value: T | ((prev: T | undefined) => T), opts?: {
-            triggerRender?: boolean;
-            cap?: number;
-        } & ScopeOptions) => any;
-        subscribe: <T = any>(key: A, listener: (value: T) => void, opts?: ScopeOptions) => (() => void);
-        delete: (key: A, opts?: ScopeOptions) => boolean;
-        entries: <T = any>(opts?: ScopeOptions) => [A, T][];
-        persist: (key: A, opts?: ScopeOptions) => void;
-        unpersist: (key: A, opts?: ScopeOptions) => void;
-        has: (key: A, opts?: ScopeOptions) => boolean;
-        clear: (opts?: ScopeOptions) => void;
-        clearPersistent: (opts?: ScopeOptions) => void;
-        _emit: (key: string | symbol, sl_reg?: any, ms_reg?: any, globalKey?: any) => void;
-    };
-    state: SauronState;
-    /**  public store2 = (() => {
-        const sa = {
-            get: <T = A>(key: SignalKey, opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },) => {
-                const { s, m, r, } = opts;
-                const atom = this.root.SIGNALS.create<T>(key, undefined, undefined, s, m, r,) as SIGNAL_CELL;
-                return atom ? atom.node : undefined;
-            },
-            set: <T = A>(key: SignalKey, value: A, opts: { triggerRender?: boolean; cap?: number; source?: string; } & ScopeOptions = { s: this.s, m: this.m, r: this.r, triggerRender: true, cap: 200, },): T | undefined => {
-                const { triggerRender = true, cap = 200, source = "state.set", s, m, r, } = opts;
-                const atom = this.root.SIGNALS.create(key, typeof value === "function" ? value() : value, opts, s, m, r,);
-                atom.historyMax = cap;
-                const next = atom.write((previous: A) => typeof value === "function" ? (value as (prev: T | undefined) => T)(previous) : value, { source, triggerRender },);
-                const listeners = this.__subscribers.get(r)?.get(m)?.get(s)?.get(key);
-                if (listeners) {
-                    for (const listener of listeners) {
-                        try { listener(next); }
-                        catch (error) { console.error(`[Sauron:state.subscribeAll] listener failed for "${String(atom.key)}":`, error,); }
-                    }
-                }
-                return MaybePromise(next);
-            },
-
-            subscribe: <T = A>(key: SignalKey, listener: (value: T) => void, opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },): Unsubscribe => {
-                let msMap = this.__subscribers.get(opts.r);
-
-                if (!msMap) { msMap = new Map(); this.__subscribers.set(opts.r, msMap); }
-                let slMap = msMap.get(opts.m);
-                if (!slMap) { slMap = new Map(); msMap.set(opts.m, slMap); }
-                let keyMap = slMap.get(opts.s);
-                if (!keyMap) { keyMap = new Map(); slMap.set(opts.s, keyMap); }
-                let listeners = keyMap.get(key);
-                if (!listeners) { listeners = new Set(); keyMap.set(key, listeners); }
-
-                listeners.add(listener);
-
-                return () => {
-                    listeners!.delete(listener);
-                    if (listeners!.size === 0) { keyMap!.delete(key); }
-                    if (keyMap!.size === 0) { slMap!.delete(opts.s); }
-                    if (slMap!.size === 0) { msMap!.delete(opts.m); }
-                    if (msMap!.size === 0) { this.__subscribers.delete(opts.r); }
-                };
-            },
-
-            delete: (key: SignalKey, opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, }): boolean => {
-                const { s, m, r } = opts;
-                const registry = this.root.SIGNALS.atom_reg(s, m, r);
-                const atom = this.root.SIGNALS.get(key, s, m, r);
-                if (!atom) return false;
-                const previous = atom.peek();
-                const resolvedKey = this.root.SIGNALS.resolveKey(key, s, m, r);
-                const listeners = this.__subscribers.get(r)?.get(m)?.get(s)?.get(key);
-                if (listeners) for (const listener of listeners) {
-                    try { listener({ key: atom.key, previous, current: undefined, version: atom.version + 1, timestamp: Date.now(), source: "state.delete" }); }
-                    catch (error) { console.error(`[Sauron:state.delete] listener failed for "${String(key)}":`, error); }
-                }
-                const subscribers = this._externalSubscribers.get(r)?.get(m)?.get(s)?.get(key);
-                if (subscribers) for (const notify of subscribers) {
-                    try { notify(undefined); }
-                    catch (error) { console.error(`[Sauron:state.delete] external subscriber failed for "${String(key)}":`, error); }
-                }
-                registry.delete(resolvedKey);
-                return MaybePromise(true);
-            },
-            entries: <T = A>(opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },): [SignalKey, T][] => {
-                const { s, m, r, } = opts;
-                const registry = this.root.SIGNALS.atom_reg(s, m, r,);
-                return MaybePromise([...registry.entries()].map(([key, atom]) => [key, atom.read() as T,]),
-                );
-            },
-            persist: (key: SignalKey, opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },): void => {
-                const atom = this.root.SIGNALS.atom_reg(opts.s, opts.m, opts.r,).get(key);
-                if (!atom) return;
-                atom.persisted = true;
-                setSS(String(atom.key), atom.peek(),);
-            },
-            unpersist: (key: SignalKey, opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },): void => {
-                const atom = this.root.SIGNALS.get(key, opts.s, opts.m, opts.r,);
-                if (!atom) return;
-                atom.persisted = false;
-                deleteSS(String(atom.key));
-            },
-            has: (key: SignalKey, opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },): boolean => {
-                const registry = this.root.SIGNALS.atom_reg(opts.s, opts.m, opts.r,);
-                const resolvedKey = this.root.SIGNALS.resolveKey(key, opts.s, opts.m, opts.r,);
-                return registry.has(resolvedKey);
-            },
-            clear: (opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },): void => {
-                const registry = this.root.SIGNALS.atom_reg(opts.s, opts.m, opts.r,);
-                for (const atom of registry.values()) {
-                    for (const notify of atom.externalSubscribers) {
-                        try {
-                            notify();
-                        } catch (error) {
-                            console.error(
-                                `[Sauron:state.clear] external subscriber failed:`,
-                                error,
-                            );
-                        }
-                    }
-
-                    atom.listeners.clear();
-                    atom.externalSubscribers.clear();
-                    atom.waiters.clear();
-                }
-
-                registry.clear();
-            },
-            clearPersistent: (opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },): void => {
-                const registry = this.root.SIGNALS.atom_reg(opts.s, opts.m, opts.r,);
-
-                for (const atom of registry.values()) {
-                    if (!atom.persisted) continue;
-
-                    atom.persisted = false;
-                    deleteSS(String(atom.key));
-                }
-            },
-            _emit: (key: SignalKey, s = this.s, m = this.m, r = this.r,): void => {
-                const atom = this.root.SIGNALS.atom_reg(s, m, r,).get('_LISTENERS').get(key);
-                if (!atom) return;
-                const value = atom.peek();
-                for (const listener of atom.listeners) {
-                    listener({ key: atom.key, previous: value, current: value, version: atom.version, timestamp: Date.now(), source: "state.emit", });
-                }
-
-                for (const notify of atom.externalSubscribers) { notify(); }
-            },
-        };
-        return sa
-    })();
-    public state2 = (() => {
-        const sa = {
-            get: <T = A>(key: SignalKey, opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },): T | undefined => {
-                return MaybePromise(this.store.get<T>(key, opts) as T);
-            },
-            set: <T = A>(key: SignalKey, value: T | ((prev: T | undefined) => T), opts: { triggerRender?: boolean; } & ScopeOptions = { s: this.s, m: this.m, r: this.r, },) => {
-                this.store.set(key, value, { triggerRender: opts.triggerRender ?? true, s: opts.s, m: opts.m, r: opts.r, source: "state.set", });
-                return MaybePromise(value as T);
-            },
-            delete: (key: SignalKey, opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },): boolean => {
-                return this.store.delete(key, opts);
-            },
-            getByPrefix: <T = A>(prefix: string, opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },) => {
-                return this.store.entries<T>(opts).filter(([key]) => { return typeof key === "string" && key.startsWith(prefix); }).map(([key, value]) => ({ key: key as string, value, }));
-            },
-            getAll: <T = A>(opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },): Record<string | symbol, T> => {
-                const result: Record<string | symbol, T> = {};
-                for (const [key, value] of this.store.entries<T>(opts)) { result[key] = value; }
-                return result;
-            },
-            subscribe: <T = A>(key: SignalKey, listener: (value: T) => void, opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },): Unsubscribe => {
-                return this.store.subscribe<T>(key, listener, opts);
-            },
-            subscribeAll: (listener: (key: SignalKey, value: unknown) => void, opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },): Unsubscribe => {
-                const scope = this.root.SIGNALS.get(opts.s, opts.m, opts.r,);
-                return () => { scope.listeners.delete(listener); };
-            },
-            clear: (opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },): void => {
-                this.store.clear(opts);
-            },
-            waitFor: <T = A>(key: SignalKey, opts: ScopeOptions = { s: this.s, m: this.m, r: this.r, },): Promise<T> => {
-                const atom = this.root.SIGNALS.get(opts.s, opts.m, opts.r,);
-                if (!atom) { return new Promise<T>(() => { }); }
-
-                if (atom.hasWritten) {
-                    return Promise.resolve(atom.read());
-                }
-
-                return atom.waitForNext();
-            },
-        };
-        return sa
-    })(); */
-    _devRecord: ((componentId: string, hookName: string, sauronId: string, key: string, value: A) => void) | null;
-    devRecord(componentId: string, hookName: string, sauronId: string, key: string, value: A): void | undefined;
-    registerDevRecorder(fn: typeof this._devRecord): void;
-    rerender: (key?: string) => void;
-    flushHookKey: (key: string) => void;
-    _flushHookNotifications: () => void;
-    getCurrentComponent: () => ComponentInstance;
-    unmountComponent(id: string): void;
-    mountComponent(id: string, renderFn?: () => void): ComponentInstance;
-    hmrPreserve(): Map<string, Map<string, A>>;
-    hmrRestore(snapshot: Map<string, Map<string, A>>): void;
-    subscribeToHook(key: string, cb: () => void): () => void;
-    notifyHook(key: string): void;
-    endHookDependencyCapture(): void;
-    beginHookDependencyCapture(hook: HookState): void;
-    registerDOMBinding(node: Node, update: (node: Node, value: A) => void): (() => void) | undefined;
-    setCurrentComponent(instance: ComponentInstance | null): void;
-    registerDOMRef(name: string, node: Node): void;
-    getDOMRef(name: string): Node | undefined;
-    registerAdapter(adapter: RuntimeAdapter): void;
-    _reactHookCursor: number;
-    _currentRenderInstanceCheck: A;
-    _isReactRenderContext(): boolean;
-    createHook<T>(hookName: string, sauronId: string, initializer: () => HookState, updater: (state: HookState, key: string, notify: (key: string) => void) => T, triggerRender?: boolean): T;
-    _broadcastSS(key: A, value: A, storageType: S, fn: S, path?: S, domain?: S, options?: A): void;
-    getChain<T = A>(key: A, s?: S, m?: S, r?: S, chain?: CHAIN): any;
-    getReChain<T = A>(key: A, s?: S, m?: S, r?: S): any;
-    get<T = A>(key: A, s?: S, m?: S, r?: S): any;
-    getSauron<T = A>(key: A, s?: S, m?: S, r?: S): any;
-    getAll<T = A>(opts?: ScopeOptions): Record<S | symbol, T>;
-    getAllSauron<T = A>(opts?: ScopeOptions): Record<S | symbol, T>;
-    getMany<T = A>(keys: S[], s?: S, m?: S, r?: S): Promise<Record<string, T | undefined>>;
-    setChain<T = A>(label: A, value: T, triggerRender?: boolean, s?: S, m?: S, r?: S): any;
-    set<T = A>(label: A, value: T, triggerRender?: boolean, s?: S, m?: S, r?: S): any;
-    setSauron<T = A>(label: S, value: T, triggerRender?: boolean, s?: S, m?: S, r?: S): any;
-    setMany<T = Record<S, A>>(entries: T): Promise<void>;
-    subChain<T = A>(label: S, fn: (value: T) => V, s?: S, m?: S, r?: S): any;
-    sub<T = A>(label: A, fn: (value: T) => V, s?: S, m?: S, r?: S): () => V;
-    /**
- * subSauronInfinity<MyType>('myKey', (value) => {
-    console.log(value) // every value
-})
- */
-    subSauron<T = A>(k: A, fn: (value: T) => void, s?: S, m?: S, r?: S): () => void;
-    subAll(fn: (key: A, value: A) => void, s?: S, m?: S, r?: S): () => V;
-    subAllSauron(fn: (key: S | symbol, value: A) => V, s?: S, m?: S, r?: S): () => V;
-    delSauron(label: S, s?: S, m?: S, r?: S): B;
-    deleteSauron(label: A, s?: S, m?: S, r?: S): B;
-    deleteChain(label: A, s?: S, m?: S, r?: S): any;
-    deleteMany(keys: A[], s?: S, m?: S, r?: S): P<B>;
-    waitFor<T = A>(label: S, s?: S, m?: S, r?: S): P<T>;
-    waitForSauron<T = A>(label: S, s?: S, m?: S, r?: S): P<T>;
-}
-declare class DRSTimeTravel {
-    root: ROOT;
-    _time_travel_reverting: boolean;
-    constructor(root: ROOT);
-    private get sauron();
-    private defaultChannels;
-    private resolveChannels;
-    private resolveHistory;
-    history: <T = unknown>(key: SignalKey, channels?: HistoryChannels) => readonly HistoryEntry<T>[];
-    private replay;
-    graft: (drs: A) => any;
-    back: <T = unknown>(key: SignalKey, steps?: number, channels?: HistoryChannels) => T | undefined;
-    forward: <T = unknown>(key: SignalKey, steps?: number, channels?: HistoryChannels) => T | undefined;
-    goto: <T = unknown>(key: SignalKey, sequence: number, channels?: HistoryChannels) => T | undefined;
-}
-export declare class ROOT {
-    SAURON: SAURON;
-    TIME_TRAVEL: DRSTimeTravel;
-    SIGNALS: SIGNALS;
-    r: S;
-    m: S;
-    s: S;
-    isReact: boolean;
-    IS_THE_WIZARD: boolean;
-    constructor();
-}
-export declare const root: ROOT;
-export declare const signals: SIGNALS;
-export declare const _root: ComponentInstance;
-export declare const getNestedMap: <K, V>(s?: any, m?: any, r?: any) => Map<K, V>;
-export declare const getMetadata: (s?: any, m?: any, r?: any) => any;
-export declare const scheduleGlobalNotify: (key: string | symbol, meta: A, opts: ScopeOptions) => void;
-export declare const scheduleNotify: (key: A, _listeners: Map<A, Set<(value: A) => void>>, _state: Map<A, A>) => void;
-export declare const state: SauronState;
-export declare const _devRecord: ((componentId: string, hookName: string, sauronId: string, key: string, value: A) => void) | null;
-export declare const devRecord: (componentId: string, hookName: string, sauronId: string, key: string, value: A) => void | undefined;
-export declare const registerDevRecorder: (fn: typeof this._devRecord) => void;
-export declare const rerender: (key?: string) => void;
-export declare const flushHookKey: (key: string) => void;
-export declare const _flushHookNotifications: () => void;
-export declare const getCurrentComponent: () => ComponentInstance;
-export declare const unmountComponent: (id: string) => void;
-export declare const mountComponent: (id: string, renderFn?: () => void) => ComponentInstance;
-export declare const hmrPreserve: () => Map<string, Map<string, A>>;
-export declare const hmrRestore: (snapshot: Map<string, Map<string, A>>) => void;
-export declare const subscribeToHook: (key: string, cb: () => void) => () => void;
-export declare const notifyHook: (key: string) => void;
-export declare const endHookDependencyCapture: () => void;
-export declare const beginHookDependencyCapture: (hook: HookState) => void;
-export declare const registerDOMBinding: (node: Node, update: (node: Node, value: A) => void) => (() => void) | undefined;
-export declare const setCurrentComponent: (instance: ComponentInstance | null) => void;
-export declare const registerDOMRef: (name: string, node: Node) => void;
-export declare const getDOMRef: (name: string) => Node | undefined;
-export declare const registerAdapter: (adapter: RuntimeAdapter) => void;
-export declare const _reactHookCursor: number;
-export declare const _currentRenderInstanceCheck: any;
-export declare const _isReactRenderContext: () => boolean;
-export declare const createHook: <T>(hookName: string, sauronId: string, initializer: () => HookState, updater: (state: HookState, key: string, notify: (key: string) => void) => T, triggerRender?: boolean) => T;
-export declare const _broadcastSS: (key: A, value: A, storageType: S, fn: S, path?: S, domain?: S, options?: A) => void;
-export declare const getChain: <T = any>(key: A, s?: S, m?: S, r?: S, chain?: CHAIN) => any;
-export declare const getReChain: <T = any>(key: A, s?: S, m?: S, r?: S) => any;
-export declare const get: <T = any>(key: A, s?: S, m?: S, r?: S) => any;
-export declare const getSauron: <T = any>(key: A, s?: S, m?: S, r?: S) => any;
-export declare const getAll: <T = any>(opts?: ScopeOptions) => Record<S | symbol, T>;
-export declare const getAllSauron: <T = any>(opts?: ScopeOptions) => Record<S | symbol, T>;
-export declare const getMany: <T = any>(keys: S[], s?: S, m?: S, r?: S) => Promise<Record<string, T | undefined>>;
-export declare const setChain: <T = any>(label: A, value: T, triggerRender?: boolean, s?: S, m?: S, r?: S) => any;
-export declare const set: <T = any>(label: A, value: T, triggerRender?: boolean, s?: S, m?: S, r?: S) => any;
-export declare const setSauron: <T = any>(label: S, value: T, triggerRender?: boolean, s?: S, m?: S, r?: S) => any;
-export declare const setMany: <T = Record<string, any>>(entries: T) => Promise<void>;
-export declare const subChain: <T = any>(label: S, fn: (value: T) => V, s?: S, m?: S, r?: S) => any;
-export declare const sub: <T = any>(label: A, fn: (value: T) => V, s?: S, m?: S, r?: S) => () => V;
-export declare const subSauron: <T = any>(k: A, fn: (value: T) => void, s?: S, m?: S, r?: S) => () => void;
-export declare const subAll: (fn: (key: A, value: A) => void, s?: S, m?: S, r?: S) => () => V;
-export declare const subAllSauron: (fn: (key: S | symbol, value: A) => V, s?: S, m?: S, r?: S) => () => V;
-export declare const delSauron: (label: S, s?: S, m?: S, r?: S) => B;
-export declare const deleteSauron: (label: A, s?: S, m?: S, r?: S) => B;
-export declare const deleteChain: (label: A, s?: S, m?: S, r?: S) => any;
-export declare const deleteMany: (keys: A[], s?: S, m?: S, r?: S) => P<B>;
-export declare const waitFor: <T = any>(label: S, s?: S, m?: S, r?: S) => P<T>;
-export declare const waitForSauron: <T = any>(label: S, s?: S, m?: S, r?: S) => P<T>;
-interface sidtype {
-    (): S;
-}
-declare global {
-    var _sid: sidtype;
-    var createHook: <T>(hookName: string, sauronId: string, initializer: () => HookState, updater: (state: HookState, key: string, notify: (key: string) => void) => T, triggerRender?: boolean) => T;
-}
-export {};