@astral/mobx-query 1.15.1 → 1.16.1

package/node/__test/documentMock/documentMock.d.ts

@@ -0,0 +1,380 @@
+export declare const createDocumentMock: () => {
+    documentMock: {
+        readonly URL: string;
+        alinkColor: string;
+        readonly all: HTMLAllCollection;
+        readonly anchors: HTMLCollectionOf<HTMLAnchorElement>;
+        readonly applets: HTMLCollection;
+        bgColor: string;
+        body: HTMLElement;
+        readonly characterSet: string;
+        readonly charset: string;
+        readonly compatMode: string;
+        readonly contentType: string;
+        cookie: string;
+        readonly currentScript: HTMLOrSVGScriptElement | null;
+        readonly defaultView: (WindowProxy & typeof globalThis) | null;
+        designMode: string;
+        dir: string;
+        readonly doctype: DocumentType | null;
+        readonly documentElement: HTMLElement;
+        readonly documentURI: string;
+        domain: string;
+        readonly embeds: HTMLCollectionOf<HTMLEmbedElement>;
+        fgColor: string;
+        readonly forms: HTMLCollectionOf<HTMLFormElement>;
+        readonly fragmentDirective: FragmentDirective;
+        readonly fullscreen: boolean;
+        readonly fullscreenEnabled: boolean;
+        readonly head: HTMLHeadElement;
+        readonly hidden: boolean;
+        readonly images: HTMLCollectionOf<HTMLImageElement>;
+        readonly implementation: DOMImplementation;
+        readonly inputEncoding: string;
+        readonly lastModified: string;
+        linkColor: string;
+        readonly links: HTMLCollectionOf<HTMLAnchorElement | HTMLAreaElement>;
+        location: Location;
+        onfullscreenchange: ((this: Document, ev: Event) => any) | null;
+        onfullscreenerror: ((this: Document, ev: Event) => any) | null;
+        onpointerlockchange: ((this: Document, ev: Event) => any) | null;
+        onpointerlockerror: ((this: Document, ev: Event) => any) | null;
+        onreadystatechange: ((this: Document, ev: Event) => any) | null;
+        onvisibilitychange: ((this: Document, ev: Event) => any) | null;
+        readonly ownerDocument: null;
+        readonly pictureInPictureEnabled: boolean;
+        readonly plugins: HTMLCollectionOf<HTMLEmbedElement>;
+        readonly readyState: DocumentReadyState;
+        readonly referrer: string;
+        readonly rootElement: SVGSVGElement | null;
+        readonly scripts: HTMLCollectionOf<HTMLScriptElement>;
+        readonly scrollingElement: Element | null;
+        readonly timeline: DocumentTimeline;
+        title: string;
+        readonly visibilityState: DocumentVisibilityState;
+        vlinkColor: string;
+        adoptNode: (<T extends Node>(node: T) => T) & import("vitest-mock-extended").CalledWithMock<Node, [node: Node]>;
+        captureEvents: (() => void) & import("vitest-mock-extended").CalledWithMock<void, []>;
+        caretPositionFromPoint: ((x: number, y: number, options?: CaretPositionFromPointOptions) => CaretPosition | null) & import("vitest-mock-extended").CalledWithMock<CaretPosition | null, [x: number, y: number, options?: CaretPositionFromPointOptions | undefined]>;
+        caretRangeFromPoint: ((x: number, y: number) => Range | null) & import("vitest-mock-extended").CalledWithMock<Range | null, [x: number, y: number]>;
+        clear: (() => void) & import("vitest-mock-extended").CalledWithMock<void, []>;
+        close: (() => void) & import("vitest-mock-extended").CalledWithMock<void, []>;
+        createAttribute: ((localName: string) => Attr) & import("vitest-mock-extended").CalledWithMock<Attr, [localName: string]>;
+        createAttributeNS: ((namespace: string | null, qualifiedName: string) => Attr) & import("vitest-mock-extended").CalledWithMock<Attr, [namespace: string | null, qualifiedName: string]>;
+        createCDATASection: ((data: string) => CDATASection) & import("vitest-mock-extended").CalledWithMock<CDATASection, [data: string]>;
+        createComment: ((data: string) => Comment) & import("vitest-mock-extended").CalledWithMock<Comment, [data: string]>;
+        createDocumentFragment: (() => DocumentFragment) & import("vitest-mock-extended").CalledWithMock<DocumentFragment, []>;
+        createElement: {
+            <K extends keyof HTMLElementTagNameMap>(tagName: K, options?: ElementCreationOptions): HTMLElementTagNameMap[K];
+            <K extends keyof HTMLElementDeprecatedTagNameMap>(tagName: K, options?: ElementCreationOptions): HTMLElementDeprecatedTagNameMap[K];
+            (tagName: string, options?: ElementCreationOptions): HTMLElement;
+        } & import("vitest-mock-extended").CalledWithMock<HTMLElement, [tagName: string, options?: ElementCreationOptions | undefined]>;
+        createElementNS: {
+            (namespaceURI: "http://www.w3.org/1999/xhtml", qualifiedName: string): HTMLElement;
+            <K extends keyof SVGElementTagNameMap>(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: K): SVGElementTagNameMap[K];
+            (namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: string): SVGElement;
+            <K extends keyof MathMLElementTagNameMap>(namespaceURI: "http://www.w3.org/1998/Math/MathML", qualifiedName: K): MathMLElementTagNameMap[K];
+            (namespaceURI: "http://www.w3.org/1998/Math/MathML", qualifiedName: string): MathMLElement;
+            (namespaceURI: string | null, qualifiedName: string, options?: ElementCreationOptions): Element;
+            (namespace: string | null, qualifiedName: string, options?: string | ElementCreationOptions): Element;
+        } & import("vitest-mock-extended").CalledWithMock<Element, [namespace: string | null, qualifiedName: string, options?: string | ElementCreationOptions | undefined]>;
+        createEvent: {
+            (eventInterface: "AnimationEvent"): AnimationEvent;
+            (eventInterface: "AnimationPlaybackEvent"): AnimationPlaybackEvent;
+            (eventInterface: "AudioProcessingEvent"): AudioProcessingEvent;
+            (eventInterface: "BeforeUnloadEvent"): BeforeUnloadEvent;
+            (eventInterface: "BlobEvent"): BlobEvent;
+            (eventInterface: "ClipboardEvent"): ClipboardEvent;
+            (eventInterface: "CloseEvent"): CloseEvent;
+            (eventInterface: "CompositionEvent"): CompositionEvent;
+            (eventInterface: "ContentVisibilityAutoStateChangeEvent"): ContentVisibilityAutoStateChangeEvent;
+            (eventInterface: "CustomEvent"): CustomEvent;
+            (eventInterface: "DeviceMotionEvent"): DeviceMotionEvent;
+            (eventInterface: "DeviceOrientationEvent"): DeviceOrientationEvent;
+            (eventInterface: "DragEvent"): DragEvent;
+            (eventInterface: "ErrorEvent"): ErrorEvent;
+            (eventInterface: "Event"): Event;
+            (eventInterface: "Events"): Event;
+            (eventInterface: "FocusEvent"): FocusEvent;
+            (eventInterface: "FontFaceSetLoadEvent"): FontFaceSetLoadEvent;
+            (eventInterface: "FormDataEvent"): FormDataEvent;
+            (eventInterface: "GamepadEvent"): GamepadEvent;
+            (eventInterface: "HashChangeEvent"): HashChangeEvent;
+            (eventInterface: "IDBVersionChangeEvent"): IDBVersionChangeEvent;
+            (eventInterface: "InputEvent"): InputEvent;
+            (eventInterface: "KeyboardEvent"): KeyboardEvent;
+            (eventInterface: "MIDIConnectionEvent"): MIDIConnectionEvent;
+            (eventInterface: "MIDIMessageEvent"): MIDIMessageEvent;
+            (eventInterface: "MediaEncryptedEvent"): MediaEncryptedEvent;
+            (eventInterface: "MediaKeyMessageEvent"): MediaKeyMessageEvent;
+            (eventInterface: "MediaQueryListEvent"): MediaQueryListEvent;
+            (eventInterface: "MediaStreamTrackEvent"): MediaStreamTrackEvent;
+            (eventInterface: "MessageEvent"): MessageEvent;
+            (eventInterface: "MouseEvent"): MouseEvent;
+            (eventInterface: "MouseEvents"): MouseEvent;
+            (eventInterface: "OfflineAudioCompletionEvent"): OfflineAudioCompletionEvent;
+            (eventInterface: "PageRevealEvent"): PageRevealEvent;
+            (eventInterface: "PageSwapEvent"): PageSwapEvent;
+            (eventInterface: "PageTransitionEvent"): PageTransitionEvent;
+            (eventInterface: "PaymentMethodChangeEvent"): PaymentMethodChangeEvent;
+            (eventInterface: "PaymentRequestUpdateEvent"): PaymentRequestUpdateEvent;
+            (eventInterface: "PictureInPictureEvent"): PictureInPictureEvent;
+            (eventInterface: "PointerEvent"): PointerEvent;
+            (eventInterface: "PopStateEvent"): PopStateEvent;
+            (eventInterface: "ProgressEvent"): ProgressEvent;
+            (eventInterface: "PromiseRejectionEvent"): PromiseRejectionEvent;
+            (eventInterface: "RTCDTMFToneChangeEvent"): RTCDTMFToneChangeEvent;
+            (eventInterface: "RTCDataChannelEvent"): RTCDataChannelEvent;
+            (eventInterface: "RTCErrorEvent"): RTCErrorEvent;
+            (eventInterface: "RTCPeerConnectionIceErrorEvent"): RTCPeerConnectionIceErrorEvent;
+            (eventInterface: "RTCPeerConnectionIceEvent"): RTCPeerConnectionIceEvent;
+            (eventInterface: "RTCTrackEvent"): RTCTrackEvent;
+            (eventInterface: "SecurityPolicyViolationEvent"): SecurityPolicyViolationEvent;
+            (eventInterface: "SpeechSynthesisErrorEvent"): SpeechSynthesisErrorEvent;
+            (eventInterface: "SpeechSynthesisEvent"): SpeechSynthesisEvent;
+            (eventInterface: "StorageEvent"): StorageEvent;
+            (eventInterface: "SubmitEvent"): SubmitEvent;
+            (eventInterface: "TextEvent"): TextEvent;
+            (eventInterface: "ToggleEvent"): ToggleEvent;
+            (eventInterface: "TouchEvent"): TouchEvent;
+            (eventInterface: "TrackEvent"): TrackEvent;
+            (eventInterface: "TransitionEvent"): TransitionEvent;
+            (eventInterface: "UIEvent"): UIEvent;
+            (eventInterface: "UIEvents"): UIEvent;
+            (eventInterface: "WebGLContextEvent"): WebGLContextEvent;
+            (eventInterface: "WheelEvent"): WheelEvent;
+            (eventInterface: string): Event;
+        } & import("vitest-mock-extended").CalledWithMock<Event, [eventInterface: string]>;
+        createNodeIterator: ((root: Node, whatToShow?: number, filter?: NodeFilter | null) => NodeIterator) & import("vitest-mock-extended").CalledWithMock<NodeIterator, [root: Node, whatToShow?: number | undefined, filter?: NodeFilter | null | undefined]>;
+        createProcessingInstruction: ((target: string, data: string) => ProcessingInstruction) & import("vitest-mock-extended").CalledWithMock<ProcessingInstruction, [target: string, data: string]>;
+        createRange: (() => Range) & import("vitest-mock-extended").CalledWithMock<Range, []>;
+        createTextNode: ((data: string) => Text) & import("vitest-mock-extended").CalledWithMock<Text, [data: string]>;
+        createTreeWalker: ((root: Node, whatToShow?: number, filter?: NodeFilter | null) => TreeWalker) & import("vitest-mock-extended").CalledWithMock<TreeWalker, [root: Node, whatToShow?: number | undefined, filter?: NodeFilter | null | undefined]>;
+        execCommand: ((commandId: string, showUI?: boolean, value?: string) => boolean) & import("vitest-mock-extended").CalledWithMock<boolean, [commandId: string, showUI?: boolean | undefined, value?: string | undefined]>;
+        exitFullscreen: (() => Promise<void>) & import("vitest-mock-extended").CalledWithMock<Promise<void>, []>;
+        exitPictureInPicture: (() => Promise<void>) & import("vitest-mock-extended").CalledWithMock<Promise<void>, []>;
+        exitPointerLock: (() => void) & import("vitest-mock-extended").CalledWithMock<void, []>;
+        getElementById: ((elementId: string) => HTMLElement | null) & import("vitest-mock-extended").CalledWithMock<HTMLElement | null, [elementId: string]>;
+        getElementsByClassName: ((classNames: string) => HTMLCollectionOf<Element>) & import("vitest-mock-extended").CalledWithMock<HTMLCollectionOf<Element>, [classNames: string]>;
+        getElementsByName: ((elementName: string) => NodeListOf<HTMLElement>) & import("vitest-mock-extended").CalledWithMock<NodeListOf<HTMLElement>, [elementName: string]>;
+        getElementsByTagName: {
+            <K extends keyof HTMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementTagNameMap[K]>;
+            <K extends keyof SVGElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<SVGElementTagNameMap[K]>;
+            <K extends keyof MathMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<MathMLElementTagNameMap[K]>;
+            <K extends keyof HTMLElementDeprecatedTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementDeprecatedTagNameMap[K]>;
+            (qualifiedName: string): HTMLCollectionOf<Element>;
+        } & import("vitest-mock-extended").CalledWithMock<HTMLCollectionOf<Element>, [qualifiedName: string]>;
+        getElementsByTagNameNS: {
+            (namespaceURI: "http://www.w3.org/1999/xhtml", localName: string): HTMLCollectionOf<HTMLElement>;
+            (namespaceURI: "http://www.w3.org/2000/svg", localName: string): HTMLCollectionOf<SVGElement>;
+            (namespaceURI: "http://www.w3.org/1998/Math/MathML", localName: string): HTMLCollectionOf<MathMLElement>;
+            (namespace: string | null, localName: string): HTMLCollectionOf<Element>;
+        } & import("vitest-mock-extended").CalledWithMock<HTMLCollectionOf<Element>, [namespace: string | null, localName: string]>;
+        getSelection: (() => Selection | null) & import("vitest-mock-extended").CalledWithMock<Selection | null, []>;
+        hasFocus: (() => boolean) & import("vitest-mock-extended").CalledWithMock<boolean, []>;
+        hasStorageAccess: (() => Promise<boolean>) & import("vitest-mock-extended").CalledWithMock<Promise<boolean>, []>;
+        importNode: (<T extends Node>(node: T, subtree?: boolean) => T) & import("vitest-mock-extended").CalledWithMock<Node, [node: Node, subtree?: boolean | undefined]>;
+        open: {
+            (unused1?: string, unused2?: string): Document;
+            (url: string | URL, name: string, features: string): WindowProxy | null;
+        } & import("vitest-mock-extended").CalledWithMock<Window | null, [url: string | URL, name: string, features: string]>;
+        queryCommandEnabled: ((commandId: string) => boolean) & import("vitest-mock-extended").CalledWithMock<boolean, [commandId: string]>;
+        queryCommandIndeterm: ((commandId: string) => boolean) & import("vitest-mock-extended").CalledWithMock<boolean, [commandId: string]>;
+        queryCommandState: ((commandId: string) => boolean) & import("vitest-mock-extended").CalledWithMock<boolean, [commandId: string]>;
+        queryCommandSupported: ((commandId: string) => boolean) & import("vitest-mock-extended").CalledWithMock<boolean, [commandId: string]>;
+        queryCommandValue: ((commandId: string) => string) & import("vitest-mock-extended").CalledWithMock<string, [commandId: string]>;
+        releaseEvents: (() => void) & import("vitest-mock-extended").CalledWithMock<void, []>;
+        requestStorageAccess: (() => Promise<void>) & import("vitest-mock-extended").CalledWithMock<Promise<void>, []>;
+        startViewTransition: ((callbackOptions?: ViewTransitionUpdateCallback) => ViewTransition) & import("vitest-mock-extended").CalledWithMock<ViewTransition, [callbackOptions?: ViewTransitionUpdateCallback | undefined]>;
+        write: ((...text: string[]) => void) & import("vitest-mock-extended").CalledWithMock<void, string[]>;
+        writeln: ((...text: string[]) => void) & import("vitest-mock-extended").CalledWithMock<void, string[]>;
+        addEventListener: {
+            <K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        } & import("vitest-mock-extended").CalledWithMock<void, [type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined]>;
+        removeEventListener: {
+            <K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+        } & import("vitest-mock-extended").CalledWithMock<void, [type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined]>;
+        readonly baseURI: string;
+        readonly childNodes: NodeListOf<ChildNode>;
+        readonly firstChild: ChildNode | null;
+        readonly isConnected: boolean;
+        readonly lastChild: ChildNode | null;
+        readonly nextSibling: ChildNode | null;
+        readonly nodeName: string;
+        readonly nodeType: number;
+        nodeValue: string | null;
+        readonly parentElement: HTMLElement | null;
+        readonly parentNode: ParentNode | null;
+        readonly previousSibling: ChildNode | null;
+        textContent: string | null;
+        appendChild: (<T extends Node>(node: T) => T) & import("vitest-mock-extended").CalledWithMock<Node, [node: Node]>;
+        cloneNode: ((subtree?: boolean) => Node) & import("vitest-mock-extended").CalledWithMock<Node, [subtree?: boolean | undefined]>;
+        compareDocumentPosition: ((other: Node) => number) & import("vitest-mock-extended").CalledWithMock<number, [other: Node]>;
+        contains: ((other: Node | null) => boolean) & import("vitest-mock-extended").CalledWithMock<boolean, [other: Node | null]>;
+        getRootNode: ((options?: GetRootNodeOptions) => Node) & import("vitest-mock-extended").CalledWithMock<Node, [options?: GetRootNodeOptions | undefined]>;
+        hasChildNodes: (() => boolean) & import("vitest-mock-extended").CalledWithMock<boolean, []>;
+        insertBefore: (<T extends Node>(node: T, child: Node | null) => T) & import("vitest-mock-extended").CalledWithMock<Node, [node: Node, child: Node | null]>;
+        isDefaultNamespace: ((namespace: string | null) => boolean) & import("vitest-mock-extended").CalledWithMock<boolean, [namespace: string | null]>;
+        isEqualNode: ((otherNode: Node | null) => boolean) & import("vitest-mock-extended").CalledWithMock<boolean, [otherNode: Node | null]>;
+        isSameNode: ((otherNode: Node | null) => boolean) & import("vitest-mock-extended").CalledWithMock<boolean, [otherNode: Node | null]>;
+        lookupNamespaceURI: ((prefix: string | null) => string | null) & import("vitest-mock-extended").CalledWithMock<string | null, [prefix: string | null]>;
+        lookupPrefix: ((namespace: string | null) => string | null) & import("vitest-mock-extended").CalledWithMock<string | null, [namespace: string | null]>;
+        normalize: (() => void) & import("vitest-mock-extended").CalledWithMock<void, []>;
+        removeChild: (<T extends Node>(child: T) => T) & import("vitest-mock-extended").CalledWithMock<Node, [child: Node]>;
+        replaceChild: (<T extends Node>(node: Node, child: T) => T) & import("vitest-mock-extended").CalledWithMock<Node, [node: Node, child: Node]>;
+        readonly ELEMENT_NODE: 1;
+        readonly ATTRIBUTE_NODE: 2;
+        readonly TEXT_NODE: 3;
+        readonly CDATA_SECTION_NODE: 4;
+        readonly ENTITY_REFERENCE_NODE: 5;
+        readonly ENTITY_NODE: 6;
+        readonly PROCESSING_INSTRUCTION_NODE: 7;
+        readonly COMMENT_NODE: 8;
+        readonly DOCUMENT_NODE: 9;
+        readonly DOCUMENT_TYPE_NODE: 10;
+        readonly DOCUMENT_FRAGMENT_NODE: 11;
+        readonly NOTATION_NODE: 12;
+        readonly DOCUMENT_POSITION_DISCONNECTED: 1;
+        readonly DOCUMENT_POSITION_PRECEDING: 2;
+        readonly DOCUMENT_POSITION_FOLLOWING: 4;
+        readonly DOCUMENT_POSITION_CONTAINS: 8;
+        readonly DOCUMENT_POSITION_CONTAINED_BY: 16;
+        readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: 32;
+        dispatchEvent: ((event: Event) => boolean) & import("vitest-mock-extended").CalledWithMock<boolean, [event: Event]>;
+        readonly activeElement: Element | null;
+        adoptedStyleSheets: CSSStyleSheet[];
+        readonly fullscreenElement: Element | null;
+        readonly pictureInPictureElement: Element | null;
+        readonly pointerLockElement: Element | null;
+        readonly styleSheets: StyleSheetList;
+        elementFromPoint: ((x: number, y: number) => Element | null) & import("vitest-mock-extended").CalledWithMock<Element | null, [x: number, y: number]>;
+        elementsFromPoint: ((x: number, y: number) => Element[]) & import("vitest-mock-extended").CalledWithMock<Element[], [x: number, y: number]>;
+        getAnimations: (() => Animation[]) & import("vitest-mock-extended").CalledWithMock<Animation[], []>;
+        readonly fonts: FontFaceSet;
+        onabort: ((this: GlobalEventHandlers, ev: UIEvent) => any) | null;
+        onanimationcancel: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
+        onanimationend: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
+        onanimationiteration: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
+        onanimationstart: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
+        onauxclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        onbeforeinput: ((this: GlobalEventHandlers, ev: InputEvent) => any) | null;
+        onbeforetoggle: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onblur: ((this: GlobalEventHandlers, ev: FocusEvent) => any) | null;
+        oncancel: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        oncanplay: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        oncanplaythrough: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        onclose: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        oncontextlost: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        oncontextmenu: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        oncontextrestored: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        oncopy: ((this: GlobalEventHandlers, ev: ClipboardEvent) => any) | null;
+        oncuechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        oncut: ((this: GlobalEventHandlers, ev: ClipboardEvent) => any) | null;
+        ondblclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        ondrag: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+        ondragend: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+        ondragenter: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+        ondragleave: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+        ondragover: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+        ondragstart: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+        ondrop: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+        ondurationchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onemptied: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onended: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onerror: OnErrorEventHandler;
+        onfocus: ((this: GlobalEventHandlers, ev: FocusEvent) => any) | null;
+        onformdata: ((this: GlobalEventHandlers, ev: FormDataEvent) => any) | null;
+        ongotpointercapture: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        oninput: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        oninvalid: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onkeydown: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
+        onkeypress: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
+        onkeyup: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
+        onload: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onloadeddata: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onloadedmetadata: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onloadstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onlostpointercapture: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        onmousedown: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        onmouseenter: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        onmouseleave: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        onmousemove: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        onmouseout: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        onmouseover: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        onmouseup: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        onpaste: ((this: GlobalEventHandlers, ev: ClipboardEvent) => any) | null;
+        onpause: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onplay: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onplaying: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onpointercancel: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        onpointerdown: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        onpointerenter: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        onpointerleave: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        onpointermove: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        onpointerout: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        onpointerover: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        onpointerup: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        onprogress: ((this: GlobalEventHandlers, ev: ProgressEvent) => any) | null;
+        onratechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onreset: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onresize: ((this: GlobalEventHandlers, ev: UIEvent) => any) | null;
+        onscroll: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onscrollend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onsecuritypolicyviolation: ((this: GlobalEventHandlers, ev: SecurityPolicyViolationEvent) => any) | null;
+        onseeked: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onseeking: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onselect: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onselectionchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onselectstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onslotchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onstalled: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onsubmit: ((this: GlobalEventHandlers, ev: SubmitEvent) => any) | null;
+        onsuspend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        ontimeupdate: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        ontoggle: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        ontouchcancel?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined | undefined;
+        ontouchend?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined | undefined;
+        ontouchmove?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined | undefined;
+        ontouchstart?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined | undefined;
+        ontransitioncancel: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
+        ontransitionend: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
+        ontransitionrun: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
+        ontransitionstart: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
+        onvolumechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onwaiting: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onwebkitanimationend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onwebkitanimationiteration: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onwebkitanimationstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onwebkittransitionend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onwheel: ((this: GlobalEventHandlers, ev: WheelEvent) => any) | null;
+        readonly childElementCount: number;
+        readonly children: HTMLCollection;
+        readonly firstElementChild: Element | null;
+        readonly lastElementChild: Element | null;
+        append: ((...nodes: (Node | string)[]) => void) & import("vitest-mock-extended").CalledWithMock<void, (string | Node)[]>;
+        prepend: ((...nodes: (Node | string)[]) => void) & import("vitest-mock-extended").CalledWithMock<void, (string | Node)[]>;
+        querySelector: {
+            <K extends keyof HTMLElementTagNameMap>(selectors: K): HTMLElementTagNameMap[K] | null;
+            <K extends keyof SVGElementTagNameMap>(selectors: K): SVGElementTagNameMap[K] | null;
+            <K extends keyof MathMLElementTagNameMap>(selectors: K): MathMLElementTagNameMap[K] | null;
+            <K extends keyof HTMLElementDeprecatedTagNameMap>(selectors: K): HTMLElementDeprecatedTagNameMap[K] | null;
+            <E extends Element = Element>(selectors: string): E | null;
+        } & import("vitest-mock-extended").CalledWithMock<Element | null, [selectors: string]>;
+        querySelectorAll: {
+            <K extends keyof HTMLElementTagNameMap>(selectors: K): NodeListOf<HTMLElementTagNameMap[K]>;
+            <K extends keyof SVGElementTagNameMap>(selectors: K): NodeListOf<SVGElementTagNameMap[K]>;
+            <K extends keyof MathMLElementTagNameMap>(selectors: K): NodeListOf<MathMLElementTagNameMap[K]>;
+            <K extends keyof HTMLElementDeprecatedTagNameMap>(selectors: K): NodeListOf<HTMLElementDeprecatedTagNameMap[K]>;
+            <E extends Element = Element>(selectors: string): NodeListOf<E>;
+        } & import("vitest-mock-extended").CalledWithMock<NodeListOf<Element>, [selectors: string]>;
+        replaceChildren: ((...nodes: (Node | string)[]) => void) & import("vitest-mock-extended").CalledWithMock<void, (string | Node)[]>;
+        createExpression: ((expression: string, resolver?: XPathNSResolver | null) => XPathExpression) & import("vitest-mock-extended").CalledWithMock<XPathExpression, [expression: string, resolver?: XPathNSResolver | null | undefined]>;
+        createNSResolver: ((nodeResolver: Node) => Node) & import("vitest-mock-extended").CalledWithMock<Node, [nodeResolver: Node]>;
+        evaluate: ((expression: string, contextNode: Node, resolver?: XPathNSResolver | null, type?: number, result?: XPathResult | null) => XPathResult) & import("vitest-mock-extended").CalledWithMock<XPathResult, [expression: string, contextNode: Node, resolver?: XPathNSResolver | null | undefined, type?: number | undefined, result?: XPathResult | null | undefined]>;
+    } & Document;
+    triggerVisibilityChange: () => void;
+};

