repo_id
stringlengths
22
103
file_path
stringlengths
41
147
content
stringlengths
181
193k
__index_level_0__
int64
0
0
data/mdn-content/files/en-us/web/api/element
data/mdn-content/files/en-us/web/api/element/attachshadow/index.md
--- title: "Element: attachShadow() method" short-title: attachShadow() slug: Web/API/Element/attachShadow page-type: web-api-instance-method browser-compat: api.Element.attachShadow --- {{APIRef('Shadow DOM')}} The **`Element.attachShadow()`** method attaches a shadow DOM tree to the specified element and returns a reference to its {{domxref("ShadowRoot")}}. ## Elements you can attach a shadow to Note that you can't attach a shadow root to every type of element. There are some that can't have a shadow DOM for security reasons (for example {{htmlelement("a")}}). The following is a list of elements you _can_ attach a shadow root to: - Any autonomous custom element with a [valid name](https://html.spec.whatwg.org/multipage/custom-elements.html#valid-custom-element-name) - {{htmlelement("article")}} - {{htmlelement("aside")}} - {{htmlelement("blockquote")}} - {{htmlelement("body")}} - {{htmlelement("div")}} - {{htmlelement("footer")}} - {{htmlelement("Heading_Elements", "h1")}} - {{htmlelement("Heading_Elements", "h2")}} - {{htmlelement("Heading_Elements", "h3")}} - {{htmlelement("Heading_Elements", "h4")}} - {{htmlelement("Heading_Elements", "h5")}} - {{htmlelement("Heading_Elements", "h6")}} - {{htmlelement("header")}} - {{htmlelement("main")}} - {{htmlelement("nav")}} - {{htmlelement("p")}} - {{htmlelement("section")}} - {{htmlelement("span")}} ## Syntax ```js-nolint attachShadow(options) ``` ### Parameters - `options` - : An object which contains the following fields: - `mode` - : A string specifying the _encapsulation mode_ for the shadow DOM tree. This can be one of: - `open` - : Elements of the shadow root are accessible from JavaScript outside the root, for example using {{domxref("Element.shadowRoot")}}: ```js element.attachShadow({ mode: "open" }); element.shadowRoot; // Returns a ShadowRoot obj ``` - `closed` - : Denies access to the node(s) of a closed shadow root from JavaScript outside it: ```js element.attachShadow({ mode: "closed" }); element.shadowRoot; // Returns null ``` - `clonable` {{Optional_Inline}} - : A boolean that specifies whether the shadow root is clonable: when set to `true`, the shadow host cloned with {{domxref("Node.cloneNode()")}} or {{domxref("Document.importNode()")}} will include shadow root in the copy. Its default value is `false`, unless the shadow root is created via declarative shadow DOM. - `delegatesFocus` {{Optional_Inline}} - : A boolean that, when set to `true`, specifies behavior that mitigates custom element issues around focusability. When a non-focusable part of the shadow DOM is clicked, the first focusable part is given focus, and the shadow host is given any available `:focus` styling. Its default value is `false`. - `slotAssignment` {{Optional_inline}} - : A string specifying the _slot assignment mode_ for the shadow DOM tree. This can be one of: - `named` - : Elements are automatically assigned to {{HTMLElement("slot")}} elements within this shadow root. Any descendants of the host with a `slot` attribute which matches the `name` attribute of a `<slot>` within this shadow root will be assigned to that slot. Any top-level children of the host with no `slot` attribute will be assigned to a `<slot>` with no `name` attribute (the "default slot") if one is present. - `manual` - : Elements are not automatically assigned to {{HTMLElement("slot")}} elements. Instead, they must be manually assigned with {{domxref("HTMLSlotElement.assign()")}}. Its default value is `named`. ### Return value Returns a {{domxref("ShadowRoot")}} object. ### Exceptions - `InvalidStateError` {{domxref("DOMException")}} - : The element you are trying to attach to is already a shadow host. - `NotSupportedError` {{domxref("DOMException")}} - : You are trying to attach a shadow root to an element outside the HTML namespace, the element cannot have a shadow attached to it, or the static property `disabledFeatures` has been given a value of `"shadow"` in the element definition. ## Examples ### Word count custom element The following example is taken from our [word-count-web-component](https://github.com/mdn/web-components-examples/tree/main/word-count-web-component) demo ([see it live also](https://mdn.github.io/web-components-examples/word-count-web-component/)). You can see that we use `attachShadow()` in the middle of the code to create a shadow root, which we then attach our custom element's contents to. ```js // Create a class for the element class WordCount extends HTMLParagraphElement { constructor() { // Always call super first in constructor super(); // count words in element's parent element const wcParent = this.parentNode; function countWords(node) { const text = node.innerText || node.textContent; return text .trim() .split(/\s+/g) .filter((a) => a.trim().length > 0).length; } const count = `Words: ${countWords(wcParent)}`; // Create a shadow root const shadow = this.attachShadow({ mode: "open" }); // Create text node and add word count to it const text = document.createElement("span"); text.textContent = count; // Append it to the shadow root shadow.appendChild(text); // Update count when element content changes setInterval(() => { const count = `Words: ${countWords(wcParent)}`; text.textContent = count; }, 200); } } // Define the new element customElements.define("word-count", WordCount, { extends: "p" }); ``` ### Disabling shadow DOM If the element has a static property named `disabledFeatures`, which is an array containing the string `"shadow"`, then the `attachShadow()` call will throw an exception. For example: ```js class MyCustomElement extends HTMLElement { // Disable shadow DOM for this element. static disabledFeatures = ["shadow"]; constructor() { super(); } connectedCallback() { // Create a shadow root. // This will throw an exception. const shadow = this.attachShadow({ mode: "open" }); } } // Define the new element customElements.define("my-custom-element", MyCustomElement); ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("ShadowRoot.mode")}} - {{domxref("ShadowRoot.delegatesFocus")}} - {{domxref("ShadowRoot.slotAssignment")}}
0
data/mdn-content/files/en-us/web/api/element
data/mdn-content/files/en-us/web/api/element/queryselector/index.md
--- title: "Element: querySelector() method" short-title: querySelector() slug: Web/API/Element/querySelector page-type: web-api-instance-method browser-compat: api.Element.querySelector --- {{APIRef("DOM")}} The **`querySelector()`** method of the {{domxref("Element")}} interface returns the first element that is a descendant of the element on which it is invoked that matches the specified group of selectors. ## Syntax ```js-nolint querySelector(selectors) ``` ### Parameters - `selectors` - : A group of [selectors](/en-US/docs/Learn/CSS/Building_blocks/Selectors) to match the descendant elements of the {{domxref("Element")}} `baseElement` against; this must be valid CSS syntax, or a `SyntaxError` exception will occur. The first element found which matches this group of selectors is returned. ### Return value The first descendant element of `baseElement` which matches the specified group of `selectors`. The entire hierarchy of elements is considered when matching, including those outside the set of elements including `baseElement` and its descendants; in other words, `selectors` is first applied to the whole document, not the `baseElement`, to generate an initial list of potential elements. The resulting elements are then examined to see if they are descendants of `baseElement`. The first match of those remaining elements is returned by the `querySelector()` method. If no matches are found, the returned value is `null`. ### Exceptions - `SyntaxError` {{domxref("DOMException")}} - : Thrown if the specified `selectors` are invalid. ## Examples Let's consider a few examples. ### Find a specific element with specific values of an attribute In this first example, the first {{HTMLElement("style")}} element which either has no type or has type "text/css" in the HTML document body is returned: ```js const el = document.body.querySelector( "style[type='text/css'], style:not([type])", ); ``` ### Get direct descendants using the :scope pseudo-class This example uses the {{cssxref(":scope")}} pseudo-class to retrieve direct children of the `parentElement` element. #### HTML ```html <div> <h6>Page Title</h6> <div id="parent"> <span>Love is Kind.</span> <span> <span>Love is Patient.</span> </span> <span> <span>Love is Selfless.</span> </span> </div> </div> ``` #### CSS ```css span { display: block; margin-bottom: 5px; } .red span { background-color: red; padding: 5px; } ``` #### JavaScript ```js const parentElement = document.querySelector("#parent"); let allChildren = parentElement.querySelectorAll(":scope > span"); allChildren.forEach((item) => item.classList.add("red")); ``` #### Result {{ EmbedLiveSample('Get_direct_descendants_using_the_scope_pseudo-class', 600, 160) }} ### The entire hierarchy counts This example demonstrates that the hierarchy of the entire document is considered when applying `selectors`, so that levels outside the specified `baseElement` are still considered when locating matches. #### HTML ```html <div> <h5>Original content</h5> <p> inside paragraph <span>inside span</span> inside paragraph </p> </div> <div> <h5>Output</h5> <div id="output"></div> </div> ``` #### JavaScript ```js const baseElement = document.querySelector("p"); document.getElementById("output").innerHTML = baseElement.querySelector("div span").innerHTML; ``` #### Result The result looks like this: {{ EmbedLiveSample('The_entire_hierarchy_counts', 600, 160) }} Notice how the `"div span"` selector still successfully matches the {{HTMLElement("span")}} element, even though the `baseElement`'s child nodes do not include the {{HTMLElement("div")}} element (it is still part of the specified selector). ### More examples See {{domxref("Document.querySelector()")}} for additional examples of the proper format for the `selectors`. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - [Locating DOM elements using selectors](/en-US/docs/Web/API/Document_object_model/Locating_DOM_elements_using_selectors) - [Attribute selectors](/en-US/docs/Web/CSS/Attribute_selectors) in the CSS Guide - [Attribute selectors](/en-US/docs/Learn/CSS/Building_blocks/Selectors/Attribute_selectors) in the MDN Learning Area - {{domxref("Element.querySelectorAll()")}} - {{domxref("Document.querySelector()")}} and {{domxref("Document.querySelectorAll()")}} - {{domxref("DocumentFragment.querySelector()")}} and {{domxref("DocumentFragment.querySelectorAll()")}} - Other methods that take selectors: {{domxref("element.closest()")}} and {{domxref("element.matches()")}}.
0
data/mdn-content/files/en-us/web/api/element
data/mdn-content/files/en-us/web/api/element/beforematch_event/index.md
--- title: "Element: beforematch event" short-title: beforematch slug: Web/API/Element/beforematch_event page-type: web-api-event status: - experimental browser-compat: api.Element.beforematch_event --- {{APIRef}}{{SeeCompatTable}} An element receives a **`beforematch`** event when it is in the _hidden until found_ state and the browser is about to reveal its content because the user has found the content through the "find in page" feature or through fragment navigation. ## Syntax Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property. ```js addEventListener("beforematch", (event) => {}); onbeforematch = (event) => {}; ``` ## Event type A generic {{domxref("Event")}}. ## Usage notes The HTML [`hidden`](/en-US/docs/Web/HTML/Global_attributes/hidden) attribute accepts a value `until-found`: when this value is specified, the element is hidden but its content will be accessible to the browser's "find in page" feature or to fragment navigation. When these features cause a scroll to an element in a "hidden until found" subtree, the browser will: - fire a `beforematch` event on the hidden element - remove the `hidden` attribute from the element - scroll to the element ## Examples ### Using beforematch In this example we have: - Two {{HTMLElement("div")}} elements. The first is not hidden, while the second has `hidden="until-found"`and `id="until-found-box"` attributes. - A link whose target is the `"until-found-box"` fragment. We also have some JavaScript that listens for the `beforematch` event firing on the hidden until found element. The event handler changes the text content of the box. #### HTML ```html <a href="#until-found-box">Go to hidden content</a> <div>I'm not hidden</div> <div id="until-found-box" hidden="until-found">Hidden until found</div> ``` ```html hidden <button id="reset">Reset</button> ``` #### CSS ```css div { height: 40px; width: 300px; border: 5px dashed black; margin: 1rem 0; padding: 1rem; font-size: 2rem; } ``` ```css hidden #until-found-box { scroll-margin-top: 200px; } ``` #### JavaScript ```js const untilFound = document.querySelector("#until-found-box"); untilFound.addEventListener( "beforematch", () => (untilFound.textContent = "I've been revealed!"), ); ``` ```js hidden document.querySelector("#reset").addEventListener("click", () => { document.location.hash = ""; document.location.reload(); }); ``` #### Result Clicking the "Go to hidden content" button navigates to the hidden-until-found element. The `beforematch` event fires, the text content is updated, and then the element's content is displayed. To run the example again, click "Reload". {{EmbedLiveSample("Using beforematch", "", 300)}} If your browser does not support the `"until-found"` enumerated value of the `hidden` attribute, the second `<div>` will be hidden (as `hidden` was boolean prior to the addition of the `until-found` value). ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - The HTML [`hidden`](/en-US/docs/Web/HTML/Global_attributes/hidden) attribute
0
data/mdn-content/files/en-us/web/api/element
data/mdn-content/files/en-us/web/api/element/animate/index.md
--- title: "Element: animate() method" short-title: animate() slug: Web/API/Element/animate page-type: web-api-instance-method browser-compat: api.Element.animate --- {{APIRef('Web Animations')}} The {{domxref("Element")}} interface's **`animate()`** method is a shortcut method which creates a new {{domxref("Animation")}}, applies it to the element, then plays the animation. It returns the created {{domxref("Animation")}} object instance. > **Note:** Elements can have multiple animations applied to them. You can get a list of the > animations that affect an element by calling {{domxref("Element.getAnimations()")}}. ## Syntax ```js-nolint animate(keyframes, options) ``` ### Parameters - `keyframes` - : Either an array of keyframe objects, **or** a keyframe object whose properties are arrays of values to iterate over. See [Keyframe Formats](/en-US/docs/Web/API/Web_Animations_API/Keyframe_Formats) for more details. - `options` - : Either an **integer representing the animation's duration** (in milliseconds), **or** an Object containing one or more timing properties described in the [`KeyframeEffect()` options parameter](/en-US/docs/Web/API/KeyframeEffect/KeyframeEffect#parameters) and/or the following options: - `id` {{optional_inline}} - : A property unique to `animate()`: A string with which to reference the animation. - `rangeEnd` {{optional_inline}} - : Specifies the end of an animation's attachment range along its timeline, i.e. where along the timeline an animation will end. The JavaScript equivalent of the CSS {{cssxref("animation-range-end")}} property. `rangeEnd` can take several different value types, as follows: - A string that can be `normal` (meaning no change to the animation's attachment range), a CSS {{cssxref("length-percentage")}} representing an offset, a `<timeline-range-name>`, or a `<timeline-range-name>` with a `<length-percentage>` following it. For example: ```plain "normal" "entry" "cover 100%" ``` See [`animation-range`](/en-US/docs/Web/CSS/animation-range) for a detailed description of the available values. Also check out the [View Timeline Ranges Visualizer](https://scroll-driven-animations.style/tools/view-timeline/ranges/), which shows exactly what the different values mean in an easy visual format. - An object containing `rangeName` (a string) and `offset` (a {{domxref("CSSNumericValue")}}) properties representing a `<timeline-range-name>` and `<length-percentage>`, as described in the previous bullet. For example: ```js { rangeName: 'entry', offset: CSS.percent('100'), } ``` - A {{domxref("CSSNumericValue")}} representing an offset, for example: ```js CSS.percent("100"); ``` - `rangeStart` {{optional_inline}} - : Specifies the start of an animation's attachment range along its timeline, i.e. where along the timeline an animation will start. The JavaScript equivalent of the CSS {{cssxref("animation-range-start")}} property. `rangeStart` can take the same value types as `rangeEnd`. - `timeline` {{optional_inline}} - : A property unique to `animate()`: The {{domxref("AnimationTimeline")}} to associate with the animation. Defaults to {{domxref("Document.timeline")}}. The JavaScript equivalent of the CSS {{cssxref("animation-timeline")}} property. ### Return value Returns an {{domxref("Animation")}}. ## Examples ### Rotating and scaling In this example we use the `animate()` method to rotate and scale an element. #### HTML ```html <div class="newspaper">Spinning newspaper<br />causes dizziness</div> ``` #### CSS ```css html, body { height: 100%; } body { display: flex; justify-content: center; align-items: center; background-color: black; } .newspaper { padding: 0.5rem; text-transform: uppercase; text-align: center; background-color: white; cursor: pointer; } ``` #### JavaScript ```js const newspaperSpinning = [ { transform: "rotate(0) scale(1)" }, { transform: "rotate(360deg) scale(0)" }, ]; const newspaperTiming = { duration: 2000, iterations: 1, }; const newspaper = document.querySelector(".newspaper"); newspaper.addEventListener("click", () => { newspaper.animate(newspaperSpinning, newspaperTiming); }); ``` #### Result {{EmbedLiveSample("Rotating and scaling")}} ### Down the Rabbit Hole demo In the demo [Down the Rabbit Hole (with the Web Animation API)](https://codepen.io/rachelnabors/pen/rxpmJL/?editors=0010), we use the convenient `animate()` method to immediately create and play an animation on the `#tunnel` element to make it flow upwards, infinitely. Notice the array of objects passed as keyframes and also the timing options block. ```js document.getElementById("tunnel").animate( [ // keyframes { transform: "translateY(0px)" }, { transform: "translateY(-300px)" }, ], { // timing options duration: 1000, iterations: Infinity, }, ); ``` ### Implicit to/from keyframes In newer browser versions, you are able to set a beginning or end state for an animation only (i.e. a single keyframe), and the browser will infer the other end of the animation if it is able to. For example, consider [this simple animation](https://mdn.github.io/dom-examples/web-animations-api/implicit-keyframes.html) — the Keyframe object looks like so: ```js let rotate360 = [{ transform: "rotate(360deg)" }]; ``` We have only specified the end state of the animation, and the beginning state is implied. ### timeline, rangeStart, and rangeEnd Typical usage of the `timeline`, `rangeStart`, and `rangeEnd` properties might look like this: ```js const img = document.querySelector("img"); const timeline = new ViewTimeline({ subject: img, axis: "block", }); img.animate( { opacity: [0, 1], transform: ["scaleX(0)", "scaleX(1)"], }, { fill: "both", duration: 1, timeline, rangeStart: "cover 0%", rangeEnd: "cover 100%", }, ); ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("Animation")}} - {{domxref("Element.getAnimations()")}} - {{cssxref("animation-range-end")}}, {{cssxref("animation-range-start")}}, {{cssxref("animation-timeline")}} - [CSS scroll-driven animations](/en-US/docs/Web/CSS/CSS_scroll-driven_animations) - [Web Animations API](/en-US/docs/Web/API/Web_Animations_API)
0
data/mdn-content/files/en-us/web/api/element
data/mdn-content/files/en-us/web/api/element/webkitmouseforcewillbegin_event/index.md
--- title: "Element: webkitmouseforcewillbegin event" short-title: webkitmouseforcewillbegin slug: Web/API/Element/webkitmouseforcewillbegin_event page-type: web-api-event status: - non-standard browser-compat: api.Element.webkitmouseforcewillbegin_event --- {{APIRef("Force Touch Events")}}{{Non-standard_header}} Safari for macOS fires the non-standard **`webkitmouseforcewillbegin`** event at an {{domxref("Element")}} before firing the initial {{domxref("Element/mousedown_event", "mousedown")}} event. This offers the opportunity to tell the system not to trigger any default Force Touch actions if and when the click turns into a {{domxref("Force Touch Events")}}. To instruct macOS not to engage any default Force Touch actions if the user apply enough pressure to activate a Force Touch event, call {{domxref("Event.preventDefault", "preventDefault()")}} on the `webkitmouseforcewillbegin` event object. **`webkitmouseforcewillbegin`** is a proprietary, WebKit-specific event. It is part of the {{domxref("Force Touch Events")}} feature. ## Syntax Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property. ```js addEventListener("webkitmouseforceup", (event) => {}); onwebkitmouseforceup = (event) => {}; ``` ## Event type A {{domxref("MouseEvent")}}. Inherits from {{domxref("UIEvent")}} and {{domxref("Event")}}. {{InheritanceDiagram("MouseEvent")}} ## Event properties _This interface also inherits properties of its parents, {{domxref("UIEvent")}} and {{domxref("Event")}}._ - {{domxref("MouseEvent.altKey")}} {{ReadOnlyInline}} - : Returns `true` if the <kbd>alt</kbd> key was down when the mouse event was fired. - {{domxref("MouseEvent.button")}} {{ReadOnlyInline}} - : The button number that was pressed (if applicable) when the mouse event was fired. - {{domxref("MouseEvent.buttons")}} {{ReadOnlyInline}} - : The buttons being pressed (if any) when the mouse event was fired. - {{domxref("MouseEvent.clientX")}} {{ReadOnlyInline}} - : The X coordinate of the mouse pointer in [viewport coordinates](/en-US/docs/Web/CSS/CSSOM_view/Coordinate_systems#viewport). - {{domxref("MouseEvent.clientY")}} {{ReadOnlyInline}} - : The Y coordinate of the mouse pointer in [viewport coordinates](/en-US/docs/Web/CSS/CSSOM_view/Coordinate_systems#viewport). - {{domxref("MouseEvent.ctrlKey")}} {{ReadOnlyInline}} - : Returns `true` if the <kbd>control</kbd> key was down when the mouse event was fired. - {{domxref("MouseEvent.layerX")}} {{Non-standard_inline}} {{ReadOnlyInline}} - : Returns the horizontal coordinate of the event relative to the current layer. - {{domxref("MouseEvent.layerY")}} {{Non-standard_inline}} {{ReadOnlyInline}} - : Returns the vertical coordinate of the event relative to the current layer. - {{domxref("MouseEvent.metaKey")}} {{ReadOnlyInline}} - : Returns `true` if the <kbd>meta</kbd> key was down when the mouse event was fired. - {{domxref("MouseEvent.movementX")}} {{ReadOnlyInline}} - : The X coordinate of the mouse pointer relative to the position of the last {{domxref("Element/mousemove_event", "mousemove")}} event. - {{domxref("MouseEvent.movementY")}} {{ReadOnlyInline}} - : The Y coordinate of the mouse pointer relative to the position of the last {{domxref("Element/mousemove_event", "mousemove")}} event. - {{domxref("MouseEvent.offsetX")}} {{ReadOnlyInline}} - : The X coordinate of the mouse pointer relative to the position of the padding edge of the target node. - {{domxref("MouseEvent.offsetY")}} {{ReadOnlyInline}} - : The Y coordinate of the mouse pointer relative to the position of the padding edge of the target node. - {{domxref("MouseEvent.pageX")}} {{ReadOnlyInline}} - : The X coordinate of the mouse pointer relative to the whole document. - {{domxref("MouseEvent.pageY")}} {{ReadOnlyInline}} - : The Y coordinate of the mouse pointer relative to the whole document. - {{domxref("MouseEvent.relatedTarget")}} {{ReadOnlyInline}} - : The secondary target for the event, if there is one. - {{domxref("MouseEvent.screenX")}} {{ReadOnlyInline}} - : The X coordinate of the mouse pointer in [screen coordinates](/en-US/docs/Web/CSS/CSSOM_view/Coordinate_systems#screen). - {{domxref("MouseEvent.screenY")}} {{ReadOnlyInline}} - : The Y coordinate of the mouse pointer in [screen coordinates](/en-US/docs/Web/CSS/CSSOM_view/Coordinate_systems#screen). - {{domxref("MouseEvent.shiftKey")}} {{ReadOnlyInline}} - : Returns `true` if the <kbd>shift</kbd> key was down when the mouse event was fired. - {{domxref("MouseEvent.mozInputSource")}} {{non-standard_inline()}} {{ReadOnlyInline}} - : The type of device that generated the event (one of the `MOZ_SOURCE_*` constants). This lets you, for example, determine whether a mouse event was generated by an actual mouse or by a touch event (which might affect the degree of accuracy with which you interpret the coordinates associated with the event). - {{domxref("MouseEvent.webkitForce")}} {{non-standard_inline()}} {{ReadOnlyInline}} - : The amount of pressure applied when clicking. - {{domxref("MouseEvent.x")}} {{ReadOnlyInline}} - : Alias for {{domxref("MouseEvent.clientX")}}. - {{domxref("MouseEvent.y")}} {{ReadOnlyInline}} - : Alias for {{domxref("MouseEvent.clientY")}}. ## Specifications _Not part of any specification._ Apple has [a description at the Mac Developer Library](https://developer.apple.com/library/archive/documentation/AppleApplications/Conceptual/SafariJSProgTopics/RespondingtoForceTouchEventsfromJavaScript.html). ## Browser compatibility {{Compat}} ## See also - [Introduction to events](/en-US/docs/Learn/JavaScript/Building_blocks/Events) - {{domxref("Element/webkitmouseforcedown_event", "webkitmouseforcedown")}} - {{domxref("Element/webkitmouseforceup_event", "webkitmouseforceup")}} - {{domxref("Element/webkitmouseforcechanged_event", "webkitmouseforcechanged")}}
0
data/mdn-content/files/en-us/web/api/element
data/mdn-content/files/en-us/web/api/element/ariarowspan/index.md
--- title: "Element: ariaRowSpan property" short-title: ariaRowSpan slug: Web/API/Element/ariaRowSpan page-type: web-api-instance-property browser-compat: api.Element.ariaRowSpan --- {{DefaultAPISidebar("DOM")}} The **`ariaRowSpan`** property of the {{domxref("Element")}} interface reflects the value of the [`aria-rowspan`](/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-rowspan) attribute, which defines the number of rows spanned by a cell or gridcell within a table, grid, or treegrid. ## Value A string which contains an integer. ## Examples In this example the `aria-rowspan` attribute on the element with an ID of `spanning-heading` is set to "3". Using `ariaRowSpan` we update the value to "2". ```html <table> <tr> <th id="spanning-heading" rowspan="3" aria-rowspan="3">Spanning heading</th> <th>Heading</th> </tr> <tr> <td>One</td> </tr> <tr> <td>Two</td> </tr> </table> ``` ```js let el = document.getElementById("spanning-heading"); console.log(el.ariaRowSpan); el.ariaRowSpan = "2"; console.log(el.ariaRowSpan); ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - [ARIA: table role](/en-US/docs/Web/Accessibility/ARIA/Roles/table_role)
0
data/mdn-content/files/en-us/web/api/element
data/mdn-content/files/en-us/web/api/element/getattributenodens/index.md
--- title: "Element: getAttributeNodeNS() method" short-title: getAttributeNodeNS() slug: Web/API/Element/getAttributeNodeNS page-type: web-api-instance-method browser-compat: api.Element.getAttributeNodeNS --- {{ APIRef("DOM") }} The **`getAttributeNodeNS()`** method of the {{domxref("Element")}} interface returns the namespaced {{domxref("Attr")}} node of an element. This method is useful if you need the namespaced attribute's [instance properties](/en-US/docs/Web/API/Attr#instance_properties). If you only need the namespaced attribute's value, you can use the {{domxref("Element.getAttributeNS()", "getAttributeNS()")}} method instead. If you need the {{domxref("Attr")}} node of an element in HTML documents and the attribute is not namespaced, use the {{domxref("Element.getAttributeNode()", "getAttributeNode()")}} method instead. ## Syntax ```js-nolint getAttributeNodeNS(namespace, nodeName) ``` ### Parameters - `namespace` is a string specifying the namespace of the attribute. - `nodeName` is a string specifying the name of the attribute. ### Return value The node for specified attribute. ## Notes `getAttributeNodeNS` is more specific than [getAttributeNode](getAttributeNode) in that it allows you to specify attributes that are part of a particular namespace. The corresponding setter method is [setAttributeNodeNS](/en-US/docs/Web/API/Element/setAttributeNodeNS). ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("Document.createAttribute()")}} - {{domxref("Document.createAttributeNS()")}} - {{domxref("Element.setAttributeNodeNS()")}}
0
data/mdn-content/files/en-us/web/api/element
data/mdn-content/files/en-us/web/api/element/ariaautocomplete/index.md
--- title: "Element: ariaAutoComplete property" short-title: ariaAutoComplete slug: Web/API/Element/ariaAutoComplete page-type: web-api-instance-property browser-compat: api.Element.ariaAutoComplete --- {{DefaultAPISidebar("DOM")}} The **`ariaAutoComplete`** property of the {{domxref("Element")}} interface reflects the value of the [`aria-autocomplete`](/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-autocomplete) attribute, which indicates whether inputting text could trigger display of one or more predictions of the user's intended value for a combobox, searchbox, or textbox and specifies how predictions would be presented if they were made. ## Value A string with one of the following values: - `"inline"` - : When a user is providing input, text suggesting one way to complete the provided input may be dynamically inserted after the caret. - `"list"` - : When a user is providing input, an element containing a collection of values that could complete the provided input may be displayed. - `"both"` - : When a user is providing input, an element containing a collection of values that could complete the provided input may be displayed. If displayed, one value in the collection is automatically selected, and the text needed to complete the automatically selected value appears after the caret in the input. - `"none"` - : When a user is providing input, there is no display of an automatic suggestion that attempts to predict how the user intends to complete the input. ## Examples In this example, the `aria-autocomplete` attribute on the element with an ID of `animal` is set to "`inline`". Using `ariaAutoComplete` we update the value to "`list`", which is the expected value for a combobox that invokes a `listbox` popup. ```html <div class="animals-combobox"> <label for="animal">Animal</label> <input id="animal" type="text" role="combobox" aria-autocomplete="inline" aria-controls="animals-listbox" aria-expanded="false" aria-haspopup="listbox" /> <ul id="animals-listbox" role="listbox" aria-label="Animals"> <li id="animal-cat" role="option">Cat</li> <li id="animal-dog" role="option">Dog</li> </ul> </div> ``` ```js let el = document.getElementById("animal"); console.log(el.ariaAutoComplete); // inline el.ariaAutoComplete = "list"; console.log(el.ariaAutoComplete); // list ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/element
data/mdn-content/files/en-us/web/api/element/scroll_event/index.md
--- title: "Element: scroll event" short-title: scroll slug: Web/API/Element/scroll_event page-type: web-api-event browser-compat: api.Element.scroll_event --- {{APIRef}} The **`scroll`** event fires when an element has been scrolled. To detect when scrolling has completed, see the {{domxref("Element/scrollend_event", "Element: scrollend event")}}. ## Syntax Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property. ```js addEventListener("scroll", (event) => {}); onscroll = (event) => {}; ``` ## Event type A generic {{domxref("Event")}}. ## Examples The following examples show how to use the `scroll` event with an event listener and with the `onscroll` event handler property. The {{DOMxRef("setTimeout()")}} method is used to throttle the event handler because `scroll` events can fire at a high rate. For additional examples that use {{DOMxRef("Window.requestAnimationFrame()", "requestAnimationFrame()")}}, see the {{domxref("Document/scroll_event", "Document: scroll event")}} page. ### Using `scroll` with an event listener The following example shows how to use the `scroll` event to detect when the user is scrolling inside an element: ```html <div id="scroll-box" style="overflow: scroll; height: 100px; width: 100px; float: left;"> <p style="height: 200px; width: 200px;">Scroll me!</p> </div> <p style="text-align: center;" id="output">Waiting on scroll events...</p> ``` ```js const element = document.querySelector("div#scroll-box"); const output = document.querySelector("p#output"); element.addEventListener("scroll", (event) => { output.innerHTML = "Scroll event fired!"; setTimeout(() => { output.innerHTML = "Waiting on scroll events..."; }, 1000); }); ``` {{EmbedLiveSample("Using_scroll_with_an_event_listener", "100%", 120)}} ### Using `onscroll` event handler property The following example shows how to use the `onscroll` event handler property to detect when the user is scrolling: ```html <div id="scroll-box" style="overflow: scroll; height: 100px; width: 100px; float: left;"> <p style="height: 200px; width: 200px;">Scroll me!</p> </div> <p id="output" style="text-align: center;">Waiting on scroll events...</p> ``` ```js const element = document.querySelector("div#scroll-box"); const output = document.querySelector("p#output"); element.onscroll = (event) => { output.innerHTML = "Element scroll event fired!"; setTimeout(() => { output.innerHTML = "Waiting on scroll events..."; }, 1000); }; ``` {{EmbedLiveSample("Using_onscroll_event_handler_property", "100%", 120)}} ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - [Element `scrollend` event](/en-US/docs/Web/API/Element/scrollend_event) - [Document `scroll` event](/en-US/docs/Web/API/Document/scroll_event) - [Document `scrollend` event](/en-US/docs/Web/API/Document/scrollend_event)
0
data/mdn-content/files/en-us/web/api/element
data/mdn-content/files/en-us/web/api/element/ariahidden/index.md
--- title: "Element: ariaHidden property" short-title: ariaHidden slug: Web/API/Element/ariaHidden page-type: web-api-instance-property browser-compat: api.Element.ariaHidden --- {{DefaultAPISidebar("DOM")}} The **`ariaHidden`** property of the {{domxref("Element")}} interface reflects the value of the [`aria-hidden`](/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-hidden)) attribute, which indicates whether the element is exposed to an accessibility API. ## Value A string with one of the following values: - `"true"` - : The element is hidden from the accessibility API. - `"false"` - : The element is exposed to the accessibility API as if it were rendered. - `undefined` - : The element's hidden state is determined by the user agent based on whether it is rendered. ## Examples In this example the [`aria-hidden`](/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-hidden) attribute on the element with an ID of `hidden` is set to "true". Using `ariaHidden` we update the value to "false". ```html <div id="hidden" aria-hidden="true">Some things are better left unsaid.</div> ``` ```js let el = document.getElementById("hidden"); console.log(el.ariaHidden); // true el.ariaHidden = "false"; console.log(el.ariaHidden); // false ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/element
data/mdn-content/files/en-us/web/api/element/beforescriptexecute_event/index.md
--- title: "Element: beforescriptexecute event" short-title: beforescriptexecute slug: Web/API/Element/beforescriptexecute_event page-type: web-api-event status: - non-standard browser-compat: api.Element.beforescriptexecute_event --- {{APIRef}}{{Non-standard_header}} > **Warning:** This event was a proposal in an early version of the specification. Do not rely on it. The **`beforescriptexecute`** event is fired when a script is about to be executed. Cancelling the event prevents the script from executing. It is a proprietary event specific to Gecko (Firefox). ## Syntax Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property. ```js addEventListener("NameOfTheEvent", (event) => {}); onNameOfTheEvent = (event) => {}; ``` ## Event type A generic {{domxref("Event")}}. ## Specifications Not part of any specification. ## Browser compatibility {{Compat}} ## See also - [`afterscriptexecute`](/en-US/docs/Web/API/Element/afterscriptexecute_event) event
0
data/mdn-content/files/en-us/web/api/element
data/mdn-content/files/en-us/web/api/element/ariapressed/index.md
--- title: "Element: ariaPressed property" short-title: ariaPressed slug: Web/API/Element/ariaPressed page-type: web-api-instance-property browser-compat: api.Element.ariaPressed --- {{DefaultAPISidebar("DOM")}} The **`ariaPressed`** property of the {{domxref("Element")}} interface reflects the value of the [`aria-pressed`](/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-pressed) attribute, which indicates the current "pressed" state of toggle buttons. > **Note:** Where possible use an HTML {{htmlelement("input")}} element with `type="button"` or the {{htmlelement("button")}} element as these have built in semantics and do not require ARIA attributes. ## Value A string with one of the following values: - `"true"` - : The element is pressed. - `"false"` - : The element supports being pressed but is not currently pressed. - `"mixed"` - : Indicates a mixed mode value for a tri-state toggle button. - `"undefined"` - : The element does not support being pressed. ## Examples In this example the `aria-pressed` attribute on the element with an ID of `saveChanges` is set to "false" indicating that this input is currently not pressed. Using `ariaPressed` we update the value to "true". ```html <div id="saveChanges" tabindex="0" role="button" aria-pressed="false">Save</div> ``` ```js let el = document.getElementById("saveChanges"); console.log(el.ariaPressed); // "false" el.ariaPressed = "true"; console.log(el.ariaPressed); // "true" ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - [ARIA: button role](/en-US/docs/Web/Accessibility/ARIA/Roles/button_role)
0
data/mdn-content/files/en-us/web/api/element
data/mdn-content/files/en-us/web/api/element/outerhtml/index.md
--- title: "Element: outerHTML property" short-title: outerHTML slug: Web/API/Element/outerHTML page-type: web-api-instance-property browser-compat: api.Element.outerHTML --- {{APIRef("DOM")}} The **`outerHTML`** attribute of the {{ domxref("Element") }} DOM interface gets the serialized HTML fragment describing the element including its descendants. It can also be set to replace the element with nodes parsed from the given string. To only obtain the HTML representation of the contents of an element, or to replace the contents of an element, use the {{domxref("Element.innerHTML", "innerHTML")}} property instead. ## Value Reading the value of `outerHTML` returns a string containing an HTML serialization of the `element` and its descendants. Setting the value of `outerHTML` replaces the element and all of its descendants with a new DOM tree constructed by parsing the specified `htmlString`. ### Exceptions - `SyntaxError` {{domxref("DOMException")}} - : Thrown if an attempt was made to set `outerHTML` using an HTML string which is not valid. - `NoModificationAllowedError` {{domxref("DOMException")}} - : Thrown if an attempt was made to set `outerHTML` on an element which is a direct child of a {{domxref("Document")}}, such as {{domxref("Document.documentElement")}}. ## Examples ### Getting the value of an element's outerHTML property #### HTML ```html <div id="d"> <p>Content</p> <p>Further Elaborated</p> </div> ``` #### JavaScript ```js const d = document.getElementById("d"); console.log(d.outerHTML); // The string '<div id="d"><p>Content</p><p>Further Elaborated</p></div>' // is written to the console window ``` ### Replacing a node by setting the outerHTML property #### HTML ```html <div id="container"> <div id="d">This is a div.</div> </div> ``` #### JavaScript ```js const container = document.getElementById("container"); const d = document.getElementById("d"); console.log(container.firstElementChild.nodeName); // logs "DIV" d.outerHTML = "<p>This paragraph replaced the original div.</p>"; console.log(container.firstElementChild.nodeName); // logs "P" // The #d div is no longer part of the document tree, // the new paragraph replaced it. ``` ## Notes If the element has no parent node, setting its `outerHTML` property will not change it or its descendants. For example: ```js const div = document.createElement("div"); div.outerHTML = '<div class="test">test</div>'; console.log(div.outerHTML); // output: "<div></div>" ``` Also, while the element will be replaced in the document, the variable whose `outerHTML` property was set will still hold a reference to the original element: ```js const p = document.querySelector("p"); console.log(p.nodeName); // shows: "P" p.outerHTML = "<div>This div replaced a paragraph.</div>"; console.log(p.nodeName); // still "P"; ``` The returned value will contain HTML escaped attributes: ```js const anc = document.createElement("a"); anc.href = "https://developer.mozilla.org?a=b&c=d"; console.log(anc.outerHTML); // output: "<a href='https://developer.mozilla.org?a=b&amp;c=d'></a>" ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - Serializing DOM trees into XML strings: {{domxref("XMLSerializer")}} - Parsing XML or HTML into DOM trees: {{domxref("DOMParser")}} - {{domxref("HTMLElement.outerText")}}
0
data/mdn-content/files/en-us/web/api/element
data/mdn-content/files/en-us/web/api/element/webkitmouseforceup_event/index.md
--- title: "Element: webkitmouseforceup event" short-title: webkitmouseforceup slug: Web/API/Element/webkitmouseforceup_event page-type: web-api-event status: - non-standard browser-compat: api.Element.webkitmouseforceup_event --- {{APIRef("Force Touch Events")}}{{Non-standard_header}} The non-standard **`webkitmouseforceup`** event is fired by Safari at an {{domxref("Element")}} some time after the {{domxref("Element/webkitmouseforcedown_event", "webkitmouseforcedown")}} event, when pressure on the button has been reduced sufficiently to end the "force click". **`webkitmouseforceup`** is a proprietary, WebKit-specific event. It is part of the {{domxref("Force Touch Events")}} feature. ## Syntax Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property. ```js addEventListener("webkitmouseforceup", (event) => {}); onwebkitmouseforceup = (event) => {}; ``` ## Event type A {{domxref("MouseEvent")}}. Inherits from {{domxref("UIEvent")}} and {{domxref("Event")}}. {{InheritanceDiagram("MouseEvent")}} ## Event properties _This interface also inherits properties of its parents, {{domxref("UIEvent")}} and {{domxref("Event")}}._ - {{domxref("MouseEvent.altKey")}} {{ReadOnlyInline}} - : Returns `true` if the <kbd>alt</kbd> key was down when the mouse event was fired. - {{domxref("MouseEvent.button")}} {{ReadOnlyInline}} - : The button number that was pressed (if applicable) when the mouse event was fired. - {{domxref("MouseEvent.buttons")}} {{ReadOnlyInline}} - : The buttons being pressed (if any) when the mouse event was fired. - {{domxref("MouseEvent.clientX")}} {{ReadOnlyInline}} - : The X coordinate of the mouse pointer in [viewport coordinates](/en-US/docs/Web/CSS/CSSOM_view/Coordinate_systems#viewport). - {{domxref("MouseEvent.clientY")}} {{ReadOnlyInline}} - : The Y coordinate of the mouse pointer in [viewport coordinates](/en-US/docs/Web/CSS/CSSOM_view/Coordinate_systems#viewport). - {{domxref("MouseEvent.ctrlKey")}} {{ReadOnlyInline}} - : Returns `true` if the <kbd>control</kbd> key was down when the mouse event was fired. - {{domxref("MouseEvent.layerX")}} {{Non-standard_inline}} {{ReadOnlyInline}} - : Returns the horizontal coordinate of the event relative to the current layer. - {{domxref("MouseEvent.layerY")}} {{Non-standard_inline}} {{ReadOnlyInline}} - : Returns the vertical coordinate of the event relative to the current layer. - {{domxref("MouseEvent.metaKey")}} {{ReadOnlyInline}} - : Returns `true` if the <kbd>meta</kbd> key was down when the mouse event was fired. - {{domxref("MouseEvent.movementX")}} {{ReadOnlyInline}} - : The X coordinate of the mouse pointer relative to the position of the last {{domxref("Element/mousemove_event", "mousemove")}} event. - {{domxref("MouseEvent.movementY")}} {{ReadOnlyInline}} - : The Y coordinate of the mouse pointer relative to the position of the last {{domxref("Element/mousemove_event", "mousemove")}} event. - {{domxref("MouseEvent.offsetX")}} {{ReadOnlyInline}} - : The X coordinate of the mouse pointer relative to the position of the padding edge of the target node. - {{domxref("MouseEvent.offsetY")}} {{ReadOnlyInline}} - : The Y coordinate of the mouse pointer relative to the position of the padding edge of the target node. - {{domxref("MouseEvent.pageX")}} {{ReadOnlyInline}} - : The X coordinate of the mouse pointer relative to the whole document. - {{domxref("MouseEvent.pageY")}} {{ReadOnlyInline}} - : The Y coordinate of the mouse pointer relative to the whole document. - {{domxref("MouseEvent.relatedTarget")}} {{ReadOnlyInline}} - : The secondary target for the event, if there is one. - {{domxref("MouseEvent.screenX")}} {{ReadOnlyInline}} - : The X coordinate of the mouse pointer in [screen coordinates](/en-US/docs/Web/CSS/CSSOM_view/Coordinate_systems#screen). - {{domxref("MouseEvent.screenY")}} {{ReadOnlyInline}} - : The Y coordinate of the mouse pointer in [screen coordinates](/en-US/docs/Web/CSS/CSSOM_view/Coordinate_systems#screen). - {{domxref("MouseEvent.shiftKey")}} {{ReadOnlyInline}} - : Returns `true` if the <kbd>shift</kbd> key was down when the mouse event was fired. - {{domxref("MouseEvent.mozInputSource")}} {{non-standard_inline()}} {{ReadOnlyInline}} - : The type of device that generated the event (one of the `MOZ_SOURCE_*` constants). This lets you, for example, determine whether a mouse event was generated by an actual mouse or by a touch event (which might affect the degree of accuracy with which you interpret the coordinates associated with the event). - {{domxref("MouseEvent.webkitForce")}} {{non-standard_inline()}} {{ReadOnlyInline}} - : The amount of pressure applied when clicking. - {{domxref("MouseEvent.x")}} {{ReadOnlyInline}} - : Alias for {{domxref("MouseEvent.clientX")}}. - {{domxref("MouseEvent.y")}} {{ReadOnlyInline}} - : Alias for {{domxref("MouseEvent.clientY")}}. ## Specifications _Not part of any specification._ Apple has [a description at the Mac Developer Library](https://developer.apple.com/library/archive/documentation/AppleApplications/Conceptual/SafariJSProgTopics/RespondingtoForceTouchEventsfromJavaScript.html). ## Browser compatibility {{Compat}} ## See also - [Introduction to events](/en-US/docs/Learn/JavaScript/Building_blocks/Events) - {{domxref("Element/webkitmouseforcewillbegin_event", "webkitmouseforcewillbegin")}} - {{domxref("Element/webkitmouseforcedown_event", "webkitmouseforcedown")}} - {{domxref("Element/webkitmouseforcechanged_event", "webkitmouseforcechanged")}}
0
data/mdn-content/files/en-us/web/api/element
data/mdn-content/files/en-us/web/api/element/mouseenter_event/index.md
--- title: "Element: mouseenter event" short-title: mouseenter slug: Web/API/Element/mouseenter_event page-type: web-api-event browser-compat: api.Element.mouseenter_event --- {{APIRef}} The **`mouseenter`** event is fired at an {{domxref("Element")}} when a pointing device (usually a mouse) is initially moved so that its hotspot is within the element at which the event was fired. ## Syntax Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property. ```js addEventListener("mouseenter", (event) => {}); onmouseenter = (event) => {}; ``` ## Event type A {{domxref("MouseEvent")}}. Inherits from {{domxref("UIEvent")}} and {{domxref("Event")}}. {{InheritanceDiagram("MouseEvent")}} ## Event properties _This interface also inherits properties of its parents, {{domxref("UIEvent")}} and {{domxref("Event")}}._ - {{domxref("MouseEvent.altKey")}} {{ReadOnlyInline}} - : Returns `true` if the <kbd>alt</kbd> key was down when the mouse event was fired. - {{domxref("MouseEvent.button")}} {{ReadOnlyInline}} - : The button number that was pressed (if applicable) when the mouse event was fired. - {{domxref("MouseEvent.buttons")}} {{ReadOnlyInline}} - : The buttons being pressed (if any) when the mouse event was fired. - {{domxref("MouseEvent.clientX")}} {{ReadOnlyInline}} - : The X coordinate of the mouse pointer in [viewport coordinates](/en-US/docs/Web/CSS/CSSOM_view/Coordinate_systems#viewport). - {{domxref("MouseEvent.clientY")}} {{ReadOnlyInline}} - : The Y coordinate of the mouse pointer in [viewport coordinates](/en-US/docs/Web/CSS/CSSOM_view/Coordinate_systems#viewport). - {{domxref("MouseEvent.ctrlKey")}} {{ReadOnlyInline}} - : Returns `true` if the <kbd>control</kbd> key was down when the mouse event was fired. - {{domxref("MouseEvent.layerX")}} {{Non-standard_inline}} {{ReadOnlyInline}} - : Returns the horizontal coordinate of the event relative to the current layer. - {{domxref("MouseEvent.layerY")}} {{Non-standard_inline}} {{ReadOnlyInline}} - : Returns the vertical coordinate of the event relative to the current layer. - {{domxref("MouseEvent.metaKey")}} {{ReadOnlyInline}} - : Returns `true` if the <kbd>meta</kbd> key was down when the mouse event was fired. - {{domxref("MouseEvent.movementX")}} {{ReadOnlyInline}} - : The X coordinate of the mouse pointer relative to the position of the last {{domxref("Element/mousemove_event", "mousemove")}} event. - {{domxref("MouseEvent.movementY")}} {{ReadOnlyInline}} - : The Y coordinate of the mouse pointer relative to the position of the last {{domxref("Element/mousemove_event", "mousemove")}} event. - {{domxref("MouseEvent.offsetX")}} {{ReadOnlyInline}} - : The X coordinate of the mouse pointer relative to the position of the padding edge of the target node. - {{domxref("MouseEvent.offsetY")}} {{ReadOnlyInline}} - : The Y coordinate of the mouse pointer relative to the position of the padding edge of the target node. - {{domxref("MouseEvent.pageX")}} {{ReadOnlyInline}} - : The X coordinate of the mouse pointer relative to the whole document. - {{domxref("MouseEvent.pageY")}} {{ReadOnlyInline}} - : The Y coordinate of the mouse pointer relative to the whole document. - {{domxref("MouseEvent.relatedTarget")}} {{ReadOnlyInline}} - : The secondary target for the event, if there is one. - {{domxref("MouseEvent.screenX")}} {{ReadOnlyInline}} - : The X coordinate of the mouse pointer in [screen coordinates](/en-US/docs/Web/CSS/CSSOM_view/Coordinate_systems#screen). - {{domxref("MouseEvent.screenY")}} {{ReadOnlyInline}} - : The Y coordinate of the mouse pointer in [screen coordinates](/en-US/docs/Web/CSS/CSSOM_view/Coordinate_systems#screen). - {{domxref("MouseEvent.shiftKey")}} {{ReadOnlyInline}} - : Returns `true` if the <kbd>shift</kbd> key was down when the mouse event was fired. - {{domxref("MouseEvent.mozInputSource")}} {{non-standard_inline()}} {{ReadOnlyInline}} - : The type of device that generated the event (one of the `MOZ_SOURCE_*` constants). This lets you, for example, determine whether a mouse event was generated by an actual mouse or by a touch event (which might affect the degree of accuracy with which you interpret the coordinates associated with the event). - {{domxref("MouseEvent.webkitForce")}} {{non-standard_inline()}} {{ReadOnlyInline}} - : The amount of pressure applied when clicking. - {{domxref("MouseEvent.x")}} {{ReadOnlyInline}} - : Alias for {{domxref("MouseEvent.clientX")}}. - {{domxref("MouseEvent.y")}} {{ReadOnlyInline}} - : Alias for {{domxref("MouseEvent.clientY")}}. ## Usage notes Though similar to {{domxref("Element/mouseover_event", "mouseover")}}, `mouseenter` differs in that it doesn't [bubble](/en-US/docs/Web/API/Event/bubbles) and it isn't sent to any descendants when the pointer is moved from one of its descendants' physical space to its own physical space. ### Behavior of `mouseenter` events ![Mouseenter behavior diagram](mouseenter.png) One `mouseenter` event is sent to each element of the hierarchy when entering them. Here 4 events are sent to the four elements of the hierarchy when the pointer reaches the text. ### Behavior of `mouseover` events ![Mouseover behavior diagram](mouseover.png) A single `mouseover` event is sent to the deepest element of the DOM tree, then it bubbles up the hierarchy until it is canceled by a handler or reaches the root. With deep hierarchies, the number of `mouseover` events sent can be quite huge and cause significant performance problems. In such cases, it is better to listen for `mouseenter` events. Combined with the corresponding `mouseleave` (which is fired at the element when the mouse exits its content area), the `mouseenter` event acts in a very similar way to the CSS {{cssxref(':hover')}} pseudo-class. ## Examples The [`mouseover`](/en-US/docs/Web/API/Element/mouseover_event#examples) documentation has an example illustrating the difference between `mouseover` and `mouseenter`. ### mouseenter The following trivial example uses the `mouseenter` event to change the border on the `div` when the mouse enters the space allotted to it. It then adds an item to the list with the number of the `mouseenter` or `mouseleave` event. #### HTML ```html <div id="mouseTarget"> <ul id="unorderedList"> <li>No events yet!</li> </ul> </div> ``` #### CSS Styling the `div` to make it more visible. ```css #mouseTarget { box-sizing: border-box; width: 15rem; border: 1px solid #333; } ``` #### JavaScript ```js let enterEventCount = 0; let leaveEventCount = 0; const mouseTarget = document.getElementById("mouseTarget"); const unorderedList = document.getElementById("unorderedList"); mouseTarget.addEventListener("mouseenter", (e) => { mouseTarget.style.border = "5px dotted orange"; enterEventCount++; addListItem(`This is mouseenter event ${enterEventCount}.`); }); mouseTarget.addEventListener("mouseleave", (e) => { mouseTarget.style.border = "1px solid #333"; leaveEventCount++; addListItem(`This is mouseleave event ${leaveEventCount}.`); }); function addListItem(text) { // Create a new text node using the supplied text const newTextNode = document.createTextNode(text); // Create a new li element const newListItem = document.createElement("li"); // Add the text node to the li element newListItem.appendChild(newTextNode); // Add the newly created list item to list unorderedList.appendChild(newListItem); } ``` ### Result {{EmbedLiveSample('mouseenter')}} ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - [Introduction to events](/en-US/docs/Learn/JavaScript/Building_blocks/Events) - {{domxref("Element/mousedown_event", "mousedown")}} - {{domxref("Element/mouseup_event", "mouseup")}} - {{domxref("Element/mousemove_event", "mousemove")}} - {{domxref("Element/click_event", "click")}} - {{domxref("Element/dblclick_event", "dblclick")}} - {{domxref("Element/mouseover_event", "mouseover")}} - {{domxref("Element/mouseout_event", "mouseout")}} - {{domxref("Element/mouseenter_event", "mouseenter")}} - {{domxref("Element/mouseleave_event", "mouseleave")}} - {{domxref("Element/contextmenu_event", "contextmenu")}}
0
data/mdn-content/files/en-us/web/api/element
data/mdn-content/files/en-us/web/api/element/webkitmouseforcedown_event/index.md
--- title: "Element: webkitmouseforcedown event" short-title: webkitmouseforcedown slug: Web/API/Element/webkitmouseforcedown_event page-type: web-api-event status: - non-standard browser-compat: api.Element.webkitmouseforcedown_event --- {{APIRef("Force Touch Events")}}{{Non-standard_header}} After a {{domxref("Element.mousedown_event", "mousedown")}} event has been fired at the element, if and when sufficient pressure has been applied to the mouse or trackpad button to qualify as a "force click," Safari begins sending **`webkitmouseforcedown`** events to the element. **`webkitmouseforcedown`** is a proprietary, WebKit-specific event. It is part of the {{domxref("Force Touch Events")}} feature. ## Syntax Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property. ```js addEventListener("webkitmouseforcedown", (event) => {}); onwebkitmouseforcedown = (event) => {}; ``` ## Event type A {{domxref("MouseEvent")}}. Inherits from {{domxref("UIEvent")}} and {{domxref("Event")}}. {{InheritanceDiagram("MouseEvent")}} ## Event properties _This interface also inherits properties of its parents, {{domxref("UIEvent")}} and {{domxref("Event")}}._ - {{domxref("MouseEvent.altKey")}} {{ReadOnlyInline}} - : Returns `true` if the <kbd>alt</kbd> key was down when the mouse event was fired. - {{domxref("MouseEvent.button")}} {{ReadOnlyInline}} - : The button number that was pressed (if applicable) when the mouse event was fired. - {{domxref("MouseEvent.buttons")}} {{ReadOnlyInline}} - : The buttons being pressed (if any) when the mouse event was fired. - {{domxref("MouseEvent.clientX")}} {{ReadOnlyInline}} - : The X coordinate of the mouse pointer in [viewport coordinates](/en-US/docs/Web/CSS/CSSOM_view/Coordinate_systems#viewport). - {{domxref("MouseEvent.clientY")}} {{ReadOnlyInline}} - : The Y coordinate of the mouse pointer in [viewport coordinates](/en-US/docs/Web/CSS/CSSOM_view/Coordinate_systems#viewport). - {{domxref("MouseEvent.ctrlKey")}} {{ReadOnlyInline}} - : Returns `true` if the <kbd>control</kbd> key was down when the mouse event was fired. - {{domxref("MouseEvent.layerX")}} {{Non-standard_inline}} {{ReadOnlyInline}} - : Returns the horizontal coordinate of the event relative to the current layer. - {{domxref("MouseEvent.layerY")}} {{Non-standard_inline}} {{ReadOnlyInline}} - : Returns the vertical coordinate of the event relative to the current layer. - {{domxref("MouseEvent.metaKey")}} {{ReadOnlyInline}} - : Returns `true` if the <kbd>meta</kbd> key was down when the mouse event was fired. - {{domxref("MouseEvent.movementX")}} {{ReadOnlyInline}} - : The X coordinate of the mouse pointer relative to the position of the last {{domxref("Element/mousemove_event", "mousemove")}} event. - {{domxref("MouseEvent.movementY")}} {{ReadOnlyInline}} - : The Y coordinate of the mouse pointer relative to the position of the last {{domxref("Element/mousemove_event", "mousemove")}} event. - {{domxref("MouseEvent.offsetX")}} {{ReadOnlyInline}} - : The X coordinate of the mouse pointer relative to the position of the padding edge of the target node. - {{domxref("MouseEvent.offsetY")}} {{ReadOnlyInline}} - : The Y coordinate of the mouse pointer relative to the position of the padding edge of the target node. - {{domxref("MouseEvent.pageX")}} {{ReadOnlyInline}} - : The X coordinate of the mouse pointer relative to the whole document. - {{domxref("MouseEvent.pageY")}} {{ReadOnlyInline}} - : The Y coordinate of the mouse pointer relative to the whole document. - {{domxref("MouseEvent.relatedTarget")}} {{ReadOnlyInline}} - : The secondary target for the event, if there is one. - {{domxref("MouseEvent.screenX")}} {{ReadOnlyInline}} - : The X coordinate of the mouse pointer in [screen coordinates](/en-US/docs/Web/CSS/CSSOM_view/Coordinate_systems#screen). - {{domxref("MouseEvent.screenY")}} {{ReadOnlyInline}} - : The Y coordinate of the mouse pointer in [screen coordinates](/en-US/docs/Web/CSS/CSSOM_view/Coordinate_systems#screen). - {{domxref("MouseEvent.shiftKey")}} {{ReadOnlyInline}} - : Returns `true` if the <kbd>shift</kbd> key was down when the mouse event was fired. - {{domxref("MouseEvent.mozInputSource")}} {{non-standard_inline()}} {{ReadOnlyInline}} - : The type of device that generated the event (one of the `MOZ_SOURCE_*` constants). This lets you, for example, determine whether a mouse event was generated by an actual mouse or by a touch event (which might affect the degree of accuracy with which you interpret the coordinates associated with the event). - {{domxref("MouseEvent.webkitForce")}} {{non-standard_inline()}} {{ReadOnlyInline}} - : The amount of pressure applied when clicking. - {{domxref("MouseEvent.x")}} {{ReadOnlyInline}} - : Alias for {{domxref("MouseEvent.clientX")}}. - {{domxref("MouseEvent.y")}} {{ReadOnlyInline}} - : Alias for {{domxref("MouseEvent.clientY")}}. ## Specifications _Not part of any specification._ Apple has [a description at the Mac Developer Library](https://developer.apple.com/library/archive/documentation/AppleApplications/Conceptual/SafariJSProgTopics/RespondingtoForceTouchEventsfromJavaScript.html). ## Browser compatibility {{Compat}} ## See also - [Introduction to events](/en-US/docs/Learn/JavaScript/Building_blocks/Events) - {{domxref("Element/webkitmouseforcewillbegin_event", "webkitmouseforcewillbegin")}} - {{domxref("Element/webkitmouseforceup_event", "webkitmouseforceup")}} - {{domxref("Element/webkitmouseforcechanged_event", "webkitmouseforcechanged")}}
0
data/mdn-content/files/en-us/web/api/element
data/mdn-content/files/en-us/web/api/element/transitioncancel_event/index.md
--- title: "Element: transitioncancel event" short-title: transitioncancel slug: Web/API/Element/transitioncancel_event page-type: web-api-event browser-compat: api.Element.transitioncancel_event --- {{APIRef}} The **`transitioncancel`** event is fired when a [CSS transition](/en-US/docs/Web/CSS/CSS_transitions/Using_CSS_transitions) is canceled. ## Syntax Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property. ```js addEventListener("transitioncancel", (event) => {}); ontransitioncancel = (event) => {}; ``` ## Event type A {{domxref("TransitionEvent")}}. Inherits from {{domxref("Event")}}. {{InheritanceDiagram("TransitionEvent")}} ## Event properties _Also inherits properties from its parent {{domxref("Event")}}_. - {{domxref("TransitionEvent.propertyName")}} {{ReadOnlyInline}} - : A string containing the name CSS property associated with the transition. - {{domxref("TransitionEvent.elapsedTime")}} {{ReadOnlyInline}} - : A `float` giving the amount of time the transition has been running, in seconds, when this event fired. This value is not affected by the {{cssxref("transition-delay")}} property. - {{domxref("TransitionEvent.pseudoElement")}} {{ReadOnlyInline}} - : A string, starting with `::`, containing the name of the [pseudo-element](/en-US/docs/Web/CSS/Pseudo-elements) the animation runs on. If the transition doesn't run on a pseudo-element but on the element, an empty string: `''`. ## Examples This code gets an element that has a transition defined and adds a listener to the `transitioncancel` event: ```js const transition = document.querySelector(".transition"); transition.addEventListener("transitioncancel", () => { console.log("Transition canceled"); }); ``` The same, but using the `ontransitioncancel` property instead of `addEventListener()`: ```js const transition = document.querySelector(".transition"); transition.ontransitioncancel = () => { console.log("Transition canceled"); }; ``` ### Live example In the following example, we have a simple {{htmlelement("div")}} element, styled with a transition that includes a delay: ```html <div class="transition"></div> <div class="message"></div> ``` ```css .transition { width: 100px; height: 100px; background: rgb(255 0 0 / 100%); transition-property: transform, background; transition-duration: 2s; transition-delay: 2s; } .transition:hover { transform: rotate(90deg); background: rgb(255 0 0 / 0%); } ``` To this, we'll add some JavaScript to indicate that the [`transitionstart`](/en-US/docs/Web/API/Element/transitionstart_event), [`transitionrun`](/en-US/docs/Web/API/Element/transitionrun_event), `transitioncancel`, and [`transitionend`](/en-US/docs/Web/API/Element/transitionend_event) events fire. In this example, to cancel the transition, stop hovering over the transitioning box before the transition ends. For the transition end event to fire, stay hovered over the transition until the transition ends. ```js const message = document.querySelector(".message"); const el = document.querySelector(".transition"); el.addEventListener("transitionrun", () => { message.textContent = "transitionrun fired"; }); el.addEventListener("transitionstart", () => { message.textContent = "transitionstart fired"; }); el.addEventListener("transitioncancel", () => { message.textContent = "transitioncancel fired"; }); el.addEventListener("transitionend", () => { message.textContent = "transitionend fired"; }); ``` {{ EmbedLiveSample('Live_example', '100%', '150px') }} The `transitioncancel` event is fired if the transition is cancelled in either direction after the `transitionrun` event occurs and before the `transitionend` is fired. If there is no transition delay or duration, if both are 0s or neither is declared, there is no transition, and none of the transition events are fired. If the `transitioncancel` event is fired, the `transitionend` event will not fire. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - The {{domxref("TransitionEvent")}} interface - CSS properties: {{cssxref("transition")}}, {{cssxref("transition-delay")}}, {{cssxref("transition-duration")}}, {{cssxref("transition-property")}}, {{cssxref("transition-timing-function")}} - Related events: {{domxref("Element/transitionrun_event", "transitionrun")}}, {{domxref("Element/transitionstart_event", "transitionstart")}}, {{domxref("Element/transitionend_event", "transitionend")}}
0
data/mdn-content/files/en-us/web/api/element
data/mdn-content/files/en-us/web/api/element/animationiteration_event/index.md
--- title: "Element: animationiteration event" short-title: animationiteration slug: Web/API/Element/animationiteration_event page-type: web-api-event browser-compat: api.Element.animationiteration_event --- {{APIRef}} The **`animationiteration`** event is fired when an iteration of a [CSS Animation](/en-US/docs/Web/CSS/CSS_animations) ends, and another one begins. This event does not occur at the same time as the {{domxref("Element/animationend_event", "animationend")}} event, and therefore does not occur for animations with an `animation-iteration-count` of one. ## Syntax Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property. ```js addEventListener("animationiteration", (event) => {}); onanimationiteration = (event) => {}; ``` ## Event type An {{domxref("AnimationEvent")}}. Inherits from {{domxref("Event")}}. {{InheritanceDiagram("AnimationEvent")}} ## Event properties _Also inherits properties from its parent {{domxref("Event")}}_. - {{domxref("AnimationEvent.animationName")}} {{ReadOnlyInline}} - : A string containing the value of the {{cssxref("animation-name")}} that generated the animation. - {{domxref("AnimationEvent.elapsedTime")}} {{ReadOnlyInline}} - : A `float` giving the amount of time the animation has been running, in seconds, when this event fired, excluding any time the animation was paused. For an `animationstart` event, `elapsedTime` is `0.0` unless there was a negative value for {{cssxref("animation-delay")}}, in which case the event will be fired with `elapsedTime` containing `(-1 * delay)`. - {{domxref("AnimationEvent.pseudoElement")}} {{ReadOnlyInline}} - : A string, starting with `'::'`, containing the name of the [pseudo-element](/en-US/docs/Web/CSS/Pseudo-elements) the animation runs on. If the animation doesn't run on a pseudo-element but on the element, an empty string: `''`. ## Examples This code uses `animationiteration` to keep track of the number of iterations an animation has completed: ```js const animated = document.querySelector(".animated"); let iterationCount = 0; animated.addEventListener("animationiteration", () => { iterationCount++; console.log(`Animation iteration count: ${iterationCount}`); }); ``` The same, but using the `onanimationiteration` event handler property: ```js const animated = document.querySelector(".animated"); let iterationCount = 0; animated.onanimationiteration = () => { iterationCount++; console.log(`Animation iteration count: ${iterationCount}`); }; ``` ### Live example #### HTML ```html <div class="animation-example"> <div class="container"> <p class="animation">You chose a cold night to visit our planet.</p> </div> <button class="activate" type="button">Activate animation</button> <div class="event-log"></div> </div> ``` #### CSS ```css .container { height: 3rem; } .event-log { width: 25rem; height: 2rem; border: 1px solid black; margin: 0.2rem; padding: 0.2rem; } .animation.active { animation-duration: 2s; animation-name: slidein; animation-iteration-count: 2; } @keyframes slidein { from { transform: translateX(100%) scaleX(3); } to { transform: translateX(0) scaleX(1); } } ``` #### JavaScript ```js const animation = document.querySelector("p.animation"); const animationEventLog = document.querySelector( ".animation-example>.event-log", ); const applyAnimation = document.querySelector( ".animation-example>button.activate", ); let iterationCount = 0; animation.addEventListener("animationstart", () => { animationEventLog.textContent = `${animationEventLog.textContent}'animation started' `; }); animation.addEventListener("animationiteration", () => { iterationCount++; animationEventLog.textContent = `${animationEventLog.textContent}'animation iterations: ${iterationCount}' `; }); animation.addEventListener("animationend", () => { animationEventLog.textContent = `${animationEventLog.textContent}'animation ended'`; animation.classList.remove("active"); applyAnimation.textContent = "Activate animation"; }); animation.addEventListener("animationcancel", () => { animationEventLog.textContent = `${animationEventLog.textContent}'animation canceled'`; }); applyAnimation.addEventListener("click", () => { animation.classList.toggle("active"); animationEventLog.textContent = ""; iterationCount = 0; const active = animation.classList.contains("active"); applyAnimation.textContent = active ? "Cancel animation" : "Activate animation"; }); ``` #### Result {{ EmbedLiveSample('Live_example', '100%', '150px') }} ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - [CSS Animations](/en-US/docs/Web/CSS/CSS_animations) - [Using CSS Animations](/en-US/docs/Web/CSS/CSS_animations/Using_CSS_animations) - {{domxref("AnimationEvent")}} - Related events: {{domxref("Element/animationstart_event", "animationstart")}}, {{domxref("Element/animationend_event", "animationend")}}, {{domxref("Element/animationcancel_event", "animationcancel")}}
0
data/mdn-content/files/en-us/web/api/element
data/mdn-content/files/en-us/web/api/element/hasattributens/index.md
--- title: "Element: hasAttributeNS() method" short-title: hasAttributeNS() slug: Web/API/Element/hasAttributeNS page-type: web-api-instance-method browser-compat: api.Element.hasAttributeNS --- {{ APIRef("DOM") }} The **`hasAttributeNS()`** method of the {{domxref("Element")}} interface returns a boolean value indicating whether the current element has the specified attribute with the specified namespace. If you are working with HTML documents and you don't need to specify the requested attribute as being part of a specific namespace, use the {{domxref("Element.hasAttribute()", "hasAttribute()")}} method instead. ## Syntax ```js-nolint hasAttributeNS(namespace,localName) ``` ### Parameters - `namespace` is a string specifying the namespace of the attribute. - `localName` is the name of the attribute. ### Return value A boolean. ## Examples ```js // Check that the attribute exists before you set a value const d = document.getElementById("div1"); if ( d.hasAttributeNS("http://www.mozilla.org/ns/specialspace/", "special-align") ) { d.setAttribute("align", "center"); } ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("Element.getAttributeNS()")}} - {{domxref("Element.setAttributeNS()")}} - {{domxref("Element.removeAttributeNS()")}}
0
data/mdn-content/files/en-us/web/api/element
data/mdn-content/files/en-us/web/api/element/insertadjacentelement/index.md
--- title: "Element: insertAdjacentElement() method" short-title: insertAdjacentElement() slug: Web/API/Element/insertAdjacentElement page-type: web-api-instance-method browser-compat: api.Element.insertAdjacentElement --- {{APIRef("DOM")}} The **`insertAdjacentElement()`** method of the {{domxref("Element")}} interface inserts a given element node at a given position relative to the element it is invoked upon. ## Syntax ```js-nolint insertAdjacentElement(position, element) ``` ### Parameters - `position` - : A string representing the position relative to the `targetElement`; must match (case-insensitively) one of the following strings: - `'beforebegin'`: Before the `targetElement` itself. - `'afterbegin'`: Just inside the `targetElement`, before its first child. - `'beforeend'`: Just inside the `targetElement`, after its last child. - `'afterend'`: After the `targetElement` itself. - `element` - : The element to be inserted into the tree. ### Return value The element that was inserted, or `null`, if the insertion failed. ### Exceptions - `SyntaxError` {{domxref("DOMException")}} - : Thrown if the `position` specified is not a recognized value. - {{jsxref("TypeError")}} - : Thrown if the `element` specified is not a valid element. ### Visualization of position names ```html <!-- beforebegin --> <p> <!-- afterbegin --> foo <!-- beforeend --> </p> <!-- afterend --> ``` > **Note:** The `beforebegin` and > `afterend` positions work only if the node is in a tree and has an element > parent. ## Examples ```js beforeBtn.addEventListener("click", () => { const tempDiv = document.createElement("div"); tempDiv.style.backgroundColor = randomColor(); if (activeElem) { activeElem.insertAdjacentElement("beforebegin", tempDiv); } setListener(tempDiv); }); afterBtn.addEventListener("click", () => { const tempDiv = document.createElement("div"); tempDiv.style.backgroundColor = randomColor(); if (activeElem) { activeElem.insertAdjacentElement("afterend", tempDiv); } setListener(tempDiv); }); ``` Have a look at our [insertAdjacentElement.html](https://mdn.github.io/dom-examples/insert-adjacent/insertAdjacentElement.html) demo on GitHub (see the [source code](https://github.com/mdn/dom-examples/blob/main/insert-adjacent/insertAdjacentElement.html) too.) Here, we have a sequence of {{htmlelement("div")}} elements inside a container. When one is clicked, it becomes selected and you can then press the _Insert before_ and _Insert after_ buttons to insert new divs before or after the selected element using `insertAdjacentElement()`. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("Element.insertAdjacentHTML()")}} - {{domxref("Element.insertAdjacentText()")}} - {{domxref("Node.insertBefore()")}} (similar to `beforebegin`, with different arguments) - {{domxref("Node.appendChild()")}} (same effect as `beforeend`)
0
data/mdn-content/files/en-us/web/api/element
data/mdn-content/files/en-us/web/api/element/ariavaluetext/index.md
--- title: "Element: ariaValueText property" short-title: ariaValueText slug: Web/API/Element/ariaValueText page-type: web-api-instance-property browser-compat: api.Element.ariaValueText --- {{DefaultAPISidebar("DOM")}} The **`ariaValueText`** property of the {{domxref("Element")}} interface reflects the value of the [`aria-valuetext`](/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-valuetext) attribute, which defines the human-readable text alternative of aria-valuenow for a range widget. ## Value A string. ## Examples In this example the `aria-valuetext` attribute on the element with an ID of `slider` is set to "Sunday" to give a human-readable value for the range. Using `ariaValueText` we update the value to "Monday". ```html <div id="slider" role="slider" aria-valuenow="1" aria-valuemin="1" aria-valuemax="7" aria-valuetext="Sunday"></div> ``` ```js let el = document.getElementById("slider"); console.log(el.ariaValueText); // Sunday el.ariaValueText = "Monday"; console.log(el.ariaValueText); // Monday ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/element
data/mdn-content/files/en-us/web/api/element/matches/index.md
--- title: "Element: matches() method" short-title: matches() slug: Web/API/Element/matches page-type: web-api-instance-method browser-compat: api.Element.matches --- {{APIRef("DOM")}} The **`matches()`** method of the {{domxref("Element")}} interface tests whether the element would be selected by the specified [CSS selector](/en-US/docs/Learn/CSS/Building_blocks/Selectors). ## Syntax ```js-nolint matches(selectors) ``` ### Parameters - `selectors` - : A string containing valid [CSS selectors](/en-US/docs/Learn/CSS/Building_blocks/Selectors) to test the {{domxref("Element")}} against. ### Return value `true` if the {{domxref("Element")}} matches the `selectors`. Otherwise, `false`. ### Exceptions - `SyntaxError` {{domxref("DOMException")}} - : Thrown if `selectors` cannot be parsed as a CSS selector list. ## Examples ### HTML ```html <ul id="birds"> <li>Orange-winged parrot</li> <li class="endangered">Philippine eagle</li> <li>Great white pelican</li> </ul> ``` ### JavaScript ```js const birds = document.querySelectorAll("li"); for (const bird of birds) { if (bird.matches(".endangered")) { console.log(`The ${bird.textContent} is endangered!`); } } ``` This will log "The Philippine eagle is endangered!" to the console, since the element has indeed a `class` attribute with value `endangered`. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - [CSS selectors](/en-US/docs/Web/CSS/CSS_selectors) module - Other {{domxref("Element")}} methods that take selectors: {{domxref("Element.querySelector()")}}, {{domxref("Element.querySelectorAll()")}}, and {{domxref("element.closest()")}}.
0
data/mdn-content/files/en-us/web/api/element
data/mdn-content/files/en-us/web/api/element/classlist/index.md
--- title: "Element: classList property" short-title: classList slug: Web/API/Element/classList page-type: web-api-instance-property browser-compat: api.Element.classList --- {{APIRef("DOM")}} The **`Element.classList`** is a read-only property that returns a live {{domxref("DOMTokenList")}} collection of the `class` attributes of the element. This can then be used to manipulate the class list. Using `classList` is a convenient alternative to accessing an element's list of classes as a space-delimited string via {{domxref("element.className")}}. ## Value A {{domxref("DOMTokenList")}} representing the contents of the element's `class` attribute. If the `class` attribute is not set or empty, it returns an empty `DOMTokenList`, i.e. a `DOMTokenList` with the `length` property equal to `0`. Although the `classList` property itself is read-only, you can modify its associated `DOMTokenList` using the {{domxref("DOMTokenList/add", "add()")}}, {{domxref("DOMTokenList/remove", "remove()")}}, {{domxref("DOMTokenList/replace", "replace()")}}, and {{domxref("DOMTokenList/toggle", "toggle()")}} methods. You can test whether the element contains a given class using the {{domxref("DOMTokenList/contains", "classList.contains()")}} method. ## Examples ```js const div = document.createElement("div"); div.className = "foo"; // our starting state: <div class="foo"></div> console.log(div.outerHTML); // use the classList API to remove and add classes div.classList.remove("foo"); div.classList.add("anotherclass"); // <div class="anotherclass"></div> console.log(div.outerHTML); // if visible is set remove it, otherwise add it div.classList.toggle("visible"); // add/remove visible, depending on test conditional, i less than 10 div.classList.toggle("visible", i < 10); // false console.log(div.classList.contains("foo")); // add or remove multiple classes div.classList.add("foo", "bar", "baz"); div.classList.remove("foo", "bar", "baz"); // add or remove multiple classes using spread syntax const cls = ["foo", "bar"]; div.classList.add(...cls); div.classList.remove(...cls); // replace class "foo" with class "bar" div.classList.replace("foo", "bar"); ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("element.className")}} - {{domxref("DOMTokenList")}} - [`classList.js`](https://github.com/eligrey/classList.js) (a cross-browser JavaScript polyfill that fully implements `element.classList`)
0
data/mdn-content/files/en-us/web/api/element
data/mdn-content/files/en-us/web/api/element/dblclick_event/index.md
--- title: "Element: dblclick event" short-title: dblclick slug: Web/API/Element/dblclick_event page-type: web-api-event browser-compat: api.Element.dblclick_event --- {{APIRef}} The **`dblclick`** event fires when a pointing device button (such as a mouse's primary button) is double-clicked; that is, when it's rapidly clicked twice on a single element within a very short span of time. `dblclick` fires after two {{domxref("Element/click_event", "click")}} events (and by extension, after two pairs of {{domxref("Element.mousedown_event", "mousedown")}} and {{domxref("Element.mouseup_event", "mouseup")}} events). ## Syntax Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property. ```js addEventListener("dblclick", (event) => {}); ondblclick = (event) => {}; ``` ## Event type A {{domxref("MouseEvent")}}. Inherits from {{domxref("UIEvent")}} and {{domxref("Event")}}. {{InheritanceDiagram("MouseEvent")}} ## Event properties _This interface also inherits properties of its parents, {{domxref("UIEvent")}} and {{domxref("Event")}}._ - {{domxref("MouseEvent.altKey")}} {{ReadOnlyInline}} - : Returns `true` if the <kbd>alt</kbd> key was down when the mouse event was fired. - {{domxref("MouseEvent.button")}} {{ReadOnlyInline}} - : The button number that was pressed (if applicable) when the mouse event was fired. - {{domxref("MouseEvent.buttons")}} {{ReadOnlyInline}} - : The buttons being pressed (if any) when the mouse event was fired. - {{domxref("MouseEvent.clientX")}} {{ReadOnlyInline}} - : The X coordinate of the mouse pointer in [viewport coordinates](/en-US/docs/Web/CSS/CSSOM_view/Coordinate_systems#viewport). - {{domxref("MouseEvent.clientY")}} {{ReadOnlyInline}} - : The Y coordinate of the mouse pointer in [viewport coordinates](/en-US/docs/Web/CSS/CSSOM_view/Coordinate_systems#viewport). - {{domxref("MouseEvent.ctrlKey")}} {{ReadOnlyInline}} - : Returns `true` if the <kbd>control</kbd> key was down when the mouse event was fired. - {{domxref("MouseEvent.layerX")}} {{Non-standard_inline}} {{ReadOnlyInline}} - : Returns the horizontal coordinate of the event relative to the current layer. - {{domxref("MouseEvent.layerY")}} {{Non-standard_inline}} {{ReadOnlyInline}} - : Returns the vertical coordinate of the event relative to the current layer. - {{domxref("MouseEvent.metaKey")}} {{ReadOnlyInline}} - : Returns `true` if the <kbd>meta</kbd> key was down when the mouse event was fired. - {{domxref("MouseEvent.movementX")}} {{ReadOnlyInline}} - : The X coordinate of the mouse pointer relative to the position of the last {{domxref("Element/mousemove_event", "mousemove")}} event. - {{domxref("MouseEvent.movementY")}} {{ReadOnlyInline}} - : The Y coordinate of the mouse pointer relative to the position of the last {{domxref("Element/mousemove_event", "mousemove")}} event. - {{domxref("MouseEvent.offsetX")}} {{ReadOnlyInline}} - : The X coordinate of the mouse pointer relative to the position of the padding edge of the target node. - {{domxref("MouseEvent.offsetY")}} {{ReadOnlyInline}} - : The Y coordinate of the mouse pointer relative to the position of the padding edge of the target node. - {{domxref("MouseEvent.pageX")}} {{ReadOnlyInline}} - : The X coordinate of the mouse pointer relative to the whole document. - {{domxref("MouseEvent.pageY")}} {{ReadOnlyInline}} - : The Y coordinate of the mouse pointer relative to the whole document. - {{domxref("MouseEvent.relatedTarget")}} {{ReadOnlyInline}} - : The secondary target for the event, if there is one. - {{domxref("MouseEvent.screenX")}} {{ReadOnlyInline}} - : The X coordinate of the mouse pointer in [screen coordinates](/en-US/docs/Web/CSS/CSSOM_view/Coordinate_systems#screen). - {{domxref("MouseEvent.screenY")}} {{ReadOnlyInline}} - : The Y coordinate of the mouse pointer in [screen coordinates](/en-US/docs/Web/CSS/CSSOM_view/Coordinate_systems#screen). - {{domxref("MouseEvent.shiftKey")}} {{ReadOnlyInline}} - : Returns `true` if the <kbd>shift</kbd> key was down when the mouse event was fired. - {{domxref("MouseEvent.mozInputSource")}} {{non-standard_inline()}} {{ReadOnlyInline}} - : The type of device that generated the event (one of the `MOZ_SOURCE_*` constants). This lets you, for example, determine whether a mouse event was generated by an actual mouse or by a touch event (which might affect the degree of accuracy with which you interpret the coordinates associated with the event). - {{domxref("MouseEvent.webkitForce")}} {{non-standard_inline()}} {{ReadOnlyInline}} - : The amount of pressure applied when clicking. - {{domxref("MouseEvent.x")}} {{ReadOnlyInline}} - : Alias for {{domxref("MouseEvent.clientX")}}. - {{domxref("MouseEvent.y")}} {{ReadOnlyInline}} - : Alias for {{domxref("MouseEvent.clientY")}}. ## Examples This example toggles the size of a card when you double click on it. ### JavaScript ```js const card = document.querySelector("aside"); card.addEventListener("dblclick", (e) => { card.classList.toggle("large"); }); ``` ### HTML ```html <aside> <h3>My Card</h3> <p>Double click to resize this object.</p> </aside> ``` ### CSS ```css aside { background: #fe9; border-radius: 1em; display: inline-block; padding: 1em; transform: scale(0.9); transform-origin: 0 0; transition: transform 0.6s; user-select: none; } .large { transform: scale(1.3); } ``` ### Result {{EmbedLiveSample("Examples", 700, 200)}} ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - [Introduction to events](/en-US/docs/Learn/JavaScript/Building_blocks/Events) - {{domxref("Element/auxclick_event", "auxclick")}} - {{domxref("Element/click_event", "click")}} - {{domxref("Element/contextmenu_event", "contextmenu")}} - {{domxref("Element/mousedown_event", "mousedown")}} - {{domxref("Element/mouseup_event", "mouseup")}} - {{domxref("Element/pointerdown_event", "pointerdown")}} - {{domxref("Element/pointerup_event", "pointerup")}}
0
data/mdn-content/files/en-us/web/api
data/mdn-content/files/en-us/web/api/htmlobjectelement/index.md
--- title: HTMLObjectElement slug: Web/API/HTMLObjectElement page-type: web-api-interface browser-compat: api.HTMLObjectElement --- {{ APIRef("HTML DOM") }} The **`HTMLObjectElement`** interface provides special properties and methods (beyond those on the {{domxref("HTMLElement")}} interface it also has available to it by inheritance) for manipulating the layout and presentation of {{HTMLElement("object")}} element, representing external resources. {{InheritanceDiagram}} ## Instance properties _Inherits properties from its parent, {{domxref("HTMLElement")}}._ - {{domxref("HTMLObjectElement.align")}} {{deprecated_inline}} - : A string representing an enumerated property indicating alignment of the element's contents with respect to the surrounding context. The possible values are `"left"`, `"right"`, `"justify"`, and `"center"`. - {{domxref("HTMLObjectElement.archive")}} {{deprecated_inline}} - : A string that reflects the [`archive`](/en-US/docs/Web/HTML/Element/object#archive) HTML attribute, containing a list of archives for resources for this object. - {{domxref("HTMLObjectElement.border")}} {{deprecated_inline}} - : A string that reflects the [`border`](/en-US/docs/Web/HTML/Element/object#border) HTML attribute, specifying the width of a border around the object. - {{domxref("HTMLObjectElement.code")}} {{deprecated_inline}} - : A string representing the name of an applet class file, containing either the applet's subclass, or the path to get to the class, including the class file itself. - {{domxref("HTMLObjectElement.codeBase")}} {{deprecated_inline}} - : A string that reflects the [`codebase`](/en-US/docs/Web/HTML/Element/object#codebase) HTML attribute, specifying the base path to use to resolve relative URIs. - {{domxref("HTMLObjectElement.codeType")}} {{deprecated_inline}} - : A string that reflects the [`codetype`](/en-US/docs/Web/HTML/Element/object#codetype) HTML attribute, specifying the content type of the data. - {{domxref("HTMLObjectElement.contentDocument")}} {{ReadOnlyInline}} - : Returns a {{domxref("Document")}} representing the active document of the object element's nested browsing context, if any; otherwise `null`. - {{domxref("HTMLObjectElement.contentWindow")}} {{ReadOnlyInline}} - : Returns a {{glossary("WindowProxy")}} representing the window proxy of the object element's nested browsing context, if any; otherwise `null`. - {{domxref("HTMLObjectElement.data")}} - : Returns a string that reflects the [`data`](/en-US/docs/Web/HTML/Element/object#data) HTML attribute, specifying the address of a resource's data. - {{domxref("HTMLObjectElement.declare")}} {{deprecated_inline}} - : A boolean value that reflects the [`declare`](/en-US/docs/Web/HTML/Element/object#declare) HTML attribute, indicating that this is a declaration, not an instantiation, of the object. - {{domxref("HTMLObjectElement.form")}} {{ReadOnlyInline}} - : Returns a {{domxref("HTMLFormElement")}} representing the object element's form owner, or null if there isn't one. - {{domxref("HTMLObjectElement.height")}} - : Returns a string that reflects the [`height`](/en-US/docs/Web/HTML/Element/object#height) HTML attribute, specifying the displayed height of the resource in CSS pixels. - {{domxref("HTMLObjectElement.hspace")}} {{deprecated_inline}} - : A `long` representing the horizontal space in pixels around the control. - {{domxref("HTMLObjectElement.name")}} - : Returns a string that reflects the [`name`](/en-US/docs/Web/HTML/Element/object#name) HTML attribute, specifying the name of the browsing context. - {{domxref("HTMLObjectElement.standby")}} {{deprecated_inline}} - : A string that reflects the [`standby`](/en-US/docs/Web/HTML/Element/object#standby) HTML attribute, specifying a message to display while the object loads. - {{domxref("HTMLObjectElement.type")}} - : A string that reflects the [`type`](/en-US/docs/Web/HTML/Element/object#type) HTML attribute, specifying the MIME type of the resource. - {{domxref("HTMLObjectElement.useMap")}} {{deprecated_inline}} - : A string that reflects the [`usemap`](/en-US/docs/Web/HTML/Element/object#usemap) HTML attribute, specifying a {{HTMLElement("map")}} element to use. - {{domxref("HTMLObjectElement.validationMessage")}} {{ReadOnlyInline}} - : Returns a string representing a localized message that describes the validation constraints that the control does not satisfy (if any). This is the empty string if the control is not a candidate for constraint validation (`willValidate` is `false`), or it satisfies its constraints. - {{domxref("HTMLObjectElement.validity")}} {{ReadOnlyInline}} - : Returns a {{domxref("ValidityState")}} with the validity states that this element is in. - {{domxref("HTMLObjectElement.vspace")}} {{deprecated_inline}} - : A `long` representing the horizontal space in pixels around the control. - {{domxref("HTMLObjectElement.width")}} - : A string that reflects the [`width`](/en-US/docs/Web/HTML/Element/object#width) HTML attribute, specifying the displayed width of the resource in CSS pixels. - {{domxref("HTMLObjectElement.willValidate")}} {{ReadOnlyInline}} - : Returns a boolean value that indicates whether the element is a candidate for constraint validation. Always `false` for `HTMLObjectElement` objects. ## Instance methods _Inherits methods from its parent, {{domxref("HTMLElement")}}._ - {{domxref("HTMLObjectElement.checkValidity()")}} - : Returns a boolean value that always is `true`, because `object` objects are never candidates for constraint validation. - {{domxref("HTMLObjectElement.setCustomValidity()")}} - : Sets a custom validity message for the element. If this message is not the empty string, then the element is suffering from a custom validity error, and does not validate. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - The HTML element implementing this interface: {{HTMLElement("object")}}
0
data/mdn-content/files/en-us/web/api/htmlobjectelement
data/mdn-content/files/en-us/web/api/htmlobjectelement/checkvalidity/index.md
--- title: "HTMLObjectElement: checkValidity() method" short-title: checkValidity() slug: Web/API/HTMLObjectElement/checkValidity page-type: web-api-instance-method browser-compat: api.HTMLObjectElement.checkValidity --- {{APIRef("HTML DOM")}} The **`checkValidity()`** method of the {{domxref("HTMLObjectElement")}} interface returns a boolean value that always is true, because object objects are never candidates for constraint validation. ## Syntax ```js-nolint checkValidity() ``` ### Parameters None. ### Return value `true` ### Exceptions None. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/htmlobjectelement
data/mdn-content/files/en-us/web/api/htmlobjectelement/name/index.md
--- title: "HTMLObjectElement: name property" short-title: name slug: Web/API/HTMLObjectElement/name page-type: web-api-instance-property browser-compat: api.HTMLObjectElement.name --- {{APIRef("HTML DOM")}} The **`name`** property of the {{domxref("HTMLObjectElement")}} interface returns a string that reflects the [`name`](/en-US/docs/Web/HTML/Element/object#name) HTML attribute, specifying the name of the browsing context. ## Value A string. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/htmlobjectelement
data/mdn-content/files/en-us/web/api/htmlobjectelement/contentdocument/index.md
--- title: "HTMLObjectElement: contentDocument property" short-title: contentDocument slug: Web/API/HTMLObjectElement/contentDocument page-type: web-api-instance-property browser-compat: api.HTMLObjectElement.contentDocument --- {{APIRef("HTML DOM")}} The **`contentDocument`** read-only property of the {{domxref("HTMLObjectElement")}} interface Returns a {{domxref("Document")}} representing the active document of the object element's nested browsing context, if any; otherwise null. ## Value A {{domxref('Document')}}. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/htmlobjectelement
data/mdn-content/files/en-us/web/api/htmlobjectelement/form/index.md
--- title: "HTMLObjectElement: form property" short-title: form slug: Web/API/HTMLObjectElement/form page-type: web-api-instance-property browser-compat: api.HTMLObjectElement.form --- {{APIRef("HTML DOM")}} The **`form`** read-only property of the {{domxref("HTMLObjectElement")}} interface returns a {{domxref("HTMLFormElement")}} representing the object element's form owner, or null if there isn't one. ## Value A {{domxref('HTMLFormElement')}}. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/htmlobjectelement
data/mdn-content/files/en-us/web/api/htmlobjectelement/data/index.md
--- title: "HTMLObjectElement: data property" short-title: data slug: Web/API/HTMLObjectElement/data page-type: web-api-instance-property browser-compat: api.HTMLObjectElement.data --- {{APIRef("HTML DOM")}} The **`data`** property of the {{domxref("HTMLObjectElement")}} interface returns a string that reflects the [`data`](/en-US/docs/Web/HTML/Element/object#data) HTML attribute, specifying the address of a resource's data. ## Value A string. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/htmlobjectelement
data/mdn-content/files/en-us/web/api/htmlobjectelement/usemap/index.md
--- title: "HTMLObjectElement: useMap property" short-title: useMap slug: Web/API/HTMLObjectElement/useMap page-type: web-api-instance-property status: - deprecated browser-compat: api.HTMLObjectElement.useMap --- {{APIRef("HTML DOM")}}{{deprecated_header}} The **`useMap`** property of the {{domxref("HTMLObjectElement")}} interface returns a string that reflects the [`usemap`](/en-US/docs/Web/HTML/Element/object#usemap) HTML attribute, specifying a {{HTMLElement("map")}} element to use. ## Value A string. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/htmlobjectelement
data/mdn-content/files/en-us/web/api/htmlobjectelement/setcustomvalidity/index.md
--- title: "HTMLObjectElement: setCustomValidity() method" short-title: setCustomValidity() slug: Web/API/HTMLObjectElement/setCustomValidity page-type: web-api-instance-method browser-compat: api.HTMLObjectElement.setCustomValidity --- {{APIRef("HTML DOM")}} The **`setCustomValidity()`** method of the {{domxref("HTMLObjectElement")}} interface sets a custom validity message for the element. ## Syntax ```js-nolint setCustomValidity(errorMessage) ``` ### Parameters - `errorMessage` - : The message to use for validity errors. ### Return value None ({{jsxref("undefined")}}). ### Exceptions None. ## Examples In this example, we pass the ID of an input element, and set different error messages depending on whether the value is missing, too low or too high. Additionally you _must_ call the [reportValidity](/en-US/docs/Web/API/HTMLFormElement/reportValidity) method on the same element or nothing will happen. ```js function validate(inputID) { const input = document.getElementById(inputID); const validityState = input.validity; if (validityState.valueMissing) { input.setCustomValidity("You gotta fill this out, yo!"); } else if (validityState.rangeUnderflow) { input.setCustomValidity("We need a higher number!"); } else if (validityState.rangeOverflow) { input.setCustomValidity("Thats too high!"); } else { input.setCustomValidity(""); } input.reportValidity(); } ``` It's vital to set the message to an empty string if there are no errors. As long as the error message is not empty, the form will not pass validation and will not be submitted. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref('validityState')}} - {{domxref('validityState.valueMissing')}} - {{domxref('validityState.typeMismatch')}} - {{domxref('validityState.patternMismatch')}} - {{domxref('validityState.tooLong')}} - {{domxref('validityState.tooShort')}} - {{domxref('validityState.rangeUnderflow')}} - {{domxref('validityState.rangeOverflow')}} - {{domxref('validityState.stepMismatch')}} - {{domxref('validityState.valid')}} - {{domxref('validityState.customError')}}
0
data/mdn-content/files/en-us/web/api/htmlobjectelement
data/mdn-content/files/en-us/web/api/htmlobjectelement/validity/index.md
--- title: "HTMLObjectElement: validity property" short-title: validity slug: Web/API/HTMLObjectElement/validity page-type: web-api-instance-property browser-compat: api.HTMLObjectElement.validity --- {{APIRef("HTML DOM")}} The **`validity`** read-only property of the {{domxref("HTMLObjectElement")}} interface returns a {{domxref("ValidityState")}} with the validity states that this element is in. ## Value A {{domxref("ValidityState")}} object. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/htmlobjectelement
data/mdn-content/files/en-us/web/api/htmlobjectelement/width/index.md
--- title: "HTMLObjectElement: width property" short-title: width slug: Web/API/HTMLObjectElement/width page-type: web-api-instance-property browser-compat: api.HTMLObjectElement.width --- {{APIRef("HTML DOM")}} The **`width`** property of the {{domxref("HTMLObjectElement")}} interface returns a string that reflects the [`width`](/en-US/docs/Web/HTML/Element/object#width) HTML attribute, specifying the displayed width of the resource in CSS pixels. ## Value A string. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("HTMLCanvasElement.width")}} - {{domxref("HTMLEmbedElement.width")}} - {{domxref("HTMLIFrameElement.width")}} - {{domxref("HTMLImageElement.width")}} - {{domxref("HTMLSourceElement.width")}} - {{domxref("HTMLVideoElement.width")}}
0
data/mdn-content/files/en-us/web/api/htmlobjectelement
data/mdn-content/files/en-us/web/api/htmlobjectelement/contentwindow/index.md
--- title: "HTMLObjectElement: contentWindow property" short-title: contentWindow slug: Web/API/HTMLObjectElement/contentWindow page-type: web-api-instance-property browser-compat: api.HTMLObjectElement.contentWindow --- {{APIRef("HTML DOM")}} The **`contentWindow`** read-only property of the {{domxref("HTMLObjectElement")}} interface returns a {{glossary("WindowProxy")}} representing the window proxy of the object element's nested browsing context, if any; otherwise null. ## Value A {{domxref('Window')}}, or `null` if there are none. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/htmlobjectelement
data/mdn-content/files/en-us/web/api/htmlobjectelement/type/index.md
--- title: "HTMLObjectElement: type property" short-title: type slug: Web/API/HTMLObjectElement/type page-type: web-api-instance-property browser-compat: api.HTMLObjectElement.type --- {{APIRef("HTML DOM")}} The **`type`** property of the {{domxref("HTMLObjectElement")}} interface returns a string that reflects the [`type`](/en-US/docs/Web/HTML/Element/object#type) HTML attribute, specifying the MIME type of the resource. ## Value A string. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/htmlobjectelement
data/mdn-content/files/en-us/web/api/htmlobjectelement/height/index.md
--- title: "HTMLObjectElement: height property" short-title: height slug: Web/API/HTMLObjectElement/height page-type: web-api-instance-property browser-compat: api.HTMLObjectElement.height --- {{APIRef("HTML DOM")}} The **`height`** property of the {{domxref("HTMLObjectElement")}} interface Returns a string that reflects the [`height`](/en-US/docs/Web/HTML/Element/object#height) HTML attribute, specifying the displayed height of the resource in CSS pixels. ## Value A string. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("HTMLCanvasElement.height")}} - {{domxref("HTMLEmbedElement.height")}} - {{domxref("HTMLIFrameElement.height")}} - {{domxref("HTMLImageElement.height")}} - {{domxref("HTMLSourceElement.height")}} - {{domxref("HTMLVideoElement.height")}}
0
data/mdn-content/files/en-us/web/api/htmlobjectelement
data/mdn-content/files/en-us/web/api/htmlobjectelement/validationmessage/index.md
--- title: "HTMLObjectElement: validationMessage property" short-title: validationMessage slug: Web/API/HTMLObjectElement/validationMessage page-type: web-api-instance-property browser-compat: api.HTMLObjectElement.validationMessage --- {{APIRef("HTML DOM")}} The **`validationMessage`** read-only property of the {{domxref("HTMLObjectElement")}} interface returns a string representing a localized message that describes the validation constraints that the control does not satisfy (if any). This is the empty string if the control is not a candidate for constraint validation (willValidate is false), or it satisfies its constraints. ## Value A string. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/htmlobjectelement
data/mdn-content/files/en-us/web/api/htmlobjectelement/willvalidate/index.md
--- title: "HTMLObjectElement: willValidate property" short-title: willValidate slug: Web/API/HTMLObjectElement/willValidate page-type: web-api-instance-property browser-compat: api.HTMLObjectElement.willValidate --- {{APIRef("HTML DOM")}} The **`willValidate`** read-only property of the {{domxref("HTMLObjectElement")}} interface returns a boolean value that indicates whether the element is a candidate for constraint validation. Always false for HTMLObjectElement objects. ## Value A boolean value. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api
data/mdn-content/files/en-us/web/api/messageevent/index.md
--- title: MessageEvent slug: Web/API/MessageEvent page-type: web-api-interface browser-compat: api.MessageEvent --- {{APIRef("HTML DOM")}} The **`MessageEvent`** interface represents a message received by a target object. This is used to represent messages in: - [Server-sent events](/en-US/docs/Web/API/Server-sent_events) (see {{domxref("EventSource.message_event")}}). - [Web sockets](/en-US/docs/Web/API/WebSockets_API) (see the `onmessage` property of the [WebSocket](/en-US/docs/Web/API/WebSocket) interface). - Cross-document messaging (see {{domxref("Window.postMessage()")}} and {{domxref("Window.message_event")}}). - [Channel messaging](/en-US/docs/Web/API/Channel_Messaging_API) (see {{domxref("MessagePort.postMessage()")}} and {{domxref("MessagePort.message_event")}}). - Cross-worker/document messaging (see the above two entries, but also {{domxref("Worker.postMessage()")}}, {{domxref("Worker.message_event")}}, {{domxref("ServiceWorkerGlobalScope.message_event")}}, etc.) - [Broadcast channels](/en-US/docs/Web/API/Broadcast_Channel_API) (see {{domxref("BroadcastChannel.postMessage()")}}) and {{domxref("BroadcastChannel.message_event")}}). - WebRTC data channels (see {{domxref("RTCDataChannel.message_event", "onmessage")}}). The action triggered by this event is defined in a function set as the event handler for the relevant `message` event (e.g. using an `onmessage` handler as listed above). {{AvailableInWorkers}} {{InheritanceDiagram}} ## Constructor - {{domxref("MessageEvent.MessageEvent", "MessageEvent()")}} - : Creates a new `MessageEvent`. ## Instance 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). ## Instance methods _This interface also inherits methods from its parent, {{domxref("Event")}}._ - {{domxref("MessageEvent.initMessageEvent","initMessageEvent()")}} {{deprecated_inline}} - : Initializes a message event. **Do not use this anymore** — **use the {{domxref("MessageEvent.MessageEvent", "MessageEvent()")}} constructor instead.** ## Examples In our [Basic shared worker example](https://github.com/mdn/dom-examples/tree/main/web-workers/simple-shared-worker) ([run shared worker](https://mdn.github.io/dom-examples/web-workers/simple-shared-worker/)), we have two HTML pages, each of which uses some JavaScript to perform a simple calculation. The different scripts are using the same worker file to perform the calculation — they can both access it, even if their pages are running inside different windows. The following code snippet shows creation of a {{domxref("SharedWorker")}} object using the {{domxref("SharedWorker.SharedWorker", "SharedWorker()")}} constructor. Both scripts contain this: ```js const myWorker = new SharedWorker("worker.js"); ``` Both scripts then access the worker through a {{domxref("MessagePort")}} object created using the {{domxref("SharedWorker.port")}} property. If the onmessage event is attached using addEventListener, the port is manually started using its `start()` method: ```js myWorker.port.start(); ``` When the port is started, both scripts post messages to the worker and handle messages sent from it using `port.postMessage()` and `port.onmessage`, respectively: ```js first.onchange = () => { myWorker.port.postMessage([first.value, second.value]); console.log("Message posted to worker"); }; second.onchange = () => { myWorker.port.postMessage([first.value, second.value]); console.log("Message posted to worker"); }; myWorker.port.onmessage = (e) => { result1.textContent = e.data; console.log("Message received from worker"); }; ``` Inside the worker we use the {{domxref("SharedWorkerGlobalScope.connect_event", "onconnect")}} handler to connect to the same port discussed above. The ports associated with that worker are accessible in the {{domxref("SharedWorkerGlobalScope/connect_event", "connect")}} event's `ports` property — we then use {{domxref("MessagePort")}} `start()` method to start the port, and the `onmessage` handler to deal with messages sent from the main threads. ```js onconnect = (e) => { const port = e.ports[0]; port.addEventListener("message", (e) => { const workerResult = `Result: ${e.data[0] * e.data[1]}`; port.postMessage(workerResult); }); port.start(); // Required when using addEventListener. Otherwise called implicitly by onmessage setter. }; ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("ExtendableMessageEvent")}} — similar to this interface but used in interfaces that needs to give more flexibility to authors.
0
data/mdn-content/files/en-us/web/api/messageevent
data/mdn-content/files/en-us/web/api/messageevent/origin/index.md
--- title: "MessageEvent: origin property" short-title: origin slug: Web/API/MessageEvent/origin page-type: web-api-instance-property browser-compat: api.MessageEvent.origin --- {{APIRef("HTML DOM")}} The **`origin`** read-only property of the {{domxref("MessageEvent")}} interface is a string representing the origin of the message emitter. ## Value A string representing the origin. ## Examples ```js myWorker.onmessage = (e) => { result.textContent = e.data; console.log("Message received from worker"); console.log(e.origin); }; ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("ExtendableMessageEvent")}} — similar to this interface but used in interfaces that needs to give more flexibility to authors.
0
data/mdn-content/files/en-us/web/api/messageevent
data/mdn-content/files/en-us/web/api/messageevent/source/index.md
--- title: "MessageEvent: source property" short-title: source slug: Web/API/MessageEvent/source page-type: web-api-instance-property browser-compat: api.MessageEvent.source --- {{APIRef("HTML DOM")}} The **`source`** read-only property of the {{domxref("MessageEvent")}} interface is a `MessageEventSource` (which can be a {{glossary("WindowProxy")}}, {{domxref("MessagePort")}}, or {{domxref("ServiceWorker")}} object) representing the message emitter. ## Value a `MessageEventSource` (which can be a {{glossary("WindowProxy")}}, {{domxref("MessagePort")}}, or {{domxref("ServiceWorker")}} object) representing the message emitter. ## Examples ```js myWorker.onmessage = (e) => { result.textContent = e.data; console.log("Message received from worker"); console.log(e.source); }; ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("ExtendableMessageEvent")}} — similar to this interface but used in interfaces that needs to give more flexibility to authors.
0
data/mdn-content/files/en-us/web/api/messageevent
data/mdn-content/files/en-us/web/api/messageevent/data/index.md
--- title: "MessageEvent: data property" short-title: data slug: Web/API/MessageEvent/data page-type: web-api-instance-property browser-compat: api.MessageEvent.data --- {{APIRef("HTML DOM")}} The **`data`** read-only property of the {{domxref("MessageEvent")}} interface represents the data sent by the message emitter. ## Value The data sent by the message emitter; this can be any data type, depending on what originated this event. ## Examples ```js myWorker.onmessage = (e) => { result.textContent = e.data; console.log("Message received from worker"); }; ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("ExtendableMessageEvent")}} — similar to this interface but used in interfaces that needs to give more flexibility to authors.
0
data/mdn-content/files/en-us/web/api/messageevent
data/mdn-content/files/en-us/web/api/messageevent/messageevent/index.md
--- title: "MessageEvent: MessageEvent() constructor" short-title: MessageEvent() slug: Web/API/MessageEvent/MessageEvent page-type: web-api-constructor browser-compat: api.MessageEvent.MessageEvent --- {{APIRef("HTML DOM")}} The **`MessageEvent()`** constructor creates a new {{domxref("MessageEvent")}} object. ## Syntax ```js-nolint new MessageEvent(type) new MessageEvent(type, options) ``` ### Parameters - `type` - : A string with the name of the event. It is case-sensitive and browsers always set it to `message`. - `options` {{optional_inline}} - : An object that, _in addition of the properties defined in {{domxref("Event/Event", "Event()")}}_, can have the following properties: - `data` {{optional_inline}} - : The data you want contained in the MessageEvent. This can be of any data type, and will default to `null` if not specified. - `origin` {{optional_inline}} - : A string representing the origin of the message emitter. This defaults to an empty string (`''`) if not specified. - `lastEventId` {{optional_inline}} - : A string representing a unique ID for the event. This defaults to an empty string ("") if not specified. - `source` {{optional_inline}} - : A `MessageEventSource` (which can be a {{domxref("Window")}}, a {{domxref("MessagePort")}}, or a {{domxref("ServiceWorker")}} object) representing the message emitter. This defaults to `null` if not set. - `ports` {{optional_inline}} - : 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). This defaults to an empty array (`[]`) if not specified. ## Return value A new {{domxref("MessageEvent")}} object. ## Examples ```js const myMessage = new MessageEvent("message", { data: "hello", }); ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("ExtendableMessageEvent")}} — similar to this interface but used in interfaces that needs to give more flexibility to authors.
0
data/mdn-content/files/en-us/web/api/messageevent
data/mdn-content/files/en-us/web/api/messageevent/lasteventid/index.md
--- title: "MessageEvent: lastEventId property" short-title: lastEventId slug: Web/API/MessageEvent/lastEventId page-type: web-api-instance-property browser-compat: api.MessageEvent.lastEventId --- {{APIRef("HTML DOM")}} The **`lastEventId`** read-only property of the {{domxref("MessageEvent")}} interface is a string representing a unique ID for the event. ## Value A string representing the ID. ## Examples ```js myWorker.onmessage = (e) => { result.textContent = e.data; console.log("Message received from worker"); console.log(e.lastEventId); }; ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("ExtendableMessageEvent")}} — similar to this interface but used in interfaces that needs to give more flexibility to authors.
0
data/mdn-content/files/en-us/web/api/messageevent
data/mdn-content/files/en-us/web/api/messageevent/ports/index.md
--- title: "MessageEvent: ports property" short-title: ports slug: Web/API/MessageEvent/ports page-type: web-api-instance-property browser-compat: api.MessageEvent.ports --- {{APIRef("HTML DOM")}} The **`ports`** read-only property of the {{domxref("MessageEvent")}} interface is 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). ## Value An array of {{domxref("MessagePort")}} objects. ## Examples ```js onconnect = (e) => { const port = e.ports[0]; port.addEventListener("message", (e) => { const workerResult = `Result: ${e.data[0] * e.data[1]}`; port.postMessage(workerResult); }); port.start(); // Required when using addEventListener. Otherwise called implicitly by onmessage setter. }; ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("ExtendableMessageEvent")}} — similar to this interface but used in interfaces that needs to give more flexibility to authors.
0
data/mdn-content/files/en-us/web/api
data/mdn-content/files/en-us/web/api/identitycredential/index.md
--- title: IdentityCredential slug: Web/API/IdentityCredential page-type: web-api-interface status: - experimental browser-compat: api.IdentityCredential --- {{APIRef("FedCM API")}}{{SeeCompatTable}}{{SecureContext_Header}} The **`IdentityCredential`** interface of the [Federated Credential Management API (FedCM)](/en-US/docs/Web/API/FedCM_API) represents a user identity credential arising from a successful federated sign-in. A successful {{domxref("CredentialsContainer.get", "navigator.credentials.get()")}} call that includes an `identity` option fulfills with an `IdentityCredential` instance. {{InheritanceDiagram}} ## Instance properties _Inherits properties from its ancestor, {{domxref("Credential")}}._ - {{domxref("IdentityCredential.isAutoSelected")}} {{ReadOnlyInline}} {{experimental_inline}} {{non-standard_inline}} - : A boolean value that indicates whether the federated sign-in was carried out using [auto-reauthentication](/en-US/docs/Web/API/FedCM_API/RP_sign-in#auto-reauthentication) (i.e. without user mediation) or not. - {{domxref("IdentityCredential.token")}} {{experimental_inline}} - : Returns the token used to validate the associated sign-in. ## Examples Relying parties (RPs) can call `navigator.credentials.get()` with the `identity` option to make a request for users to sign in to the RP via an identity provider (IdP), using identity federation. A typical request would look like this: ```js async function signIn() { const identityCredential = await navigator.credentials.get({ identity: { providers: [ { configURL: "https://accounts.idp.example/config.json", clientId: "********", nonce: "******", }, ], }, }); } ``` If successful, this call will fulfill with an `IdentityCredential` instance. From this, you could return the {{domxref("IdentityCredential.token")}} value, for example: ```js console.log(identityCredential.token); ``` Check out [Federated Credential Management API (FedCM)](/en-US/docs/Web/API/FedCM_API) for more details on how this works. This call will start off the sign-in flow described in [FedCM sign-in flow](/en-US/docs/Web/API/FedCM_API/RP_sign-in#fedcm_sign-in_flow). ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - [Federated Credential Management API](https://developer.chrome.com/docs/privacy-sandbox/fedcm/)
0
data/mdn-content/files/en-us/web/api/identitycredential
data/mdn-content/files/en-us/web/api/identitycredential/token/index.md
--- title: "IdentityCredential: token property" short-title: token slug: Web/API/IdentityCredential/token page-type: web-api-instance-property status: - experimental browser-compat: api.IdentityCredential.token --- {{APIRef("FedCM API")}}{{SeeCompatTable}}{{SecureContext_Header}} The **`token`** read-only property of the {{domxref("IdentityCredential")}} interface returns the token used to validate the associated sign-in. The token includes user identity information that has been signed with the identity provider (IdP)'s {{glossary("digital certificate")}}. The relying party (RP) sends the token to its server to validate the certificate, and on success can use the (now trusted) identity information in the token to sign them into their service (starting a new session), sign them up to their service if they are a new user, etc. If the user has never signed into the IdP or is logged out, the associated {{domxref("CredentialsContainer.get", "get()")}} call rejects with an error and the RP can direct the user to the IdP login page to sign in or create an account. > **Note:** The exact structure and content of the validation token token is opaque to the FedCM API, and to the browser. The IdP decides on the syntax and usage of it, and the RP needs to follow the instructions provided by the IdP (see [Verify the Google ID token on your server side](https://developers.google.com/identity/gsi/web/guides/verify-google-id-token), for example) to make sure they are using it correctly. ## Value A string. ## Examples Relying parties (RPs) can call `navigator.credentials.get()` with the `identity` option to make a request for users to sign in to the RP via an identity provider (IdP), using identity federation. A typical request would look like this: ```js async function signIn() { const identityCredential = await navigator.credentials.get({ identity: { providers: [ { configURL: "https://accounts.idp.example/config.json", clientId: "********", nonce: "******", }, ], }, }); console.log(identityCredential.token); } ``` A successful {{domxref("CredentialsContainer.get", "navigator.credentials.get()")}} call that includes an `identity` option fulfills with an `IdentityCredential` instance, which can be used to access the token used to validate the sign-in. Check out [Federated Credential Management API (FedCM)](/en-US/docs/Web/API/FedCM_API) for more details on how this works. This call will start off the sign-in flow described in [FedCM sign-in flow](/en-US/docs/Web/API/FedCM_API/RP_sign-in#fedcm_sign-in_flow). ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - [Federated Credential Management API](https://developer.chrome.com/docs/privacy-sandbox/fedcm/)
0
data/mdn-content/files/en-us/web/api/identitycredential
data/mdn-content/files/en-us/web/api/identitycredential/isautoselected/index.md
--- title: "IdentityCredential: isAutoSelected property" short-title: isAutoSelected slug: Web/API/IdentityCredential/isAutoSelected page-type: web-api-instance-property status: - experimental - non-standard browser-compat: api.IdentityCredential.isAutoSelected --- {{securecontext_header}}{{APIRef("FedCM API")}}{{SeeCompatTable}}{{non-standard_header}} The **`isAutoSelected`** read-only property of the {{domxref("IdentityCredential")}} interface indicates whether the federated sign-in flow was carried out using [auto-reauthentication](/en-US/docs/Web/API/FedCM_API/RP_sign-in#auto-reauthentication) (i.e. without user mediation) or not. Automatic reauthentication can occur when a {{domxref("CredentialsContainer.get", "navigator.credentials.get()")}} call is issued with a [`mediation`](/en-US/docs/Web/API/CredentialsContainer/get#mediation) option value of `"optional"` or `"silent"`. It is useful for a relying party (RP) to know whether auto reauthentication occurred for analytics/performance evaluation and for UX purposes — automatic sign-in may warrant a different UI flow to non-automatic sign-in. ## Value A boolean value. `true` indicates that automatic reauthentication was used; `false` indicates that it was not. ## Examples RPs can call `navigator.credentials.get()` with the `identity` option to make a request for users to sign in to the RP via an identity provider (IdP), using identity federation. Auto-reauthentication behavior is controlled by the [`mediation`](/en-US/docs/Web/API/CredentialsContainer/get#mediation) option in the `get()` call: ```js async function signIn() { const identityCredential = await navigator.credentials.get({ identity: { providers: [ { configURL: "https://accounts.idp.example/config.json", clientId: "********", }, ], }, mediation: "optional", // this is the default }); // isAutoSelected is true if auto-reauthentication occurred. const isAutoSelected = identityCredential.isAutoSelected; } ``` Check out [Federated Credential Management API (FedCM)](/en-US/docs/Web/API/FedCM_API) for more details on how this works. This call will start off the sign-in flow described in [FedCM sign-in flow](/en-US/docs/Web/API/FedCM_API/RP_sign-in#fedcm_sign-in_flow). ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - [Federated Credential Management API](https://developer.chrome.com/docs/privacy-sandbox/fedcm/)
0
data/mdn-content/files/en-us/web/api
data/mdn-content/files/en-us/web/api/geolocationposition/index.md
--- title: GeolocationPosition slug: Web/API/GeolocationPosition page-type: web-api-interface browser-compat: api.GeolocationPosition --- {{securecontext_header}}{{APIRef("Geolocation API")}} The **`GeolocationPosition`** interface represents the position of the concerned device at a given time. The position, represented by a {{domxref("GeolocationCoordinates")}} object, comprehends the 2D position of the device, on a spheroid representing the Earth, but also its altitude and its speed. ## Instance properties _The `GeolocationPosition` interface doesn't inherit any properties._ - {{domxref("GeolocationPosition.coords")}} {{ReadOnlyInline}} - : Returns a {{domxref("GeolocationCoordinates")}} object defining the current location. - {{domxref("GeolocationPosition.timestamp")}} {{ReadOnlyInline}} - : Returns a timestamp, given as {{Glossary("Unix time")}} in milliseconds, representing the time at which the location was retrieved. ## Instance methods _The `GeolocationPosition` interface neither implements, nor inherits any methods._ ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - [Using the Geolocation API](/en-US/docs/Web/API/Geolocation_API/Using_the_Geolocation_API) - {{domxref("Geolocation")}}
0
data/mdn-content/files/en-us/web/api/geolocationposition
data/mdn-content/files/en-us/web/api/geolocationposition/coords/index.md
--- title: "GeolocationPosition: coords property" short-title: coords slug: Web/API/GeolocationPosition/coords page-type: web-api-instance-property browser-compat: api.GeolocationPosition.coords --- {{securecontext_header}}{{APIRef("Geolocation API")}} The **`coords`** read-only property of the {{domxref("GeolocationPosition")}} interface returns a {{domxref("GeolocationCoordinates")}} object representing a geographic position. It contains the location, that is longitude and latitude on the Earth, the altitude, and the speed of the object concerned, regrouped inside the returned value. It also contains accuracy information about these values. ## Value A {{domxref("GeolocationCoordinates")}} object instance. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - [Using the Geolocation API](/en-US/docs/Web/API/Geolocation_API/Using_the_Geolocation_API) - {{domxref("GeolocationPosition")}}
0
data/mdn-content/files/en-us/web/api/geolocationposition
data/mdn-content/files/en-us/web/api/geolocationposition/timestamp/index.md
--- title: "GeolocationPosition: timestamp property" short-title: timestamp slug: Web/API/GeolocationPosition/timestamp page-type: web-api-instance-property browser-compat: api.GeolocationPosition.timestamp --- {{securecontext_header}}{{APIRef("Geolocation API")}} The **`timestamp`** read-only property of the {{domxref("GeolocationPosition")}} interface represents the date and time that the position was acquired by the device. ## Value A number containing a timestamp, given as {{Glossary("Unix time")}} in milliseconds. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - [Using the Geolocation API](/en-US/docs/Web/API/Geolocation_API/Using_the_Geolocation_API) - {{domxref("GeolocationPosition")}}
0
data/mdn-content/files/en-us/web/api
data/mdn-content/files/en-us/web/api/permissionstatus/index.md
--- title: PermissionStatus slug: Web/API/PermissionStatus page-type: web-api-interface browser-compat: api.PermissionStatus --- {{APIRef("Permissions API")}} {{AvailableInWorkers}} The **`PermissionStatus`** interface of the [Permissions API](/en-US/docs/Web/API/Permissions_API) provides the state of an object and an event handler for monitoring changes to said state. {{InheritanceDiagram}} ## Instance properties - {{domxref("PermissionStatus.name")}} {{ReadOnlyInline}} - : Returns the name of a requested permission, identical to the `name` passed to {{domxref("Permissions.query")}}. - {{domxref("PermissionStatus.state")}} {{ReadOnlyInline}} - : Returns the state of a requested permission; one of `'granted'`, `'denied'`, or `'prompt'`. - `PermissionStatus.status` {{ReadOnlyInline}} {{deprecated_inline}} - : Returns the state of a requested permission; one of `'granted'`, `'denied'`, or `'prompt'`. Later versions of the specification replace this with {{domxref("PermissionStatus.state")}}. ### Events - {{domxref("PermissionStatus.change_event", "change")}} - : Invoked upon changes to `PermissionStatus.state`, or the deprecated `PermissionStatus.status` in the case of older browsers. ## Example ```js navigator.permissions .query({ name: "geolocation" }) .then((permissionStatus) => { console.log(`geolocation permission status is ${permissionStatus.state}`); permissionStatus.onchange = () => { console.log( `geolocation permission status has changed to ${permissionStatus.state}`, ); }; }); ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/permissionstatus
data/mdn-content/files/en-us/web/api/permissionstatus/name/index.md
--- title: "PermissionStatus: name property" short-title: name slug: Web/API/PermissionStatus/name page-type: web-api-instance-property browser-compat: api.PermissionStatus.name --- {{APIRef("Permissions API")}} The **`name`** read-only property of the {{domxref("PermissionStatus")}} interface returns the name of a requested permission. ## Value A read-only value that is identical to the `name` argument passed to {{domxref("Permissions.query", "navigator.permissions.query()")}}. ## Examples ```js function stateChangeListener() { console.log(`${this.name} permission status changed to ${this.state}`); } function queryAndTrackPermission(permissionName) { navigator.permissions .query({ name: permissionName }) .then((permissionStatus) => { console.log( `${permissionName} permission state is ${permissionStatus.state}`, ); permissionStatus.onchange = stateChangeListener; }); } queryAndTrackPermission("geolocation"); queryAndTrackPermission("midi"); ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/permissionstatus
data/mdn-content/files/en-us/web/api/permissionstatus/state/index.md
--- title: "PermissionStatus: state property" short-title: state slug: Web/API/PermissionStatus/state page-type: web-api-instance-property browser-compat: api.PermissionStatus.state --- {{APIRef("Permissions API")}} The **`state`** read-only property of the {{domxref("PermissionStatus")}} interface returns the state of a requested permission. This property returns one of `'granted'`, `'denied'`, or `'prompt'`. ## Value One of the following: - `'granted'` - `'denied'` - `'prompt'` ## Examples ```js navigator.permissions .query({ name: "geolocation" }) .then((permissionStatus) => { console.log(`geolocation permission state is ${permissionStatus.state}`); permissionStatus.onchange = () => { console.log( `geolocation permission status has changed to ${permissionStatus.state}`, ); }; }); ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/permissionstatus
data/mdn-content/files/en-us/web/api/permissionstatus/change_event/index.md
--- title: "PermissionStatus: change event" short-title: change slug: Web/API/PermissionStatus/change_event page-type: web-api-event browser-compat: api.PermissionStatus.change_event --- {{APIRef("Permissions API")}} The **`change`** event of the {{domxref("PermissionStatus")}} interface fires whenever the {{domxref("PermissionStatus.state")}} property changes. ## Syntax Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property. ```js addEventListener("change", (event) => {}); onchange = (event) => {}; ``` ## Event type A generic {{domxref("Event")}}. ## Example ```js navigator.permissions .query({ name: "geolocation" }) .then((permissionStatus) => { console.log(`geolocation permission state is ${permissionStatus.state}`); permissionStatus.onchange = () => { console.log( `geolocation permission state has changed to ${permissionStatus.state}`, ); }; }); ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api
data/mdn-content/files/en-us/web/api/mediakeysystemaccess/index.md
--- title: MediaKeySystemAccess slug: Web/API/MediaKeySystemAccess page-type: web-api-interface browser-compat: api.MediaKeySystemAccess --- {{APIRef("EncryptedMediaExtensions")}}{{SecureContext_Header}} The **`MediaKeySystemAccess`** interface of the [Encrypted Media Extensions API](/en-US/docs/Web/API/Encrypted_Media_Extensions_API) provides access to a Key System for decryption and/or a content protection provider. You can request an instance of this object using the {{domxref("Navigator.requestMediaKeySystemAccess","Navigator.requestMediaKeySystemAccess()")}} method. ## Instance properties - {{domxref("MediaKeySystemAccess.keySystem")}} {{ReadOnlyInline}} - : Returns a string identifying the key system being used. ## Instance methods - {{domxref("MediaKeySystemAccess.createMediaKeys()")}} - : Returns a {{jsxref('Promise')}} that resolves to a new {{domxref("MediaKeys")}} object. - {{domxref("MediaKeySystemAccess.getConfiguration()")}} - : Returns an object with the supported combination of configuration options. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/mediakeysystemaccess
data/mdn-content/files/en-us/web/api/mediakeysystemaccess/createmediakeys/index.md
--- title: "MediaKeySystemAccess: createMediaKeys() method" short-title: createMediaKeys() slug: Web/API/MediaKeySystemAccess/createMediaKeys page-type: web-api-instance-method browser-compat: api.MediaKeySystemAccess.createMediaKeys --- {{APIRef("EncryptedMediaExtensions")}}{{SecureContext_Header}} The `MediaKeySystemAccess.createMediaKeys()` method returns a {{jsxref('Promise')}} that resolves to a new {{domxref('MediaKeys')}} object. ## Syntax ```js-nolint createMediaKeys() ``` ### Parameters None. ### Return value A {{jsxref('Promise')}}. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/mediakeysystemaccess
data/mdn-content/files/en-us/web/api/mediakeysystemaccess/getconfiguration/index.md
--- title: "MediaKeySystemAccess: getConfiguration() method" short-title: getConfiguration() slug: Web/API/MediaKeySystemAccess/getConfiguration page-type: web-api-instance-method browser-compat: api.MediaKeySystemAccess.getConfiguration --- {{APIRef("EncryptedMediaExtensions")}}{{SecureContext_Header}} The `MediaKeySystemAccess.getConfiguration()` method returns an object with the supported combination of the following configuration options: - `initDataTypes` {{ReadOnlyInline}} - : Returns a list of supported initialization data type names. An initialization data type is a string indicating the format of the initialization data. - `audioCapabilities` {{ReadOnlyInline}} - : Returns a list of supported audio type and capability pairs. - `videoCapabilities` {{ReadOnlyInline}} - : Returns a list of supported video type and capability pairs. - `distinctiveIdentifier` {{ReadOnlyInline}} - : Indicates whether a persistent distinctive identifier is required. - `persistentState` {{ReadOnlyInline}} - : Indicates whether the ability to persist state is required. ## Syntax ```js-nolint getConfiguration() ``` ### Parameters None. ### Return value An object. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/mediakeysystemaccess
data/mdn-content/files/en-us/web/api/mediakeysystemaccess/keysystem/index.md
--- title: "MediaKeySystemAccess: keySystem property" short-title: keySystem slug: Web/API/MediaKeySystemAccess/keySystem page-type: web-api-instance-property browser-compat: api.MediaKeySystemAccess.keySystem --- {{APIRef("EncryptedMediaExtensions")}}{{SecureContext_Header}} The `MediaKeySystemAccess.keySystem` read-only property returns a string identifying the key system being used. ## Value A string. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api
data/mdn-content/files/en-us/web/api/resizeobserversize/index.md
--- title: ResizeObserverSize slug: Web/API/ResizeObserverSize page-type: web-api-interface browser-compat: api.ResizeObserverSize --- {{DefaultAPISidebar("Resize Observer API")}} The **`ResizeObserverSize`** interface of the {{domxref('Resize Observer API')}} is used by the {{domxref("ResizeObserverEntry")}} interface to access the box sizing properties of the element being observed. > **Note:** In [multi-column layout](/en-US/docs/Web/CSS/CSS_multicol_layout), which is a fragmented context, the sizing returned by `ResizeObserverSize` will be the size of the first column. ## Instance properties - {{domxref("ResizeObserverSize.blockSize")}} {{ReadOnlyInline}} - : The length of the observed element's border box in the block dimension. For boxes with a horizontal {{cssxref("writing-mode")}}, this is the vertical dimension, or height; if the writing-mode is vertical, this is the horizontal dimension, or width. - {{domxref("ResizeObserverSize.inlineSize")}} {{ReadOnlyInline}} - : The length of the observed element's border box in the inline dimension. For boxes with a horizontal {{cssxref("writing-mode")}}, this is the horizontal dimension, or width; if the writing-mode is vertical, this is the vertical dimension, or height. > **Note:** For more explanation of writing modes and block and inline dimensions, read [Handling different text directions](/en-US/docs/Learn/CSS/Building_blocks/Handling_different_text_directions). ## Examples In this example the {{domxref("ResizeObserverEntry.contentBoxSize")}} property returns a `ResizeObserverSize` object. This is an array containing the sizing information for the content box of the observed element. ```js const resizeObserver = new ResizeObserver((entries) => { for (const entry of entries) { console.log(entry.contentBoxSize[0]); // a ResizeObserverSize } }); resizeObserver.observe(divElem); ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/resizeobserversize
data/mdn-content/files/en-us/web/api/resizeobserversize/blocksize/index.md
--- title: "ResizeObserverSize: blockSize property" short-title: blockSize slug: Web/API/ResizeObserverSize/blockSize page-type: web-api-instance-property browser-compat: api.ResizeObserverSize.blockSize --- {{DefaultAPISidebar("Resize Observer API")}} The **`blockSize`** read-only property of the {{domxref("ResizeObserverSize")}} interface returns the length of the observed element's border box in the block dimension. For boxes with a horizontal {{cssxref("writing-mode")}}, this is the vertical dimension, or height; if the writing-mode is vertical, this is the horizontal dimension, or width. > **Note:** For more explanation of writing modes and block and inline dimensions, read [Handling different text directions](/en-US/docs/Learn/CSS/Building_blocks/Handling_different_text_directions). ## Value A decimal representing the block size in pixels. ## Examples In this example we return an array of sizing information with {{domxref("ResizeObserverEntry.contentBoxSize")}}. The `blockSize` property returns the block dimension size of the observed element. ```js const resizeObserver = new ResizeObserver((entries) => { for (const entry of entries) { const elemSize = entry.contentBoxSize[0]; console.log(elemSize.blockSize); // a decimal } }); resizeObserver.observe(divElem); ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/resizeobserversize
data/mdn-content/files/en-us/web/api/resizeobserversize/inlinesize/index.md
--- title: "ResizeObserverSize: inlineSize property" short-title: inlineSize slug: Web/API/ResizeObserverSize/inlineSize page-type: web-api-instance-property browser-compat: api.ResizeObserverSize.inlineSize --- {{DefaultAPISidebar("Resize Observer API")}} The **`inlineSize`** read-only property of the {{domxref("ResizeObserverSize")}} interface returns the length of the observed element's border box in the inline dimension. For boxes with a horizontal {{cssxref("writing-mode")}}, this is the horizontal dimension, or width; if the writing-mode is vertical, this is the vertical dimension, or height. > **Note:** For more explanation of writing modes and block and inline dimensions, read [Handling different text directions](/en-US/docs/Learn/CSS/Building_blocks/Handling_different_text_directions). ## Value A decimal representing the inline size in pixels. ## Examples In this example we return an array of sizing information with {{domxref("ResizeObserverEntry.contentBoxSize")}}. The `inlineSize` property returns the inline dimension size of the observed element. ```js const resizeObserver = new ResizeObserver((entries) => { for (const entry of entries) { const elemSize = entry.contentBoxSize[0]; console.log(elemSize.inlineSize); // a decimal } }); resizeObserver.observe(divElem); ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api
data/mdn-content/files/en-us/web/api/highlightregistry/index.md
--- title: HighlightRegistry slug: Web/API/HighlightRegistry page-type: web-api-interface browser-compat: api.HighlightRegistry --- {{APIRef("CSS Custom Highlight API")}} The **`HighlightRegistry`** interface of the [CSS Custom Highlight API](/en-US/docs/Web/API/CSS_Custom_Highlight_API) is used to register {{domxref("Highlight")}} objects to be styled using the API. It is accessed via {{domxref("CSS.highlights_static", "CSS.highlights")}}. A `HighlightRegistry` instance is a [`Map`-like object](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#map-like_browser_apis), in which each key is the name string for a custom highlight, and the corresponding value is the associated {{domxref("Highlight")}} object. {{InheritanceDiagram}} ## Instance properties _The `HighlightRegistry` interface doesn't inherit any properties._ - {{domxref("HighlightRegistry.size")}} {{ReadOnlyInline}} - : Returns the number of `Highlight` objects currently registered. ## Instance methods _The `HighlightRegistry` interface doesn't inherit any methods_. - {{domxref("HighlightRegistry.clear()")}} - : Remove all `Highlight` objects from the registry. - {{domxref("HighlightRegistry.delete()")}} - : Remove the named `Highlight` object from the registry. - {{domxref("HighlightRegistry.entries()")}} - : Returns a new iterator object that contains each `Highlight` object in the registry, in insertion order. - {{domxref("HighlightRegistry.forEach()")}} - : Calls the given callback once for each `Highlight` object in the registry, in insertion order. - {{domxref("HighlightRegistry.get()")}} - : Gets the named `Highlight` object from the registry. - {{domxref("HighlightRegistry.has()")}} - : Returns a boolean asserting whether a `Highlight` object is present the registry or not. - {{domxref("HighlightRegistry.keys()")}} - : An alias for {{domxref("HighlightRegistry.values()")}}. - {{domxref("HighlightRegistry.set()")}} - : Adds the given `Highlight` object to the registry with the given name, or updates the named `Highlight` object, if it already exists in the registry. - {{domxref("HighlightRegistry.values()")}} - : Returns a new iterator object that yields the `Highlight` objects in the registry, in insertion order. ## Examples ### Registering a highlight The following example demonstrates how to create ranges, instantiate a new `Highlight` object for them, and register the highlight using the `HighlightRegistry`, to style it on the page: #### HTML ```html <p id="foo">CSS Custom Highlight API</p> ``` #### CSS ```css ::highlight(my-custom-highlight) { background-color: peachpuff; } ``` #### JavaScript ```js const text = document.getElementById("foo").firstChild; if (!CSS.highlights) { text.textContent = "The CSS Custom Highlight API is not supported in this browser!"; } // Create a couple of ranges. const range1 = new Range(); range1.setStart(text, 0); range1.setEnd(text, 3); const range2 = new Range(); range2.setStart(text, 21); range2.setEnd(text, 24); // Create a custom highlight for these ranges. const highlight = new Highlight(range1, range2); // Register the ranges in the HighlightRegistry. CSS.highlights.set("my-custom-highlight", highlight); ``` #### Result {{ EmbedLiveSample("Registering a highlight") }} ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("css_custom_highlight_api", "The CSS Custom Highlight API", "", "nocode")}} - [CSS Custom Highlight API: The Future of Highlighting Text Ranges on the Web](https://css-tricks.com/css-custom-highlight-api-early-look/)
0
data/mdn-content/files/en-us/web/api/highlightregistry
data/mdn-content/files/en-us/web/api/highlightregistry/get/index.md
--- title: "HighlightRegistry: get() method" short-title: get() slug: Web/API/HighlightRegistry/get page-type: web-api-instance-method browser-compat: api.HighlightRegistry.get spec-urls: https://tc39.es/ecma262/multipage/keyed-collections.html#sec-map.prototype.get --- {{APIRef("CSS Custom Highlight API")}} The **`get()`** method of the {{domxref("HighlightRegistry")}} interface returns the named {{domxref("Highlight")}} object from the registry. `HighlightRegistry` is a {{jsxref("Map")}}-like object, so this is similar to using {{jsxref("Map.get()")}}. ## Syntax ```js-nolint get(name) ``` ### Parameters - `name` - : The name of the `Highlight` object to return from the registry. The name must be a {{jsxref("String")}}. ### Return value The `Highlight` object associated with the specified name, or {{jsxref("undefined")}} if the name can't be found in the `HighlightRegistry`. ## Examples The following code sample demonstrates how to create a new `Highlight`, add it to the registry, and retrieve it by its name using the `get()` method: ```js const fooHighlight = new Highlight(); CSS.highlights.set("foo", fooHighlight); console.log(CSS.highlights.get("foo")); // Returns the fooHighlight object. ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("css_custom_highlight_api", "The CSS Custom Highlight API", "", "nocode")}} - [CSS Custom Highlight API: The Future of Highlighting Text Ranges on the Web](https://css-tricks.com/css-custom-highlight-api-early-look/)
0
data/mdn-content/files/en-us/web/api/highlightregistry
data/mdn-content/files/en-us/web/api/highlightregistry/has/index.md
--- title: "HighlightRegistry: has() method" short-title: has() slug: Web/API/HighlightRegistry/has page-type: web-api-instance-method browser-compat: api.HighlightRegistry.has spec-urls: https://tc39.es/ecma262/multipage/keyed-collections.html#sec-map.prototype.has --- {{APIRef("CSS Custom Highlight API")}} The **`has()`** method of the {{domxref("HighlightRegistry")}} interface returns a boolean indicating whether or not a {{domxref("Highlight")}} object with the specified name exists in the registry. `HighlightRegistry` is a {{jsxref("Map")}}-like object, so this is similar to using {{jsxref("Map.has()")}}. ## Syntax ```js-nolint has(name) ``` ### Parameters - `name` - : The name of the `Highlight` object to test for presence in the registry. ### Return value Returns `true` if a highlight with the specified name exists in the registry; otherwise `false`. ## Examples ```js const fooHighlight = new Highlight(); CSS.highlights.set("foo", fooHighlight); myHighlight.has("foo"); // true myHighlight.has("bar"); // false ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("css_custom_highlight_api", "The CSS Custom Highlight API", "", "nocode")}} - [CSS Custom Highlight API: The Future of Highlighting Text Ranges on the Web](https://css-tricks.com/css-custom-highlight-api-early-look/)
0
data/mdn-content/files/en-us/web/api/highlightregistry
data/mdn-content/files/en-us/web/api/highlightregistry/set/index.md
--- title: "HighlightRegistry: set() method" short-title: set() slug: Web/API/HighlightRegistry/set page-type: web-api-instance-method browser-compat: api.HighlightRegistry.set spec-urls: https://tc39.es/ecma262/multipage/keyed-collections.html#sec-map.prototype.set --- {{APIRef("CSS Custom Highlight API")}} The **`set()`** method of the {{domxref("HighlightRegistry")}} interface adds or updates a {{domxref("Highlight")}} object in the registry with the specified name. `HighlightRegistry` is a {{jsxref("Map")}}-like object, so this is similar to using {{jsxref("Map.set()")}}. ## Syntax ```js-nolint set(name, highlight) ``` ### Parameters - `name` - : The name of the `Highlight` object to add or update. The name must be a {{jsxref("String")}}. - `highlight` - : The `Highlight` object to add or update. This must be a {{domxref("Highlight")}} interface instance. ### Return value The `HighlightRegistry` object. ## Examples ### Using set() ```js const fooHighlight = new Highlight(); CSS.highlights.set("foo", fooHighlight); ``` ### Using set() with chaining Since the `set()` method returns back the registry, you can chain the method call like below: ```js const fooHighlight = new Highlight(); const barHighlight = new Highlight(); const bazHighlight = new Highlight(); CSS.highlights .set("foo", fooHighlight) .set("bar", barHighlight) .set("baz", bazHighlight); ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("css_custom_highlight_api", "The CSS Custom Highlight API", "", "nocode")}} - [CSS Custom Highlight API: The Future of Highlighting Text Ranges on the Web](https://css-tricks.com/css-custom-highlight-api-early-look/)
0
data/mdn-content/files/en-us/web/api/highlightregistry
data/mdn-content/files/en-us/web/api/highlightregistry/keys/index.md
--- title: "HighlightRegistry: keys() method" short-title: keys() slug: Web/API/HighlightRegistry/keys page-type: web-api-instance-method browser-compat: api.HighlightRegistry.keys spec-urls: https://tc39.es/ecma262/multipage/keyed-collections.html#sec-map.prototype.keys --- {{APIRef("CSS Custom Highlight API")}} The **`keys()`** method of the {{domxref("HighlightRegistry")}} interface returns a new [Iterator](/en-US/docs/Web/JavaScript/Guide/Iterators_and_generators) object that contains the keys for each `Highlight` object in the `HighlightRegistry` object in insertion order. `HighlightRegistry` is a {{jsxref("Map")}}-like object, so this is similar to using {{jsxref("Map.keys()")}}. ## Syntax ```js-nolint keys() ``` ### Return value A new iterator object containing the names of each `Highlight` object in the registry, in insertion order. ## Examples The following code snippet shows how to create and register three `Highlight` objects, and use the iterator returned by the `keys()` method to log their names: ```js const fooHighlight = new Highlight(); const barHighlight = new Highlight(); const bazHighlight = new Highlight(); CSS.highlights.set("foo", fooHighlight); CSS.highlights.set("bar", barHighlight); CSS.highlights.set("baz", bazHighlight); const iter = CSS.highlights.keys(); console.log(iter.next().value); // "foo" console.log(iter.next().value); // "bar" console.log(iter.next().value); // "baz" ``` The following code example shows how to iterate over the highlights in the registry by using a [`for...of`](/en-US/docs/Web/JavaScript/Reference/Statements/for...of) loop: ```js const fooHighlight = new Highlight(); const barHighlight = new Highlight(); const bazHighlight = new Highlight(); CSS.highlights.set("foo", fooHighlight); CSS.highlights.set("bar", barHighlight); CSS.highlights.set("baz", bazHighlight); for (const name of CSS.highlights.keys()) { console.log(name); } ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("css_custom_highlight_api", "The CSS Custom Highlight API", "", "nocode")}} - [CSS Custom Highlight API: The Future of Highlighting Text Ranges on the Web](https://css-tricks.com/css-custom-highlight-api-early-look/)
0
data/mdn-content/files/en-us/web/api/highlightregistry
data/mdn-content/files/en-us/web/api/highlightregistry/clear/index.md
--- title: "HighlightRegistry: clear() method" short-title: clear() slug: Web/API/HighlightRegistry/clear page-type: web-api-instance-method browser-compat: api.HighlightRegistry.clear spec-urls: https://tc39.es/ecma262/multipage/keyed-collections.html#sec-map.prototype.clear --- {{APIRef("CSS Custom Highlight API")}} The **`clear()`** method of the {{domxref("HighlightRegistry")}} interface removes all the {{domxref("Highlight")}} objects registered in the `HighlightRegistry`. `HighlightRegistry` is a {{jsxref("Map")}}-like object, so this is similar to using {{jsxref("Map.clear()")}}. ## Syntax ```js-nolint clear() ``` ### Return value None ({{jsxref("undefined")}}). ## Examples The code snippet below registers two highlight objects in the registry and then clears the registry: ```js const customHighlight1 = new Highlight(range1, range2); const customHighlight2 = new Highlight(range3, range4, range5); CSS.highlights.set("custom-highlight-1", customHighlight1); CSS.highlights.set("custom-highlight-2", customHighlight2); console.log(CSS.highlights.size); // 2 CSS.highlights.clear(); console.log(CSS.highlights.size); // 0 ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("css_custom_highlight_api", "The CSS Custom Highlight API", "", "nocode")}} - [CSS Custom Highlight API: The Future of Highlighting Text Ranges on the Web](https://css-tricks.com/css-custom-highlight-api-early-look/)
0
data/mdn-content/files/en-us/web/api/highlightregistry
data/mdn-content/files/en-us/web/api/highlightregistry/size/index.md
--- title: "HighlightRegistry: size property" short-title: size slug: Web/API/HighlightRegistry/size page-type: web-api-instance-property browser-compat: api.HighlightRegistry.size spec-urls: https://tc39.es/ecma262/multipage/keyed-collections.html#sec-get-map.prototype.size --- {{APIRef("CSS Custom Highlight API")}} The **`size`** property returns the number of {{domxref("Highlight")}} objects in the {{domxref("HighlightRegistry")}}. ## Value A read-only integer indicating how many `Highlight` objects the registry contains. ## Examples ### Using size ```js const highlight1 = new Highlight(); const highlight2 = new Highlight(); CSS.highlights.set("highlight-1", highlight1); CSS.highlights.set("highlight-2", highlight2); console.log(CSS.highlights.size); // 2 ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("css_custom_highlight_api", "The CSS Custom Highlight API", "", "nocode")}} - [CSS Custom Highlight API: The Future of Highlighting Text Ranges on the Web](https://css-tricks.com/css-custom-highlight-api-early-look/)
0
data/mdn-content/files/en-us/web/api/highlightregistry
data/mdn-content/files/en-us/web/api/highlightregistry/values/index.md
--- title: "HighlightRegistry: values() method" short-title: values() slug: Web/API/HighlightRegistry/values page-type: web-api-instance-method browser-compat: api.HighlightRegistry.values spec-urls: https://tc39.es/ecma262/multipage/keyed-collections.html#sec-map.prototype.values --- {{APIRef("CSS Custom Highlight API")}} The **`values()`** method of the {{domxref("HighlightRegistry")}} interface returns a new [Iterator](/en-US/docs/Web/JavaScript/Guide/Iterators_and_generators) object that contains the values for each `Highlight` object in the `HighlightRegistry` object in insertion order. `HighlightRegistry` is a {{jsxref("Map")}}-like object, so this is similar to using {{jsxref("Map.values()")}}. ## Syntax ```js-nolint values() ``` ### Return value A new iterator object containing each `Highlight` object in the registry, in insertion order. ## Examples The following code snippet shows how to create and register three `Highlight` objects, and use the iterator returned by the `values()` method to log the highlights: ```js const fooHighlight = new Highlight(); const barHighlight = new Highlight(); const bazHighlight = new Highlight(); CSS.highlights.set("foo", fooHighlight); CSS.highlights.set("bar", barHighlight); CSS.highlights.set("baz", bazHighlight); const iter = CSS.highlights.values(); console.log(iter.next().value); // Highlight console.log(iter.next().value); // Highlight console.log(iter.next().value); // Highlight ``` The following code example shows how to iterate over the highlights in the registry by using a [`for...of`](/en-US/docs/Web/JavaScript/Reference/Statements/for...of) loop: ```js const fooHighlight = new Highlight(); const barHighlight = new Highlight(); const bazHighlight = new Highlight(); CSS.highlights.set("foo", fooHighlight); CSS.highlights.set("bar", barHighlight); CSS.highlights.set("baz", bazHighlight); for (const highlight of CSS.highlights.values()) { console.log(highlight); // Highlight } ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("css_custom_highlight_api", "The CSS Custom Highlight API", "", "nocode")}} - [CSS Custom Highlight API: The Future of Highlighting Text Ranges on the Web](https://css-tricks.com/css-custom-highlight-api-early-look/)
0
data/mdn-content/files/en-us/web/api/highlightregistry
data/mdn-content/files/en-us/web/api/highlightregistry/delete/index.md
--- title: "HighlightRegistry: delete() method" short-title: delete() slug: Web/API/HighlightRegistry/delete page-type: web-api-instance-method browser-compat: api.HighlightRegistry.delete spec-urls: https://tc39.es/ecma262/multipage/keyed-collections.html#sec-map.prototype.delete --- {{APIRef("CSS Custom Highlight API")}} The **`delete()`** method of the {{domxref("HighlightRegistry")}} interface removes a the named {{domxref("Highlight")}} object from the `HighlightRegistry`. `HighlightRegistry` is a {{jsxref("Map")}}-like object, so this is similar to using {{jsxref("Map.delete()")}}. ## Syntax ```js-nolint delete(customHighlightName) ``` ### Parameters - `customHighlightName` - : The name, as a {{jsxref("String")}}, of the {{domxref("Highlight")}} object to remove from the `HighlightRegistry`. ### Return value Returns `true` if a `Highlight` object under the provided name was in the `HighlightRegistry`; otherwise `false`. ## Examples The following code sample registers a highlight in the registry, and then deletes it: ```js const myHighlight = new Highlight(range1, range2); CSS.highlights.set("my-highlight", myHighlight); CSS.highlights.delete("foo"); // false CSS.highlights.delete("my-highlight"); // true ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("css_custom_highlight_api", "The CSS Custom Highlight API", "", "nocode")}} - [CSS Custom Highlight API: The Future of Highlighting Text Ranges on the Web](https://css-tricks.com/css-custom-highlight-api-early-look/)
0
data/mdn-content/files/en-us/web/api/highlightregistry
data/mdn-content/files/en-us/web/api/highlightregistry/foreach/index.md
--- title: "HighlightRegistry: forEach() method" short-title: forEach() slug: Web/API/HighlightRegistry/forEach page-type: web-api-instance-method browser-compat: api.HighlightRegistry.forEach spec-urls: https://tc39.es/ecma262/multipage/keyed-collections.html#sec-map.prototype.foreach --- {{APIRef("CSS Custom Highlight API")}} The **`forEach()`** method of the {{domxref("HighlightRegistry")}} interface executes a provided function once for each {{domxref("Highlight")}} object in the registry, in insertion order. `HighlightRegistry` is a {{jsxref("Map")}}-like object, so this is similar to using {{jsxref("Map.forEach()")}}. ## Syntax ```js-nolint forEach(callbackFn) forEach(callbackFn, thisArg) ``` ### Parameters - `callback` - : Function to execute for each `Highlight` object, taking three arguments: - `highlight` - : The current highlight. - `name` - : The highlight name. - `registry` - : The registry object which `forEach()` was called upon. - `thisArg` - : Value to use as `this` when executing `callbackFn`. ### Return value None ({{jsxref("undefined")}}). ## Examples The code snippet below shows how create a new highlight with two ranges, and then log the ranges by using the `forEach()` method: ```js function logAllHighlights(highlight, name) { console.log(`Highlight ${name} exists in the registry`, highlight); } const customHighlight1 = new Highlight(); const customHighlight2 = new Highlight(); const customHighlight3 = new Highlight(); CSS.highlights.set("custom-highlight-1", customHighlight1); CSS.highlights.set("custom-highlight-2", customHighlight2); CSS.highlights.set("custom-highlight-3", customHighlight3); CSS.highlights.forEach(logAllHighlights); ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("css_custom_highlight_api", "The CSS Custom Highlight API", "", "nocode")}} - [CSS Custom Highlight API: The Future of Highlighting Text Ranges on the Web](https://css-tricks.com/css-custom-highlight-api-early-look/)
0
data/mdn-content/files/en-us/web/api/highlightregistry
data/mdn-content/files/en-us/web/api/highlightregistry/entries/index.md
--- title: "HighlightRegistry: entries() method" short-title: entries() slug: Web/API/HighlightRegistry/entries page-type: web-api-instance-method browser-compat: api.HighlightRegistry.entries spec-urls: https://tc39.es/ecma262/multipage/keyed-collections.html#sec-map.prototype.entries --- {{APIRef("CSS Custom Highlight API")}} The **`entries()`** method of the {{domxref("HighlightRegistry")}} interface returns a new [Iterator](/en-US/docs/Web/JavaScript/Guide/Iterators_and_generators) object that contains the `[name, highlight]` pairs for each element in the `HighlightRegistry` object, in insertion order. `HighlightRegistry` is a {{jsxref("Map")}}-like object, so this is similar to using {{jsxref("Map.entries()")}}. ## Syntax ```js-nolint entries() ``` ### Return value A new iterator object that contains an array of `[name, highlight]` for each `Highlight` object in the `HighlightRegistry`, in insertion order. ## Examples The code snippet below creates and registers two new highlights, and then logs the highlights and their names by using the iterator returned by the `entries()` method: ```js const myHighlight1 = new Highlight(); const myHighlight2 = new Highlight(); CSS.highlights.set("first-highlight", myHighlight1); CSS.highlights.set("second-highlight", myHighlight2); const iter = CSS.highlights.entries(); console.log(iter.next().value); // ['first-highlight', Highlight] console.log(iter.next().value); // ['second-highlight', Highlight] ``` The following code example shows how to iterate over the highlights in the registry by using a [`for...of`](/en-US/docs/Web/JavaScript/Reference/Statements/for...of) loop: ```js const myHighlight1 = new Highlight(); const myHighlight2 = new Highlight(); CSS.highlights.set("first-highlight", myHighlight1); CSS.highlights.set("second-highlight", myHighlight2); for (const [name, highlight] of CSS.highlights.entries()) { console.log(`Highlight ${name}`, highlight); } ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("css_custom_highlight_api", "The CSS Custom Highlight API", "", "nocode")}} - [CSS Custom Highlight API: The Future of Highlighting Text Ranges on the Web](https://css-tricks.com/css-custom-highlight-api-early-look/)
0
data/mdn-content/files/en-us/web/api
data/mdn-content/files/en-us/web/api/htmlscriptelement/index.md
--- title: HTMLScriptElement slug: Web/API/HTMLScriptElement page-type: web-api-interface browser-compat: api.HTMLScriptElement --- {{APIRef("HTML DOM")}} HTML {{HTMLElement("script")}} elements expose the **`HTMLScriptElement`** interface, which provides special properties and methods for manipulating the behavior and execution of `<script>` elements (beyond the inherited {{domxref("HTMLElement")}} interface). JavaScript files should be served with the `text/javascript` [MIME type](/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types), but browsers are lenient and block them only if the script is served with an image type (`image/*`), video type (`video/*`), audio type (`audio/*`), or `text/csv`. If the script is blocked, its element receives an {{domxref("HTMLElement/error_event", "error")}} event; otherwise, it receives a {{domxref("Window/load_event", "load")}} event. {{InheritanceDiagram}} ## Instance properties _Inherits properties from its parent, {{domxref("HTMLElement")}}._ - {{domxref("HTMLScriptElement.type")}} - : A string representing the MIME type of the script. It reflects the [`type`](/en-US/docs/Web/HTML/Element/script#type) attribute. - {{domxref("HTMLScriptElement.src")}} - : A string representing the URL of an external script. It reflects the [`src`](/en-US/docs/Web/HTML/Element/script#src) attribute. - {{domxref("HTMLScriptElement.event")}} {{deprecated_inline}} - : A string; an obsolete way of registering event handlers on elements in an HTML document. - {{domxref("HTMLScriptElement.charset")}} {{deprecated_inline}} - : A string representing the character encoding of an external script. It reflects the [`charset`](/en-US/docs/Web/HTML/Element/script#charset) attribute. - {{domxref("HTMLScriptElement.async")}}, {{domxref("HTMLScriptElement.defer")}} - : The `async` and `defer` attributes are boolean attributes that control how the script should be executed. **The `defer` and `async` attributes must not be specified if the `src` attribute is absent.** There are three possible execution modes: 1. If the `async` attribute is present, then the script will be executed asynchronously as soon as it downloads. 2. If the `async` attribute is absent but the `defer` attribute is present, then the script is executed when [the page has finished parsing](/en-US/docs/Web/API/Document/DOMContentLoaded_event). 3. If neither attribute is present, then the script is fetched and executed immediately, blocking further parsing of the page. The `defer` attribute may be specified with the `async` attribute, so legacy browsers that only support `defer` (and not `async`) fall back to the `defer` behavior instead of the default blocking behavior. > **Note:** The exact processing details for these attributes are complex, involving many different aspects of HTML, and therefore are scattered throughout the specification. [These algorithms](https://html.spec.whatwg.org/multipage/scripting.html) describe the core ideas, but they rely on the parsing rules for {{HTMLElement("script")}} [start](https://html.spec.whatwg.org/multipage/syntax.html#start-tags) and [end](https://html.spec.whatwg.org/multipage/syntax.html#end-tags) tags in HTML, [in foreign content](https://html.spec.whatwg.org/multipage/syntax.html#foreign-elements), and [in XML](https://html.spec.whatwg.org/multipage/xhtml.html); the rules for the [`document.write()`](/en-US/docs/Web/API/Document/write) method; the handling of [scripting](https://html.spec.whatwg.org/multipage/webappapis.html); and so on. - {{domxref("HTMLScriptElement.crossOrigin")}} - : A string reflecting the [CORS setting](/en-US/docs/Web/HTML/Attributes/crossorigin) for the script element. For classic scripts from other [origins](/en-US/docs/Glossary/Origin), this controls if error information will be exposed. - {{domxref("HTMLScriptElement.text")}} - : A string that joins and returns the contents of all [`Text` nodes](/en-US/docs/Web/API/Text) inside the {{HTMLElement("script")}} element (ignoring other nodes like comments) in tree order. On setting, it acts the same way as the [`textContent`](/en-US/docs/Web/API/Node/textContent) IDL attribute. > **Note:** When inserted using the [`document.write()`](/en-US/docs/Web/API/Document/write) method, {{HTMLElement("script")}} elements execute (typically synchronously), but when inserted using [`innerHTML`](/en-US/docs/Web/API/Element/innerHTML) or [`outerHTML`](/en-US/docs/Web/API/Element/outerHTML), they do not execute at all. - {{domxref("HTMLScriptElement.fetchPriority")}} - : An optional string representing a hint given to the browser on how it should prioritize fetching of an external script relative to other external scripts. If this value is provided, it must be one of the possible permitted values: `high` to fetch at a high priority, `low` to fetch at a low priority, or `auto` to indicate no preference (which is the default). - {{domxref("HTMLScriptElement.noModule")}} - : A boolean value that if true, stops the script's execution in browsers that support [ES modules](/en-US/docs/Web/JavaScript/Guide/Modules) — used to run fallback scripts in older browsers that do _not_ support JavaScript modules. - {{domxref("HTMLScriptElement.referrerPolicy")}} - : A string that reflects the [`referrerPolicy`](/en-US/docs/Web/HTML/Element/script#referrerpolicy) HTML attribute indicating which referrer to use when fetching the script, and fetches done by that script. ## Static methods - {{domxref("HTMLScriptElement.supports_static", "HTMLScriptElement.supports()")}} - : Returns `true` if the browser supports scripts of the specified type and `false` otherwise. This method provides a simple and unified method for script-related feature detection. ## Instance methods _No specific methods; inherits methods from its parent, {{domxref("HTMLElement")}}._ ## Events _No specific events; inherits events from its parent, {{domxref("HTMLElement")}}._ ## Examples ### Dynamically importing scripts Let's create a function that imports new scripts within a document creating a {{HTMLElement("script")}} node _immediately before_ the {{HTMLElement("script")}} that hosts the following code (through {{domxref("document.currentScript")}}). These scripts will be **asynchronously** executed. For more details, see the [`defer`](#defer_property) and [`async`](#async_property) properties. ```js function loadError(oError) { throw new URIError(`The script ${oError.target.src} didn't load correctly.`); } function prefixScript(url, onloadFunction) { const newScript = document.createElement("script"); newScript.onerror = loadError; if (onloadFunction) { newScript.onload = onloadFunction; } document.currentScript.parentNode.insertBefore( newScript, document.currentScript, ); newScript.src = url; } ``` This next function, instead of prepending the new scripts immediately before the {{domxref("document.currentScript")}} element, appends them as children of the {{HTMLElement("head")}} tag. ```js function loadError(oError) { throw new URIError(`The script ${oError.target.src} didn't load correctly.`); } function affixScriptToHead(url, onloadFunction) { const newScript = document.createElement("script"); newScript.onerror = loadError; if (onloadFunction) { newScript.onload = onloadFunction; } document.head.appendChild(newScript); newScript.src = url; } ``` Sample usage: ```js affixScriptToHead("myScript1.js"); affixScriptToHead("myScript2.js", () => { alert('The script "myScript2.js" has been correctly loaded.'); }); ``` ### Checking if a script type is supported {{domxref("HTMLScriptElement.supports_static", "HTMLScriptElement.supports()")}} provides a unified mechanism for checking whether a browser supports particular types of scripts. The example below shows how to check for module support, using the existence of the `noModule` attribute as a fallback. ```js function checkModuleSupport() { if ("supports" in HTMLScriptElement) { return HTMLScriptElement.supports("module"); } return "noModule" in document.createElement("script"); } ``` Classic scripts are assumed to be supported on all browsers. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - HTML {{HTMLElement("script")}} element - HTML {{HTMLElement("noscript")}} element - {{domxref("document.currentScript")}} - [Web Workers](/en-US/docs/Web/API/Web_Workers_API/Using_web_workers) (code snippets similar to scripts but executed in [another global context](/en-US/docs/Web/API/DedicatedWorkerGlobalScope))
0
data/mdn-content/files/en-us/web/api/htmlscriptelement
data/mdn-content/files/en-us/web/api/htmlscriptelement/crossorigin/index.md
--- title: "HTMLScriptElement: crossOrigin property" short-title: crossOrigin slug: Web/API/HTMLScriptElement/crossOrigin page-type: web-api-instance-property browser-compat: api.HTMLScriptElement.crossOrigin --- {{APIRef("HTML DOM")}} The **`crossOrigin`** property of the {{domxref("HTMLScriptElement")}} interface reflects the {{Glossary("CORS", "Cross-Origin Resource Sharing")}} settings for the script element. For classic scripts from other [origins](/en-US/docs/Glossary/Origin), this controls if full error information will be exposed. For module scripts, it controls the script itself and any script it imports. See [CORS settings attributes](/en-US/docs/Web/HTML/Attributes/crossorigin) for details. ## Value A string of a keyword specifying the CORS mode to use when fetching the resource. Possible values are: - `anonymous` or an empty string (`""`) - : Requests sent by the {{domxref("HTMLScriptElement")}} will use the `cors` {{domxref("Request.mode", "mode", "", "nocode")}} and the `same-origin` {{domxref("Request.credentials", "credentials", "", "nocode")}} mode. This means that CORS is enabled and credentials are sent _if_ the resource is fetched from the same origin from which the document was loaded. - `use-credentials` - : Requests sent by the {{domxref("HTMLScriptElement")}} will use the `cors` {{domxref("Request.mode", "mode", "", "nocode")}} and the `include` {{domxref("Request.credentials", "credentials", "", "nocode")}} mode. All resources requests by the element will use CORS, regardless of which domain the fetch is from. If the `crossOrigin` property is specified with any other value, it is the same as specifing it as the `anonymous`. If the `crossOrigin` property is not specified, the resource is fetched without CORS (the `no-cors` {{domxref("Request.mode", "mode", "", "nocode")}} and the `same-origin` {{domxref("Request.credentials", "credentials", "", "nocode")}} mode). ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("HTMLImageElement.crossOrigin")}} - {{domxref("HTMLLinkElement.crossOrigin")}} - {{domxref("HTMLMediaElement.crossOrigin")}}
0
data/mdn-content/files/en-us/web/api/htmlscriptelement
data/mdn-content/files/en-us/web/api/htmlscriptelement/referrerpolicy/index.md
--- title: "HTMLScriptElement: referrerPolicy property" short-title: referrerPolicy slug: Web/API/HTMLScriptElement/referrerPolicy page-type: web-api-instance-property browser-compat: api.HTMLScriptElement.referrerPolicy --- {{APIRef}} The **`referrerPolicy`** property of the {{domxref("HTMLScriptElement")}} interface reflects the HTML [`referrerpolicy`](/en-US/docs/Web/HTML/Element/script#referrerpolicy) of the {{HTMLElement("script")}} element, which defines how the referrer is set when fetching the script and any scripts it imports. ## Value A string; one of the following: - `no-referrer` - : The {{HTTPHeader("Referer")}} header will be omitted entirely. No referrer information is sent along with requests. - `no-referrer-when-downgrade` - : The URL is sent as a referrer when the protocol security level stays the same (e.g.HTTP→HTTP, HTTPS→HTTPS), but isn't sent to a less secure destination (e.g. HTTPS→HTTP). - `origin` - : Only send the origin of the document as the referrer in all cases. The document `https://example.com/page.html` will send the referrer `https://example.com/`. - `origin-when-cross-origin` - : Send a full URL when performing a same-origin request, but only send the origin of the document for other cases. - `same-origin` - : A referrer will be sent for [same-site origins](/en-US/docs/Web/Security/Same-origin_policy), but cross-origin requests will contain no referrer information. - `strict-origin` - : Only send the origin of the document as the referrer when the protocol security level stays the same (e.g. HTTPS→HTTPS), but don't send it to a less secure destination (e.g. HTTPS→HTTP). - `strict-origin-when-cross-origin` (default) - : This is the user agent's default behavior if no policy is specified. Send a full URL when performing a same-origin request, only send the origin when the protocol security level stays the same (e.g. HTTPS→HTTPS), and send no header to a less secure destination (e.g. HTTPS→HTTP). - `unsafe-url` - : Send a full URL when performing a same-origin or cross-origin request. This policy will leak origins and paths from TLS-protected resources to insecure origins. Carefully consider the impact of this setting. > **Note:** An empty string value (`""`) is both the default > value, and a fallback value if `referrerpolicy` is not supported. If > `referrerpolicy` is not explicitly specified on the > `<script>` element, it will adopt a higher-level referrer policy, > i.e. one set on the whole document or domain. If a higher-level policy is not > available, the empty string is treated as being equivalent to > `no-referrer-when-downgrade`. ## Examples ```js const scriptElem = document.createElement("script"); scriptElem.src = "/"; scriptElem.referrerPolicy = "unsafe-url"; document.body.appendChild(scriptElem); ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("HTMLIFrameElement.referrerPolicy")}}
0
data/mdn-content/files/en-us/web/api/htmlscriptelement
data/mdn-content/files/en-us/web/api/htmlscriptelement/supports_static/index.md
--- title: "HTMLScriptElement: supports() static method" short-title: supports() slug: Web/API/HTMLScriptElement/supports_static page-type: web-api-static-method browser-compat: api.HTMLScriptElement.supports_static --- {{APIRef}} The **`supports()`** static method of the {{domxref("HTMLScriptElement")}} interface provides a simple and consistent method to feature-detect what types of scripts are supported by the user agent. The method is expected to return `true` for classic and module scripts, which are supported by most modern browsers. ## Syntax ```js-nolint HTMLScriptElement.supports(type) ``` ### Parameters - `type` - : A string literal that indicates the type of script for which support is to be checked. Supported values are case sensitive, and include: - `"classic"` - : Test if _classic scripts_ are supported. "Classic" scripts are the normal/traditional JavaScript files that predate module scripts. - `"module"` - : Test if [module scripts](/en-US/docs/Web/JavaScript/Guide/Modules) are supported. - `"importmap"` - : Test if import maps are supported. - `"speculationrules"` - : Test if speculation rules are supported and enabled. Any other value will cause the method to return `false`. ### Return value Returns `true` if the indicated script type is supported and `false` otherwise. ## Examples The code below shows how to check if `HTMLScriptElement.supports()` is defined, and if so, to use it to test whether particular types of scripts are supported. ```js const log = document.getElementById("log"); function checkSupport(type) { const result = HTMLScriptElement.supports(type) ? "true" : "false"; log.textContent += `HTMLScriptElement.supports('${type}') is ${result}\n`; } if (typeof HTMLScriptElement.supports === "undefined") { log.textContent = "HTMLScriptElement.supports() method is not supported"; } else { // Check if various script types are supported checkSupport("module"); checkSupport("classic"); checkSupport("importmap"); checkSupport("speculationrules"); // Any other value will cause the method to return false checkSupport("anything else"); } ``` ```html hidden <textarea id="log" rows="6" cols="80"></textarea> ``` {{ EmbedLiveSample('Examples') }} ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("HTMLScriptElement")}} - {{HTMLElement("script")}} - [JavaScript modules](/en-US/docs/Web/JavaScript/Guide/Modules) - {{domxref("Worker/Worker","Worker")}} constructor
0
data/mdn-content/files/en-us/web/api
data/mdn-content/files/en-us/web/api/htmltableelement/index.md
--- title: HTMLTableElement slug: Web/API/HTMLTableElement page-type: web-api-interface browser-compat: api.HTMLTableElement --- {{APIRef("HTML DOM")}} The **`HTMLTableElement`** interface provides special properties and methods (beyond the regular {{DOMxRef("HTMLElement")}} object interface it also has available to it by inheritance) for manipulating the layout and presentation of tables in an HTML document. {{InheritanceDiagram}} ## Instance properties _Inherits properties from its parent, {{DOMxRef("HTMLElement")}}._ - {{DOMxRef("HTMLTableElement.caption")}} - : A {{DOMxRef("HTMLTableCaptionElement")}} representing the first {{HTMLElement("caption")}} that is a child of the element, or `null` if none is found. When set, if the object doesn't represent a `<caption>`, a {{DOMxRef("DOMException")}} with the `HierarchyRequestError` name is thrown. If a correct object is given, it is inserted in the tree as the first child of this element and the first `<caption>` that is a child of this element is removed from the tree, if any. - {{DOMxRef("HTMLTableElement.tHead")}} - : A {{DOMxRef("HTMLTableSectionElement")}} representing the first {{HTMLElement("thead")}} that is a child of the element, or `null` if none is found. When set, if the object doesn't represent a `<thead>`, a {{DOMxRef("DOMException")}} with the `HierarchyRequestError` name is thrown. If a correct object is given, it is inserted in the tree immediately before the first element that is neither a {{HTMLElement("caption")}}, nor a {{HTMLElement("colgroup")}}, or as the last child if there is no such element, and the first `<thead>` that is a child of this element is removed from the tree, if any. - {{DOMxRef("HTMLTableElement.tFoot")}} - : A {{DOMxRef("HTMLTableSectionElement")}} representing the first {{HTMLElement("tfoot")}} that is a child of the element, or `null` if none is found. When set, if the object doesn't represent a `<tfoot>`, a {{DOMxRef("DOMException")}} with the `HierarchyRequestError` name is thrown. If a correct object is given, it is inserted in the tree immediately before the first element that is neither a {{HTMLElement("caption")}}, a {{HTMLElement("colgroup")}}, nor a {{HTMLElement("thead")}}, or as the last child if there is no such element, and the first `<tfoot>` that is a child of this element is removed from the tree, if any. - {{DOMxRef("HTMLTableElement.rows")}} {{ReadOnlyInline}} - : Returns a live {{DOMxRef("HTMLCollection")}} containing all the rows of the element, that is all {{HTMLElement("tr")}} that are a child of the element, or a child of one of its {{HTMLElement("thead")}}, {{HTMLElement("tbody")}} and {{HTMLElement("tfoot")}} children. The rows members of a `<thead>` appear first, in tree order, and those members of a `<tbody>` last, also in tree order. The `HTMLCollection` is live and is automatically updated when the `HTMLTableElement` changes. - {{DOMxRef("HTMLTableElement.tBodies")}} {{ReadOnlyInline}} - : Returns a live {{DOMxRef("HTMLCollection")}} containing all the {{HTMLElement("tbody")}} of the element. The `HTMLCollection` is live and is automatically updated when the `HTMLTableElement` changes. ### Obsolete Properties > **Warning:** The following properties are obsolete. You should avoid using them. - {{DOMxRef("HTMLTableElement.align")}} {{deprecated_inline}} - : A string containing an enumerated value reflecting the [`align`](/en-US/docs/Web/HTML/Element/table#align) attribute. It indicates the alignment of the element's contents with respect to the surrounding context. The possible values are `"left"`, `"right"`, and `"center"`. - {{DOMxRef("HTMLTableElement.bgColor")}} {{deprecated_inline}} - : A string containing the background color of the cells. It reflects the obsolete [`bgColor`](/en-US/docs/Web/HTML/Element/table#bgcolor) attribute. - {{DOMxRef("HTMLTableElement.border")}} {{deprecated_inline}} - : A string containing the width in pixels of the border of the table. It reflects the obsolete [`border`](/en-US/docs/Web/HTML/Element/table#border) attribute. - {{DOMxRef("HTMLTableElement.cellPadding")}} {{deprecated_inline}} - : A string containing the width in pixels of the horizontal and vertical space between cell content and cell borders. It reflects the obsolete [`cellpadding`](/en-US/docs/Web/HTML/Element/table#cellpadding) attribute. - {{DOMxRef("HTMLTableElement.cellSpacing")}} {{deprecated_inline}} - : A string containing the width in pixels of the horizontal and vertical separation between cells. It reflects the obsolete [`cellspacing`](/en-US/docs/Web/HTML/Element/table#cellspacing) attribute. - {{DOMxRef("HTMLTableElement.frame")}} {{deprecated_inline}} - : A string containing the type of the external borders of the table. It reflects the obsolete [`frame`](/en-US/docs/Web/HTML/Element/table#frame) attribute and can take one of the following values: `"void"`, `"above"`, `"below"`, `"hsides"`, `"vsides"`, `"lhs"`, `"rhs"`, `"box"`, or `"border"`. - {{DOMxRef("HTMLTableElement.rules")}} {{deprecated_inline}} - : A string containing the type of the internal borders of the table. It reflects the obsolete [`rules`](/en-US/docs/Web/HTML/Element/table#rules) attribute and can take one of the following values: `"none"`, `"groups"`, `"rows"`, `"cols"`, or `"all"`. - {{DOMxRef("HTMLTableElement.summary")}} {{deprecated_inline}} - : A string containing a description of the purpose or the structure of the table. It reflects the obsolete [`summary`](/en-US/docs/Web/HTML/Element/table#summary) attribute. - {{DOMxRef("HTMLTableElement.width")}} {{deprecated_inline}} - : A string containing the length in pixels or in percentage of the desired width of the entire table. It reflects the obsolete [`width`](/en-US/docs/Web/HTML/Element/table#width) attribute. ## Instance methods _Inherits methods from its parent, {{DOMxRef("HTMLElement")}}_. - {{DOMxRef("HTMLTableElement.createTHead()")}} - : Returns an {{DOMxRef("HTMLTableSectionElement")}} representing the first {{HTMLElement("thead")}} that is a child of the element. If none is found, a new one is created and inserted in the tree immediately before the first element that is neither a {{HTMLElement("caption")}}, nor a {{HTMLElement("colgroup")}}, or as the last child if there is no such element. - {{DOMxRef("HTMLTableElement.deleteTHead()")}} - : Removes the first {{HTMLElement("thead")}} that is a child of the element. - {{DOMxRef("HTMLTableElement.createTFoot()")}} - : Returns an {{DOMxRef("HTMLTableSectionElement")}} representing the first {{HTMLElement("tfoot")}} that is a child of the element. If none is found, a new one is created and inserted in the tree as the last child. - {{DOMxRef("HTMLTableElement.deleteTFoot()")}} - : Removes the first {{HTMLElement("tfoot")}} that is a child of the element. - {{DOMxRef("HTMLTableElement.createTBody()")}} - : Returns a {{DOMxRef("HTMLTableSectionElement")}} representing a new {{HTMLElement("tbody")}} that is a child of the element. It is inserted in the tree after the last element that is a {{HTMLElement("tbody")}}, or as the last child if there is no such element. - {{DOMxRef("HTMLTableElement.createCaption()")}} - : Returns an {{DOMxRef("HTMLElement")}} representing the first {{HTMLElement("caption")}} that is a child of the element. If none is found, a new one is created and inserted in the tree as the first child of the {{HTMLElement("table")}} element. - {{DOMxRef("HTMLTableElement.deleteCaption()")}} - : Removes the first {{HTMLElement("caption")}} that is a child of the element. - {{DOMxRef("HTMLTableElement.insertRow()")}} - : Returns an {{DOMxRef("HTMLTableRowElement")}} representing a new row of the table. It inserts it in the rows collection immediately before the {{HTMLElement("tr")}} element at the given `index` position. If necessary a {{HTMLElement("tbody")}} is created. If the `index` is `-1`, the new row is appended to the collection. If the `index` is smaller than `-1` or greater than the number of rows in the collection, a {{DOMxRef("DOMException")}} with the value `IndexSizeError` is raised. - {{DOMxRef("HTMLTableElement.deleteRow()")}} - : Removes the row corresponding to the `index` given in parameter. If the `index` value is `-1` the last row is removed; if it is smaller than `-1` or greater than the amount of rows in the collection, a {{DOMxRef("DOMException")}} with the value `IndexSizeError` is raised. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - The HTML element implementing this interface: {{HTMLElement("table")}}.
0
data/mdn-content/files/en-us/web/api/htmltableelement
data/mdn-content/files/en-us/web/api/htmltableelement/createthead/index.md
--- title: "HTMLTableElement: createTHead() method" short-title: createTHead() slug: Web/API/HTMLTableElement/createTHead page-type: web-api-instance-method browser-compat: api.HTMLTableElement.createTHead --- {{APIRef("HTML DOM")}} The **`createTHead()`** method of {{domxref("HTMLTableElement")}} objects returns the {{HTMLElement("thead")}} element associated with a given {{HtmlElement("table")}}. If no header exists in the table, this method creates it, and then returns it. > **Note:** If no header exists, `createTHead()` inserts a new > header directly into the table. The header does not need to be added separately as > would be the case if {{domxref("Document.createElement()")}} had been used to create > the new `<thead>` element. ## Syntax ```js-nolint createTHead() ``` ### Parameters None. ### Return value {{domxref("HTMLTableSectionElement")}} ## Examples ```js let myhead = mytable.createTHead(); // Now this should be true: myhead === mytable.tHead ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/htmltableelement
data/mdn-content/files/en-us/web/api/htmltableelement/rows/index.md
--- title: "HTMLTableElement: rows property" short-title: rows slug: Web/API/HTMLTableElement/rows page-type: web-api-instance-property browser-compat: api.HTMLTableElement.rows --- {{APIRef("HTML DOM")}} The read-only {{domxref("HTMLTableElement")}} property **`rows`** returns a live {{domxref("HTMLCollection")}} of all the rows in the table, including the rows contained within any {{HTMLElement("thead")}}, {{HTMLElement("tfoot")}}, and {{HTMLElement("tbody")}} elements. Although the property itself is read-only, the returned object is live and allows the modification of its content. ## Value An {{domxref("HTMLCollection")}} providing a live-updating list of the {{domxref("HTMLTableRowElement")}} objects representing all of the {{HTMLElement("tr")}} elements contained in the table. This provides quick access to all of the table rows, without having to manually search for them. ## Examples ```js myrows = mytable.rows; firstRow = mytable.rows[0]; lastRow = mytable.rows.item(mytable.rows.length - 1); ``` This demonstrates how you can use both array syntax (line 2) and the {{domxref("HTMLCollection.item()")}} method (line 3) to obtain individual rows in the table. ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/htmltableelement
data/mdn-content/files/en-us/web/api/htmltableelement/caption/index.md
--- title: "HTMLTableElement: caption property" short-title: caption slug: Web/API/HTMLTableElement/caption page-type: web-api-instance-property browser-compat: api.HTMLTableElement.caption --- {{APIRef("HTML DOM")}} The **`HTMLTableElement.caption`** property represents the table caption. If no caption element is associated with the table, this property is `null`. ## Value A string. ## Examples ```js if (table.caption) { // Do something with the caption } ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - The interface implementing this property: {{domxref("HTMLTableElement")}}.
0
data/mdn-content/files/en-us/web/api/htmltableelement
data/mdn-content/files/en-us/web/api/htmltableelement/frame/index.md
--- title: "HTMLTableElement: frame property" short-title: frame slug: Web/API/HTMLTableElement/frame page-type: web-api-instance-property status: - deprecated browser-compat: api.HTMLTableElement.frame --- {{APIRef("HTML DOM")}} {{Deprecated_Header}} The {{domxref("HTMLTableElement")}} interface's **`frame`** property is a string that indicates which of the table's exterior borders should be drawn. ## Value One of the following: - `void` - : No sides. This is the default. - `"above"` - : Top side - `"below"` - : Bottom side - `"hsides"` - : Top and bottom only - `"vsides"` - : Right and left sides only - `"lhs"` - : Left-hand side only - `"rhs"` - : Right-hand side only - `"box"` - : All four sides - `"border"` - : All four sides ## Examples ```js // Set the frame of TableA to 'border' const t = document.getElementById("TableA"); t.frame = "border"; t.border = "2px"; ``` ## Specifications - W3C DOM 2 HTML Specification ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/htmltableelement
data/mdn-content/files/en-us/web/api/htmltableelement/createtfoot/index.md
--- title: "HTMLTableElement: createTFoot() method" short-title: createTFoot() slug: Web/API/HTMLTableElement/createTFoot page-type: web-api-instance-method browser-compat: api.HTMLTableElement.createTFoot --- {{APIRef("HTML DOM")}} The **`createTFoot()`** method of {{domxref("HTMLTableElement")}} objects returns the {{HTMLElement("tfoot")}} element associated with a given {{HtmlElement("table")}}. If no footer exists in the table, this method creates it, and then returns it. > **Note:** If no footer exists, `createTFoot()` inserts a new > footer directly into the table. The footer does not need to be added separately as > would be the case if {{domxref("Document.createElement()")}} had been used to create > the new `<tfoot>` element. ## Syntax ```js-nolint createTFoot() ``` ### Parameters None. ### Return value {{domxref("HTMLTableSectionElement")}} ## Examples ```js let myfoot = mytable.createTFoot(); // Now this should be true: myfoot === mytable.tFoot ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/htmltableelement
data/mdn-content/files/en-us/web/api/htmltableelement/deletecaption/index.md
--- title: "HTMLTableElement: deleteCaption() method" short-title: deleteCaption() slug: Web/API/HTMLTableElement/deleteCaption page-type: web-api-instance-method browser-compat: api.HTMLTableElement.deleteCaption --- {{APIRef("HTML DOM")}} The **`HTMLTableElement.deleteCaption()`** method removes the {{HtmlElement("caption")}} element from a given {{HtmlElement("table")}}. If there is no `<caption>` element associated with the table, this method does nothing. ## Syntax ```js-nolint deleteCaption() ``` ### Parameters None. ### Return value None ({{jsxref("undefined")}}). ## Examples This example uses JavaScript to delete a table's caption. ### HTML ```html <table> <caption> This caption will be deleted! </caption> <tr> <td>Cell 1.1</td> <td>Cell 1.2</td> </tr> <tr> <td>Cell 2.1</td> <td>Cell 2.2</td> </tr> </table> ``` ### JavaScript ```js let table = document.querySelector("table"); table.deleteCaption(); ``` ### Result {{EmbedLiveSample("Examples")}} ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/htmltableelement
data/mdn-content/files/en-us/web/api/htmltableelement/tfoot/index.md
--- title: "HTMLTableElement: tFoot property" short-title: tFoot slug: Web/API/HTMLTableElement/tFoot page-type: web-api-instance-property browser-compat: api.HTMLTableElement.tFoot --- {{APIRef("HTML DOM")}} The **`HTMLTableElement.tFoot`** property represents the {{HTMLElement("tfoot")}} element of a {{HTMLElement("table")}}. Its value will be `null` if there is no such element. ## Value A {{HTMLElement("tfoot")}} element or `null`. ## Examples ```js if (table.tFoot === my_foot) { // … } ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - The interface implementing this property: {{domxref("HTMLTableElement")}}.
0
data/mdn-content/files/en-us/web/api/htmltableelement
data/mdn-content/files/en-us/web/api/htmltableelement/cellspacing/index.md
--- title: "HTMLTableElement: cellSpacing property" short-title: cellSpacing slug: Web/API/HTMLTableElement/cellSpacing page-type: web-api-instance-property status: - deprecated browser-compat: api.HTMLTableElement.cellSpacing --- {{APIRef("HTML DOM")}}{{deprecated_header}} While you should instead use the CSS {{cssxref("border-spacing")}} property, the obsolete {{domxref("HTMLTableElement")}} interface's **`cellSpacing`** property represents the spacing around the individual {{HTMLElement("th")}} and {{HTMLElement("td")}} elements representing a table's cells. Any two cells are separated by the sum of the `cellSpacing` of each of the two cells. ## Value A string which is either a number of pixels (such as `"10"`) or a percentage value (like `"10%"`). ## Examples This example sets cell spacing for a given table to 10 pixels. ```js const t = document.getElementById("TableA"); t.cellSpacing = "10"; ``` ## Specifications - W3C DOM 2 HTML Specification [_HTMLTableElement.cellSpacing_](https://www.w3.org/TR/DOM-Level-2-HTML/html.html#ID-68907883). ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/htmltableelement
data/mdn-content/files/en-us/web/api/htmltableelement/rules/index.md
--- title: "HTMLTableElement: rules property" short-title: rules slug: Web/API/HTMLTableElement/rules page-type: web-api-instance-property status: - deprecated browser-compat: api.HTMLTableElement.rules --- {{APIRef("HTML DOM")}} {{Deprecated_Header}} The **`HTMLTableElement.rules`** property indicates which cell borders to render in the table. ## Value One of the following: - `none` - : No rules - `groups` - : Lines between groups only - `rows` - : Lines between rows - `cols` - : Lines between cols - `all` - : Lines between all cells ## Examples ```js // Turn on all the internal borders of a table const t = document.getElementById("TableID"); t.rules = "all"; ``` ## Specifications - W3C DOM 2 HTML Specification ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/htmltableelement
data/mdn-content/files/en-us/web/api/htmltableelement/border/index.md
--- title: "HTMLTableElement: border property" short-title: border slug: Web/API/HTMLTableElement/border page-type: web-api-instance-property status: - deprecated browser-compat: api.HTMLTableElement.border --- {{APIRef("HTML DOM")}}{{Deprecated_Header}} The **`HTMLTableElement.border`** property represents the border width of the {{HtmlElement("table")}} element. ## Value A string representing the width of the border in pixels. ## Examples ```js // Set the width of a table border to 2 pixels const t = document.getElementById("TableA"); t.border = "2"; ``` ## Specifications W3C DOM 2 HTML Specification [_HTMLTableElement.border_](https://www.w3.org/TR/DOM-Level-2-HTML/html.html#ID-50969400). This attribute is deprecated in HTML 4.0. ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/htmltableelement
data/mdn-content/files/en-us/web/api/htmltableelement/bgcolor/index.md
--- title: "HTMLTableElement: bgColor property" short-title: bgColor slug: Web/API/HTMLTableElement/bgColor page-type: web-api-instance-property status: - deprecated browser-compat: api.HTMLTableElement.bgColor --- {{APIRef("HTML DOM")}} {{Deprecated_Header}} The **`bgcolor`** property of the {{domxref("HTMLTableElement")}} represents the background color of the table. > **Note:** Do not use this attribute anymore. Instead, use the CSS {{cssxref("background-color")}} property by modifying the element's [`style`](/en-US/docs/Web/API/HTMLElement/style) attribute or using a style rule. ## Value A string representing a color value. ## Examples ```js // Set table background color to lightblue const t = document.getElementById("TableA"); t.bgColor = "lightblue"; ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{cssxref("background-color")}}
0
data/mdn-content/files/en-us/web/api/htmltableelement
data/mdn-content/files/en-us/web/api/htmltableelement/createtbody/index.md
--- title: "HTMLTableElement: createTBody() method" short-title: createTBody() slug: Web/API/HTMLTableElement/createTBody page-type: web-api-instance-method browser-compat: api.HTMLTableElement.createTBody --- {{APIRef("HTML DOM")}} The **`createTBody()`** method of {{domxref("HTMLTableElement")}} objects creates and returns a new {{HTMLElement("tbody")}} element associated with a given {{HtmlElement("table")}}. > **Note:** Unlike {{domxref("HTMLTableElement.createTHead()")}} and > {{domxref("HTMLTableElement.createTFoot()")}}, `createTBody()` > systematically creates a new `<tbody>` element, even if the table > already contains one or more bodies. If so, the new one is inserted after the existing > ones. ## Syntax ```js-nolint createTBody() ``` ### Parameters None. ### Return value {{domxref("HTMLTableSectionElement")}} ## Examples ```js let mybody = mytable.createTBody(); // Now this should be true: mybody === mytable.tBodies.item(mytable.tBodies.length - 1) ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/htmltableelement
data/mdn-content/files/en-us/web/api/htmltableelement/deleterow/index.md
--- title: "HTMLTableElement: deleteRow() method" short-title: deleteRow() slug: Web/API/HTMLTableElement/deleteRow page-type: web-api-instance-method browser-compat: api.HTMLTableElement.deleteRow --- {{APIRef("HTML DOM")}} The **`HTMLTableElement.deleteRow()`** method removes a specific row ({{HtmlElement("tr")}}) from a given {{HtmlElement("table")}}. ## Syntax ```js-nolint deleteRow(index) ``` ### Parameters - `index` - : `index` is an integer representing the row that should be deleted. However, the special index `-1` can be used to remove the very last row of a table. ### Return value None ({{jsxref("undefined")}}). ### Exceptions - `IndexSizeError` {{domxref("DOMException")}} - : Thrown if `index` is greater than or equal to the number of available rows or is a negative value other than `-1`. ## Examples This example uses JavaScript to delete a table's second row. ### HTML ```html <table> <tr> <td>Cell 1.1</td> <td>Cell 1.2</td> <td>Cell 1.3</td> </tr> <tr> <td>Cell 2.1</td> <td>Cell 2.2</td> <td>Cell 2.3</td> </tr> <tr> <td>Cell 3.1</td> <td>Cell 3.2</td> <td>Cell 3.3</td> </tr> </table> ``` ### JavaScript ```js let table = document.querySelector("table"); // Delete second row table.deleteRow(1); ``` ### Result {{EmbedLiveSample("Examples")}} ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/htmltableelement
data/mdn-content/files/en-us/web/api/htmltableelement/createcaption/index.md
--- title: "HTMLTableElement: createCaption() method" short-title: createCaption() slug: Web/API/HTMLTableElement/createCaption page-type: web-api-instance-method browser-compat: api.HTMLTableElement.createCaption --- {{APIRef("HTML DOM")}} The **`HTMLTableElement.createCaption()`** method returns the {{HtmlElement("caption")}} element associated with a given {{HtmlElement("table")}}. If no `<caption>` element exists on the table, this method creates it, and then returns it. > **Note:** If no caption exists, `createCaption()` inserts a > new caption directly into the table. The caption does not need to be added > separately as would be the case if {{domxref("Document.createElement()")}} had > been used to create the new `<caption>` element. ## Syntax ```js-nolint createCaption() ``` ### Parameters None. ### Return value {{domxref("HTMLTableCaptionElement")}} ## Examples This example uses JavaScript to add a caption to a table that initially lacks one. ### HTML ```html <table> <tr> <td>Cell 1.1</td> <td>Cell 1.2</td> <td>Cell 1.3</td> </tr> <tr> <td>Cell 2.1</td> <td>Cell 2.2</td> <td>Cell 2.3</td> </tr> </table> ``` ### JavaScript ```js let table = document.querySelector("table"); let caption = table.createCaption(); caption.textContent = "This caption was created by JavaScript!"; ``` ### Result {{EmbedLiveSample("Examples")}} ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/htmltableelement
data/mdn-content/files/en-us/web/api/htmltableelement/summary/index.md
--- title: "HTMLTableElement: summary property" short-title: summary slug: Web/API/HTMLTableElement/summary page-type: web-api-instance-property status: - deprecated browser-compat: api.HTMLTableElement.summary --- {{APIRef("HTML DOM")}} {{Deprecated_Header}} The **`HTMLTableElement.summary`** property represents the table description. ## Value A string. ## Examples ```js HTMLTableElement.summary = "Usage statistics"; ``` ## Specifications - W3C DOM 2 HTML Specification ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/htmltableelement
data/mdn-content/files/en-us/web/api/htmltableelement/thead/index.md
--- title: "HTMLTableElement: tHead property" short-title: tHead slug: Web/API/HTMLTableElement/tHead page-type: web-api-instance-property browser-compat: api.HTMLTableElement.tHead --- {{APIRef("HTML DOM")}} The **`HTMLTableElement.tHead`** represents the {{HTMLElement("thead")}} element of a {{HTMLElement("table")}}. Its value will be `null` if there is no such element. ## Value A {{domxref("HTMLTableSectionElement")}}. ## Examples ```js if (table.tHead === my_head_el) { // … } ``` ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - The interface implementing this property: {{domxref("HTMLTableElement")}}.
0
data/mdn-content/files/en-us/web/api/htmltableelement
data/mdn-content/files/en-us/web/api/htmltableelement/deletetfoot/index.md
--- title: "HTMLTableElement: deleteTFoot() method" short-title: deleteTFoot() slug: Web/API/HTMLTableElement/deleteTFoot page-type: web-api-instance-method browser-compat: api.HTMLTableElement.deleteTFoot --- {{APIRef("HTML DOM")}} The **`HTMLTableElement.deleteTFoot()`** method removes the {{HTMLElement("tfoot")}} element from a given {{HtmlElement("table")}}. ## Syntax ```js-nolint deleteTFoot() ``` ### Parameters None. ### Return value None ({{jsxref("undefined")}}). ## Examples This example uses JavaScript to delete a table's footer. ### HTML ```html <table> <thead> <th>Name</th> <th>Score</th> </thead> <tr> <td>Bob</td> <td>541</td> </tr> <tr> <td>Jim</td> <td>225</td> </tr> <tfoot> <th>Average</th> <td>383</td> </tfoot> </table> ``` ### JavaScript ```js let table = document.querySelector("table"); table.deleteTFoot(); ``` ### Result {{EmbedLiveSample("Examples")}} ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/htmltableelement
data/mdn-content/files/en-us/web/api/htmltableelement/width/index.md
--- title: "HTMLTableElement: width property" short-title: width slug: Web/API/HTMLTableElement/width page-type: web-api-instance-property status: - deprecated browser-compat: api.HTMLTableElement.width --- {{APIRef("HTML DOM")}} {{Deprecated_Header}} The **`HTMLTableElement.width`** property represents the desired width of the table. ## Value A string representing the width in number of pixels or as a percentage value. ## Examples ```js mytable.width = "75%"; ``` ## Specifications - W3C DOM 2 HTML Specification [_HTMLTableElement.width_](https://www.w3.org/TR/DOM-Level-2-HTML/html.html#ID-77447361) ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/htmltableelement
data/mdn-content/files/en-us/web/api/htmltableelement/cellpadding/index.md
--- title: "HTMLTableElement: cellPadding property" short-title: cellPadding slug: Web/API/HTMLTableElement/cellPadding page-type: web-api-instance-property status: - deprecated browser-compat: api.HTMLTableElement.cellPadding --- {{APIRef("HTML DOM")}} {{Deprecated_Header}} The **`HTMLTableElement.cellPadding`** property represents the padding around the individual cells of the table. ## Value A string representing pixels (e.g. "10") or a percentage value (e.g. "10%"). ## Examples ```js // Set cell padding to 10 pixels let t = document.getElementById("TableA"); t.cellPadding = "10"; ``` ## Specifications - W3C DOM 2 HTML Specification [_HTMLTableElement.cellPadding_](https://www.w3.org/TR/DOM-Level-2-HTML/html.html#ID-59162158). ## Browser compatibility {{Compat}}
0
data/mdn-content/files/en-us/web/api/htmltableelement
data/mdn-content/files/en-us/web/api/htmltableelement/insertrow/index.md
--- title: "HTMLTableElement: insertRow() method" short-title: insertRow() slug: Web/API/HTMLTableElement/insertRow page-type: web-api-instance-method browser-compat: api.HTMLTableElement.insertRow --- {{APIRef("HTML DOM")}} The **`HTMLTableElement.insertRow()`** method inserts a new row ({{HtmlElement("tr")}}) in a given {{HtmlElement("table")}}, and returns a reference to the new row. If a table has multiple {{HtmlElement("tbody")}} elements, by default, the new row is inserted into the last `<tbody>`. To insert the row into a specific `<tbody>`: ```js let specific_tbody = document.getElementById(tbody_id); let row = specific_tbody.insertRow(index); ``` > **Note:** `insertRow()` inserts the row directly into the > table. The row does not need to be appended separately as would be the case if > {{domxref("Document.createElement()")}} had been used to create the new > `<tr>` element. ## Syntax ```js-nolint insertRow() insertRow(index) ``` {{domxref("HTMLTableElement")}} is a reference to an HTML {{HtmlElement("table")}} element. ### Parameters - `index` {{optional_inline}} - : The row index of the new row. If `index` is `-1` or equal to the number of rows, the row is appended as the last row. If `index` is omitted it defaults to `-1`. ### Return value An {{domxref("HTMLTableRowElement")}} that references the new row. ### Exceptions - `IndexSizeError` {{domxref("DOMException")}} - : Thrown if `index` is greater than the number of rows. ## Examples This example uses `insertRow(-1)` to append a new row to a table. We then use {{domxref("HTMLTableRowElement.insertCell()")}} to insert a new cell in the new row. (To be valid HTML, a `<tr>` must have at least one `<td>` element.) Finally, we add some text to the cell using {{domxref("Document.createTextNode()")}} and {{domxref("Node.appendChild()")}}. ### HTML ```html <table id="my-table"> <tr> <td>Row 1</td> </tr> <tr> <td>Row 2</td> </tr> <tr> <td>Row 3</td> </tr> </table> ``` ### JavaScript ```js function addRow(tableID) { // Get a reference to the table let tableRef = document.getElementById(tableID); // Insert a row at the end of the table let newRow = tableRef.insertRow(-1); // Insert a cell in the row at index 0 let newCell = newRow.insertCell(0); // Append a text node to the cell let newText = document.createTextNode("New bottom row"); newCell.appendChild(newText); } // Call addRow() with the table's ID addRow("my-table"); ``` ### Result {{EmbedLiveSample("Examples")}} ## Specifications {{Specifications}} ## Browser compatibility {{Compat}} ## See also - {{domxref("HTMLTableRowElement.insertCell()")}} - The HTML element representing rows: {{domxref("HTMLTableRowElement")}}
0
data/mdn-content/files/en-us/web/api/htmltableelement
data/mdn-content/files/en-us/web/api/htmltableelement/deletethead/index.md
--- title: "HTMLTableElement: deleteTHead() method" short-title: deleteTHead() slug: Web/API/HTMLTableElement/deleteTHead page-type: web-api-instance-method browser-compat: api.HTMLTableElement.deleteTHead --- {{APIRef("HTML DOM")}} The **`HTMLTableElement.deleteTHead()`** removes the {{HTMLElement("thead")}} element from a given {{HtmlElement("table")}}. ## Syntax ```js-nolint deleteTHead() ``` ### Parameters None. ### Return value None ({{jsxref("undefined")}}). ## Examples This example uses JavaScript to delete a table's header. ### HTML ```html <table> <thead> <th>Name</th> <th>Occupation</th> </thead> <tr> <td>Bob</td> <td>Plumber</td> </tr> <tr> <td>Jim</td> <td>Roofer</td> </tr> </table> ``` ### JavaScript ```js let table = document.querySelector("table"); table.deleteTHead(); ``` ### Result {{EmbedLiveSample("Examples")}} ## Specifications {{Specifications}} ## Browser compatibility {{Compat}}
0