very-happy-dom 0.0.7

package/dist/network/RequestInterceptor.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Network Request Interception
+ * Allows intercepting, modifying, and mocking network requests
+ */
+export declare interface InterceptedRequest {
+  url: string
+  method: string
+  headers: Record<string, string>
+  postData?: string | null
+  resourceType: string
+  continue: (overrides?: { url?: string, method?: string, headers?: Record<string, string>, postData?: string }) => void
+  abort: (errorCode?: string) => void
+  respond: (response: { status: number, headers?: Record<string, string>, body: string | ArrayBuffer }) => void
+}
+export declare interface RequestInterceptionHandler {
+  (request: InterceptedRequest): void | Promise<void>
+}
+/**
+ * Request Interceptor manages network request interception
+ */
+export declare class RequestInterceptor {
+  private _enabled: any;
+  private _handlers: any;
+  private _originalFetch: typeof fetch;
+  constructor();
+  enable(): void;
+  disable(): void;
+  addHandler(handler: RequestInterceptionHandler): void;
+  removeHandler(handler: RequestInterceptionHandler): void;
+  clear(): void;
+}

package/dist/network/WebSocket.d.ts

@@ -0,0 +1,47 @@
+declare interface MessageEvent extends Event {
+  data: any
+  origin: string
+  lastEventId: string
+  source: any
+  ports: any[]
+}
+declare interface CloseEvent extends Event {
+  code: number
+  reason: string
+  wasClean: boolean
+}
+declare type EventListener = (event: Event | MessageEvent | CloseEvent) => void
+export declare class VeryHappyWebSocket {
+  static readonly CONNECTING: number;
+  static readonly OPEN: number;
+  static readonly CLOSING: number;
+  static readonly CLOSED: number;
+  readyState: WebSocketReadyState;
+  url: string;
+  protocol: any;
+  extensions: any;
+  binaryType: 'blob' | 'arraybuffer';
+  bufferedAmount: any;
+  onopen: ((event: Event) => void) | null;
+  onmessage: ((event: MessageEvent) => void) | null;
+  onerror: ((event: Event) => void) | null;
+  onclose: ((event: CloseEvent) => void) | null;
+  private _ws: WebSocket | null;
+  private _eventListeners: any;
+  constructor(url: string, protocols?: string | string[]);
+  send(data: string | ArrayBuffer | Blob): void;
+  close(code?: number, reason?: string): void;
+  addEventListener(type: string, listener: EventListener): void;
+  removeEventListener(type: string, listener: EventListener): void;
+  dispatchEvent(event: Event | MessageEvent | CloseEvent): boolean;
+}
+/**
+ * WebSocket implementation
+ * Wraps Bun's native WebSocket for browser-like API
+ */
+export declare enum WebSocketReadyState {
+  CONNECTING = 0,
+  OPEN = 1,
+  CLOSING = 2,
+  CLOSED = 3,
+}

package/dist/nodes/VirtualCommentNode.d.ts

@@ -0,0 +1,10 @@
+import type { NodeType, VirtualNode } from './VirtualNode';
+export declare class VirtualCommentNode implements VirtualNode {
+  nodeType: NodeType;
+  nodeName: string;
+  nodeValue: string;
+  attributes: Map<string, string>;
+  children: VirtualNode[];
+  parentNode: VirtualNode | null;
+  constructor(text: string);
+}

package/dist/nodes/VirtualDocument.d.ts

