/// <reference lib="dom" />

/// <reference lib="dom.iterable" />

/// <reference types="node" />

import { EventEmitter } from "events";

import { Token } from "parse5";

import * as tough from "tough-cookie";

import { Dispatcher } from "undici-types";

import { Context } from "vm";

export const toughCookie: typeof tough;

export class CookieJar extends tough.CookieJar {}

export interface AbortablePromise<T> extends Promise<T> {

abort(): void;

}

export class JSDOM {

constructor(html?: string | Buffer | BinaryData, options?: ConstructorOptions);

static fromURL(url: string, options?: BaseOptions): Promise<JSDOM>;

static fromFile(url: string, options?: FileOptions): Promise<JSDOM>;

static fragment(html: string): DocumentFragment;

readonly window: DOMWindow;

readonly virtualConsole: VirtualConsole;

readonly cookieJar: CookieJar;

/**

* The serialize() method will return the HTML serialization of the document, including the doctype.

*/

serialize(): string;

/**

* The nodeLocation() method will find where a DOM node is within the source document,

* returning the parse5 location info for the node.

*

* @throws {Error} If the JSDOM was not created with `includeNodeLocations`

*/

nodeLocation(node: Node): Token.Location | null | undefined;

/**

* The built-in `vm` module of Node.js is what underpins JSDOM's script-running magic.

* Some advanced use cases, like pre-compiling a script and then running it multiple

* times, benefit from using the `vm` module directly with a jsdom-created `Window`.

*

* @throws {TypeError} If the `JSDOM` instance was created without `runScripts` set, or if you are using JSDOM in a web browser.

*/

getInternalVMContext(): Context;

/**

* The reconfigure method allows changing the `window.top` and url from the outside.

*/

reconfigure(settings: ReconfigureSettings): void;

}

export class VirtualConsole extends EventEmitter {

on<K extends keyof Console>(method: K, callback: Console[K]): this;

on(event: "jsdomError", callback: (e: Error) => void): this;

forwardTo(console: Console, options?: VirtualConsoleForwardToOptions): this;

}

export type BinaryData = ArrayBufferLike | NodeJS.ArrayBufferView;

export interface BaseOptions {

/**

* referrer just affects the value read from document.referrer.

* It defaults to no referrer (which reflects as the empty string).

*/

referrer?: string | undefined;

/**

* `includeNodeLocations` preserves the location info produced by the HTML parser,

* allowing you to retrieve it with the nodeLocation() method (described below).

*

* It defaults to false to give the best performance,

* and cannot be used with an XML content type since our XML parser does not support location info.

*

* @default false

*/

includeNodeLocations?: boolean | undefined;

runScripts?: "dangerously" | "outside-only" | undefined;

resources?: "usable" | ResourcesOptions | undefined;

virtualConsole?: VirtualConsole | undefined;

cookieJar?: CookieJar | undefined;

/**

* jsdom does not have the capability to render visual content, and will act like a headless browser by default.

* It provides hints to web pages through APIs such as document.hidden that their content is not visible.

*

* When the `pretendToBeVisual` option is set to `true`, jsdom will pretend that it is rendering and displaying

* content.

*

* @default false

*/

pretendToBeVisual?: boolean | undefined;

beforeParse?(window: DOMWindow): void;

}

export interface FileOptions extends BaseOptions {

/**

* url sets the value returned by window.location, document.URL, and document.documentURI,

* and affects things like resolution of relative URLs within the document

* and the same-origin restrictions and referrer used while fetching subresources.

* It will default to a file URL corresponding to the given filename, instead of to "about:blank".

*/

url?: string | undefined;

/**

* contentType affects the value read from document.contentType, and how the document is parsed: as HTML or as XML.

* Values that are not "text/html" or an XML mime type will throw. It will default to "application/xhtml+xml" if

* the given filename ends in .xhtml or .xml; otherwise it will continue to default to "text/html".

*/

contentType?: string | undefined;

}

export interface ConstructorOptions extends BaseOptions {

/**

* url sets the value returned by window.location, document.URL, and document.documentURI,

* and affects things like resolution of relative URLs within the document

* and the same-origin restrictions and referrer used while fetching subresources.

* It defaults to "about:blank".

*/

url?: string | undefined;

/**

* contentType affects the value read from document.contentType, and how the document is parsed: as HTML or as XML.

* Values that are not "text/html" or an XML mime type will throw. It defaults to "text/html".

*/

contentType?: string | undefined;

/**

* The maximum size in code units for the separate storage areas used by localStorage and sessionStorage.

* Attempts to store data larger than this limit will cause a DOMException to be thrown. By default, it is set

* to 5,000,000 code units per origin, as inspired by the HTML specification.

*

* @default 5_000_000

*/

storageQuota?: number | undefined;

}

