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/batterymanager | data/mdn-content/files/en-us/web/api/batterymanager/levelchange_event/index.md | ---
title: "BatteryManager: levelchange event"
short-title: levelchange
slug: Web/API/BatteryManager/levelchange_event
page-type: web-api-event
browser-compat: api.BatteryManager.levelchange_event
---
{{ApiRef("Battery API")}}{{securecontext_header}}
The **`levelchange`** event of the {{domxref("Battery Status API", "", "", "nocode")}} is fired when the battery {{domxref("BatteryManager.level", "level")}} property is updated.
## Syntax
Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property.
```js-nolint
addEventListener("levelchange", (event) => { })
onlevelchange = (event) => { }
```
## Event type
_A generic {{domxref("Event")}}._
## Example
### HTML
```html
<div id="level">(battery level unknown)</div>
<div id="stateBattery">(charging state unknown)</div>
```
### JavaScript
```js
navigator.getBattery().then((battery) => {
battery.onlevelchange = () => {
document.querySelector("#level").textContent = battery.level;
if (battery.charging) {
document.querySelector("#stateBattery").textContent = `Charging time: ${
battery.chargingTime / 60
}`;
} else {
document.querySelector("#stateBattery").textContent =
`Discharging time: ${battery.dischargingTime / 60}`;
}
};
});
```
{{ EmbedLiveSample('Example', '100%', 40) }}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("BatteryManager")}}
- {{domxref("Navigator.getBattery()")}}
| 0 |
data/mdn-content/files/en-us/web/api/batterymanager | data/mdn-content/files/en-us/web/api/batterymanager/dischargingtimechange_event/index.md | ---
title: "BatteryManager: dischargingtimechange event"
short-title: dischargingtimechange
slug: Web/API/BatteryManager/dischargingtimechange_event
page-type: web-api-event
browser-compat: api.BatteryManager.dischargingtimechange_event
---
{{ApiRef("Battery API")}}{{securecontext_header}}
The **`dischargingtimechange`** event of the {{domxref("Battery Status API", "", "", "nocode")}} is fired when the battery {{domxref("BatteryManager.dischargingTime", "dischargingTime")}} property is updated.
## Syntax
Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property.
```js-nolint
addEventListener("dischargingtimechange", (event) => { })
ondischargingtimechange = (event) => { }
```
## Event type
_A generic {{domxref("Event")}}._
## Example
### HTML
```html
<div id="level">(battery level unknown)</div>
<div id="chargingTime">(charging time unknown)</div>
```
### JavaScript
```js
navigator.getBattery().then((battery) => {
battery.ondischargingtimechange = () => {
document.querySelector("#level").textContent = battery.level;
document.querySelector("#chargingTime").textContent = battery.chargingTime;
};
});
```
{{ EmbedLiveSample('Example', '100%', 40) }}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("BatteryManager")}}
- {{domxref("Navigator.getBattery()")}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/midimessageevent/index.md | ---
title: MIDIMessageEvent
slug: Web/API/MIDIMessageEvent
page-type: web-api-interface
browser-compat: api.MIDIMessageEvent
---
{{securecontext_header}}{{APIRef("Web MIDI API")}}
The **`MIDIMessageEvent`** interface of the [Web MIDI API](/en-US/docs/Web/API/Web_MIDI_API) represents the event passed to the {{domxref("MIDIInput.midimessage_event","midimessage")}} event of the {{domxref("MIDIInput")}} interface. A `midimessage` event is fired every time a MIDI message is sent from a device represented by a {{domxref("MIDIInput")}}, for example when a MIDI keyboard key is pressed, a knob is tweaked, or a slider is moved.
{{InheritanceDiagram}}
## Constructor
- {{domxref("MIDIMessageEvent.MIDIMessageEvent", "MIDIMessageEvent()")}}
- : Creates a new `MIDIMessageEvent` object instance.
## Instance properties
_This interface also inherits properties from {{domxref("Event")}}._
- {{domxref("MIDIMessageEvent.data")}}
- : A {{jsxref("Uint8Array")}} containing the data bytes of a single MIDI message. See the [MIDI specification](https://www.midi.org/specifications-old/item/table-1-summary-of-midi-message) for more information on its form.
## Instance methods
_This interface doesn't implement any specific methods, but inherits methods from {{domxref("Event")}}._
## Examples
The following example prints all MIDI messages to the console.
```js
navigator.requestMIDIAccess().then((midiAccess) => {
Array.from(midiAccess.inputs).forEach((input) => {
input[1].onmidimessage = (msg) => {
console.log(msg);
};
});
});
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/midimessageevent | data/mdn-content/files/en-us/web/api/midimessageevent/data/index.md | ---
title: "MIDIMessageEvent: data property"
short-title: data
slug: Web/API/MIDIMessageEvent/data
page-type: web-api-instance-property
browser-compat: api.MIDIMessageEvent.data
---
{{securecontext_header}}{{APIRef("Web MIDI API")}}
The **`data`** read-only property of the {{domxref("MIDIMessageEvent")}} interface returns the MIDI data bytes of a single MIDI message.
## Value
A {{jsxref("Uint8Array")}}.
## Examples
In the following example {{domxref("MIDIInput.midimessage_event", "midimessage")}} events are listened for on all input ports. When a message is received the value of `data` is printed to the console.
```js
inputs.forEach((input) => {
input.onmidimessage = (message) => {
console.log(message.data);
};
});
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/midimessageevent | data/mdn-content/files/en-us/web/api/midimessageevent/midimessageevent/index.md | ---
title: "MIDIMessageEvent: MIDIMessageEvent() constructor"
short-title: MIDIMessageEvent()
slug: Web/API/MIDIMessageEvent/MIDIMessageEvent
page-type: web-api-constructor
browser-compat: api.MIDIMessageEvent.MIDIMessageEvent
---
{{securecontext_header}}{{APIRef("Web MIDI API")}}
The **`MIDIMessageEvent()`** constructor creates a new {{domxref("MIDIMessageEvent")}} object. Typically this constructor is not used as events are created when a {{domxref("MIDIInput")}} finishes receiving one or more MIDI messages.
## Syntax
```js-nolint
new MIDIMessageEvent(type)
new MIDIMessageEvent(type, options)
```
### Parameters
- `type`
- : A string with the name of the event.
It is case-sensitive and browsers always set it to `MIDIMessageEvent`.
- `options` {{optional_inline}}
- : An object that, _in addition of the properties defined in {{domxref("Event/Event", "Event()")}}_, can have the following properties:
- `data`
- : A {{jsxref("Uint8Array")}} instance containing the data bytes of the MIDI message.
### Return value
A new {{domxref("MIDIMessageEvent")}} object.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/scrolltimeline/index.md | ---
title: ScrollTimeline
slug: Web/API/ScrollTimeline
page-type: web-api-interface
status:
- experimental
browser-compat: api.ScrollTimeline
---
{{APIRef("Web Animations")}}{{SeeCompatTable}}
The **`ScrollTimeline`** interface of the {{domxref("Web Animations API", "Web Animations API", "", "nocode")}} represents a scroll progress timeline (see [CSS scroll-driven animations](/en-US/docs/Web/CSS/CSS_scroll-driven_animations) for more details).
Pass a `ScrollTimeline` instance to the {{domxref("Animation.Animation", "Animation()")}} constructor or the {{domxref("Element.animate()", "animate()")}} method to specify it as the timeline that will control the progress of the animation.
{{InheritanceDiagram}}
## Constructor
- {{domxref("ScrollTimeline.ScrollTimeline", "ScrollTimeline()")}} {{Experimental_Inline}}
- : Creates a new `ScrollTimeline` object instance.
## Instance properties
_This interface also inherits the properties of its parent, {{domxref("AnimationTimeline")}}._
- {{domxref("ScrollTimeline.source", "source")}} {{ReadOnlyInline}} {{Experimental_Inline}}
- : Returns a reference to the scrollable element (_scroller_) whose scroll position is driving the progress of the timeline and therefore the animation.
- {{domxref("ScrollTimeline.axis", "axis")}} {{ReadOnlyInline}} {{Experimental_Inline}}
- : Returns an enumerated value representing the scroll axis that is driving the progress of the timeline.
## Instance methods
_This interface inherits the methods of its parent, {{domxref("AnimationTimeline")}}._
## Examples
### Displaying the source and axis of a scroll progress timeline
In this example, we animate an element with a `class` of `box` along a view progress timeline — it animates across the screen as the document scrolls. We output the `source` element and scroll `axis` to an `output` element in the top-right corner.
#### HTML
The HTML for the example is shown below.
```html
<div class="content"></div>
<div class="box"></div>
<div class="output"></div>
```
#### CSS
The CSS for the example looks like this:
```css
.content {
height: 2000px;
}
.box {
width: 100px;
height: 100px;
border-radius: 10px;
background-color: rebeccapurple;
position: fixed;
top: 20px;
left: 0%;
}
.output {
font-family: Arial, Helvetica, sans-serif;
position: fixed;
top: 5px;
right: 5px;
}
```
#### JavaScript
In the JavaScript, we grab references to the `box` and `output` `<div>`s, then create a new `ScrollTimeline`, specifying that the element that will drive the scroll timeline progress is the document ({{htmlelement("html")}}) element, and the scroll axis is the `block` axis. We then animate the `box` element with the Web Animations API. Last of all, we display the source element and axis in the `output` element.
```js
const box = document.querySelector(".box");
const output = document.querySelector(".output");
const timeline = new ScrollTimeline({
source: document.documentElement,
axis: "block",
});
box.animate(
{
rotate: ["0deg", "720deg"],
left: ["0%", "100%"],
},
{
timeline,
},
);
output.textContent = `Timeline source element: ${timeline.source.nodeName}. Timeline scroll axis: ${timeline.axis}`;
```
#### Result
Scroll to see the box being animated.
{{EmbedLiveSample("Displaying the source and axis of a scroll progress timeline", "100%", "320px")}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Web Animations API](/en-US/docs/Web/API/Web_Animations_API)
- [CSS scroll-driven animations](/en-US/docs/Web/CSS/CSS_scroll-driven_animations)
- {{domxref("AnimationTimeline")}}, {{domxref("ViewTimeline")}}
| 0 |
data/mdn-content/files/en-us/web/api/scrolltimeline | data/mdn-content/files/en-us/web/api/scrolltimeline/source/index.md | ---
title: "ScrollTimeline: source property"
short-title: source
slug: Web/API/ScrollTimeline/source
page-type: web-api-instance-property
status:
- experimental
browser-compat: api.ScrollTimeline.source
---
{{APIRef("Web Animations")}}{{SeeCompatTable}}
The **`source`** read-only property of the
{{domxref("ScrollTimeline")}} interface returns a reference to the scrollable element (_scroller_) whose scroll position is driving the progress of the timeline and therefore the animation.
## Value
An {{domxref("Element")}}.
## Examples
See the main {{domxref("ScrollTimeline")}} page for an example.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Web Animations API](/en-US/docs/Web/API/Web_Animations_API)
- [CSS scroll-driven animations](/en-US/docs/Web/CSS/CSS_scroll-driven_animations)
- {{domxref("ScrollTimeline")}}
- {{domxref("AnimationTimeline")}}, {{domxref("ViewTimeline")}}
| 0 |
data/mdn-content/files/en-us/web/api/scrolltimeline | data/mdn-content/files/en-us/web/api/scrolltimeline/scrolltimeline/index.md | ---
title: "ScrollTimeline: ScrollTimeline() constructor"
short-title: ScrollTimeline()
slug: Web/API/ScrollTimeline/ScrollTimeline
page-type: web-api-constructor
status:
- experimental
browser-compat: api.ScrollTimeline.ScrollTimeline
---
{{APIRef("History API")}}{{SeeCompatTable}}
The **`ScrollTimeline()`** constructor creates a new {{domxref("ScrollTimeline")}} object instance.
## Syntax
```js-nolint
new ScrollTimeline(options)
```
### Parameters
- `options`
- : An object that can contain the following properties:
- `source`
- : A reference to an {{domxref("Element")}} representing the scrollable element (_scroller_) whose scroll position will drive the progress of the timeline.
- `axis` {{optional_inline}}
- : An enumerated value representing the scroll axis that will drive the progress of the timeline. Possible values are:
- `"block"`: The scrollbar on the block axis of the scroll container, which is the axis in the direction perpendicular to the flow of text within a line. For horizontal writing modes, such as standard English, this is the same as `"y"`, while for vertical writing modes, it is the same as `"x"`.
- `"inline"`: The scrollbar on the inline axis of the scroll container, which is the axis in the direction parallel to the flow of text in a line. For horizontal writing modes, this is the same as `"x"`, while for vertical writing modes, this is the same as `"y"`.
- `"y"`: The scrollbar on the vertical axis of the scroll container.
- `"x"`: The scrollbar on the horizontal axis of the scroll container.
If omitted, `axis` defaults to `"block"`.
### Return value
A new {{domxref("ScrollTimeline")}} object instance.
## Examples
See the main {{domxref("ScrollTimeline")}} page for an example.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Web Animations API](/en-US/docs/Web/API/Web_Animations_API)
- [CSS scroll-driven animations](/en-US/docs/Web/CSS/CSS_scroll-driven_animations)
- {{domxref("ScrollTimeline")}}
- {{domxref("AnimationTimeline")}}, {{domxref("ViewTimeline")}}
| 0 |
data/mdn-content/files/en-us/web/api/scrolltimeline | data/mdn-content/files/en-us/web/api/scrolltimeline/axis/index.md | ---
title: "ScrollTimeline: axis property"
short-title: axis
slug: Web/API/ScrollTimeline/axis
page-type: web-api-instance-property
status:
- experimental
browser-compat: api.ScrollTimeline.axis
---
{{APIRef("Web Animations")}}{{SeeCompatTable}}
The **`axis`** read-only property of the
{{domxref("ScrollTimeline")}} interface returns an enumerated value representing the scroll axis that is driving the progress of the timeline.
## Value
An enumerated value. Possible values are:
- `"block"`
- : The scrollbar on the block axis of the scroll container, which is the axis in the direction perpendicular to the flow of text within a line. For horizontal writing modes, such as standard English, this is the same as `"y"`, while for vertical writing modes, it is the same as `"x"`.
- `"inline"`
- : The scrollbar on the inline axis of the scroll container, which is the axis in the direction parallel to the flow of text in a line. For horizontal writing modes, this is the same as `"x"`, while for vertical writing modes, this is the same as `"y"`.
- `"y"`
- : The scrollbar on the vertical axis of the scroll container.
- `"x"`
- : The scrollbar on the horizontal axis of the scroll container.
## Examples
See the main {{domxref("ScrollTimeline")}} page for an example.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("ScrollTimeline")}}
- {{domxref("AnimationTimeline")}}, {{domxref("ViewTimeline")}}
- [Web Animations API](/en-US/docs/Web/API/Web_Animations_API)
- [CSS scroll-driven animations](/en-US/docs/Web/CSS/CSS_scroll-driven_animations)
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/settimeout/index.md | ---
title: setTimeout() global function
short-title: setTimeout()
slug: Web/API/setTimeout
page-type: web-api-global-function
browser-compat: api.setTimeout
---
{{APIRef("HTML DOM")}}{{AvailableInWorkers}}
The global **`setTimeout()`** method sets a timer which executes a function or specified
piece of code once the timer expires.
## Syntax
```js-nolint
setTimeout(code)
setTimeout(code, delay)
setTimeout(functionRef)
setTimeout(functionRef, delay)
setTimeout(functionRef, delay, param1)
setTimeout(functionRef, delay, param1, param2)
setTimeout(functionRef, delay, param1, param2, /* …, */ paramN)
```
### Parameters
- `functionRef`
- : A {{jsxref("function")}} to be executed after the timer expires.
- `code`
- : An alternative syntax that allows you to include a string instead of a function,
which is compiled and executed when the timer expires. This syntax is **not
recommended** for the same reasons that make using
{{jsxref("Global_Objects/eval", "eval()")}} a security risk.
- `delay` {{optional_inline}}
- : The time, in milliseconds that the timer should wait before
the specified function or code is executed. If this parameter is omitted, a value of 0
is used, meaning execute "immediately", or more accurately, the next event cycle.
Note that in either case, the actual delay may be longer than intended; see [Reasons for delays longer than specified](#reasons_for_delays_longer_than_specified) below.
Also note that if the value isn't a number, implicit [type coercion](/en-US/docs/Glossary/Type_coercion) is silently done on the value to convert it to a number — which can lead to unexpected and surprising results; see [Non-number delay values are silently coerced into numbers](#non-number_delay_values_are_silently_coerced_into_numbers) for an example.
- `param1`, …, `paramN` {{optional_inline}}
- : Additional arguments which are passed through to the function specified by
`functionRef`.
### Return value
The returned `timeoutID` is a positive integer value which
identifies the timer created by the call to `setTimeout()`. This value can be
passed to {{domxref("clearTimeout","clearTimeout()")}} to
cancel the timeout.
It is guaranteed that a `timeoutID` value will never be reused by a subsequent call to
`setTimeout()` or `setInterval()` on the same object (a window or
a worker). However, different objects use separate pools of IDs.
## Description
Timeouts are cancelled using
{{domxref("clearTimeout()")}}.
To call a function repeatedly (e.g., every _N_ milliseconds), consider using
{{domxref("setInterval()")}}.
### Non-number delay values are silently coerced into numbers
If `setTimeout()` is called with [_delay_](#delay) value that's not a number, implicit [type coercion](/en-US/docs/Glossary/Type_coercion) is silently done on the value to convert it to a number. For example, the following code incorrectly uses the string `"1000"` for the _delay_ value, rather than the number `1000` – but it nevertheless works, because when the code runs, the string is coerced into the number `1000`, and so the code executes 1 second later.
```js example-bad
setTimeout(() => {
console.log("Delayed for 1 second.");
}, "1000");
```
But in many cases, the implicit type coercion can lead to unexpected and surprising results. For example, when the following code runs, the string `"1 second"` ultimately gets coerced into the number `0` — and so, the code executes immediately, with zero delay.
```js example-bad
setTimeout(() => {
console.log("Delayed for 1 second.");
}, "1 second");
```
Therefore, don't use strings for the _delay_ value but instead always use numbers:
```js example-good
setTimeout(() => {
console.log("Delayed for 1 second.");
}, 1000);
```
### Working with asynchronous functions
`setTimeout()` is an asynchronous function, meaning that the timer function will not pause execution of other functions in the functions stack.
In other words, you cannot use `setTimeout()` to create a "pause" before the next function in the function stack fires.
See the following example:
```js
setTimeout(() => {
console.log("this is the first message");
}, 5000);
setTimeout(() => {
console.log("this is the second message");
}, 3000);
setTimeout(() => {
console.log("this is the third message");
}, 1000);
// Output:
// this is the third message
// this is the second message
// this is the first message
```
Notice that the first function does not create a 5-second "pause" before calling the second function. Instead, the first function is called, but waits 5 seconds to
execute. While the first function is waiting to execute, the second function is called, and a 3-second wait is applied to the second function before it executes. Since neither
the first nor the second function's timers have completed, the third function is called and completes its execution first. Then the second follows. Then finally the first function
is executed after its timer finally completes.
To create a progression in which one function only fires after the completion of another function, see the documentation on [Promises](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise).
### The "this" problem
When you pass a method to `setTimeout()`, it will be invoked with a `this` value that may differ from your
expectation. The general issue is explained in detail in the [JavaScript reference](/en-US/docs/Web/JavaScript/Reference/Operators/this#callbacks).
Code executed by `setTimeout()` is called from an execution context separate
from the function from which `setTimeout` was called. The usual rules for
setting the `this` keyword for the called function apply, and if you have not
set `this` in the call or with `bind`, it will default to
the `window` (or `global`) object. It will not be the same as the
`this` value for the function that called `setTimeout`.
See the following example:
```js
const myArray = ["zero", "one", "two"];
myArray.myMethod = function (sProperty) {
console.log(arguments.length > 0 ? this[sProperty] : this);
};
myArray.myMethod(); // prints "zero,one,two"
myArray.myMethod(1); // prints "one"
```
The above works because when `myMethod` is called, its `this` is
set to `myArray` by the call, so within the function,
`this[sProperty]` is equivalent to `myArray[sProperty]`. However,
in the following:
```js
setTimeout(myArray.myMethod, 1.0 * 1000); // prints "[object Window]" after 1 second
setTimeout(myArray.myMethod, 1.5 * 1000, "1"); // prints "undefined" after 1.5 seconds
```
The `myArray.myMethod` function is passed to `setTimeout`, then
when it's called, its `this` is not set, so it defaults to the
`window` object.
There's also no option to pass a `thisArg` to
`setTimeout` as there is in Array methods such as {{jsxref("Array.forEach()", "forEach()")}} and {{jsxref("Array.reduce()", "reduce()")}}. As shown below,
using `call` to set `this` doesn't work either.
```js
setTimeout.call(myArray, myArray.myMethod, 2.0 * 1000); // error
setTimeout.call(myArray, myArray.myMethod, 2.5 * 1000, 2); // same error
```
#### Solutions
##### Use a wrapper function
A common way to solve the problem is to use a wrapper function that sets
`this` to the required value:
```js
setTimeout(function () {
myArray.myMethod();
}, 2.0 * 1000); // prints "zero,one,two" after 2 seconds
setTimeout(function () {
myArray.myMethod("1");
}, 2.5 * 1000); // prints "one" after 2.5 seconds
```
The wrapper function can be an arrow function:
```js
setTimeout(() => {
myArray.myMethod();
}, 2.0 * 1000); // prints "zero,one,two" after 2 seconds
setTimeout(() => {
myArray.myMethod("1");
}, 2.5 * 1000); // prints "one" after 2.5 seconds
```
##### Use bind()
Alternatively, you can use {{jsxref("Function.bind()", "bind()")}} to set the value of `this` for all calls to a given function:
```js
const myArray = ["zero", "one", "two"];
const myBoundMethod = function (sProperty) {
console.log(arguments.length > 0 ? this[sProperty] : this);
}.bind(myArray);
myBoundMethod(); // prints "zero,one,two" because 'this' is bound to myArray in the function
myBoundMethod(1); // prints "one"
setTimeout(myBoundMethod, 1.0 * 1000); // still prints "zero,one,two" after 1 second because of the binding
setTimeout(myBoundMethod, 1.5 * 1000, "1"); // prints "one" after 1.5 seconds
```
### Passing string literals
Passing a string instead of a function to `setTimeout()` has the same problems as using
[`eval()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval).
```js example-bad
// Don't do this
setTimeout("console.log('Hello World!');", 500);
```
```js example-good
// Do this instead
setTimeout(() => {
console.log("Hello World!");
}, 500);
```
A string passed to `setTimeout()` is evaluated in the global context, so local symbols in the context where `setTimeout()` was called will not be available when the string is evaluated as code.
### Reasons for delays longer than specified
There are a number of reasons why a timeout may take longer to fire than anticipated.
This section describes the most common reasons.
#### Nested timeouts
As specified in the [HTML standard](https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#timers),
browsers will enforce a minimum timeout of 4 milliseconds once a nested call to `setTimeout` has been scheduled 5 times.
This can be seen in the following example, in which we nest a call to `setTimeout` with a delay of `0` milliseconds,
and log the delay each time the handler is called. The first four times, the delay is approximately 0 milliseconds, and after that it is
approximately 4 milliseconds:
```html
<button id="run">Run</button>
<table>
<thead>
<tr>
<th>Previous</th>
<th>This</th>
<th>Actual delay</th>
</tr>
</thead>
<tbody id="log"></tbody>
</table>
```
```js
let last = 0;
let iterations = 10;
function timeout() {
// log the time of this call
logline(new Date().getMilliseconds());
// if we are not finished, schedule the next call
if (iterations-- > 0) {
setTimeout(timeout, 0);
}
}
function run() {
// clear the log
const log = document.querySelector("#log");
while (log.lastElementChild) {
log.removeChild(log.lastElementChild);
}
// initialize iteration count and the starting timestamp
iterations = 10;
last = new Date().getMilliseconds();
// start timer
setTimeout(timeout, 0);
}
function logline(now) {
// log the last timestamp, the new timestamp, and the difference
const tableBody = document.getElementById("log");
const logRow = tableBody.insertRow();
logRow.insertCell().textContent = last;
logRow.insertCell().textContent = now;
logRow.insertCell().textContent = now - last;
last = now;
}
document.querySelector("#run").addEventListener("click", run);
```
```css hidden
* {
font-family: monospace;
}
th,
td {
padding: 0 10px 0 10px;
text-align: center;
border: 1px solid;
}
table {
border-collapse: collapse;
margin-top: 10px;
}
```
{{EmbedLiveSample("Nested_timeouts", 100, 420)}}
#### Timeouts in inactive tabs
To reduce the load (and associated battery usage) from background tabs, browsers will enforce
a minimum timeout delay in inactive tabs. It may also be waived if a page is playing sound
using a Web Audio API {{domxref("AudioContext")}}.
The specifics of this are browser-dependent:
- Firefox Desktop and Chrome both have a minimum timeout of 1 second for inactive tabs.
- Firefox for Android has a minimum timeout of 15 minutes for inactive tabs and may unload them entirely.
- Firefox does not throttle inactive tabs if the tab contains an {{domxref("AudioContext")}}.
#### Throttling of tracking scripts
Firefox enforces additional throttling for scripts that it recognizes as tracking scripts.
When running in the foreground, the throttling minimum delay is still 4ms. In background tabs, however,
the throttling minimum delay is 10,000 ms, or 10 seconds, which comes into effect 30 seconds after a
document has first loaded.
See [Tracking Protection](https://wiki.mozilla.org/Security/Tracking_protection) for
more details.
#### Late timeouts
The timeout can also fire later than expected if the page (or the OS/browser) is busy with other tasks.
One important case to note is that the function or code snippet cannot be executed until
the thread that called `setTimeout()` has terminated. For example:
```js
function foo() {
console.log("foo has been called");
}
setTimeout(foo, 0);
console.log("After setTimeout");
```
Will write to the console:
```plain
After setTimeout
foo has been called
```
This is because even though `setTimeout` was called with a delay of zero,
it's placed on a queue and scheduled to run at the next opportunity; not immediately.
Currently-executing code must complete before functions on the queue are executed, thus
the resulting execution order may not be as expected.
#### Deferral of timeouts during pageload
Firefox will defer firing `setTimeout()` timers
while the current tab is loading. Firing is deferred until the main thread is deemed
idle (similar to [window.requestIdleCallback()](/en-US/docs/Web/API/Window/requestIdleCallback)),
or until the load event is fired.
### WebExtension background pages and timers
In [WebExtensions](/en-US/docs/Mozilla/Add-ons/WebExtensions), `setTimeout()`
does not work reliably. Extension authors should use the [`alarms`](/en-US/docs/Mozilla/Add-ons/WebExtensions/API/alarms)
API instead.
### Maximum delay value
Browsers store the delay as a 32-bit signed integer internally. This causes an integer
overflow when using delays larger than 2,147,483,647 ms (about 24.8 days), resulting in
the timeout being executed immediately.
## Examples
### Setting and clearing timeouts
The following example sets up two simple buttons in a web page and hooks them to the
`setTimeout()` and `clearTimeout()` routines. Pressing the first
button will set a timeout which shows a message after two seconds and stores the
timeout id for use by `clearTimeout()`. You may optionally cancel this
timeout by pressing on the second button.
#### HTML
```html
<button onclick="delayedMessage();">Show a message after two seconds</button>
<button onclick="clearMessage();">Cancel message before it happens</button>
<div id="output"></div>
```
#### JavaScript
```js
let timeoutID;
function setOutput(outputContent) {
document.querySelector("#output").textContent = outputContent;
}
function delayedMessage() {
setOutput("");
timeoutID = setTimeout(setOutput, 2 * 1000, "That was really slow!");
}
function clearMessage() {
clearTimeout(timeoutID);
}
```
```css hidden
#output {
padding: 0.5rem 0;
}
```
#### Result
{{EmbedLiveSample('Setting_and_clearing_timeouts')}}
See also the [`clearTimeout()` example](/en-US/docs/Web/API/clearTimeout#examples).
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Polyfill of `setTimeout` which allows passing arguments to the callback in `core-js`](https://github.com/zloirock/core-js#settimeout-and-setinterval)
- {{domxref("clearTimeout")}}
- {{domxref("setInterval()")}}
- {{domxref("window.requestAnimationFrame")}}
- {{domxref("queueMicrotask()")}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/svganimatedrect/index.md | ---
title: SVGAnimatedRect
slug: Web/API/SVGAnimatedRect
page-type: web-api-interface
browser-compat: api.SVGAnimatedRect
---
{{APIRef("SVG")}}
The `SVGAnimatedRect` interface is used for attributes of basic {{ domxref("SVGRect") }} which can be animated.
### Interface overview
<table class="no-markdown">
<tbody>
<tr>
<th scope="row">Also implement</th>
<td><em>None</em></td>
</tr>
<tr>
<th scope="row">Methods</th>
<td><em>None</em></td>
</tr>
<tr>
<th scope="row">Properties</th>
<td>
<ul>
<li>
readonly {{ domxref("SVGRect") }} <code>baseVal</code>
</li>
<li>
readonly {{ domxref("SVGRect") }} <code>animVal</code>
</li>
</ul>
</td>
</tr>
<tr>
<th scope="row">Normative document</th>
<td>
<a
href="https://www.w3.org/TR/SVG11/types.html#InterfaceSVGAnimatedRect"
>SVG 1.1 (2nd Edition)</a
>
</td>
</tr>
</tbody>
</table>
## Instance properties
<table class="no-markdown">
<thead>
<tr>
<th>Name</th>
<th>Type</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>baseVal</code></td>
<td>{{ domxref("SVGRect") }}</td>
<td>
The base value of the given attribute before applying any animations.
</td>
</tr>
<tr>
<td><code>animVal</code></td>
<td>{{ domxref("SVGRect") }}</td>
<td>
A read only {{ domxref("SVGRect") }} representing the current
animated value of the given attribute. If the given attribute is not
currently being animated, then the {{ domxref("SVGRect") }} will
have the same contents as <code>baseVal</code>. The object referenced by
<code>animVal</code> will always be distinct from the one referenced by
<code>baseVal</code>, even when the attribute is not animated.
</td>
</tr>
</tbody>
</table>
## Instance methods
_The `SVGAnimatedRect` interface do not provide any specific methods._
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/ink/index.md | ---
title: Ink
slug: Web/API/Ink
page-type: web-api-interface
status:
- experimental
browser-compat: api.Ink
---
{{APIRef("Ink API")}}{{SeeCompatTable}}
The **`Ink`** interface of the [Ink API](/en-US/docs/Web/API/Ink_API) provides access to {{domxref("InkPresenter")}} objects for the application to use to render ink strokes.
{{InheritanceDiagram}}
## Instance methods
- {{domxref("Ink.requestPresenter", "requestPresenter()")}} {{Experimental_Inline}}
- : Returns a {{jsxref("Promise")}} that fulfills with an {{domxref("InkPresenter")}} object to handle rendering strokes.
## Example
```js
async function inkInit() {
const ink = navigator.ink;
let presenter = await ink.requestPresenter({ presentationArea: canvas });
//...
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Enhancing Inking on the Web](https://blogs.windows.com/msedgedev/2021/08/18/enhancing-inking-on-the-web/)
| 0 |
data/mdn-content/files/en-us/web/api/ink | data/mdn-content/files/en-us/web/api/ink/requestpresenter/index.md | ---
title: "Ink: requestPresenter() method"
short-title: requestPresenter()
slug: Web/API/Ink/requestPresenter
page-type: web-api-instance-method
status:
- experimental
browser-compat: api.Ink.requestPresenter
---
{{APIRef("Ink API")}}{{SeeCompatTable}}
The **`requestPresenter()`** method of the {{domxref("Ink")}} interface returns a {{jsxref("Promise")}} that fulfills with an {{domxref("InkPresenter")}} object to handle rendering strokes.
## Syntax
```js-nolint
requestPresenter(param)
```
### Parameters
- `param` {{optional_inline}}
- : An `InkPresenterParam` object that contains the following property:
- `presentationArea` {{optional_inline}}
- : An {{domxref("Element")}} inside which rendering of ink strokes is confined (the element's border box, to be precise). If `param` is not included, or `presentationArea` is set to `null`, ink rendering is confined to the containing viewport by default.
### Return value
A {{jsxref("Promise")}} that resolves to an {{domxref("InkPresenter")}} object instance.
### Exceptions
- `Error` {{domxref("DOMException")}}
- : An error is thrown and the operation is aborted if `presentationArea` is not a valid {{domxref("Element")}}, or is not in the same document as the associated {{domxref("Ink")}} object.
## Example
```js
async function inkInit() {
const ink = navigator.ink;
let presenter = await ink.requestPresenter({ presentationArea: canvas });
//...
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Enhancing Inking on the Web](https://blogs.windows.com/msedgedev/2021/08/18/enhancing-inking-on-the-web/)
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/gpudevicelostinfo/index.md | ---
title: GPUDeviceLostInfo
slug: Web/API/GPUDeviceLostInfo
page-type: web-api-interface
status:
- experimental
browser-compat: api.GPUDeviceLostInfo
---
{{APIRef("WebGPU API")}}{{SeeCompatTable}}{{SecureContext_Header}}
The **`GPUDeviceLostInfo`** interface of the {{domxref("WebGPU API", "WebGPU API", "", "nocode")}} represents the object returned when the {{domxref("GPUDevice.lost")}} {{jsxref("Promise")}} resolves. This provides information as to why a device has been lost.
See the {{domxref("GPUDevice.lost")}} page for more information about "lost" state.
{{InheritanceDiagram}}
## Instance properties
- {{domxref("GPUDeviceLostInfo.message", "message")}} {{Experimental_Inline}} {{ReadOnlyInline}}
- : A string providing a human-readable message that explains why the device was lost.
- {{domxref("GPUDeviceLostInfo.reason", "reason")}} {{Experimental_Inline}} {{ReadOnlyInline}}
- : An enumerated value that defines the reason the device was lost in a machine-readable way.
## Examples
```js
async function init() {
if (!navigator.gpu) {
throw Error("WebGPU not supported.");
}
const adapter = await navigator.gpu.requestAdapter();
if (!adapter) {
throw Error("Couldn't request WebGPU adapter.");
}
// Create a GPUDevice
let device = await adapter.requestDevice(descriptor);
// Use lost to handle lost devices
device.lost.then((info) => {
console.error(`WebGPU device was lost: ${info.message}`);
device = null;
if (info.reason !== "destroyed") {
init();
}
});
// ...
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- The [WebGPU API](/en-US/docs/Web/API/WebGPU_API)
| 0 |
data/mdn-content/files/en-us/web/api/gpudevicelostinfo | data/mdn-content/files/en-us/web/api/gpudevicelostinfo/message/index.md | ---
title: "GPUDeviceLostInfo: message property"
short-title: message
slug: Web/API/GPUDeviceLostInfo/message
page-type: web-api-instance-property
status:
- experimental
browser-compat: api.GPUDeviceLostInfo.message
---
{{APIRef("WebGPU API")}}{{SeeCompatTable}}{{SecureContext_Header}}
The **`message`** read-only property of the
{{domxref("GPUDeviceLostInfo")}} interface provides a human-readable message that explains why the device was lost.
## Value
A string.
## Examples
See the main [`GPUDevice.lost` page](/en-US/docs/Web/API/GPUDevice/lost#examples) for an example.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- The [WebGPU API](/en-US/docs/Web/API/WebGPU_API)
| 0 |
data/mdn-content/files/en-us/web/api/gpudevicelostinfo | data/mdn-content/files/en-us/web/api/gpudevicelostinfo/reason/index.md | ---
title: "GPUDeviceLostInfo: reason property"
short-title: reason
slug: Web/API/GPUDeviceLostInfo/reason
page-type: web-api-instance-property
status:
- experimental
browser-compat: api.GPUDeviceLostInfo.reason
---
{{APIRef("WebGPU API")}}{{SeeCompatTable}}{{SecureContext_Header}}
The **`reason`** read-only property of the
{{domxref("GPUDeviceLostInfo")}} interface defines the reason the device was lost in a machine-readable way.
## Value
An enumerated value. At the moment the only value defined in the spec is `"destroyed"`, which indicates that the device was destroyed by a call to {{domxref("GPUDevice.destroy()")}}.
If the device was lost because of an unknown reason not covered in the available enumerated values, `reason` returns `undefined`.
## Examples
See the main [`GPUDevice.lost` page](/en-US/docs/Web/API/GPUDevice/lost#examples) for an example.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- The [WebGPU API](/en-US/docs/Web/API/WebGPU_API)
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/touch/index.md | ---
title: Touch
slug: Web/API/Touch
page-type: web-api-interface
browser-compat: api.Touch
---
{{APIRef("Touch Events")}}
The **`Touch`** interface represents a single contact point on a touch-sensitive device. The contact point is commonly a finger or stylus and the device may be a touchscreen or trackpad.
The {{ domxref("Touch.radiusX") }}, {{ domxref("Touch.radiusY") }}, and {{ domxref("Touch.rotationAngle") }} describe the area of contact between the user and the screen, the _touch area_. This can be helpful when dealing with imprecise pointing devices such as fingers. These values are set to describe an ellipse that as closely as possible matches the entire area of contact (such as the user's fingertip).
> **Note:** Many of the properties' values are hardware-dependent; for example, if the device doesn't have a way to detect the amount of pressure placed on the surface, the `force` value will always be 0. This may also be the case for `radiusX` and `radiusY`; if the hardware reports only a single point, these values will be 1.
## Constructor
- {{domxref("Touch.Touch", "Touch()")}}
- : Creates a Touch object.
## Instance properties
_This interface has no parent, and doesn't inherit or implement other properties._
### Basic properties
- {{domxref("Touch.identifier")}} {{ReadOnlyInline}}
- : Returns a unique identifier for this `Touch` object. A given touch point (say, by a finger) will have the same identifier for the duration of its movement around the surface. This lets you ensure that you're tracking the same touch all the time.
- {{domxref("Touch.screenX")}} {{ReadOnlyInline}}
- : Returns the X coordinate of the touch point relative to the left edge of the screen.
- {{domxref("Touch.screenY")}} {{ReadOnlyInline}}
- : Returns the Y coordinate of the touch point relative to the top edge of the screen.
- {{domxref("Touch.clientX")}} {{ReadOnlyInline}}
- : Returns the X coordinate of the touch point relative to the left edge of the browser viewport, not including any scroll offset.
- {{domxref("Touch.clientY")}} {{ReadOnlyInline}}
- : Returns the Y coordinate of the touch point relative to the top edge of the browser viewport, not including any scroll offset.
- {{domxref("Touch.pageX")}} {{ReadOnlyInline}}
- : Returns the X coordinate of the touch point relative to the left edge of the document. Unlike `clientX`, this value includes the horizontal scroll offset, if any.
- {{domxref("Touch.pageY")}} {{ReadOnlyInline}}
- : Returns the Y coordinate of the touch point relative to the top of the document. Unlike `clientY,` this value includes the vertical scroll offset, if any.
- {{domxref("Touch.target")}} {{ReadOnlyInline}}
- : Returns the {{ domxref("Element")}} on which the touch point started when it was first placed on the surface, even if the touch point has since moved outside the interactive area of that element or even been removed from the document.
### Touch area
- {{domxref("Touch.radiusX")}} {{ReadOnlyInline}}
- : Returns the X radius of the ellipse that most closely circumscribes the area of contact with the screen. The value is in pixels of the same scale as `screenX`.
- {{domxref("Touch.radiusY")}} {{ReadOnlyInline}}
- : Returns the Y radius of the ellipse that most closely circumscribes the area of contact with the screen. The value is in pixels of the same scale as `screenY`.
- {{domxref("Touch.rotationAngle")}} {{ReadOnlyInline}}
- : Returns the angle (in degrees) that the ellipse described by radiusX and radiusY must be rotated, clockwise, to most accurately cover the area of contact between the user and the surface.
- {{domxref("Touch.force")}} {{ReadOnlyInline}}
- : Returns the amount of pressure being applied to the surface by the user, as a `float` between `0.0` (no pressure) and `1.0` (maximum pressure).
## Instance methods
_This interface has no methods and no parent, and doesn't inherit or implement any methods._
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Touch events](/en-US/docs/Web/API/Touch_events)
- {{ domxref("Document.createTouch()") }}
| 0 |
data/mdn-content/files/en-us/web/api/touch | data/mdn-content/files/en-us/web/api/touch/screeny/index.md | ---
title: "Touch: screenY property"
short-title: screenY
slug: Web/API/Touch/screenY
page-type: web-api-instance-property
browser-compat: api.Touch.screenY
---
{{ APIRef("Touch Events") }}
Returns the Y coordinate of the touch point relative to the screen, not including any scroll offset.
## Value
A number.
## Examples
The [Touch.screenX example](/en-US/docs/Web/API/Touch/screenX#examples) includes an example of this property's usage.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/touch | data/mdn-content/files/en-us/web/api/touch/radiusx/index.md | ---
title: "Touch: radiusX property"
short-title: radiusX
slug: Web/API/Touch/radiusX
page-type: web-api-instance-property
browser-compat: api.Touch.radiusX
---
{{ APIRef("Touch Events") }}
The **`radiusX`** read-only property of the {{domxref("Touch")}} interface returns the X radius of the ellipse that most closely circumscribes the area of contact with the touch surface. The value is in CSS pixels of the same scale as {{ domxref("Touch.screenX") }}.
This value, in combination with {{ domxref("Touch.radiusY") }} and {{ domxref("Touch.rotationAngle") }} constructs an ellipse that approximates the size and shape of the area of contact between the user and the screen. This may be a relatively large ellipse representing the contact between a fingertip and the screen or a small area representing the tip of a stylus, for example.
## Value
A number.
## Examples
This example illustrates using the {{domxref("Touch")}} interface's {{domxref("Touch.radiusX")}}, {{domxref("Touch.radiusX")}} and {{domxref("Touch.rotationAngle")}} properties. The {{domxref("Touch.radiusX")}} property is the radius of the ellipse which most closely circumscribes the touching area (e.g. finger, stylus) along the axis **indicated** by the touch point's {{domxref("Touch.rotationAngle")}}. Likewise, the {{domxref("Touch.radiusY")}} property is the radius of the ellipse which most closely circumscribes the touching area (e.g. finger, stylus) along the axis **perpendicular** to that indicated by {{domxref("Touch.rotationAngle")}}. The {{domxref("Touch.rotationAngle")}} is the angle (in degrees) that the ellipse described by `radiusX` and `radiusY` is rotated clockwise about its center.
The following simple code snippet, registers a single handler for the {{domxref("Element/touchstart_event", "touchstart")}}, {{domxref("Element/touchmove_event", "touchmove")}} and {{domxref("Element/touchend_event", "touchend")}} events. When the `src` element is touched, the element's width and height will be calculate based on the touch point's `radiusX` and `radiusY` values and the element will then be rotated using the touch point's `rotationAngle`.
```html
<div id="src">…</div>
```
```js
const src = document.getElementById("src");
src.addEventListener("touchstart", rotate);
src.addEventListener("touchmove", rotate);
src.addEventListener("touchend", rotate);
function rotate(e) {
const touch = e.changedTouches.item(0);
// Turn off default event handling
e.preventDefault();
// Rotate element 'src'.
src.style.width = `${touch.radiusX * 2}px`;
src.style.height = `${touch.radiusY * 2}px`;
src.style.transform = `rotate(${touch.rotationAngle}deg)`;
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/touch | data/mdn-content/files/en-us/web/api/touch/target/index.md | ---
title: "Touch: target property"
short-title: target
slug: Web/API/Touch/target
page-type: web-api-instance-property
browser-compat: api.Touch.target
---
{{ APIRef("Touch Events") }}
The read-only **`target`** property of the `Touch` interface returns the ({{domxref("EventTarget")}}) on which the touch contact started when it was first placed on the surface, even if the touch point has since moved outside the interactive area of that element or even been removed from the document. Note that if the target element is removed from the document, events will still be targeted at it, and hence won't necessarily bubble up to the window or document anymore. If there is any risk of an element being removed while it is being touched, the best practice is to attach the touch listeners directly to the target.
## Value
The {{domxref("EventTarget")}} the {{domxref("Touch")}} object applies to.
## Examples
This example illustrates how to access the {{domxref("Touch")}} object's {{domxref("Touch.target")}} property. The {{domxref("Touch.target")}} property is an {{domxref("Element")}} ({{domxref("EventTarget")}}) on which a touch point is started when contact is first placed on the surface.
In following simple code snippet, we assume the user initiates one or more touch contacts on the `source` element. When the {{domxref("Element/touchstart_event", "touchstart")}} event handler for this element is invoked, each touch point's {{domxref("Touch.target")}} property is accessed via the event's {{domxref("TouchEvent.targetTouches")}} list.
```js
// Register a touchmove listener for the 'source' element
const src = document.getElementById("source");
src.addEventListener(
"touchstart",
(e) => {
// Iterate through the touch points that were activated
// for this element.
for (let i = 0; i < e.targetTouches.length; i++) {
console.log(`touchpoint[${i}].target = ${e.targetTouches[i].target}`);
}
},
false,
);
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/touch | data/mdn-content/files/en-us/web/api/touch/clientx/index.md | ---
title: "Touch: clientX property"
short-title: clientX
slug: Web/API/Touch/clientX
page-type: web-api-instance-property
browser-compat: api.Touch.clientX
---
{{ APIRef("Touch Events") }}
The `Touch.clientX` read-only property returns the X coordinate of the touch
point relative to the viewport, not including any scroll offset.
## Value
A `double` floating point value representing the X coordinate of the touch point
relative to the viewport, not including any scroll offset.
## Examples
This example illustrates using the {{domxref("Touch")}} object's
{{domxref("Touch.clientX")}} and {{domxref("Touch.clientY")}} properties. The
{{domxref("Touch.clientX")}} property is the horizontal coordinate of a touch point
relative to the browser's viewport excluding any scroll offset. The
{{domxref("Touch.clientY")}} property is the vertical coordinate of the touch point
relative to the browser's viewport excluding any scroll offset .
In this example, we assume the user initiates a touch on an element with an id of
`source`, moves within the element or out of the element and then releases
contact with the surface. When the {{domxref("Element/touchend_event", "touchend")}}
event handler is invoked, the changes in the {{domxref("Touch.clientX")}} and
{{domxref("Touch.clientY")}} coordinates, from the starting touch point to the ending
touch point, are calculated.
```js
// Register touchstart and touchend listeners for element 'source'
const src = document.getElementById("source");
let clientX;
let clientY;
src.addEventListener(
"touchstart",
(e) => {
// Cache the client X/Y coordinates
clientX = e.touches[0].clientX;
clientY = e.touches[0].clientY;
},
false,
);
src.addEventListener(
"touchend",
(e) => {
let deltaX;
let deltaY;
// Compute the change in X and Y coordinates.
// The first touch point in the changedTouches
// list is the touch point that was just removed from the surface.
deltaX = e.changedTouches[0].clientX - clientX;
deltaY = e.changedTouches[0].clientY - clientY;
// Process the data…
},
false,
);
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/touch | data/mdn-content/files/en-us/web/api/touch/force/index.md | ---
title: "Touch: force property"
short-title: force
slug: Web/API/Touch/force
page-type: web-api-instance-property
browser-compat: api.Touch.force
---
{{ APIRef("Touch Events") }}
The **`Touch.force`** read-only property returns the amount of
pressure the user is applying to the touch surface for a {{ domxref("Touch") }} point.
## Value
A `float` that represents the amount of pressure the user is applying to the
touch surface. This is a value between `0.0` (no pressure) and
`1.0` (the maximum amount of pressure the hardware can recognize). A value of
`0.0` is returned if no value is known (for example the touch device does not
support this property). In environments where force is known, the absolute pressure
represented by the force attribute, and the sensitivity in levels of pressure, may vary.
## Examples
This example illustrates using the {{domxref("Touch")}} interface's
{{domxref("Touch.force")}} property. This property is a relative value of pressure
applied, in the range `0.0` to `1.0`, where `0.0` is no
pressure, and `1.0` is the highest level of pressure the touch device is
capable of sensing.
In following code snippet, the {{domxref("Element/touchstart_event", "touchstart")}} event handler iterates through
the `targetTouches` list and logs the `force` value of each touch
point but the code could invoke different processing depending on the value.
```js
someElement.addEventListener(
"touchstart",
(e) => {
// Iterate through the list of touch points and log each touch
// point's force.
for (let i = 0; i < e.targetTouches.length; i++) {
// Add code to "switch" based on the force value. For example
// minimum pressure vs. maximum pressure could result in
// different handling of the user's input.
console.log(`targetTouches[${i}].force = ${e.targetTouches[i].force}`);
}
},
false,
);
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/touch | data/mdn-content/files/en-us/web/api/touch/pagey/index.md | ---
title: "Touch: pageY property"
short-title: pageY
slug: Web/API/Touch/pageY
page-type: web-api-instance-property
browser-compat: api.Touch.pageY
---
{{ APIRef("Touch Events") }}
The **`Touch.pageY`** read-only property returns the Y
coordinate of the touch point relative to the viewport, including any scroll offset.
## Value
A `double` floating point value representing the Y coordinate of the touch point
relative to the viewport, including any scroll offset.
## Examples
This example illustrates how to access the {{domxref("Touch")}} object's
{{domxref("Touch.pageX")}} and {{domxref("Touch.pageY")}} properties. The
{{domxref("Touch.pageX")}} property is the horizontal coordinate of a touch point
relative to the viewport (in CSS pixels), including any scroll offset. The
{{domxref("Touch.pageY")}} property is the vertical coordinate of a touch point relative
to the viewport (in CSS pixels), including any scroll offset.
In following simple code snippet, we assume the user initiates one or more touch
contacts on the `source` element, moves the touch points and then releases
all contacts with the surface. When the {{domxref("Element/touchmove_event", "touchmove")}} event handler is invoked,
each touch point's {{domxref("Touch.pageX")}} and {{domxref("Touch.pageY")}} coordinates
are accessed via the event's {{domxref("TouchEvent.changedTouches")}} list.
```js
// Register a touchmove listeners for the 'source' element
const src = document.getElementById("source");
src.addEventListener(
"touchmove",
(e) => {
// Iterate through the touch points that have moved and log each
// of the pageX/Y coordinates. The unit of each coordinate is CSS pixels.
for (let i = 0; i < e.changedTouches.length; i++) {
console.log(`touchpoint[${i}].pageX = ${e.changedTouches[i].pageX}`);
console.log(`touchpoint[${i}].pageY = ${e.changedTouches[i].pageY}`);
}
},
false,
);
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/touch | data/mdn-content/files/en-us/web/api/touch/touch/index.md | ---
title: "Touch: Touch() constructor"
short-title: Touch()
slug: Web/API/Touch/Touch
page-type: web-api-constructor
browser-compat: api.Touch.Touch
---
{{APIRef("Touch Events")}}
The **`Touch()`** constructor creates a new {{domxref("Touch")}} object.
## Syntax
```js-nolint
new Touch(options)
```
### Parameters
- `touchInit`
- : An object with the following fields:
- `identifier`
- : A `long` value, that is the identification number for the touch point.
- `target`
- : A {{domxref("EventTarget")}} object, the item at which the touch point started when it was first placed on the surface.
- `clientX` {{optional_inline}}
- : Defaults to `0`, of type `double`, that is the horizontal position of the touch on the client window of user's screen, excluding any scroll offset.
- `clientY` {{optional_inline}}
- : Defaults to `0`, of type `double`, that is the vertical position of the touch on the client window of the user's screen, excluding any scroll offset.
- `screenX` {{optional_inline}}
- : Defaults to `0`, of type `double`, that is the horizontal position of the touch on the user's screen.
- `screenY` {{optional_inline}}
- : Defaults to `0`, of type `double`, that is the vertical position of the touch on the user's screen.
- `pageX` {{optional_inline}}
- : Defaults to `0`, of type `double`, that is the horizontal position of the touch on the client window of user's screen, including any scroll offset.
- `pageY` {{optional_inline}}
- : Defaults to `0`, of type `double`, that is the vertical position of the touch on the client window of the user's screen, including any scroll offset.
- `radiusX` {{optional_inline}}
- : Defaults to `0`, of type `float`, that is the radius of the ellipse which most closely circumscribes the touching area (e.g. finger, stylus) along the axis indicated by rotationAngle, in CSS pixels of the same scale as screenX; `0` if no value is known. The value must not be negative.
- `radiusY` {{optional_inline}}
- : Defaults to `0`, of type `float`, that is the radius of the ellipse which most closely circumscribes the touching area (e.g. finger, stylus) along the axis perpendicular to that indicated by rotationAngle, in CSS pixels of the same scale as screenY; `0` if no value is known. The value must not be negative.
- `rotationAngle` {{optional_inline}}
- : Defaults to `0`, of type `float`, that is the angle (in degrees) that the ellipse described by radiusX and radiusY is rotated clockwise about its center; `0` if no value is known. The value must be greater than or equal to `0` and less than `90`. If the ellipse described by radiusX and radiusY is circular, then rotationAngle has no effect. The user agent may use `0` as the value in this case, or it may use any other value in the allowed range. (For example, the user agent may use the rotationAngle value from the previous touch event, to avoid sudden changes.).
- `force` {{optional_inline}}
- : Defaults to `0`, of type `float`, that is the relative value of pressure applied, in the range `0` to `1`, where `0` is no pressure, and `1` is the highest level of pressure the touch device is capable of sensing; `0` if no value is known. In environments where force is known, the absolute pressure represented by the force attribute, and the sensitivity in levels of pressure, may vary.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("TouchEvent")}}, the interface of the objects it constructs.
| 0 |
data/mdn-content/files/en-us/web/api/touch | data/mdn-content/files/en-us/web/api/touch/identifier/index.md | ---
title: "Touch: identifier property"
short-title: identifier
slug: Web/API/Touch/identifier
page-type: web-api-instance-property
browser-compat: api.Touch.identifier
---
{{ APIRef("Touch Events") }}
The **`Touch.identifier`** returns a value uniquely identifying
this point of contact with the touch surface. This value remains consistent for every
event involving this finger's (or stylus's) movement on the surface until it is lifted
off the surface.
## Value
A `long` that represents the unique ID of the {{ domxref("Touch") }} object.
## Examples
```js
someElement.addEventListener(
"touchmove",
(e) => {
// Iterate through the list of touch points that changed
// since the last event and print each touch point's identifier.
for (let i = 0; i < e.changedTouches.length; i++) {
console.log(
`changedTouches[${i}].identifier = ${e.changedTouches[i].identifier}`,
);
}
},
false,
);
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/touch | data/mdn-content/files/en-us/web/api/touch/screenx/index.md | ---
title: "Touch: screenX property"
short-title: screenX
slug: Web/API/Touch/screenX
page-type: web-api-instance-property
browser-compat: api.Touch.screenX
---
{{ APIRef("Touch Events") }}
Returns the X coordinate of the touch point relative to the screen, not including any scroll offset.
## Value
A number.
## Examples
This example illustrates how to access the {{domxref("Touch")}} object's {{domxref("Touch.screenX")}} and {{domxref("Touch.screenY")}} properties. The {{domxref("Touch.screenX")}} property is the horizontal (x) coordinate of a touch point relative to the screen in CSS pixels. The {{domxref("Touch.screenY")}} property is the vertical coordinate of a touch point relative to the screen in CSS pixels.
In following simple code snippet, we assume the user initiates multiple touch contacts on an element with an id of `source` and then releases contacts with the surface. When the {{domxref("Element/touchstart_event", "touchstart")}} event handler is invoked, each touch point's {{domxref("Touch.screenX")}} and {{domxref("Touch.screenY")}} coordinates are accessed.
```js
// Register a touchstart listeners for the 'source' element
const src = document.getElementById("source");
src.addEventListener(
"touchstart",
(e) => {
// Iterate through the touch points and log each screenX/Y coordinate.
// The unit of each coordinate is CSS pixels.
for (let i = 0; i < e.touches.length; i++) {
console.log(`touchpoint[${i}].screenX = ${e.touches[i].screenX}`);
console.log(`touchpoint[${i}].screenY = ${e.touches[i].screenY}`);
}
},
false,
);
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/touch | data/mdn-content/files/en-us/web/api/touch/rotationangle/index.md | ---
title: "Touch: rotationAngle property"
short-title: rotationAngle
slug: Web/API/Touch/rotationAngle
page-type: web-api-instance-property
browser-compat: api.Touch.rotationAngle
---
{{ APIRef("Touch Events") }}
The **`rotationAngle`** read-only property of the {{domxref("Touch")}} interface returns the rotation angle, in degrees, of the contact area ellipse defined by {{ domxref("Touch.radiusX") }} and {{ domxref("Touch.radiusY") }}. The value may be between 0 and 90. Together, these three values describe an ellipse that approximates the size and shape of the area of contact between the user and the screen. This may be a relatively large ellipse representing the contact between a fingertip and the screen or a small area representing the tip of a stylus, for example.
## Value
A number.
## Examples
The [Touch.radiusX example](/en-US/docs/Web/API/Touch/radiusX#examples) includes an example of this property's usage.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/touch | data/mdn-content/files/en-us/web/api/touch/pagex/index.md | ---
title: "Touch: pageX property"
short-title: pageX
slug: Web/API/Touch/pageX
page-type: web-api-instance-property
browser-compat: api.Touch.pageX
---
{{ APIRef("Touch Events") }}
The **`Touch.pageX`** read-only property returns the X
coordinate of the touch point relative to the viewport, including any scroll offset.
## Value
A `double` floating point value representing the X coordinate of the touch point
relative to the viewport, including any scroll offset.
## Examples
This example illustrates how to access the {{domxref("Touch")}} object's
{{domxref("Touch.pageX")}} and {{domxref("Touch.pageY")}} properties. The
{{domxref("Touch.pageX")}} property is the horizontal coordinate of a touch point
relative to the viewport (in CSS pixels), including any scroll offset. The
{{domxref("Touch.pageY")}} property is the vertical coordinate of a touch point relative
to the viewport (in CSS pixels), including any scroll offset.
In following simple code snippet, we assume the user initiates one or more touch
contacts on the `source` element, moves the touch points and then releases
all contacts with the surface. When the {{domxref("Element/touchmove_event", "touchmove")}} event handler is invoked,
each touch point's {{domxref("Touch.pageX")}} and {{domxref("Touch.pageY")}} coordinates
are accessed via the event's {{domxref("TouchEvent.changedTouches")}} list.
```js
// Register a touchmove listeners for the 'source' element
const src = document.getElementById("source");
src.addEventListener(
"touchmove",
(e) => {
// Iterate through the touch points that have moved and log each
// of the pageX/Y coordinates. The unit of each coordinate is CSS pixels.
for (let i = 0; i < e.changedTouches.length; i++) {
console.log(`touchpoint[${i}].pageX = ${e.changedTouches[i].pageX}`);
console.log(`touchpoint[${i}].pageY = ${e.changedTouches[i].pageY}`);
}
},
false,
);
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/touch | data/mdn-content/files/en-us/web/api/touch/radiusy/index.md | ---
title: "Touch: radiusY property"
short-title: radiusY
slug: Web/API/Touch/radiusY
page-type: web-api-instance-property
browser-compat: api.Touch.radiusY
---
{{ APIRef("Touch Events") }}
The **`radiusY`** read-only property of the {{domxref("Touch")}} interface returns the Y radius of the ellipse that most closely circumscribes the area of contact with the touch surface. The value is in CSS pixels of the same scale as {{ domxref("Touch.screenX") }}.
This value, in combination with {{ domxref("Touch.radiusX") }} and {{ domxref("Touch.rotationAngle") }} constructs an ellipse that approximates the size and shape of the area of contact between the user and the screen. This may be a large ellipse representing the contact between a fingertip and the screen or a small one representing the tip of a stylus, for example.
## Value
A number.
## Examples
The [Touch.radiusX example](/en-US/docs/Web/API/Touch/radiusX#examples) includes an example of this property's usage.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/touch | data/mdn-content/files/en-us/web/api/touch/clienty/index.md | ---
title: "Touch: clientY property"
short-title: clientY
slug: Web/API/Touch/clientY
page-type: web-api-instance-property
browser-compat: api.Touch.clientY
---
{{ APIRef("Touch Events") }}
The **`Touch.clientY`** read-only property returns the Y
coordinate of the touch point relative to the browser's viewport, not including any
scroll offset.
## Value
A `double` floating point value representing the Y coordinate of the touch point
relative to the viewport, not including any scroll offset.
## Examples
This example illustrates using the {{domxref("Touch")}} object's
{{domxref("Touch.clientX")}} and {{domxref("Touch.clientY")}} properties. The
{{domxref("Touch.clientX")}} property is the horizontal coordinate of a touch point
relative to the browser's viewport excluding any scroll offset. The
{{domxref("Touch.clientY")}} property is the vertical coordinate of the touch point
relative to the browser's viewport excluding any scroll offset .
In this example, we assume the user initiates a touch on an element with an id of
`source`, moves within the element or out of the element and then releases
contact with the surface. When the {{domxref("Element/touchend_event", "touchend")}}
event handler is invoked, the changes in the {{domxref("Touch.clientX")}} and
{{domxref("Touch.clientY")}} coordinates, from the starting touch point to the ending
touch point, are calculated.
```js
// Register touchstart and touchend listeners for element 'source'
const src = document.getElementById("source");
let clientX;
let clientY;
src.addEventListener(
"touchstart",
(e) => {
// Cache the client X/Y coordinates
clientX = e.touches[0].clientX;
clientY = e.touches[0].clientY;
},
false,
);
src.addEventListener(
"touchend",
(e) => {
let deltaX;
let deltaY;
// Compute the change in X and Y coordinates.
// The first touch point in the changedTouches
// list is the touch point that was just removed from the surface.
deltaX = e.changedTouches[0].clientX - clientX;
deltaY = e.changedTouches[0].clientY - clientY;
// Process the data…
},
false,
);
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/scheduler_property/index.md | ---
title: scheduler global property
short-title: scheduler
slug: Web/API/scheduler_property
page-type: web-api-global-property
browser-compat: api.scheduler
---
{{APIRef("Prioritized Task Scheduling API")}}
The global read-only **`scheduler`** property is the entry point for using the [Prioritized Task Scheduling API](/en-US/docs/Web/API/Prioritized_Task_Scheduling_API).
It is implemented by both [`Window`](/en-US/docs/Web/API/Window#scheduler) and [`WorkerGlobalScope`](/en-US/docs/Web/API/WorkerGlobalScope#scheduler).
The existence of the property indicates that the API is supported in the current context, and can be accessed using `this.scheduler`.
The object has a single instance method {{domxref('Scheduler.postTask()')}} that is used to post prioritized tasks for scheduling.
## Value
A {{domxref("Scheduler")}}.
## Examples
The code below shows a very basic use of the property and its associated interface.
It demonstrates how to check that the property exists and then posts a task that returns a promise.
```js
// Check if the prioritized task API is supported
if ("scheduler" in this) {
// Callback function - "the task"
const myTask = () => "Task 1: user-visible";
// Post task with default priority: 'user-visible' (no other options)
// When the task resolves, Promise.then() logs the result.
scheduler
.postTask(myTask)
// Handle resolved value
.then((taskResult) => console.log(`${taskResult}`))
// Handle error or abort
.catch((error) => console.log(`Error: ${error}`));
} else {
console.log("Feature: NOT Supported");
}
```
For comprehensive example code showing to use the API see [Prioritized Task Scheduling API > Examples](/en-US/docs/Web/API/Prioritized_Task_Scheduling_API#examples).
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Prioritized Task Scheduling API](/en-US/docs/Web/API/Prioritized_Task_Scheduling_API)
- {{domxref('Scheduler.postTask()')}}
- {{domxref('TaskController')}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/ndefreadingevent/index.md | ---
title: NDEFReadingEvent
slug: Web/API/NDEFReadingEvent
page-type: web-api-interface
status:
- experimental
browser-compat: api.NDEFReadingEvent
---
{{securecontext_header}}{{SeeCompatTable}}{{APIRef}}
The **`NDEFReadingEvent`** interface of the [Web NFC API](/en-US/docs/Web/API/Web_NFC_API) represents events dispatched on new NFC readings obtained by {{DOMxRef("NDEFReader")}}.
{{InheritanceDiagram}}
## Constructor
- {{DOMxRef("NDEFReadingEvent.NDEFReadingEvent", "NDEFReadingEvent.NDEFReadingEvent()")}} {{Experimental_Inline}}
- : Creates a new `NDEFReadingEvent`.
## Instance properties
_Inherits properties from its parent, {{DOMxRef("Event")}}_.
- {{DOMxRef("NDEFReadingEvent.message")}} {{ReadOnlyInline}} {{Experimental_Inline}}
- : Returns an {{DOMxRef("NDEFMessage")}} object containing the received message.
- {{DOMxRef("NDEFReadingEvent.serialNumber")}} {{ReadOnlyInline}} {{Experimental_Inline}}
- : Returns the serial number of the device, which is used for anti-collision and identification, or an empty string if no serial number is available.
## Instance methods
_Inherits methods from its parent, {{DOMxRef("Event")}}_.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/ndefreadingevent | data/mdn-content/files/en-us/web/api/ndefreadingevent/ndefreadingevent/index.md | ---
title: "NDEFReadingEvent: NDEFReadingEvent() constructor"
short-title: NDEFReadingEvent()
slug: Web/API/NDEFReadingEvent/NDEFReadingEvent
page-type: web-api-constructor
status:
- experimental
browser-compat: api.NDEFReadingEvent.NDEFReadingEvent
---
{{securecontext_header}}{{APIRef()}}{{SeeCompatTable}}
The **`NDEFReadingEvent()`** constructor creates a new {{domxref("NDEFReadingEvent")}} object which represents events dispatched on new NFC readings obtained by {{DOMxRef("NDEFReader")}}.
## Syntax
```js-nolint
new NDEFReadingEvent(type, options)
```
### Parameters
- `type`
- : A string with the name of the event.
It is case-sensitive and browsers always set it to `reading`.
- `options`
- : An object that, _in addition of the properties defined in {{domxref("Event/Event", "Event()")}}_, can have the following properties:
- `serialNumber` {{optional_inline}}
- : The serial number of the device a message was read from. It default to `""`, and can be set to `null`.
- `message`
- : An object with the following members:
- `data` {{optional_inline}}
- : Contains the data to be transmitted. It can be a string object or literal, an {{jsxref("ArrayBuffer")}}, a {{jsxref("TypedArray")}}, a {{jsxref("DataView")}}, or an array of nested records.
- `encoding` {{optional_inline}}
- : A string specifying the record's encoding.
- `id` {{optional_inline}}
- : A developer-defined identifier for the record.
- `lang` {{optional_inline}}
- : A valid language tag according to {{RFC(5646, "Tags for Identifying Languages (also known as BCP 47)")}}.
- `mediaType` {{optional_inline}}
- : A valid [MIME type](/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types).
- `recordType`
- : A string indicating the type of data stored in `data`. It must be one of the following values:
- `"absolute-url"`
An absolute URL to the data.
`"empty"`
- : An empty {{domxref("NDEFRecord")}}.
- `"mime"`
- : A valid [MIME type](/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types).
- `"smart-poster"`
- : A smart poster as defined by the [NDEF-SMARTPOSTER](https://w3c.github.io/web-nfc/#bib-ndef-smartposter) specification.
- `"text"`
- : Text as defined by the [NDEF-TEXT](https://w3c.github.io/web-nfc/#bib-ndef-text) specification.
- `"unknown"`
- : The record type is not known.
- `"URL"`
- : A URL as defined by the [NDEF-URI](https://w3c.github.io/web-nfc/#bib-ndef-uri) specification.
### Return value
A new {{domxref("NDEFReadingEvent")}} object.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/ndefreadingevent | data/mdn-content/files/en-us/web/api/ndefreadingevent/message/index.md | ---
title: "NDEFReadingEvent: message property"
short-title: message
slug: Web/API/NDEFReadingEvent/message
page-type: web-api-instance-property
status:
- experimental
browser-compat: api.NDEFReadingEvent.message
---
{{securecontext_header}}{{APIRef()}}{{SeeCompatTable}}
The **`message`** property of the {{domxref("NDEFReadingEvent")}} interface returns an {{DOMxRef("NDEFMessage")}} object containing the received message.
## Value
An {{domxref("NDEFMessage")}} object.
## Examples
This example shows how to create a convenience function that reads a single tag and then stops polling, saving battery life by cutting unneeded work. The example could easily be extended to time out after a given amount of milliseconds.
```js
const ndefReader = new NDEFReader();
function read() {
return new Promise((resolve, reject) => {
const ctlr = new AbortController();
ctlr.signal.onabort = reject;
ndefReader.addEventListener(
"reading",
(event) => {
ctlr.abort();
resolve(event);
},
{ once: true },
);
ndefReader.scan({ signal: ctlr.signal }).catch((err) => reject(err));
});
}
read().then(({ serialNumber }) => {
console.log(serialNumber);
});
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/ndefreadingevent | data/mdn-content/files/en-us/web/api/ndefreadingevent/serialnumber/index.md | ---
title: "NDEFReadingEvent: serialNumber property"
short-title: serialNumber
slug: Web/API/NDEFReadingEvent/serialNumber
page-type: web-api-instance-property
status:
- experimental
browser-compat: api.NDEFReadingEvent.serialNumber
---
{{securecontext_header}}{{APIRef()}}{{SeeCompatTable}}
The **`serialNumber`** property of the {{domxref("NDEFReadingEvent")}} interface returns the serial number of the device, which is used for anti-collision and identification, or an empty string if no serial number is available.
## Value
A string containing the device's serial number.
## Examples
This example shows how to create a convenience function that reads a single tag and then stops polling, saving battery life by cutting unneeded work. The example could easily be extended to time out after a given amount of milliseconds.
```js
const ndefReader = new NDEFReader();
function read() {
return new Promise((resolve, reject) => {
const ctlr = new AbortController();
ctlr.signal.onabort = reject;
ndefReader.addEventListener(
"reading",
(event) => {
ctlr.abort();
resolve(event);
},
{ once: true },
);
ndefReader.scan({ signal: ctlr.signal }).catch((err) => reject(err));
});
}
read().then(({ serialNumber }) => {
console.log(serialNumber);
});
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/gamepadevent/index.md | ---
title: GamepadEvent
slug: Web/API/GamepadEvent
page-type: web-api-interface
browser-compat: api.GamepadEvent
---
{{APIRef("Gamepad API")}}{{securecontext_header}}
The GamepadEvent interface of the Gamepad API contains references to gamepads connected to the system, which is what the gamepad events {{domxref("Window.gamepadconnected_event", "gamepadconnected")}} and {{domxref("Window.gamepaddisconnected_event", "gamepaddisconnected")}} are fired in response to.
{{InheritanceDiagram}}
## Constructor
- {{domxref("GamepadEvent.GamepadEvent","GamepadEvent()")}}
- : Returns a new `GamepadEvent` object.
## Instance properties
- {{ domxref("GamepadEvent.gamepad") }} {{ReadOnlyInline}}
- : Returns a {{ domxref("Gamepad") }} object, providing access to the associated gamepad data for the event fired.
## Examples
The gamepad property being called on a fired {{domxref("Window.gamepadconnected_event", "gamepadconnected")}} event.
```js
window.addEventListener("gamepadconnected", (e) => {
console.log(
"Gamepad connected at index %d: %s. %d buttons, %d axes.",
e.gamepad.index,
e.gamepad.id,
e.gamepad.buttons.length,
e.gamepad.axes.length,
);
});
```
And on a {{domxref("Window.gamepaddisconnected_event", "gamepaddisconnected")}} event.
```js
window.addEventListener("gamepaddisconnected", (e) => {
console.log(
"Gamepad disconnected from index %d: %s",
e.gamepad.index,
e.gamepad.id,
);
});
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
[Using the Gamepad API](/en-US/docs/Web/API/Gamepad_API/Using_the_Gamepad_API)
| 0 |
data/mdn-content/files/en-us/web/api/gamepadevent | data/mdn-content/files/en-us/web/api/gamepadevent/gamepad/index.md | ---
title: "GamepadEvent: gamepad property"
short-title: gamepad
slug: Web/API/GamepadEvent/gamepad
page-type: web-api-instance-property
browser-compat: api.GamepadEvent.gamepad
---
{{APIRef("Gamepad API")}}{{SecureContext_Header}}
The **`GamepadEvent.gamepad`** property of the
**{{domxref("GamepadEvent")}} interface** returns a {{domxref("Gamepad")}}
object, providing access to the associated gamepad data for fired
{{domxref("Window.gamepadconnected_event", "gamepadconnected")}} and {{domxref("Window.gamepaddisconnected_event", "gamepaddisconnected")}} events.
## Value
A {{domxref("Gamepad")}} object.
## Examples
The `gamepad` property being called on a fired
{{domxref("Window.gamepadconnected_event", "gamepadconnected")}} event.
```js
window.addEventListener("gamepadconnected", (e) => {
console.log(
"Gamepad connected at index %d: %s. %d buttons, %d axes.",
e.gamepad.index,
e.gamepad.id,
e.gamepad.buttons.length,
e.gamepad.axes.length,
);
});
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
[Using the Gamepad API](/en-US/docs/Web/API/Gamepad_API/Using_the_Gamepad_API)
| 0 |
data/mdn-content/files/en-us/web/api/gamepadevent | data/mdn-content/files/en-us/web/api/gamepadevent/gamepadevent/index.md | ---
title: "GamepadEvent: GamepadEvent() constructor"
short-title: GamepadEvent()
slug: Web/API/GamepadEvent/GamepadEvent
page-type: web-api-constructor
browser-compat: api.GamepadEvent.GamepadEvent
---
{{APIRef("Gamepad API")}}{{SecureContext_Header}}
The **`GamepadEvent()`** constructor creates a new {{domxref("GamepadEvent")}} object.
## Syntax
```js-nolint
new GamepadEvent(type, options)
```
### Parameters
- `type`
- : A string with the name of the event.
It is case-sensitive and browsers set it to `gamepadconnected` or `gamepaddisconnected`.
- `options`
- : An object that, _in addition of the properties defined in {{domxref("Event/Event", "Event()")}}_, can have the following properties:
- `gamepad`
- : A {{domxref("Gamepad")}} object describing the gamepad associated with the event.
### Return value
A new {{domxref("GamepadEvent")}} object.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/launch_handler_api/index.md | ---
title: Launch Handler API
slug: Web/API/Launch_Handler_API
page-type: web-api-overview
status:
- experimental
browser-compat: api.Window.launchQueue
---
{{SeeCompatTable}}{{DefaultAPISidebar("Launch Handler API")}}
The **Launch Handler API** allows developers to control how a [progressive web app](/en-US/docs/Web/Progressive_web_apps) (PWA) is launched — for example if it uses an existing window or creates a new one, and how the app's target launch URL is handled.
## Concepts and usage
You can specify launch behavior for your app by adding the [`launch_handler`](/en-US/docs/Web/Manifest/launch_handler) field to your web app manifest file. This has one sub-field, `client_mode`, which contains a string value specifying how the app should be launched and navigated to. For example:
```json
"launch_handler": {
"client_mode": "focus-existing"
}
```
If not specified, the default `client_mode` value is `auto`. Available values are:
- `focus-existing`
- : The most recently interacted with browsing context in a web app window is chosen to handle the launch. This will populate the target launch URL in the {{domxref("LaunchParams.targetURL", "targetURL")}} property of the {{domxref("LaunchParams")}} object passed into the {{domxref("LaunchQueue.setConsumer", "window.launchQueue.setConsumer()")}}'s callback function. As you'll see below, this allows you to set custom launch handing functionality for your app.
- `navigate-existing`
- : The most recently interacted with browsing context in a web app window is navigated to the target launch URL. The target URL is still made available via {{domxref("LaunchQueue.setConsumer", "window.launchQueue.setConsumer()")}} to allow additional custom launch navigation handling to be implemented.
- `navigate-new`
- : A new browsing context is created in a web app window to load the target launch URL. The target URL is still made available via {{domxref("LaunchQueue.setConsumer", "window.launchQueue.setConsumer()")}} to allow additional custom launch navigation handling to be implemented.
- `auto`
- : The user agent decides what works best for the platform. For example, <code>navigate-existing</code> might make more sense on mobile, where single app instances are commonplace, whereas <code>navigate-new</code> might make more sense in a desktop context. This is the default value used if provided values are invalid.
When `focus-existing` is used, you can include code inside the {{domxref("LaunchQueue.setConsumer", "window.launchQueue.setConsumer()")}}'s callback function to provide custom handling of the {{domxref("LaunchParams.targetURL", "targetURL")}}
```js
window.launchQueue.setConsumer((launchParams) => {
// Do something with launchParams.targetURL
});
```
> **Note:** {{domxref("LaunchParams")}} also has a {{domxref("LaunchParams.files")}} property, which returns a read-only array of {{domxref("FileSystemHandle")}} objects representing any files passed along with the launch navigation via the [`POST`](/en-US/docs/Web/HTTP/Methods/POST) method. This allows custom file handling to be implemented.
## Interfaces
- {{domxref("LaunchParams")}}
- : Used when implementing custom launch navigation handling in a PWA. When {{domxref("LaunchQueue.setConsumer", "window.launchQueue.setConsumer()")}} is invoked to set up the launch navigation handling functionality, the callback function inside `setConsumer()` is passed a `LaunchParams` object instance.
- {{domxref("LaunchQueue")}}
- : When a [progressive web app](/en-US/docs/Web/Progressive_web_apps) (PWA) is launched with a [`launch_handler`](/en-US/docs/Web/Manifest/launch_handler) `client_mode` value of `focus-existing`, `navigate-new`, or `navigate-existing`, `LaunchQueue` provides access to functionality that allows custom launch navigation handling to be implemented in the PWA. This functionality is controlled by the properties of the {{domxref("LaunchParams")}} object passed into the {{domxref("LaunchQueue.setConsumer", "setConsumer()")}} callback function.
## Extensions to other interfaces
- {{domxref("window.launchQueue")}}
- : Provides access to the {{domxref("LaunchQueue")}} class, which allows custom launch navigation handling to be implemented in a [progressive web app](/en-US/docs/Web/Progressive_web_apps) (PWA), with the handling context signified by the [`launch_handler`](/en-US/docs/Web/Manifest/launch_handler) manifest field `client_mode` value.
## Examples
```js
if ("launchQueue" in window) {
window.launchQueue.setConsumer((launchParams) => {
if (launchParams.targetURL) {
const params = new URL(launchParams.targetURL).searchParams;
// Assuming a music player app that gets a track passed to it to be played
const track = params.get("track");
if (track) {
audio.src = track;
title.textContent = new URL(track).pathname.substr(1);
audio.play();
}
}
});
}
```
This code is included in the PWA, and executed when the app loads, upon launch. The {{domxref("LaunchQueue.setConsumer", "window.launchQueue.setConsumer()")}}'s callback function extracts the search param out of the {{domxref("LaunchParams.targetURL")}} and, if it finds a `track` param, uses it to populate an {{htmlelement("audio")}} element's `src` and play the audio track that this points to.
See the [Musicr 2.0](https://launch-handler.glitch.me/) demo app for full working code.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Launch Handler API: Control how your app is launched](https://developer.chrome.com/docs/web-platform/launch-handler/)
- [Musicr 2.0](https://launch-handler.glitch.me/) demo app
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/textmetrics/index.md | ---
title: TextMetrics
slug: Web/API/TextMetrics
page-type: web-api-interface
browser-compat: api.TextMetrics
---
{{APIRef("Canvas API")}}
The **`TextMetrics`** interface represents the dimensions of a piece of text in the canvas; a `TextMetrics` instance can be retrieved using the {{domxref("CanvasRenderingContext2D.measureText()")}} method.
## Instance properties
- {{domxref("TextMetrics.width")}} {{ReadOnlyInline}}
- : Returns the width of a segment of inline text in CSS pixels. It takes into account the current font of the context.
- {{domxref("TextMetrics.actualBoundingBoxLeft")}} {{ReadOnlyInline}}
- : Distance parallel to the baseline from the alignment point given by the {{domxref("CanvasRenderingContext2D.textAlign")}} property to the left side of the bounding rectangle of the given text, in CSS pixels; positive numbers indicating a distance going left from the given alignment point.
- {{domxref("TextMetrics.actualBoundingBoxRight")}} {{ReadOnlyInline}}
- : Returns the distance from the alignment point given by the {{domxref("CanvasRenderingContext2D.textAlign")}} property to the right side of the bounding rectangle of the given text, in CSS pixels. The distance is measured parallel to the baseline.
- {{domxref("TextMetrics.fontBoundingBoxAscent")}} {{ReadOnlyInline}}
- : Returns the distance from the horizontal line indicated by the {{domxref("CanvasRenderingContext2D.textBaseline")}} attribute to the top of the highest bounding rectangle of all the fonts used to render the text, in CSS pixels.
- {{domxref("TextMetrics.fontBoundingBoxDescent")}} {{ReadOnlyInline}}
- : Returns the distance from the horizontal line indicated by the {{domxref("CanvasRenderingContext2D.textBaseline")}} attribute to the bottom of the bounding rectangle of all the fonts used to render the text, in CSS pixels.
- {{domxref("TextMetrics.actualBoundingBoxAscent")}} {{ReadOnlyInline}}
- : Returns the distance from the horizontal line indicated by the {{domxref("CanvasRenderingContext2D.textBaseline")}} attribute to the top of the bounding rectangle used to render the text, in CSS pixels.
- {{domxref("TextMetrics.actualBoundingBoxDescent")}} {{ReadOnlyInline}}
- : Returns the distance from the horizontal line indicated by the {{domxref("CanvasRenderingContext2D.textBaseline")}} attribute to the bottom of the bounding rectangle used to render the text, in CSS pixels.
- {{domxref("TextMetrics.emHeightAscent")}} {{ReadOnlyInline}}
- : Returns the distance from the horizontal line indicated by the {{domxref("CanvasRenderingContext2D.textBaseline")}} property to the top of the _em_ square in the line box, in CSS pixels.
- {{domxref("TextMetrics.emHeightDescent")}} {{ReadOnlyInline}}
- : Returns the distance from the horizontal line indicated by the {{domxref("CanvasRenderingContext2D.textBaseline")}} property to the bottom of the _em_ square in the line box, in CSS pixels.
- {{domxref("TextMetrics.hangingBaseline")}} {{ReadOnlyInline}}
- : Returns the distance from the horizontal line indicated by the {{domxref("CanvasRenderingContext2D.textBaseline")}} property to the hanging baseline of the line box, in CSS pixels.
- {{domxref("TextMetrics.alphabeticBaseline")}} {{ReadOnlyInline}}
- : Returns the distance from the horizontal line indicated by the {{domxref("CanvasRenderingContext2D.textBaseline")}} property to the alphabetic baseline of the line box, in CSS pixels.
- {{domxref("TextMetrics.ideographicBaseline")}} {{ReadOnlyInline}}
- : Returns the distance from the horizontal line indicated by the {{domxref("CanvasRenderingContext2D.textBaseline")}} property to the ideographic baseline of the line box, in CSS pixels.
## Examples
### Baselines illustrated
This example demonstrates the baselines the `TextMetrics` object holds. The default baseline is the `alphabeticBaseline`. See also the {{domxref("CanvasRenderingContext2D.textBaseline")}} property.
#### HTML
```html
<canvas id="canvas" width="550" height="500"></canvas>
```
#### JavaScript
```js
const canvas = document.getElementById("canvas");
const ctx = canvas.getContext("2d");
const baselinesAboveAlphabetic = [
"fontBoundingBoxAscent",
"actualBoundingBoxAscent",
"emHeightAscent",
"hangingBaseline",
];
const baselinesBelowAlphabetic = [
"ideographicBaseline",
"emHeightDescent",
"actualBoundingBoxDescent",
"fontBoundingBoxDescent",
];
const baselines = [...baselinesAboveAlphabetic, ...baselinesBelowAlphabetic];
ctx.font = "25px serif";
ctx.strokeStyle = "red";
baselines.forEach((baseline, index) => {
const text = `Abcdefghijklmnop (${baseline})`;
const textMetrics = ctx.measureText(text);
const y = 50 + index * 50;
ctx.beginPath();
ctx.fillText(text, 0, y);
const baselineMetricValue = textMetrics[baseline];
if (baselineMetricValue === undefined) {
return;
}
const lineY = baselinesBelowAlphabetic.includes(baseline)
? y + Math.abs(baselineMetricValue)
: y - Math.abs(baselineMetricValue);
ctx.moveTo(0, lineY);
ctx.lineTo(550, lineY);
ctx.stroke();
});
```
#### Result
{{EmbedLiveSample('Baselines_illustrated', 700, 550)}}
### Measuring text width
When measuring the x-direction of a piece of text, the sum of `actualBoundingBoxLeft` and `actualBoundingBoxRight` can be wider than the width of the inline box (`width`), due to slanted/italic fonts where characters overhang their advance width.
It can therefore be useful to use the sum of `actualBoundingBoxLeft` and `actualBoundingBoxRight` as a more accurate way to get the absolute text width:
```js
const canvas = document.getElementById("canvas");
const ctx = canvas.getContext("2d");
const text = "Abcdefghijklmnop";
ctx.font = "italic 50px serif";
const textMetrics = ctx.measureText(text);
console.log(textMetrics.width);
// 459.8833312988281
console.log(
textMetrics.actualBoundingBoxRight + textMetrics.actualBoundingBoxLeft,
);
// 462.8833333333333
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- Creator method in {{domxref("CanvasRenderingContext2D")}}
- The {{HTMLElement("canvas")}} element and its associated interface, {{domxref("HTMLCanvasElement")}}
| 0 |
data/mdn-content/files/en-us/web/api/textmetrics | data/mdn-content/files/en-us/web/api/textmetrics/ideographicbaseline/index.md | ---
title: "TextMetrics: ideographicBaseline property"
short-title: ideographicBaseline
slug: Web/API/TextMetrics/ideographicBaseline
page-type: web-api-instance-property
browser-compat: api.TextMetrics.ideographicBaseline
---
{{APIRef("Canvas API")}}
The read-only `ideographicBaseline` property of the {{domxref("TextMetrics")}} interface is a `double` giving the distance from the horizontal line indicated by the {{domxref("CanvasRenderingContext2D.textBaseline")}} property to the ideographic baseline of the line box, in CSS pixels.
## Examples
```js
const canvas = document.createElement("canvas");
const ctx = canvas.getContext("2d");
const text = ctx.measureText("foo"); // returns TextMetrics object
text.ideographicBaseline; // -1.201171875;
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("TextMetrics")}}
| 0 |
data/mdn-content/files/en-us/web/api/textmetrics | data/mdn-content/files/en-us/web/api/textmetrics/actualboundingboxdescent/index.md | ---
title: "TextMetrics: actualBoundingBoxDescent property"
short-title: actualBoundingBoxDescent
slug: Web/API/TextMetrics/actualBoundingBoxDescent
page-type: web-api-instance-property
browser-compat: api.TextMetrics.actualBoundingBoxDescent
---
{{APIRef("Canvas API")}}
The read-only `actualBoundingBoxDescent` property of the {{domxref("TextMetrics")}} interface is a `double` giving the distance from the horizontal line indicated by the {{domxref("CanvasRenderingContext2D.textBaseline")}} attribute to the bottom of the bounding rectangle used to render the text, in CSS pixels.
## Examples
```js
const canvas = document.createElement("canvas");
const ctx = canvas.getContext("2d");
const text = ctx.measureText("foo"); // returns TextMetrics object
text.actualBoundingBoxDescent; // 0;
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("TextMetrics")}}
| 0 |
data/mdn-content/files/en-us/web/api/textmetrics | data/mdn-content/files/en-us/web/api/textmetrics/actualboundingboxleft/index.md | ---
title: "TextMetrics: actualBoundingBoxLeft property"
short-title: actualBoundingBoxLeft
slug: Web/API/TextMetrics/actualBoundingBoxLeft
page-type: web-api-instance-property
browser-compat: api.TextMetrics.actualBoundingBoxLeft
---
{{APIRef("Canvas API")}}
The read-only `actualBoundingBoxLeft` property of the {{domxref("TextMetrics")}} interface is a `double` giving the distance parallel to the baseline from the alignment point given by the {{domxref("CanvasRenderingContext2D.textAlign")}} property to the left side of the bounding rectangle of the given text, in CSS pixels; positive numbers indicating a distance going left from the given alignment point.
## Examples
```js
const canvas = document.createElement("canvas");
const ctx = canvas.getContext("2d");
const text = ctx.measureText("foo"); // returns TextMetrics object
text.actualBoundingBoxLeft; // 0;
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("TextMetrics")}}
| 0 |
data/mdn-content/files/en-us/web/api/textmetrics | data/mdn-content/files/en-us/web/api/textmetrics/fontboundingboxascent/index.md | ---
title: "TextMetrics: fontBoundingBoxAscent property"
short-title: fontBoundingBoxAscent
slug: Web/API/TextMetrics/fontBoundingBoxAscent
page-type: web-api-instance-property
browser-compat: api.TextMetrics.fontBoundingBoxAscent
---
{{APIRef("Canvas API")}}
The read-only `fontBoundingBoxAscent` property of the {{domxref("TextMetrics")}} interface returns the distance from the horizontal line indicated by the {{domxref("CanvasRenderingContext2D.textBaseline")}} attribute, to the top of the highest bounding rectangle of all the fonts used to render the text, in CSS pixels.
## Value
A number, in CSS pixels.
## Examples
The code below shows how you can get the `fontBoundingBoxAscent` for some text in a particular font.
```js
const canvas = document.createElement("canvas");
const ctx = canvas.getContext("2d");
ctx.font = "25px serif";
const text = "Foo";
const textMetrics = ctx.measureText("foo"); // returns TextMetrics object
const ascentCssPixels = textMetrics.fontBoundingBoxAscent;
```
```html hidden
<p id="log"></p>
```
```js hidden
const log = document.getElementById("log");
log.innerText = `fontBoundingBoxAscent: ${ascentCssPixels}`;
```
The ascent in CSS pixels for the text "Foo" in a 25px serif font is shown below.
{{EmbedLiveSample('Examples', 100, 50)}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("TextMetrics.fontBoundingBoxDescent")}}
- {{domxref("TextMetrics")}}
| 0 |
data/mdn-content/files/en-us/web/api/textmetrics | data/mdn-content/files/en-us/web/api/textmetrics/actualboundingboxright/index.md | ---
title: "TextMetrics: actualBoundingBoxRight property"
short-title: actualBoundingBoxRight
slug: Web/API/TextMetrics/actualBoundingBoxRight
page-type: web-api-instance-property
browser-compat: api.TextMetrics.actualBoundingBoxRight
---
{{APIRef("Canvas API")}}
The read-only `actualBoundingBoxRight` property of the {{domxref("TextMetrics")}} interface is a `double` giving the distance parallel to the baseline from the alignment point given by the {{domxref("CanvasRenderingContext2D.textAlign")}} property to the right side of the bounding rectangle of the given text, in CSS pixels.
## Examples
```js
const canvas = document.createElement("canvas");
const ctx = canvas.getContext("2d");
const text = ctx.measureText("foo"); // returns TextMetrics object
text.actualBoundingBoxRight; // 15.633333333333333;
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("TextMetrics")}}
| 0 |
data/mdn-content/files/en-us/web/api/textmetrics | data/mdn-content/files/en-us/web/api/textmetrics/emheightascent/index.md | ---
title: "TextMetrics: emHeightAscent property"
short-title: emHeightAscent
slug: Web/API/TextMetrics/emHeightAscent
page-type: web-api-instance-property
browser-compat: api.TextMetrics.emHeightAscent
---
{{APIRef("Canvas API")}}
The read-only `emHeightAscent` property of the {{domxref("TextMetrics")}} interface returns the distance from the horizontal line indicated by the {{domxref("CanvasRenderingContext2D.textBaseline")}} property to the top of the _em_ square in the line box, in CSS pixels.
## Value
A number, in CSS pixels.
## Examples
```js
const canvas = document.createElement("canvas");
const ctx = canvas.getContext("2d");
const text = ctx.measureText("foo"); // returns TextMetrics object
text.emHeightAscent; // 7.59765625;
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("TextMetrics")}}
| 0 |
data/mdn-content/files/en-us/web/api/textmetrics | data/mdn-content/files/en-us/web/api/textmetrics/alphabeticbaseline/index.md | ---
title: "TextMetrics: alphabeticBaseline property"
short-title: alphabeticBaseline
slug: Web/API/TextMetrics/alphabeticBaseline
page-type: web-api-instance-property
browser-compat: api.TextMetrics.alphabeticBaseline
---
{{APIRef("Canvas API")}}
The read-only `alphabeticBaseline` property of the {{domxref("TextMetrics")}} interface is a `double` giving the distance from the horizontal line indicated by the {{domxref("CanvasRenderingContext2D.textBaseline")}} property to the alphabetic baseline of the line box, in CSS pixels.
## Examples
```js
const canvas = document.createElement("canvas");
const ctx = canvas.getContext("2d");
const text = ctx.measureText("foo"); // returns TextMetrics object
text.alphabeticBaseline; // -0;
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("TextMetrics")}}
| 0 |
data/mdn-content/files/en-us/web/api/textmetrics | data/mdn-content/files/en-us/web/api/textmetrics/width/index.md | ---
title: "TextMetrics: width property"
short-title: width
slug: Web/API/TextMetrics/width
page-type: web-api-instance-property
browser-compat: api.TextMetrics.width
---
{{APIRef("Canvas API")}}
The read-only **`width`** property of the {{domxref("TextMetrics")}} interface contains the text's advance width (the width of that inline box) in CSS pixels.
## Examples
Start with this {{HTMLElement("canvas")}} element:
```html
<canvas id="canvas"></canvas>
```
You can get a {{domxref("TextMetrics")}} object using the following code:
```js
const canvas = document.getElementById("canvas");
const ctx = canvas.getContext("2d");
let text = ctx.measureText("foo"); // TextMetrics object
text.width; // 16;
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("TextMetrics")}}
| 0 |
data/mdn-content/files/en-us/web/api/textmetrics | data/mdn-content/files/en-us/web/api/textmetrics/hangingbaseline/index.md | ---
title: "TextMetrics: hangingBaseline property"
short-title: hangingBaseline
slug: Web/API/TextMetrics/hangingBaseline
page-type: web-api-instance-property
browser-compat: api.TextMetrics.hangingBaseline
---
{{APIRef("Canvas API")}}
The read-only `hangingBaseline` property of the {{domxref("TextMetrics")}} interface is a `double` giving the distance from the horizontal line indicated by the {{domxref("CanvasRenderingContext2D.textBaseline")}} property to the hanging baseline of the line box, in CSS pixels.
## Examples
```js
const canvas = document.createElement("canvas");
const ctx = canvas.getContext("2d");
const text = ctx.measureText("foo"); // returns TextMetrics object
text.hangingBaseline; // 6.078125;
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("TextMetrics")}}
| 0 |
data/mdn-content/files/en-us/web/api/textmetrics | data/mdn-content/files/en-us/web/api/textmetrics/fontboundingboxdescent/index.md | ---
title: "TextMetrics: fontBoundingBoxDescent property"
short-title: fontBoundingBoxDescent
slug: Web/API/TextMetrics/fontBoundingBoxDescent
page-type: web-api-instance-property
browser-compat: api.TextMetrics.fontBoundingBoxDescent
---
{{APIRef("Canvas API")}}
The read-only `fontBoundingBoxDescent` property of the {{domxref("TextMetrics")}} interface returns the distance from the horizontal line indicated by the {{domxref("CanvasRenderingContext2D.textBaseline")}} attribute to the bottom of the bounding rectangle of all the fonts used to render the text, in CSS pixels.
## Value
A number, in CSS pixels.
## Examples
The code below shows how you can get the `fontBoundingBoxDescent` for text in a particular font.
```js
const canvas = document.createElement("canvas");
const ctx = canvas.getContext("2d");
ctx.font = "25px serif";
const text = "Foo";
const textMetrics = ctx.measureText("foo"); // returns TextMetrics object
const descentCssPixels = textMetrics.fontBoundingBoxDescent;
```
```html hidden
<p id="log"></p>
```
```js hidden
const log = document.getElementById("log");
log.innerText = `fontBoundingBoxDescent: ${descentCssPixels}`;
```
The descent in CSS pixels for the text "Foo" in a 25px serif font is shown below.
{{EmbedLiveSample('Examples', 100, 50)}}
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("TextMetrics.fontBoundingBoxAscent")}}
- {{domxref("TextMetrics")}}
| 0 |
data/mdn-content/files/en-us/web/api/textmetrics | data/mdn-content/files/en-us/web/api/textmetrics/actualboundingboxascent/index.md | ---
title: "TextMetrics: actualBoundingBoxAscent property"
short-title: actualBoundingBoxAscent
slug: Web/API/TextMetrics/actualBoundingBoxAscent
page-type: web-api-instance-property
browser-compat: api.TextMetrics.actualBoundingBoxAscent
---
{{APIRef("Canvas API")}}
The read-only **`actualBoundingBoxAscent`** property of the {{domxref("TextMetrics")}} interface is a `double` giving the distance from the horizontal line indicated by the {{domxref("CanvasRenderingContext2D.textBaseline")}} attribute to the top of the bounding rectangle used to render the text, in CSS pixels.
## Examples
```js
const canvas = document.createElement("canvas");
const ctx = canvas.getContext("2d");
const text = ctx.measureText("foo"); // returns TextMetrics object
text.actualBoundingBoxAscent; // 8;
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("TextMetrics")}}
| 0 |
data/mdn-content/files/en-us/web/api/textmetrics | data/mdn-content/files/en-us/web/api/textmetrics/emheightdescent/index.md | ---
title: "TextMetrics: emHeightDescent property"
short-title: emHeightDescent
slug: Web/API/TextMetrics/emHeightDescent
page-type: web-api-instance-property
browser-compat: api.TextMetrics.emHeightDescent
---
{{APIRef("Canvas API")}}
The read-only `emHeightDescent` property of the {{domxref("TextMetrics")}} interface returns the distance from the horizontal line indicated by the {{domxref("CanvasRenderingContext2D.textBaseline")}} property to the bottom of the _em_ square in the line box, in CSS pixels.
## Value
A number, in CSS pixels.
## Examples
```js
const canvas = document.createElement("canvas");
const ctx = canvas.getContext("2d");
const text = ctx.measureText("foo"); // returns TextMetrics object
text.emHeightDescent; // -2.40234375;
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("TextMetrics")}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/eckeyimportparams/index.md | ---
title: EcKeyImportParams
slug: Web/API/EcKeyImportParams
page-type: web-api-interface
spec-urls: https://w3c.github.io/webcrypto/#dfn-EcKeyImportParams
---
{{ APIRef("Web Crypto API") }}
The **`EcKeyImportParams`** dictionary of the [Web Crypto API](/en-US/docs/Web/API/Web_Crypto_API) represents the object that should be passed as the `algorithm` parameter into {{domxref("SubtleCrypto.importKey()")}} or {{domxref("SubtleCrypto.unwrapKey()")}}, when generating any elliptic-curve-based key pair: that is, when the algorithm is identified as either of [ECDSA](/en-US/docs/Web/API/SubtleCrypto/sign#ecdsa) or [ECDH](/en-US/docs/Web/API/SubtleCrypto/deriveKey#ecdh).
## Instance properties
- `name`
- : A string. This should be set to `ECDSA` or `ECDH`, depending on the algorithm you want to use.
- `namedCurve`
- : A string representing the name of the elliptic curve to use. This may be any of the following names for [NIST](https://www.nist.gov/)-approved curves:
- `P-256`
- `P-384`
- `P-521`
## Examples
See the examples for {{domxref("SubtleCrypto.importKey()")}}.
## Specifications
{{Specifications}}
## Browser compatibility
Browsers that support the "ECDH" or "ECDSA" algorithms for the {{domxref("SubtleCrypto.importKey()")}} or {{domxref("SubtleCrypto.wrapKey()")}} methods will support this type.
## See also
- {{domxref("SubtleCrypto.importKey()")}}.
- {{domxref("SubtleCrypto.unwrapKey()")}}.
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/featurepolicy/index.md | ---
title: FeaturePolicy
slug: Web/API/FeaturePolicy
page-type: web-api-interface
status:
- experimental
browser-compat: api.FeaturePolicy
---
{{APIRef("Feature Policy")}}{{SeeCompatTable}}
The `FeaturePolicy` interface represents the set of [Permissions Policies](/en-US/docs/Web/HTTP/Permissions_Policy) applied to the current execution context.
## Instance methods
- {{DOMxRef("FeaturePolicy.allowsFeature")}} {{Experimental_Inline}}
- : Returns a Boolean that indicates whether or not a particular feature is enabled in the specified context.
- {{DOMxRef("FeaturePolicy.features")}} {{Experimental_Inline}}
- : Returns a list of names of all features supported by the User Agent. Features whose names appear on the list might not be allowed by the Permissions Policy of the current execution context and/or might be restricted by user-granted permissions.
- {{DOMxRef("FeaturePolicy.allowedFeatures")}} {{Experimental_Inline}}
- : Returns a list of names of all features supported by the User Agent and allowed by the Permissions Policy. Note that features appearing on this list might still be behind a user permission.
- {{DOMxRef("FeaturePolicy.getAllowlistForFeature")}} {{Experimental_Inline}}
- : Returns the allow for the specified feature.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{HTTPHeader("Permissions-Policy")}}
- [Privacy, permissions, and information security](/en-US/docs/Web/Privacy)
| 0 |
data/mdn-content/files/en-us/web/api/featurepolicy | data/mdn-content/files/en-us/web/api/featurepolicy/allowedfeatures/index.md | ---
title: "FeaturePolicy: allowedFeatures() method"
short-title: allowedFeatures()
slug: Web/API/FeaturePolicy/allowedFeatures
page-type: web-api-instance-method
status:
- experimental
browser-compat: api.FeaturePolicy.allowedFeatures
---
{{APIRef("Feature Policy API")}}{{SeeCompatTable}}
The **`allowedFeatures()`** method of
the {{DOMxRef("FeaturePolicy")}} interface returns a list of directive names of all
features allowed by the [Permissions Policy](/en-US/docs/Web/HTTP/Permissions_Policy). This enables introspection of individual directives
of the Permissions Policy it is run on. As such, `allowedFeatures()` method
returns a subset of directives returned by {{DOMxRef("FeaturePolicy.features",
"features()")}}.
## Syntax
```js-nolint
allowedFeatures()
```
### Parameters
None.
### Return value
An array of strings representing the Permissions Policy directive names that are allowed by
the Permissions Policy this method is called on.
## Example
The following example logs all the allowed directives for the current document. Please
note that these features might be restricted by the Permissions API, if the user did not
grant the corresponding permission yet.
```js
// First, get the Permissions Policy object
const featurePolicy = document.featurePolicy;
// Then query feature for specific
const allowed = featurePolicy.allowedFeatures();
for (const directive of allowed) {
console.log(directive);
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/featurepolicy | data/mdn-content/files/en-us/web/api/featurepolicy/features/index.md | ---
title: "FeaturePolicy: features() method"
short-title: features()
slug: Web/API/FeaturePolicy/features
page-type: web-api-instance-method
status:
- experimental
browser-compat: api.FeaturePolicy.features
---
{{APIRef("Feature Policy API")}}{{SeeCompatTable}}
The **`features()`** method of the
{{DOMxRef("FeaturePolicy")}} interface returns a list of names of all features
supported by the User Agent. Feature whose name appears on the list might not be
allowed by the [Permissions Policy](/en-US/docs/Web/HTTP/Permissions_Policy) of the current execution context and/or might not be
accessible because of user's permissions.
## Syntax
```js-nolint
features()
```
### Parameters
None.
### Return value
A list of strings that represent names of all Permissions Policy directives supported by
the user agent.
## Example
The following example logs all the supported directives in the console.
```js
// Get the FeaturePolicy object
const featurePolicy = document.featurePolicy;
// Retrieve the list of all supported Permissions Policy directives
const supportedDirectives = featurePolicy.features();
// Print out each directive into the console
for (const directive of supportedDirectives) {
console.log(directive);
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/featurepolicy | data/mdn-content/files/en-us/web/api/featurepolicy/allowsfeature/index.md | ---
title: "FeaturePolicy: allowsFeature() method"
short-title: allowsFeature()
slug: Web/API/FeaturePolicy/allowsFeature
page-type: web-api-instance-method
status:
- experimental
browser-compat: api.FeaturePolicy.allowsFeature
---
{{APIRef("Feature Policy API")}}{{SeeCompatTable}}
The **`allowsFeature()`** method of
the {{DOMxRef("FeaturePolicy")}} interface enables introspection of individual
directives of the [Permissions Policy](/en-US/docs/Web/HTTP/Permissions_Policy) it is run on. It returns a {{JSxRef("Boolean")}}
that is `true` if and only if the specified feature is allowed in the
specified context (or the default context if no context is specified).
## Syntax
```js-nolint
allowsFeature(feature)
allowsFeature(feature, origin)
```
### Parameters
- `feature`
- : The specific feature name to check its availability.
- `origin` {{Optional_inline}}
- : The specific origin name to check its availability. If not specificed, the default origin will be used.
### Return value
A {{JSxRef("Boolean")}} that is `true` if and only if the feature is
allowed.
## Example
The following example queries whether or not the document is allowed to use camera API
by the Permissions Policy. Please note that Camera API might be restricted by the
Permissions API, if the user did not grant the corresponding permission yet.
```js
// First, get the Feature Policy object
const featurePolicy = document.featurePolicy;
// Then query feature for specific
const allowed = featurePolicy.allowsFeature("camera");
if (allowed) {
console.log("FP allows camera.");
} else {
console.log("FP does not allows camera.");
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/featurepolicy | data/mdn-content/files/en-us/web/api/featurepolicy/getallowlistforfeature/index.md | ---
title: "FeaturePolicy: getAllowlistForFeature() method"
short-title: getAllowlistForFeature()
slug: Web/API/FeaturePolicy/getAllowlistForFeature
page-type: web-api-instance-method
status:
- experimental
browser-compat: api.FeaturePolicy.getAllowlistForFeature
---
{{APIRef("Feature Policy API")}}{{SeeCompatTable}}
The **`getAllowlistForFeature()`**
method of the {{DOMxRef("FeaturePolicy")}} interface enables querying of the allowlist for a specific feature for the current Permissions Policy.
## Syntax
```js-nolint
getAllowlistForFeature(feature)
```
### Parameter
- `feature`
- : The specific feature name to get its allowlist.
### Return value
An array of strings containing the serialized list of allowed origins for the feature. If a wildcard (`*`) is used, the array will contain `*`.
## Errors
The function will raise a warning if the specified Permissions Policy directive name is not
known. However, it will also return empty array, indicating that no origin is allowed to
use the feature.
## Example
The following example prints all the origins that are allowed to use Camera API by the
Permissions Policy. Please note that Camera API might also be restricted by the [Permissions API](/en-US/docs/Web/API/Permissions_API), if the user did not grant the corresponding permission.
```js
// First, get the FeaturePolicy object
const featurePolicy = document.featurePolicy;
// Query for specific feature
const allowlist = featurePolicy.getAllowlistForFeature("camera");
for (const origin of allowlist) {
console.log(origin);
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/idbdatabase/index.md | ---
title: IDBDatabase
slug: Web/API/IDBDatabase
page-type: web-api-interface
browser-compat: api.IDBDatabase
---
{{APIRef("IndexedDB")}}
The **`IDBDatabase`** interface of the IndexedDB API provides a [connection to a database](/en-US/docs/Web/API/IndexedDB_API#database_connection); you can use an `IDBDatabase` object to open a [transaction](/en-US/docs/Web/API/IndexedDB_API/Basic_Terminology#transaction) on your database then create, manipulate, and delete objects (data) in that database. The interface provides the only way to get and manage versions of the database.
{{AvailableInWorkers}}
> **Note:** Everything you do in IndexedDB always happens in the context of a [transaction](/en-US/docs/Web/API/IndexedDB_API/Basic_Terminology#transaction), representing interactions with data in the database. All objects in IndexedDB — including object stores, indexes, and cursors — are tied to a particular transaction. Thus, you cannot execute commands, access data, or open anything outside of a transaction.
{{InheritanceDiagram}}
## Instance properties
- {{domxref("IDBDatabase.name")}} {{ReadOnlyInline}}
- : A string that contains the name of the connected database.
- {{domxref("IDBDatabase.version")}} {{ReadOnlyInline}}
- : A 64-bit integer that contains the version of the connected database. When a database is first created, this attribute is an empty string.
- {{domxref("IDBDatabase.objectStoreNames")}} {{ReadOnlyInline}}
- : A {{ domxref("DOMStringList") }} that contains a list of the names of the [object stores](/en-US/docs/Web/API/IndexedDB_API/Basic_Terminology#object_store) currently in the connected database.
## Instance methods
Inherits from: [EventTarget](/en-US/docs/Web/API/EventTarget)
- {{domxref("IDBDatabase.close()")}}
- : Returns immediately and closes the connection to a database in a separate thread.
- {{domxref("IDBDatabase.createObjectStore()")}}
- : Creates and returns a new object store or index.
- {{domxref("IDBDatabase.deleteObjectStore()")}}
- : Destroys the object store with the given name in the connected database, along with any indexes that reference it.
- {{domxref("IDBDatabase.transaction()")}}
- : Immediately returns a transaction object ({{domxref("IDBTransaction")}}) containing the {{domxref("IDBTransaction.objectStore")}} method, which you can use to access your object store. Runs in a separate thread.
## Events
Listen to these events using `addEventListener()` or by assigning an event listener to the `oneventname` property of this interface.
- [`close`](/en-US/docs/Web/API/IDBDatabase/close_event)
- : An event fired when the database connection is unexpectedly closed.
- [`versionchange`](/en-US/docs/Web/API/IDBDatabase/versionchange_event)
- : An event fired when a database structure change was requested.
The following events are available to `IDBDatabase` via event bubbling from {{domxref("IDBTransaction")}}:
- `IDBTransaction` [`abort`](/en-US/docs/Web/API/IDBTransaction/abort_event)
- : An event fired when a transaction is aborted.
- `IDBTransaction` [`error`](/en-US/docs/Web/API/IDBTransaction/error_event)
- : An event fired when a request returns an error and the event bubbles up to the connection object.
## Example
In the following code snippet, we open a database asynchronously ({{domxref("IDBFactory")}}), handle success and error cases, and create a new object store in the case that an upgrade is needed ({{ domxref("IDBdatabase") }}). For a complete working example, see our [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) app ([view example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
```js
// Let us open our database
const DBOpenRequest = window.indexedDB.open("toDoList", 4);
// these two event handlers act on the IDBDatabase object,
// when the database is opened successfully, or not
DBOpenRequest.onerror = (event) => {
note.innerHTML += "<li>Error loading database.</li>";
};
DBOpenRequest.onsuccess = (event) => {
note.innerHTML += "<li>Database initialized.</li>";
// store the result of opening the database in the db
// variable. This is used a lot later on
db = DBOpenRequest.result;
// Run the displayData() function to populate the task
// list with all the to-do list data already in the IDB
displayData();
};
// This event handles the event whereby a new version of
// the database needs to be created Either one has not
// been created before, or a new version number has been
// submitted via the window.indexedDB.open line above
DBOpenRequest.onupgradeneeded = (event) => {
const db = event.target.result;
db.onerror = (event) => {
note.innerHTML += "<li>Error loading database.</li>";
};
// Create an objectStore for this database using
// IDBDatabase.createObjectStore
const objectStore = db.createObjectStore("toDoList", {
keyPath: "taskTitle",
});
// define what data items the objectStore will contain
objectStore.createIndex("hours", "hours", { unique: false });
objectStore.createIndex("minutes", "minutes", { unique: false });
objectStore.createIndex("day", "day", { unique: false });
objectStore.createIndex("month", "month", { unique: false });
objectStore.createIndex("year", "year", { unique: false });
objectStore.createIndex("notified", "notified", { unique: false });
note.innerHTML += "<li>Object store created.</li>";
};
```
This next line opens up a transaction on the Database, then opens an object store that we can then manipulate the data inside of.
```js
const objectStore = db
.transaction("toDoList", "readwrite")
.objectStore("toDoList");
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
- Starting transactions: {{domxref("IDBDatabase")}}
- Using transactions: {{domxref("IDBTransaction")}}
- Setting a range of keys: {{domxref("IDBKeyRange")}}
- Retrieving and making changes to your data: {{domxref("IDBObjectStore")}}
- Using cursors: {{domxref("IDBCursor")}}
- Reference example: [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) ([View the example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
| 0 |
data/mdn-content/files/en-us/web/api/idbdatabase | data/mdn-content/files/en-us/web/api/idbdatabase/name/index.md | ---
title: "IDBDatabase: name property"
short-title: name
slug: Web/API/IDBDatabase/name
page-type: web-api-instance-property
browser-compat: api.IDBDatabase.name
---
{{ APIRef("IndexedDB") }}
The **`name`** read-only property of the
`IDBDatabase` interface is a string that contains the
name of the connected database.
{{AvailableInWorkers}}
## Value
A string containing the name of the connected database.
## Examples
This example shows a database connection being opened, the resulting
{{domxref("IDBDatabase")}} object being stored in a db variable, and the name property
then being logged. For a full example, see our
[To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications)
app ([view example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
```js
// Let us open our database
const DBOpenRequest = window.indexedDB.open("toDoList", 4);
// these two event handlers act on the database being
// opened successfully, or not
DBOpenRequest.onerror = (event) => {
note.innerHTML += "<li>Error loading database.</li>";
};
DBOpenRequest.onsuccess = (event) => {
note.innerHTML += "<li>Database initialized.</li>";
// store the result of opening the database in the db variable. This is used a lot below
db = DBOpenRequest.result;
// This line will log the name of the database, which should be "toDoList"
console.log(db.name);
};
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
- Starting transactions: {{domxref("IDBDatabase")}}
- Using transactions: {{domxref("IDBTransaction")}}
- Setting a range of keys: {{domxref("IDBKeyRange")}}
- Retrieving and making changes to your data: {{domxref("IDBObjectStore")}}
- Using cursors: {{domxref("IDBCursor")}}
- Reference example: [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) ([View the example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
| 0 |
data/mdn-content/files/en-us/web/api/idbdatabase | data/mdn-content/files/en-us/web/api/idbdatabase/transaction/index.md | ---
title: "IDBDatabase: transaction() method"
short-title: transaction()
slug: Web/API/IDBDatabase/transaction
page-type: web-api-instance-method
browser-compat: api.IDBDatabase.transaction
---
{{ APIRef("IndexedDB") }}
The **`transaction`** method of the {{domxref("IDBDatabase")}} interface immediately
returns a transaction object ({{domxref("IDBTransaction")}}) containing the
{{domxref("IDBTransaction.objectStore")}} method, which you can use to access your
object store.
{{AvailableInWorkers}}
## Syntax
```js-nolint
transaction(storeNames)
transaction(storeNames, mode)
transaction(storeNames, mode, options)
```
### Parameters
- `storeNames`
- : The names of object stores that are in the scope of the new transaction, declared as
an array of strings. Specify only the object stores that you need to access.
If you need to access only one object store, you can specify its name as a string.
Therefore the following lines are equivalent:
```js
db.transaction(["my-store-name"]);
db.transaction("my-store-name");
```
If you need to access all object stores in the database, you can use the property
{{domxref("IDBDatabase.objectStoreNames")}}:
```js
const transaction = db.transaction(db.objectStoreNames);
```
Passing an empty array will throw an exception.
- `mode` {{optional_inline}}
- : The types of access that can be performed in the transaction. Transactions are
opened in one of three modes: `readonly`, `readwrite` and
`readwriteflush` (non-standard, Firefox-only.) `versionchange`
mode can't be specified here. If you don't provide the parameter, the default access
mode is `readonly`. To avoid slowing things down, don't open a
`readwrite` transaction unless you actually need to write into the
database.
If you need to open the object store in `readwrite` mode to change data,
you would use the following:
```js
const transaction = db.transaction("my-store-name", "readwrite");
```
As of Firefox 40, IndexedDB transactions have relaxed durability guarantees to
increase performance (see [Firefox bug 1112702](https://bugzil.la/1112702)), which is the same behavior as other
IndexedDB-supporting browsers. Previously in a `readwrite` transaction, a
{{domxref("IDBTransaction.complete_event", "complete")}} event was fired only when all data was guaranteed
to have been flushed to disk. In Firefox 40+ the `complete` event is
fired after the OS has been told to write the data but potentially before that data
has actually been flushed to disk. The `complete` event may thus be
delivered quicker than before, however, there exists a small chance that the entire
transaction will be lost if the OS crashes or there is a loss of system power before
the data is flushed to disk. Since such catastrophic events are rare most consumers
should not need to concern themselves further.
> **Note:** In Firefox, if you wish to ensure durability for some
> reason (e.g. you're storing critical data that cannot be recomputed later) you can
> force a transaction to flush to disk before delivering the `complete`
> event by creating a transaction using the experimental (non-standard)
> `readwriteflush` mode (see {{domxref("IDBDatabase.transaction")}}.)
> This is currently experimental, and can only be used if the
> `dom.indexedDB.experimental` pref is set to `true` in
> `about:config`.
- `options` {{optional_inline}}
- : Dictionary of other options. Available options are:
- `durability`
- : `"default"`, `"strict"`, or
`"relaxed"`. The default is `"default"`. Using
`"relaxed"` provides better performance, but with fewer guarantees. Web
applications are encouraged to use `"relaxed"` for ephemeral data such
as caches or quickly changing records, and `"strict"` in cases where
reducing the risk of data loss outweighs the impact to performance and power.
### Return value
An {{domxref("IDBTransaction")}} object.
### Exceptions
- `InvalidStateError` {{domxref("DOMException")}}
- : Thrown if the {{domxref("IDBDatabase.close", "close()")}} method has previously been called on this {{domxref("IDBDatabase")}} instance.
- `NotFoundError` {{domxref("DOMException")}}
- : Thrown if an object store specified in the 'storeNames' parameter has been deleted or removed.
- {{jsxref("TypeError")}}
- : Thrown if the value for the `mode` parameter is invalid.
- `InvalidAccessError` {{domxref("DOMException")}}
- : Thrown if the function was called with an empty list of store names.
## Examples
In this example we open a database connection, then use transaction() to open a
transaction on the database. For a complete example, see our
[To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) app ([view example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
```js
let db;
// Let us open our database
const DBOpenRequest = window.indexedDB.open("toDoList", 4);
DBOpenRequest.onsuccess = (event) => {
note.innerHTML += "<li>Database initialized.</li>";
// store the result of opening the database in the db variable.
// This is used a lot below
db = DBOpenRequest.result;
// Run the displayData() function to populate the task list with
// all the to-do list data already in the IDB
displayData();
};
// open a read/write db transaction, ready for adding the data
const transaction = db.transaction(["toDoList"], "readwrite");
// report on the success of opening the transaction
transaction.oncomplete = (event) => {
note.innerHTML +=
"<li>Transaction completed: database modification finished.</li>";
};
transaction.onerror = (event) => {
note.innerHTML +=
"<li>Transaction not opened due to error. Duplicate items not allowed.</li>";
};
// you would then go on to do something to this database
// via an object store
const objectStore = transaction.objectStore("toDoList");
// etc.
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
- Starting transactions: {{domxref("IDBDatabase")}}
- Using transactions: {{domxref("IDBTransaction")}}
- Setting a range of keys: {{domxref("IDBKeyRange")}}
- Retrieving and making changes to your data: {{domxref("IDBObjectStore")}}
- Using cursors: {{domxref("IDBCursor")}}
- Reference example: [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) ([View the example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
| 0 |
data/mdn-content/files/en-us/web/api/idbdatabase | data/mdn-content/files/en-us/web/api/idbdatabase/deleteobjectstore/index.md | ---
title: "IDBDatabase: deleteObjectStore() method"
short-title: deleteObjectStore()
slug: Web/API/IDBDatabase/deleteObjectStore
page-type: web-api-instance-method
browser-compat: api.IDBDatabase.deleteObjectStore
---
{{ APIRef("IndexedDB") }}
The **`deleteObjectStore()`** method of the
{{domxref("IDBDatabase")}} interface destroys the object store with the given name in
the connected database, along with any indexes that reference it.
As with {{ domxref("IDBDatabase.createObjectStore") }}, this method can be called
_only_ within a [`versionchange`](/en-US/docs/Web/API/IDBTransaction#version_change)
transaction.
{{AvailableInWorkers}}
## Syntax
```js-nolint
deleteObjectStore(name)
```
### Parameters
- `name`
- : The name of the object store you want to delete. Names are
case sensitive.
### Return value
None ({{jsxref("undefined")}}).
### Exceptions
- `InvalidStateError` {{domxref("DOMException")}}
- : Thrown if the method was not called from a `versionchange` transaction callback.
- `TransactionInactiveError` {{domxref("DOMException")}}
- : Thrown if a request is made on a source database that doesn't exist (E.g. has been deleted or removed.)
- `NotFoundError` {{domxref("DOMException")}}
- : Thrown when trying to delete an object store that does not exist.
## Examples
```js
const dbName = "sampleDB";
const dbVersion = 2;
const request = indexedDB.open(dbName, dbVersion);
request.onupgradeneeded = (event) => {
const db = request.result;
if (event.oldVersion < 1) {
db.createObjectStore("store1");
}
if (event.oldVersion < 2) {
db.deleteObjectStore("store1");
db.createObjectStore("store2");
}
// etc. for version < 3, 4…
};
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
- Starting transactions: {{domxref("IDBDatabase")}}
- Using transactions: {{domxref("IDBTransaction")}}
- Setting a range of keys: {{domxref("IDBKeyRange")}}
- Retrieving and making changes to your data: {{domxref("IDBObjectStore")}}
- Using cursors: {{domxref("IDBCursor")}}
- Reference example: [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) ([View the example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
| 0 |
data/mdn-content/files/en-us/web/api/idbdatabase | data/mdn-content/files/en-us/web/api/idbdatabase/close_event/index.md | ---
title: "IDBDatabase: close event"
short-title: close
slug: Web/API/IDBDatabase/close_event
page-type: web-api-event
browser-compat: api.IDBDatabase.close_event
---
{{ APIRef("IndexedDB") }}
The `close` event is fired on `IDBDatabase` when the database connection is unexpectedly closed. This could happen, for example, if the underlying storage is removed or if the user clears the database in the browser's history preferences.
Note that it is not fired if the database connection is closed normally using [`IDBDatabase.close()`](/en-US/docs/Web/API/IDBDatabase/close).
## Syntax
Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property.
```js
addEventListener("close", (event) => {});
onclose = (event) => {};
```
## Event type
A generic {{domxref("Event")}}.
## Examples
This example opens a database and listens for the `close` event:
```js
// Open the database
const dBOpenRequest = window.indexedDB.open("toDoList", 4);
dBOpenRequest.onupgradeneeded = (event) => {
const db = event.target.result;
// Create an objectStore for this database
const objectStore = db.createObjectStore("toDoList", {
keyPath: "taskTitle",
});
// define what data items the objectStore will contain
objectStore.createIndex("hours", "hours", { unique: false });
objectStore.createIndex("minutes", "minutes", { unique: false });
objectStore.createIndex("day", "day", { unique: false });
objectStore.createIndex("month", "month", { unique: false });
objectStore.createIndex("year", "year", { unique: false });
};
dBOpenRequest.onsuccess = (event) => {
const db = dBOpenRequest.result;
db.addEventListener("close", () => {
console.log("Database connection closed");
});
};
```
The same example, using the `onclose` property instead of `addEventListener()`:
```js
// Open the database
const dBOpenRequest = window.indexedDB.open("toDoList", 4);
dBOpenRequest.onupgradeneeded = (event) => {
const db = event.target.result;
// Create an objectStore for this database
const objectStore = db.createObjectStore("toDoList", {
keyPath: "taskTitle",
});
// define what data items the objectStore will contain
objectStore.createIndex("hours", "hours", { unique: false });
objectStore.createIndex("minutes", "minutes", { unique: false });
objectStore.createIndex("day", "day", { unique: false });
objectStore.createIndex("month", "month", { unique: false });
objectStore.createIndex("year", "year", { unique: false });
};
dBOpenRequest.onsuccess = (event) => {
const db = dBOpenRequest.result;
db.onclose = () => {
console.log("Database connection closed");
};
};
```
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
| 0 |
data/mdn-content/files/en-us/web/api/idbdatabase | data/mdn-content/files/en-us/web/api/idbdatabase/objectstorenames/index.md | ---
title: "IDBDatabase: objectStoreNames property"
short-title: objectStoreNames
slug: Web/API/IDBDatabase/objectStoreNames
page-type: web-api-instance-property
browser-compat: api.IDBDatabase.objectStoreNames
---
{{ APIRef("IndexedDB") }}
The **`objectStoreNames`** read-only property of the
{{domxref("IDBDatabase")}} interface is a {{ domxref("DOMStringList") }} containing a
list of the names of the [object stores](/en-US/docs/Web/API/IndexedDB_API/Basic_Terminology#object_store) currently in the connected database.
{{AvailableInWorkers}}
## Value
A {{ domxref("DOMStringList") }} containing a list of
the names of the [object stores](/en-US/docs/Web/API/IndexedDB_API/Basic_Terminology#object_store) currently
in the connected database.
## Examples
```js
// Let us open our database
const DBOpenRequest = window.indexedDB.open("toDoList", 4);
// these two event handlers act on the database being opened successfully, or not
DBOpenRequest.onerror = (event) => {
note.innerHTML += "<li>Error loading database.</li>";
};
DBOpenRequest.onsuccess = (event) => {
note.innerHTML += "<li>Database initialized.</li>";
// store the result of opening the database in the db variable. This is used a lot below
db = DBOpenRequest.result;
// This line will log the names of the object stores of the connected database, which should be
// an object that looks like { ['my-store-name'] }
console.log(db.objectStoreNames);
};
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
- Starting transactions: {{domxref("IDBDatabase")}}
- Using transactions: {{domxref("IDBTransaction")}}
- Setting a range of keys: {{domxref("IDBKeyRange")}}
- Retrieving and making changes to your data: {{domxref("IDBObjectStore")}}
- Using cursors: {{domxref("IDBCursor")}}
- Reference example: [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) ([View the example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
| 0 |
data/mdn-content/files/en-us/web/api/idbdatabase | data/mdn-content/files/en-us/web/api/idbdatabase/createobjectstore/index.md | ---
title: "IDBDatabase: createObjectStore() method"
short-title: createObjectStore()
slug: Web/API/IDBDatabase/createObjectStore
page-type: web-api-instance-method
browser-compat: api.IDBDatabase.createObjectStore
---
{{ APIRef("IndexedDB") }}
The **`createObjectStore()`** method of the
{{domxref("IDBDatabase")}} interface creates and returns a new {{domxref("IDBObjectStore")}}.
The method takes the name of the store as well as a parameter object that lets you
define important optional properties. You can use the property to uniquely identify
individual objects in the store. As the property is an identifier, it should be unique
to every object, and every object should have that property.
This method can be called _only_ within a [`versionchange`](/en-US/docs/Web/API/IDBTransaction#version_change)
transaction.
{{AvailableInWorkers}}
## Syntax
```js-nolint
createObjectStore(name)
createObjectStore(name, options)
```
### Parameters
- `name`
- : The name of the new object store to be created. Note that it is possible to create
an object store with an empty name.
- `options` {{optional_inline}}
- : An options object whose attributes are optional parameters to the method. It
includes the following properties:
- `keyPath` {{optional_inline}}
- : The [key path](/en-US/docs/Web/API/IndexedDB_API/Basic_Terminology#key_path)
to be used by the new object store. If empty or not specified, the
object store is created without a key path and uses
[out-of-line keys](/en-US/docs/Web/API/IndexedDB_API/Basic_Terminology#out-of-line_key).
You can also pass in an array as a `keyPath`.
- `autoIncrement` {{optional_inline}}
- : If `true`, the object store has a [key generator](/en-US/docs/Web/API/IndexedDB_API/Basic_Terminology#key_generator).
Defaults to <code>false</code>.
### Return value
A new {{domxref("IDBObjectStore")}}.
### Exceptions
This method may raise a {{domxref("DOMException")}} with a `name` of
one of the following types:
- `InvalidStateError` {{domxref("DOMException")}}
- : Thrown if the method was not called from a
`versionchange` transaction callback.
- `TransactionInactiveError` {{domxref("DOMException")}}
- : Thrown if a request is made on a source database that does not exist
(for example, when the database has been deleted or removed). In Firefox previous to version 41,
an `InvalidStateError` was raised in this case as well, which
was misleading; this has now been fixed (see [Firefox bug 1176165](https://bugzil.la/1176165)).
- `ConstraintError` {{domxref("DOMException")}}
- : Thrown if an object store with the given name (based on a case-sensitive comparison)
already exists in the connected database.
- `InvalidAccessError` {{domxref("DOMException")}}
- : Thrown if `autoIncrement` is set to true and `keyPath` is
either an empty string or an array containing an empty string.
## Examples
```js
// Let us open our database
const request = window.indexedDB.open("toDoList", 4);
// This handler is called when a new version of the database
// is created, either when one has not been created before
// or when a new version number is submitted by calling
// window.indexedDB.open().
// This handler is only supported in recent browsers.
request.onupgradeneeded = (event) => {
const db = event.target.result;
db.onerror = (event) => {
note.innerHTML += "<li>Error loading database.</li>";
};
// Create an objectStore for this database
const objectStore = db.createObjectStore("toDoList", {
keyPath: "taskTitle",
});
// define what data items the objectStore will contain
objectStore.createIndex("hours", "hours", { unique: false });
objectStore.createIndex("minutes", "minutes", { unique: false });
objectStore.createIndex("day", "day", { unique: false });
objectStore.createIndex("month", "month", { unique: false });
objectStore.createIndex("year", "year", { unique: false });
objectStore.createIndex("notified", "notified", { unique: false });
note.innerHTML += "<li>Object store created.</li>";
};
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
- Starting transactions: {{domxref("IDBDatabase")}}
- Using transactions: {{domxref("IDBTransaction")}}
- Setting a range of keys: {{domxref("IDBKeyRange")}}
- Retrieving and making changes to your data: {{domxref("IDBObjectStore")}}
- Using cursors: {{domxref("IDBCursor")}}
- Reference example: [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) ([View the example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
| 0 |
data/mdn-content/files/en-us/web/api/idbdatabase | data/mdn-content/files/en-us/web/api/idbdatabase/versionchange_event/index.md | ---
title: "IDBDatabase: versionchange event"
short-title: versionchange
slug: Web/API/IDBDatabase/versionchange_event
page-type: web-api-event
browser-compat: api.IDBDatabase.versionchange_event
---
{{APIRef("IndexedDB")}}
The `versionchange` event is fired when a database structure change ([`upgradeneeded`](/en-US/docs/Web/API/IDBOpenDBRequest/upgradeneeded_event) event send on an [`IDBOpenDBRequest`](/en-US/docs/Web/API/IDBOpenDBRequest) or [`IDBFactory.deleteDatabase`](/en-US/docs/Web/API/IDBFactory/deleteDatabase)) was requested elsewhere (most probably in
another window/tab on the same computer).
## Syntax
Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property.
```js
addEventListener("versionchange", (event) => {});
onversionchange = (event) => {};
```
## Event type
A generic {{domxref("Event")}}.
## Examples
This example opens a database and, on success, adds a listener to `versionchange`:
```js
// Open the database
const dBOpenRequest = window.indexedDB.open("Nonexistent", 4);
dBOpenRequest.onupgradeneeded = (event) => {
const db = event.target.result;
// Create an objectStore for this database
const objectStore = db.createObjectStore("toDoList", {
keyPath: "taskTitle",
});
// define what data items the objectStore will contain
objectStore.createIndex("hours", "hours", { unique: false });
objectStore.createIndex("minutes", "minutes", { unique: false });
objectStore.createIndex("day", "day", { unique: false });
objectStore.createIndex("month", "month", { unique: false });
objectStore.createIndex("year", "year", { unique: false });
};
dBOpenRequest.addEventListener("success", (event) => {
const db = event.target.result;
db.addEventListener("versionchange", (event) => {
console.log("The version of this database has changed");
});
});
```
The same example, using the `onversionchange` event handler property:
```js
// Open the database
const dBOpenRequest = window.indexedDB.open("Nonexistent", 4);
dBOpenRequest.onupgradeneeded = (event) => {
const db = event.target.result;
// Create an objectStore for this database
const objectStore = db.createObjectStore("toDoList", {
keyPath: "taskTitle",
});
// define what data items the objectStore will contain
objectStore.createIndex("hours", "hours", { unique: false });
objectStore.createIndex("minutes", "minutes", { unique: false });
objectStore.createIndex("day", "day", { unique: false });
objectStore.createIndex("month", "month", { unique: false });
objectStore.createIndex("year", "year", { unique: false });
};
dBOpenRequest.onsuccess = (event) => {
const db = event.target.result;
db.onversionchange = (event) => {
console.log("The version of this database has changed");
};
};
```
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
| 0 |
data/mdn-content/files/en-us/web/api/idbdatabase | data/mdn-content/files/en-us/web/api/idbdatabase/close/index.md | ---
title: "IDBDatabase: close() method"
short-title: close()
slug: Web/API/IDBDatabase/close
page-type: web-api-instance-method
browser-compat: api.IDBDatabase.close
---
{{ APIRef("IndexedDB") }}
The **`close()`** method of the {{domxref("IDBDatabase")}}
interface returns immediately and closes the connection in a separate thread.
The connection is not actually closed until all transactions created using this
connection are complete. No new transactions can be created for this connection once
this method is called. Methods that create transactions throw an exception if a closing
operation is pending.
{{AvailableInWorkers}}
## Syntax
```js-nolint
close()
```
### Parameters
None.
### Return value
None ({{jsxref("undefined")}}).
## Examples
```js
// Let us open our database
const DBOpenRequest = window.indexedDB.open("toDoList", 4); // opening a database.
// Create event handlers for both success and failure of
DBOpenRequest.onerror = (event) => {
note.innerHTML += "<li>Error loading database.</li>";
};
DBOpenRequest.onsuccess = (event) => {
note.innerHTML += "<li>Database initialized.</li>";
// store the result of opening the database in the db variable.
db = DBOpenRequest.result;
// now let's close the database again!
db.close();
};
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
- Starting transactions: {{domxref("IDBDatabase")}}
- Using transactions: {{domxref("IDBTransaction")}}
- Setting a range of keys: {{domxref("IDBKeyRange")}}
- Retrieving and making changes to your data: {{domxref("IDBObjectStore")}}
- Using cursors: {{domxref("IDBCursor")}}
- Reference example: [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) ([View the example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
| 0 |
data/mdn-content/files/en-us/web/api/idbdatabase | data/mdn-content/files/en-us/web/api/idbdatabase/version/index.md | ---
title: "IDBDatabase: version property"
short-title: version
slug: Web/API/IDBDatabase/version
page-type: web-api-instance-property
browser-compat: api.IDBDatabase.version
---
{{ APIRef("IndexedDB") }}
The **`version`** property of the {{domxref("IDBDatabase")}}
interface is a [64-bit integer](/en-US/docs/NSPR_API_Reference/Long_Long_%2864-bit%29_Integers)
that contains the version of the connected database.
When a database is first created, this attribute is an empty string.
{{AvailableInWorkers}}
## Value
An integer containing the version of the connected database.
## Examples
```js
// Let us open our database
const DBOpenRequest = window.indexedDB.open("toDoList", 4);
// these two event handlers act on the database
// being opened successfully, or not
DBOpenRequest.onerror = (event) => {
note.innerHTML += "<li>Error loading database.</li>";
};
DBOpenRequest.onsuccess = (event) => {
note.innerHTML += "<li>Database initialized.</li>";
// store the result of opening the database in the db variable. This is used a lot below
db = DBOpenRequest.result;
// This line will log the version of the connected database, which should be "4"
console.log(db.version);
};
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Using IndexedDB](/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB)
- Starting transactions: {{domxref("IDBDatabase")}}
- Using transactions: {{domxref("IDBTransaction")}}
- Setting a range of keys: {{domxref("IDBKeyRange")}}
- Retrieving and making changes to your data: {{domxref("IDBObjectStore")}}
- Using cursors: {{domxref("IDBCursor")}}
- Reference example: [To-do Notifications](https://github.com/mdn/dom-examples/tree/main/to-do-notifications) ([View the example live](https://mdn.github.io/dom-examples/to-do-notifications/)).
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/subtlecrypto/index.md | ---
title: SubtleCrypto
slug: Web/API/SubtleCrypto
page-type: web-api-interface
browser-compat: api.SubtleCrypto
---
{{APIRef("Web Crypto API")}}{{SecureContext_header}}
The **`SubtleCrypto`** interface of the [Web Crypto API](/en-US/docs/Web/API/Web_Crypto_API) provides a number of low-level cryptographic functions. Access to the features of `SubtleCrypto` is obtained through the {{domxref("Crypto.subtle", "subtle")}} property of the {{domxref("Crypto")}} object you get from the {{domxref("crypto_property", "crypto")}} property.
> **Warning:** This API provides a number of low-level cryptographic primitives. It's very easy to misuse them, and the pitfalls involved can be very subtle.
>
> Even assuming you use the basic cryptographic functions correctly, secure key management and overall security system design are extremely hard to get right, and are generally the domain of specialist security experts.
>
> Errors in security system design and implementation can make the security of the system completely ineffective.
>
> Please learn and experiment, but don't guarantee or imply the security of your work before an individual knowledgeable in this subject matter thoroughly reviews it. The [Crypto 101 Course](https://www.crypto101.io/) can be a great place to start learning about the design and implementation of secure systems.
## Instance properties
_This interface doesn't inherit any properties, as it has no parent interface._
## Instance methods
_This interface doesn't inherit any methods, as it has no parent interface._
- {{domxref("SubtleCrypto.encrypt()")}}
- : Returns a {{jsxref("Promise")}} that fulfills with the encrypted data corresponding to the clear text, algorithm, and key given as parameters.
- {{domxref("SubtleCrypto.decrypt()")}}
- : Returns a {{jsxref("Promise")}} that fulfills with the clear data corresponding to the encrypted text, algorithm, and key given as parameters.
- {{domxref("SubtleCrypto.sign()")}}
- : Returns a {{jsxref("Promise")}} that fulfills with the signature corresponding to the text, algorithm, and key given as parameters.
- {{domxref("SubtleCrypto.verify()")}}
- : Returns a {{jsxref("Promise")}} that fulfills with a boolean value indicating if the signature given as a parameter matches the text, algorithm, and key that are also given as parameters.
- {{domxref("SubtleCrypto.digest()")}}
- : Returns a {{jsxref("Promise")}} that fulfills with a digest generated from the algorithm and text given as parameters.
- {{domxref("SubtleCrypto.generateKey()")}}
- : Returns a {{jsxref("Promise")}} that fulfills with a newly-generated {{domxref("CryptoKey")}}, for symmetrical algorithms, or a {{domxref("CryptoKeyPair")}}, containing two newly generated keys, for asymmetrical algorithms. These will match the algorithm, usages, and extractability given as parameters.
- {{domxref("SubtleCrypto.deriveKey()")}}
- : Returns a {{jsxref("Promise")}} that fulfills with a newly generated {{domxref("CryptoKey")}} derived from the master key and specific algorithm given as parameters.
- {{domxref("SubtleCrypto.deriveBits()")}}
- : Returns a {{jsxref("Promise")}} that fulfills with a newly generated buffer of pseudo-random bits derived from the master key and specific algorithm given as parameters.
- {{domxref("SubtleCrypto.importKey()")}}
- : Returns a {{jsxref("Promise")}} that fulfills with a {{domxref("CryptoKey")}} corresponding to the format, the algorithm, raw key data, usages, and extractability given as parameters.
- {{domxref("SubtleCrypto.exportKey()")}}
- : Returns a {{jsxref("Promise")}} that fulfills with the raw key data containing the key in the requested format.
- {{domxref("SubtleCrypto.wrapKey()")}}
- : Returns a {{jsxref("Promise")}} that fulfills with a wrapped symmetric key for usage (transfer and storage) in insecure environments. The wrapped key matches the format specified in the given parameters, and wrapping is done by the given wrapping key, using the specified algorithm.
- {{domxref("SubtleCrypto.unwrapKey()")}}
- : Returns a {{jsxref("Promise")}} that fulfills with a {{domxref("CryptoKey")}} corresponding to the wrapped key given in the parameter.
## Using SubtleCrypto
We can split the functions implemented by this API into two groups: cryptography functions and key management functions.
### Cryptography functions
These are the functions you can use to implement security features such as privacy and authentication in a system. The `SubtleCrypto` API provides the following cryptography functions:
- {{DOMxRef("SubtleCrypto.sign","sign()")}} and {{DOMxRef("SubtleCrypto.verify","verify()")}}: create and verify digital signatures.
- {{DOMxRef("SubtleCrypto.encrypt","encrypt()")}} and {{DOMxRef("SubtleCrypto.decrypt","decrypt()")}}: encrypt and decrypt data.
- {{DOMxRef("SubtleCrypto.digest","digest()")}}: create a fixed-length, collision-resistant digest of some data.
### Key management functions
Except for {{DOMxRef("SubtleCrypto.digest","digest()")}}, all the cryptography functions in the API use cryptographic keys. In the `SubtleCrypto` API a cryptographic key is represented using a {{DOMxRef("CryptoKey")}} object. To perform operations like signing and encrypting, you pass a {{DOMxRef("CryptoKey")}} object into the {{DOMxRef("SubtleCrypto.sign","sign()")}} or {{DOMxRef("SubtleCrypto.encrypt","encrypt()")}} function.
#### Generating and deriving keys
The {{DOMxRef("SubtleCrypto.generateKey","generateKey()")}} and {{DOMxRef("SubtleCrypto.deriveKey","deriveKey()")}} functions both create a new {{DOMxRef("CryptoKey")}} object.
The difference is that `generateKey()` will generate a new distinct key value each time you call it, while `deriveKey()` derives a key from some initial keying material. If you provide the same keying material to two separate calls to `deriveKey()`, you will get two `CryptoKey` objects that have the same underlying value. This is useful if, for example, you want to derive an encryption key from a password and later derive the same key from the same password to decrypt the data.
#### Importing and exporting keys
To make keys available outside your app, you need to export the key, and that's what {{DOMxRef("SubtleCrypto.exportKey","exportKey()")}} is for. You can choose one of a number of export formats.
The inverse of `exportKey()` is {{DOMxRef("SubtleCrypto.importKey","importKey()")}}. You can import keys from other systems, and support for standard formats like [PKCS #8](https://datatracker.ietf.org/doc/html/rfc5208) and [JSON Web Key](https://datatracker.ietf.org/doc/html/rfc7517) helps you do this. The `exportKey()` function exports the key in an unencrypted format.
If the key is sensitive you should use {{DOMxRef("SubtleCrypto.wrapKey","wrapKey()")}}, which exports the key and then encrypts it using another key; the API calls a "key-wrapping key".
The inverse of `wrapKey()` is {{DOMxRef("SubtleCrypto.unwrapKey","unwrapKey()")}}, which decrypts then imports the key.
#### Storing keys
`CryptoKey` objects can be stored using the [structured clone algorithm](/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm), meaning that you can store and retrieve them using standard web storage APIs. The specification expects that most developers will use the [IndexedDB API](/en-US/docs/Web/API/IndexedDB_API) to store `CryptoKey` objects.
### Supported algorithms
The cryptographic functions provided by the Web Crypto API can be performed by one or more different _cryptographic algorithms_: the `algorithm` argument to the function indicates which algorithm to use. Some algorithms need extra parameters: in these cases the `algorithm` argument is a dictionary object that includes the extra parameters.
The table below summarizes which algorithms are suitable for which cryptographic operations:
<table class="standard-table">
<thead>
<tr>
<th scope="row"></th>
<th scope="col">
<a href="/en-US/docs/Web/API/SubtleCrypto/sign">sign()</a><br /><a
href="/en-US/docs/Web/API/SubtleCrypto/verify"
>verify()</a
>
</th>
<th scope="col">
<a href="/en-US/docs/Web/API/SubtleCrypto/encrypt">encrypt()</a><br /><a
href="/en-US/docs/Web/API/SubtleCrypto/decrypt"
>decrypt()</a
>
</th>
<th scope="col">
<a href="/en-US/docs/Web/API/SubtleCrypto/digest">digest()</a>
</th>
<th scope="col">
<a href="/en-US/docs/Web/API/SubtleCrypto/deriveBits">deriveBits()</a
><br /><a href="/en-US/docs/Web/API/SubtleCrypto/deriveKey"
>deriveKey()</a
>
</th>
<th scope="col">
<a href="/en-US/docs/Web/API/SubtleCrypto/wrapKey">wrapKey()</a><br /><a
href="/en-US/docs/Web/API/SubtleCrypto/unwrapKey"
>unwrapKey()</a
>
</th>
</tr>
</thead>
<tbody>
<tr>
<th scope="row">RSASSA-PKCS1-v1_5</th>
<td>✓</td>
<td></td>
<td></td>
<td></td>
<td></td>
</tr>
<tr>
<th scope="row">RSA-PSS</th>
<td>✓</td>
<td></td>
<td></td>
<td></td>
<td></td>
</tr>
<tr>
<th scope="row">ECDSA</th>
<td>✓</td>
<td></td>
<td></td>
<td></td>
<td></td>
</tr>
<tr>
<th scope="row">HMAC</th>
<td>✓</td>
<td></td>
<td></td>
<td></td>
<td></td>
</tr>
<tr>
<th scope="row">RSA-OAEP</th>
<td></td>
<td>✓</td>
<td></td>
<td></td>
<td>✓</td>
</tr>
<tr>
<th scope="row">AES-CTR</th>
<td></td>
<td>✓</td>
<td></td>
<td></td>
<td>✓</td>
</tr>
<tr>
<th scope="row">AES-CBC</th>
<td></td>
<td>✓</td>
<td></td>
<td></td>
<td>✓</td>
</tr>
<tr>
<th scope="row">AES-GCM</th>
<td></td>
<td>✓</td>
<td></td>
<td></td>
<td>✓</td>
</tr>
<tr>
<th scope="row">SHA-1</th>
<td></td>
<td></td>
<td>✓</td>
<td></td>
<td></td>
</tr>
<tr>
<th scope="row">SHA-256</th>
<td></td>
<td></td>
<td>✓</td>
<td></td>
<td></td>
</tr>
<tr>
<th scope="row">SHA-384</th>
<td></td>
<td></td>
<td>✓</td>
<td></td>
<td></td>
</tr>
<tr>
<th scope="row">SHA-512</th>
<td></td>
<td></td>
<td>✓</td>
<td></td>
<td></td>
</tr>
<tr>
<th scope="row">ECDH</th>
<td></td>
<td></td>
<td></td>
<td>✓</td>
<td></td>
</tr>
<tr>
<th scope="row">HKDF</th>
<td></td>
<td></td>
<td></td>
<td>✓</td>
<td></td>
</tr>
<tr>
<th scope="row">PBKDF2</th>
<td></td>
<td></td>
<td></td>
<td>✓</td>
<td></td>
</tr>
<tr>
<th scope="row">AES-KW</th>
<td></td>
<td></td>
<td></td>
<td></td>
<td>✓</td>
</tr>
</tbody>
</table>
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Web Crypto API](/en-US/docs/Web/API/Web_Crypto_API)
- [Non-cryptographic uses of SubtleCrypto](/en-US/docs/Web/API/Web_Crypto_API/Non-cryptographic_uses_of_subtle_crypto)
- [Web security](/en-US/docs/Web/Security)
- [Privacy, permissions, and information security](/en-US/docs/Web/Privacy)
- {{domxref("Crypto")}} and {{domxref("Crypto.subtle")}}.
- [Crypto 101](https://www.crypto101.io/): an introductory course on cryptography.
| 0 |
data/mdn-content/files/en-us/web/api/subtlecrypto | data/mdn-content/files/en-us/web/api/subtlecrypto/encrypt/index.md | ---
title: "SubtleCrypto: encrypt() method"
short-title: encrypt()
slug: Web/API/SubtleCrypto/encrypt
page-type: web-api-instance-method
browser-compat: api.SubtleCrypto.encrypt
---
{{APIRef("Web Crypto API")}}{{SecureContext_header}}
The **`encrypt()`** method of the {{domxref("SubtleCrypto")}} interface encrypts data.
It takes as its arguments a {{glossary("key")}} to encrypt with, some algorithm-specific parameters, and the data to encrypt (also known as "plaintext").
It returns a {{jsxref("Promise")}} which will be fulfilled with the encrypted data (also known as "ciphertext").
## Syntax
```js-nolint
encrypt(algorithm, key, data)
```
### Parameters
- `algorithm`
- : An object specifying the [algorithm](#supported_algorithms) to be used and any extra parameters if required:
- To use [RSA-OAEP](#rsa-oaep), pass an {{domxref("RsaOaepParams")}} object.
- To use [AES-CTR](#aes-ctr), pass an {{domxref("AesCtrParams")}} object.
- To use [AES-CBC](#aes-cbc), pass an {{domxref("AesCbcParams")}} object.
- To use [AES-GCM](#aes-gcm), pass an {{domxref("AesGcmParams")}} object.
- `key`
- : A {{domxref("CryptoKey")}} containing the key to be used for encryption.
- `data`
- : An {{jsxref("ArrayBuffer")}}, a {{jsxref("TypedArray")}}, or a {{jsxref("DataView")}}
containing the data to be encrypted (also known as the {{glossary("plaintext")}}).
### Return value
A {{jsxref("Promise")}} that fulfills with an {{jsxref("ArrayBuffer")}} containing the "ciphertext".
### Exceptions
The promise is rejected when the following exceptions are encountered:
- `InvalidAccessError` {{domxref("DOMException")}}
- : Raised when the requested operation is not valid for the provided key (e.g. invalid encryption algorithm, or invalid key for the specified encryption algorithm).
- `OperationError` {{domxref("DOMException")}}
- : Raised when the operation failed for an operation-specific reason (e.g. algorithm parameters of invalid sizes, or AES-GCM plaintext longer than 2<sup>39</sup>−256 bytes).
## Supported algorithms
The Web Crypto API provides four algorithms that support the `encrypt()` and `decrypt()` operations.
One of these algorithms — RSA-OAEP — is a {{Glossary("public-key cryptography", "public-key cryptosystem")}}.
The other three encryption algorithms here are all {{Glossary("Symmetric-key cryptography", "symmetric algorithms")}}, and they're all based on the same underlying cipher, AES (Advanced Encryption Standard).
The difference between them is the {{Glossary("Block cipher mode of operation", "mode")}}.
The Web Crypto API supports three different AES modes:
- CTR (Counter Mode)
- CBC (Cipher Block Chaining)
- GCM (Galois/Counter Mode)
It's strongly recommended to use _authenticated encryption_, which includes checks that the ciphertext has not been modified by an attacker.
Authentication helps protect against _chosen-ciphertext_ attacks, in which an attacker can ask the system to decrypt arbitrary messages, and use the result to deduce information about the
secret key.
While it's possible to add authentication to CTR and CBC modes, they do not provide it by default and when implementing it manually one can easily make minor, but serious mistakes.
GCM does provide built-in authentication, and for this reason it's often recommended over the other two AES modes.
### RSA-OAEP
The RSA-OAEP public-key encryption system is specified in [RFC 3447](https://datatracker.ietf.org/doc/html/rfc3447).
### AES-CTR
This represents AES in Counter Mode, as specified in [NIST SP800-38A](https://csrc.nist.gov/publications/detail/sp/800-38a/final).
AES is a block cipher, meaning that it splits the message into blocks and encrypts it a block at a time.
In CTR mode, every time a block of the message is encrypted, an extra block of data is mixed in. This extra block is called the "counter block".
A given counter block value must never be used more than once with the same key:
- Given a message _n_ blocks long, a different counter block must be used for every block.
- If the same key is used to encrypt more than one message, a different counter block must be used for all blocks across all messages.
Typically this is achieved by splitting the initial counter block value into two concatenated parts:
- A [nonce](https://en.wikipedia.org/wiki/Cryptographic_nonce) (that is, a number that may only be used once). The nonce part of the block stays the same for every block in the message. Each time a new message is to be encrypted, a new nonce is chosen. Nonces don't have to be secret, but they must not be reused with the same key.
- A counter. This part of the block gets incremented each time a block is encrypted.
Essentially: the nonce should ensure that counter blocks are not reused from one message to the next, while the counter should ensure that counter blocks are not reused within a single message.
> **Note:** See [Appendix B of the NIST SP800-38A standard](https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38a.pdf#%5B%7B%22num%22%3A70%2C%22gen%22%3A0%7D%2C%7B%22name%22%3A%22Fit%22%7D%5D) for more information.
### AES-CBC
This represents AES in Cipher Block Chaining Mode, as specified in [NIST SP800-38A](https://csrc.nist.gov/publications/detail/sp/800-38a/final).
### AES-GCM
This represents AES in Galois/Counter Mode, as specified in [NIST SP800-38D](https://csrc.nist.gov/publications/detail/sp/800-38d/final).
One major difference between this mode and the others is that GCM is an "authenticated" mode, which means that it includes checks that the ciphertext has not been modified by an attacker.
## Examples
> **Note:** You can [try the working examples](https://mdn.github.io/dom-examples/web-crypto/encrypt-decrypt/index.html) out on GitHub.
### RSA-OAEP
This code fetches the contents of a text box, encodes it for encryption, and encrypts
it with using RSA-OAEP. [See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/encrypt-decrypt/rsa-oaep.js)
```js
function getMessageEncoding() {
const messageBox = document.querySelector(".rsa-oaep #message");
let message = messageBox.value;
let enc = new TextEncoder();
return enc.encode(message);
}
function encryptMessage(publicKey) {
let encoded = getMessageEncoding();
return window.crypto.subtle.encrypt(
{
name: "RSA-OAEP",
},
publicKey,
encoded,
);
}
```
### AES-CTR
This code fetches the contents of a text box, encodes it for encryption, and encrypts it using AES in CTR mode.
[See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/encrypt-decrypt/aes-ctr.js)
```js
function getMessageEncoding() {
const messageBox = document.querySelector(".aes-ctr #message");
let message = messageBox.value;
let enc = new TextEncoder();
return enc.encode(message);
}
function encryptMessage(key) {
let encoded = getMessageEncoding();
// counter will be needed for decryption
counter = window.crypto.getRandomValues(new Uint8Array(16));
return window.crypto.subtle.encrypt(
{
name: "AES-CTR",
counter,
length: 64,
},
key,
encoded,
);
}
```
```js
let iv = window.crypto.getRandomValues(new Uint8Array(16));
let key = window.crypto.getRandomValues(new Uint8Array(16));
let data = new Uint8Array(12345);
// crypto functions are wrapped in promises so we have to use await and make sure the function that
// contains this code is an async function
// encrypt function wants a cryptokey object
const key_encoded = await crypto.subtle.importKey(
"raw",
key.buffer,
"AES-CTR",
false,
["encrypt", "decrypt"],
);
const encrypted_content = await window.crypto.subtle.encrypt(
{
name: "AES-CTR",
counter: iv,
length: 128,
},
key_encoded,
data,
);
// Uint8Array
console.log(encrypted_content);
```
### AES-CBC
This code fetches the contents of a text box, encodes it for encryption, and encrypts it using AES in CBC mode.
[See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/encrypt-decrypt/aes-cbc.js)
```js
function getMessageEncoding() {
const messageBox = document.querySelector(".aes-cbc #message");
let message = messageBox.value;
let enc = new TextEncoder();
return enc.encode(message);
}
function encryptMessage(key) {
let encoded = getMessageEncoding();
// iv will be needed for decryption
iv = window.crypto.getRandomValues(new Uint8Array(16));
return window.crypto.subtle.encrypt(
{
name: "AES-CBC",
iv: iv,
},
key,
encoded,
);
}
```
### AES-GCM
This code fetches the contents of a text box, encodes it for encryption, and encrypts it using AES in GCM mode.
[See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/encrypt-decrypt/aes-gcm.js)
```js
function getMessageEncoding() {
const messageBox = document.querySelector(".aes-gcm #message");
const message = messageBox.value;
const enc = new TextEncoder();
return enc.encode(message);
}
function encryptMessage(key) {
const encoded = getMessageEncoding();
// iv will be needed for decryption
const iv = window.crypto.getRandomValues(new Uint8Array(12));
return window.crypto.subtle.encrypt(
{ name: "AES-GCM", iv: iv },
key,
encoded,
);
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("SubtleCrypto.decrypt()")}}.
- [RFC 3447](https://datatracker.ietf.org/doc/html/rfc3447) specifies RSAOAEP.
- [NIST SP800-38A](https://csrc.nist.gov/publications/detail/sp/800-38a/final) specifies CTR mode.
- [NIST SP800-38A](https://csrc.nist.gov/publications/detail/sp/800-38a/final) specifies CBC mode.
- [NIST SP800-38D](https://csrc.nist.gov/publications/detail/sp/800-38d/final) specifies GCM mode.
| 0 |
data/mdn-content/files/en-us/web/api/subtlecrypto | data/mdn-content/files/en-us/web/api/subtlecrypto/digest/index.md | ---
title: "SubtleCrypto: digest() method"
short-title: digest()
slug: Web/API/SubtleCrypto/digest
page-type: web-api-instance-method
browser-compat: api.SubtleCrypto.digest
---
{{APIRef("Web Crypto API")}}{{SecureContext_header}}
The **`digest()`** method of the {{domxref("SubtleCrypto")}}
interface generates a {{Glossary("digest")}} of the given data. A digest is a short
fixed-length value derived from some variable-length input. Cryptographic digests should
exhibit collision-resistance, meaning that it's hard to come up with two different
inputs that have the same digest value.
It takes as its arguments an identifier for the digest algorithm to use and the data to
digest. It returns a {{jsxref("Promise")}} which will be fulfilled with the digest.
Note that this API does not support streaming input: you must read the entire input into memory before passing it into the digest function.
## Syntax
```js-nolint
digest(algorithm, data)
```
### Parameters
- `algorithm`
- : This may be a string or an object with a single property `name` that is a string. The string names the hash function to use. Supported values are:
- `"SHA-1"` (but don't use this in cryptographic applications)
- `"SHA-256"`
- `"SHA-384"`
- `"SHA-512"`.
- `data`
- : An {{jsxref("ArrayBuffer")}}, a {{jsxref("TypedArray")}} or a {{jsxref("DataView")}} object containing the data to be digested.
### Return value
A {{jsxref("Promise")}} that fulfills with an {{jsxref("ArrayBuffer")}} containing the digest.
## Supported algorithms
Digest algorithms, also known as [cryptographic hash functions](/en-US/docs/Glossary/Cryptographic_hash_function),
transform an arbitrarily large block of data into a fixed-size output,
usually much shorter than the input. They have a variety of applications in
cryptography.
<table class="standard-table">
<tbody>
<tr>
<th scope="col">Algorithm</th>
<th scope="col">Output length (bits)</th>
<th scope="col">Block size (bits)</th>
<th scope="col">Specification</th>
</tr>
<tr>
<th scope="row">SHA-1</th>
<td>160</td>
<td>512</td>
<td>
<a href="https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf"
>FIPS 180-4</a
>, section 6.1
</td>
</tr>
<tr>
<th scope="row">SHA-256</th>
<td>256</td>
<td>512</td>
<td>
<a href="https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf"
>FIPS 180-4</a
>, section 6.2
</td>
</tr>
<tr>
<th scope="row">SHA-384</th>
<td>384</td>
<td>1024</td>
<td>
<a href="https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf"
>FIPS 180-4</a
>, section 6.5
</td>
</tr>
<tr>
<th scope="row">SHA-512</th>
<td>512</td>
<td>1024</td>
<td>
<a href="https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf"
>FIPS 180-4</a
>, section 6.4
</td>
</tr>
</tbody>
</table>
> **Warning:** SHA-1 is now considered vulnerable and should not
> be used for cryptographic applications.
> **Note:** If you are looking here for how to create a keyed-hash message authentication
> code ([HMAC](/en-US/docs/Glossary/HMAC)), you need to use the [SubtleCrypto.sign()](/en-US/docs/Web/API/SubtleCrypto/sign#hmac) instead.
## Examples
For more examples of using the `digest()` API, see [Non-cryptographic uses of SubtleCrypto](/en-US/docs/Web/API/Web_Crypto_API/Non-cryptographic_uses_of_subtle_crypto).
### Basic example
This example encodes a message, then calculates its SHA-256 digest and logs the digest
length:
```js
const text =
"An obscure body in the S-K System, your majesty. The inhabitants refer to it as the planet Earth.";
async function digestMessage(message) {
const encoder = new TextEncoder();
const data = encoder.encode(message);
const hash = await crypto.subtle.digest("SHA-256", data);
return hash;
}
digestMessage(text).then((digestBuffer) =>
console.log(digestBuffer.byteLength),
);
```
### Converting a digest to a hex string
The digest is returned as an `ArrayBuffer`, but for comparison and display
digests are often represented as hex strings. This example calculates a digest, then
converts the `ArrayBuffer` to a hex string:
```js
const text =
"An obscure body in the S-K System, your majesty. The inhabitants refer to it as the planet Earth.";
async function digestMessage(message) {
const msgUint8 = new TextEncoder().encode(message); // encode as (utf-8) Uint8Array
const hashBuffer = await crypto.subtle.digest("SHA-256", msgUint8); // hash the message
const hashArray = Array.from(new Uint8Array(hashBuffer)); // convert buffer to byte array
const hashHex = hashArray
.map((b) => b.toString(16).padStart(2, "0"))
.join(""); // convert bytes to hex string
return hashHex;
}
digestMessage(text).then((digestHex) => console.log(digestHex));
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Non-cryptographic uses of SubtleCrypto](/en-US/docs/Web/API/Web_Crypto_API/Non-cryptographic_uses_of_subtle_crypto)
- [Chromium secure origins specification](https://www.chromium.org/Home/chromium-security/prefer-secure-origins-for-powerful-new-features/)
- [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf) specifies the SHA family of digest algorithms.
| 0 |
data/mdn-content/files/en-us/web/api/subtlecrypto | data/mdn-content/files/en-us/web/api/subtlecrypto/unwrapkey/index.md | ---
title: "SubtleCrypto: unwrapKey() method"
short-title: unwrapKey()
slug: Web/API/SubtleCrypto/unwrapKey
page-type: web-api-instance-method
browser-compat: api.SubtleCrypto.unwrapKey
---
{{APIRef("Web Crypto API")}}{{SecureContext_header}}
The **`unwrapKey()`** method of the {{domxref("SubtleCrypto")}} interface "unwraps" a key.
This means that it takes as its input a key that has been exported and then encrypted (also called "wrapped").
It decrypts the key and then imports it, returning a {{domxref("CryptoKey")}} object that can be used in the [Web Crypto API](/en-US/docs/Web/API/Web_Crypto_API).
As with [`SubtleCrypto.importKey()`](/en-US/docs/Web/API/SubtleCrypto/importKey), you specify the key's [import format](/en-US/docs/Web/API/SubtleCrypto/importKey#supported_formats) and other attributes of the key to import details such as whether it is extractable, and which operations it can be used for.
But because `unwrapKey()` also decrypts the key to be imported, you also need to pass in the key that must be used to decrypt it.
This is sometimes called the "unwrapping key".
The inverse of `unwrapKey()` is {{domxref("SubtleCrypto.wrapKey()")}}: while `unwrapKey` is composed of decrypt + import, `wrapKey` is composed of encrypt + export.
## Syntax
```js-nolint
unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgo, unwrappedKeyAlgo, extractable, keyUsages)
```
### Parameters
- `format`
- : A string describing the data format of the key to unwrap. It can be one of the following:
- `raw`: [Raw](/en-US/docs/Web/API/SubtleCrypto/importKey#raw) format.
- `pkcs8`: [PKCS #8](/en-US/docs/Web/API/SubtleCrypto/importKey#pkcs_8) format.
- `spki`: [SubjectPublicKeyInfo](/en-US/docs/Web/API/SubtleCrypto/importKey#subjectpublickeyinfo) format.
- `jwk`: [JSON Web Key](/en-US/docs/Web/API/SubtleCrypto/importKey#json_web_key) format.
- `wrappedKey`
- : An {{jsxref("ArrayBuffer")}} containing the wrapped key in the given format.
- `unwrappingKey`
- : The {{domxref("CryptoKey")}} to use to decrypt the wrapped key. The key must have the `unwrapKey` usage set.
- `unwrapAlgo`
- : An object specifying the [algorithm](/en-US/docs/Web/API/SubtleCrypto/encrypt#supported_algorithms)
to be used to decrypt the wrapped key, and any extra parameters as required:
- To use [RSA-OAEP](/en-US/docs/Web/API/SubtleCrypto/encrypt#rsa-oaep),
pass an [`RsaOaepParams`](/en-US/docs/Web/API/RsaOaepParams) object.
- To use [AES-CTR](/en-US/docs/Web/API/SubtleCrypto/encrypt#aes-ctr),
pass an [`AesCtrParams`](/en-US/docs/Web/API/AesCtrParams) object.
- To use [AES-CBC](/en-US/docs/Web/API/SubtleCrypto/encrypt#aes-cbc),
pass an [`AesCbcParams`](/en-US/docs/Web/API/AesCbcParams) object.
- To use [AES-GCM](/en-US/docs/Web/API/SubtleCrypto/encrypt#aes-gcm),
pass an [`AesGcmParams`](/en-US/docs/Web/API/AesGcmParams) object.
- To use [AES-KW](/en-US/docs/Web/API/SubtleCrypto/wrapKey#aes-kw),
pass the string `"AES-KW"` or an object of the form `{ "name": "AES-KW }`.
- `unwrappedKeyAlgo`
- : An object defining the type of key to unwrap and providing extra algorithm-specific parameters as required.
- For [RSASSA-PKCS1-v1_5](/en-US/docs/Web/API/SubtleCrypto/sign#rsassa-pkcs1-v1_5), [RSA-PSS](/en-US/docs/Web/API/SubtleCrypto/sign#rsa-pss),
or [RSA-OAEP](/en-US/docs/Web/API/SubtleCrypto/encrypt#rsa-oaep):
Pass an [`RsaHashedImportParams`](/en-US/docs/Web/API/RsaHashedImportParams) object.
- For [ECDSA](/en-US/docs/Web/API/SubtleCrypto/sign#ecdsa) or [ECDH](/en-US/docs/Web/API/SubtleCrypto/deriveKey#ecdh): Pass
an [`EcKeyImportParams`](/en-US/docs/Web/API/EcKeyImportParams) object.
- For [HMAC](/en-US/docs/Web/API/SubtleCrypto/sign#hmac): Pass an
[`HmacImportParams`](/en-US/docs/Web/API/HmacImportParams) object.
- For [AES-CTR](/en-US/docs/Web/API/SubtleCrypto/encrypt#aes-ctr), [AES-CBC](/en-US/docs/Web/API/SubtleCrypto/encrypt#aes-cbc),
[AES-GCM](/en-US/docs/Web/API/SubtleCrypto/encrypt#aes-gcm), or [AES-KW](/en-US/docs/Web/API/SubtleCrypto/wrapKey#aes-kw):
Pass the string identifying the algorithm or an object of the form `{ "name": ALGORITHM }`, where `ALGORITHM` is the name of the algorithm.
- `extractable`
- : A boolean indicating whether it will be possible to export the key
using [`SubtleCrypto.exportKey()`](/en-US/docs/Web/API/SubtleCrypto/exportKey) or [`SubtleCrypto.wrapKey()`](/en-US/docs/Web/API/SubtleCrypto/wrapKey).
- `keyUsages`
- : An [`Array`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array) indicating what can be done with the key. Possible values of the array are:
- `encrypt`: The key may be used to [`encrypt`](/en-US/docs/Web/API/SubtleCrypto/encrypt) messages.
- `decrypt`: The key may be used to [`decrypt`](/en-US/docs/Web/API/SubtleCrypto/decrypt) messages.
- `sign`: The key may be used to [`sign`](/en-US/docs/Web/API/SubtleCrypto/sign) messages.
- `verify`: The key may be used to [`verify`](/en-US/docs/Web/API/SubtleCrypto/verify) signatures.
- `deriveKey`: The key may be used in [`deriving a new key`](/en-US/docs/Web/API/SubtleCrypto/deriveKey).
- `deriveBits`: The key may be used in [`deriving bits`](/en-US/docs/Web/API/SubtleCrypto/deriveBits).
- `wrapKey`: The key may be used to [`wrap a key`](/en-US/docs/Web/API/SubtleCrypto/wrapKey).
- `unwrapKey`: The key may be used to unwrap a key.
### Return value
A [`Promise`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) that fulfills with the unwrapped key as a [`CryptoKey`](/en-US/docs/Web/API/CryptoKey) object.
### Exceptions
The promise is rejected when one of the following exceptions is encountered:
- `InvalidAccessError` {{domxref("DOMException")}}
- : Raised when the unwrapping key is not a key for the requested unwrap algorithm or if the `keyUsages` value of that key doesn't contain `unwrap`.
- `NotSupported` {{domxref("DOMException")}}
- : Raised when trying to use an algorithm that is either unknown or isn't suitable for encryption or wrapping.
- `SyntaxError` {{domxref("DOMException")}}
- : Raised when `keyUsages` is empty but the unwrapped key is of type `secret` or `private`.
- {{jsxref("TypeError")}}
- : Raised when trying to use an invalid format.
## Supported algorithms
The `unwrapKey()` method supports the same algorithms as the [`wrapKey()`](/en-US/docs/Web/API/SubtleCrypto/wrapKey#supported_algorithms) method.
## Examples
> **Note:** You can [try the working examples](https://mdn.github.io/dom-examples/web-crypto/unwrap-key/index.html) on GitHub.
### Unwrapping a "raw" key
In this example we unwrap an AES-GCM symmetric key. The key was exported in "raw"
format and encrypted using the AES-KW algorithm, with a key derived from a password.
To unwrap, we ask the user for the password and use PBKDF2 and some salt to derive the
AES-KW unwrapping key. The salt needs to be the same as the salt that was used to derive
the original AES-KW key wrapping key.
Once we have the unwrapping key we pass it into `unwrapKey()` with the
wrapped key and other parameters. [See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/unwrap-key/raw.js)
```js
/*
Salt that is to be used in derivation of the key-wrapping key,
alongside the password the user supplies.
This must match the salt value that was originally used to derive
the key.
*/
const saltBytes = [
89, 113, 135, 234, 168, 204, 21, 36, 55, 93, 1, 132, 242, 242, 192, 156,
];
/*
The wrapped key itself.
*/
const wrappedKeyBytes = [
171, 223, 14, 36, 201, 233, 233, 120, 164, 68, 217, 192, 226, 80, 224, 39,
199, 235, 239, 60, 212, 169, 100, 23, 61, 54, 244, 197, 160, 80, 109, 230,
207, 225, 57, 197, 175, 71, 80, 209,
];
/*
Convert an array of byte values to an ArrayBuffer.
*/
function bytesToArrayBuffer(bytes) {
const bytesAsArrayBuffer = new ArrayBuffer(bytes.length);
const bytesUint8 = new Uint8Array(bytesAsArrayBuffer);
bytesUint8.set(bytes);
return bytesAsArrayBuffer;
}
/*
Get some key material to use as input to the deriveKey method.
The key material is a password supplied by the user.
*/
function getKeyMaterial() {
let password = window.prompt("Enter your password");
let enc = new TextEncoder();
return window.crypto.subtle.importKey(
"raw",
enc.encode(password),
{ name: "PBKDF2" },
false,
["deriveBits", "deriveKey"],
);
}
/*
Derive an AES-KW key using PBKDF2.
*/
async function getUnwrappingKey() {
// 1. get the key material (user-supplied password)
const keyMaterial = await getKeyMaterial();
// 2 initialize the salt parameter.
// The salt must match the salt originally used to derive the key.
// In this example it's supplied as a constant "saltBytes".
const saltBuffer = bytesToArrayBuffer(saltBytes);
// 3 derive the key from key material and salt
return window.crypto.subtle.deriveKey(
{
name: "PBKDF2",
salt: saltBuffer,
iterations: 100000,
hash: "SHA-256",
},
keyMaterial,
{ name: "AES-KW", length: 256 },
true,
["wrapKey", "unwrapKey"],
);
}
/*
Unwrap an AES secret key from an ArrayBuffer containing the raw bytes.
Takes an array containing the bytes, and returns a Promise
that will resolve to a CryptoKey representing the secret key.
*/
async function unwrapSecretKey(wrappedKey) {
// 1. get the unwrapping key
const unwrappingKey = await getUnwrappingKey();
// 2. initialize the wrapped key
const wrappedKeyBuffer = bytesToArrayBuffer(wrappedKey);
// 3. unwrap the key
return window.crypto.subtle.unwrapKey(
"raw", // import format
wrappedKeyBuffer, // ArrayBuffer representing key to unwrap
unwrappingKey, // CryptoKey representing key encryption key
"AES-KW", // algorithm identifier for key encryption key
"AES-GCM", // algorithm identifier for key to unwrap
true, // extractability of key to unwrap
["encrypt", "decrypt"], // key usages for key to unwrap
);
}
```
### Unwrapping a "pkcs8" key
In this example we unwrap an RSA-PSS private signing key. The key was exported in
"pkcs8" format and encrypted using the AES-GCM algorithm, with a key derived from a password.
To unwrap, we ask the user for the password and use PBKDF2 and some salt to derive the
AES-GCM unwrapping key. The salt needs to be the same as the salt that was used to
derive the original AES-GCM key wrapping key.
Once we have the unwrapping key we pass it into `unwrapKey()` with the
wrapped key and other parameters. Note that when using AES-GCM we have to pass the iv
value into `unwrapKey()`, and this must be the same as the iv that was used
in the corresponding `wrapKey()` operation. [See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/unwrap-key/pkcs8.js)
```js
/*
Salt that is to be used in derivation of the key-wrapping key,
alongside the password the user supplies.
This must match the salt value that was originally used to derive
the key.
*/
const saltBytes = [
180, 253, 62, 216, 47, 35, 90, 55, 218, 233, 103, 10, 172, 143, 161, 177,
];
/*
IV that is to be used in decrypting the key to unwrap.
This must the same IV that was originally used to encrypt
the key.
*/
const ivBytes = [212, 187, 26, 247, 172, 51, 37, 151, 27, 177, 249, 142];
/*
The wrapped key itself.
*/
const wrappedKeyBytes = [
6, 155, 182, 208, 7, 141, 44, 18, 3, 151, 58, 126, 68, 100, 252, 225, 241, 11,
25, 201, 153, 171, 102, 174, 150, 29, 62, 195, 110, 138, 106, 109, 14, 6, 108,
148, 104, 221, 22, 93, 102, 221, 146, 25, 65, 112, 4, 140, 79, 194, 164, 163,
156, 250, 108, 11, 14, 220, 78, 194, 161, 17, 14, 57, 121, 70, 13, 28, 220,
210, 78, 32, 46, 217, 36, 165, 220, 170, 244, 152, 214, 150, 83, 2, 138, 128,
11, 251, 227, 213, 72, 100, 158, 10, 162, 40, 195, 60, 248, 77, 37, 156, 34,
10, 213, 171, 67, 147, 73, 231, 31, 63, 80, 176, 103, 206, 187, 164, 214, 250,
49, 223, 185, 5, 48, 241, 17, 1, 253, 59, 185, 181, 209, 255, 42, 223, 175,
90, 159, 174, 169, 205, 156, 120, 195, 1, 135, 165, 226, 46, 119, 27, 97, 183,
23, 197, 227, 85, 138, 235, 79, 158, 167, 59, 62, 194, 34, 210, 214, 240, 215,
101, 233, 63, 138, 53, 87, 253, 189, 27, 66, 150, 76, 242, 76, 102, 174, 179,
163, 184, 205, 11, 161, 224, 19, 110, 34, 175, 192, 101, 117, 169, 86, 66, 56,
241, 128, 13, 156, 165, 125, 139, 110, 138, 50, 108, 129, 251, 137, 26, 186,
110, 117, 113, 207, 179, 59, 213, 18, 175, 14, 203, 192, 2, 97, 131, 125, 167,
227, 182, 87, 72, 123, 54, 156, 60, 195, 88, 224, 96, 46, 126, 245, 251, 247,
147, 110, 147, 173, 82, 106, 93, 210, 55, 71, 127, 133, 41, 37, 181, 17, 106,
16, 158, 220, 136, 43, 75, 133, 96, 240, 151, 116, 40, 44, 254, 2, 32, 74,
226, 193, 172, 48, 211, 71, 109, 163, 143, 30, 92, 28, 30, 183, 25, 16, 176,
207, 77, 93, 139, 242, 114, 91, 218, 126, 123, 234, 18, 9, 245, 53, 46, 172,
215, 62, 92, 249, 191, 17, 27, 0, 58, 151, 33, 23, 169, 93, 177, 253, 152,
147, 198, 196, 226, 42, 202, 166, 99, 250, 127, 40, 221, 196, 121, 195, 198,
235, 30, 159, 159, 95, 182, 107, 175, 137, 177, 49, 72, 63, 131, 162, 198,
186, 22, 255, 230, 237, 195, 56, 147, 177, 101, 52, 227, 125, 32, 180, 242,
47, 92, 212, 6, 148, 218, 107, 125, 137, 123, 15, 51, 107, 159, 228, 238, 212,
60, 54, 184, 48, 110, 248, 252, 208, 46, 23, 149, 78, 169, 201, 68, 242, 193,
251, 156, 227, 42, 90, 109, 102, 172, 61, 207, 124, 96, 98, 79, 37, 218, 16,
212, 139, 162, 0, 183, 235, 171, 75, 18, 84, 160, 120, 173, 156, 187, 99, 24,
58, 88, 213, 148, 24, 193, 111, 75, 169, 10, 158, 207, 148, 84, 249, 156, 248,
19, 221, 2, 175, 1, 8, 74, 221, 212, 244, 123, 34, 223, 175, 54, 166, 101, 51,
175, 141, 80, 87, 9, 146, 72, 223, 46, 251, 199, 192, 2, 22, 125, 16, 15, 99,
26, 159, 165, 133, 172, 169, 26, 236, 44, 86, 182, 162, 81, 143, 249, 15, 207,
12, 232, 15, 205, 199, 78, 133, 199, 19, 232, 183, 33, 183, 72, 117, 72, 27,
43, 254, 13, 17, 252, 1, 143, 137, 154, 10, 4, 77, 85, 24, 85, 143, 200, 81,
76, 171, 43, 124, 42, 191, 150, 70, 10, 90, 178, 198, 40, 233, 233, 225, 146,
231, 209, 254, 2, 90, 216, 5, 97, 105, 204, 82, 88, 81, 99, 92, 159, 116, 192,
223, 148, 252, 12, 24, 197, 211, 187, 212, 98, 252, 201, 154, 184, 65, 54, 47,
13, 106, 151, 168, 208, 112, 212, 74, 204, 36, 233, 98, 104, 58, 103, 1, 194,
13, 26, 109, 101, 60, 42, 3, 215, 20, 25, 99, 176, 63, 28, 112, 102, 121, 190,
96, 198, 228, 196, 78, 38, 82, 37, 248, 42, 150, 115, 6, 10, 22, 101, 42, 237,
175, 69, 232, 212, 231, 40, 193, 70, 211, 245, 106, 231, 175, 150, 88, 105,
170, 139, 238, 196, 64, 218, 250, 47, 165, 22, 36, 196, 161, 30, 79, 175, 14,
133, 88, 129, 182, 56, 140, 147, 168, 134, 91, 68, 172, 110, 195, 134, 156,
68, 78, 249, 215, 68, 250, 11, 23, 70, 59, 156, 99, 75, 249, 159, 84, 16, 206,
93, 16, 130, 34, 66, 210, 82, 252, 53, 251, 84, 59, 226, 212, 154, 15, 20,
163, 58, 228, 109, 53, 214, 151, 237, 10, 169, 107, 180, 123, 174, 159, 182,
8, 240, 115, 115, 220, 131, 128, 79, 80, 61, 133, 58, 24, 98, 193, 225, 56,
36, 159, 254, 199, 49, 44, 160, 28, 81, 140, 163, 24, 143, 114, 31, 237, 235,
250, 83, 72, 215, 44, 232, 182, 45, 39, 182, 193, 248, 65, 174, 186, 52, 219,
30, 198, 48, 1, 134, 151, 81, 114, 38, 124, 7, 213, 205, 138, 28, 22, 216, 76,
46, 224, 241, 88, 156, 7, 62, 23, 104, 34, 54, 25, 156, 93, 212, 133, 182, 61,
93, 255, 195, 68, 244, 234, 53, 132, 151, 140, 72, 146, 127, 113, 227, 34,
243, 218, 222, 47, 218, 113, 18, 173, 203, 158, 133, 90, 156, 214, 77, 20,
113, 1, 231, 164, 52, 55, 69, 132, 24, 68, 131, 212, 7, 153, 34, 179, 113,
156, 81, 127, 83, 57, 29, 195, 90, 64, 211, 115, 202, 188, 5, 42, 188, 142,
203, 109, 231, 53, 206, 72, 220, 90, 23, 12, 1, 178, 122, 60, 221, 68, 6, 14,
154, 108, 203, 171, 142, 159, 249, 13, 55, 52, 110, 214, 33, 147, 164, 181,
50, 79, 164, 200, 83, 251, 40, 105, 223, 50, 0, 115, 240, 146, 23, 122, 80,
204, 169, 38, 198, 154, 31, 29, 23, 236, 39, 35, 131, 147, 242, 163, 138, 158,
236, 117, 7, 108, 33, 132, 98, 50, 111, 46, 146, 251, 82, 34, 85, 5, 130, 237,
67, 40, 170, 235, 124, 92, 66, 71, 239, 12, 97, 136, 251, 1, 206, 13, 51, 232,
92, 46, 35, 95, 5, 123, 24, 183, 99, 243, 124, 75, 155, 89, 66, 54, 72, 17,
255, 99, 137, 199, 232, 204, 9, 248, 78, 35, 218, 136, 117, 239, 102, 240,
187, 40, 89, 244, 140, 109, 229, 120, 116, 54, 207, 171, 11, 248, 190, 199,
81, 53, 109, 8, 188, 51, 93, 165, 34, 255, 165, 191, 198, 130, 220, 41, 192,
166, 194, 69, 104, 124, 158, 122, 236, 176, 24, 60, 87, 240, 42, 158, 143, 37,
143, 208, 155, 249, 230, 21, 4, 230, 56, 194, 62, 235, 132, 14, 50, 180, 216,
134, 28, 25, 159, 64, 199, 161, 236, 60, 233, 160, 172, 68, 169, 2, 5, 252,
190, 20, 54, 115, 248, 63, 93, 107, 156, 8, 96, 85, 32, 189, 118, 66, 114,
126, 64, 203, 97, 235, 13, 18, 102, 192, 51, 59, 5, 122, 171, 96, 129, 40, 32,
154, 4, 191, 234, 75, 184, 112, 201, 244, 110, 50, 216, 44, 88, 139, 175, 58,
112, 7, 52, 25, 64, 112, 40, 148, 187, 39, 234, 96, 151, 16, 158, 114, 113,
109, 164, 47, 108, 94, 148, 35, 232, 221, 33, 110, 126, 170, 25, 234, 45, 165,
180, 210, 193, 120, 247, 155, 127,
];
/*
The unwrapped signing key.
*/
let signingKey;
const signButton = document.querySelector(".pkcs8 .sign-button");
/*
Convert an array of byte values to an ArrayBuffer.
*/
function bytesToArrayBuffer(bytes) {
const bytesAsArrayBuffer = new ArrayBuffer(bytes.length);
const bytesUint8 = new Uint8Array(bytesAsArrayBuffer);
bytesUint8.set(bytes);
return bytesAsArrayBuffer;
}
/*
Get some key material to use as input to the deriveKey method.
The key material is a password supplied by the user.
*/
function getKeyMaterial() {
let password = window.prompt("Enter your password");
let enc = new TextEncoder();
return window.crypto.subtle.importKey(
"raw",
enc.encode(password),
{ name: "PBKDF2" },
false,
["deriveBits", "deriveKey"],
);
}
/*
Derive an AES-GCM key using PBKDF2.
*/
async function getUnwrappingKey() {
// 1. get the key material (user-supplied password)
const keyMaterial = await getKeyMaterial();
// 2 initialize the salt parameter.
// The salt must match the salt originally used to derive the key.
// In this example it's supplied as a constant "saltBytes".
const saltBuffer = bytesToArrayBuffer(saltBytes);
// 3 derive the key from key material and salt
return window.crypto.subtle.deriveKey(
{
name: "PBKDF2",
salt: saltBuffer,
iterations: 100000,
hash: "SHA-256",
},
keyMaterial,
{ name: "AES-GCM", length: 256 },
true,
["wrapKey", "unwrapKey"],
);
}
/*
Unwrap an RSA-PSS private signing key from an ArrayBuffer containing
the raw bytes.
Takes an array containing the bytes, and returns a Promise
that will resolve to a CryptoKey representing the private key.
*/
async function unwrapPrivateKey(wrappedKey) {
// 1. get the unwrapping key
const unwrappingKey = await getUnwrappingKey();
// 2. initialize the wrapped key
const wrappedKeyBuffer = bytesToArrayBuffer(wrappedKey);
// 3. initialize the iv
const ivBuffer = bytesToArrayBuffer(ivBytes);
// 4. unwrap the key
return window.crypto.subtle.unwrapKey(
"pkcs8", // import format
wrappedKeyBuffer, // ArrayBuffer representing key to unwrap
unwrappingKey, // CryptoKey representing key encryption key
{
// algorithm params for key encryption key
name: "AES-GCM",
iv: ivBuffer,
},
{
// algorithm params for key to unwrap
name: "RSA-PSS",
hash: "SHA-256",
},
true, // extractability of key to unwrap
["sign"], // key usages for key to unwrap
);
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [`SubtleCrypto.importKey()`](/en-US/docs/Web/API/SubtleCrypto/importKey)
- [PKCS #8 format](https://datatracker.ietf.org/doc/html/rfc5208).
- [SubjectPublicKeyInfo format](https://datatracker.ietf.org/doc/html/rfc5280#section-4.1).
- [JSON Web Key format](https://datatracker.ietf.org/doc/html/rfc7517).
- [AES-KW specification](https://datatracker.ietf.org/doc/html/rfc3394).
| 0 |
data/mdn-content/files/en-us/web/api/subtlecrypto | data/mdn-content/files/en-us/web/api/subtlecrypto/exportkey/index.md | ---
title: "SubtleCrypto: exportKey() method"
short-title: exportKey()
slug: Web/API/SubtleCrypto/exportKey
page-type: web-api-instance-method
browser-compat: api.SubtleCrypto.exportKey
---
{{APIRef("Web Crypto API")}}{{SecureContext_header}}
The **`exportKey()`** method of the {{domxref("SubtleCrypto")}}
interface exports a key: that is, it takes as input a {{domxref("CryptoKey")}} object
and gives you the key in an external, portable format.
To export a key, the key must have {{domxref("CryptoKey.extractable")}} set to
`true`.
Keys can be exported in several formats: see [Supported formats](/en-US/docs/Web/API/SubtleCrypto/importKey#supported_formats) in the
[`SubtleCrypto.importKey()`](/en-US/docs/Web/API/SubtleCrypto/importKey)
page for details.
Keys are not exported in an encrypted format: to encrypt keys when exporting them use
the
[`SubtleCrypto.wrapKey()`](/en-US/docs/Web/API/SubtleCrypto/wrapKey)
API instead.
## Syntax
```js-nolint
exportKey(format, key)
```
### Parameters
- `format`
- : A string value describing the data format in which the key should be exported. It can be one of the following:
- `raw`: [Raw](/en-US/docs/Web/API/SubtleCrypto/importKey#raw) format.
- `pkcs8`: [PKCS #8](/en-US/docs/Web/API/SubtleCrypto/importKey#pkcs_8) format.
- `spki`: [SubjectPublicKeyInfo](/en-US/docs/Web/API/SubtleCrypto/importKey#subjectpublickeyinfo) format.
- `jwk`: [JSON Web Key](/en-US/docs/Web/API/SubtleCrypto/importKey#json_web_key) format.
- `key`
- : The {{domxref("CryptoKey")}} to export.
### Return value
A [`Promise`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise).
- If `format` was `jwk`, then the promise fulfills
with a JSON object containing the key.
- Otherwise the promise fulfills with an
[`ArrayBuffer`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer)
containing the key.
### Exceptions
The promise is rejected when one of the following exceptions is encountered:
- `InvalidAccessError` {{domxref("DOMException")}}
- : Raised when trying to export a non-extractable key.
- `NotSupported` {{domxref("DOMException")}}
- : Raised when trying to export in an unknown format.
- {{jsxref("TypeError")}}
- : Raised when trying to use an invalid format.
## Examples
> **Note:** You can [try the working examples](https://mdn.github.io/dom-examples/web-crypto/export-key/index.html) out on GitHub.
### Raw export
This example exports an AES key as an `ArrayBuffer` containing the bytes for
the key. [See the complete code on GitHub](https://github.com/mdn/dom-examples/blob/main/web-crypto/export-key/raw.js).
```js
/*
Export the given key and write it into the "exported-key" space.
*/
async function exportCryptoKey(key) {
const exported = await window.crypto.subtle.exportKey("raw", key);
const exportedKeyBuffer = new Uint8Array(exported);
const exportKeyOutput = document.querySelector(".exported-key");
exportKeyOutput.textContent = `[${exportedKeyBuffer}]`;
}
/*
Generate an encrypt/decrypt secret key,
then set up an event listener on the "Export" button.
*/
window.crypto.subtle
.generateKey(
{
name: "AES-GCM",
length: 256,
},
true,
["encrypt", "decrypt"],
)
.then((key) => {
const exportButton = document.querySelector(".raw");
exportButton.addEventListener("click", () => {
exportCryptoKey(key);
});
});
```
### PKCS #8 export
This example exports an RSA private signing key as a PKCS #8 object. The exported key
is then PEM-encoded. [See the complete code on GitHub](https://github.com/mdn/dom-examples/blob/main/web-crypto/export-key/pkcs8.js).
```js
/*
Convert an ArrayBuffer into a string
from https://developer.chrome.com/blog/how-to-convert-arraybuffer-to-and-from-string/
*/
function ab2str(buf) {
return String.fromCharCode.apply(null, new Uint8Array(buf));
}
/*
Export the given key and write it into the "exported-key" space.
*/
async function exportCryptoKey(key) {
const exported = await window.crypto.subtle.exportKey("pkcs8", key);
const exportedAsString = ab2str(exported);
const exportedAsBase64 = window.btoa(exportedAsString);
const pemExported = `-----BEGIN PRIVATE KEY-----\n${exportedAsBase64}\n-----END PRIVATE KEY-----`;
const exportKeyOutput = document.querySelector(".exported-key");
exportKeyOutput.textContent = pemExported;
}
/*
Generate a sign/verify key pair,
then set up an event listener on the "Export" button.
*/
window.crypto.subtle
.generateKey(
{
name: "RSA-PSS",
// Consider using a 4096-bit key for systems that require long-term security
modulusLength: 2048,
publicExponent: new Uint8Array([1, 0, 1]),
hash: "SHA-256",
},
true,
["sign", "verify"],
)
.then((keyPair) => {
const exportButton = document.querySelector(".pkcs8");
exportButton.addEventListener("click", () => {
exportCryptoKey(keyPair.privateKey);
});
});
```
### SubjectPublicKeyInfo export
This example exports an RSA public encryption key as a PEM-encoded SubjectPublicKeyInfo
object. [See the complete code on GitHub](https://github.com/mdn/dom-examples/blob/main/web-crypto/export-key/spki.js).
```js
/*
Convert an ArrayBuffer into a string
from https://developer.chrome.com/blog/how-to-convert-arraybuffer-to-and-from-string/
*/
function ab2str(buf) {
return String.fromCharCode.apply(null, new Uint8Array(buf));
}
/*
Export the given key and write it into the "exported-key" space.
*/
async function exportCryptoKey(key) {
const exported = await window.crypto.subtle.exportKey("spki", key);
const exportedAsString = ab2str(exported);
const exportedAsBase64 = window.btoa(exportedAsString);
const pemExported = `-----BEGIN PUBLIC KEY-----\n${exportedAsBase64}\n-----END PUBLIC KEY-----`;
const exportKeyOutput = document.querySelector(".exported-key");
exportKeyOutput.textContent = pemExported;
}
/*
Generate an encrypt/decrypt key pair,
then set up an event listener on the "Export" button.
*/
window.crypto.subtle
.generateKey(
{
name: "RSA-OAEP",
// Consider using a 4096-bit key for systems that require long-term security
modulusLength: 2048,
publicExponent: new Uint8Array([1, 0, 1]),
hash: "SHA-256",
},
true,
["encrypt", "decrypt"],
)
.then((keyPair) => {
const exportButton = document.querySelector(".spki");
exportButton.addEventListener("click", () => {
exportCryptoKey(keyPair.publicKey);
});
});
```
### JSON Web Key export
This example exports an ECDSA private signing key as a JSON Web Key object. [See the complete code on GitHub](https://github.com/mdn/dom-examples/blob/main/web-crypto/export-key/jwk.js).
```js
/*
Export the given key and write it into the "exported-key" space.
*/
async function exportCryptoKey(key) {
const exported = await window.crypto.subtle.exportKey("jwk", key);
const exportKeyOutput = document.querySelector(".exported-key");
exportKeyOutput.textContent = JSON.stringify(exported, null, " ");
}
/*
Generate a sign/verify key pair,
then set up an event listener on the "Export" button.
*/
window.crypto.subtle
.generateKey(
{
name: "ECDSA",
namedCurve: "P-384",
},
true,
["sign", "verify"],
)
.then((keyPair) => {
const exportButton = document.querySelector(".jwk");
exportButton.addEventListener("click", () => {
exportCryptoKey(keyPair.privateKey);
});
});
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [`SubtleCrypto.importKey()`](/en-US/docs/Web/API/SubtleCrypto/importKey)
- [`SubtleCrypto.wrapKey()`](/en-US/docs/Web/API/SubtleCrypto/importKey)
- [PKCS #8 format](https://datatracker.ietf.org/doc/html/rfc5208).
- [SubjectPublicKeyInfo format](https://datatracker.ietf.org/doc/html/rfc5280#section-4.1).
- [JSON Web Key format](https://datatracker.ietf.org/doc/html/rfc7517).
| 0 |
data/mdn-content/files/en-us/web/api/subtlecrypto | data/mdn-content/files/en-us/web/api/subtlecrypto/derivebits/index.md | ---
title: "SubtleCrypto: deriveBits() method"
short-title: deriveBits()
slug: Web/API/SubtleCrypto/deriveBits
page-type: web-api-instance-method
browser-compat: api.SubtleCrypto.deriveBits
---
{{APIRef("Web Crypto API")}}{{SecureContext_header}}
The **`deriveBits()`** method of the
{{domxref("SubtleCrypto")}} interface can be used to derive an array of bits from a base
key.
It takes as its arguments the base key, the derivation algorithm to use, and the length
of the bits to derive. It returns a [`Promise`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
which will be fulfilled with an
[`ArrayBuffer`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer)
containing the derived bits.
This method is very similar to
[`SubtleCrypto.deriveKey()`](/en-US/docs/Web/API/SubtleCrypto/deriveKey),
except that `deriveKey()` returns a
[`CryptoKey`](/en-US/docs/Web/API/CryptoKey) object rather than an
`ArrayBuffer`. Essentially `deriveKey()` is composed of
`deriveBits()` followed by
[`importKey()`](/en-US/docs/Web/API/SubtleCrypto/importKey).
This function supports the same derivation algorithms as `deriveKey()`:
ECDH, HKDF, and PBKDF2. See [Supported algorithms](/en-US/docs/Web/API/SubtleCrypto/deriveKey#supported_algorithms)
for some more detail on these algorithms.
## Syntax
```js-nolint
deriveBits(algorithm, baseKey, length)
```
### Parameters
- `algorithm`
- : An object defining the [derivation algorithm](/en-US/docs/Web/API/SubtleCrypto/deriveKey#supported_algorithms) to use.
- To use [ECDH](/en-US/docs/Web/API/SubtleCrypto/deriveKey#ecdh), pass an
[`EcdhKeyDeriveParams`](/en-US/docs/Web/API/EcdhKeyDeriveParams) object.
- To use [HKDF](/en-US/docs/Web/API/SubtleCrypto/deriveKey#hkdf), pass
an [`HkdfParams`](/en-US/docs/Web/API/HkdfParams) object.
- To use [PBKDF2](/en-US/docs/Web/API/SubtleCrypto/deriveKey#pbkdf2),
pass a [`Pbkdf2Params`](/en-US/docs/Web/API/Pbkdf2Params) object.
- `baseKey`
- : A {{domxref("CryptoKey")}} representing the input
to the derivation algorithm. If `algorithm` is ECDH, this will be the ECDH
private key. Otherwise it will be the initial key material for the derivation
function: for example, for PBKDF2 it might be a password, imported as a
`CryptoKey` using [`SubtleCrypto.importKey()`](/en-US/docs/Web/API/SubtleCrypto/importKey).
- `length`
- : A number representing the number of bits to derive. To be compatible with all browsers, the number should be a multiple of 8.
### Return value
A [`Promise`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
that fulfills with an [`ArrayBuffer`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer)
containing the derived bits.
### Exceptions
The promise is rejected when one of the following exceptions are encountered:
- `OperationError` {{domxref("DOMException")}}
- : Raised if the _length_ parameter of the `deriveBits()` call is null, and also in some cases if the _length_ parameter is not a multiple of 8.
- `InvalidAccessError` {{domxref("DOMException")}}
- : Raised when the base key is not a key for the requested derivation algorithm or if
the [`CryptoKey.usages`](/en-US/docs/Web/API/CryptoKey) value of that key doesn't contain
`deriveBits`.
- `NotSupported` {{domxref("DOMException")}}
- : Raised when trying to use an algorithm that is either unknown or isn't suitable for
derivation.
## Supported algorithms
See the [Supported algorithms section of the `deriveKey()` documentation](/en-US/docs/Web/API/SubtleCrypto/deriveKey#supported_algorithms).
## Examples
> **Note:** You can [try the working examples](https://mdn.github.io/dom-examples/web-crypto/derive-bits/index.html) on GitHub.
### ECDH
In this example Alice and Bob each generate an ECDH key pair.
We then use Alice's private key and Bob's public key to derive a shared secret. [See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/derive-bits/ecdh.js)
```js
async function deriveSharedSecret(privateKey, publicKey) {
const sharedSecret = await window.crypto.subtle.deriveBits(
{
name: "ECDH",
namedCurve: "P-384",
public: publicKey,
},
privateKey,
128,
);
const buffer = new Uint8Array(sharedSecret, 0, 5);
const sharedSecretValue = document.querySelector(".ecdh .derived-bits-value");
sharedSecretValue.classList.add("fade-in");
sharedSecretValue.addEventListener("animationend", () => {
sharedSecretValue.classList.remove("fade-in");
});
sharedSecretValue.textContent = `${buffer}…[${sharedSecret.byteLength} bytes total]`;
}
// Generate 2 ECDH key pairs: one for Alice and one for Bob
// In more normal usage, they would generate their key pairs
// separately and exchange public keys securely
const generateAlicesKeyPair = window.crypto.subtle.generateKey(
{
name: "ECDH",
namedCurve: "P-384",
},
false,
["deriveBits"],
);
const generateBobsKeyPair = window.crypto.subtle.generateKey(
{
name: "ECDH",
namedCurve: "P-384",
},
false,
["deriveBits"],
);
Promise.all([generateAlicesKeyPair, generateBobsKeyPair]).then((values) => {
const alicesKeyPair = values[0];
const bobsKeyPair = values[1];
const deriveBitsButton = document.querySelector(".ecdh .derive-bits-button");
deriveBitsButton.addEventListener("click", () => {
// Alice then generates a secret using her private key and Bob's public key.
// Bob could generate the same secret using his private key and Alice's public key.
deriveSharedSecret(alicesKeyPair.privateKey, bobsKeyPair.publicKey);
});
});
```
### PBKDF2
In this example we ask the user for a password, then use it to derive some bits using
PBKDF2. [See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/derive-bits/pbkdf2.js)
```js
let salt;
/*
Get some key material to use as input to the deriveBits method.
The key material is a password supplied by the user.
*/
function getKeyMaterial() {
const password = window.prompt("Enter your password");
const enc = new TextEncoder();
return window.crypto.subtle.importKey(
"raw",
enc.encode(password),
{ name: "PBKDF2" },
false,
["deriveBits", "deriveKey"],
);
}
/*
Derive some bits from a password supplied by the user.
*/
async function getDerivedBits() {
const keyMaterial = await getKeyMaterial();
salt = window.crypto.getRandomValues(new Uint8Array(16));
const derivedBits = await window.crypto.subtle.deriveBits(
{
name: "PBKDF2",
salt,
iterations: 100000,
hash: "SHA-256",
},
keyMaterial,
256,
);
const buffer = new Uint8Array(derivedBits, 0, 5);
const derivedBitsValue = document.querySelector(
".pbkdf2 .derived-bits-value",
);
derivedBitsValue.classList.add("fade-in");
derivedBitsValue.addEventListener("animationend", () => {
derivedBitsValue.classList.remove("fade-in");
});
derivedBitsValue.textContent = `${buffer}…[${derivedBits.byteLength} bytes total]`;
}
const deriveBitsButton = document.querySelector(".pbkdf2 .derive-bits-button");
deriveBitsButton.addEventListener("click", () => {
getDerivedBits();
});
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [HKDF specification](https://datatracker.ietf.org/doc/html/rfc5869).
- [NIST guidelines for password-based key derivation](https://csrc.nist.gov/publications/detail/sp/800-132/final).
- [Password storage cheat sheet](https://cheatsheetseries.owasp.org/cheatsheets/Password_Storage_Cheat_Sheet.html).
- [Advice on choosing an iteration count for PBKDF2](https://security.stackexchange.com/questions/3959/recommended-of-iterations-when-using-pbkdf2-sha256/3993#3993).
| 0 |
data/mdn-content/files/en-us/web/api/subtlecrypto | data/mdn-content/files/en-us/web/api/subtlecrypto/verify/index.md | ---
title: "SubtleCrypto: verify() method"
short-title: verify()
slug: Web/API/SubtleCrypto/verify
page-type: web-api-instance-method
browser-compat: api.SubtleCrypto.verify
---
{{APIRef("Web Crypto API")}}{{SecureContext_header}}
The **`verify()`** method of the {{domxref("SubtleCrypto")}}
interface verifies a digital {{glossary("signature")}}.
It takes as its arguments a {{glossary("key")}} to verify the signature with, some
algorithm-specific parameters, the signature, and the original signed data. It returns a
{{jsxref("Promise")}} which will be fulfilled with a boolean value
indicating whether the signature is valid.
## Syntax
```js-nolint
verify(algorithm, key, signature, data)
```
### Parameters
- `algorithm`
- : A string or object defining the algorithm to use, and for some algorithm choices, some extra parameters.
The values given for the extra parameters must match those passed into the corresponding {{domxref("SubtleCrypto.sign()", "sign()")}} call.
- To use [RSASSA-PKCS1-v1_5](/en-US/docs/Web/API/SubtleCrypto/sign#rsassa-pkcs1-v1_5),
pass the string `"RSASSA-PKCS1-v1_5"` or an object of the form `{ "name": "RSASSA-PKCS1-v1_5" }`.
- To use [RSA-PSS](/en-US/docs/Web/API/SubtleCrypto/sign#rsa-pss), pass an {{domxref("RsaPssParams")}} object.
- To use [ECDSA](/en-US/docs/Web/API/SubtleCrypto/sign#ecdsa), pass an {{domxref("EcdsaParams")}} object.
- To use [HMAC](/en-US/docs/Web/API/SubtleCrypto/sign#hmac), pass the string `"HMAC"` or an object of the form `{ "name": "HMAC" }`.
- `key`
- : A {{domxref("CryptoKey")}} containing the key that will be used to verify the signature.
It is the secret key for a symmetric algorithm and the public key for a public-key system.
- `signature`
- : A {{jsxref("ArrayBuffer")}} containing the {{glossary("signature")}} to verify.
- `data`
- : A {{jsxref("ArrayBuffer")}} containing the data whose signature is to be verified.
### Return value
A {{jsxref("Promise")}} that fulfills with a
boolean value: `true` if the signature is valid, `false`
otherwise.
### Exceptions
The promise is rejected when the following exception is encountered:
- `InvalidAccessError` {{domxref("DOMException")}}
- : Raised when the encryption key is not a key for the requested verifying algorithm or
when trying to use an algorithm that is either unknown or isn't suitable for a verify
operation.
## Supported algorithms
The `verify()` method supports the same algorithms as the
[`sign()`](/en-US/docs/Web/API/SubtleCrypto/sign#supported_algorithms)
method.
## Examples
> **Note:** You can [try the working examples](https://mdn.github.io/dom-examples/web-crypto/sign-verify/index.html) out on GitHub.
### RSASSA-PKCS1-v1_5
This code uses a public key to verify a signature.
[See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/sign-verify/rsassa-pkcs1.js)
```js
/*
Fetch the contents of the "message" textbox, and encode it
in a form we can use for sign operation.
*/
function getMessageEncoding() {
const messageBox = document.querySelector(".rsassa-pkcs1 #message");
let message = messageBox.value;
let enc = new TextEncoder();
return enc.encode(message);
}
/*
Fetch the encoded message-to-sign and verify it against the stored signature.
* If it checks out, set the "valid" class on the signature.
* Otherwise set the "invalid" class.
*/
async function verifyMessage(publicKey) {
const signatureValue = document.querySelector(
".rsassa-pkcs1 .signature-value",
);
signatureValue.classList.remove("valid", "invalid");
let encoded = getMessageEncoding();
let result = await window.crypto.subtle.verify(
"RSASSA-PKCS1-v1_5",
publicKey,
signature,
encoded,
);
signatureValue.classList.add(result ? "valid" : "invalid");
}
```
### RSA-PSS
This code uses a public key to verify a signature.
[See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/sign-verify/rsa-pss.js)
```js
/*
Fetch the contents of the "message" textbox, and encode it
in a form we can use for sign operation.
*/
function getMessageEncoding() {
const messageBox = document.querySelector(".rsa-pss #message");
let message = messageBox.value;
let enc = new TextEncoder();
return enc.encode(message);
}
/*
Fetch the encoded message-to-sign and verify it against the stored signature.
* If it checks out, set the "valid" class on the signature.
* Otherwise set the "invalid" class.
*/
async function verifyMessage(publicKey) {
const signatureValue = document.querySelector(".rsa-pss .signature-value");
signatureValue.classList.remove("valid", "invalid");
let encoded = getMessageEncoding();
let result = await window.crypto.subtle.verify(
{
name: "RSA-PSS",
saltLength: 32,
},
publicKey,
signature,
encoded,
);
signatureValue.classList.add(result ? "valid" : "invalid");
}
```
### ECDSA
This code uses a public key to verify a signature.
[See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/sign-verify/ecdsa.js)
```js
/*
Fetch the contents of the "message" textbox, and encode it
in a form we can use for sign operation.
*/
function getMessageEncoding() {
const messageBox = document.querySelector(".ecdsa #message");
let message = messageBox.value;
let enc = new TextEncoder();
return enc.encode(message);
}
/*
Fetch the encoded message-to-sign and verify it against the stored signature.
* If it checks out, set the "valid" class on the signature.
* Otherwise set the "invalid" class.
*/
async function verifyMessage(publicKey) {
const signatureValue = document.querySelector(".ecdsa .signature-value");
signatureValue.classList.remove("valid", "invalid");
let encoded = getMessageEncoding();
let result = await window.crypto.subtle.verify(
{
name: "ECDSA",
hash: { name: "SHA-384" },
},
publicKey,
signature,
encoded,
);
signatureValue.classList.add(result ? "valid" : "invalid");
}
```
### HMAC
This code uses a secret key to verify a signature.
[See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/sign-verify/hmac.js)
```js
/*
Fetch the contents of the "message" textbox, and encode it
in a form we can use for sign operation.
*/
function getMessageEncoding() {
const messageBox = document.querySelector(".hmac #message");
let message = messageBox.value;
let enc = new TextEncoder();
return enc.encode(message);
}
/*
Fetch the encoded message-to-sign and verify it against the stored signature.
* If it checks out, set the "valid" class on the signature.
* Otherwise set the "invalid" class.
*/
async function verifyMessage(key) {
const signatureValue = document.querySelector(".hmac .signature-value");
signatureValue.classList.remove("valid", "invalid");
let encoded = getMessageEncoding();
let result = await window.crypto.subtle.verify(
"HMAC",
key,
signature,
encoded,
);
signatureValue.classList.add(result ? "valid" : "invalid");
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("SubtleCrypto.sign()")}}.
- [RFC 3447](https://datatracker.ietf.org/doc/html/rfc3447) specifies RSASSA-PKCS1-v1_5.
- [RFC 3447](https://datatracker.ietf.org/doc/html/rfc3447) specifies RSA-PSS.
- [FIPS-186](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.186-4.pdf) specifies ECDSA.
- [FIPS 198-1](https://csrc.nist.gov/csrc/media/publications/fips/198/1/final/documents/fips-198-1_final.pdf) specifies HMAC.
| 0 |
data/mdn-content/files/en-us/web/api/subtlecrypto | data/mdn-content/files/en-us/web/api/subtlecrypto/decrypt/index.md | ---
title: "SubtleCrypto: decrypt() method"
short-title: decrypt()
slug: Web/API/SubtleCrypto/decrypt
page-type: web-api-instance-method
browser-compat: api.SubtleCrypto.decrypt
---
{{APIRef("Web Crypto API")}}{{SecureContext_header}}
The **`decrypt()`** method of the {{domxref("SubtleCrypto")}} interface decrypts some encrypted data.
It takes as arguments a {{glossary("key")}} to decrypt with, some optional extra parameters, and the data to decrypt (also known as "ciphertext").
It returns a {{jsxref("Promise")}} which will be fulfilled with the decrypted data (also known as "plaintext").
## Syntax
```js-nolint
decrypt(algorithm, key, data)
```
### Parameters
- `algorithm`
- : An object specifying the [algorithm](#supported_algorithms) to be used, and any extra parameters as required.
The values given for the extra parameters must match those passed into the corresponding {{domxref("SubtleCrypto.encrypt()", "encrypt()")}} call.
- To use [RSA-OAEP](#rsa-oaep), pass an {{domxref("RsaOaepParams")}} object.
- To use [AES-CTR](#aes-ctr), pass an {{domxref("AesCtrParams")}} object.
- To use [AES-CBC](#aes-cbc), pass an {{domxref("AesCbcParams")}} object.
- To use [AES-GCM](#aes-gcm), pass an {{domxref("AesGcmParams")}} object.
- `key`
- : A {{domxref("CryptoKey")}} containing the key to be used for decryption.
If using RSA-OAEP, this is the `privateKey` property of the {{domxref("CryptoKeyPair")}} object.
- `data`
- : An {{jsxref("ArrayBuffer")}}, a {{jsxref("TypedArray")}}, or a {{jsxref("DataView")}} containing the data to be decrypted (also known as {{glossary("ciphertext")}}).
### Return value
A {{jsxref("Promise")}} that fulfills with an {{jsxref("ArrayBuffer")}} containing the plaintext.
### Exceptions
The promise is rejected when the following exceptions are encountered:
- `InvalidAccessError` {{domxref("DOMException")}}
- : Raised when the requested operation is not valid for the provided key (e.g. invalid encryption algorithm, or invalid key for the specified encryption algorithm*)*.
- `OperationError` {{domxref("DOMException")}}
- : Raised when the operation failed for an operation-specific reason (e.g. algorithm parameters of invalid sizes, or there was an error decrypting the ciphertext).
## Supported algorithms
The `decrypt()` method supports the same algorithms as the [`encrypt()`](/en-US/docs/Web/API/SubtleCrypto/encrypt#supported_algorithms) method.
## Examples
> **Note:** You can [try the working examples](https://mdn.github.io/dom-examples/web-crypto/encrypt-decrypt/index.html) on GitHub.
### RSA-OAEP
This code decrypts `ciphertext` using RSA-OAEP. [See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/encrypt-decrypt/rsa-oaep.js)
```js
function decryptMessage(privateKey, ciphertext) {
return window.crypto.subtle.decrypt(
{ name: "RSA-OAEP" },
privateKey,
ciphertext,
);
}
```
### AES-CTR
This code decrypts `ciphertext` using AES in CTR mode.
Note that `counter` must match the value that was used for encryption. [See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/encrypt-decrypt/aes-ctr.js)
```js
function decryptMessage(key, ciphertext) {
return window.crypto.subtle.decrypt(
{ name: "AES-CTR", counter, length: 64 },
key,
ciphertext,
);
}
```
### AES-CBC
This code decrypts `ciphertext` using AES in CBC mode. Note that
`iv` must match the value that was used for encryption. [See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/encrypt-decrypt/aes-cbc.js)
```js
function decryptMessage(key, ciphertext) {
// The iv value is the same as that used for encryption
return window.crypto.subtle.decrypt({ name: "AES-CBC", iv }, key, ciphertext);
}
```
### AES-GCM
This code decrypts `ciphertext` using AES in GCM mode. Note that
`iv` must match the value that was used for encryption. [See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/encrypt-decrypt/aes-gcm.js)
```js
function decryptMessage(key, ciphertext) {
// The iv value is the same as that used for encryption
return window.crypto.subtle.decrypt({ name: "AES-GCM", iv }, key, ciphertext);
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("SubtleCrypto.encrypt()")}}.
- [RFC 3447](https://datatracker.ietf.org/doc/html/rfc3447) specifies RSAOAEP.
- [NIST SP800-38A](https://csrc.nist.gov/publications/detail/sp/800-38a/final) specifies CTR mode.
- [NIST SP800-38A](https://csrc.nist.gov/publications/detail/sp/800-38a/final) specifies CBC mode.
- [NIST SP800-38D](https://csrc.nist.gov/publications/detail/sp/800-38d/final) specifies GCM mode.
- [FIPS 198-1](https://csrc.nist.gov/csrc/media/publications/fips/198/1/final/documents/fips-198-1_final.pdf) specifies HMAC.
| 0 |
data/mdn-content/files/en-us/web/api/subtlecrypto | data/mdn-content/files/en-us/web/api/subtlecrypto/derivekey/index.md | ---
title: "SubtleCrypto: deriveKey() method"
short-title: deriveKey()
slug: Web/API/SubtleCrypto/deriveKey
page-type: web-api-instance-method
browser-compat: api.SubtleCrypto.deriveKey
---
{{APIRef("Web Crypto API")}}{{SecureContext_header}}
The **`deriveKey()`** method of the {{domxref("SubtleCrypto")}}
interface can be used to derive a secret key from a master key.
It takes as arguments some initial key material, the derivation algorithm to use, and
the desired properties for the key to derive. It returns a [`Promise`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
which will be fulfilled with a {{domxref("CryptoKey")}} object representing the new key.
It's worth noting that the three key derivation algorithms you can use have quite
different characteristics and are appropriate in quite different situations. See [Supported algorithms](#supported_algorithms) for some more detail on this.
## Syntax
```js-nolint
deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages)
```
### Parameters
- `algorithm`
- : An object defining the [derivation algorithm](#supported_algorithms) to use.
- To use [ECDH](#ecdh), pass an
[`EcdhKeyDeriveParams`](/en-US/docs/Web/API/EcdhKeyDeriveParams) object.
- To use [HKDF](#hkdf), pass an [`HkdfParams`](/en-US/docs/Web/API/HkdfParams) object.
- To use [PBKDF2](#pbkdf2), pass
a [`Pbkdf2Params`](/en-US/docs/Web/API/Pbkdf2Params) object.
- `baseKey`
- : A {{domxref("CryptoKey")}} representing the input
to the derivation algorithm. If `algorithm` is ECDH, then this will be the
ECDH private key. Otherwise it will be the initial key material for the derivation
function: for example, for PBKDF2 it might be a password, imported as a
`CryptoKey` using
[`SubtleCrypto.importKey()`](/en-US/docs/Web/API/SubtleCrypto/importKey).
- `derivedKeyAlgorithm`
- : An object defining the algorithm the derived key will be used for:
- For [HMAC](/en-US/docs/Web/API/SubtleCrypto/sign#hmac) pass an [`HmacKeyGenParams`](/en-US/docs/Web/API/HmacKeyGenParams) object.
- For [AES-CTR](/en-US/docs/Web/API/SubtleCrypto/encrypt#aes-ctr), [AES-CBC](/en-US/docs/Web/API/SubtleCrypto/encrypt#aes-cbc),
[AES-GCM](/en-US/docs/Web/API/SubtleCrypto/encrypt#aes-gcm), or [AES-KW](/en-US/docs/Web/API/SubtleCrypto/wrapKey#aes-kw), pass an
[`AesKeyGenParams`](/en-US/docs/Web/API/AesKeyGenParams) object.
- For [HKDF](#hkdf), pass an [`HkdfParams`](/en-US/docs/Web/API/HkdfParams) object.
- For [PBKDF2](#pbkdf2), pass a [`Pbkdf2Params`](/en-US/docs/Web/API/Pbkdf2Params) object.
- `extractable`
- : A boolean value indicating whether it
will be possible to export the key using {{domxref("SubtleCrypto.exportKey()")}} or
{{domxref("SubtleCrypto.wrapKey()")}}.
- `keyUsages`
- : An {{jsxref("Array")}} indicating what can be
done with the derived key. Note that the key usages must be allowed by the algorithm
set in `derivedKeyAlgorithm`. Possible values of the array are:
- `encrypt`: The key may be used to {{domxref("SubtleCrypto.encrypt()", "encrypt")}} messages.
- `decrypt`: The key may be used to {{domxref("SubtleCrypto.decrypt()", "decrypt")}} messages.
- `sign`: The key may be used to {{domxref("SubtleCrypto.sign()", "sign")}} messages.
- `verify`: The key may be used to {{domxref("SubtleCrypto.verify()", "verify")}} signatures.
- `deriveKey`: The key may be used in {{domxref("SubtleCrypto.deriveKey()", "deriving a new key")}}.
- `deriveBits`: The key may be used in {{domxref("SubtleCrypto.deriveBits()", "deriving bits")}}.
- `wrapKey`: The key may be used to {{domxref("SubtleCrypto.wrapKey()", "wrap a key")}}.
- `unwrapKey`: The key may be used to {{domxref("SubtleCrypto.unwrapKey()", "unwrap a key")}}.
### Return value
A {{jsxref("Promise")}} that fulfills with a {{domxref("CryptoKey")}}.
### Exceptions
The promise is rejected when one of the following exceptions are encountered:
- `InvalidAccessError` {{domxref("DOMException")}}
- : Raised when the master key is not a key for the requested derivation algorithm
or if the `keyUsages` value of that key doesn't contain `deriveKey`.
- `NotSupported` {{domxref("DOMException")}}
- : Raised when trying to use an algorithm that is either unknown or isn't suitable for
derivation, or if the algorithm requested for the derived key doesn't define a key
length.
- `SyntaxError` {{domxref("DOMException")}}
- : Raised when `keyUsages` is empty but the unwrapped key is of
type `secret` or `private`.
## Supported algorithms
The three algorithms supported by `deriveKey()` have quite different
characteristics and are appropriate in different situations.
### ECDH
ECDH (Elliptic Curve Diffie-Hellman) is a _key-agreement algorithm_. It enables
two people who each have an ECDH public/private key pair to generate a shared secret:
that is, a secret that they — and no one else — share. They can then use this shared
secret as a symmetric key to secure their communication, or can use the secret as an
input to derive such a key (for example, using the HKDF algorithm).
ECDH is specified in [RFC 6090](https://datatracker.ietf.org/doc/html/rfc6090).
### HKDF
HKDF is a _key derivation function_. It's designed to derive key material from
some high-entropy input, such as the output of an ECDH key agreement operation.
It's _not_ designed to derive keys from relatively low-entropy inputs such as
passwords. For that, use PBKDF2.
HKDF is specified in [RFC 5869](https://datatracker.ietf.org/doc/html/rfc5869).
### PBKDF2
PBKDF2 is also a _key derivation function_. It's designed to derive key material
from some relatively low-entropy input, such as a password. It derives key material by
applying a function such as HMAC to the input password along with some salt, and
repeating this process many times. The more times the process is repeated, the more
computationally expensive key derivation is: this makes it harder for an attacker to use
brute-force to discover the key using a dictionary attack.
PBKDF2 is specified in [RFC 2898](https://datatracker.ietf.org/doc/html/rfc2898).
## Examples
> **Note:** You can [try the working examples](https://mdn.github.io/dom-examples/web-crypto/derive-key/index.html) on GitHub.
### ECDH
In this example Alice and Bob each generate an ECDH key pair, then exchange public
keys. They then use `deriveKey()` to derive a shared AES key, that they could
use to encrypt messages. [See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/derive-key/ecdh.js)
```js
/*
Derive an AES key, given:
- our ECDH private key
- their ECDH public key
*/
function deriveSecretKey(privateKey, publicKey) {
return window.crypto.subtle.deriveKey(
{
name: "ECDH",
public: publicKey,
},
privateKey,
{
name: "AES-GCM",
length: 256,
},
false,
["encrypt", "decrypt"],
);
}
async function agreeSharedSecretKey() {
// Generate 2 ECDH key pairs: one for Alice and one for Bob
// In more normal usage, they would generate their key pairs
// separately and exchange public keys securely
let alicesKeyPair = await window.crypto.subtle.generateKey(
{
name: "ECDH",
namedCurve: "P-384",
},
false,
["deriveKey"],
);
let bobsKeyPair = await window.crypto.subtle.generateKey(
{
name: "ECDH",
namedCurve: "P-384",
},
false,
["deriveKey"],
);
// Alice then generates a secret key using her private key and Bob's public key.
let alicesSecretKey = await deriveSecretKey(
alicesKeyPair.privateKey,
bobsKeyPair.publicKey,
);
// Bob generates the same secret key using his private key and Alice's public key.
let bobsSecretKey = await deriveSecretKey(
bobsKeyPair.privateKey,
alicesKeyPair.publicKey,
);
// Alice can then use her copy of the secret key to encrypt a message to Bob.
let encryptButton = document.querySelector(".ecdh .encrypt-button");
encryptButton.addEventListener("click", () => {
encrypt(alicesSecretKey);
});
// Bob can use his copy to decrypt the message.
let decryptButton = document.querySelector(".ecdh .decrypt-button");
decryptButton.addEventListener("click", () => {
decrypt(bobsSecretKey);
});
}
```
### PBKDF2
In this example we ask the user for a password, then use it to derive an AES key using
PBKDF2, then use the AES key to encrypt a message.
[See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/derive-key/pbkdf2.js)
```js
/*
Get some key material to use as input to the deriveKey method.
The key material is a password supplied by the user.
*/
function getKeyMaterial() {
const password = window.prompt("Enter your password");
const enc = new TextEncoder();
return window.crypto.subtle.importKey(
"raw",
enc.encode(password),
"PBKDF2",
false,
["deriveBits", "deriveKey"],
);
}
async function encrypt(plaintext, salt, iv) {
const keyMaterial = await getKeyMaterial();
const key = await window.crypto.subtle.deriveKey(
{
name: "PBKDF2",
salt,
iterations: 100000,
hash: "SHA-256",
},
keyMaterial,
{ name: "AES-GCM", length: 256 },
true,
["encrypt", "decrypt"],
);
return window.crypto.subtle.encrypt({ name: "AES-GCM", iv }, key, plaintext);
}
```
### HKDF
In this example, we encrypt a message `plainText` given a shared secret `secret`, which might itself have been derived using an algorithm such as ECDH. Instead of using the shared secret directly, we use it as key material for the HKDF function, to derive an AES-GCM encryption key, which we then use to encrypt the message. [See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/derive-key/hkdf.js)
```js
/*
Given some key material and some random salt,
derive an AES-GCM key using HKDF.
*/
function getKey(keyMaterial, salt) {
return window.crypto.subtle.deriveKey(
{
name: "HKDF",
salt: salt,
info: new Uint8Array("Encryption example"),
hash: "SHA-256",
},
keyMaterial,
{ name: "AES-GCM", length: 256 },
true,
["encrypt", "decrypt"],
);
}
async function encrypt(secret, plainText) {
const message = {
salt: window.crypto.getRandomValues(new Uint8Array(16)),
iv: window.crypto.getRandomValues(new Uint8Array(12)),
};
const key = await getKey(secret, message.salt);
message.ciphertext = await window.crypto.subtle.encrypt(
{
name: "AES-GCM",
iv: message.iv,
},
key,
plainText,
);
return message;
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [HKDF specification](https://datatracker.ietf.org/doc/html/rfc5869).
- [NIST guidelines for password-based key derivation](https://csrc.nist.gov/publications/detail/sp/800-132/final).
- [Password storage cheat sheet](https://cheatsheetseries.owasp.org/cheatsheets/Password_Storage_Cheat_Sheet.html).
- [Advice on choosing an iteration count for PBKDF2](https://security.stackexchange.com/questions/3959/recommended-of-iterations-when-using-pbkdf2-sha256/3993#3993).
| 0 |
data/mdn-content/files/en-us/web/api/subtlecrypto | data/mdn-content/files/en-us/web/api/subtlecrypto/generatekey/index.md | ---
title: "SubtleCrypto: generateKey() method"
short-title: generateKey()
slug: Web/API/SubtleCrypto/generateKey
page-type: web-api-instance-method
browser-compat: api.SubtleCrypto.generateKey
---
{{APIRef("Web Crypto API")}}{{SecureContext_header}}
Use the **`generateKey()`** method of the
{{domxref("SubtleCrypto")}} interface to generate a new key (for symmetric algorithms)
or key pair (for public-key algorithms).
## Syntax
```js-nolint
generateKey(algorithm, extractable, keyUsages)
```
### Parameters
- `algorithm`
- : An object defining the type of key to generate and providing extra algorithm-specific parameters.
- For [RSASSA-PKCS1-v1_5](/en-US/docs/Web/API/SubtleCrypto/sign#rsassa-pkcs1-v1_5), [RSA-PSS](/en-US/docs/Web/API/SubtleCrypto/sign#rsa-pss),
or [RSA-OAEP](/en-US/docs/Web/API/SubtleCrypto/encrypt#rsa-oaep):
pass an [`RsaHashedKeyGenParams`](/en-US/docs/Web/API/RsaHashedKeyGenParams) object.
- For [ECDSA](/en-US/docs/Web/API/SubtleCrypto/sign#ecdsa) or [ECDH](/en-US/docs/Web/API/SubtleCrypto/deriveKey#ecdh):
pass an [`EcKeyGenParams`](/en-US/docs/Web/API/EcKeyGenParams) object.
- For [HMAC](/en-US/docs/Web/API/SubtleCrypto/sign#hmac):
pass an [`HmacKeyGenParams`](/en-US/docs/Web/API/HmacKeyGenParams) object.
- For [AES-CTR](/en-US/docs/Web/API/SubtleCrypto/encrypt#aes-ctr), [AES-CBC](/en-US/docs/Web/API/SubtleCrypto/encrypt#aes-cbc),
[AES-GCM](/en-US/docs/Web/API/SubtleCrypto/encrypt#aes-gcm), or [AES-KW](/en-US/docs/Web/API/SubtleCrypto/wrapKey#aes-kw):
pass an [`AesKeyGenParams`](/en-US/docs/Web/API/AesKeyGenParams) object.
- `extractable`
- : A boolean value indicating whether it
will be possible to export the key using {{domxref("SubtleCrypto.exportKey()")}} or
{{domxref("SubtleCrypto.wrapKey()")}}.
- `keyUsages`
- : An {{jsxref("Array")}} indicating what can be
done with the newly generated key. Possible values for array elements are:
- `encrypt`: The key may be used to {{domxref("SubtleCrypto.encrypt()", "encrypt")}} messages.
- `decrypt`: The key may be used to {{domxref("SubtleCrypto.decrypt()", "decrypt")}} messages.
- `sign`: The key may be used to {{domxref("SubtleCrypto.sign()", "sign")}} messages.
- `verify`: The key may be used to {{domxref("SubtleCrypto.verify()", "verify")}} signatures.
- `deriveKey`: The key may be used in {{domxref("SubtleCrypto.deriveKey()", "deriving a new key")}}.
- `deriveBits`: The key may be used in {{domxref("SubtleCrypto.deriveBits()", "deriving bits")}}.
- `wrapKey`: The key may be used to {{domxref("SubtleCrypto.wrapKey()", "wrap a key")}}.
- `unwrapKey`: The key may be used to {{domxref("SubtleCrypto.unwrapKey()", "unwrap a key")}}.
### Return value
A {{jsxref("Promise")}} that fulfills with a
{{domxref("CryptoKey")}} (for symmetric algorithms) or a {{domxref("CryptoKeyPair")}}
(for public-key algorithms).
### Exceptions
The promise is rejected when the following exception is encountered:
- `SyntaxError` {{domxref("DOMException")}}
- : Raised when the result is a {{domxref("CryptoKey")}} of type `secret` or
`private` but `keyUsages` is empty.
- `SyntaxError` {{domxref("DOMException")}}
- : Raised when the result is a {{domxref("CryptoKeyPair")}} and its
`privateKey.usages` attribute is empty.
## Examples
> **Note:** You can [try the working examples](https://mdn.github.io/dom-examples/web-crypto/encrypt-decrypt/index.html) on GitHub.
### RSA key pair generation
This code generates an RSA-OAEP encryption key pair.
[See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/encrypt-decrypt/rsa-oaep.js)
```js
let keyPair = await window.crypto.subtle.generateKey(
{
name: "RSA-OAEP",
modulusLength: 4096,
publicExponent: new Uint8Array([1, 0, 1]),
hash: "SHA-256",
},
true,
["encrypt", "decrypt"],
);
```
### Elliptic curve key pair generation
This code generates an ECDSA signing key pair.
[See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/sign-verify/ecdsa.js)
```js
let keyPair = await window.crypto.subtle.generateKey(
{
name: "ECDSA",
namedCurve: "P-384",
},
true,
["sign", "verify"],
);
```
### HMAC key generation
This code generates an HMAC signing key.
[See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/sign-verify/hmac.js)
```js
let key = await window.crypto.subtle.generateKey(
{
name: "HMAC",
hash: { name: "SHA-512" },
},
true,
["sign", "verify"],
);
```
### AES key generation
This code generates an AES-GCM encryption key.
[See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/encrypt-decrypt/aes-gcm.js)
```js
let key = await window.crypto.subtle.generateKey(
{
name: "AES-GCM",
length: 256,
},
true,
["encrypt", "decrypt"],
);
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Cryptographic key length recommendations](https://www.keylength.com/).
- [NIST Transitioning the Use of Cryptographic Algorithms and Key Lengths](https://csrc.nist.gov/publications/detail/sp/800-131a/rev-2/final).
| 0 |
data/mdn-content/files/en-us/web/api/subtlecrypto | data/mdn-content/files/en-us/web/api/subtlecrypto/sign/index.md | ---
title: "SubtleCrypto: sign() method"
short-title: sign()
slug: Web/API/SubtleCrypto/sign
page-type: web-api-instance-method
browser-compat: api.SubtleCrypto.sign
---
{{APIRef("Web Crypto API")}}{{SecureContext_header}}
The **`sign()`** method of the {{domxref("SubtleCrypto")}}
interface generates a digital {{glossary("signature")}}.
It takes as its arguments a {{glossary("key")}} to sign with, some algorithm-specific
parameters, and the data to sign. It returns a {{jsxref("Promise")}} which will be
fulfilled with the signature.
You can use the corresponding {{domxref("SubtleCrypto.verify()")}} method to verify the
signature.
## Syntax
```js-nolint
sign(algorithm, key, data)
```
### Parameters
- `algorithm`
- : A string or object that specifies the signature algorithm to use and its parameters:
- To use [RSASSA-PKCS1-v1_5](#rsassa-pkcs1-v1_5), pass the string `"RSASSA-PKCS1-v1_5"`
or an object of the form `{ "name": "RSASSA-PKCS1-v1_5" }`.
- To use [RSA-PSS](#rsa-pss), pass an {{domxref("RsaPssParams")}} object.
- To use [ECDSA](#ecdsa), pass an {{domxref("EcdsaParams")}} object.
- To use [HMAC](#hmac), pass the string `"HMAC"`
or an object of the form `{ "name": "HMAC" }`.
- `key`
- : A {{domxref("CryptoKey")}} object containing the key to be used for signing.
If `algorithm` identifies a public-key cryptosystem, this is the private key.
- `data`
- : An {{jsxref("ArrayBuffer")}}, a {{jsxref("TypedArray")}} or a {{jsxref("DataView")}} object containing the data to be signed.
### Return value
A {{jsxref("Promise")}} that fulfills with an
{{jsxref("ArrayBuffer")}} containing the signature.
### Exceptions
The promise is rejected when the following exception is encountered:
- `InvalidAccessError` {{domxref("DOMException")}}
- : Raised when the signing key is not a key for the request signing algorithm or when
trying to use an algorithm that is either unknown or isn't suitable for signing.
## Supported algorithms
The Web Crypto API provides four algorithms that can be used for signing and signature
verification.
Three of these algorithms — RSASSA-PKCS1-v1_5, RSA-PSS, and ECDSA — are
{{Glossary("public-key cryptography", "public-key cryptosystems")}} that use the private
key for signing and the public key for verification.
These systems all use a [digest algorithm](/en-US/docs/Web/API/SubtleCrypto/digest#supported_algorithms)
to hash the message to a short fixed size before signing.
Except for ECDSA (for which it is passed in the `algorithm` object), the choice of digest algorithm is passed into the
{{domxref("SubtleCrypto.generateKey()", "generateKey()")}} or {{domxref("SubtleCrypto.importKey()", "importKey()")}} functions.
The fourth algorithm — HMAC — uses the same algorithm and key for signing and for
verification: this means that the verification key must be kept secret, which in turn
means that this algorithm is not suitable for many signature use cases. It can be a good
choice however when the signer and verifier are the same entity.
### RSASSA-PKCS1-v1_5
The RSASSA-PKCS1-v1_5 algorithm is specified in [RFC 3447](https://datatracker.ietf.org/doc/html/rfc3447).
### RSA-PSS
The RSA-PSS algorithm is specified in [RFC 3447](https://datatracker.ietf.org/doc/html/rfc3447).
It's different from RSASSA-PKCS1-v1_5 in that it incorporates a random salt in the
signature operation, so the same message signed with the same key will not result in the
same signature each time. An extra property, defining the salt length, is passed into
the {{domxref("SubtleCrypto.sign()", "sign()")}} and {{domxref("SubtleCrypto.verify()",
"verify()")}} functions when they are invoked.
### ECDSA
ECDSA (Elliptic Curve Digital Signature Algorithm) is a variant of the Digital
Signature Algorithm, specified in [FIPS-186](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.186-4.pdf),
that uses Elliptic Curve Cryptography ([RFC 6090](https://datatracker.ietf.org/doc/html/rfc6090)).
Signatures are encoded as the `s1` and `s2` values specified in RFC 6090 (known respectively as `r`
and `s` in [RFC 4754](https://datatracker.ietf.org/doc/html/rfc4754#section-3)), each in big-endian
byte arrays, with their length the bit size of the curve rounded up to a whole number of bytes.
These values are concatenated together in this order.
This encoding was also proposed by the [IEEE 1363-2000](https://standards.ieee.org/ieee/1363/2049/)
standard, and is sometimes referred to as the IEEE P1363 format. It differs from the
[X.509](https://www.itu.int/rec/T-REC-X.509) signature structure, which is the default format
produced by some tools and libraries such as [OpenSSL](https://www.openssl.org).
### HMAC
The HMAC algorithm calculates and verifies hash-based message authentication codes according to the
[FIPS 198-1 standard](https://csrc.nist.gov/csrc/media/publications/fips/198/1/final/documents/fips-198-1_final.pdf).
The digest algorithm to use is specified in the
[`HmacKeyGenParams`](/en-US/docs/Web/API/HmacKeyGenParams) object
that you pass into {{domxref("SubtleCrypto.generateKey()", "generateKey()")}}, or the
[`HmacImportParams`](/en-US/docs/Web/API/HmacImportParams) object
that you pass into {{domxref("SubtleCrypto.importKey()", "importKey()")}}.
## Examples
> **Note:** You can [try the working examples](https://mdn.github.io/dom-examples/web-crypto/sign-verify/index.html) out on GitHub.
### RSASSA-PKCS1-v1_5
This code fetches the contents of a text box, encodes it for signing, and signs it with
a private key.
[See the complete source code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/sign-verify/rsassa-pkcs1.js)
```js
/*
Fetch the contents of the "message" textbox, and encode it
in a form we can use for the sign operation.
*/
function getMessageEncoding() {
const messageBox = document.querySelector(".rsassa-pkcs1 #message");
let message = messageBox.value;
let enc = new TextEncoder();
return enc.encode(message);
}
let encoded = getMessageEncoding();
let signature = await window.crypto.subtle.sign(
"RSASSA-PKCS1-v1_5",
privateKey,
encoded,
);
```
### RSA-PSS
This code fetches the contents of a text box, encodes it for signing, and signs it with
a private key.
[See the complete source code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/sign-verify/rsa-pss.js)
```js
/*
Fetch the contents of the "message" textbox, and encode it
in a form we can use for the sign operation.
*/
function getMessageEncoding() {
const messageBox = document.querySelector(".rsa-pss #message");
let message = messageBox.value;
let enc = new TextEncoder();
return enc.encode(message);
}
let encoded = getMessageEncoding();
let signature = await window.crypto.subtle.sign(
{
name: "RSA-PSS",
saltLength: 32,
},
privateKey,
encoded,
);
```
### ECDSA
This code fetches the contents of a text box, encodes it for signing, and signs it with
a private key.
[See the complete source code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/sign-verify/ecdsa.js)
```js
/*
Fetch the contents of the "message" textbox, and encode it
in a form we can use for the sign operation.
*/
function getMessageEncoding() {
const messageBox = document.querySelector(".ecdsa #message");
let message = messageBox.value;
let enc = new TextEncoder();
return enc.encode(message);
}
let encoded = getMessageEncoding();
let signature = await window.crypto.subtle.sign(
{
name: "ECDSA",
hash: { name: "SHA-384" },
},
privateKey,
encoded,
);
```
### HMAC
This code fetches the contents of a text box, encodes it for signing, and signs it with
a secret key.
[See the complete source code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/sign-verify/hmac.js)
```js
/*
Fetch the contents of the "message" textbox, and encode it
in a form we can use for the sign operation.
*/
function getMessageEncoding() {
const messageBox = document.querySelector(".hmac #message");
let message = messageBox.value;
let enc = new TextEncoder();
return enc.encode(message);
}
let encoded = getMessageEncoding();
let signature = await window.crypto.subtle.sign("HMAC", key, encoded);
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("SubtleCrypto.verify()")}}.
- [RFC 3447](https://datatracker.ietf.org/doc/html/rfc3447) specifies RSASSA-PKCS1-v1_5.
- [RFC 3447](https://datatracker.ietf.org/doc/html/rfc3447) specifies RSA-PSS.
- [FIPS-186](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.186-4.pdf) specifies ECDSA.
- [FIPS 198-1](https://csrc.nist.gov/csrc/media/publications/fips/198/1/final/documents/fips-198-1_final.pdf) specifies HMAC.
| 0 |
data/mdn-content/files/en-us/web/api/subtlecrypto | data/mdn-content/files/en-us/web/api/subtlecrypto/wrapkey/index.md | ---
title: "SubtleCrypto: wrapKey() method"
short-title: wrapKey()
slug: Web/API/SubtleCrypto/wrapKey
page-type: web-api-instance-method
browser-compat: api.SubtleCrypto.wrapKey
---
{{APIRef("Web Crypto API")}}{{SecureContext_header}}
The **`wrapKey()`** method of the {{domxref("SubtleCrypto")}} interface "wraps" a key.
This means that it exports the key in an external, portable format, then encrypts the exported key.
Wrapping a key helps protect it in untrusted environments, such as inside an otherwise unprotected data store or in transmission over an unprotected network.
As with {{DOMxRef("SubtleCrypto.exportKey()")}}, you specify an [export format](/en-US/docs/Web/API/SubtleCrypto/importKey#supported_formats) for the key.
To export a key, it must have {{DOMxRef("CryptoKey.extractable")}} set to `true`.
But because `wrapKey()` also encrypts the key to be exported, you also need to pass in the key that must be used to encrypt it.
This is sometimes called the "wrapping key".
The inverse of `wrapKey()` is {{domxref("SubtleCrypto.unwrapKey()")}}: while `wrapKey` is composed of export + encrypt, `unwrapKey` is composed of import + decrypt.
## Syntax
```js-nolint
wrapKey(format, key, wrappingKey, wrapAlgo)
```
### Parameters
- `format`
- : A string describing the data format in which the key will be exported before it is encrypted. It can be one of the following:
- `raw`
- : [Raw](/en-US/docs/Web/API/SubtleCrypto/importKey#raw) format.
- `pkcs8`
- : [PKCS #8](/en-US/docs/Web/API/SubtleCrypto/importKey#pkcs_8) format.
- `spki`
- : [SubjectPublicKeyInfo](/en-US/docs/Web/API/SubtleCrypto/importKey#subjectpublickeyinfo) format.
- `jwk`
- : [JSON Web Key](/en-US/docs/Web/API/SubtleCrypto/importKey#json_web_key) format.
- `key`
- : The {{domxref("CryptoKey")}} to wrap.
- `wrappingkey`
- : The {{domxref("CryptoKey")}} used to encrypt the exported key. The key must have the `wrapKey` usage set.
- `wrapAlgo`
- : An object specifying the [algorithm](/en-US/docs/Web/API/SubtleCrypto/encrypt#supported_algorithms)
to be used to encrypt the exported key, and any required extra parameters:
- To use [RSA-OAEP](/en-US/docs/Web/API/SubtleCrypto/encrypt#rsa-oaep),
pass an [`RsaOaepParams`](/en-US/docs/Web/API/RsaOaepParams) object.
- To use [AES-CTR](/en-US/docs/Web/API/SubtleCrypto/encrypt#aes-ctr),
pass an [`AesCtrParams`](/en-US/docs/Web/API/AesCtrParams) object.
- To use [AES-CBC](/en-US/docs/Web/API/SubtleCrypto/encrypt#aes-cbc),
pass an [`AesCbcParams`](/en-US/docs/Web/API/AesCbcParams) object.
- To use [AES-GCM](/en-US/docs/Web/API/SubtleCrypto/encrypt#aes-gcm),
pass an [`AesGcmParams`](/en-US/docs/Web/API/AesGcmParams) object.
- To use [AES-KW](#aes-kw),
pass the string `"AES-KW"`, or an object of the form `{ name: "AES-KW" }`.
### Return value
A [`Promise`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) that fulfills with
an [`ArrayBuffer`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer)
containing the encrypted exported key.
### Exceptions
The promise is rejected when one of the following exceptions is encountered:
- `InvalidAccessError` {{domxref("DOMException")}}
- : Raised when the wrapping key is not a key for the requested wrap algorithm.
- `NotSupported` {{domxref("DOMException")}}
- : Raised when trying to use an algorithm that is either unknown or isn't suitable for
encryption or wrapping.
- {{jsxref("TypeError")}}
- : Raised when trying to use an invalid format.
## Supported algorithms
All [algorithms that are usable for encryption](/en-US/docs/Web/API/SubtleCrypto/encrypt#supported_algorithms) are also usable for key wrapping, as long as the key has the "wrapKey" usage set.
For key wrapping you have the additional option of [AES-KW](#aes-kw).
### AES-KW
AES-KW is a way to use the AES cipher for key wrapping.
One advantage of using AES-KW over another AES mode such as AES-GCM is that AES-KW does not require an initialization vector.
To use AES-KW, the input must be a multiple of 64 bits.
AES-KW is specified in [RFC 3394](https://datatracker.ietf.org/doc/html/rfc3394).
## Examples
> **Note:** You can [try the working examples](https://mdn.github.io/dom-examples/web-crypto/wrap-key/index.html) out on GitHub.
### Raw wrap
This example wraps an AES key.
It uses "raw" as the export format and AES-KW, with a password-derived key, to encrypt it. [See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/wrap-key/raw.js)
```js
let salt;
/*
Get some key material to use as input to the deriveKey method.
The key material is a password supplied by the user.
*/
function getKeyMaterial() {
const password = window.prompt("Enter your password");
const enc = new TextEncoder();
return window.crypto.subtle.importKey(
"raw",
enc.encode(password),
{ name: "PBKDF2" },
false,
["deriveBits", "deriveKey"],
);
}
/*
Given some key material and some random salt
derive an AES-KW key using PBKDF2.
*/
function getKey(keyMaterial, salt) {
return window.crypto.subtle.deriveKey(
{
name: "PBKDF2",
salt,
iterations: 100000,
hash: "SHA-256",
},
keyMaterial,
{ name: "AES-KW", length: 256 },
true,
["wrapKey", "unwrapKey"],
);
}
/*
Wrap the given key.
*/
async function wrapCryptoKey(keyToWrap) {
// get the key encryption key
const keyMaterial = await getKeyMaterial();
salt = window.crypto.getRandomValues(new Uint8Array(16));
const wrappingKey = await getKey(keyMaterial, salt);
return window.crypto.subtle.wrapKey("raw", keyToWrap, wrappingKey, "AES-KW");
}
/*
Generate an encrypt/decrypt secret key,
then wrap it.
*/
window.crypto.subtle
.generateKey(
{
name: "AES-GCM",
length: 256,
},
true,
["encrypt", "decrypt"],
)
.then((secretKey) => wrapCryptoKey(secretKey))
.then((wrappedKey) => console.log(wrappedKey));
```
### PKCS #8 wrap
This example wraps an RSA private signing key. It uses "pkcs8" as the export format and
AES-GCM, with a password-derived key, to encrypt it.
[See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/wrap-key/pkcs8.js)
```js
let salt;
let iv;
/*
Get some key material to use as input to the deriveKey method.
The key material is a password supplied by the user.
*/
function getKeyMaterial() {
const password = window.prompt("Enter your password");
const enc = new TextEncoder();
return window.crypto.subtle.importKey(
"raw",
enc.encode(password),
{ name: "PBKDF2" },
false,
["deriveBits", "deriveKey"],
);
}
/*
Given some key material and some random salt
derive an AES-GCM key using PBKDF2.
*/
function getKey(keyMaterial, salt) {
return window.crypto.subtle.deriveKey(
{
name: "PBKDF2",
salt,
iterations: 100000,
hash: "SHA-256",
},
keyMaterial,
{ name: "AES-GCM", length: 256 },
true,
["wrapKey", "unwrapKey"],
);
}
/*
Wrap the given key.
*/
async function wrapCryptoKey(keyToWrap) {
// get the key encryption key
const keyMaterial = await getKeyMaterial();
salt = window.crypto.getRandomValues(new Uint8Array(16));
const wrappingKey = await getKey(keyMaterial, salt);
iv = window.crypto.getRandomValues(new Uint8Array(12));
return window.crypto.subtle.wrapKey("pkcs8", keyToWrap, wrappingKey, {
name: "AES-GCM",
iv,
});
}
/*
Generate a sign/verify key pair,
then wrap the private key.
*/
window.crypto.subtle
.generateKey(
{
name: "RSA-PSS",
// Consider using a 4096-bit key for systems that require long-term security
modulusLength: 2048,
publicExponent: new Uint8Array([1, 0, 1]),
hash: "SHA-256",
},
true,
["sign", "verify"],
)
.then((keyPair) => wrapCryptoKey(keyPair.privateKey))
.then((wrappedKey) => {
console.log(wrappedKey);
});
```
### SubjectPublicKeyInfo wrap
This example wraps an RSA public encryption key. It uses "spki" as the export format and AES-CBC, with a password-derived key, to encrypt it.
[See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/wrap-key/spki.js)
```js
let salt;
let iv;
/*
Get some key material to use as input to the deriveKey method.
The key material is a password supplied by the user.
*/
function getKeyMaterial() {
const password = window.prompt("Enter your password");
const enc = new TextEncoder();
return window.crypto.subtle.importKey(
"raw",
enc.encode(password),
{ name: "PBKDF2" },
false,
["deriveBits", "deriveKey"],
);
}
/*
Given some key material and some random salt
derive an AES-CBC key using PBKDF2.
*/
function getKey(keyMaterial, salt) {
return window.crypto.subtle.deriveKey(
{
name: "PBKDF2",
salt,
iterations: 100000,
hash: "SHA-256",
},
keyMaterial,
{ name: "AES-CBC", length: 256 },
true,
["wrapKey", "unwrapKey"],
);
}
/*
Wrap the given key.
*/
async function wrapCryptoKey(keyToWrap) {
// get the key encryption key
const keyMaterial = await getKeyMaterial();
salt = window.crypto.getRandomValues(new Uint8Array(16));
const wrappingKey = await getKey(keyMaterial, salt);
iv = window.crypto.getRandomValues(new Uint8Array(16));
return window.crypto.subtle.wrapKey("spki", keyToWrap, wrappingKey, {
name: "AES-CBC",
iv,
});
}
/*
Generate an encrypt/decrypt key pair,
then wrap it.
*/
window.crypto.subtle
.generateKey(
{
name: "RSA-OAEP",
// Consider using a 4096-bit key for systems that require long-term security
modulusLength: 2048,
publicExponent: new Uint8Array([1, 0, 1]),
hash: "SHA-256",
},
true,
["encrypt", "decrypt"],
)
.then((keyPair) => wrapCryptoKey(keyPair.publicKey))
.then((wrappedKey) => console.log(wrappedKey));
```
### JSON Web Key wrap
This example wraps an ECDSA private signing key. It uses "jwk" as the export format and AES-GCM, with a password-derived key, to encrypt it.
[See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/wrap-key/jwk.js)
```js
let salt;
let iv;
/*
Get some key material to use as input to the deriveKey method.
The key material is a password supplied by the user.
*/
function getKeyMaterial() {
const password = window.prompt("Enter your password");
const enc = new TextEncoder();
return window.crypto.subtle.importKey(
"raw",
enc.encode(password),
{ name: "PBKDF2" },
false,
["deriveBits", "deriveKey"],
);
}
/*
Given some key material and some random salt
derive an AES-GCM key using PBKDF2.
*/
function getKey(keyMaterial, salt) {
return window.crypto.subtle.deriveKey(
{
name: "PBKDF2",
salt,
iterations: 100000,
hash: "SHA-256",
},
keyMaterial,
{ name: "AES-GCM", length: 256 },
true,
["wrapKey", "unwrapKey"],
);
}
/*
Wrap the given key.
*/
async function wrapCryptoKey(keyToWrap) {
// get the key encryption key
const keyMaterial = await getKeyMaterial();
salt = window.crypto.getRandomValues(new Uint8Array(16));
const wrappingKey = await getKey(keyMaterial, salt);
iv = window.crypto.getRandomValues(new Uint8Array(12));
return window.crypto.subtle.wrapKey("jwk", keyToWrap, wrappingKey, {
name: "AES-GCM",
iv,
});
}
/*
Generate a sign/verify key pair,
then wrap the private key
*/
window.crypto.subtle
.generateKey(
{
name: "ECDSA",
namedCurve: "P-384",
},
true,
["sign", "verify"],
)
.then((keyPair) => wrapCryptoKey(keyPair.privateKey))
.then((wrappedKey) => console.log(wrappedKey));
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [`SubtleCrypto.exportKey()`](/en-US/docs/Web/API/SubtleCrypto/exportKey)
- [PKCS #8 format](https://datatracker.ietf.org/doc/html/rfc5208).
- [SubjectPublicKeyInfo format](https://datatracker.ietf.org/doc/html/rfc5280#section-4.1).
- [JSON Web Key format](https://datatracker.ietf.org/doc/html/rfc7517).
- [AES-KW specification](https://datatracker.ietf.org/doc/html/rfc3394).
| 0 |
data/mdn-content/files/en-us/web/api/subtlecrypto | data/mdn-content/files/en-us/web/api/subtlecrypto/importkey/index.md | ---
title: "SubtleCrypto: importKey() method"
short-title: importKey()
slug: Web/API/SubtleCrypto/importKey
page-type: web-api-instance-method
browser-compat: api.SubtleCrypto.importKey
---
{{APIRef("Web Crypto API")}}{{SecureContext_header}}
The **`importKey()`** method of the {{domxref("SubtleCrypto")}}
interface imports a key: that is, it takes as input a key in an external, portable
format and gives you a {{domxref("CryptoKey")}} object that you can use in the [Web Crypto API](/en-US/docs/Web/API/Web_Crypto_API).
The function accepts several import formats: see [Supported formats](#supported_formats) for details.
## Syntax
```js-nolint
importKey(format, keyData, algorithm, extractable, keyUsages)
```
### Parameters
- `format`
- : A string describing the data format of the key to import. It can be one of the following:
- `raw`: [Raw](#raw) format.
- `pkcs8`: [PKCS #8](#pkcs_8) format.
- `spki`: [SubjectPublicKeyInfo](#subjectpublickeyinfo) format.
- `jwk`: [JSON Web Key](#json_web_key) format.
- `keyData`
- : An {{jsxref("ArrayBuffer")}}, a [TypedArray](/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray),
a {{jsxref("DataView")}}, or a `JSONWebKey` object containing the key in
the given format.
- `algorithm`
- : An object defining the type of key to import and providing extra algorithm-specific parameters.
- For [RSASSA-PKCS1-v1_5](/en-US/docs/Web/API/SubtleCrypto/sign#rsassa-pkcs1-v1_5), [RSA-PSS](/en-US/docs/Web/API/SubtleCrypto/sign#rsa-pss),
or [RSA-OAEP](/en-US/docs/Web/API/SubtleCrypto/encrypt#rsa-oaep):
Pass an [`RsaHashedImportParams`](/en-US/docs/Web/API/RsaHashedImportParams) object.
- For [ECDSA](/en-US/docs/Web/API/SubtleCrypto/sign#ecdsa) or [ECDH](/en-US/docs/Web/API/SubtleCrypto/deriveKey#ecdh):
Pass an [`EcKeyImportParams`](/en-US/docs/Web/API/EcKeyImportParams) object.
- For [HMAC](/en-US/docs/Web/API/SubtleCrypto/sign#hmac):
Pass an [`HmacImportParams`](/en-US/docs/Web/API/HmacImportParams) object.
- For [AES-CTR](/en-US/docs/Web/API/SubtleCrypto/encrypt#aes-ctr), [AES-CBC](/en-US/docs/Web/API/SubtleCrypto/encrypt#aes-cbc),
[AES-GCM](/en-US/docs/Web/API/SubtleCrypto/encrypt#aes-gcm), or [AES-KW](/en-US/docs/Web/API/SubtleCrypto/wrapKey#aes-kw):
Pass the string identifying the algorithm or an object of the form `{ "name": ALGORITHM }`, where `ALGORITHM` is the name of the algorithm.
- For [PBKDF2](/en-US/docs/Web/API/SubtleCrypto/deriveKey#pbkdf2): Pass the string `PBKDF2`.
- For [HKDF](/en-US/docs/Web/API/SubtleCrypto/deriveKey#hkdf): Pass the string `HKDF`.
- `extractable`
- : A boolean value indicating whether it will be possible to export the key
using {{domxref("SubtleCrypto.exportKey()")}} or {{domxref("SubtleCrypto.wrapKey()")}}.
- `keyUsages`
- : An {{jsxref("Array")}} indicating what can be done with the key. Possible array values are:
- `encrypt`: The key may be used to {{domxref("SubtleCrypto.encrypt()", "encrypt")}} messages.
- `decrypt`: The key may be used to {{domxref("SubtleCrypto.decrypt()", "decrypt")}} messages.
- `sign`: The key may be used to {{domxref("SubtleCrypto.sign()", "sign")}} messages.
- `verify`: The key may be used to {{domxref("SubtleCrypto.verify()", "verify")}} signatures.
- `deriveKey`: The key may be used in {{domxref("SubtleCrypto.deriveKey()", "deriving a new key")}}.
- `deriveBits`: The key may be used in {{domxref("SubtleCrypto.deriveBits()", "deriving bits")}}.
- `wrapKey`: The key may be used to {{domxref("SubtleCrypto.wrapKey()", "wrap a key")}}.
- `unwrapKey`: The key may be used to {{domxref("SubtleCrypto.unwrapKey()", "unwrap a key")}}.
### Return value
A [`Promise`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
that fulfills with the imported key as a {{domxref("CryptoKey")}} object.
### Exceptions
The promise is rejected when one of the following exceptions is encountered:
- `SyntaxError` {{domxref("DOMException")}}
- : Raised when `keyUsages` is empty but the unwrapped key is of
type `secret` or `private`.
- {{jsxref("TypeError")}}
- : Raised when trying to use an invalid format or if the `keyData`
is not suited for that format.
## Supported formats
This API supports four different key import/export formats: Raw, PKCS #8,
SubjectPublicKeyInfo, and JSON Web Key.
### Raw
You can use this format to import or export AES or HMAC secret keys, or Elliptic Curve
public keys.
In this format the key is supplied as an
[`ArrayBuffer`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer)
containing the raw bytes for the key.
### PKCS #8
You can use this format to import or export RSA or Elliptic Curve private keys.
The PKCS #8 format is defined in [RFC 5208](https://datatracker.ietf.org/doc/html/rfc5208),
using the [ASN.1 notation](https://en.wikipedia.org/wiki/ASN.1):
```plain
PrivateKeyInfo ::= SEQUENCE {
version Version,
privateKeyAlgorithm PrivateKeyAlgorithmIdentifier,
privateKey PrivateKey,
attributes [0] IMPLICIT Attributes OPTIONAL }
```
The `importKey()` method expects to receive this object as an
[`ArrayBuffer`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer)
containing the [DER-encoded](https://luca.ntop.org/Teaching/Appunti/asn1.html)
form of the `PrivateKeyInfo`. DER is a set of rules for encoding ASN.1
structures into a binary form.
You are most likely to encounter this object in [PEM format](https://en.wikipedia.org/wiki/Privacy-Enhanced_Mail). PEM format
is a way to encode binary data in ASCII. It consists of a header and a footer, and in
between, the [base64-encoded](/en-US/docs/Glossary/Base64)
binary data. A PEM-encoded `PrivateKeyInfo` looks like this:
```plain
-----BEGIN PRIVATE KEY-----
MIG2AgEAMBAGByqGSM49AgEGBSuBBAAiBIGeMIGbAgEBBDAU9BD0jxDfF5OV380z
9VIEUN2W5kJDZ3hbuaDenCxLiAMsoquKTfFaou71eLdN0TShZANiAARMUhCee/cp
xmjGc1roj0D0k6VlUqtA+JVCWigXcIAukOeTHCngZDKCrD4PkXDBvbciJdZKvO+l
ml2FIkoovZh/8yeTKmjUMb804g6OmjUc9vVojCRV0YdaSmYkkJMJbLg=
-----END PRIVATE KEY-----
```
To get this into a format you can give to `importKey()` you need to do two
things:
- base64-decode the part between header and footer, using
[`window.atob()`](/en-US/docs/Web/API/atob).
- convert the resulting string into an
[`ArrayBuffer`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer).
See the [Examples](#examples) section for more concrete guidance.
### SubjectPublicKeyInfo
You can use this format to import or export RSA or Elliptic Curve public keys.
`SubjectPublicKey` is defined in [RFC 5280, Section 4.1](https://datatracker.ietf.org/doc/html/rfc5280#section-4.1) using
the [ASN.1 notation](https://en.wikipedia.org/wiki/ASN.1):
```plain
SubjectPublicKeyInfo ::= SEQUENCE {
algorithm AlgorithmIdentifier,
subjectPublicKey BIT STRING }
```
Just like [PKCS #8](#pkcs_8), the `importKey()` method expects to
receive this object as an
[`ArrayBuffer`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer)
containing the [DER-encoded](https://luca.ntop.org/Teaching/Appunti/asn1.html)
form of the `SubjectPublicKeyInfo`.
Again, you are most likely to encounter this object in [PEM format](https://en.wikipedia.org/wiki/Privacy-Enhanced_Mail).
A PEM-encoded `SubjectPublicKeyInfo` looks like this:
```plain
-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA3j+HgSHUnc7F6XzvEbD0
r3M5JNy+/kabiJVu8IU1ERAl3Osi38VgiMzjDBDOrFxVzNNzl+SXAHwXIV5BHiXL
CQ6qhwYsDgH6OqgKIwiALra/wNH4UHxj1Or/iyAkjHRR/kGhUtjyVCjzvaQaDpJW
2G+syd1ui0B6kJov2CRUWiPwpff8hBfVWv8q9Yc2yD5hCnykVL0iAiyn+SDAk/rv
8dC5eIlzCI4efUCbyG4c9O88Qz7bS14DxSfaPTy8P/TWoihVVjLaDF743LgM/JLq
CDPUBUA3HLsZUhKm3BbSkd7Q9Ngkjv3+yByo4/fL+fkYRa8j9Ypa2N0Iw53LFb3B
gQIDAQAB
-----END PUBLIC KEY-----
```
Just as with [PKCS #8](#pkcs_8), to get this into a format you can give to
`importKey()` you need to do two things:
- base64-decode the part between header and footer, using
[`window.atob()`](/en-US/docs/Web/API/atob).
- convert the resulting string into an
[`ArrayBuffer`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer).
See the [Examples](#examples) section for more concrete guidance.
### JSON Web Key
You can use JSON Web Key format to import or export RSA or Elliptic Curve public or
private keys, as well as AES and HMAC secret keys.
JSON Web Key format is defined in [RFC 7517](https://datatracker.ietf.org/doc/html/rfc7517).
It describes a way to represent public, private, and secret keys as JSON objects.
A JSON Web Key looks something like this (this is an EC private key):
```json
{
"crv": "P-384",
"d": "wouCtU7Nw4E8_7n5C1-xBjB4xqSb_liZhYMsy8MGgxUny6Q8NCoH9xSiviwLFfK_",
"ext": true,
"key_ops": ["sign"],
"kty": "EC",
"x": "SzrRXmyI8VWFJg1dPUNbFcc9jZvjZEfH7ulKI1UkXAltd7RGWrcfFxqyGPcwu6AQ",
"y": "hHUag3OvDzEr0uUQND4PXHQTXP5IDGdYhJhL-WLKjnGjQAw0rNGy5V29-aV-yseW"
};
```
## Examples
> **Note:** You can [try the working examples](https://mdn.github.io/dom-examples/web-crypto/import-key/index.html) on GitHub.
### Raw import
This example imports an AES key from an `ArrayBuffer` containing the raw bytes
to use. [See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/import-key/raw.js)
```js
const rawKey = window.crypto.getRandomValues(new Uint8Array(16));
/*
Import an AES secret key from an ArrayBuffer containing the raw bytes.
Takes an ArrayBuffer string containing the bytes, and returns a Promise
that will resolve to a CryptoKey representing the secret key.
*/
function importSecretKey(rawKey) {
return window.crypto.subtle.importKey("raw", rawKey, "AES-GCM", true, [
"encrypt",
"decrypt",
]);
}
```
### PKCS #8 import
This example imports an RSA private signing key from a PEM-encoded PKCS #8 object.
[See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/import-key/pkcs8.js)
```js
/*
Convert a string into an ArrayBuffer
from https://developers.google.com/web/updates/2012/06/How-to-convert-ArrayBuffer-to-and-from-String
*/
function str2ab(str) {
const buf = new ArrayBuffer(str.length);
const bufView = new Uint8Array(buf);
for (let i = 0, strLen = str.length; i < strLen; i++) {
bufView[i] = str.charCodeAt(i);
}
return buf;
}
const pemEncodedKey = `-----BEGIN PRIVATE KEY-----
MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDD0tPV/du2vftjvXj1t/gXTK39sNBVrOAEb/jKzXae+Xa0H+3LhZaQIQNMfACiBSgIfZUvEGb+7TqXWQpoLoFR/R7MvGWcSk98JyrVtveD8ZmZYyItSY7m2hcasqAFiKyOouV5vzyRe87/lEyzzBpF3bQQ4IDaQu+K9Hj5fKuU6rrOeOhsdnJc+VdDQLScHxvMoLZ9Vtt+oK9J4/tOLwr4CG8khDlBURcBY6gPcLo3dPU09SW+6ctX2cX4mkXx6O/0mmdTmacr/vu50KdRMleFeZYOWPAEhhMfywybTuzBiPVIZVP8WFCSKNMbfi1S9A9PdBqnebwwHhX3/hsEBt2BAgMBAAECggEABEI1P6nf6Zs7mJlyBDv+Pfl5rjL2cOqLy6TovvZVblMkCPpJyFuNIPDK2tK2i897ZaXfhPDBIKmllM2Hq6jZQKB110OAnTPDg0JxzMiIHPs32S1d/KilHjGff4Hjd4NXp1l1Dp8BUPOllorR2TYm2x6dcCGFw9lhTr8O03Qp4hjn84VjGIWADYCk83mgS4nRsnHkdiqYnWx1AjKlY51yEK6RcrDMi0Th2RXrrINoC35sVv+APt2rkoMGi52RwTEseA1KZGFrxjq61ReJif6p2VXEcvHeX6CWLx014LGk43z6Q28P6HgeEVEfIjyqCUea5Du/mYb/QsRSCosXLxBqwQKBgQD1+fdC9ZiMrVI+km7Nx2CKBn8rJrDmUh5SbXn2MYJdrUd8bYNnZkCgKMgxVXsvJrbmVOrby2txOiqudZkk5mD3E5O/QZWPWQLgRu8ueYNpobAX9NRgNfZ7rZD+81vh5MfZiXfuZOuzv29iZhU0oqyZ9y75eHkLdrerNkwYOe5aUQKBgQDLzapDi1NxkBgsj9iiO4KUa7jvD4JjRqFy4Zhj/jbQvlvM0F/uFp7sxVcHGx4r11C+6iCbhX4u+Zuu0HGjT4d+hNXmgGyxR8fIUVxOlOtDkVJa5sOBZK73/9/MBeKusdmJPRhalZQfMUJRWIoEVDMhfg3tW/rBj5RYAtP2dTVUMQKBgDs8yr52dRmT+BWXoFWwaWB0NhYHSFz/c8v4D4Ip5DJ5M5kUqquxJWksySGQa40sbqnD05fBQovPLU48hfgr/zghn9hUjBcsoZOvoZR4sRw0UztBvA+7jzOz1hKAOyWIulR6Vca0yUrNlJ6G5R56+sRNkiOETupi2dLCzcqb0PoxAoGAZyNHvTLvIZN4iGSrjz5qkM4LIwBIThFadxbv1fq6pt0O/BGf2o+cEdq0diYlGK64cEVwBwSBnSg4vzlBqRIAUejLjwEDAJyA4EE8Y5A9l04dzV7nJb5cRak6CrgXxay/mBJRFtaHxVlaZGxYPGSYE6UFS0+3EOmmevvDZQBf4qECgYEA0ZF6Vavz28+8wLO6SP3w8NmpHk7K9tGEvUfQ30SgDx4G7qPIgfPrbB4OP/E0qCfsIImi3sCPpjvUMQdVVZyPOIMuB+rV3ZOxkrzxEUOrpOpR48FZbL7RN90yRQsAsrp9e4iv8QwB3VxLe7X0TDqqnRyqrc/osGzuS2ZcHOKmCU8=
-----END PRIVATE KEY-----`;
/*
Import a PEM encoded RSA private key, to use for RSA-PSS signing.
Takes a string containing the PEM encoded key, and returns a Promise
that will resolve to a CryptoKey representing the private key.
*/
function importPrivateKey(pem) {
// fetch the part of the PEM string between header and footer
const pemHeader = "-----BEGIN PRIVATE KEY-----";
const pemFooter = "-----END PRIVATE KEY-----";
const pemContents = pem.substring(
pemHeader.length,
pem.length - pemFooter.length - 1,
);
// base64 decode the string to get the binary data
const binaryDerString = window.atob(pemContents);
// convert from a binary string to an ArrayBuffer
const binaryDer = str2ab(binaryDerString);
return window.crypto.subtle.importKey(
"pkcs8",
binaryDer,
{
name: "RSA-PSS",
hash: "SHA-256",
},
true,
["sign"],
);
}
```
### SubjectPublicKeyInfo import
This example imports an RSA public encryption key from a PEM-encoded
SubjectPublicKeyInfo object. [See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/import-key/spki.js)
```js
// from https://developers.google.com/web/updates/2012/06/How-to-convert-ArrayBuffer-to-and-from-String
function str2ab(str) {
const buf = new ArrayBuffer(str.length);
const bufView = new Uint8Array(buf);
for (let i = 0, strLen = str.length; i < strLen; i++) {
bufView[i] = str.charCodeAt(i);
}
return buf;
}
const pemEncodedKey = `-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAy3Xo3U13dc+xojwQYWoJLCbOQ5fOVY8LlnqcJm1W1BFtxIhOAJWohiHuIRMctv7dzx47TLlmARSKvTRjd0dF92jx/xY20Lz+DXp8YL5yUWAFgA3XkO3LSJgEOex10NB8jfkmgSb7QIudTVvbbUDfd5fwIBmCtaCwWx7NyeWWDb7A9cFxj7EjRdrDaK3ux/ToMLHFXVLqSL341TkCf4ZQoz96RFPUGPPLOfvN0x66CM1PQCkdhzjE6U5XGE964ZkkYUPPsy6Dcie4obhW4vDjgUmLzv0z7UD010RLIneUgDE2FqBfY/C+uWigNPBPkkQ+Bv/UigS6dHqTCVeD5wgyBQIDAQAB
-----END PUBLIC KEY-----`;
function importRsaKey(pem) {
// fetch the part of the PEM string between header and footer
const pemHeader = "-----BEGIN PUBLIC KEY-----";
const pemFooter = "-----END PUBLIC KEY-----";
const pemContents = pem.substring(
pemHeader.length,
pem.length - pemFooter.length - 1,
);
// base64 decode the string to get the binary data
const binaryDerString = window.atob(pemContents);
// convert from a binary string to an ArrayBuffer
const binaryDer = str2ab(binaryDerString);
return window.crypto.subtle.importKey(
"spki",
binaryDer,
{
name: "RSA-OAEP",
hash: "SHA-256",
},
true,
["encrypt"],
);
}
```
### JSON Web Key import
This code imports an ECDSA private signing key, given a JSON Web Key object that
represents it. [See the complete code on GitHub.](https://github.com/mdn/dom-examples/blob/main/web-crypto/import-key/jwk.js)
```js
const jwkEcKey = {
crv: "P-384",
d: "wouCtU7Nw4E8_7n5C1-xBjB4xqSb_liZhYMsy8MGgxUny6Q8NCoH9xSiviwLFfK_",
ext: true,
key_ops: ["sign"],
kty: "EC",
x: "SzrRXmyI8VWFJg1dPUNbFcc9jZvjZEfH7ulKI1UkXAltd7RGWrcfFxqyGPcwu6AQ",
y: "hHUag3OvDzEr0uUQND4PXHQTXP5IDGdYhJhL-WLKjnGjQAw0rNGy5V29-aV-yseW",
};
/*
Import a JSON Web Key format EC private key, to use for ECDSA signing.
Takes an object representing the JSON Web Key, and returns a Promise
that will resolve to a CryptoKey representing the private key.
*/
function importPrivateKey(jwk) {
return window.crypto.subtle.importKey(
"jwk",
jwk,
{
name: "ECDSA",
namedCurve: "P-384",
},
true,
["sign"],
);
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [`SubtleCrypto.exportKey()`](/en-US/docs/Web/API/SubtleCrypto/exportKey)
- [PKCS #8 format](https://datatracker.ietf.org/doc/html/rfc5208).
- [SubjectPublicKeyInfo format](https://datatracker.ietf.org/doc/html/rfc5280#section-4.1).
- [JSON Web Key format](https://datatracker.ietf.org/doc/html/rfc7517).
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/cssstylevalue/index.md | ---
title: CSSStyleValue
slug: Web/API/CSSStyleValue
page-type: web-api-interface
browser-compat: api.CSSStyleValue
---
{{APIRef("CSS Typed Object Model API")}}
The **`CSSStyleValue`** interface of the [CSS Typed Object Model API](/en-US/docs/Web/API/CSS_Object_Model#css_typed_object_model) is the base class of all CSS values accessible through the Typed OM API. An instance of this class may be used anywhere a string is expected.
## Interfaces based on CSSStyleValue
Below is a list of interfaces based on the `CSSStyleValue` interface.
- {{domxref('CSSImageValue')}}
- {{domxref('CSSKeywordValue')}}
- {{domxref('CSSNumericValue')}}
- {{domxref('CSSPositionValue')}}
- {{domxref('CSSTransformValue')}}
- {{domxref('CSSUnparsedValue')}}
## Static methods
- [`CSSStyleValue.parse()`](/en-US/docs/Web/API/CSSStyleValue/parse_static)
- : Sets a specific CSS property to the specified values and returns the first value as a {{domxref('CSSStyleValue')}} object.
- [`CSSStyleValue.parseAll()`](/en-US/docs/Web/API/CSSStyleValue/parseAll_static)
- : Sets all occurrences of a specific CSS property to the specified value and returns an array of {{domxref('CSSStyleValue')}} objects, each containing one of the supplied values.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
| 0 |
data/mdn-content/files/en-us/web/api/cssstylevalue | data/mdn-content/files/en-us/web/api/cssstylevalue/parse_static/index.md | ---
title: "CSSStyleValue: parse() static method"
short-title: parse()
slug: Web/API/CSSStyleValue/parse_static
page-type: web-api-static-method
browser-compat: api.CSSStyleValue.parse_static
---
{{APIRef("CSS Typed Object Model API")}}
The **`parse()`** static method of the {{domxref("CSSStyleValue")}}
interface sets a specific CSS property to the specified values and returns the first
value as a {{domxref('CSSStyleValue')}} object.
## Syntax
```js-nolint
CSSStyleValue.parse(property, cssText)
```
### Parameters
- `property`
- : A CSS property to set.
- `cssText`
- : A comma-separated string containing one or more values to apply to the provided
property.
### Return value
A `CSSStyleValue` object containing the first supplied value.
## Examples
The code below parses a set of declarations for the `transform` property.
The second code block shows the structure of the returned object as it would be rendered
in a developer tools console.
```js
const css = CSSStyleValue.parse(
"transform",
"translate3d(10px,10px,0) scale(0.5)",
);
```
```css
CSSTransformValue {0: CSSTranslate, 1: CSSScale, length: 2, is2D: false}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [`CSSStyleValue.parseAll()`](/en-US/docs/Web/API/CSSStyleValue/parseAll_static)
- [Using the CSS Typed OM](/en-US/docs/Web/API/CSS_Typed_OM_API/Guide)
- [CSS Typed Object Model API](/en-US/docs/Web/API/CSS_Typed_OM_API)
| 0 |
data/mdn-content/files/en-us/web/api/cssstylevalue | data/mdn-content/files/en-us/web/api/cssstylevalue/parseall_static/index.md | ---
title: "CSSStyleValue: parseAll() static method"
short-title: parseAll()
slug: Web/API/CSSStyleValue/parseAll_static
page-type: web-api-static-method
browser-compat: api.CSSStyleValue.parseAll_static
---
{{APIRef("CSS Typed Object Model API")}}
The **`parseAll()`** static method of the {{domxref("CSSStyleValue")}}
interface sets all occurrences of a specific CSS property to the specified value and
returns an array of {{domxref('CSSStyleValue')}} objects, each containing one of the
supplied values.
## Syntax
```js-nolint
CSSStyleValue.parseAll(property, value)
```
### Parameters
- `property`
- : A CSS property to set.
- `value`
- : A comma-separated string containing one or more values that apply to the provided
property.
### Return value
An array of `CSSStyleValue` objects, each containing one of the supplied
values.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [`CSSStyleValue.parse()`](/en-US/docs/Web/API/CSSStyleValue/parse_static)
- [Using the CSS Typed OM](/en-US/docs/Web/API/CSS_Typed_OM_API/Guide)
- [CSS Typed Object Model API](/en-US/docs/Web/API/CSS_Typed_OM_API)
| 0 |
data/mdn-content/files/en-us/web/api | data/mdn-content/files/en-us/web/api/mediatracksettings/index.md | ---
title: MediaTrackSettings
slug: Web/API/MediaTrackSettings
page-type: web-api-interface
browser-compat: api.MediaTrackSettings
---
{{APIRef("Media Capture and Streams")}}
The **`MediaTrackSettings`** dictionary is used to return the current values configured for each of a {{domxref("MediaStreamTrack")}}'s settings. These values will adhere as closely as possible to any constraints previously described using a {{domxref("MediaTrackConstraints")}} object and set using {{domxref("MediaStreamTrack.applyConstraints", "applyConstraints()")}}, and will adhere to the default constraints for any properties whose constraints haven't been changed, or whose customized constraints couldn't be matched.
To learn more about how constraints and settings work, see [Capabilities, constraints, and settings](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints).
## Instance properties
Some or all of the following will be included in the object, either because it's not supported by the browser or because it's not available due to context. For example, because {{Glossary("RTP")}} doesn't provide some of these values during negotiation of a WebRTC connection, a track associated with a {{domxref("RTCPeerConnection")}} will not include certain values, such as {{domxref("MediaTrackSettings.facingMode", "facingMode")}} or {{domxref("MediaTrackSettings.groupId", "groupId")}}.
### Instance properties of all media tracks
- {{domxref("MediaTrackSettings.deviceId", "deviceId")}}
- : A string indicating the current value of the {{domxref("MediaTrackConstraints.deviceId", "deviceId")}} property. The device ID is an origin-unique string identifying the source of the track; this is usually a [GUID](https://en.wikipedia.org/wiki/Universally_unique_identifier). This value is specific to the source of the track's data and is not usable for setting constraints; it can, however, be used for initially selecting media when calling {{domxref("MediaDevices.getUserMedia()")}}.
- {{domxref("MediaTrackSettings.groupId", "groupId")}}
- : A string indicating the current value of the {{domxref("MediaTrackConstraints.groupId", "groupId")}} property. The group ID is a browsing session-unique string identifying the source group of the track. Two devices (as identified by the {{domxref("MediaTrackSettings.deviceId", "deviceId")}}) are considered part of the same group if they are from the same physical device. For instance, the audio input and output devices for the speaker and microphone built into a phone would share the same group ID, since they're part of the same physical device. The microphone on a headset would have a different ID, though. This value is specific to the source of the track's data and is not usable for setting constraints; it can, however, be used for initially selecting media when calling {{domxref("MediaDevices.getUserMedia()")}}.
### Instance properties of audio tracks
- {{domxref("MediaTrackSettings.autoGainControl", "autoGainControl")}}
- : A Boolean which indicates the current value of the {{domxref("MediaTrackConstraints.autoGainControl", "autoGainControl")}} property, which is `true` if automatic gain control is enabled and is `false` otherwise.
- {{domxref("MediaTrackSettings.channelCount", "channelCount")}}
- : A long integer value indicating the current value of the {{domxref("MediaTrackConstraints.channelCount", "channelCount")}} property, specifying the number of audio channels present on the track (therefore indicating how many audio samples exist in each audio frame). This is 1 for mono, 2 for stereo, and so forth.
- {{domxref("MediaTrackSettings.echoCancellation", "echoCancellation")}}
- : A Boolean indicating the current value of the {{domxref("MediaTrackConstraints.echoCancellation", "echoCancellation")}} property, specifying `true` if echo cancellation is enabled, otherwise `false`.
- {{domxref("MediaTrackSettings.latency", "latency")}}
- : A double-precision floating point value indicating the current value of the {{domxref("MediaTrackConstraints.latency", "latency")}} property, specifying the audio latency, in seconds. Latency is the amount of time which elapses between the start of processing the audio and the data being available to the next stop in the audio utilization process. This value is a target value; actual latency may vary to some extent for various reasons.
- {{domxref("MediaTrackSettings.noiseSuppression", "noiseSuppression")}}
- : A Boolean which indicates the current value of the {{domxref("MediaTrackConstraints.noiseSuppression", "noiseSuppression")}} property, which is `true` if noise suppression is enabled and is `false` otherwise.
- {{domxref("MediaTrackSettings.sampleRate", "sampleRate")}}
- : A long integer value indicating the current value of the {{domxref("MediaTrackConstraints.sampleRate", "sampleRate")}} property, specifying the sample rate in samples per second of the audio data. Standard CD-quality audio, for example, has a sample rate of 41,000 samples per second.
- {{domxref("MediaTrackSettings.sampleSize", "sampleSize")}}
- : A long integer value indicating the current value of the {{domxref("MediaTrackConstraints.sampleSize", "sampleSize")}} property, specifying the linear size, in bits, of each audio sample. CD-quality audio, for example, is 16-bit, so this value would be 16 in that case.
- {{domxref("MediaTrackSettings.volume", "volume")}} {{Deprecated_Inline}} {{Non-standard_Inline}}
- : A double-precision floating point value indicating the current value of the {{domxref("MediaTrackConstraints.volume", "volume")}} property, specifying the volume level of the track. This value will be between 0.0 (silent) to 1.0 (maximum supported volume).
### Instance properties of video tracks
- {{domxref("MediaTrackSettings.aspectRatio", "aspectRatio")}}
- : A double-precision floating point value indicating the current value of the {{domxref("MediaTrackConstraints.aspectRatio", "aspectRatio")}} property, specified precisely to 10 decimal places. This is the width of the image in pixels divided by its height in pixels. Common values include 1.3333333333 (for the classic television 4:3 "standard" aspect ratio, also used on tablets such as Apple's iPad), 1.7777777778 (for the 16:9 high-definition widescreen aspect ratio), and 1.6 (for the 16:10 aspect ratio common among widescreen computers and tablets).
- {{domxref("MediaTrackSettings.facingMode", "facingMode")}}
- : A string indicating the current value of the {{domxref("MediaTrackConstraints.facingMode", "facingMode")}} property, specifying the direction the camera is facing. The value will be one of:
- `"user"`
- : A camera facing the user (commonly known as a "selfie cam"), used for self-portraiture and video calling.
- `"environment"`
- : A camera facing away from the user (when the user is looking at the screen). This is typically the highest quality camera on the device, used for general photography.
- `"left"`
- : A camera facing toward the environment to the user's left.
- `"right"`
- : A camera facing toward the environment to the user's right.
- {{domxref("MediaTrackSettings.frameRate", "frameRate")}}
- : A double-precision floating point value indicating the current value of the {{domxref("MediaTrackConstraints.frameRate", "frameRate")}} property, specifying how many frames of video per second the track includes. If the value can't be determined for any reason, the value will match the vertical sync rate of the device the user agent is running on.
- {{domxref("MediaTrackSettings.height", "height")}}
- : A long integer value indicating the current value of the {{domxref("MediaTrackConstraints.height", "height")}} property, specifying the height of the track's video data in pixels.
- {{domxref("MediaTrackSettings.width", "width")}}
- : A long integer value indicating the current value of the {{domxref("MediaTrackSettings.width", "width")}} property, specifying the width of the track's video data in pixels.
- {{domxref("MediaTrackSettings.resizeMode", "resizeMode")}}
- : A string indicating the current value of the {{domxref("MediaTrackConstraints.resizeMode", "resizeMode")}} property, specifying the mode used by the user agent to derive the resolution of the track. The value will be one of:
- `"none"`
- : The track has the resolution offered by the camera, its driver or the OS.
- `"crop-and-scale"`
- : The track's resolution might be the result of the user agent using cropping or downscaling from a higher camera resolution.
### Instance properties of shared screen tracks
Tracks containing video shared from a user's screen (regardless of whether the screen data comes from the entire screen or a portion of a screen, like a window or tab) are generally treated like video tracks, with the exception that they also support the following added settings:
- {{domxref("MediaTrackSettings.cursor", "cursor")}}
- : A string which indicates whether or not the mouse cursor is being included in the generated stream and under what conditions. Possible values are:
- `always`
- : The mouse is always visible in the video content of the {domxref("MediaStream"), unless the mouse has moved outside the area of the content.
- `motion`
- : The mouse cursor is always included in the video if it's moving, and for a short time after it stops moving.
- `never`
- : The mouse cursor is never included in the shared video.
- {{domxref("MediaTrackSettings.displaySurface", "displaySurface")}}
- : A string which specifies the type of source the track contains; one of:
- `application`
- : The stream contains all of the windows of the application chosen by the user rendered into the one video track.
- `browser`
- : The stream contains the contents of a single browser tab selected by the user.
- `monitor`
- : The stream's video track contains the entire contents of one or more of the user's screens.
- `window`
- : The stream contains a single window selected by the user for sharing.
- {{domxref("MediaTrackSettings.logicalSurface", "logicalSurface")}}
- : A Boolean value which, if `true`, indicates that the video contained in the stream's video track contains a background rendering context, rather than a user-visible one. This is `false` if the video being captured is coming from a foreground (user-visible) source.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- {{domxref("MediaDevices.getUserMedia()")}}
- {{domxref("MediaDevices.getDisplayMedia()")}}
- {{domxref("MediaStreamTrack.getConstraints()")}}
- {{domxref("MediaStreamTrack.applyConstraints()")}}
- {{domxref("MediaStreamTrack.getSettings()")}}
| 0 |
data/mdn-content/files/en-us/web/api/mediatracksettings | data/mdn-content/files/en-us/web/api/mediatracksettings/noisesuppression/index.md | ---
title: "MediaTrackSettings: noiseSuppression property"
short-title: noiseSuppression
slug: Web/API/MediaTrackSettings/noiseSuppression
page-type: web-api-instance-property
browser-compat: api.MediaTrackSettings.noiseSuppression
---
{{APIRef("Media Capture and Streams")}}
The {{domxref("MediaTrackSettings")}} dictionary's
**`noiseSuppression`** property is a Boolean value whose value
indicates whether or not noise suppression technology is enabled on an audio track. This
lets you determine what value was selected to comply with your specified constraints for
this property's value as described in the
{{domxref("MediaTrackConstraints.noiseSuppression")}} property you provided when calling
either {{domxref("MediaDevices.getUserMedia", "getUserMedia()")}} or
{{domxref("MediaStreamTrack.applyConstraints()")}}.
Noise suppression automatically filters the audio to remove background noise, hum
caused by equipment, and the like from the sound before delivering it to your code. This
feature is typically used on microphones, although it is technically possible it could
be provided by other input sources as well.
If needed, you can determine whether or not this constraint is supported by checking
the value of {{domxref("MediaTrackSupportedConstraints.noiseSuppression")}} as returned
by a call to {{domxref("MediaDevices.getSupportedConstraints()")}}. However, typically
this is unnecessary since browsers will ignore any constraints they're unfamiliar with.
## Value
A Boolean value which is `true` if the input track has noise suppression
enabled or `false` if AGC is disabled.
## Examples
See the [Constraint exerciser](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints#example_constraint_exerciser) example.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Media Capture and Streams API](/en-US/docs/Web/API/Media_Capture_and_Streams_API)
- [Capabilities, constraints, and settings](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints)
- {{domxref("MediaTrackConstraints.noiseSuppression")}}
- {{domxref("MediaTrackSupportedConstraints")}}
| 0 |
data/mdn-content/files/en-us/web/api/mediatracksettings | data/mdn-content/files/en-us/web/api/mediatracksettings/samplesize/index.md | ---
title: "MediaTrackSettings: sampleSize property"
short-title: sampleSize
slug: Web/API/MediaTrackSettings/sampleSize
page-type: web-api-instance-property
browser-compat: api.MediaTrackSettings.sampleSize
---
{{APIRef("Media Capture and Streams")}}
The {{domxref("MediaTrackSettings")}} dictionary's
**`sampleSize`** property is an integer indicating the linear
sample size (in bits per sample) the {{domxref("MediaStreamTrack")}} is currently
configured for. This lets you determine what value was selected to comply with your
specified constraints for this property's value as described in the
{{domxref("MediaTrackConstraints.sampleSize")}} property you provided when calling
either {{domxref("MediaDevices.getUserMedia", "getUserMedia()")}} or
{{domxref("MediaStreamTrack.applyConstraints()")}}.
If needed, you can determine whether or not this constraint is supported by checking
the value of {{domxref("MediaTrackSupportedConstraints.sampleSize")}} as returned by a
call to {{domxref("MediaDevices.getSupportedConstraints()")}}. However, typically this
is unnecessary since browsers will ignore any constraints they're unfamiliar with.
## Value
An integer value indicating how many bits each audio sample is represented by. The most
commonly used sample size for many years now is 16 bits per sample, which was used for
CD audio among others. Other common sample sizes are 8 (for reduced bandwidth
requirements) and 24 (for high-resolution professional audio).
Each audio channel on the track requires sampleSize bits.
That means that a given sample actually uses (`sampleSize`/8)\*{{domxref("MediaTrackSettings.channelCount","channelCount")}} bytes of data.
For example, 16-bit stereo audio requires (16/8)\*2 or 4 bytes per sample.
## Examples
See the [Constraint exerciser](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints#example_constraint_exerciser) example.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Media Capture and Streams API](/en-US/docs/Web/API/Media_Capture_and_Streams_API)
- [Capabilities, constraints, and settings](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints)
- {{domxref("MediaTrackConstraints.sampleSize")}}
- {{domxref("MediaTrackSettings")}}
| 0 |
data/mdn-content/files/en-us/web/api/mediatracksettings | data/mdn-content/files/en-us/web/api/mediatracksettings/echocancellation/index.md | ---
title: "MediaTrackSettings: echoCancellation property"
short-title: echoCancellation
slug: Web/API/MediaTrackSettings/echoCancellation
page-type: web-api-instance-property
browser-compat: api.MediaTrackSettings.echoCancellation
---
{{APIRef("Media Capture and Streams")}}
The {{domxref("MediaTrackSettings")}} dictionary's
**`echoCancellation`** property is a Boolean value whose value
indicates whether or not echo cancellation is enabled on an audio track. This lets you
determine what value was selected to comply with your specified constraints for this
property's value as described in the
{{domxref("MediaTrackConstraints.echoCancellation")}} property you provided when calling
either {{domxref("MediaDevices.getUserMedia", "getUserMedia()")}} or
{{domxref("MediaStreamTrack.applyConstraints()")}}.
Echo cancellation is a feature which attempts to prevent echo effects on a two-way
audio connection by attempting to reduce or eliminate crosstalk between the user's
output device and their input device. For example, it might apply a filter that negates
the sound being produced on the speakers from being included in the input track
generated from the microphone.
If needed, you can determine whether or not this constraint is supported by checking
the value of {{domxref("MediaTrackSupportedConstraints.echoCancellation")}} as returned
by a call to {{domxref("MediaDevices.getSupportedConstraints()")}}. However, typically
this is unnecessary since browsers will ignore any constraints they're unfamiliar with.
Because {{Glossary("RTP")}} doesn't include this information, tracks associated with a
[WebRTC](/en-US/docs/Web/API/WebRTC_API) {{domxref("RTCPeerConnection")}}
will never include this property.
## Value
A Boolean value which is `true` if the track has echo cancellation
functionality enabled or `false` if echo cancellation is disabled.
## Examples
See the [Constraint exerciser](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints#example_constraint_exerciser) example.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Media Capture and Streams API](/en-US/docs/Web/API/Media_Capture_and_Streams_API)
- [Capabilities, constraints, and settings](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints)
- {{domxref("MediaTrackConstraints.echoCancellation")}}
- {{domxref("MediaTrackSettings")}}
| 0 |
data/mdn-content/files/en-us/web/api/mediatracksettings | data/mdn-content/files/en-us/web/api/mediatracksettings/volume/index.md | ---
title: "MediaTrackSettings: volume property"
short-title: volume
slug: Web/API/MediaTrackSettings/volume
page-type: web-api-instance-property
status:
- deprecated
- non-standard
browser-compat: api.MediaTrackSettings.volume
---
{{APIRef("Media Capture and Streams")}}{{Deprecated_Header}}{{Non-standard_Header}}
The {{domxref("MediaTrackSettings")}} dictionary's **`volume`**
property is a double-precision floating-point number indicating the volume of the
{{domxref("MediaStreamTrack")}} as currently configured, as a value from 0.0 (silence)
to 1.0 (maximum supported volume for the device). This lets you determine what value was
selected to comply with your specified constraints for this property's value as
described in the {{domxref("MediaTrackConstraints.volume")}} property you provided when
calling either {{domxref("MediaDevices.getUserMedia", "getUserMedia()")}} or
{{domxref("MediaStreamTrack.applyConstraints()")}}.
If needed, you can determine whether or not this constraint is supported by checking
the value of {{domxref("MediaTrackSupportedConstraints.volume")}} as returned by a call
to {{domxref("MediaDevices.getSupportedConstraints()")}}. However, typically this is
unnecessary since browsers will ignore any constraints they're unfamiliar with.
## Value
A double-precision floating-point number indicating the volume, from 0.0 to 1.0, of the
audio track as currently configured.
## Examples
See the [Constraint exerciser](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints#example_constraint_exerciser) example.
## Browser compatibility
{{Compat}}
## See also
- [Media Capture and Streams API](/en-US/docs/Web/API/Media_Capture_and_Streams_API)
- [Capabilities, constraints, and settings](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints)
- {{domxref("MediaTrackConstraints.volume")}}
- {{domxref("MediaTrackSettings")}}
| 0 |
data/mdn-content/files/en-us/web/api/mediatracksettings | data/mdn-content/files/en-us/web/api/mediatracksettings/logicalsurface/index.md | ---
title: "MediaTrackSettings: logicalSurface property"
short-title: logicalSurface
slug: Web/API/MediaTrackSettings/logicalSurface
page-type: web-api-instance-property
browser-compat: api.MediaTrackSettings.logicalSurface
---
{{APIRef("Media Capture and Streams")}}
The {{domxref("MediaTrackSettings")}} dictionary's
**`logicalSurface`** property indicates whether or not the
display area being captured is a logical surface. Logical surfaces are those which are
not necessarily entirely onscreen, or may even be off-screen, such as windows' backing
buffers (where only part of the buffer is visible without scrolling the containing
window) and offscreen rendering contexts.
## Value
A Boolean value which is `true` if the video track in the stream of captured
video is taken from a logical display surface.
The most common scenario in which a display surface may be a logical one is if the
selected surface contains the entire content area of a window which is too large to
display onscreen at once. Since the window that contains the surface has to be scrolled
to show the rest of the contents, the surface is a logical one.
A visible display surface (that is, a surface for which `logicalSurface`
returns `false`) is the portion of a logical display surface which is
currently visible onscreen.
For example, a user agent _may_ choose to allow the user to choose whether to
share the entire document (a `browser` with `logicalSurface` value
of `true`), or just the currently visible portion of the document (where the
`logicalSurface` of the `browser` surface is `false`).
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Screen Capture API](/en-US/docs/Web/API/Screen_Capture_API)
- [Using the screen capture API](/en-US/docs/Web/API/Screen_Capture_API/Using_Screen_Capture)
- [Capabilities, constraints, and settings](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints)
- {{domxref("MediaDevices.getDisplayMedia()")}}
- {{domxref("MediaStreamTrack.getConstraints()")}}
- {{domxref("MediaStreamTrack.applyConstraints()")}}
- {{domxref("MediaStreamTrack.getSettings()")}}
| 0 |
data/mdn-content/files/en-us/web/api/mediatracksettings | data/mdn-content/files/en-us/web/api/mediatracksettings/framerate/index.md | ---
title: "MediaTrackSettings: frameRate property"
short-title: frameRate
slug: Web/API/MediaTrackSettings/frameRate
page-type: web-api-instance-property
browser-compat: api.MediaTrackSettings.frameRate
---
{{APIRef("Media Capture and Streams")}}
The {{domxref("MediaTrackSettings")}} dictionary's
**`frameRate`** property is a double-precision floating-point
number indicating the frame rate, in frames per second, of the
{{domxref("MediaStreamTrack")}} as currently configured. This lets you determine what
value was selected to comply with your specified constraints for this property's value
as described in the {{domxref("MediaTrackConstraints.frameRate")}} property you provided
when calling either {{domxref("MediaDevices.getUserMedia", "getUserMedia()")}} or
{{domxref("MediaStreamTrack.applyConstraints()")}}.
If needed, you can determine whether or not this constraint is supported by checking
the value of {{domxref("MediaTrackSupportedConstraints.frameRate")}} as returned by a
call to {{domxref("MediaDevices.getSupportedConstraints()")}}. However, typically this
is unnecessary since browsers will ignore any constraints they're unfamiliar with.
## Value
A double-precision floating-point number indicating the current configuration of the
track's frame rate, in frames per second.
## Examples
See the [Constraint exerciser](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints#example_constraint_exerciser) example.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Media Capture and Streams API](/en-US/docs/Web/API/Media_Capture_and_Streams_API)
- [Capabilities, constraints, and settings](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints)
- {{domxref("MediaTrackConstraints.frameRate")}}
- {{domxref("MediaTrackSettings")}}
| 0 |
data/mdn-content/files/en-us/web/api/mediatracksettings | data/mdn-content/files/en-us/web/api/mediatracksettings/autogaincontrol/index.md | ---
title: "MediaTrackSettings: autoGainControl property"
short-title: autoGainControl
slug: Web/API/MediaTrackSettings/autoGainControl
page-type: web-api-instance-property
browser-compat: api.MediaTrackSettings.autoGainControl
---
{{APIRef("Media Capture and Streams")}}
The {{domxref("MediaTrackSettings")}} dictionary's
**`autoGainControl`** property is a Boolean value whose value
indicates whether or not automatic gain control (AGC) is enabled on an audio track. This
lets you determine what value was selected to comply with your specified constraints for
this property's value as described in the
{{domxref("MediaTrackConstraints.autoGainControl")}} property you provided when calling
either {{domxref("MediaDevices.getUserMedia", "getUserMedia()")}} or
{{domxref("MediaStreamTrack.applyConstraints()")}}.
Automatic gain control is a feature in which a sound source automatically manages
changes in the volume of its source media to maintain a steady overall volume level.
This feature is typically used on microphones, although it can be provided by other
input sources as well.
If needed, you can determine whether or not this constraint is supported by checking
the value of {{domxref("MediaTrackSupportedConstraints.autoGainControl")}} as returned
by a call to {{domxref("MediaDevices.getSupportedConstraints()")}}. However, typically
this is unnecessary since browsers will ignore any constraints they're unfamiliar with.
## Value
A Boolean value which is `true` if the track has automatic gain control
enabled or `false` if AGC is disabled.
## Examples
See the [Constraint exerciser](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints#example_constraint_exerciser) example.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Media Capture and Streams API](/en-US/docs/Web/API/Media_Capture_and_Streams_API)
- [Capabilities, constraints, and settings](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints)
- {{domxref("MediaTrackConstraints.autoGainControl")}}
- {{domxref("MediaTrackSupportedConstraints")}}
| 0 |
data/mdn-content/files/en-us/web/api/mediatracksettings | data/mdn-content/files/en-us/web/api/mediatracksettings/suppresslocalaudioplayback/index.md | ---
title: "MediaTrackSettings: suppressLocalAudioPlayback property"
short-title: suppressLocalAudioPlayback
slug: Web/API/MediaTrackSettings/suppressLocalAudioPlayback
page-type: web-api-instance-property
status:
- experimental
browser-compat: api.MediaTrackSettings.suppressLocalAudioPlayback
---
{{APIRef("Media Capture and Streams")}}{{SeeCompatTable}}
The {{domxref("MediaTrackSettings")}} dictionary's **`suppressLocalAudioPlayback`** property controls whether the audio playing in a tab will continue to be played out of a user's local speakers when the tab is captured.
For example, in cases where you broadcast a video call to an external AV system in a conference room, you will want the audio to play out of the AV system, and not the local speakers. This way, the audio will be louder and clearer, and also in sync with the conference video.
## Value
The value of `suppressLocalAudioPlayback` is a boolean — `true` enables local audio playback suppression, and `false` disables it.
## Examples
The below function sets up the constraints object specifying the options for the call to {{domxref("MediaDevices.getDisplayMedia", "getDisplayMedia()")}}. It adds the `suppressLocalAudioPlayback` constraint (requesting that captured audio is not played out of the user's local speakers) only if it is known to be supported by the browser. Capturing is then started by calling `getDisplayMedia()` and attaching the returned stream to the video element referenced by the variable `videoElem`.
```js
async function capture() {
const supportedConstraints = navigator.mediaDevices.getSupportedConstraints();
const displayMediaOptions = {
audio: {},
};
if (supportedConstraints.suppressLocalAudioPlayback) {
displayMediaOptions.audio.suppressLocalAudioPlayback = true;
}
try {
videoElem.srcObject =
await navigator.mediaDevices.getDisplayMedia(displayMediaOptions);
} catch (err) {
/* handle the error */
}
}
```
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Screen Capture API](/en-US/docs/Web/API/Screen_Capture_API)
- [Using the screen capture API](/en-US/docs/Web/API/Screen_Capture_API/Using_Screen_Capture)
- [Capabilities, constraints, and settings](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints)
- {{domxref("MediaDevices.getDisplayMedia()")}}
- {{domxref("MediaStreamTrack.getConstraints()")}}
- {{domxref("MediaStreamTrack.applyConstraints()")}}
- {{domxref("MediaStreamTrack.getSettings()")}}
| 0 |
data/mdn-content/files/en-us/web/api/mediatracksettings | data/mdn-content/files/en-us/web/api/mediatracksettings/latency/index.md | ---
title: "MediaTrackSettings: latency property"
short-title: latency
slug: Web/API/MediaTrackSettings/latency
page-type: web-api-instance-property
browser-compat: api.MediaTrackSettings.latency
---
{{APIRef("Media Capture and Streams")}}
The {{domxref("MediaTrackSettings")}} dictionary's
**`latency`** property is a double-precision floating-point
number indicating the estimated latency (specified in seconds) of the
{{domxref("MediaStreamTrack")}} as currently configured. This lets you determine what
value was selected to comply with your specified constraints for this property's value
as described in the {{domxref("MediaTrackConstraints.latency")}} property you provided
when calling either {{domxref("MediaDevices.getUserMedia", "getUserMedia()")}} or
{{domxref("MediaStreamTrack.applyConstraints()")}}.
This is, of course, an approximation, since latency can vary for many reasons including
CPU, transmission, and storage overhead.
If needed, you can determine whether or not this constraint is supported by checking
the value of {{domxref("MediaTrackSupportedConstraints.latency")}} as returned by a call
to {{domxref("MediaDevices.getSupportedConstraints()")}}. However, typically this is
unnecessary since browsers will ignore any constraints they're unfamiliar with.
Because {{Glossary("RTP")}} doesn't include this information, tracks associated with a
[WebRTC](/en-US/docs/Web/API/WebRTC_API) {{domxref("RTCPeerConnection")}}
will never include this property.
## Value
A double-precision floating-point number indicating the estimated latency, in seconds,
of the audio track as currently configured.
## Examples
See the [Constraint exerciser](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints#example_constraint_exerciser) example.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Media Capture and Streams API](/en-US/docs/Web/API/Media_Capture_and_Streams_API)
- [Capabilities, constraints, and settings](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints)
- {{domxref("MediaTrackConstraints.latency")}}
- {{domxref("MediaTrackSettings")}}
| 0 |
data/mdn-content/files/en-us/web/api/mediatracksettings | data/mdn-content/files/en-us/web/api/mediatracksettings/cursor/index.md | ---
title: "MediaTrackSettings: cursor property"
short-title: cursor
slug: Web/API/MediaTrackSettings/cursor
page-type: web-api-instance-property
browser-compat: api.MediaTrackSettings.cursor
---
{{APIRef("Media Capture and Streams")}}
The {{domxref("MediaTrackSettings")}} dictionary's **`cursor`** property indicates whether or not the cursor should be captured as part of the video track included in the {{domxref("MediaStream")}} returned by {{domxref("MediaDevices.getDisplayMedia", "getDisplayMedia()")}}.
## Value
The value of `cursor` comes from the `CursorCaptureConstraint` enumerated string type, and may have one of the following values:
- `always`
- : The mouse should always be visible in the video content of the {{domxref("MediaStream")}}, unless the mouse has moved outside the area of the content.
- `motion`
- : The mouse cursor should always be included in the video if it's moving, and for a short time after it stops moving.
- `never`
- : The mouse cursor is never included in the shared video.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Screen Capture API](/en-US/docs/Web/API/Screen_Capture_API)
- [Using the screen capture API](/en-US/docs/Web/API/Screen_Capture_API/Using_Screen_Capture)
- [Capabilities, constraints, and settings](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints)
- {{domxref("MediaDevices.getDisplayMedia()")}}
- {{domxref("MediaStreamTrack.getConstraints()")}}
- {{domxref("MediaStreamTrack.applyConstraints()")}}
- {{domxref("MediaStreamTrack.getSettings()")}}
| 0 |
data/mdn-content/files/en-us/web/api/mediatracksettings | data/mdn-content/files/en-us/web/api/mediatracksettings/channelcount/index.md | ---
title: "MediaTrackSettings: channelCount property"
short-title: channelCount
slug: Web/API/MediaTrackSettings/channelCount
page-type: web-api-instance-property
browser-compat: api.MediaTrackSettings.channelCount
---
{{APIRef("Media Capture and Streams")}}
The {{domxref("MediaTrackSettings")}} dictionary's
**`channelCount`** property is an integer indicating how many
audio channels the {{domxref("MediaStreamTrack")}} is currently configured to have. This
lets you determine what value was selected to comply with your specified constraints for
this property's value as described in the
{{domxref("MediaTrackConstraints.channelCount")}} property you provided when calling
either {{domxref("MediaDevices.getUserMedia", "getUserMedia()")}} or
{{domxref("MediaStreamTrack.applyConstraints()")}}.
If needed, you can determine whether or not this constraint is supported by checking
the value of {{domxref("MediaTrackSupportedConstraints.channelCount")}} as returned by a
call to {{domxref("MediaDevices.getSupportedConstraints()")}}. However, typically this
is unnecessary since browsers will ignore any constraints they're unfamiliar with.
## Value
An integer value indicating the number of audio channels on the track. A value of 1
indicates monaural sound, 2 means stereo, and so forth.
## Examples
See the [Constraint exerciser](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints#example_constraint_exerciser) example.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Media Capture and Streams API](/en-US/docs/Web/API/Media_Capture_and_Streams_API)
- [Capabilities, constraints, and settings](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints)
- {{domxref("MediaTrackConstraints.channelCount")}}
- {{domxref("MediaTrackSettings")}}
| 0 |
data/mdn-content/files/en-us/web/api/mediatracksettings | data/mdn-content/files/en-us/web/api/mediatracksettings/facingmode/index.md | ---
title: "MediaTrackSettings: facingMode property"
short-title: facingMode
slug: Web/API/MediaTrackSettings/facingMode
page-type: web-api-instance-property
browser-compat: api.MediaTrackSettings.facingMode
---
{{APIRef("Media Capture and Streams")}}
The {{domxref("MediaTrackSettings")}} dictionary's
**`facingMode`** property is a string
indicating the direction in which the camera producing the video track represented by
the {{domxref("MediaStreamTrack")}} is currently facing. This lets you determine what
value was selected to comply with your specified constraints for this property's value
as described in the {{domxref("MediaTrackConstraints.facingMode")}} property you
provided when calling either {{domxref("MediaDevices.getUserMedia", "getUserMedia()")}}
or {{domxref("MediaStreamTrack.applyConstraints()")}}.
If needed, you can determine whether or not this constraint is supported by checking
the value of {{domxref("MediaTrackSupportedConstraints.facingMode")}} as returned by a
call to {{domxref("MediaDevices.getSupportedConstraints()")}}. However, typically this
is unnecessary since browsers will ignore any constraints they're unfamiliar with.
Because {{Glossary("RTP")}} doesn't include this information, tracks associated with a
[WebRTC](/en-US/docs/Web/API/WebRTC_API) {{domxref("RTCPeerConnection")}}
will never include this property.
## Value
A string whose value is one of the strings in
[`VideoFacingModeEnum`](#videofacingmodeenum).
### VideoFacingModeEnum
The following strings are permitted values for the facing mode. These may represent
separate cameras, or they may represent directions in which an adjustable camera can be
pointed.
- `"user"`
- : The video source is facing toward the user; this includes, for example, the
front-facing camera on a smartphone.
- `"environment"`
- : The video source is facing away from the user, thereby viewing their environment.
This is the back camera on a smartphone.
- `"left"`
- : The video source is facing toward the user but to their left, such as a camera aimed
toward the user but over their left shoulder.
- `"right"`
- : The video source is facing toward the user but to their right, such as a camera
aimed toward the user but over their right shoulder.
## Examples
See the [Constraint exerciser](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints#example_constraint_exerciser) example.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Media Capture and Streams API](/en-US/docs/Web/API/Media_Capture_and_Streams_API)
- [Capabilities, constraints, and settings](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints)
- {{domxref("MediaTrackConstraints.facingMode")}}
- {{domxref("MediaTrackSettings")}}
| 0 |
data/mdn-content/files/en-us/web/api/mediatracksettings | data/mdn-content/files/en-us/web/api/mediatracksettings/width/index.md | ---
title: "MediaTrackSettings: width property"
short-title: width
slug: Web/API/MediaTrackSettings/width
page-type: web-api-instance-property
browser-compat: api.MediaTrackSettings.width
---
{{APIRef("Media Capture and Streams")}}
The {{domxref("MediaTrackSettings")}} dictionary's **`width`**
property is an integer indicating the number of pixels wide
{{domxref("MediaStreamTrack")}} is currently configured to be. This lets you determine
what value was selected to comply with your specified constraints for this property's
value as described in the {{domxref("MediaTrackConstraints.width")}} property you
provided when calling either {{domxref("MediaDevices.getUserMedia", "getUserMedia()")}}
or {{domxref("MediaStreamTrack.applyConstraints()")}}.
If needed, you can determine whether or not this constraint is supported by checking
the value of {{domxref("MediaTrackSupportedConstraints.width")}} as returned by a call
to {{domxref("MediaDevices.getSupportedConstraints()")}}. However, typically this is
unnecessary since browsers will ignore any constraints they're unfamiliar with.
## Value
An integer value indicating the width, in pixels, of the video track as currently configured.
## Examples
See the [Constraint exerciser](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints#example_constraint_exerciser) example.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Media Capture and Streams API](/en-US/docs/Web/API/Media_Capture_and_Streams_API)
- [Capabilities, constraints, and settings](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints)
- {{domxref("MediaTrackConstraints.width")}}
- {{domxref("MediaTrackSettings")}}
| 0 |
data/mdn-content/files/en-us/web/api/mediatracksettings | data/mdn-content/files/en-us/web/api/mediatracksettings/height/index.md | ---
title: "MediaTrackSettings: height property"
short-title: height
slug: Web/API/MediaTrackSettings/height
page-type: web-api-instance-property
browser-compat: api.MediaTrackSettings.height
---
{{APIRef("Media Capture and Streams")}}
The {{domxref("MediaTrackSettings")}} dictionary's **`height`**
property is an integer indicating the number of pixels tall
{{domxref("MediaStreamTrack")}} is currently configured to be. This lets you determine
what value was selected to comply with your specified constraints for this property's
value as described in the {{domxref("MediaTrackConstraints.height")}} property you
provided when calling either {{domxref("MediaDevices.getUserMedia", "getUserMedia()")}}
or {{domxref("MediaStreamTrack.applyConstraints()")}}.
If needed, you can determine whether or not this constraint is supported by checking
the value of {{domxref("MediaTrackSupportedConstraints.height")}} as returned by a call
to {{domxref("MediaDevices.getSupportedConstraints()")}}. However, typically this is
unnecessary since browsers will ignore any constraints they're unfamiliar with.
## Value
An integer value indicating the height, in pixels, of the video track as currently
configured.
## Examples
See the [Constraint exerciser](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints#example_constraint_exerciser) example.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Media Capture and Streams API](/en-US/docs/Web/API/Media_Capture_and_Streams_API)
- [Capabilities, constraints, and settings](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints)
- {{domxref("MediaTrackConstraints.height")}}
- {{domxref("MediaTrackSettings")}}
| 0 |
data/mdn-content/files/en-us/web/api/mediatracksettings | data/mdn-content/files/en-us/web/api/mediatracksettings/deviceid/index.md | ---
title: "MediaTrackSettings: deviceId property"
short-title: deviceId
slug: Web/API/MediaTrackSettings/deviceId
page-type: web-api-instance-property
browser-compat: api.MediaTrackSettings.deviceId
---
{{APIRef("Media Capture and Streams")}}
The {{domxref("MediaTrackSettings")}} dictionary's
**`deviceId`** property is a string which
uniquely identifies the source for the corresponding {{domxref("MediaStreamTrack")}} for
the origin corresponding to the browsing session. This lets you determine what value was
selected to comply with your specified constraints for this property's value as
described in the {{domxref("MediaTrackConstraints.deviceId")}} property you provided
when calling either {{domxref("MediaDevices.getUserMedia", "getUserMedia()")}}.
If needed, you can determine whether or not this constraint is supported by checking
the value of {{domxref("MediaTrackSupportedConstraints.deviceId")}} as returned by a
call to {{domxref("MediaDevices.getSupportedConstraints()")}}. However, typically this
is unnecessary since browsers will ignore any constraints they're unfamiliar with.
Because {{Glossary("RTP")}} doesn't include this information, tracks associated with a
[WebRTC](/en-US/docs/Web/API/WebRTC_API) {{domxref("RTCPeerConnection")}}
will never include this property.
## Value
A string whose value is an origin-unique identifier for the track's
source. This ID is valid across multiple browsing sessions for the same origin and is
guaranteed to be different for all other origins, so you can safely use it to request
the same source be used for multiple sessions, for example.
The actual value of the string, however, is determined by the source of the track, and
there is no guarantee what form it will take, although the specification does recommend
it be a GUID.
Since there is a one-to-one pairing of ID with each source, all tracks with the same
source will share the same ID for any given origin, so
{{domxref("MediaStreamTrack.getCapabilities()")}} will always return exactly one value
for `deviceId`. That makes the device ID not useful for any changes to
constraints when calling {{domxref("MediaStreamTrack.applyConstraints()")}}.
> **Note:** An exception to the rule that device IDs are the same across browsing sessions:
> private browsing mode will use a different ID, and will change it each browsing
> session.
## Examples
See the [Constraint exerciser](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints#example_constraint_exerciser) example.
## Specifications
{{Specifications}}
## Browser compatibility
{{Compat}}
## See also
- [Media Capture and Streams API](/en-US/docs/Web/API/Media_Capture_and_Streams_API)
- [Capabilities, constraints, and settings](/en-US/docs/Web/API/Media_Capture_and_Streams_API/Constraints)
- {{domxref("MediaTrackSettings.groupId")}}
- {{domxref("MediaTrackConstraints.deviceId")}}
- {{domxref("MediaTrackSettings")}}
| 0 |
Subsets and Splits