@@ -0,0 +1,50 @@
+import { parseHTML } from '../parsers/html-parser';
+import { VirtualCommentNode } from './VirtualCommentNode';
+import { VirtualElement } from './VirtualElement';
+import { VirtualTextNode } from './VirtualTextNode';
+import { XPathResultType } from '../xpath/XPathResult';
+import type { History, HistoryState, Location, NodeType, VirtualNode } from './VirtualNode';
+import type { XPathResult } from '../xpath/XPathResult';
+/**
+ * Factory function to create a new virtual document
+ */
+export declare function createDocument(): VirtualDocument;
+export declare class VirtualDocument implements VirtualNode {
+  nodeType: NodeType;
+  nodeName: string;
+  nodeValue: string | null;
+  attributes: Map<string, string>;
+  children: VirtualNode[];
+  parentNode: VirtualNode | null;
+  documentElement: VirtualElement | null;
+  head: VirtualElement | null;
+  body: VirtualElement | null;
+  location: Location;
+  history: History;
+  title: any;
+  private _historyStack: HistoryState[];
+  private _historyIndex: any;
+  private _eventListeners: any;
+  private _xpathEvaluator: any;
+  private _cookies: Record<string, string>;
+  constructor();
+  private _updateLocation(url: string): void;
+  appendChild(child: VirtualNode): VirtualNode;
+  createElement(tagName: string): VirtualElement;
+  createTextNode(text: string): VirtualTextNode;
+  createComment(text: string): VirtualCommentNode;
+  createDocumentFragment(): VirtualElement;
+  querySelector(selector: string): VirtualElement | null;
+  querySelectorAll(selector: string): VirtualElement[];
+  getElementById(id: string): VirtualElement | null;
+  getElementsByTagName(tagName: string): VirtualElement[];
+  getElementsByClassName(className: string): VirtualElement[];
+  parseHTML(html: string): void;
+  write(html: string): void;
+  getComputedStyle(element: VirtualElement): any;
+  addEventListener(type: string, listener: (event: any) => void): void;
+  removeEventListener(type: string, listener: (event: any) => void): void;
+  dispatchEvent(event: any): boolean;
+  evaluate(expression: string, contextNode?: VirtualNode, resolver?: any, type?: XPathResultType, result?: XPathResult | null): XPathResult;
+  createExpression(expression: string, resolver?: any): any;
+}

package/dist/nodes/VirtualElement.d.ts

@@ -0,0 +1,43 @@
+import { ShadowRoot } from '../webcomponents/ShadowRoot';
+import { VirtualEvent } from '../events/VirtualEvent';
+import type { EventListener, EventListenerOptions, NodeType, VirtualNode } from './VirtualNode';
+import type { ShadowRootInit } from '../webcomponents/ShadowRoot';
+export declare class VirtualElement implements VirtualNode {
+  nodeType: NodeType;
+  nodeName: string;
+  nodeValue: string | null;
+  tagName: string;
+  attributes: Map<string, string>;
+  childNodes: VirtualNode[];
+  parentNode: VirtualNode | null;
+  shadowRoot: ShadowRoot | null;
+  private eventListeners: Map<string, EventListener[]>;
+  private _customValidity: string;
+  private _internalStyles: Map<string, string>;
+  constructor(tagName: string);
+  getAttribute(name: string): string | null;
+  setAttribute(name: string, value: string): void;
+  removeAttribute(name: string): void;
+  hasAttribute(name: string): boolean;
+  appendChild(child: VirtualNode): VirtualNode;
+  removeChild(child: VirtualNode): VirtualNode;
+  insertBefore(newNode: VirtualNode, referenceNode: VirtualNode | null): VirtualNode;
+  replaceChild(newNode: VirtualNode, oldNode: VirtualNode): VirtualNode;
+  cloneNode(deep?: any): VirtualElement;
+  closest(selector: string): VirtualElement | null;
+  private _serializeNode(node: VirtualNode): string;
+  private _updateStyleAttribute(): void;
+  setCustomValidity(message: string): void;
+  checkValidity(): boolean;
+  reportValidity(): boolean;
+  querySelector(selector: string): VirtualElement | null;
+  querySelectorAll(selector: string): VirtualElement[];
+  matches(selector: string): boolean;
+  addEventListener(type: string, listener: (event: VirtualEvent) => void, options?: EventListenerOptions | boolean): void;
+  removeEventListener(type: string, listener: (event: VirtualEvent) => void, options?: EventListenerOptions | boolean): void;
+  dispatchEvent(event: any): boolean;
+  private _invokeEventListeners(element: VirtualElement, event: VirtualEvent, capture: boolean): void;
+  click(): void;
+  isVisible(): boolean;
+  attachShadow(init: ShadowRootInit): ShadowRoot;
+}

package/dist/nodes/VirtualNode.d.ts