export interface RequestInterceptorContext {

element: HTMLElement | null;

}

export type RequestInterceptorCallback = (

request: Request,

context: RequestInterceptorContext,

// eslint-disable-next-line @typescript-eslint/no-invalid-void-type

) => void | undefined | Response | Promise<undefined | Response>;

export function requestInterceptor(fn: RequestInterceptorCallback): Dispatcher.DispatchInterceptor;

export type SupportedContentTypes =

| "text/html"

| "application/xhtml+xml"

| "application/xml"

| "text/xml"

| "image/svg+xml";

export type JSDOMError =

| "css-parsing"

| "not-implemented"

| "resource-loading"

| "unhandled-exception";

export interface VirtualConsoleForwardToOptions {

jsdomErrors?: JSDOMError[] | "none" | undefined;

}

export interface ReconfigureSettings {

windowTop?: DOMWindow | undefined;

url?: string | undefined;

}

export interface ResourcesOptions {

/**

* userAgent affects the value read from navigator.userAgent, as well as the User-Agent header sent while fetching subresources.

*

* @default

* `Mozilla/5.0 (${process.platform}) AppleWebKit/537.36 (KHTML, like Gecko) jsdom/${jsdomVersion}`

*/

userAgent?: string | undefined;

dispatcher?: Dispatcher | undefined;

interceptors?: Dispatcher.DispatcherComposeInterceptor[] | undefined;

}

