Datasets:

SuperSecureHuman
/

vendata-code

Dataset card Data Studio Files Files and versions Community

Split (1)

train · 9.13k rows

Subsets and Splits

No saved queries yet

Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.

repo_id stringlengths 22 103	file_path stringlengths 41 147	content stringlengths 181 193k
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/dump/index.md	--- title: "Window: dump() method" short-title: dump() slug: Web/API/Window/dump page-type: web-api-instance-method status: - non-standard browser-compat: api.Window.dump --- {{ ApiRef() }} {{Non-standard_header}} The `Window.dump()` method logs messages to the browser's standard output (`stdout`). If the browser was started from a terminal, output sent to `dump()` will appear in the terminal. Output from `dump()` is _not_ sent to the browser's developer tools console. To log to the developer tools console, use [`console.log()`](/en-US/docs/Web/API/console/log_static). ## Syntax ```js-nolint dump(message) ``` ### Parameters - `message` - : A string containing the message to log. ### Return value None ({{jsxref("undefined")}}). ## Specifications This feature is not part of any specification. ## Browser compatibility {{Compat}}
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/external/index.md	--- title: "Window: external property" short-title: external slug: Web/API/Window/external page-type: web-api-instance-property status: - deprecated browser-compat: api.Window.external --- {{APIRef}} {{deprecated_header}} The `external` property of the {{domxref("Window")}} API returns an instance of the `External` interface, which was intended to contain functions related to adding external search providers to the browser. However, this is now deprecated, and the contained methods are now dummy functions that do nothing as per spec. ## Instance methods The `External` object has the following methods: <table class="fullwidth-table"> <tbody> <tr> <th>Method</th> <th>Description</th> </tr> <tr> <td> <code>AddSearchProvider(<em>descriptionURL)</em></code> </td> <td> Dummy function; does nothing. See <a href="/en-US/docs/Web/OpenSearch#autodiscovery_of_search_plugins" >Autodiscovery of search plugins</a >. </td> </tr> <tr> <td><code>IsSearchProviderInstalled()</code></td> <td>Dummy function; does nothing.</td> </tr> </tbody> </table> ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/resizeby/index.md	--- title: "Window: resizeBy() method" short-title: resizeBy() slug: Web/API/Window/resizeBy page-type: web-api-instance-method browser-compat: api.Window.resizeBy --- {{APIRef}} The `Window.resizeBy()` method resizes the current window by a specified amount. ## Syntax ```js-nolint resizeBy(xDelta, yDelta) ``` ### Parameters - `xDelta` is the number of pixels to grow the window horizontally. - `yDelta` is the number of pixels to grow the window vertically. ### Return value None ({{jsxref("undefined")}}). ## Examples ```js // Shrink the window window.resizeBy(-200, -200); ``` ## Notes This method resizes the window relative to its current size. To resize the window in absolute terms, use {{domxref("window.resizeTo()")}}. ### Creating and resizing an external window For security reasons, it's no longer possible in Firefox for a website to change the default size of a window in a browser if the window wasn't created by `window.open()`, or contains more than one tab. See the compatibility table for details on the change. Even if you create window by `window.open()` it is not resizable by default. To make the window resizable, you must open it with the `"resizable"` feature. ```js // Create resizable window myExternalWindow = window.open( "https://example.com", "myWindowName", "resizable", ); // Resize window to 500x500 myExternalWindow.resizeTo(500, 500); // Make window relatively smaller to 400x400 myExternalWindow.resizeBy(-100, -100); ``` The window you create must respect the Same Origin Policy. If the window you open is not in the same origin as the current window, you will not be able to resize, or access any information on, that window/tab. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/credentialless/index.md	--- title: "Window: credentialless property" short-title: credentialless slug: Web/API/Window/credentialless page-type: web-api-instance-property status: - experimental browser-compat: api.Window.credentialless --- {{APIRef}}{{SeeCompatTable}} The `window.credentialless` read-only property returns a boolean that indicates whether the current document was loaded inside a credentialless {{htmlelement("iframe")}}, meaning that it is loaded in a new, ephemeral context. This context doesn't have access to the network, cookies, and storage data associated with its origin. It uses a new context local to the top-level document lifetime. In return, the {{httpheader("Cross-Origin-Embedder-Policy")}} (COEP) embedding rules can be lifted, so documents with COEP set can embed third-party documents that do not. See [IFrame credentialless](/en-US/docs/Web/Security/IFrame_credentialless) for a deeper explanation. ## Value A boolean. A value of `true` indicates that the document was loaded inside a credentialless `<iframe>`; `false` indicates that it was not. ## Examples You can specify a credentialless `<iframe>` like so: ```html <iframe src="https://en.wikipedia.org/wiki/Spectre_(security_vulnerability)" title="Spectre vulnerability Wikipedia page" width="960" height="600" credentialless></iframe> ``` In supporting browsers, if the document loaded in the `<iframe>` were to run the following line, it would return `true`: ```js console.log(window.credentialless); ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/copy_event/index.md	--- title: "Window: copy event" short-title: copy slug: Web/API/Window/copy_event page-type: web-api-event browser-compat: api.Element.copy_event --- {{APIRef}} The `copy` event fires when the user initiates a copy action through the browser's user interface. The original target for this event is the {{domxref("Element")}} that was the intended target of the copy action. You can listen for this event on the {{domxref("Window")}} interface to handle it in the capture or bubbling phases. For full details on this event please see the page on the [Element: copy event](/en-US/docs/Web/API/Element/copy_event). ## Syntax Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property. ```js addEventListener("copy", (event) => {}); oncopy = (event) => {}; ``` ## Event type A {{domxref("ClipboardEvent")}}. Inherits from {{domxref("Event")}}. {{InheritanceDiagram("ClipboardEvent")}} ## Examples ```js window.addEventListener("copy", (event) => { console.log("copy action initiated"); }); ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - Related events: {{domxref("Window/cut_event", "cut")}}, {{domxref("Window/paste_event", "paste")}} - This event on {{domxref("Element")}} targets: {{domxref("Element/copy_event", "copy")}} - This event on {{domxref("Document")}} targets: {{domxref("Document/copy_event", "copy")}}
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/document/index.md	--- title: "Window: document property" short-title: document slug: Web/API/Window/document page-type: web-api-instance-property browser-compat: api.Window.document --- {{APIRef}} `window.document` returns a reference to the [document](/en-US/docs/Web/API/Document) contained in the window. ## Value A [document](/en-US/docs/Web/API/Document) object. ## Examples ```js console.log(window.document.title); ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/online_event/index.md	--- title: "Window: online event" short-title: online slug: Web/API/Window/online_event page-type: web-api-event browser-compat: api.Window.online_event --- {{APIRef}} The `online` event of the {{domxref("Window")}} interface is fired when the browser has gained access to the network and the value of {{domxref("Navigator.onLine")}} switches to `true`. > Note: This event shouldn't be used to determine the availability of a particular website. Network problems or firewalls might still prevent the website from being reached. ## Syntax Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property. ```js addEventListener("online", (event) => {}); ononline = (event) => {}; ``` ## Event type A generic {{domxref("Event")}}. ## Event handler aliases In addition to the `Window` interface, the event handler property `ononline` is also available on the following targets: - {{domxref("HTMLBodyElement")}} - {{domxref("HTMLFrameSetElement")}} - {{domxref("SVGSVGElement")}} ## Examples ```js // addEventListener version window.addEventListener("online", (event) => { console.log("You are now connected to the network."); }); // ononline version window.ononline = (event) => { console.log("You are now connected to the network."); }; ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - [`offline`](/en-US/docs/Web/API/Window/offline_event)
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/beforeprint_event/index.md	--- title: "Window: beforeprint event" short-title: beforeprint slug: Web/API/Window/beforeprint_event page-type: web-api-event browser-compat: api.Window.beforeprint_event --- {{APIRef}} The `beforeprint` event is fired when the associated document is about to be printed or previewed for printing. The {{domxref("Window.afterprint_event", "afterprint")}} and `beforeprint` events allow pages to change their content before printing starts (perhaps to remove a banner, for example) and then revert those changes after printing has completed. In general, you should prefer the use of a [`@media print`](/en-US/docs/Web/CSS/CSS_media_queries/Using_media_queries#targeting_media_types) CSS at-rule, but it may be necessary to use these events in some cases. ## Syntax Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property. ```js addEventListener("beforeprint", (event) => {}); onbeforeprint = (event) => {}; ``` ## Event type A generic {{domxref("Event")}}. ## Examples Using `addEventListener()`: ```js window.addEventListener("beforeprint", (event) => { console.log("Before print"); }); ``` Using the `onbeforeprint` event handler property: ```js window.onbeforeprint = (event) => { console.log("Before print"); }; ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - Related events: {{domxref("Window/afterprint_event", "afterprint")}}
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/frames/index.md	--- title: "Window: frames property" short-title: frames slug: Web/API/Window/frames page-type: web-api-instance-property browser-compat: api.Window.frames --- {{APIRef("DOM")}} Returns the window itself, which is an array-like object, listing the direct sub-frames of the current window. ## Value A list of frame objects. It is similar to an array in that it has a `length` property and its items can be accessed using the `[i]` notation. - `frameList === window` evaluates to true. - Each item in the `window.frames` pseudo-array represents the {{domxref("Window")}} object corresponding to the given {{HTMLElement("frame")}}'s or {{HTMLElement("iframe")}}'s content, not the `frame` or `iframe` DOM element (i.e., `window.frames[0]` is the same thing as `document.getElementsByTagName("iframe")[0].contentWindow`). - For more details about the returned value, refer to this [thread on mozilla.dev.platform](https://groups.google.com/d/topic/mozilla.dev.platform/VijG80aFnU8?hl=en&pli=1). ## Examples ```js const frames = window.frames; // or const frames = window.parent.frames; for (let i = 0; i < frames.length; i++) { // do something with each subframe as frames[i] frames[i].document.body.style.background = "red"; } ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/stop/index.md	--- title: "Window: stop() method" short-title: stop() slug: Web/API/Window/stop page-type: web-api-instance-method browser-compat: api.Window.stop --- {{APIRef}} The `window.stop()` stops further resource loading in the current browsing context, equivalent to the stop button in the browser. Because of how scripts are executed, this method cannot interrupt its parent document's loading, but it will stop its images, new windows, and other still-loading objects. ## Syntax ```js-nolint stop() ``` ### Parameters None. ### Return value None ({{jsxref("undefined")}}). ## Examples ```js window.stop(); ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/languagechange_event/index.md	--- title: "Window: languagechange event" short-title: languagechange slug: Web/API/Window/languagechange_event page-type: web-api-event browser-compat: api.Window.languagechange_event --- {{APIRef}} The `languagechange` event is fired at the global scope object when the user's preferred language changes. ## Syntax Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property. ```js addEventListener("languagechange", (event) => {}); onlanguagechange = (event) => {}; ``` ## Event type A generic {{domxref("Event")}}. ## Event handler aliases In addition to the `Window` interface, the event handler property `onlanguagechange` is also available on the following targets: - {{domxref("HTMLBodyElement")}} - {{domxref("HTMLFrameSetElement")}} - {{domxref("SVGSVGElement")}} ## Examples You can use the `languagechange` event in an {{domxref("EventTarget/addEventListener", "addEventListener")}} method: ```js window.addEventListener("languagechange", () => { console.log("languagechange event detected!"); }); ``` Or use the `onlanguagechange` event handler property: ```js window.onlanguagechange = (event) => { console.log("languagechange event detected!"); }; ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("navigator.language")}} - {{domxref("navigator.languages")}} - {{domxref("navigator")}}
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/localstorage/index.md	--- title: "Window: localStorage property" short-title: localStorage slug: Web/API/Window/localStorage page-type: web-api-instance-property browser-compat: api.Window.localStorage --- {{APIRef("Web Storage API")}} The `localStorage` read-only property of the {{domxref("window")}} interface allows you to access a {{DOMxRef("Storage")}} object for the {{DOMxRef("Document")}}'s {{glossary("origin")}}; the stored data is saved across browser sessions. `localStorage` is similar to {{DOMxRef("Window.sessionStorage", "sessionStorage")}}, except that while `localStorage` data has no expiration time, `sessionStorage` data gets cleared when the page session ends — that is, when the page is closed. (`localStorage` data for a document loaded in a "private browsing" or "incognito" session is cleared when the last "private" tab is closed.) ## Value A {{DOMxRef("Storage")}} object which can be used to access the current origin's local storage space. ### Exceptions - `SecurityError` - : Thrown in one of the following cases: - The origin is not [a valid scheme/host/port tuple](/en-US/docs/Web/Security/Same-origin_policy#definition_of_an_origin). This can happen if the origin uses the `file:` or `data:` schemes, for example. - The request violates a policy decision. For example, the user has configured the browsers to prevent the page from persisting data. Note that if the user blocks cookies, browsers will probably interpret this as an instruction to prevent the page from persisting data. ## Description The keys and the values stored with `localStorage` are _always_ in the UTF-16 string format, which uses two bytes per character. As with objects, integer keys are automatically converted to strings. `localStorage` data is specific to the protocol of the document. In particular, for a site loaded over HTTP (e.g., `http://example.com`), `localStorage` returns a different object than `localStorage` for the corresponding site loaded over HTTPS (e.g., `https://example.com`). For documents loaded from `file:` URLs (that is, files opened in the browser directly from the user's local filesystem, rather than being served from a web server) the requirements for `localStorage` behavior are undefined and may vary among different browsers. In all current browsers, `localStorage` seems to return a different object for each `file:` URL. In other words, each `file:` URL seems to have its own unique local-storage area. But there are no guarantees about that behavior, so you shouldn't rely on it because, as mentioned above, the requirements for `file:` URLs remain undefined. So it's possible that browsers may change their `file:` URL handling for `localStorage` at any time. In fact some browsers _have_ changed their handling for it over time. ## Examples The following snippet accesses the current domain's local {{DOMxRef("Storage")}} object and adds a data item to it using {{DOMxRef("Storage.setItem()")}}. ```js localStorage.setItem("myCat", "Tom"); ``` The syntax for reading the `localStorage` item is as follows: ```js const cat = localStorage.getItem("myCat"); ``` The syntax for removing the `localStorage` item is as follows: ```js localStorage.removeItem("myCat"); ``` The syntax for removing all the `localStorage` items is as follows: ```js localStorage.clear(); ``` > Note: Please refer to the [Using the Web Storage API](/en-US/docs/Web/API/Web_Storage_API/Using_the_Web_Storage_API) article for a full example. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - [Using the Web Storage API](/en-US/docs/Web/API/Web_Storage_API/Using_the_Web_Storage_API) - {{DOMxRef("Window.sessionStorage")}}
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/moveto/index.md	--- title: "Window: moveTo() method" short-title: moveTo() slug: Web/API/Window/moveTo page-type: web-api-instance-method browser-compat: api.Window.moveTo --- {{APIRef}} The `moveTo()` method of the {{domxref("Window")}} interface moves the current window to the specified coordinates. > Note: This function moves the window to an absolute location. In > contrast, {{domxref("window.moveBy()")}} moves the window relative to its current > location. ## Syntax ```js-nolint moveTo(x, y) ``` ### Parameters - `x` is the horizontal coordinate to be moved to. - `y` is the vertical coordinate to be moved to. ### Return value None ({{jsxref("undefined")}}). ## Examples This example moves the window to the top-left corner of the screen. ```js function origin() { window.moveTo(0, 0); } ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} As of Firefox 7, websites can no longer move a browser window [in the following cases](https://bugzil.la/565541#c24): 1. You can't move a window or tab that wasn't created by {{domxref("Window.open()")}}. 2. You can't move a window or tab when it's in a window with more than one tab. ## See also - {{domxref("Window.moveBy()")}}
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/messageerror_event/index.md	--- title: "Window: messageerror event" short-title: messageerror slug: Web/API/Window/messageerror_event page-type: web-api-event browser-compat: api.Window.messageerror_event --- {{APIRef}} The `messageerror` event is fired on a {{domxref('Window')}} object when it receives a message that can't be deserialized. This event is not cancellable and does not bubble. ## Syntax Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property. ```js addEventListener("messageerror", (event) => {}); onmessageerror = (event) => {}; ``` ## Event type A {{domxref("MessageEvent")}}. Inherits from {{domxref("Event")}}. {{InheritanceDiagram("MessageEvent")}} ## Event properties _This interface also inherits properties from its parent, {{domxref("Event")}}._ - {{domxref("MessageEvent.data")}} {{ReadOnlyInline}} - : The data sent by the message emitter. - {{domxref("MessageEvent.origin")}} {{ReadOnlyInline}} - : A string representing the origin of the message emitter. - {{domxref("MessageEvent.lastEventId")}} {{ReadOnlyInline}} - : A string representing a unique ID for the event. - {{domxref("MessageEvent.source")}} {{ReadOnlyInline}} - : A `MessageEventSource` (which can be a {{glossary("WindowProxy")}}, {{domxref("MessagePort")}}, or {{domxref("ServiceWorker")}} object) representing the message emitter. - {{domxref("MessageEvent.ports")}} {{ReadOnlyInline}} - : An array of {{domxref("MessagePort")}} objects representing the ports associated with the channel the message is being sent through (where appropriate, e.g. in channel messaging or when sending a message to a shared worker). ## Examples Listen for `messageerror` using {{domxref("EventTarget/addEventListener", "addEventListener()")}}: ```js window.addEventListener("messageerror", (event) => { console.error(event); }); ``` The same, but using the `onmessageerror` event handler property: ```js window.onmessageerror = (event) => { console.error(event); }; ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("Window.postMessage()")}} - Related events: {{domxref("Window/message_event", "message")}}.
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/parent/index.md	--- title: "Window: parent property" short-title: parent slug: Web/API/Window/parent page-type: web-api-instance-property browser-compat: api.Window.parent --- {{APIRef}} The `Window.parent` property is a reference to the parent of the current window or subframe. If a window does not have a parent, its `parent` property is a reference to itself. When a window is loaded in an {{htmlelement("iframe")}}, {{htmlelement("object")}}, or {{htmlelement("frame")}}, its parent is the window with the element embedding the window. ## Value A `Window` or {{htmlelement("iframe")}} object. ## Examples ```js if (window.parent !== window.top) { // We're deeper than one down } ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("window.frameElement")}} returns the specific element (such as `<iframe>`) the `window` is embedded into. - {{domxref("window.top")}} returns a reference to the top-level window.
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/vrdisplaydisconnect_event/index.md	--- title: "Window: vrdisplaydisconnect event" short-title: vrdisplaydisconnect slug: Web/API/Window/vrdisplaydisconnect_event page-type: web-api-event status: - deprecated - non-standard browser-compat: api.Window.vrdisplaydisconnect_event --- {{APIRef("Window")}}{{Deprecated_Header}}{{Non-standard_Header}} The `vrdisplaydisconnect` event of the [WebVR API](/en-US/docs/Web/API/WebVR_API) is fired when a compatible VR display is disconnected from the computer. This event is not cancelable and does not bubble. ## Syntax Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property. ```js addEventListener("vrdisplaydisconnect", (event) => {}); onvrdisplaydisconnect = (event) => {}; ``` ## Event type A {{domxref("VRDisplayEvent")}}. Inherits from {{domxref("Event")}}. {{InheritanceDiagram("VRDisplayEvent")}} ## Event properties _`VRDisplayEvent` also inherits properties from its parent object, {{domxref("Event")}}._ - {{domxref("VRDisplayEvent.display")}} {{Deprecated_Inline}} {{ReadOnlyInline}} - : The {{domxref("VRDisplay")}} associated with this event. - {{domxref("VRDisplayEvent.reason")}} {{Deprecated_Inline}} {{ReadOnlyInline}} - : A human-readable reason why the event was fired. ## Examples You can use the `vrdisplaydisconnect` event in an [`addEventListener`](/en-US/docs/Web/API/EventTarget/addEventListener) method: > Note: This event was part of the old [WebVR API](https://immersive-web.github.io/webvr/spec/1.1/). It has been superseded by the [WebXR Device API](https://immersive-web.github.io/webxr/). ```js window.addEventListener("vrdisplaydisconnect", () => { info.textContent = "Display disconnected."; reportDisplays(); }); ``` Or use the `onvrdisplaydisconnect` event handler property: ```js window.onvrdisplaydisconnect = () => { info.textContent = "Display disconnected."; reportDisplays(); }; ``` ## Specifications This event was part of the old [WebVR API](https://immersive-web.github.io/webvr/spec/1.1/) that has been superseded by the [WebXR Device API](https://immersive-web.github.io/webxr/). It is no longer on track to becoming a standard. Until all browsers have implemented the new [WebXR Device API](https://immersive-web.github.io/webxr/), it is recommended to rely on frameworks, like [A-Frame](https://aframe.io/), [Babylon.js](https://www.babylonjs.com/), or [Three.js](https://threejs.org/), or a [polyfill](https://github.com/immersive-web/webxr-polyfill), to develop WebXR applications that will work across all browsers [\[1\]](https://developer.oculus.com/documentation/web/port-vr-xr/). ## Browser compatibility {{Compat}} ## See also - [WebVR API](/en-US/docs/Web/API/WebVR_API)
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/mozinnerscreeny/index.md	--- title: "Window: mozInnerScreenY property" short-title: mozInnerScreenY slug: Web/API/Window/mozInnerScreenY page-type: web-api-instance-property status: - non-standard browser-compat: api.Window.mozInnerScreenY --- {{APIRef}}{{Non-standard_Header}} The `mozInnerScreenY` property of the {{domxref("Window")}} interface returns the Y coordinate of the top-left corner of the window's viewport, in screen coordinates. > Note: This coordinate is reported in CSS pixels, not in hardware pixels. ## Value The `window.mozInnerScreenY` property is a floating point, read-only value; it has no default value. ## Specifications This feature is not part of any current specification. It is not on track to become a standard. ## Browser compatibility {{Compat}} ## See also - {{domxref("window.mozInnerScreenX")}}
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/deviceorientation_event/index.md	--- title: "Window: deviceorientation event" short-title: deviceorientation slug: Web/API/Window/deviceorientation_event page-type: web-api-event browser-compat: api.Window.deviceorientation_event --- {{APIRef("Device Orientation Events")}}{{securecontext_header}} The `deviceorientation` event is fired when fresh data is available from an orientation sensor about the current orientation of the device as compared to the Earth coordinate frame. This data is gathered from a magnetometer inside the device. See [Orientation and motion data explained](/en-US/docs/Web/API/Device_orientation_events/Orientation_and_motion_data_explained) for details. This event is not cancelable and does not bubble. ## Syntax Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property. ```js addEventListener("deviceorientation", (event) => {}); ondeviceorientation = (event) => {}; ``` ## Event type A {{domxref("DeviceOrientationEvent")}}. Inherits from {{domxref("Event")}}. {{InheritanceDiagram("DeviceOrientationEvent")}} ## Event properties - {{domxref("DeviceOrientationEvent.absolute")}} {{ReadOnlyInline}} - : A boolean that indicates whether the device is providing orientation data absolutely. - {{domxref("DeviceOrientationEvent.alpha")}} {{ReadOnlyInline}} - : A number representing the motion of the device around the z axis, express in degrees with values ranging from 0 (inclusive) to 360 (exclusive). - {{domxref("DeviceOrientationEvent.beta")}} {{ReadOnlyInline}} - : A number representing the motion of the device around the x axis, expressed in degrees with values ranging from -180 (inclusive) to 180 (exclusive). This represents the front to back motion of the device. - {{domxref("DeviceOrientationEvent.gamma")}} {{ReadOnlyInline}} - : A number representing the motion of the device around the y axis, expressed in degrees with values ranging from -90 (inclusive) to 90 (exclusive). This represents the left to right motion of the device. - `DeviceOrientationEvent.webkitCompassHeading` {{Non-Standard_Inline}} {{ReadOnlyInline}} - : A number represents the difference between the motion of the device around the z axis of the world system and the direction of the north, expressed in degrees with values ranging from 0 to 360. - `DeviceOrientationEvent.webkitCompassAccuracy` {{Non-Standard_Inline}} {{ReadOnlyInline}} - : The accuracy of the compass given as a positive or negative deviation. It's usually 10. ## Examples ```js if (window.DeviceOrientationEvent) { window.addEventListener( "deviceorientation", (event) => { const rotateDegrees = event.alpha; // alpha: rotation around z-axis const leftToRight = event.gamma; // gamma: left to right const frontToBack = event.beta; // beta: front back motion handleOrientationEvent(frontToBack, leftToRight, rotateDegrees); }, true, ); } const handleOrientationEvent = (frontToBack, leftToRight, rotateDegrees) => { // do something amazing }; ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - [`devicemotion`](/en-US/docs/Web/API/Window/devicemotion_event) - [Detecting device orientation](/en-US/docs/Web/API/Device_orientation_events/Detecting_device_orientation) - [Orientation and motion data explained](/en-US/docs/Web/API/Device_orientation_events/Orientation_and_motion_data_explained)
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/length/index.md	--- title: "Window: length property" short-title: length slug: Web/API/Window/length page-type: web-api-instance-property browser-compat: api.Window.length --- {{ ApiRef() }} Returns the number of frames (either {{HTMLElement("frame")}} or {{HTMLElement("iframe")}} elements) in the window. ## Value A number. ## Examples ```js if (window.length) { // this is a document with subframes } ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/documentpictureinpicture/index.md	--- title: "Window: documentPictureInPicture property" short-title: documentPictureInPicture slug: Web/API/Window/documentPictureInPicture page-type: web-api-instance-property status: - experimental browser-compat: api.Window.documentPictureInPicture --- {{APIRef}}{{seecompattable}}{{SecureContext_Header}} The `documentPictureInPicture` read-only property of the {{domxref("Window")}} interface returns a reference to the {{domxref("DocumentPictureInPicture")}} object for the current document context. ## Value A {{domxref("DocumentPictureInPicture")}} object instance. ## Examples ```js const videoPlayer = document.getElementById("player"); // ... // Open a Picture-in-Picture window. await window.documentPictureInPicture.requestWindow({ width: videoPlayer.clientWidth, height: videoPlayer.clientHeight, }); // ... ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("Document Picture-in-Picture API", "Document Picture-in-Picture API", "", "nocode")}} - [Using the Document Picture-in-Picture API](/en-US/docs/Web/API/Document_Picture-in-Picture_API/Using)
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/releaseevents/index.md	--- title: "Window: releaseEvents() method" short-title: releaseEvents() slug: Web/API/Window/releaseEvents page-type: web-api-instance-method status: - deprecated browser-compat: api.Window.releaseEvents --- {{APIRef}}{{Deprecated_Header}} Releases the window from trapping events of a specific type. ## Syntax ```js-nolint releaseEvents(eventType) ``` ### Parameters - `eventType` - : `eventType` is a combination of the following values: `Event.ABORT`, `Event.BLUR`, `Event.CLICK`, `Event.CHANGE`, `Event.DBLCLICK`, `Event.DRAGDDROP`, `Event.ERROR`, `Event.FOCUS`, `Event.KEYDOWN`, `Event.KEYPRESS`, `Event.KEYUP`, `Event.LOAD`, `Event.MOUSEDOWN`, `Event.MOUSEMOVE`, `Event.MOUSEOUT`, `Event.MOUSEOVER`, `Event.MOUSEUP`, `Event.MOVE`, `Event.RESET`, `Event.RESIZE`, `Event.SELECT`, `Event.SUBMIT`, `Event.UNLOAD`. ### Return value None ({{jsxref("undefined")}}). ## Examples ```js window.releaseEvents(Event.KEYPRESS); ``` ## Notes Note that you can pass a list of events to this method using the following syntax: `window.releaseEvents(Event.KEYPRESS \| Event.KEYDOWN \| Event.KEYUP)`. See also [`window.captureEvents`](/en-US/docs/Web/API/Window/captureEvents) ({{Deprecated_Inline}}). ## Specifications This is not part of any specification. ## Browser compatibility {{Compat}}
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/prompt/index.md	--- title: "Window: prompt() method" short-title: prompt() slug: Web/API/Window/prompt page-type: web-api-instance-method browser-compat: api.Window.prompt --- {{ApiRef("Window")}} `window.prompt()` instructs the browser to display a dialog with an optional message prompting the user to input some text, and to wait until the user either submits the text or cancels the dialog. Under some conditions — for example, when the user switches tabs — the browser may not actually display a dialog, or may not wait for the user to submit text or to cancel the dialog. ## Syntax ```js-nolint prompt() prompt(message) prompt(message, defaultValue) ``` ### Parameters - `message` {{optional_inline}} - : A string of text to display to the user. Can be omitted if there is nothing to show in the prompt window. - `defaultValue` {{optional_inline}} - : A string containing the default value displayed in the text input field. ### Return value A string containing the text entered by the user, or `null`. ## Examples ```js let sign = prompt("What's your sign?"); if (sign.toLowerCase() === "scorpio") { alert("Wow! I'm a Scorpio too!"); } // there are many ways to use the prompt feature sign = window.prompt(); // open the blank prompt window sign = prompt(); // open the blank prompt window sign = window.prompt("Are you feeling lucky"); // open the window with Text "Are you feeling lucky" sign = window.prompt("Are you feeling lucky", "sure"); // open the window with Text "Are you feeling lucky" and default value "sure" ``` When the user clicks the OK button, text entered in the input field is returned. If the user clicks OK without entering any text, an empty string is returned. If the user clicks the Cancel button, this function returns `null`. The above prompt appears as follows (in Chrome on macOS): [![prompt() dialog in Chrome on macOS](prompt.png)](prompt.png) ## Notes A prompt dialog contains a single-line textbox, a Cancel button, and an OK button, and returns the (possibly empty) text the user entered into that textbox. Please note that result is a string. That means you should sometimes cast the value given by the user. For example, if their answer should be a Number, you should cast the value to Number. ```js const aNumber = Number(window.prompt("Type a number", "")); ``` Dialog boxes are modal windows; they prevent the user from accessing the rest of the program's interface until the dialog box is closed. For this reason, you should not overuse any function that creates a dialog box (or modal window). Alternatively {{HTMLElement("dialog")}} element can be used to take user inputs. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{HTMLElement("dialog")}} element - {{domxref("window.alert", "alert")}} - {{domxref("window.confirm", "confirm")}}
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/fullscreen/index.md	--- title: "Window: fullScreen property" short-title: fullScreen slug: Web/API/Window/fullScreen page-type: web-api-instance-property status: - non-standard browser-compat: api.Window.fullScreen --- {{APIRef}}{{Non-standard_Header}} The `fullScreen` property of the `Window` interface indicates whether the window is displayed in full screen mode or not. ## Value A boolean value with `true` meaning that the window is in full-screen mode and `false` meaning it isn't. ## Notes - Switching between regular window and full screen will fire the "resize" event on the corresponding window. ## Examples ```js if (window.fullScreen) { // it's fullscreen! } else { // not fullscreen! } ``` ## Browser compatibility {{Compat}}
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/find/index.md	--- title: "Window: find() method" short-title: find() slug: Web/API/Window/find page-type: web-api-instance-method status: - non-standard browser-compat: api.Window.find --- {{ApiRef}}{{Non-standard_Header}} > Note: Support for `Window.find()` might change in future > versions of Gecko. See [Firefox bug 672395](https://bugzil.la/672395). The `Window.find()` method finds a string in a window sequentially. ## Syntax ```js-nolint find(aString, aCaseSensitive, aBackwards, aWrapAround, aWholeWord, aSearchInFrames, aShowDialog) ``` ### Parameters - `aString` - : The text string for which to search. - `aCaseSensitive` - : A boolean value. If `true`, specifies a case-sensitive search. - `aBackwards` - : A boolean value. If `true`, specifies a backward search. - `aWrapAround` - : A boolean value. If `true`, specifies a wrap around search. - `aWholeWord` - : A boolean value. If `true`, specifies a whole word search. - `aSearchInFrames` - : A boolean value. If `true`, specifies a search in frames. - `aShowDialog` - : A boolean value. If `true`, a search dialog is shown. ### Return value `true` if the string is found; otherwise, `false`. ## Examples ### JavaScript ```js function findString(text) { document.querySelector("#output").textContent = `String found? ${window.find( text, )}`; } ``` ### HTML ```html <p>Apples, Bananas, and Oranges.</p> <button type="button" onClick='findString("Apples")'>Search for Apples</button> <button type="button" onClick='findString("Bananas")'> Search for Bananas </button> <button type="button" onClick='findString("Orange")'>Search for Orange</button> <p id="output"></p> ``` ### Result {{EmbedLiveSample("Examples")}} ## Notes In some browsers, `Window.find()` selects (highlights) the found content on the site. ## Specifications This is not part of any specification. ## Browser compatibility {{Compat}}
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/outerheight/index.md	--- title: "Window: outerHeight property" short-title: outerHeight slug: Web/API/Window/outerHeight page-type: web-api-instance-property browser-compat: api.Window.outerHeight --- {{APIRef}} The `Window.outerHeight` read-only property returns the height in pixels of the whole browser window, including any sidebar, window chrome, and window-resizing borders/handles. ## Notes To change the size of a window, see {{domxref("window.resizeBy()")}} and {{domxref("window.resizeTo()")}}. To get the inner height of a window, i.e. the height of the page being displayed, see {{domxref("window.innerHeight")}}. ### Graphical example The following figure shows the difference between `outerHeight` and `innerHeight`. ![innerHeight vs. outerHeight illustration](firefoxinnervsouterheight2.png) ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("window.innerHeight")}} - {{domxref("window.innerWidth")}} - {{domxref("window.outerWidth")}} - {{domxref("window.resizeBy()")}} - {{domxref("window.resizeTo()")}}
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/unhandledrejection_event/index.md	--- title: "Window: unhandledrejection event" short-title: unhandledrejection slug: Web/API/Window/unhandledrejection_event page-type: web-api-event browser-compat: api.Window.unhandledrejection_event --- {{APIRef("HTML DOM")}} The `unhandledrejection` event is sent to the global scope of a script when a JavaScript {{jsxref("Promise")}} that has no rejection handler is rejected; typically, this is the {{domxref("window")}}, but may also be a {{domxref("Worker")}}. This is useful for debugging and for providing fallback error handling for unexpected situations. ## Syntax Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property. ```js addEventListener("unhandledrejection", (event) => {}); onunhandledrejection = (event) => {}; ``` ## Event type A {{domxref("PromiseRejectionEvent")}}. Inherits from {{domxref("Event")}}. {{InheritanceDiagram("PromiseRejectionEvent")}} ## Event properties - {{domxref("PromiseRejectionEvent.promise")}} {{ReadOnlyInline}} - : The JavaScript {{jsxref("Promise")}} that was rejected. - {{domxref("PromiseRejectionEvent.reason")}} {{ReadOnlyInline}} - : A value or {{jsxref("Object")}} indicating why the promise was rejected, as passed to {{jsxref("Promise.reject()")}}. ## Event handler aliases In addition to the `Window` interface, the event handler property `onunhandledrejection` is also available on the following targets: - {{domxref("HTMLBodyElement")}} - {{domxref("HTMLFrameSetElement")}} - {{domxref("SVGSVGElement")}} ## Usage notes Allowing the `unhandledrejection` event to bubble will eventually result in an error message being output to the console. You can prevent this by calling {{domxref("Event.preventDefault", "preventDefault()")}} on the {{domxref("PromiseRejectionEvent")}}; see [Preventing default handling](#preventing_default_handling) below for an example. Because this event can leak data, {{jsxref("Promise")}} rejections that originate from a cross-origin script won't fire this event. ## Examples ### Basic error logging This example logs information about the unhandled promise rejection to the console. ```js window.addEventListener("unhandledrejection", (event) => { console.warn(`UNHANDLED PROMISE REJECTION: ${event.reason}`); }); ``` You can also use the `onunhandledrejection` event handler property to set up the event listener: ```js window.onunhandledrejection = (event) => { console.warn(`UNHANDLED PROMISE REJECTION: ${event.reason}`); }; ``` ### Preventing default handling Many environments (such as {{Glossary("Node.js")}}) report unhandled promise rejections to the console by default. You can prevent that from happening by adding a handler for `unhandledrejection` events that—in addition to any other tasks you wish to perform—calls {{domxref("Event.preventDefault()", "preventDefault()")}} to cancel the event, preventing it from bubbling up to be handled by the runtime's logging code. This works because `unhandledrejection` is cancelable. ```js window.addEventListener("unhandledrejection", (event) => { // code for handling the unhandled rejection // … // Prevent the default handling (such as outputting the // error to the console) event.preventDefault(); }); ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - [Promise rejection events](/en-US/docs/Web/JavaScript/Guide/Using_promises#promise_rejection_events) - {{domxref("Window/rejectionhandled_event", "rejectionhandled")}} event - {{jsxref("Promise")}}
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/offline_event/index.md	--- title: "Window: offline event" short-title: offline slug: Web/API/Window/offline_event page-type: web-api-event browser-compat: api.Window.offline_event --- {{APIRef}} The `offline` event of the {{domxref("Window")}} interface is fired when the browser has lost access to the network and the value of {{domxref("Navigator.onLine")}} switches to `false`. ## Syntax Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property. ```js addEventListener("offline", (event) => {}); onoffline = (event) => {}; ``` ## Event type A generic {{domxref("Event")}}. ## Event handler aliases In addition to the `Window` interface, the event handler property `onoffline` is also available on the following targets: - {{domxref("HTMLBodyElement")}} - {{domxref("HTMLFrameSetElement")}} - {{domxref("SVGSVGElement")}} ## Examples ```js // addEventListener version window.addEventListener("offline", (event) => { console.log("The network connection has been lost."); }); // onoffline version window.onoffline = (event) => { console.log("The network connection has been lost."); }; ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - [`online`](/en-US/docs/Web/API/Window/online_event)
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/requestfilesystem/index.md	--- title: "Window: requestFileSystem() method" short-title: requestFileSystem() slug: Web/API/Window/requestFileSystem page-type: web-api-instance-method status: - deprecated - non-standard browser-compat: api.Window.requestFileSystem --- {{APIRef("HTML DOM")}}{{Deprecated_Header}}{{non-standard_header}} The non-standard {{domxref("Window")}} method `requestFileSystem()` method is a Google Chrome-specific method which lets a website or app gain access to a sandboxed file system for its own use. The returned {{domxref("FileSystem")}} is then available for use with the other [file system APIs](/en-US/docs/Web/API/File_and_Directory_Entries_API). > Note: This method is prefixed with `webkit` in all browsers that implement it. ## Syntax ```js-nolint requestFileSystem(type, size, successCallback) requestFileSystem(type, size, successCallback, errorCallback) ``` ### Parameters - `type` - : The type of storage to request. Specify `Window.TEMPORARY` if it's acceptable for the browser to delete the files at its own discretion, such as if storage space runs low, or `Window.PERSISTENT` if you need the files to remain in place unless the user or the website or app explicitly permit it. Persistent storage requires that the user grant the site quota. - `size` - : The amount of storage space you wish to have allocated for your app's use. - `successCallback` - : A function which is invoked when the file system has been successfully obtained. The callback receives a single parameter: a {{domxref("FileSystem")}} object representing the file system the app has permission to use. - `errorCallback` {{optional_inline}} - : An optional parameter specifying a function which is called if an error occurs while attempting to obtain the file system, or if the user denies permission to create or access the file system. The callback receives as input a single parameter: a `FileError` object describing the error. ### Return value None ({{jsxref("undefined")}}). ## Specifications As this method was removed from the [File and Directory Entries API](https://wicg.github.io/entries-api/) proposal, it has no official W3C or WHATWG specification. It is no longer on track to become a standard. ## Browser compatibility {{Compat}} ## See also - [File and Directory Entries API support in Firefox](/en-US/docs/Web/API/File_and_Directory_Entries_API/Firefox_support)
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/orientationchange_event/index.md	--- title: "Window: orientationchange event" short-title: orientationchange slug: Web/API/Window/orientationchange_event page-type: web-api-event status: - deprecated browser-compat: api.Window.orientationchange_event --- {{APIRef}}{{Deprecated_Header}} The `orientationchange` event is fired when the orientation of the device has changed. This event is not cancelable and does not bubble. This event is deprecated. Listen for the {{domxref("ScreenOrientation.change_event", "change")}} event of the {{domxref("ScreenOrientation")}} interface instead. ## Syntax Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property. ```js addEventListener("orientationchange", (event) => {}); onorientationchange = (event) => {}; ``` ## Event type A generic {{domxref("Event")}}. ## Example You can use the `orientationchange` event in an {{domxref("EventTarget/addEventListener", "addEventListener")}} method: ```js window.addEventListener("orientationchange", (event) => { console.log( `the orientation of the device is now ${event.target.screen.orientation.angle}`, ); }); ``` Or use the `onorientationchange` event handler property: ```js window.onorientationchange = (event) => { console.log( `the orientation of the device is now ${event.target.screen.orientation.angle}`, ); }; ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/unload_event/index.md	--- title: "Window: unload event" short-title: unload slug: Web/API/Window/unload_event page-type: web-api-event status: - deprecated browser-compat: api.Window.unload_event --- {{APIRef}}{{deprecated_header}} > Warning: Developers should avoid using this event. See "Usage notes" below. The `unload` event is fired when the document or a child resource is being unloaded. It is fired after: - {{domxref("Window/beforeunload_event", "beforeunload")}} (cancelable event) - {{domxref("Window/pagehide_event", "pagehide")}} The document is in the following state: - All the resources still exist (img, iframe etc.) - Nothing is visible anymore to the end user - UI interactions are ineffective ({{domxref("window.open")}}, {{domxref("window.alert", "alert")}}, {{domxref("window.confirm", "confirm")}}, etc.) - An error won't stop the unloading workflow Please note that the unload event also follows the document tree: parent frame unload will happen before child frame `unload` (see example below). ## Syntax Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property. ```js addEventListener("unload", (event) => {}); onunload = (event) => {}; ``` ## Event type A generic {{domxref("Event")}}. ## Event handler aliases In addition to the `Window` interface, the event handler property `onunload` is also available on the following targets: - {{domxref("HTMLBodyElement")}} - {{domxref("HTMLFrameSetElement")}} - {{domxref("SVGSVGElement")}} ## Usage notes Developers should avoid using this event. Especially on mobile, the `unload` event is not reliably fired. For example, the `unload` event is not fired at all in the following scenario: 1. A mobile user visits your page. 2. The user then switches to a different app. 3. Later, the user closes the browser from the app manager. Also, the `unload` event is not compatible with the [back/forward cache](https://web.dev/articles/bfcache) (bfcache), because many pages using this event assume that the page will not continue to exist after the event is fired. To combat this, some browsers (such as Firefox) will not place pages in the bfcache if they have unload listeners, and this is bad for performance. Others, such as Chrome, will not fire the `unload` when a user navigates away. The best event to use to signal the end of a user's session is the [`visibilitychange`](/en-US/docs/Web/API/Document/visibilitychange_event) event. In browsers that don't support `visibilitychange` the next-best alternative is the [`pagehide`](/en-US/docs/Web/API/Window/pagehide_event) event, which is also not fired reliably, but which is bfcache-compatible. If you're specifically trying to detect page unload events, it's best to listen for the `pagehide` event. See the [Page Lifecycle API](https://developer.chrome.com/blog/page-lifecycle-api/#the-unload-event) guide for more information about the problems associated with the `unload` event. ## Examples ```html <!doctype html> <html lang="en-US"> <head> <meta charset="UTF-8" /> <title>Parent Frame</title> <script> window.addEventListener("beforeunload", (event) => { console.log("I am the 1st one."); }); window.addEventListener("unload", (event) => { console.log("I am the 3rd one."); }); </script> </head> <body> <iframe src="child-frame.html"></iframe> </body> </html> ``` Below, the content of `child-frame.html`: ```html <!doctype html> <html lang="en-US"> <head> <meta charset="UTF-8" /> <title>Child Frame</title> <script> window.addEventListener("beforeunload", (event) => { console.log("I am the 2nd one."); }); window.addEventListener("unload", (event) => { console.log("I am the 4th and last one…"); }); </script> </head> <body> ☻ </body> </html> ``` When the parent frame is unloaded, events will be fired in the order described by the `console.log()` messages. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - Related events: {{domxref("Document/DOMContentLoaded_event", "DOMContentLoaded")}}, {{domxref("Document/readystatechange_event", "readystatechange")}}, {{domxref("Window/load_event", "load")}} - [Unloading Documents — unload a document](https://html.spec.whatwg.org/multipage/browsers.html#unloading-documents) - The [`visibilitychange`](/en-US/docs/Web/API/Document/visibilitychange_event) event. - [Don't lose user and app state, use Page Visibility](https://www.igvita.com/2015/11/20/dont-lose-user-and-app-state-use-page-visibility/) explains in detail why you should use `visibilitychange`, not `beforeunload`/`unload`. - [Page Lifecycle API](https://developer.chrome.com/blog/page-lifecycle-api/#developer-recommendations-for-each-state) gives best-practices guidance on handling page lifecycle behavior in your web applications. - [PageLifecycle.js](https://github.com/GoogleChromeLabs/page-lifecycle): a JavaScript library that deals with cross-browser inconsistencies in page lifecycle behavior. - [Back/forward cache](https://web.dev/articles/bfcache) explains what the back/forward cache is, and its implications for various page lifecycle events.
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/frameelement/index.md	--- title: "Window: frameElement property" short-title: frameElement slug: Web/API/Window/frameElement page-type: web-api-instance-property browser-compat: api.Window.frameElement --- {{ApiRef}} The `Window.frameElement` property returns the element (such as {{HTMLElement("iframe")}} or {{HTMLElement("object")}}) in which the window is embedded. > Note: Despite this property's name, it works for documents embedded > within any embedding point, including {{HTMLElement("object")}}, > {{HTMLElement("iframe")}}, or {{HTMLElement("embed")}}. ## Value The element which the window is embedded into. If the window isn't embedded into another document, or if the document into which it's embedded has a different {{glossary("origin")}}, the value is [`null`](/en-US/docs/Web/JavaScript/Reference/Operators/null) instead. ## Examples ```js const frameEl = window.frameElement; // If we're embedded, change the containing element's URL to 'https://mozilla.org/' if (frameEl) { frameEl.src = "https://mozilla.org/"; } ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("window.frames")}} returns an array-like object, listing the direct sub-frames of the current window. - {{domxref("window.parent")}} returns the parent window, which is the window containing the `frameElement` of the child window.
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/scrollbars/index.md	--- title: "Window: scrollbars property" short-title: scrollbars slug: Web/API/Window/scrollbars page-type: web-api-instance-property browser-compat: api.Window.scrollbars --- {{APIRef()}} Returns the `scrollbars` object. This is one of a group of `Window` properties that contain a boolean `visible` property, that used to represent whether or not a particular part of a web browser's user interface was visible. For privacy and interoperability reasons, the value of the `visible` property is now `false` if this `Window` is a popup, and `true` otherwise. ## Value An object containing a single property: - `visible` {{ReadOnlyInline}} - : A boolean property, `false` if this `Window` is a popup, and `true` otherwise. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("window.locationbar")}} - {{domxref("window.menubar")}} - {{domxref("window.personalbar")}} - {{domxref("window.statusbar")}} - {{domxref("window.toolbar")}}
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/vrdisplayactivate_event/index.md	--- title: "Window: vrdisplayactivate event" short-title: vrdisplayactivate slug: Web/API/Window/vrdisplayactivate_event page-type: web-api-event status: - deprecated - non-standard browser-compat: api.Window.vrdisplayactivate_event --- {{APIRef("Window")}}{{Deprecated_Header}}{{Non-standard_Header}} The `vrdisplayactivate` event of the [WebVR API](/en-US/docs/Web/API/WebVR_API) is fired when a VR display is able to be presented to, for example if an HMD has been moved to bring it out of standby, or woken up by being put on. > Note: This event was part of the old [WebVR API](https://immersive-web.github.io/webvr/spec/1.1/). It has been superseded by the [WebXR Device API](https://immersive-web.github.io/webxr/). This event is not cancelable and does not bubble. ## Syntax Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property. ```js addEventListener("vrdisplayactivate", (event) => {}); onvrdisplayactivate = (event) => {}; ``` ## Event type A {{domxref("VRDisplayEvent")}}. Inherits from {{domxref("Event")}}. {{InheritanceDiagram("VRDisplayEvent")}} ## Event properties _`VRDisplayEvent` also inherits properties from its parent object, {{domxref("Event")}}._ - {{domxref("VRDisplayEvent.display")}} {{Deprecated_Inline}} {{ReadOnlyInline}} - : The {{domxref("VRDisplay")}} associated with this event. - {{domxref("VRDisplayEvent.reason")}} {{Deprecated_Inline}} {{ReadOnlyInline}} - : A human-readable reason why the event was fired. ## Examples You can use the `vrdisplayactivate` event in an [`addEventListener`](/en-US/docs/Web/API/EventTarget/addEventListener) method: ```js window.addEventListener("vrdisplayactivate", () => { info.textContent = "Display activated."; reportDisplays(); }); ``` Or use the `onvrdisplayactivate` event handler property: ```js window.onvrdisplayactivate = () => { info.textContent = "Display activated."; reportDisplays(); }; ``` ## Specifications This event was part of the old [WebVR API](https://immersive-web.github.io/webvr/spec/1.1/) that has been superseded by the [WebXR Device API](https://immersive-web.github.io/webxr/). It is no longer on track to becoming a standard. Until all browsers have implemented the new [WebXR Device API](https://immersive-web.github.io/webxr/), it is recommended to rely on frameworks, like [A-Frame](https://aframe.io/), [Babylon.js](https://www.babylonjs.com/), or [Three.js](https://threejs.org/), or a [polyfill](https://github.com/immersive-web/webxr-polyfill), to develop WebXR applications that will work across all browsers [\[1\]](https://developer.oculus.com/documentation/web/port-vr-xr/). ## Browser compatibility {{Compat}} ## See also - [WebVR API](/en-US/docs/Web/API/WebVR_API)
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/outerwidth/index.md	--- title: "Window: outerWidth property" short-title: outerWidth slug: Web/API/Window/outerWidth page-type: web-api-instance-property browser-compat: api.Window.outerWidth --- {{APIRef}} `Window.outerWidth` read-only property returns the width of the outside of the browser window. It represents the width of the whole browser window including sidebar (if expanded), window chrome and window resizing borders/handles. ## Notes To change the size of a window, see {{domxref("window.resizeBy()")}} and {{domxref("window.resizeTo()")}}. To get the inner width of a window, i.e. the width of the page being displayed, see {{domxref("window.innerWidth")}}. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("window.outerHeight")}}, {{domxref("window.innerHeight")}}, {{domxref("window.innerWidth")}} - {{domxref("window.resizeBy()")}}, {{domxref("window.resizeTo()")}}
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/screen/index.md	--- title: "Window: screen property" short-title: screen slug: Web/API/Window/screen page-type: web-api-instance-property browser-compat: api.Window.screen --- {{APIRef("CSSOM")}} The {{DOMxRef("Window")}} property `screen` returns a reference to the screen object associated with the window. The `screen` object, implementing the {{DOMxRef("Screen")}} interface, is a special object for inspecting properties of the screen on which the current window is being rendered. ## Value A {{DOMxRef("Screen")}} object. ## Examples ```js if (screen.pixelDepth < 8) { // use low-color version of page } else { // use regular, colorful page } ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/sessionstorage/index.md	--- title: "Window: sessionStorage property" short-title: sessionStorage slug: Web/API/Window/sessionStorage page-type: web-api-instance-property browser-compat: api.Window.sessionStorage --- {{APIRef("Web Storage API")}} The read-only `sessionStorage` property accesses a session {{DOMxRef("Storage")}} object for the current {{glossary("origin")}}. `sessionStorage` is similar to {{DOMxRef("Window.localStorage", "localStorage")}}; the difference is that while data in `localStorage` doesn't expire, data in `sessionStorage` is cleared when the _page session_ ends. - Whenever a document is loaded in a particular tab in the browser, a unique page session gets created and assigned to that particular tab. That page session is valid only for that particular tab. - A page session lasts as long as the tab or the browser is open, and survives over page reloads and restores. - Opening a page in a new tab or window creates a new session with the value of the top-level browsing context, which differs from how session cookies work. - Opening multiple tabs/windows with the same URL creates `sessionStorage` for each tab/window. - Duplicating a tab copies the tab's `sessionStorage` into the new tab. - Closing a tab/window ends the session and clears objects in `sessionStorage`. Data stored in `sessionStorage` is specific to the protocol of the page. In particular, data stored by a script on a site accessed with HTTP (e.g., [http://example.com](https://example.com)) is put in a different `sessionStorage` object from the same site accessed with HTTPS (e.g., <https://example.com>). The keys and the values are _always_ in the UTF-16 string format, which uses two bytes per character. As with objects, integer keys are automatically converted to strings. ## Value A {{DOMxRef("Storage")}} object which can be used to access the current origin's session storage space. ### Exceptions - `SecurityError` - : Thrown in one of the following cases: - The origin is not [a valid scheme/host/port tuple](/en-US/docs/Web/Security/Same-origin_policy#definition_of_an_origin). This can happen if the origin uses the `file:` or `data:` schemes, for example. - The request violates a policy decision. For example, the user has configured the browsers to prevent the page from persisting data. Note that if the user blocks cookies, browsers will probably interpret this as an instruction to prevent the page from persisting data. ## Examples ### Basic usage ```js // Save data to sessionStorage sessionStorage.setItem("key", "value"); // Get saved data from sessionStorage let data = sessionStorage.getItem("key"); // Remove saved data from sessionStorage sessionStorage.removeItem("key"); // Remove all saved data from sessionStorage sessionStorage.clear(); ``` ### Saving text between refreshes The following example autosaves the contents of a text field, and if the browser is refreshed, restores the text field content so that no writing is lost. ```js // Get the text field that we're going to track let field = document.getElementById("field"); // See if we have an autosave value // (this will only happen if the page is accidentally refreshed) if (sessionStorage.getItem("autosave")) { // Restore the contents of the text field field.value = sessionStorage.getItem("autosave"); } // Listen for changes in the text field field.addEventListener("change", () => { // And save the results into the session storage object sessionStorage.setItem("autosave", field.value); }); ``` > Note: Please refer to the [Using the Web Storage API](/en-US/docs/Web/API/Web_Storage_API/Using_the_Web_Storage_API) article for a full example. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - [Using the Web Storage API](/en-US/docs/Web/API/Web_Storage_API/Using_the_Web_Storage_API) - {{DOMxRef("Window.localStorage")}}
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/status/index.md	--- title: "Window: status property" short-title: status slug: Web/API/Window/status page-type: web-api-instance-property status: - deprecated browser-compat: api.Window.status --- {{APIRef}}{{Deprecated_Header}} The `status` property of the {{domxref("Window")}} interface was originally intended to set the text in the status bar at the bottom of the browser window. However, the HTML standard now requires setting `window.status` to have no effect on the text displayed in the status bar. ## Value A string. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/getselection/index.md	--- title: "Window: getSelection() method" short-title: getSelection() slug: Web/API/Window/getSelection page-type: web-api-instance-method browser-compat: api.Window.getSelection --- {{ ApiRef() }} The `Window.getSelection()` method returns a {{domxref("Selection")}} object representing the range of text selected by the user or the current position of the caret. ## Syntax ```js-nolint getSelection() ``` ### Parameters None. ### Return value A {{domxref("Selection")}} object. When cast to string, either by appending an empty string (`""`) or using {{domxref("Selection.toString()")}}, this object returns the text selected. When called on an {{htmlelement("iframe")}} that is not displayed (e.g., where `display: none` is set) Firefox will return `null`, whereas other browsers will return a {{domxref("Selection")}} object with {{domxref("Selection.type")}} set to `None`. ## Examples ```js function foo() { const selObj = window.getSelection(); alert(selObj); const selRange = selObj.getRangeAt(0); // do stuff with the range } ``` ## Notes ### String representation of the Selection object In JavaScript, when an object is passed to a function expecting a string (like {{ Domxref("window.alert()") }} or {{ Domxref("document.write()") }}), the object's {{jsxref("Object.toString", "toString()")}} method is called and the returned value is passed to the function. This can make the object appear to be a string when used with other functions when it is really an object with properties and methods. In the above example, `selObj.toString()` is automatically called when it is passed to {{domxref("window.alert()")}}. However, attempting to use a JavaScript [String](/en-US/docs/Web/JavaScript/Reference/Global_Objects/String) property or method such as [`length`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length) or [`substr`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substr) directly on a {{domxref("Selection")}} object will result in an error if it does not have that property or method and may return unexpected results if it does. To use a `Selection` object as a string, call its `toString()` method directly: ```js const selectedText = selObj.toString(); ``` - `selObj` is a `Selection` object. - `selectedText` is a string (Selected text). ### Related objects You can call {{domxref("Document.getSelection()")}}, which works identically to `Window.getSelection()`. It is worth noting that currently `getSelection()` doesn't work on the content of {{htmlelement("textarea")}} and {{htmlelement("input")}} elements in Firefox and Edge (Legacy). {{domxref("HTMLInputElement.setSelectionRange()")}} or the `selectionStart` and `selectionEnd` properties could be used to work around this. Notice also the difference between _selection_ and _focus_. {{domxref("Document.activeElement")}} returns the focused element. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - [Selection API](/en-US/docs/Web/API/Selection) - {{domxref("Selection")}} - {{domxref("Range")}} - {{domxref("Document.getSelection()")}} - {{domxref("HTMLInputElement.setSelectionRange()")}}
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/orientation/index.md	--- title: "Window: orientation property" short-title: orientation slug: Web/API/Window/orientation page-type: web-api-instance-property status: - deprecated browser-compat: api.Window.orientation --- {{APIRef}}{{Deprecated_Header}} Returns the orientation in degrees (in 90-degree increments) of the viewport relative to the device's natural orientation. Its only possible values are `-90`, `0`, `90`, and `180`. Positive values are counterclockwise; negative values are clockwise. This property is deprecated. Use the {{domxref("Screen.orientation")}} property instead, available on the {{domxref("window.screen")}} property. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
data/mdn-content/files/en-us/web/api/window	data/mdn-content/files/en-us/web/api/window/showmodaldialog/index.md	--- title: "Window: showModalDialog() method" short-title: showModalDialog() slug: Web/API/Window/showModalDialog page-type: web-api-instance-method status: - deprecated - non-standard browser-compat: api.Window.showModalDialog --- {{APIRef}}{{Deprecated_Header}}{{Non-standard_Header}} > Warning: This feature has been removed. Please fix your websites and applications. > > This method was removed in Chrome 43 and Firefox 56. The `Window.showModalDialog()` created and displayed a modal dialog box containing a specified HTML document. ## Syntax ```js-nolint showModalDialog(uri) showModalDialog(uri, arguments) showModalDialog(uri, arguments, options) ``` ### Parameters - `uri` - : Is the URL of the document to display in the dialog. - `arguments` {{optional_inline}} - : Values passed to the dialog. property. - `options` {{optional_inline}} - : A string specifying window ornamentation for the dialog, using one or more semicolon delimited values: <table class="no-markdown"> <tbody> <tr> <th>Syntax</th> <th>Description</th> </tr> <tr> <td><code>center: {on \| off \| yes \| no \| 1 \| 0 }</code></td> <td> If <code>on</code>, <code>yes</code>, or <code>1</code>, the dialog window is centered on the desktop; otherwise it's hidden. Default is <code>yes</code>. </td> </tr> <tr> <td> <code>dialogheight: <em>height</em></code> </td> <td>The height of the dialog box in pixels.</td> </tr> <tr> <td> <code>dialogleft: <em>left</em></code> </td> <td>Distance of the dialog box from the left edge of the desktop.</td> </tr> <tr> <td> <code>dialogwidth: <em>width</em></code> </td> <td>The width of the dialog box in pixels.</td> </tr> <tr> <td> <code>dialogtop: <em>top</em></code> </td> <td>Distance of the dialog box from the top edge of the desktop.</td> </tr> <tr> <td><code>resizable: {on \| off \| yes \| no \| 1 \| 0 }</code></td> <td> If this argument's value is <code>on</code>, <code>yes</code>, or 1, the dialog window can be resized by the user; otherwise its size is fixed. The default value is <code>no</code>. </td> </tr> <tr> <td><code>scroll: {on \| off \| yes \| no \| 1 \| 0 }</code></td> <td> If <code>on</code>, <code>yes</code>, or 1, the dialog window has scroll bars; otherwise its size is fixed. Default is <code>no</code>. </td> </tr> </tbody> </table> > Note: Firefox does not implement the `dialogHide`, `edge`, `status`, or `unadorned` arguments. ### Return value Holds the `returnValue` property as set by the document specified by `uri`. ## Specifications - [MSDN page for `showModalDialog`](<https://msdn.microsoft.com/library/ms536759(VS.85).aspx>) ## Browser compatibility {{Compat}} ## See also - {{HTMLElement("dialog")}}, a replacement for `window.showModalDialog()`. - [showModalDialog Polyfill](https://github.com/niutech/showModalDialog) using a {{HTMLElement("dialog")}} and [generators](/en-US/docs/Web/JavaScript/Reference/Statements/function*)