@@ -0,0 +1,47 @@
+export declare interface VirtualNode {
+  nodeType: NodeType
+  nodeName: string
+  nodeValue: string | null
+  attributes: Map<string, string>
+  children: VirtualNode[]
+  parentNode: VirtualNode | null
+  textContent: string
+}
+export declare interface EventListenerOptions {
+  capture?: boolean
+  once?: boolean
+  passive?: boolean
+}
+export declare interface EventListener {
+  listener: (event: any) => void
+  options: EventListenerOptions
+}
+export declare interface Location {
+  href: string
+  protocol: string
+  host: string
+  hostname: string
+  port: string
+  pathname: string
+  search: string
+  hash: string
+  origin: string
+  assign: (url: string) => void
+  replace: (url: string) => void
+  reload: () => void
+}
+export declare interface HistoryState {
+  state: any
+  title: string
+  url: string
+}
+export declare interface History {
+  length: number
+  state: any
+  pushState: (state: any, title: string, url?: string) => void
+  replaceState: (state: any, title: string, url?: string) => void
+  back: () => void
+  forward: () => void
+  go: (delta: number) => void
+}
+export type NodeType = 'element' | 'text' | 'comment' | 'document'

package/dist/nodes/VirtualTextNode.d.ts

@@ -0,0 +1,10 @@
+import type { NodeType, VirtualNode } from './VirtualNode';
+export declare class VirtualTextNode implements VirtualNode {
+  nodeType: NodeType;
+  nodeName: string;
+  nodeValue: string;
+  attributes: Map<string, string>;
+  children: VirtualNode[];
+  parentNode: VirtualNode | null;
+  constructor(text: string);
+}

package/dist/observers/IntersectionObserver.d.ts

@@ -0,0 +1,49 @@
+import type { VirtualElement } from '../nodes/VirtualElement';
+export declare interface IntersectionObserverInit {
+  root?: VirtualElement | null
+  rootMargin?: string
+  threshold?: number | number[]
+}
+export declare interface IntersectionObserverEntry {
+  boundingClientRect: DOMRectReadOnly
+  intersectionRatio: number
+  intersectionRect: DOMRectReadOnly
+  isIntersecting: boolean
+  rootBounds: DOMRectReadOnly | null
+  target: VirtualElement
+  time: number
+}
+declare interface DOMRectReadOnly {
+  x: number
+  y: number
+  width: number
+  height: number
+  top: number
+  right: number
+  bottom: number
+  left: number
+}
+export type IntersectionObserverCallback = (
+  entries: IntersectionObserverEntry[],
+  observer: IntersectionObserver
+) => void
+/**
+ * IntersectionObserver implementation
+ * Note: This is a simplified implementation for testing
+ * It simulates intersection behavior without actual viewport calculations
+ */
+export declare class IntersectionObserver {
+  root: VirtualElement | null;
+  rootMargin: string;
+  thresholds: number[];
+  private _callback: IntersectionObserverCallback;
+  private _observedElements: any;
+  constructor(callback: IntersectionObserverCallback, options?: IntersectionObserverInit);
+  observe(target: VirtualElement): void;
+  unobserve(target: VirtualElement): void;
+  disconnect(): void;
+  takeRecords(): IntersectionObserverEntry[];
+  private _createEntry(target: VirtualElement, isIntersecting: boolean): IntersectionObserverEntry;
+  private _getBoundingClientRect(_element: VirtualElement): DOMRectReadOnly;
+  private _createEmptyRect(): DOMRectReadOnly;
+}

package/dist/observers/MutationObserver.d.ts

@@ -0,0 +1,37 @@
+import type { VirtualNode } from '../nodes/VirtualNode';
+export declare interface MutationObserverInit {
+  childList?: boolean
+  attributes?: boolean
+  characterData?: boolean
+  subtree?: boolean
+  attributeOldValue?: boolean
+  characterDataOldValue?: boolean
+  attributeFilter?: string[]
+}
+export declare interface MutationRecord {
+  type: 'childList' | 'attributes' | 'characterData'
+  target: VirtualNode
+  addedNodes: VirtualNode[]
+  removedNodes: VirtualNode[]
+  previousSibling: VirtualNode | null
+  nextSibling: VirtualNode | null
+  attributeName: string | null
+  attributeNamespace: string | null
+  oldValue: string | null
+}
+export type MutationCallback = (mutations: MutationRecord[], observer: MutationObserver) => void
+/**
+ * MutationObserver implementation
+ * Note: This is a simplified implementation for testing
+ * It doesn't actually observe live changes, but provides the API
+ */
+export declare class MutationObserver {
+  private _callback: MutationCallback;
+  private _records: MutationRecord[];
+  private _observing: any;
+  constructor(callback: MutationCallback);
+  observe(_target: VirtualNode, _options?: MutationObserverInit): void;
+  disconnect(): void;
+  takeRecords(): MutationRecord[];
+  _addRecord(record: MutationRecord): void;
+}

