happy-dom 16.8.1 → 20.0.2

package/lib/window/BrowserWindow.js

@@ -9,8 +9,10 @@ import * as PropertySymbol from '../PropertySymbol.js';
 import Base64 from '../base64/Base64.js';
 import BrowserErrorCaptureEnum from '../browser/enums/BrowserErrorCaptureEnum.js';
 import Clipboard from '../clipboard/Clipboard.js';
+import ClipboardItem from '../clipboard/ClipboardItem.js';
 import CSS from '../css/CSS.js';
 import CSSRule from '../css/CSSRule.js';
+import CSSUnitValue from '../css/CSSUnitValue.js';
 import CSSStyleDeclaration from '../css/declaration/CSSStyleDeclaration.js';
 import CSSContainerRule from '../css/rules/CSSContainerRule.js';
 import CSSFontFaceRule from '../css/rules/CSSFontFaceRule.js';
@@ -20,6 +22,9 @@ import CSSMediaRule from '../css/rules/CSSMediaRule.js';
 import CSSStyleRule from '../css/rules/CSSStyleRule.js';
 import CSSSupportsRule from '../css/rules/CSSSupportsRule.js';
 import CustomElementRegistry from '../custom-element/CustomElementRegistry.js';
+import DataTransfer from '../event/DataTransfer.js';
+import DataTransferItem from '../event/DataTransferItem.js';
+import DataTransferItemList from '../event/DataTransferItemList.js';
 import Event from '../event/Event.js';
 import EventTarget from '../event/EventTarget.js';
 import Touch from '../event/Touch.js';
@@ -43,6 +48,7 @@ import TouchEvent from '../event/events/TouchEvent.js';
 import WheelEvent from '../event/events/WheelEvent.js';
 import DOMExceptionNameEnum from '../exception/DOMExceptionNameEnum.js';
 import Fetch from '../fetch/Fetch.js';
+import Headers from '../fetch/Headers.js';
 import Blob from '../file/Blob.js';
 import File from '../file/File.js';
 import History from '../history/History.js';
@@ -65,6 +71,7 @@ import DOMRect from '../dom/DOMRect.js';
 import DOMRectReadOnly from '../dom/DOMRectReadOnly.js';
 import Element from '../nodes/element/Element.js';
 import HTMLCollection from '../nodes/element/HTMLCollection.js';
+import NamedNodeMap from '../nodes/element/NamedNodeMap.js';
 import HTMLAnchorElement from '../nodes/html-anchor-element/HTMLAnchorElement.js';
 import HTMLAreaElement from '../nodes/html-area-element/HTMLAreaElement.js';
 import HTMLAudioElement from '../nodes/html-audio-element/HTMLAudioElement.js';
@@ -144,12 +151,14 @@ import SVGElement from '../nodes/svg-element/SVGElement.js';
 import Permissions from '../permissions/Permissions.js';
 import ResizeObserver from '../resize-observer/ResizeObserver.js';
 import Screen from '../screen/Screen.js';
+import Selection from '../selection/Selection.js';
 import Storage from '../storage/Storage.js';
 import NodeFilter from '../tree-walker/NodeFilter.js';
-import URL from '../url/URL.js';
+import NodeIterator from '../tree-walker/NodeIterator.js';
+import TreeWalker from '../tree-walker/TreeWalker.js';
 import ValidityState from '../validity-state/ValidityState.js';
+import XMLSerializer from '../xml-serializer/XMLSerializer.js';
 import VMGlobalPropertyScript from './VMGlobalPropertyScript.js';
-import WindowErrorUtility from './WindowErrorUtility.js';
 import WindowPageOpenUtility from './WindowPageOpenUtility.js';
 import { PerformanceObserver, PerformanceEntry } from 'node:perf_hooks';
 import EventPhaseEnum from '../event/EventPhaseEnum.js';
@@ -254,6 +263,15 @@ import SVGUnitTypes from '../svg/SVGUnitTypes.js';
 import DOMPoint from '../dom/DOMPoint.js';
 import SVGAnimatedLengthList from '../svg/SVGAnimatedLengthList.js';
 import CustomElementReactionStack from '../custom-element/CustomElementReactionStack.js';