export interface DOMWindow extends Omit<Window, "top" | "self" | "window"> {

[key: string]: any;

[index: number]: any;

/* node_modules/jsdom/browser/Window.js */

Window: typeof Window;

readonly top: DOMWindow;

readonly self: DOMWindow;

readonly window: DOMWindow;

/* ECMAScript Globals */

globalThis: DOMWindow;

readonly ["Infinity"]: number;

readonly ["NaN"]: number;

readonly undefined: undefined;

eval(script: string): unknown;

parseInt(s: string, radix?: number): number;

parseFloat(string: string): number;

isNaN(number: number): boolean;

isFinite(number: number): boolean;

decodeURI(encodedURI: string): string;

decodeURIComponent(encodedURIComponent: string): string;

encodeURI(uri: string): string;

encodeURIComponent(uriComponent: string | number | boolean): string;

escape(string: string): string;

unescape(string: string): string;

Array: typeof Array;

ArrayBuffer: typeof ArrayBuffer;

Atomics: typeof Atomics;

BigInt: typeof BigInt;

BigInt64Array: typeof BigInt64Array;

BigUint64Array: typeof BigUint64Array;

Boolean: typeof Boolean;

DataView: typeof DataView;

Date: typeof Date;

Error: typeof Error;

EvalError: typeof EvalError;

FinalizationRegistry: FinalizationRegistryConstructor;

Float32Array: typeof Float32Array;

Float64Array: typeof Float64Array;

Function: typeof Function;

Int16Array: typeof Int16Array;

Int32Array: typeof Int32Array;

Int8Array: typeof Int8Array;

Intl: typeof Intl;

JSON: typeof JSON;

Map: typeof Map;

Math: typeof Math;

Number: typeof Number;

Object: typeof Object;

Promise: typeof Promise;

Proxy: typeof Proxy;

RangeError: typeof RangeError;

ReferenceError: typeof ReferenceError;

Reflect: typeof Reflect;

RegExp: typeof RegExp;

Set: typeof Set;

SharedArrayBuffer: typeof SharedArrayBuffer;

String: typeof String;

Symbol: typeof Symbol;

SyntaxError: typeof SyntaxError;

TypeError: typeof TypeError;

URIError: typeof URIError;

Uint16Array: typeof Uint16Array;

Uint32Array: typeof Uint32Array;

Uint8Array: typeof Uint8Array;

Uint8ClampedArray: typeof Uint8ClampedArray;

WeakMap: typeof WeakMap;

WeakRef: WeakRefConstructor;

WeakSet: typeof WeakSet;

WebAssembly: typeof WebAssembly;

/* node_modules/jsdom/living/interfaces.js */

DOMException: typeof DOMException;

URL: typeof URL;

URLSearchParams: typeof URLSearchParams;

EventTarget: typeof EventTarget;

NamedNodeMap: typeof NamedNodeMap;

Node: typeof Node;

Attr: typeof Attr;

Element: typeof Element;

DocumentFragment: typeof DocumentFragment;

DOMImplementation: typeof DOMImplementation;

Document: typeof Document;

HTMLDocument: typeof HTMLDocument;

XMLDocument: typeof XMLDocument;

CharacterData: typeof CharacterData;

Text: typeof Text;

CDATASection: typeof CDATASection;

ProcessingInstruction: typeof ProcessingInstruction;

Comment: typeof Comment;

DocumentType: typeof DocumentType;

NodeList: typeof NodeList;

HTMLCollection: typeof HTMLCollection;

HTMLOptionsCollection: typeof HTMLOptionsCollection;

DOMStringMap: typeof DOMStringMap;

DOMTokenList: typeof DOMTokenList;

StyleSheetList: typeof StyleSheetList;

HTMLElement: typeof HTMLElement;

HTMLHeadElement: typeof HTMLHeadElement;

HTMLTitleElement: typeof HTMLTitleElement;

HTMLBaseElement: typeof HTMLBaseElement;

HTMLLinkElement: typeof HTMLLinkElement;

HTMLMetaElement: typeof HTMLMetaElement;

HTMLStyleElement: typeof HTMLStyleElement;

HTMLBodyElement: typeof HTMLBodyElement;

HTMLHeadingElement: typeof HTMLHeadingElement;

HTMLParagraphElement: typeof HTMLParagraphElement;

HTMLHRElement: typeof HTMLHRElement;

HTMLPreElement: typeof HTMLPreElement;

HTMLUListElement: typeof HTMLUListElement;

HTMLOListElement: typeof HTMLOListElement;

HTMLLIElement: typeof HTMLLIElement;

HTMLMenuElement: typeof HTMLMenuElement;

HTMLDListElement: typeof HTMLDListElement;

HTMLDivElement: typeof HTMLDivElement;

HTMLAnchorElement: typeof HTMLAnchorElement;

HTMLAreaElement: typeof HTMLAreaElement;

HTMLBRElement: typeof HTMLBRElement;

HTMLButtonElement: typeof HTMLButtonElement;

HTMLCanvasElement: typeof HTMLCanvasElement;

HTMLDataElement: typeof HTMLDataElement;

HTMLDataListElement: typeof HTMLDataListElement;

HTMLDetailsElement: typeof HTMLDetailsElement;

HTMLDialogElement: {

new(): HTMLDialogElement;

readonly prototype: HTMLDialogElement;

};

HTMLDirectoryElement: typeof HTMLDirectoryElement;

HTMLFieldSetElement: typeof HTMLFieldSetElement;

HTMLFontElement: typeof HTMLFontElement;

HTMLFormElement: typeof HTMLFormElement;

HTMLHtmlElement: typeof HTMLHtmlElement;

HTMLImageElement: typeof HTMLImageElement;

HTMLInputElement: typeof HTMLInputElement;

InputEvent: typeof InputEvent;

HTMLLabelElement: typeof HTMLLabelElement;

HTMLLegendElement: typeof HTMLLegendElement;

HTMLMapElement: typeof HTMLMapElement;

HTMLMarqueeElement: typeof HTMLMarqueeElement;

HTMLMediaElement: typeof HTMLMediaElement;

HTMLMeterElement: typeof HTMLMeterElement;

HTMLModElement: typeof HTMLModElement;

HTMLOptGroupElement: typeof HTMLOptGroupElement;

HTMLOptionElement: typeof HTMLOptionElement;

HTMLOutputElement: typeof HTMLOutputElement;

HTMLPictureElement: typeof HTMLPictureElement;

HTMLProgressElement: typeof HTMLProgressElement;

HTMLQuoteElement: typeof HTMLQuoteElement;

HTMLScriptElement: typeof HTMLScriptElement;

HTMLSelectElement: typeof HTMLSelectElement;

HTMLSlotElement: typeof HTMLSlotElement;

HTMLSourceElement: typeof HTMLSourceElement;

HTMLSpanElement: typeof HTMLSpanElement;

HTMLTableCaptionElement: typeof HTMLTableCaptionElement;

HTMLTableCellElement: typeof HTMLTableCellElement;

HTMLTableColElement: typeof HTMLTableColElement;

HTMLTableElement: typeof HTMLTableElement;

HTMLTimeElement: typeof HTMLTimeElement;

HTMLTableRowElement: typeof HTMLTableRowElement;

HTMLTableSectionElement: typeof HTMLTableSectionElement;

HTMLTemplateElement: typeof HTMLTemplateElement;

HTMLTextAreaElement: typeof HTMLTextAreaElement;

HTMLUnknownElement: typeof HTMLUnknownElement;

HTMLFrameElement: typeof HTMLFrameElement;

HTMLFrameSetElement: typeof HTMLFrameSetElement;

HTMLIFrameElement: typeof HTMLIFrameElement;

HTMLEmbedElement: typeof HTMLEmbedElement;

HTMLObjectElement: typeof HTMLObjectElement;

HTMLParamElement: typeof HTMLParamElement;

HTMLVideoElement: typeof HTMLVideoElement;

HTMLAudioElement: typeof HTMLAudioElement;

HTMLTrackElement: typeof HTMLTrackElement;

SVGElement: typeof SVGElement;

SVGGraphicsElement: typeof SVGGraphicsElement;

SVGSVGElement: typeof SVGSVGElement;

SVGTitleElement: typeof SVGTitleElement;

SVGAnimatedString: typeof SVGAnimatedString;

SVGNumber: typeof SVGNumber;

SVGStringList: typeof SVGStringList;

Event: typeof Event;

CloseEvent: typeof CloseEvent;

CustomEvent: typeof CustomEvent;

MessageEvent: typeof MessageEvent;

ErrorEvent: typeof ErrorEvent;

HashChangeEvent: typeof HashChangeEvent;

PopStateEvent: typeof PopStateEvent;

StorageEvent: typeof StorageEvent;

ProgressEvent: typeof ProgressEvent;

PageTransitionEvent: typeof PageTransitionEvent;

UIEvent: typeof UIEvent;

FocusEvent: typeof FocusEvent;

MouseEvent: typeof MouseEvent;

KeyboardEvent: typeof KeyboardEvent;

TouchEvent: typeof TouchEvent;

CompositionEvent: typeof CompositionEvent;

WheelEvent: typeof WheelEvent;

BarProp: typeof BarProp;

External: typeof External;

Location: typeof Location;

History: typeof History;

Screen: typeof Screen;

Performance: typeof Performance;

Navigator: typeof Navigator;

PluginArray: typeof PluginArray;

MimeTypeArray: typeof MimeTypeArray;

Plugin: typeof Plugin;

MimeType: typeof MimeType;

FileReader: typeof FileReader;

Blob: typeof Blob;

File: typeof File;

FileList: typeof FileList;

ValidityState: typeof ValidityState;

DOMParser: typeof DOMParser;

XMLSerializer: typeof XMLSerializer;

FormData: typeof FormData;

XMLHttpRequestEventTarget: typeof XMLHttpRequestEventTarget;

XMLHttpRequestUpload: typeof XMLHttpRequestUpload;

XMLHttpRequest: typeof XMLHttpRequest;

WebSocket: typeof WebSocket;

NodeFilter: typeof NodeFilter;

NodeIterator: typeof NodeIterator;

TreeWalker: typeof TreeWalker;

AbstractRange: typeof AbstractRange;

Range: typeof Range;

StaticRange: typeof StaticRange;

Selection: typeof Selection;

Storage: typeof Storage;

CustomElementRegistry: typeof CustomElementRegistry;

ShadowRoot: typeof ShadowRoot;

MutationObserver: typeof MutationObserver;

MutationRecord: typeof MutationRecord;

Headers: typeof Headers;

AbortController: typeof AbortController;

AbortSignal: typeof AbortSignal;

/* node_modules/jsdom/level2/style.js */

StyleSheet: typeof StyleSheet;

MediaList: typeof MediaList;

CSSStyleSheet: typeof CSSStyleSheet;

CSSRule: typeof CSSRule;

CSSStyleRule: typeof CSSStyleRule;

CSSMediaRule: typeof CSSMediaRule;

CSSImportRule: typeof CSSImportRule;

CSSStyleDeclaration: typeof CSSStyleDeclaration;

/* node_modules/jsdom/level3/xpath.js */

// XPathException: typeof XPathException;

XPathExpression: typeof XPathExpression;

XPathResult: typeof XPathResult;

XPathEvaluator: typeof XPathEvaluator;

}

// Necessary to avoid breaking dependents because of the dependency

// on the `ESNext.WeakRef` lib:

declare global {

// eslint-disable-next-line @typescript-eslint/no-empty-interface

interface FinalizationRegistryConstructor {}

// eslint-disable-next-line @typescript-eslint/no-empty-interface

interface WeakRefConstructor {}

}