package/dist/observers/ResizeObserver.d.ts

@@ -0,0 +1,41 @@
+import type { VirtualElement } from '../nodes/VirtualElement';
+export declare interface ResizeObserverSize {
+  inlineSize: number
+  blockSize: number
+}
+export declare interface ResizeObserverEntry {
+  target: VirtualElement
+  contentRect: DOMRectReadOnly
+  borderBoxSize: ReadonlyArray<ResizeObserverSize>
+  contentBoxSize: ReadonlyArray<ResizeObserverSize>
+  devicePixelContentBoxSize: ReadonlyArray<ResizeObserverSize>
+}
+declare interface DOMRectReadOnly {
+  x: number
+  y: number
+  width: number
+  height: number
+  top: number
+  right: number
+  bottom: number
+  left: number
+}
+export type ResizeObserverCallback = (
+  entries: ResizeObserverEntry[],
+  observer: ResizeObserver
+) => void
+/**
+ * ResizeObserver implementation
+ * Note: This is a simplified implementation for testing
+ * It simulates resize behavior without actual size calculations
+ */
+export declare class ResizeObserver {
+  private _callback: ResizeObserverCallback;
+  private _observedElements: any;
+  constructor(callback: ResizeObserverCallback);
+  observe(target: VirtualElement, _options?: { box?: 'content-box' | 'border-box' | 'device-pixel-content-box' }): void;
+  unobserve(target: VirtualElement): void;
+  disconnect(): void;
+  private _createEntry(target: VirtualElement): ResizeObserverEntry;
+  private _getContentRect(_element: VirtualElement): DOMRectReadOnly;
+}

package/dist/parsers/html-parser.d.ts

@@ -0,0 +1,5 @@
+import type { VirtualNode } from '../nodes/VirtualNode';
+/**
+ * Parse HTML string into virtual DOM nodes
+ */
+export declare function parseHTML(html: string): VirtualNode[];

package/dist/selectors/engine.d.ts