+import StylePropertyMapReadOnly from '../css/style-property-map/StylePropertyMapReadOnly.js';
+import StylePropertyMap from '../css/style-property-map/StylePropertyMap.js';
+import MediaList from '../css/MediaList.js';
+import CSSKeywordValue from '../css/style-property-map/CSSKeywordValue.js';
+import CSSStyleValue from '../css/style-property-map/CSSStyleValue.js';
+import CSSConditionRule from '../css/rules/CSSConditionRule.js';
+import CSSGroupingRule from '../css/rules/CSSGroupingRule.js';
+import CSSScopeRule from '../css/rules/CSSScopeRule.js';
+import PopStateEvent from '../event/events/PopStateEvent.js';
 const TIMER = {
     setTimeout: globalThis.setTimeout.bind(globalThis),
     clearTimeout: globalThis.clearTimeout.bind(globalThis),
@@ -264,6 +282,26 @@ const TIMER = {
     clearImmediate: globalThis.clearImmediate.bind(globalThis)
 };
 const IS_NODE_JS_TIMEOUT_ENVIRONMENT = setTimeout.toString().includes('new Timeout');
+const IS_CODE_GENERATION_FROM_STRINGS_ENVIRONMENT = (() => {
+    try {
+        // eslint-disable-next-line no-new-func
+        new Function('return true;')();
+        return true;
+    }
+    catch {
+        return false;
+    }
+})();
+const IS_UNFROZEN_INTRINSICS_ENVIRONMENT = (() => {
+    try {
+        globalThis.Function['$UNFROZEN$'] = true;
+        delete globalThis.Function['$UNFROZEN$'];
+        return true;
+    }
+    catch {
+        return false;
+    }
+})();
 /**
  * Class for PerformanceObserverEntryList as it is only available as an interface from Node.js.
  */
@@ -461,6 +499,7 @@ export default class BrowserWindow extends EventTarget {
     HashChangeEvent = HashChangeEvent;
     ClipboardEvent = ClipboardEvent;
     TouchEvent = TouchEvent;
+    PopStateEvent = PopStateEvent;
     Touch = Touch;
     // Non-implemented event classes
     AudioProcessingEvent = Event;
@@ -486,7 +525,6 @@ export default class BrowserWindow extends EventTarget {
     OverconstrainedError = Event;
     PageTransitionEvent = Event;
     PaymentRequestUpdateEvent = Event;
-    PopStateEvent = Event;
     RelatedEvent = Event;
     RTCDataChannelEvent = Event;
     RTCIdentityErrorEvent = Event;
@@ -521,6 +559,9 @@ export default class BrowserWindow extends EventTarget {
     CSSMediaRule = CSSMediaRule;
     CSSStyleRule = CSSStyleRule;
     CSSSupportsRule = CSSSupportsRule;
+    CSSConditionRule = CSSConditionRule;
+    CSSGroupingRule = CSSGroupingRule;
+    CSSScopeRule = CSSScopeRule;
     DOMRect = DOMRect;
     DOMRectReadOnly = DOMRectReadOnly;
     Plugin = Plugin;
@@ -528,7 +569,6 @@ export default class BrowserWindow extends EventTarget {
     Location = Location;
     CustomElementRegistry = CustomElementRegistry;
     ResizeObserver = ResizeObserver;
-    URL = URL;
     Blob = Blob;
     File = File;
     Storage = Storage;
@@ -544,6 +584,17 @@ export default class BrowserWindow extends EventTarget {
     Screen = Screen;
     DOMMatrixReadOnly = DOMMatrixReadOnly;
     DOMMatrix = DOMMatrix;
+    NamedNodeMap = NamedNodeMap;
+    TreeWalker = TreeWalker;
+    NodeIterator = NodeIterator;
+    DataTransfer = DataTransfer;
+    DataTransferItem = DataTransferItem;
+    DataTransferItemList = DataTransferItemList;
+    Headers = Headers;
+    XMLSerializer = XMLSerializer;
+    ClipboardItem = ClipboardItem;
+    Selection = Selection;
+    CSSUnitValue = CSSUnitValue;
     SVGAngle = SVGAngle;
     SVGAnimatedAngle = SVGAnimatedAngle;
     SVGAnimatedBoolean = SVGAnimatedBoolean;
@@ -571,6 +622,11 @@ export default class BrowserWindow extends EventTarget {
     SVGAnimatedLengthList = SVGAnimatedLengthList;
     SVGUnitTypes = SVGUnitTypes;
     DOMPoint = DOMPoint;
+    StylePropertyMap = StylePropertyMap;
+    StylePropertyMapReadOnly = StylePropertyMapReadOnly;
+    MediaList = MediaList;
+    CSSKeywordValue = CSSKeywordValue;
+    CSSStyleValue = CSSStyleValue;
     Window = this.constructor;
     // Node.js Classes
     URLSearchParams = URLSearchParams;
@@ -604,7 +660,7 @@ export default class BrowserWindow extends EventTarget {
     // Used for tracking capture event listeners to improve performance when they are not used.
     // See EventTarget class.
     [PropertySymbol.mutationObservers] = [];
-    [PropertySymbol.readyStateManager] = new DocumentReadyStateManager(this);
+    [PropertySymbol.readyStateManager];
     [PropertySymbol.location];
     [PropertySymbol.history];
     [PropertySymbol.navigator];
@@ -615,8 +671,15 @@ export default class BrowserWindow extends EventTarget {
     [PropertySymbol.top] = this;
     [PropertySymbol.parent] = this;
     [PropertySymbol.window] = this;
+    [PropertySymbol.frames] = this;
     [PropertySymbol.internalId] = -1;
     [PropertySymbol.customElementReactionStack] = new CustomElementReactionStack(this);
+    [PropertySymbol.modules] = {
+        json: new Map(),
+        css: new Map(),
+        esm: new Map()
+    };
+    [PropertySymbol.moduleImportMap] = null;
     // Private properties
     #browserFrame;
     #innerWidth = null;
@@ -626,6 +689,7 @@ export default class BrowserWindow extends EventTarget {
     #devicePixelRatio = null;
     #zeroDelayTimeout = { timeouts: null };
     #timerLoopStacks = [];
+    #timerLoopLimits = [];
     /**
      * Constructor.
      *
@@ -636,13 +700,16 @@ export default class BrowserWindow extends EventTarget {
     constructor(browserFrame, options) {
         super();
         this.#browserFrame = browserFrame;
+        this[PropertySymbol.validateJavaScriptExecutionEnvironment]();
         this.console = browserFrame.page.console;
+        this[PropertySymbol.readyStateManager] = new DocumentReadyStateManager(browserFrame);
         this[PropertySymbol.navigator] = new Navigator(this);
         this[PropertySymbol.screen] = new Screen();
         this[PropertySymbol.sessionStorage] = new Storage();
         this[PropertySymbol.localStorage] = new Storage();
         this[PropertySymbol.location] = new Location(this.#browserFrame, options?.url ?? 'about:blank');
         this[PropertySymbol.history] = new History(this.#browserFrame, this);
+        browserFrame[PropertySymbol.history].currentItem.href = options?.url ?? 'about:blank';
         WindowBrowserContext.setWindowBrowserFrameRelation(this, this.#browserFrame);
         this[PropertySymbol.setupVMContext]();
         WindowContextClassExtender.extendClasses(this);
@@ -650,11 +717,13 @@ export default class BrowserWindow extends EventTarget {
         this.document = new this.HTMLDocument();
         this.document[PropertySymbol.defaultView] = this;
         // Ready state manager
+        const taskID = browserFrame[PropertySymbol.asyncTaskManager].startTask(() => this[PropertySymbol.readyStateManager].destroy());
         this[PropertySymbol.readyStateManager].waitUntilComplete().then(() => {
+            browserFrame[PropertySymbol.asyncTaskManager].endTask(taskID);
             this.document[PropertySymbol.readyState] = DocumentReadyStateEnum.complete;
             this.document.dispatchEvent(new Event('readystatechange'));
-            // Not sure why target is set to document here, but this is how it works in the browser
             const loadEvent = new Event('load');
+            // Not sure why target is set to document here, but this is how it seem to work in the browser
             loadEvent[PropertySymbol.currentTarget] = this;
             loadEvent[PropertySymbol.target] = this.document;
             loadEvent[PropertySymbol.eventPhase] = EventPhaseEnum.atTarget;
@@ -674,7 +743,7 @@ export default class BrowserWindow extends EventTarget {
         return this[PropertySymbol.self];
     }
     /**
-     * Returns self.
+     * Sets self.
      *
      * @param self Self.
      */
@@ -698,13 +767,29 @@ export default class BrowserWindow extends EventTarget {
         return this[PropertySymbol.parent];
     }
     /**
-     * Returns parent.
+     * Sets parent.
      *
      * @param parent Parent.
      */
     set parent(parent) {
         this[PropertySymbol.parent] = parent;
     }
+    /**
+     * Returns frames.
+     *
+     * @returns Frames.
+     */
+    get frames() {
+        return this[PropertySymbol.frames];
+    }
+    /**
+     * Sets frames.
+     *
+     * @param frames Frames.
+     */
+    set frames(frames) {
+        this[PropertySymbol.parent] = frames;
+    }
     /**
      * Returns location.
      */
@@ -1009,9 +1094,11 @@ export default class BrowserWindow extends EventTarget {
      * Closes the window.
      */
     close() {
-        // When using a Window instance directly, the Window instance is the main frame and we will close the page and destroy the browser.
-        // When using the Browser API we should only close the page when the Window instance is connected to the main frame (we should not close child frames such as iframes).
-        if (this.#browserFrame.page?.mainFrame === this.#browserFrame) {
+        // Users can only close the main frame of a page (not child frames such as iframes).
+        if (this.#browserFrame.page.mainFrame === this.#browserFrame &&
+            // Scripts may close only the windows that were opened by them.
+            // In this case, this means windows that have been opened by another window
+            this.#browserFrame[PropertySymbol.openerWindow]) {
             this[PropertySymbol.destroy]();
             this.#browserFrame.page.close();
         }
@@ -1035,16 +1122,30 @@ export default class BrowserWindow extends EventTarget {
      */
     setTimeout(callback, delay = 0, ...args) {
         if (this.closed) {
-            return;
+            return {};
         }
-        const settings = this.#browserFrame.page?.context?.browser?.settings;
+        const settings = this.#browserFrame.page.context.browser.settings;
         if (settings.timer.preventTimerLoops) {
             const stack = new Error().stack;
             const timerLoopStacks = this.#timerLoopStacks;
-            if (timerLoopStacks.includes(stack)) {
-                return;
+            const timerLoopLimits = this.#timerLoopLimits;
+            const index = timerLoopStacks.indexOf(stack);
+            if (index !== -1) {
+                timerLoopLimits[index].timeout++;
+                if (timerLoopLimits[index].timeout >=
+                    (settings.timer.preventTimerLoops === true
+                        ? 1
+                        : (settings.timer.preventTimerLoops.timeout ?? 1))) {
+                    return {};
+                }
+            }
+            else {
+                timerLoopStacks.push(stack);
+                timerLoopLimits.push({
+                    timeout: 0,
+                    requestAnimationFrame: 0
+                });
             }
-            timerLoopStacks.push(stack);
         }
         // We can group timeouts with a delay of 0 into one timeout to improve performance.
         // Grouping timeouts will also improve the performance of the async task manager.
@@ -1062,13 +1163,22 @@ export default class BrowserWindow extends EventTarget {
                     zeroDelayTimeout.timeouts = null;
                     for (const timeout of timeouts) {
                         if (useTryCatch) {
-                            WindowErrorUtility.captureError(this, () => timeout.callback());
+                            let result;
+                            try {
+                                result = timeout.callback();
+                            }
+                            catch (error) {
+                                this[PropertySymbol.dispatchError](error);
+                            }
+                            if (result instanceof Promise) {
+                                result.catch((error) => this[PropertySymbol.dispatchError](error));
+                            }
                         }
                         else {
                             timeout.callback();
                         }
                     }
-                });
+                }, 0);
                 zeroDelayTimeout.timeouts = [];
                 this.#browserFrame[PropertySymbol.asyncTaskManager].startTimer(id);
             }
@@ -1083,7 +1193,16 @@ export default class BrowserWindow extends EventTarget {
             // We need to call endTimer() before the callback as the callback might throw an error.
             this.#browserFrame[PropertySymbol.asyncTaskManager].endTimer(id);
             if (useTryCatch) {
-                WindowErrorUtility.captureError(this, () => callback(...args));
+                let result;
+                try {
+                    result = callback(...args);
+                }
+                catch (error) {
+                    this[PropertySymbol.dispatchError](error);
+                }
+                if (result instanceof Promise) {
+                    result.catch((error) => this[PropertySymbol.dispatchError](error));
+                }
             }
             else {
                 callback(...args);
@@ -1129,16 +1248,29 @@ export default class BrowserWindow extends EventTarget {
      */
     setInterval(callback, delay = 0, ...args) {
         if (this.closed) {
-            return;
+            return {};
         }
-        const settings = this.#browserFrame.page?.context?.browser?.settings;
+        const settings = this.#browserFrame.page.context.browser.settings;
         const useTryCatch = !settings ||
             (!settings.disableErrorCapturing &&
                 settings.errorCapture === BrowserErrorCaptureEnum.tryAndCatch);
         let iterations = 0;
         const id = TIMER.setInterval(() => {
             if (useTryCatch) {
-                WindowErrorUtility.captureError(this, () => callback(...args), () => this.clearInterval(id));
+                let result;
+                try {
+                    result = callback(...args);
+                }
+                catch (error) {
+                    this.clearInterval(id);
+                    this[PropertySymbol.dispatchError](error);
+                }
+                if (result instanceof Promise) {
+                    result.catch((error) => {
+                        this.clearInterval(id);
+                        this[PropertySymbol.dispatchError](error);
+                    });
+                }
             }
             else {
                 callback(...args);
@@ -1177,16 +1309,30 @@ export default class BrowserWindow extends EventTarget {
      */
     requestAnimationFrame(callback) {
         if (this.closed) {
-            return;
+            return {};
         }
-        const settings = this.#browserFrame.page?.context?.browser?.settings;
+        const settings = this.#browserFrame.page.context.browser.settings;
         if (settings.timer.preventTimerLoops) {
             const stack = new Error().stack;
             const timerLoopStacks = this.#timerLoopStacks;
-            if (timerLoopStacks.includes(stack)) {
-                return;
+            const timerLoopLimits = this.#timerLoopLimits;
+            const index = timerLoopStacks.indexOf(stack);
+            if (index !== -1) {
+                timerLoopLimits[index].requestAnimationFrame++;
+                if (timerLoopLimits[index].requestAnimationFrame >=
+                    (settings.timer.preventTimerLoops === true
+                        ? 1
+                        : (settings.timer.preventTimerLoops.requestAnimationFrame ?? 1))) {
+                    return {};
+                }
+            }
+            else {
+                timerLoopStacks.push(stack);
+                timerLoopLimits.push({
+                    timeout: 0,
+                    requestAnimationFrame: 0
+                });
             }
-            timerLoopStacks.push(stack);
         }
         const useTryCatch = !settings ||
             (!settings.disableErrorCapturing &&
@@ -1195,7 +1341,16 @@ export default class BrowserWindow extends EventTarget {
             // We need to call endImmediate() before the callback as the callback might throw an error.
             this.#browserFrame[PropertySymbol.asyncTaskManager].endImmediate(id);
             if (useTryCatch) {
-                WindowErrorUtility.captureError(this, () => callback(this.performance.now()));
+                let result;
+                try {
+                    result = callback(this.performance.now());
+                }
+                catch (error) {
+                    this[PropertySymbol.dispatchError](error);
+                }
+                if (result instanceof Promise) {
+                    result.catch((error) => this[PropertySymbol.dispatchError](error));
+                }
             }
             else {
                 callback(this.performance.now());
@@ -1229,7 +1384,7 @@ export default class BrowserWindow extends EventTarget {
         }
         let isAborted = false;
         const taskId = this.#browserFrame[PropertySymbol.asyncTaskManager].startTask(() => (isAborted = true));
-        const settings = this.#browserFrame.page?.context?.browser?.settings;
+        const settings = this.#browserFrame.page.context.browser.settings;
         const useTryCatch = !settings ||
             (!settings.disableErrorCapturing &&
                 settings.errorCapture === BrowserErrorCaptureEnum.tryAndCatch);
@@ -1238,7 +1393,16 @@ export default class BrowserWindow extends EventTarget {
                 // We need to call endTask() before the callback as the callback might throw an error.
                 this.#browserFrame[PropertySymbol.asyncTaskManager].endTask(taskId);
                 if (useTryCatch) {
-                    WindowErrorUtility.captureError(this, callback);
+                    let result;
+                    try {
+                        result = callback();
+                    }
+                    catch (error) {
+                        this[PropertySymbol.dispatchError](error);
+                    }
+                    if (result instanceof Promise) {
+                        result.catch((error) => this[PropertySymbol.dispatchError](error));
+                    }
                 }
                 else {
                     callback();
@@ -1358,6 +1522,26 @@ export default class BrowserWindow extends EventTarget {
             });
         }
     }
+    /**
+     * Dispatches an error event and outputs the error to the console.
+     *
+     * @param error Error.
+     */
+    [PropertySymbol.dispatchError](error) {
+        this.#browserFrame.page.console.error(error);
+        this.dispatchEvent(new ErrorEvent('error', { message: error.message, error }));
+    }
+    /**
+     * Evaluates code in a VM context.
+     *
+     * @param code Code.
+     * @param [options] Options.
+     * @param [options.filename] Filename.
+     * @returns any.
+     */
+    [PropertySymbol.evaluateScript](code, options) {
+        return new VM.Script(code, options).runInContext(this);
+    }
     /**
      * Setup of VM context.
      */
@@ -1369,6 +1553,23 @@ export default class BrowserWindow extends EventTarget {
             VMGlobalPropertyScript.runInContext(this);
         }
     }
+    /**
+     * Checks if the JavaScript execution environment is secure and outputs a warning if not.
+     */
+    [PropertySymbol.validateJavaScriptExecutionEnvironment]() {
+        const browserFrame = this.#browserFrame;
+        if ((IS_CODE_GENERATION_FROM_STRINGS_ENVIRONMENT || IS_UNFROZEN_INTRINSICS_ENVIRONMENT) &&
+            browserFrame.page.context.browser.settings.enableJavaScriptEvaluation &&
+            !browserFrame.page.context.browser.settings.suppressInsecureJavaScriptEnvironmentWarning &&
+            !browserFrame.page.context.browser.settings.suppressCodeGenerationFromStringsWarning) {
+            // eslint-disable-next-line no-console
+            console.warn('\nWarning! Happy DOM has JavaScript evaluation enabled and is running in an insecure environment.' +
+                '\n\nA VM Context is not an isolated environment, and if you run untrusted code you are at risk of RCE (Remote Code Execution) attacks. The attacker can escape the VM and run code at process level.' +
+                '\n\nIt is recommended to disable code generation and freeze all builtins at process level by running node with the flags "--disallow-code-generation-from-strings" and "--frozen-intrinsics".' +
+                ' You can suppress this warning by setting "suppressInsecureJavaScriptEnvironmentWarning" to "true" at your own risk.' +
+                '\n\nFor more information, see https://github.com/capricorn86/happy-dom/wiki/JavaScript-Evaluation-Warning\n\n');
+        }
+    }
     /**
      * Destroys the window.
      */
@@ -1384,8 +1585,6 @@ export default class BrowserWindow extends EventTarget {
             }
         }
         this[PropertySymbol.mutationObservers] = [];
-        this[PropertySymbol.asyncTaskManager] = null;
-        this[PropertySymbol.mutationObservers] = [];
         // Disconnects nodes from the document, so that they can be garbage collected.
         const childNodes = this.document[PropertySymbol.nodeArray];
         while (childNodes.length > 0) {
@@ -1411,6 +1610,10 @@ export default class BrowserWindow extends EventTarget {
         if (this.history[PropertySymbol.destroy]) {
             this.history[PropertySymbol.destroy]();
         }
+        this[PropertySymbol.modules].json.clear();
+        this[PropertySymbol.modules].css.clear();
+        this[PropertySymbol.modules].esm.clear();
+        this.document[PropertySymbol.preloads].clear();
         this.document[PropertySymbol.activeElement] = null;
         this.document[PropertySymbol.nextActiveElement] = null;
         this.document[PropertySymbol.currentScript] = null;