package/node/__test/documentMock/documentMock.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDocumentMock = void 0;
+// biome-ignore lint/correctness/noUndeclaredDependencies: требуется для тестов
+const vitest_mock_extended_1 = require("vitest-mock-extended");
+const createDocumentMock = () => {
+    let isVisible = true;
+    const listeners = [];
+    const documentMock = (0, vitest_mock_extended_1.mock)({
+        addEventListener: (_, listener) => listeners.push(listener),
+        get visibilityState() {
+            return isVisible ? 'visible' : 'hidden';
+        },
+        set visibilityState(_) { },
+    });
+    const triggerVisibilityChange = () => {
+        isVisible = !isVisible;
+        listeners.forEach((listener) => listener());
+    };
+    return { documentMock, triggerVisibilityChange };
+};
+exports.createDocumentMock = createDocumentMock;

package/node/__test/documentMock/index.d.ts

@@ -0,0 +1 @@
+export * from './documentMock';

package/node/__test/documentMock/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./documentMock"), exports);

package/node/__test/index.d.ts

@@ -0,0 +1,2 @@
+export * from './documentMock';
+export * from './BroadcastChannel';

package/node/__test/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./documentMock"), exports);
+__exportStar(require("./BroadcastChannel"), exports);

package/package.json

@@ -9,7 +9,7 @@
   "peerDependencies": {
     "mobx": "^6.0.0"
   },
-  "version": "1.15.1",
+  "version": "1.16.1",
   "author": "Astral.Soft",
   "license": "MIT",
   "repository": {