@@ -0,0 +1,132 @@
+import type { VirtualElement } from '../nodes/VirtualElement';
+import type { VirtualNode } from '../nodes/VirtualNode';
+/**
+ * Finds the first element matching the CSS selector starting from the given root node.
+ *
+ * @param root - The root node to search from (inclusive)
+ * @param selector - CSS selector string (supports tags, classes, IDs, attributes, pseudo-classes, and combinators)
+ * @returns The first matching VirtualElement, or null if no match is found
+ * @throws {Error} If selector syntax is invalid
+ *
+ * @example
+ * ```typescript
+ * const element = querySelectorEngine(document, 'div.container > p#intro')
+ * ```
+ */
+export declare function querySelectorEngine(root: VirtualNode, selector: string): VirtualElement | null;
+/**
+ * Finds all elements matching the CSS selector starting from the given root node.
+ * Traverses the DOM tree depth-first and returns matching elements in document order.
+ *
+ * @param root - The root node to search from (inclusive)
+ * @param selector - CSS selector string supporting:
+ *   - Tag selectors: `div`, `span`
+ *   - Class selectors: `.class-name`
+ *   - ID selectors: `#element-id`
+ *   - Attribute selectors: `[attr]`, `[attr="value"]`, `[attr^="value"]`, `[attr$="value"]`, `[attr*="value"]`, `[attr~="word"]`
+ *   - Pseudo-classes: `:first-child`, `:last-child`, `:first-of-type`, `:last-of-type`, `:only-child`, `:only-of-type`, `:nth-child()`, `:nth-last-child()`, `:nth-of-type()`, `:nth-last-of-type()`, `:not()`, `:disabled`, `:enabled`, `:checked`, `:empty`
+ *   - Combinators: ` ` (descendant), `>` (child), `+` (adjacent sibling), `~` (general sibling)
+ * @returns Array of all matching VirtualElements in document order
+ * @throws {Error} If selector syntax is invalid
+ *
+ * @example
+ * ```typescript
+ * const buttons = querySelectorAllEngine(document, 'button[type="submit"]:not(:disabled)')
+ * ```
+ */
+export declare function querySelectorAllEngine(root: VirtualNode, selector: string): VirtualElement[];
+/**
+ * Checks if a CSS selector contains any combinators (>, +, ~, or space).
+ * This helps optimize selector matching by using simpler logic for simple selectors.
+ *
+ * @param selector - CSS selector string to analyze
+ * @returns True if the selector contains any combinator characters
+ * @internal
+ */
+export declare function hasCombinators(selector: string): boolean;
+/**
+ * Tests if an element matches a complex selector containing combinators.
+ * Uses right-to-left matching (starting from the element itself) for efficiency.
+ *
+ * @param element - The element to test
+ * @param selector - Complex CSS selector with combinators
+ * @param root - Root node to limit ancestor traversal
+ * @returns True if the element matches the complex selector
+ * @internal
+ */
+export declare function matchesComplexSelector(element: VirtualElement, selector: string, root: VirtualNode): boolean;
+/**
+ * Parses a complex CSS selector into individual selector parts and their combinators.
+ * Handles nested pseudo-classes and attribute selectors correctly.
+ *
+ * @param selector - Complex CSS selector to parse
+ * @returns Array of selector parts with their following combinators
+ * @internal
+ *
+ * @example
+ * ```typescript
+ * parseComplexSelector('div > p.intro')
+ * // Returns: [{ selector: 'div', combinator: '>' }, { selector: 'p.intro', combinator: null }]
+ * ```
+ */
+export declare function parseComplexSelector(selector: string): Array<{ selector: string, combinator: string | null }>;
+/**
+ * Tests if an element matches a simple selector (without combinators).
+ * Supports tag names, IDs, classes, attributes, and pseudo-classes.
+ *
+ * @param element - The element to test
+ * @param selector - Simple CSS selector (no combinators)
+ * @returns True if the element matches all parts of the selector
+ *
+ * @example
+ * ```typescript
+ * matchesSimpleSelector(element, 'button.primary[disabled]')
+ * ```
+ */
+export declare function matchesSimpleSelector(element: VirtualElement, selector: string): boolean;
+/**
+ * Tests if an element matches a pseudo-class selector.
+ *
+ * Supported pseudo-classes:
+ * - `:first-child` - First element child of parent
+ * - `:last-child` - Last element child of parent
+ * - `:first-of-type` - First element of its type among siblings
+ * - `:last-of-type` - Last element of its type among siblings
+ * - `:only-child` - Only element child of parent
+ * - `:only-of-type` - Only element of its type among siblings
+ * - `:nth-child(n)` - Nth element child (supports 'odd', 'even', numbers, and An+B notation like '2n+1')
+ * - `:nth-last-child(n)` - Nth element child from the end
+ * - `:nth-of-type(n)` - Nth element of its type (supports An+B notation)
+ * - `:nth-last-of-type(n)` - Nth element of its type from the end
+ * - `:not(selector)` - Elements that don't match the selector
+ * - `:disabled` - Elements with disabled attribute
+ * - `:enabled` - Elements without disabled attribute
+ * - `:checked` - Elements with checked attribute
+ * - `:empty` - Elements with no children
+ *
+ * @param element - The element to test
+ * @param pseudo - Pseudo-class selector (e.g., ':first-child', ':nth-child(2n+1)')
+ * @returns True if the element matches the pseudo-class
+ */
+export declare function matchesPseudoClass(element: VirtualElement, pseudo: string): boolean;
+/**
+ * Tests if an element matches an attribute selector.
+ *
+ * Supported attribute selectors:
+ * - `[attr]` - Has attribute
+ * - `[attr="value"]` - Exact match
+ * - `[attr^="value"]` - Starts with
+ * - `[attr$="value"]` - Ends with
+ * - `[attr*="value"]` - Contains substring
+ * - `[attr~="word"]` - Contains word (space-separated)
+ *
+ * @param element - The element to test
+ * @param attrSelector - Attribute selector content (without the brackets)
+ * @returns True if the element's attribute matches the selector
+ *
+ * @example
+ * ```typescript
+ * matchesAttributeSelector(element, 'href^="https"')  // Tests [href^="https"]
+ * ```
+ */
+export declare function matchesAttributeSelector(element: VirtualElement, attrSelector: string): boolean;

package/dist/storage/Storage.d.ts

@@ -0,0 +1,14 @@
+// Create Proxy to support bracket notation
+export declare function createStorage(): Storage;
+/**
+ * Storage implementation for localStorage and sessionStorage
+ * Compatible with Web Storage API
+ */
+export declare class Storage {
+  private _data: Map<string, string>;
+  key(index: number): string | null;
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+  removeItem(key: string): void;
+  clear(): void;
+}

package/dist/timers/TimerManager.d.ts

@@ -0,0 +1,21 @@
+/**
+ * TimerManager handles setTimeout, setInterval, and requestAnimationFrame
+ * Tracks pending timers for waitUntilComplete() integration
+ */
+export declare class TimerManager {
+  private _timeouts: any;
+  private _intervals: any;
+  private _animationFrames: any;
+  private _nextId: any;
+  private _aborted: any;
+  setTimeout(callback: (...args: any[]) => void, delay?: number, args: any[]): number;
+  clearTimeout(id: number): void;
+  setInterval(callback: (...args: any[]) => void, delay?: number, args: any[]): number;
+  clearInterval(id: number): void;
+  requestAnimationFrame(callback: (time: number) => void): number;
+  cancelAnimationFrame(id: number): void;
+  hasPendingTimers(): boolean;
+  waitForTimers(): Promise<void>;
+  clearAll(): void;
+  abort(): void;
+}

package/dist/webcomponents/CustomElementRegistry.d.ts

@@ -0,0 +1,22 @@
+import { VirtualElement } from '../nodes/VirtualElement';
+export declare interface CustomElementConstructor {
+  new (): HTMLElement
+}
+declare interface ElementDefinitionOptions {
+  extends?: string
+}
+export declare class CustomElementRegistry {
+  private _definitions: any;
+  private _whenDefinedPromises: any;
+  define(name: string, constructor: CustomElementConstructor, _options?: ElementDefinitionOptions): void;
+  get(name: string): CustomElementConstructor | undefined;
+  whenDefined(name: string): Promise<CustomElementConstructor>;
+  upgrade(_root: Node): void;
+}
+// Simplified HTMLElement for custom elements
+export declare class HTMLElement extends VirtualElement {
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+  adoptedCallback(): void;
+}

package/dist/webcomponents/ShadowRoot.d.ts

@@ -0,0 +1,23 @@
+import type { VirtualElement } from '../nodes/VirtualElement';
+import type { VirtualNode } from '../nodes/VirtualNode';
+export declare interface ShadowRootInit {
+  mode: ShadowRootMode
+  delegatesFocus?: boolean
+}
+export type ShadowRootMode = 'open' | 'closed'
+/**
+ * ShadowRoot represents a shadow DOM tree
+ */
+export declare class ShadowRoot {
+  mode: ShadowRootMode;
+  delegatesFocus: boolean;
+  host: VirtualElement;
+  innerHTML: any;
+  children: VirtualNode[];
+  constructor(host: VirtualElement, init: ShadowRootInit);
+  querySelector(selector: string): VirtualElement | null;
+  querySelectorAll(selector: string): VirtualElement[];
+  appendChild(child: VirtualNode): VirtualNode;
+  removeChild(child: VirtualNode): VirtualNode;
+  getElementById(id: string): VirtualElement | null;
+}

package/dist/window/DetachedWindowAPI.d.ts

@@ -0,0 +1,19 @@
+import type { Window } from './Window';
+/**
+ * DetachedWindowAPI provides an API for communicating with a detached Window
+ * A Window is considered detached when created directly (e.g. new Window())
+ * instead of through the Browser API
+ */
+export declare class DetachedWindowAPI {
+  private _window: Window;
+  private _pendingOperations: Set<Promise<any>>;
+  private _aborted: any;
+  constructor(window: Window);
+  close(): Promise<void>;
+  waitUntilComplete(): Promise<void>;
+  abort(): Promise<void>;
+  setURL(url: string): void;
+  setViewport(options: { width?: number, height?: number }): void;
+  _trackOperation(operation: Promise<any>): void;
+  _isAborted(): boolean;
+}

package/dist/window/GlobalWindow.d.ts

@@ -0,0 +1,15 @@
+import { Window } from './Window';
+import type { WindowOptions } from './Window';
+/**
+ * GlobalWindow represents a window instance running in the global scope
+ * instead of an isolated VM context
+ *
+ * This is useful for setting up a test environment in its own Node process
+ * Compatible with Happy DOM's GlobalWindow API
+ */
+export declare class GlobalWindow extends Window {
+  constructor(options?: WindowOptions);
+  setGlobal(key: string, value: any): void;
+  getGlobal(key: string): any;
+  close(): Promise<void>;
+}